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 <sys/mm/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
  51 void
  52 serial_end_xmit(struct serial_dev* sdev, size_t len)
  53 {
  54     mark_device_done_write(sdev->dev);
  55
  56     sdev->wr_len = len;
  57     pwake_one(&sdev->wq_txdone);
  58 }
  59
  60 int
  61 serial_readone_nowait(struct serial_dev* sdev, u8_t* val)
  62 {
  63     lock_sdev(sdev);
  64
  65     int rd_len = rbuffer_get(&sdev->rxbuf, (char*)val);
  66
  67     unlock_sdev(sdev);
  68
  69     return rd_len;
  70 }
  71
  72 void
  73 serial_readone(struct serial_dev* sdev, u8_t* val)
  74 {
  75     lock_sdev(sdev);
  76
  77     mark_device_doing_read(sdev->dev);
  78
  79     while (!rbuffer_get(&sdev->rxbuf, (char*)val)) {
  80         unlock_and_wait(sdev, wq_rxdone);
  81     }
  82
  83     unlock_sdev(sdev);
  84 }
  85
  86 size_t
  87 serial_readbuf(struct serial_dev* sdev, u8_t* buf, size_t len)
  88 {
  89     lock_sdev(sdev);
  90
  91     mark_device_doing_read(sdev->dev);
  92
  93     size_t rdlen;
  94     while (!(rdlen = rbuffer_gets(&sdev->rxbuf, (char*)buf, len))) {
  95         unlock_and_wait(sdev, wq_rxdone);
  96     }
  97
  98     unlock_sdev(sdev);
  99
 100     return rdlen;
 101 }
 102
 103 int
 104 serial_readbuf_nowait(struct serial_dev* sdev, u8_t* buf, size_t len)
 105 {
 106     lock_sdev(sdev);
 107
 108     mark_device_doing_read(sdev->dev);
 109
 110     int rdlen = rbuffer_gets(&sdev->rxbuf, (char*)buf, len);
 111
 112     unlock_sdev(sdev);
 113
 114     return rdlen;
 115 }
 116
 117 int
 118 serial_writebuf(struct serial_dev* sdev, u8_t* buf, size_t len)
 119 {
 120     lock_sdev(sdev);
 121
 122     mark_device_doing_write(sdev->dev);
 123
 124     if (sdev->write(sdev, buf, len) == RXTX_DONE) {
 125         goto done;
 126     }
 127
 128     unlock_and_wait(sdev, wq_txdone);
 129
 130 done:
 131     int rdlen = sdev->wr_len;
 132     unlock_sdev(sdev);
 133
 134     return rdlen;
 135 }
 136
 137 int
 138 serial_writebuf_nowait(struct serial_dev* sdev, u8_t* buf, size_t len)
 139 {
 140     lock_sdev(sdev);
 141
 142     mark_device_doing_write(sdev->dev);
 143
 144     sdev->write(sdev, buf, len);
 145     int rdlen = sdev->wr_len;
 146
 147     unlock_sdev(sdev);
 148
 149     return rdlen;
 150 }
 151
 152 static int
 153 __serial_read(struct device* dev, void* buf, off_t fpos, size_t len)
 154 {
 155     return serial_readbuf(serial_device(dev), (u8_t*)buf, len);
 156 }
 157
 158 static int
 159 __serial_read_async(struct device* dev, void* buf, off_t fpos, size_t len)
 160 {
 161     return serial_readbuf_nowait(
 162         serial_device(dev), (u8_t*)buf, len);
 163 }
 164
 165 static int
 166 __serial_read_page(struct device* dev, void* buf, off_t fpos)
 167 {
 168     return serial_readbuf(serial_device(dev), (u8_t*)buf, PAGE_SIZE);
 169 }
 170
 171 static int
 172 __serial_write(struct device* dev, void* buf, off_t fpos, size_t len)
 173 {
 174     return serial_writebuf(serial_device(dev), (u8_t*)buf, len);
 175 }
 176
 177 static int
 178 __serial_write_async(struct device* dev, void* buf, off_t fpos, size_t len)
 179 {
 180     return serial_writebuf_nowait(
 181         serial_device(dev), (u8_t*)buf, len);
 182 }
 183
 184 static int
 185 __serial_write_page(struct device* dev, void* buf, off_t fpos)
 186 {
 187     return serial_writebuf(serial_device(dev), (u8_t*)buf, PAGE_SIZE);
 188 }
 189
 190 static int
 191 __serial_exec_command(struct device* dev, u32_t req, va_list args)
 192 {
 193     struct serial_dev* sdev = serial_device(dev);
 194
 195     if (!sdev->exec_cmd) {
 196         return ENOTSUP;
 197     }
 198
 199     return sdev->exec_cmd(sdev, req, args);
 200 }
 201
 202 static int
 203 __serial_poll_event(struct device* dev)
 204 {
 205     struct serial_dev* sdev = serial_device(dev);
 206
 207     return sdev->dev->poll_evflags;
 208 }
 209
 210 static void sdev_execmd(struct serial_dev* sdev, u32_t req, ...)
 211 {
 212     va_list args;
 213     va_start(args, req);
 214
 215     sdev->exec_cmd(sdev, req, args);
 216
 217     va_end(args);
 218 }
 219
 220 static void
 221 __serial_set_speed(struct device* dev, speed_t speed)
 222 {
 223     struct serial_dev* sdev = serial_device(dev);
 224     lock_sdev(sdev);
 225
 226     sdev_execmd(sdev, SERIO_SETBRDIV, speed);
 227
 228     unlock_sdev(sdev);
 229 }
 230
 231 static void
 232 __serial_set_cntrl_mode(struct device* dev, tcflag_t cflag)
 233 {
 234     struct serial_dev* sdev = serial_device(dev);
 235     lock_sdev(sdev);
 236
 237     sdev_execmd(sdev, SERIO_SETCNTRLMODE, cflag);
 238
 239     unlock_sdev(sdev);
 240 }
 241
 242 #define RXBUF_SIZE 512
 243
 244 struct serial_dev*
 245 serial_create(struct devclass* class, char* if_ident)
 246 {
 247     struct serial_dev* sdev = valloc(sizeof(struct serial_dev));
 248     struct device* dev = device_allocseq(dev_meta(serial_cat), sdev);
 249     dev->ops.read = __serial_read;
 250     dev->ops.read_page = __serial_read_page;
 251     dev->ops.read_async = __serial_read_async;
 252     dev->ops.write_async = __serial_write_async;
 253     dev->ops.write = __serial_write;
 254     dev->ops.write_page = __serial_write_page;
 255     dev->ops.exec_cmd = __serial_exec_command;
 256     dev->ops.poll = __serial_poll_event;
 257
 258     sdev->dev = dev;
 259     dev->underlay = sdev;
 260
 261     struct termport_capability* tp_cap =
 262         new_capability(TERMPORT_CAP, struct termport_capability);
 263     tp_cap->set_speed = __serial_set_speed;
 264     tp_cap->set_cntrl_mode = __serial_set_cntrl_mode;
 265
 266     waitq_init(&sdev->wq_rxdone);
 267     waitq_init(&sdev->wq_txdone);
 268     rbuffer_init(&sdev->rxbuf, valloc(RXBUF_SIZE), RXBUF_SIZE);
 269     llist_append(&serial_devs, &sdev->sdev_list);
 270
 271     device_grant_capability(dev, cap_meta(tp_cap));
 272
 273     register_device(dev, class, "%s%d", if_ident, class->variant);
 274
 275     term_create(dev, if_ident);
 276
 277     INFO("interface: %s, %xh:%xh.%d", dev->name_val,
 278             class->fn_grp, class->device, class->variant);
 279
 280     class->variant++;
 281     return sdev;
 282 }
 283
 284 struct serial_dev*
 285 serial_get_avilable()
 286 {
 287     struct serial_dev *pos, *n;
 288     llist_for_each(pos, n, &serial_devs, sdev_list)
 289     {
 290         if (!device_locked(pos->dev)) {
 291             return pos;
 292         }
 293     }
 294
 295     return NULL;
 296 }
 297
 298 static void
 299 init_serial_dev()
 300 {
 301     serial_cat = device_addcat(NULL, "serial");
 302
 303     assert(serial_cat);
 304 }
 305 owloysius_fetch_init(init_serial_dev, on_earlyboot)