1 /* -----------------------------------------------------------------------------
2 * Copyright (c) 2011 Ozmo Inc
3 * Released under the GNU General Public License Version 2 (GPLv2).
4 * -----------------------------------------------------------------------------
6 #include <linux/module.h>
8 #include <linux/cdev.h>
9 #include <linux/uaccess.h>
10 #include <linux/netdevice.h>
11 #include <linux/poll.h>
12 #include <linux/sched.h>
14 #include "ozprotocol.h"
21 /*------------------------------------------------------------------------------
23 #define OZ_RD_BUF_SZ 256
27 wait_queue_head_t rdq;
29 u8 active_addr[ETH_ALEN];
30 struct oz_pd *active_pd;
33 /* Per PD context for the serial service stored in the PD. */
34 struct oz_serial_ctx {
38 u8 rd_buf[OZ_RD_BUF_SZ];
42 /*------------------------------------------------------------------------------
44 static struct oz_cdev g_cdev;
45 /*------------------------------------------------------------------------------
46 * Context: process and softirq
48 static struct oz_serial_ctx *oz_cdev_claim_ctx(struct oz_pd *pd)
50 struct oz_serial_ctx *ctx;
51 spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
52 ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
54 atomic_inc(&ctx->ref_count);
55 spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
58 /*------------------------------------------------------------------------------
59 * Context: softirq or process
61 static void oz_cdev_release_ctx(struct oz_serial_ctx *ctx)
63 if (atomic_dec_and_test(&ctx->ref_count)) {
64 oz_trace("Dealloc serial context.\n");
68 /*------------------------------------------------------------------------------
71 int oz_cdev_open(struct inode *inode, struct file *filp)
74 oz_trace("oz_cdev_open()\n");
75 oz_trace("major = %d minor = %d\n", imajor(inode), iminor(inode));
76 dev = container_of(inode->i_cdev, struct oz_cdev, cdev);
77 filp->private_data = dev;
80 /*------------------------------------------------------------------------------
83 int oz_cdev_release(struct inode *inode, struct file *filp)
85 oz_trace("oz_cdev_release()\n");
88 /*------------------------------------------------------------------------------
91 ssize_t oz_cdev_read(struct file *filp, char __user *buf, size_t count,
98 struct oz_serial_ctx *ctx = 0;
100 spin_lock_bh(&g_cdev.lock);
101 pd = g_cdev.active_pd;
104 spin_unlock_bh(&g_cdev.lock);
107 ctx = oz_cdev_claim_ctx(pd);
110 n = ctx->rd_in - ctx->rd_out;
116 n = OZ_RD_BUF_SZ - ix;
119 if (copy_to_user(buf, &ctx->rd_buf[ix], n)) {
124 if (ix == OZ_RD_BUF_SZ)
127 if (copy_to_user(&buf[n], ctx->rd_buf, count-n)) {
135 oz_cdev_release_ctx(ctx);
140 /*------------------------------------------------------------------------------
143 ssize_t oz_cdev_write(struct file *filp, const char __user *buf, size_t count,
147 struct oz_elt_buf *eb;
148 struct oz_elt_info *ei = 0;
150 struct oz_app_hdr *app_hdr;
151 struct oz_serial_ctx *ctx;
153 spin_lock_bh(&g_cdev.lock);
154 pd = g_cdev.active_pd;
157 spin_unlock_bh(&g_cdev.lock);
161 ei = oz_elt_info_alloc(eb);
166 elt = (struct oz_elt *)ei->data;
167 app_hdr = (struct oz_app_hdr *)(elt+1);
168 elt->length = sizeof(struct oz_app_hdr) + count;
169 elt->type = OZ_ELT_APP_DATA;
170 ei->app_id = OZ_APPID_SERIAL;
171 ei->length = elt->length + sizeof(struct oz_elt);
172 app_hdr->app_id = OZ_APPID_SERIAL;
173 if (copy_from_user(app_hdr+1, buf, count))
175 spin_lock_bh(&pd->app_lock[OZ_APPID_USB-1]);
176 ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
178 app_hdr->elt_seq_num = ctx->tx_seq_num++;
179 if (ctx->tx_seq_num == 0)
181 spin_lock(&eb->lock);
182 if (oz_queue_elt_info(eb, 0, 0, ei) == 0)
184 spin_unlock(&eb->lock);
186 spin_unlock_bh(&pd->app_lock[OZ_APPID_USB-1]);
190 spin_lock_bh(&eb->lock);
191 oz_elt_info_free(eb, ei);
192 spin_unlock_bh(&eb->lock);
197 /*------------------------------------------------------------------------------
200 static int oz_set_active_pd(u8 *addr)
204 struct oz_pd *old_pd;
205 pd = oz_pd_find(addr);
207 spin_lock_bh(&g_cdev.lock);
208 memcpy(g_cdev.active_addr, addr, ETH_ALEN);
209 old_pd = g_cdev.active_pd;
210 g_cdev.active_pd = pd;
211 spin_unlock_bh(&g_cdev.lock);
215 if (!memcmp(addr, "\0\0\0\0\0\0", sizeof(addr))) {
216 spin_lock_bh(&g_cdev.lock);
217 pd = g_cdev.active_pd;
218 g_cdev.active_pd = 0;
219 memset(g_cdev.active_addr, 0,
220 sizeof(g_cdev.active_addr));
221 spin_unlock_bh(&g_cdev.lock);
230 /*------------------------------------------------------------------------------
233 long oz_cdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
236 if (_IOC_TYPE(cmd) != OZ_IOCTL_MAGIC)
238 if (_IOC_NR(cmd) > OZ_IOCTL_MAX)
240 if (_IOC_DIR(cmd) & _IOC_READ)
241 rc = !access_ok(VERIFY_WRITE, (void __user *)arg,
243 else if (_IOC_DIR(cmd) & _IOC_WRITE)
244 rc = !access_ok(VERIFY_READ, (void __user *)arg,
249 case OZ_IOCTL_GET_PD_LIST: {
250 struct oz_pd_list list;
251 oz_trace("OZ_IOCTL_GET_PD_LIST\n");
252 list.count = oz_get_pd_list(list.addr, OZ_MAX_PDS);
253 if (copy_to_user((void __user *)arg, &list,
258 case OZ_IOCTL_SET_ACTIVE_PD: {
260 oz_trace("OZ_IOCTL_SET_ACTIVE_PD\n");
261 if (copy_from_user(addr, (void __user *)arg, ETH_ALEN))
263 rc = oz_set_active_pd(addr);
266 case OZ_IOCTL_GET_ACTIVE_PD: {
268 oz_trace("OZ_IOCTL_GET_ACTIVE_PD\n");
269 spin_lock_bh(&g_cdev.lock);
270 memcpy(addr, g_cdev.active_addr, ETH_ALEN);
271 spin_unlock_bh(&g_cdev.lock);
272 if (copy_to_user((void __user *)arg, addr, ETH_ALEN))
276 case OZ_IOCTL_ADD_BINDING:
277 case OZ_IOCTL_REMOVE_BINDING: {
278 struct oz_binding_info b;
279 if (copy_from_user(&b, (void __user *)arg,
280 sizeof(struct oz_binding_info))) {
283 /* Make sure name is null terminated. */
284 b.name[OZ_MAX_BINDING_LEN-1] = 0;
285 if (cmd == OZ_IOCTL_ADD_BINDING)
286 oz_binding_add(b.name);
288 oz_binding_remove(b.name);
294 /*------------------------------------------------------------------------------
297 unsigned int oz_cdev_poll(struct file *filp, poll_table *wait)
299 unsigned int ret = 0;
300 struct oz_cdev *dev = filp->private_data;
301 oz_trace("Poll called wait = %p\n", wait);
302 spin_lock_bh(&dev->lock);
303 if (dev->active_pd) {
304 struct oz_serial_ctx *ctx = oz_cdev_claim_ctx(dev->active_pd);
306 if (ctx->rd_in != ctx->rd_out)
307 ret |= POLLIN | POLLRDNORM;
308 oz_cdev_release_ctx(ctx);
311 spin_unlock_bh(&dev->lock);
313 poll_wait(filp, &dev->rdq, wait);
316 /*------------------------------------------------------------------------------
318 const struct file_operations oz_fops = {
319 .owner = THIS_MODULE,
320 .open = oz_cdev_open,
321 .release = oz_cdev_release,
322 .read = oz_cdev_read,
323 .write = oz_cdev_write,
324 .unlocked_ioctl = oz_cdev_ioctl,
327 /*------------------------------------------------------------------------------
330 int oz_cdev_register(void)
333 memset(&g_cdev, 0, sizeof(g_cdev));
334 err = alloc_chrdev_region(&g_cdev.devnum, 0, 1, "ozwpan");
337 oz_trace("Alloc dev number %d:%d\n", MAJOR(g_cdev.devnum),
338 MINOR(g_cdev.devnum));
339 cdev_init(&g_cdev.cdev, &oz_fops);
340 g_cdev.cdev.owner = THIS_MODULE;
341 g_cdev.cdev.ops = &oz_fops;
342 spin_lock_init(&g_cdev.lock);
343 init_waitqueue_head(&g_cdev.rdq);
344 err = cdev_add(&g_cdev.cdev, g_cdev.devnum, 1);
347 /*------------------------------------------------------------------------------
350 int oz_cdev_deregister(void)
352 cdev_del(&g_cdev.cdev);
353 unregister_chrdev_region(g_cdev.devnum, 1);
356 /*------------------------------------------------------------------------------
359 int oz_cdev_init(void)
361 oz_event_log(OZ_EVT_SERVICE, 1, OZ_APPID_SERIAL, 0, 0);
362 oz_app_enable(OZ_APPID_SERIAL, 1);
365 /*------------------------------------------------------------------------------
368 void oz_cdev_term(void)
370 oz_event_log(OZ_EVT_SERVICE, 2, OZ_APPID_SERIAL, 0, 0);
371 oz_app_enable(OZ_APPID_SERIAL, 0);
373 /*------------------------------------------------------------------------------
374 * Context: softirq-serialized
376 int oz_cdev_start(struct oz_pd *pd, int resume)
378 struct oz_serial_ctx *ctx;
379 struct oz_serial_ctx *old_ctx = 0;
380 oz_event_log(OZ_EVT_SERVICE, 3, OZ_APPID_SERIAL, 0, resume);
382 oz_trace("Serial service resumed.\n");
385 ctx = kzalloc(sizeof(struct oz_serial_ctx), GFP_ATOMIC);
388 atomic_set(&ctx->ref_count, 1);
390 spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
391 old_ctx = pd->app_ctx[OZ_APPID_SERIAL-1];
393 spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
396 pd->app_ctx[OZ_APPID_SERIAL-1] = ctx;
397 spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
399 spin_lock(&g_cdev.lock);
400 if ((g_cdev.active_pd == 0) &&
401 (memcmp(pd->mac_addr, g_cdev.active_addr, ETH_ALEN) == 0)) {
403 g_cdev.active_pd = pd;
404 oz_trace("Active PD arrived.\n");
406 spin_unlock(&g_cdev.lock);
407 oz_trace("Serial service started.\n");
410 /*------------------------------------------------------------------------------
411 * Context: softirq or process
413 void oz_cdev_stop(struct oz_pd *pd, int pause)
415 struct oz_serial_ctx *ctx;
416 oz_event_log(OZ_EVT_SERVICE, 4, OZ_APPID_SERIAL, 0, pause);
418 oz_trace("Serial service paused.\n");
421 spin_lock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
422 ctx = (struct oz_serial_ctx *)pd->app_ctx[OZ_APPID_SERIAL-1];
423 pd->app_ctx[OZ_APPID_SERIAL-1] = 0;
424 spin_unlock_bh(&pd->app_lock[OZ_APPID_SERIAL-1]);
426 oz_cdev_release_ctx(ctx);
427 spin_lock(&g_cdev.lock);
428 if (pd == g_cdev.active_pd)
429 g_cdev.active_pd = 0;
432 spin_unlock(&g_cdev.lock);
435 oz_trace("Active PD departed.\n");
437 oz_trace("Serial service stopped.\n");
439 /*------------------------------------------------------------------------------
440 * Context: softirq-serialized
442 void oz_cdev_rx(struct oz_pd *pd, struct oz_elt *elt)
444 struct oz_serial_ctx *ctx;
445 struct oz_app_hdr *app_hdr;
452 ctx = oz_cdev_claim_ctx(pd);
454 oz_trace("Cannot claim serial context.\n");
458 app_hdr = (struct oz_app_hdr *)(elt+1);
459 /* If sequence number is non-zero then check it is not a duplicate.
461 if (app_hdr->elt_seq_num != 0) {
462 if (((ctx->rx_seq_num - app_hdr->elt_seq_num) & 0x80) == 0) {
463 /* Reject duplicate element. */
464 oz_trace("Duplicate element:%02x %02x\n",
465 app_hdr->elt_seq_num, ctx->rx_seq_num);
469 ctx->rx_seq_num = app_hdr->elt_seq_num;
470 len = elt->length - sizeof(struct oz_app_hdr);
471 data = ((u8 *)(elt+1)) + sizeof(struct oz_app_hdr);
474 space = ctx->rd_out - ctx->rd_in - 1;
476 space += OZ_RD_BUF_SZ;
478 oz_trace("Not enough space:%d %d\n", len, space);
482 copy_sz = OZ_RD_BUF_SZ - ix;
485 memcpy(&ctx->rd_buf[ix], data, copy_sz);
488 if (ix == OZ_RD_BUF_SZ)
491 memcpy(ctx->rd_buf, data+copy_sz, len);
495 wake_up(&g_cdev.rdq);
497 oz_cdev_release_ctx(ctx);
499 /*------------------------------------------------------------------------------
502 void oz_cdev_heartbeat(struct oz_pd *pd)