lunaix-os/hal/char/serial.c

   1 #include <lunaix/device.h>
   2 #include <lunaix/mm/valloc.h>
   3 #include <lunaix/spike.h>
   4 #include <lunaix/owloysius.h>
   5 #include <lunaix/status.h>
   6 #include <lunaix/syslog.h>
   7
   8 #include <asm/pagetable.h>
   9
  10 #include <hal/serial.h>
  11 #include <hal/term.h>
  12
  13 LOG_MODULE("serial")
  14
  15 #define lock_sdev(sdev) device_lock((sdev)->dev)
  16 #define unlock_sdev(sdev) device_unlock((sdev)->dev)
  17 #define unlock_and_wait(sdev, wq)                                              \
  18     ({                                                                         \
  19         unlock_sdev(sdev);                                                     \
  20         pwait(&(sdev)->wq);                                                    \
  21         lock_sdev(sdev);                                                       \
  22     })
  23
  24 static DEFINE_LLIST(serial_devs);
  25 static int serial_idx = 0;
  26
  27 static struct device_cat* serial_cat;
  28
  29 #define serial_device(dev) ((struct serial_dev*)(dev)->underlay)
  30
  31 int
  32 serial_accept_one(struct serial_dev* sdev, u8_t val)
  33 {
  34     return !!rbuffer_put(&sdev->rxbuf, val);
  35 }
  36
  37 int
  38 serial_accept_buffer(struct serial_dev* sdev, void* val, size_t len)
  39 {
  40     return !!rbuffer_puts(&sdev->rxbuf, val, len);
  41 }
  42
  43 void
  44 serial_end_recv(struct serial_dev* sdev)
  45 {
  46     mark_device_done_read(sdev->dev);
  47
  48     pwake_one(&sdev->wq_rxdone);
  49
  50     struct termport_capability* tpcap;
  51     tpcap = get_capability(sdev->tp_cap, typeof(*tpcap));
  52     term_notify_data_avaliable(tpcap);
  53 }
  54
  55 void
  56 serial_end_xmit(struct serial_dev* sdev, size_t len)
  57 {
  58     mark_device_done_write(sdev->dev);
  59
  60     sdev->wr_len = len;
  61     pwake_one(&sdev->wq_txdone);
  62 }
  63
  64 int
  65 serial_readone_nowait(struct serial_dev* sdev, u8_t* val)
  66 {
  67     lock_sdev(sdev);
  68
  69     int rd_len = rbuffer_get(&sdev->rxbuf, (char*)val);
  70
  71     unlock_sdev(sdev);
  72
  73     return rd_len;
  74 }
  75
  76 void
  77 serial_readone(struct serial_dev* sdev, u8_t* val)
  78 {
  79     lock_sdev(sdev);
  80
  81     mark_device_doing_read(sdev->dev);
  82
  83     while (!rbuffer_get(&sdev->rxbuf, (char*)val)) {
  84         unlock_and_wait(sdev, wq_rxdone);
  85     }
  86
  87     unlock_sdev(sdev);
  88 }
  89
  90 size_t
  91 serial_readbuf(struct serial_dev* sdev, u8_t* buf, size_t len)
  92 {
  93     lock_sdev(sdev);
  94
  95     mark_device_doing_read(sdev->dev);
  96
  97     size_t rdlen;
  98     while (!(rdlen = rbuffer_gets(&sdev->rxbuf, (char*)buf, len))) {
  99         unlock_and_wait(sdev, wq_rxdone);
 100     }
 101
 102     unlock_sdev(sdev);
 103
 104     return rdlen;
 105 }
 106
 107 int
 108 serial_readbuf_nowait(struct serial_dev* sdev, u8_t* buf, size_t len)
 109 {
 110     lock_sdev(sdev);
 111
 112     mark_device_doing_read(sdev->dev);
 113
 114     int rdlen = rbuffer_gets(&sdev->rxbuf, (char*)buf, len);
 115
 116     unlock_sdev(sdev);
 117
 118     return rdlen;
 119 }
 120
 121 int
 122 serial_writebuf(struct serial_dev* sdev, u8_t* buf, size_t len)
 123 {
 124     lock_sdev(sdev);
 125
 126     mark_device_doing_write(sdev->dev);
 127
 128     if (sdev->write(sdev, buf, len) == RXTX_DONE) {
 129         goto done;
 130     }
 131
 132     unlock_and_wait(sdev, wq_txdone);
 133
 134 done:
 135     int rdlen = sdev->wr_len;
 136     unlock_sdev(sdev);
 137
 138     return rdlen;
 139 }
 140
 141 int
 142 serial_writebuf_nowait(struct serial_dev* sdev, u8_t* buf, size_t len)
 143 {
 144     lock_sdev(sdev);
 145
 146     mark_device_doing_write(sdev->dev);
 147
 148     sdev->write(sdev, buf, len);
 149     int rdlen = sdev->wr_len;
 150
 151     unlock_sdev(sdev);
 152
 153     return rdlen;
 154 }
 155
 156 static int
 157 __serial_read(struct device* dev, void* buf, off_t fpos, size_t len)
 158 {
 159     return serial_readbuf(serial_device(dev), (u8_t*)buf, len);
 160 }
 161
 162 static int
 163 __serial_read_async(struct device* dev, void* buf, off_t fpos, size_t len)
 164 {
 165     return serial_readbuf_nowait(
 166         serial_device(dev), (u8_t*)buf, len);
 167 }
 168
 169 static int
 170 __serial_read_page(struct device* dev, void* buf, off_t fpos)
 171 {
 172     return serial_readbuf(serial_device(dev), (u8_t*)buf, PAGE_SIZE);
 173 }
 174
 175 static int
 176 __serial_write(struct device* dev, void* buf, off_t fpos, size_t len)
 177 {
 178     return serial_writebuf(serial_device(dev), (u8_t*)buf, len);
 179 }
 180
 181 static int
 182 __serial_write_async(struct device* dev, void* buf, off_t fpos, size_t len)
 183 {
 184     return serial_writebuf_nowait(
 185         serial_device(dev), (u8_t*)buf, len);
 186 }
 187
 188 static int
 189 __serial_write_page(struct device* dev, void* buf, off_t fpos)
 190 {
 191     return serial_writebuf(serial_device(dev), (u8_t*)buf, PAGE_SIZE);
 192 }
 193
 194 static int
 195 __serial_exec_command(struct device* dev, u32_t req, va_list args)
 196 {
 197     struct serial_dev* sdev = serial_device(dev);
 198
 199     if (!sdev->exec_cmd) {
 200         return ENOTSUP;
 201     }
 202
 203     return sdev->exec_cmd(sdev, req, args);
 204 }
 205
 206 static int
 207 __serial_poll_event(struct device* dev)
 208 {
 209     struct serial_dev* sdev = serial_device(dev);
 210
 211     return sdev->dev->poll_evflags;
 212 }
 213
 214 static void sdev_execmd(struct serial_dev* sdev, u32_t req, ...)
 215 {
 216     va_list args;
 217     va_start(args, req);
 218
 219     sdev->exec_cmd(sdev, req, args);
 220
 221     va_end(args);
 222 }
 223
 224 static void
 225 __serial_set_speed(struct device* dev, speed_t speed)
 226 {
 227     struct serial_dev* sdev = serial_device(dev);
 228     lock_sdev(sdev);
 229
 230     sdev_execmd(sdev, SERIO_SETBRDRATE, speed);
 231
 232     unlock_sdev(sdev);
 233 }
 234
 235 static void
 236 __serial_set_baseclk(struct device* dev, unsigned int base)
 237 {
 238     struct serial_dev* sdev = serial_device(dev);
 239     lock_sdev(sdev);
 240
 241     sdev_execmd(sdev, SERIO_SETBRDBASE, base);
 242
 243     unlock_sdev(sdev);
 244 }
 245
 246 static void
 247 __serial_set_cntrl_mode(struct device* dev, tcflag_t cflag)
 248 {
 249     struct serial_dev* sdev = serial_device(dev);
 250     lock_sdev(sdev);
 251
 252     sdev_execmd(sdev, SERIO_SETCNTRLMODE, cflag);
 253
 254     unlock_sdev(sdev);
 255 }
 256
 257 #define RXBUF_SIZE 512
 258
 259 static struct termport_cap_ops tpcap_ops = {
 260     .set_cntrl_mode = __serial_set_cntrl_mode,
 261     .set_clkbase = __serial_set_baseclk,
 262     .set_speed = __serial_set_speed
 263 };
 264
 265 struct serial_dev*
 266 serial_create(struct devclass* class, char* if_ident)
 267 {
 268     struct serial_dev* sdev = vzalloc(sizeof(struct serial_dev));
 269     struct device* dev = device_allocseq(dev_meta(serial_cat), sdev);
 270     dev->ops.read = __serial_read;
 271     dev->ops.read_page = __serial_read_page;
 272     dev->ops.read_async = __serial_read_async;
 273     dev->ops.write_async = __serial_write_async;
 274     dev->ops.write = __serial_write;
 275     dev->ops.write_page = __serial_write_page;
 276     dev->ops.exec_cmd = __serial_exec_command;
 277     dev->ops.poll = __serial_poll_event;
 278
 279     sdev->dev = dev;
 280     dev->underlay = sdev;
 281
 282     struct termport_capability* tp_cap =
 283         new_capability(TERMPORT_CAP, struct termport_capability);
 284
 285     term_cap_set_operations(tp_cap, &tpcap_ops);
 286     sdev->tp_cap = cap_meta(tp_cap);
 287
 288     waitq_init(&sdev->wq_rxdone);
 289     waitq_init(&sdev->wq_txdone);
 290     rbuffer_init(&sdev->rxbuf, valloc(RXBUF_SIZE), RXBUF_SIZE);
 291     llist_append(&serial_devs, &sdev->sdev_list);
 292
 293     device_grant_capability(dev, cap_meta(tp_cap));
 294
 295     register_device(dev, class, "%s%d", if_ident, class->variant);
 296
 297     term_create(dev, if_ident);
 298
 299     INFO("interface: %s, %xh:%xh.%d", dev->name_val,
 300             class->fn_grp, class->device, class->variant);
 301
 302     class->variant++;
 303     return sdev;
 304 }
 305
 306 struct serial_dev*
 307 serial_get_avilable()
 308 {
 309     struct serial_dev *pos, *n;
 310     llist_for_each(pos, n, &serial_devs, sdev_list)
 311     {
 312         if (!device_locked(pos->dev)) {
 313             return pos;
 314         }
 315     }
 316
 317     return NULL;
 318 }
 319
 320 static void
 321 init_serial_dev()
 322 {
 323     serial_cat = device_addcat(NULL, "serial");
 324
 325     assert(serial_cat);
 326 }
 327 owloysius_fetch_init(init_serial_dev, on_earlyboot)