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/etherdevice.h>
12 #include <linux/poll.h>
13 #include <linux/sched.h>
15 #include "ozprotocol.h"
23 /*------------------------------------------------------------------------------
25 #define OZ_RD_BUF_SZ 256
29 wait_queue_head_t rdq
;
31 u8 active_addr
[ETH_ALEN
];
32 struct oz_pd
*active_pd
;
35 /* Per PD context for the serial service stored in the PD. */
36 struct oz_serial_ctx
{
40 u8 rd_buf
[OZ_RD_BUF_SZ
];
44 /*------------------------------------------------------------------------------
46 static struct oz_cdev g_cdev
;
47 static struct class *g_oz_class
;
48 /*------------------------------------------------------------------------------
49 * Context: process and softirq
51 static struct oz_serial_ctx
*oz_cdev_claim_ctx(struct oz_pd
*pd
)
53 struct oz_serial_ctx
*ctx
;
54 spin_lock_bh(&pd
->app_lock
[OZ_APPID_SERIAL
-1]);
55 ctx
= (struct oz_serial_ctx
*)pd
->app_ctx
[OZ_APPID_SERIAL
-1];
57 atomic_inc(&ctx
->ref_count
);
58 spin_unlock_bh(&pd
->app_lock
[OZ_APPID_SERIAL
-1]);
61 /*------------------------------------------------------------------------------
62 * Context: softirq or process
64 static void oz_cdev_release_ctx(struct oz_serial_ctx
*ctx
)
66 if (atomic_dec_and_test(&ctx
->ref_count
)) {
67 oz_trace("Dealloc serial context.\n");
71 /*------------------------------------------------------------------------------
74 static int oz_cdev_open(struct inode
*inode
, struct file
*filp
)
77 oz_trace("oz_cdev_open()\n");
78 oz_trace("major = %d minor = %d\n", imajor(inode
), iminor(inode
));
79 dev
= container_of(inode
->i_cdev
, struct oz_cdev
, cdev
);
80 filp
->private_data
= dev
;
83 /*------------------------------------------------------------------------------
86 static int oz_cdev_release(struct inode
*inode
, struct file
*filp
)
88 oz_trace("oz_cdev_release()\n");
91 /*------------------------------------------------------------------------------
94 static ssize_t
oz_cdev_read(struct file
*filp
, char __user
*buf
, size_t count
,
101 struct oz_serial_ctx
*ctx
;
103 spin_lock_bh(&g_cdev
.lock
);
104 pd
= g_cdev
.active_pd
;
107 spin_unlock_bh(&g_cdev
.lock
);
110 ctx
= oz_cdev_claim_ctx(pd
);
113 n
= ctx
->rd_in
- ctx
->rd_out
;
119 n
= OZ_RD_BUF_SZ
- ix
;
122 if (copy_to_user(buf
, &ctx
->rd_buf
[ix
], n
)) {
127 if (ix
== OZ_RD_BUF_SZ
)
130 if (copy_to_user(&buf
[n
], ctx
->rd_buf
, count
-n
)) {
138 oz_cdev_release_ctx(ctx
);
143 /*------------------------------------------------------------------------------
146 static ssize_t
oz_cdev_write(struct file
*filp
, const char __user
*buf
,
147 size_t count
, loff_t
*fpos
)
150 struct oz_elt_buf
*eb
;
151 struct oz_elt_info
*ei
;
153 struct oz_app_hdr
*app_hdr
;
154 struct oz_serial_ctx
*ctx
;
156 spin_lock_bh(&g_cdev
.lock
);
157 pd
= g_cdev
.active_pd
;
160 spin_unlock_bh(&g_cdev
.lock
);
164 ei
= oz_elt_info_alloc(eb
);
169 elt
= (struct oz_elt
*)ei
->data
;
170 app_hdr
= (struct oz_app_hdr
*)(elt
+1);
171 elt
->length
= sizeof(struct oz_app_hdr
) + count
;
172 elt
->type
= OZ_ELT_APP_DATA
;
173 ei
->app_id
= OZ_APPID_SERIAL
;
174 ei
->length
= elt
->length
+ sizeof(struct oz_elt
);
175 app_hdr
->app_id
= OZ_APPID_SERIAL
;
176 if (copy_from_user(app_hdr
+1, buf
, count
))
178 spin_lock_bh(&pd
->app_lock
[OZ_APPID_USB
-1]);
179 ctx
= (struct oz_serial_ctx
*)pd
->app_ctx
[OZ_APPID_SERIAL
-1];
181 app_hdr
->elt_seq_num
= ctx
->tx_seq_num
++;
182 if (ctx
->tx_seq_num
== 0)
184 spin_lock(&eb
->lock
);
185 if (oz_queue_elt_info(eb
, 0, 0, ei
) == 0)
187 spin_unlock(&eb
->lock
);
189 spin_unlock_bh(&pd
->app_lock
[OZ_APPID_USB
-1]);
193 spin_lock_bh(&eb
->lock
);
194 oz_elt_info_free(eb
, ei
);
195 spin_unlock_bh(&eb
->lock
);
200 /*------------------------------------------------------------------------------
203 static int oz_set_active_pd(const u8
*addr
)
207 struct oz_pd
*old_pd
;
208 pd
= oz_pd_find(addr
);
210 spin_lock_bh(&g_cdev
.lock
);
211 memcpy(g_cdev
.active_addr
, addr
, ETH_ALEN
);
212 old_pd
= g_cdev
.active_pd
;
213 g_cdev
.active_pd
= pd
;
214 spin_unlock_bh(&g_cdev
.lock
);
218 if (is_zero_ether_addr(addr
)) {
219 spin_lock_bh(&g_cdev
.lock
);
220 pd
= g_cdev
.active_pd
;
221 g_cdev
.active_pd
= NULL
;
222 memset(g_cdev
.active_addr
, 0,
223 sizeof(g_cdev
.active_addr
));
224 spin_unlock_bh(&g_cdev
.lock
);
233 /*------------------------------------------------------------------------------
236 static long oz_cdev_ioctl(struct file
*filp
, unsigned int cmd
,
240 if (_IOC_TYPE(cmd
) != OZ_IOCTL_MAGIC
)
242 if (_IOC_NR(cmd
) > OZ_IOCTL_MAX
)
244 if (_IOC_DIR(cmd
) & _IOC_READ
)
245 rc
= !access_ok(VERIFY_WRITE
, (void __user
*)arg
,
247 else if (_IOC_DIR(cmd
) & _IOC_WRITE
)
248 rc
= !access_ok(VERIFY_READ
, (void __user
*)arg
,
253 case OZ_IOCTL_GET_PD_LIST
: {
254 struct oz_pd_list list
;
255 oz_trace("OZ_IOCTL_GET_PD_LIST\n");
256 memset(&list
, 0, sizeof(list
));
257 list
.count
= oz_get_pd_list(list
.addr
, OZ_MAX_PDS
);
258 if (copy_to_user((void __user
*)arg
, &list
,
263 case OZ_IOCTL_SET_ACTIVE_PD
: {
265 oz_trace("OZ_IOCTL_SET_ACTIVE_PD\n");
266 if (copy_from_user(addr
, (void __user
*)arg
, ETH_ALEN
))
268 rc
= oz_set_active_pd(addr
);
271 case OZ_IOCTL_GET_ACTIVE_PD
: {
273 oz_trace("OZ_IOCTL_GET_ACTIVE_PD\n");
274 spin_lock_bh(&g_cdev
.lock
);
275 memcpy(addr
, g_cdev
.active_addr
, ETH_ALEN
);
276 spin_unlock_bh(&g_cdev
.lock
);
277 if (copy_to_user((void __user
*)arg
, addr
, ETH_ALEN
))
281 case OZ_IOCTL_ADD_BINDING
:
282 case OZ_IOCTL_REMOVE_BINDING
: {
283 struct oz_binding_info b
;
284 if (copy_from_user(&b
, (void __user
*)arg
,
285 sizeof(struct oz_binding_info
))) {
288 /* Make sure name is null terminated. */
289 b
.name
[OZ_MAX_BINDING_LEN
-1] = 0;
290 if (cmd
== OZ_IOCTL_ADD_BINDING
)
291 oz_binding_add(b
.name
);
293 oz_binding_remove(b
.name
);
299 /*------------------------------------------------------------------------------
302 static unsigned int oz_cdev_poll(struct file
*filp
, poll_table
*wait
)
304 unsigned int ret
= 0;
305 struct oz_cdev
*dev
= filp
->private_data
;
306 oz_trace("Poll called wait = %p\n", wait
);
307 spin_lock_bh(&dev
->lock
);
308 if (dev
->active_pd
) {
309 struct oz_serial_ctx
*ctx
= oz_cdev_claim_ctx(dev
->active_pd
);
311 if (ctx
->rd_in
!= ctx
->rd_out
)
312 ret
|= POLLIN
| POLLRDNORM
;
313 oz_cdev_release_ctx(ctx
);
316 spin_unlock_bh(&dev
->lock
);
318 poll_wait(filp
, &dev
->rdq
, wait
);
321 /*------------------------------------------------------------------------------
323 static const struct file_operations oz_fops
= {
324 .owner
= THIS_MODULE
,
325 .open
= oz_cdev_open
,
326 .release
= oz_cdev_release
,
327 .read
= oz_cdev_read
,
328 .write
= oz_cdev_write
,
329 .unlocked_ioctl
= oz_cdev_ioctl
,
332 /*------------------------------------------------------------------------------
335 int oz_cdev_register(void)
339 memset(&g_cdev
, 0, sizeof(g_cdev
));
340 err
= alloc_chrdev_region(&g_cdev
.devnum
, 0, 1, "ozwpan");
343 oz_trace("Alloc dev number %d:%d\n", MAJOR(g_cdev
.devnum
),
344 MINOR(g_cdev
.devnum
));
345 cdev_init(&g_cdev
.cdev
, &oz_fops
);
346 g_cdev
.cdev
.owner
= THIS_MODULE
;
347 g_cdev
.cdev
.ops
= &oz_fops
;
348 spin_lock_init(&g_cdev
.lock
);
349 init_waitqueue_head(&g_cdev
.rdq
);
350 err
= cdev_add(&g_cdev
.cdev
, g_cdev
.devnum
, 1);
352 oz_trace("Failed to add cdev\n");
355 g_oz_class
= class_create(THIS_MODULE
, "ozmo_wpan");
356 if (IS_ERR(g_oz_class
)) {
357 oz_trace("Failed to register ozmo_wpan class\n");
360 dev
= device_create(g_oz_class
, NULL
, g_cdev
.devnum
, NULL
, "ozwpan");
362 oz_trace("Failed to create sysfs entry for cdev\n");
367 cdev_del(&g_cdev
.cdev
);
369 unregister_chrdev_region(g_cdev
.devnum
, 1);
373 /*------------------------------------------------------------------------------
376 int oz_cdev_deregister(void)
378 cdev_del(&g_cdev
.cdev
);
379 unregister_chrdev_region(g_cdev
.devnum
, 1);
381 device_destroy(g_oz_class
, g_cdev
.devnum
);
382 class_destroy(g_oz_class
);
386 /*------------------------------------------------------------------------------
389 int oz_cdev_init(void)
391 oz_event_log(OZ_EVT_SERVICE
, 1, OZ_APPID_SERIAL
, NULL
, 0);
392 oz_app_enable(OZ_APPID_SERIAL
, 1);
395 /*------------------------------------------------------------------------------
398 void oz_cdev_term(void)
400 oz_event_log(OZ_EVT_SERVICE
, 2, OZ_APPID_SERIAL
, NULL
, 0);
401 oz_app_enable(OZ_APPID_SERIAL
, 0);
403 /*------------------------------------------------------------------------------
404 * Context: softirq-serialized
406 int oz_cdev_start(struct oz_pd
*pd
, int resume
)
408 struct oz_serial_ctx
*ctx
;
409 struct oz_serial_ctx
*old_ctx
;
410 oz_event_log(OZ_EVT_SERVICE
, 3, OZ_APPID_SERIAL
, NULL
, resume
);
412 oz_trace("Serial service resumed.\n");
415 ctx
= kzalloc(sizeof(struct oz_serial_ctx
), GFP_ATOMIC
);
418 atomic_set(&ctx
->ref_count
, 1);
420 spin_lock_bh(&pd
->app_lock
[OZ_APPID_SERIAL
-1]);
421 old_ctx
= pd
->app_ctx
[OZ_APPID_SERIAL
-1];
423 spin_unlock_bh(&pd
->app_lock
[OZ_APPID_SERIAL
-1]);
426 pd
->app_ctx
[OZ_APPID_SERIAL
-1] = ctx
;
427 spin_unlock_bh(&pd
->app_lock
[OZ_APPID_SERIAL
-1]);
429 spin_lock(&g_cdev
.lock
);
430 if ((g_cdev
.active_pd
== NULL
) &&
431 (memcmp(pd
->mac_addr
, g_cdev
.active_addr
, ETH_ALEN
) == 0)) {
433 g_cdev
.active_pd
= pd
;
434 oz_trace("Active PD arrived.\n");
436 spin_unlock(&g_cdev
.lock
);
437 oz_trace("Serial service started.\n");
440 /*------------------------------------------------------------------------------
441 * Context: softirq or process
443 void oz_cdev_stop(struct oz_pd
*pd
, int pause
)
445 struct oz_serial_ctx
*ctx
;
446 oz_event_log(OZ_EVT_SERVICE
, 4, OZ_APPID_SERIAL
, NULL
, pause
);
448 oz_trace("Serial service paused.\n");
451 spin_lock_bh(&pd
->app_lock
[OZ_APPID_SERIAL
-1]);
452 ctx
= (struct oz_serial_ctx
*)pd
->app_ctx
[OZ_APPID_SERIAL
-1];
453 pd
->app_ctx
[OZ_APPID_SERIAL
-1] = NULL
;
454 spin_unlock_bh(&pd
->app_lock
[OZ_APPID_SERIAL
-1]);
456 oz_cdev_release_ctx(ctx
);
457 spin_lock(&g_cdev
.lock
);
458 if (pd
== g_cdev
.active_pd
)
459 g_cdev
.active_pd
= NULL
;
462 spin_unlock(&g_cdev
.lock
);
465 oz_trace("Active PD departed.\n");
467 oz_trace("Serial service stopped.\n");
469 /*------------------------------------------------------------------------------
470 * Context: softirq-serialized
472 void oz_cdev_rx(struct oz_pd
*pd
, struct oz_elt
*elt
)
474 struct oz_serial_ctx
*ctx
;
475 struct oz_app_hdr
*app_hdr
;
482 ctx
= oz_cdev_claim_ctx(pd
);
484 oz_trace("Cannot claim serial context.\n");
488 app_hdr
= (struct oz_app_hdr
*)(elt
+1);
489 /* If sequence number is non-zero then check it is not a duplicate.
491 if (app_hdr
->elt_seq_num
!= 0) {
492 if (((ctx
->rx_seq_num
- app_hdr
->elt_seq_num
) & 0x80) == 0) {
493 /* Reject duplicate element. */
494 oz_trace("Duplicate element:%02x %02x\n",
495 app_hdr
->elt_seq_num
, ctx
->rx_seq_num
);
499 ctx
->rx_seq_num
= app_hdr
->elt_seq_num
;
500 len
= elt
->length
- sizeof(struct oz_app_hdr
);
501 data
= ((u8
*)(elt
+1)) + sizeof(struct oz_app_hdr
);
504 space
= ctx
->rd_out
- ctx
->rd_in
- 1;
506 space
+= OZ_RD_BUF_SZ
;
508 oz_trace("Not enough space:%d %d\n", len
, space
);
512 copy_sz
= OZ_RD_BUF_SZ
- ix
;
515 memcpy(&ctx
->rd_buf
[ix
], data
, copy_sz
);
518 if (ix
== OZ_RD_BUF_SZ
)
521 memcpy(ctx
->rd_buf
, data
+copy_sz
, len
);
525 wake_up(&g_cdev
.rdq
);
527 oz_cdev_release_ctx(ctx
);