TI Bluetooth: Adding TTY HCI driver
[linux-2.6.git] / drivers / misc / ti-st / tty_hci.c
1 /*
2  *  TTY emulation for user-space Bluetooth stacks over HCI-H4
3  *  Copyright (C) 2011-2012 Texas Instruments
4  *  Author: Pavan Savoy <pavan_savoy@ti.com>
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License version 2 as
8  *  published by the Free Software Foundation.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU General Public License for more details.
14  *
15  *  You should have received a copy of the GNU General Public License
16  *  along with this program; if not, write to the Free Software
17  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  *
19  */
20
21 /** define one of the following for debugging
22 #define DEBUG
23 #define VERBOSE
24 */
25
26 #define pr_fmt(fmt) "(hci_tty): " fmt
27 #include <linux/module.h>
28 #include <linux/cdev.h>
29 #include <linux/fs.h>
30 #include <linux/device.h>
31
32 #include <linux/uaccess.h>
33 #include <linux/tty.h>
34 #include <linux/sched.h>
35
36 #include <linux/delay.h>
37 #include <linux/firmware.h>
38 #include <linux/platform_device.h>
39 #include <linux/poll.h>
40 #include <linux/skbuff.h>
41 #include <linux/interrupt.h>
42
43 #include <linux/ti_wilink_st.h>
44
45 /* Number of seconds to wait for registration completion
46  * when ST returns PENDING status.
47  */
48 #define BT_REGISTER_TIMEOUT   6000      /* 6 sec */
49
50 /**
51  * struct ti_st - driver operation structure
52  * @hdev: hci device pointer which binds to bt driver
53  * @reg_status: ST registration callback status
54  * @st_write: write function provided by the ST driver
55  *      to be used by the driver during send_frame.
56  * @wait_reg_completion - completion sync between ti_st_open
57  *      and st_reg_completion_cb.
58  */
59 struct ti_st {
60         struct hci_dev *hdev;
61         char reg_status;
62         long (*st_write) (struct sk_buff *);
63         struct completion wait_reg_completion;
64         wait_queue_head_t data_q;
65         struct sk_buff_head rx_list;
66 };
67
68 #define DEVICE_NAME     "hci_tty"
69
70 /***********Functions called from ST driver**********************************/
71 /* Called by Shared Transport layer when receive data is
72  * available */
73 static long st_receive(void *priv_data, struct sk_buff *skb)
74 {
75         struct ti_st    *hst = (void *) priv_data;
76
77         pr_debug("@ %s", __func__);
78 #ifdef VERBOSE
79         print_hex_dump(KERN_INFO, ">rx>", DUMP_PREFIX_NONE,
80                         16, 1, skb->data, skb->len, 0);
81 #endif
82         skb_queue_tail(&hst->rx_list, skb);
83         wake_up_interruptible(&hst->data_q);
84         return 0;
85 }
86
87 /* Called by ST layer to indicate protocol registration completion
88  * status.ti_st_open() function will wait for signal from this
89  * API when st_register() function returns ST_PENDING.
90  */
91 static void st_reg_completion_cb(void *priv_data, char data)
92 {
93         struct ti_st    *lhst = (void *) priv_data;
94
95         pr_info("@ %s\n", __func__);
96         /* Save registration status for use in ti_st_open() */
97         lhst->reg_status = data;
98         /* complete the wait in ti_st_open() */
99         complete(&lhst->wait_reg_completion);
100 }
101
102 /* protocol structure registered with shared transport */
103 #define MAX_BT_CHNL_IDS 3
104 static struct st_proto_s ti_st_proto[MAX_BT_CHNL_IDS] = {
105         {
106                 .chnl_id = 0x04, /* HCI Events */
107                 .hdr_len = 2,
108                 .offset_len_in_hdr = 1,
109                 .len_size = 1, /* sizeof(plen) in struct hci_event_hdr */
110                 .reserve = 8,
111         },
112         {
113                 .chnl_id = 0x02, /* ACL */
114                 .hdr_len = 4,
115                 .offset_len_in_hdr = 2,
116                 .len_size = 2,  /* sizeof(dlen) in struct hci_acl_hdr */
117                 .reserve = 8,
118         },
119         {
120                 .chnl_id = 0x03, /* SCO */
121                 .hdr_len = 3,
122                 .offset_len_in_hdr = 2,
123                 .len_size = 1, /* sizeof(dlen) in struct hci_sco_hdr */
124                 .reserve = 8,
125         },
126 };
127 /** hci_tty_open Function
128  *  This function will perform an register on ST driver.
129  *
130  *  Parameters :
131  *  @file  : File pointer for BT char driver
132  *  @inod  :
133  *  Returns  0 -  on success
134  *           else suitable error code
135  */
136 int hci_tty_open(struct inode *inod, struct file *file)
137 {
138         int i = 0, err = 0;
139         unsigned long timeleft;
140         struct ti_st *hst;
141
142         pr_info("inside %s (%p, %p)\n", __func__, inod, file);
143
144         hst = kzalloc(sizeof(*hst), GFP_KERNEL);
145         file->private_data = hst;
146         hst = file->private_data;
147
148         for (i = 0; i < MAX_BT_CHNL_IDS; i++) {
149                 ti_st_proto[i].priv_data = hst;
150                 ti_st_proto[i].max_frame_size = 1026;
151                 ti_st_proto[i].recv = st_receive;
152                 ti_st_proto[i].reg_complete_cb = st_reg_completion_cb;
153
154                 /* Prepare wait-for-completion handler */
155                 init_completion(&hst->wait_reg_completion);
156                 /* Reset ST registration callback status flag,
157                  * this value will be updated in
158                  * st_reg_completion_cb()
159                  * function whenever it called from ST driver.
160                  */
161                 hst->reg_status = -EINPROGRESS;
162
163                 err = st_register(&ti_st_proto[i]);
164                 if (!err)
165                         goto done;
166
167                 if (err != -EINPROGRESS) {
168                         pr_err("st_register failed %d", err);
169                         return err;
170                 }
171
172                 /* ST is busy with either protocol
173                  * registration or firmware download.
174                  */
175                 pr_debug("waiting for registration "
176                                 "completion signal from ST");
177                 timeleft = wait_for_completion_timeout
178                         (&hst->wait_reg_completion,
179                          msecs_to_jiffies(BT_REGISTER_TIMEOUT));
180                 if (!timeleft) {
181                         pr_err("Timeout(%d sec),didn't get reg "
182                                         "completion signal from ST",
183                                         BT_REGISTER_TIMEOUT / 1000);
184                         return -ETIMEDOUT;
185                 }
186
187                 /* Is ST registration callback
188                  * called with ERROR status? */
189                 if (hst->reg_status != 0) {
190                         pr_err("ST registration completed with invalid "
191                                         "status %d", hst->reg_status);
192                         return -EAGAIN;
193                 }
194
195 done:
196                 hst->st_write = ti_st_proto[i].write;
197                 if (!hst->st_write) {
198                         pr_err("undefined ST write function");
199                         for (i = 0; i < MAX_BT_CHNL_IDS; i++) {
200                                 /* Undo registration with ST */
201                                 err = st_unregister(&ti_st_proto[i]);
202                                 if (err)
203                                         pr_err("st_unregister() failed with "
204                                                         "error %d", err);
205                                 hst->st_write = NULL;
206                         }
207                         return -EIO;
208                 }
209         }
210
211         skb_queue_head_init(&hst->rx_list);
212         init_waitqueue_head(&hst->data_q);
213
214         return 0;
215 }
216
217 /** hci_tty_release Function
218  *  This function will un-registers from the ST driver.
219  *
220  *  Parameters :
221  *  @file  : File pointer for BT char driver
222  *  @inod  :
223  *  Returns  0 -  on success
224  *           else suitable error code
225  */
226 int hci_tty_release(struct inode *inod, struct file *file)
227 {
228         int err, i;
229         struct ti_st *hst = file->private_data;
230
231         pr_info("inside %s (%p, %p)\n", __func__, inod, file);
232
233         for (i = 0; i < MAX_BT_CHNL_IDS; i++) {
234                 err = st_unregister(&ti_st_proto[i]);
235                 if (err)
236                         pr_err("st_unregister(%d) failed with error %d",
237                                         ti_st_proto[i].chnl_id, err);
238         }
239
240         hst->st_write = NULL;
241         skb_queue_purge(&hst->rx_list);
242         kfree(hst);
243         return err;
244 }
245
246 /** hci_tty_read Function
247  *
248  *  Parameters :
249  *  @file  : File pointer for BT char driver
250  *  @data  : Data which needs to be passed to APP
251  *  @size  : Length of the data passesd
252  *  offset :
253  *  Returns  Size of packet received -  on success
254  *           else suitable error code
255  */
256 ssize_t hci_tty_read(struct file *file, char __user *data, size_t size,
257                 loff_t *offset)
258 {
259         int len = 0, tout;
260         struct sk_buff *skb = NULL, *rskb = NULL;
261         struct ti_st    *hst;
262
263         pr_debug("inside %s (%p, %p, %u, %p)\n",
264                         __func__, file, data, size, offset);
265
266         /* Validate input parameters */
267         if ((NULL == file) || (((NULL == data) || (0 == size)))) {
268                 pr_err("Invalid input params passed to %s", __func__);
269                 return -EINVAL;
270         }
271
272         hst = file->private_data;
273
274         /* cannot come here if poll-ed before reading
275          * if not poll-ed wait on the same wait_q
276          */
277         tout = wait_event_interruptible_timeout(hst->data_q,
278                         !skb_queue_empty(&hst->rx_list),
279                                 msecs_to_jiffies(1000));
280         /* Check for timed out condition */
281         if (0 == tout) {
282                 pr_err("Device Read timed out\n");
283                 return -ETIMEDOUT;
284         }
285
286         /* hst->rx_list not empty skb already present */
287         skb = skb_dequeue(&hst->rx_list);
288         if (!skb) {
289                 pr_err("dequed skb is null?\n");
290                 return -EIO;
291         }
292
293 #ifdef VERBOSE
294         print_hex_dump(KERN_INFO, ">in>", DUMP_PREFIX_NONE,
295                         16, 1, skb->data, skb->len, 0);
296 #endif
297
298         /* Forward the data to the user */
299         if (skb->len >= size) {
300                 pr_err("FIONREAD not done before read\n");
301                 return -ENOMEM;
302         } else {
303                 /* returning skb */
304                 rskb = alloc_skb(size, GFP_KERNEL);
305                 if (!rskb) {
306                         pr_err("alloc_skb error\n");
307                         return -ENOMEM;
308                 }
309
310                 /* cb[0] has the pkt_type 0x04 or 0x02 or 0x03 */
311                 memcpy(skb_put(rskb, 1), &skb->cb[0], 1);
312                 memcpy(skb_put(rskb, skb->len), skb->data, skb->len);
313
314                 if (copy_to_user(data, rskb->data, rskb->len)) {
315                         pr_err("unable to copy to user space\n");
316                         /* Queue the skb back to head */
317                         skb_queue_head(&hst->rx_list, skb);
318                         kfree_skb(rskb);
319                         return -EIO;
320                 }
321         }
322
323         len = rskb->len;        /* len of returning skb */
324         kfree_skb(skb);
325         kfree_skb(rskb);
326         pr_debug("total size read= %d\n", len);
327         return len;
328 }
329
330 /* hci_tty_write Function
331  *
332  *  Parameters :
333  *  @file   : File pointer for BT char driver
334  *  @data   : packet data from BT application
335  *  @size   : Size of the packet data
336  *  @offset :
337  *  Returns  Size of packet on success
338  *           else suitable error code
339  */
340 ssize_t hci_tty_write(struct file *file, const char __user *data,
341                 size_t size, loff_t *offset)
342 {
343         struct ti_st *hst = file->private_data;
344         struct  sk_buff *skb;
345
346         pr_debug("inside %s (%p, %p, %u, %p)\n",
347                         __func__, file, data, size, offset);
348
349         if (!hst->st_write) {
350                 pr_err(" Can't write to ST, hhci_tty->st_write null ?");
351                 return -EINVAL;
352         }
353
354         skb = alloc_skb(size, GFP_KERNEL);
355         /* Validate Created SKB */
356         if (NULL == skb) {
357                 pr_err("Error aaloacting SKB");
358                 return -ENOMEM;
359         }
360
361         /* Forward the data from the user space to ST core */
362         if (copy_from_user(skb_put(skb, size), data, size)) {
363                 pr_err(" Unable to copy from user space");
364                 kfree_skb(skb);
365                 return -EIO;
366         }
367
368 #ifdef VERBOSE
369         pr_debug("start data..");
370         print_hex_dump(KERN_INFO, "<out<", DUMP_PREFIX_NONE,
371                         16, 1, skb->data, size, 0);
372         pr_debug("\n..end data");
373 #endif
374
375         hst->st_write(skb);
376         return size;
377 }
378
379 /** hci_tty_ioctl Function
380  *  This will peform the functions as directed by the command and command
381  *  argument.
382  *
383  *  Parameters :
384  *  @file  : File pointer for BT char driver
385  *  @cmd   : IOCTL Command
386  *  @arg   : Command argument for IOCTL command
387  *  Returns  0 on success
388  *           else suitable error code
389  */
390 static long hci_tty_ioctl(struct file *file,
391                 unsigned int cmd, unsigned long arg)
392 {
393         struct sk_buff *skb = NULL;
394         int             retCode = 0;
395         struct ti_st    *hst;
396
397         pr_debug("inside %s (%p, %u, %lx)", __func__, file, cmd, arg);
398
399         /* Validate input parameters */
400         if ((NULL == file) || (0 == cmd)) {
401                 pr_err("invalid input parameters passed to %s", __func__);
402                 return -EINVAL;
403         }
404
405         hst = file->private_data;
406
407         switch (cmd) {
408         case FIONREAD:
409                 /* Deque the SKB from the head if rx_list is not empty
410                  * update the argument with skb->len to provide amount of data
411                  * available in the available SKB +1 for the PKT_TYPE
412                  * field not provided in data by TI-ST.
413                  */
414                 skb = skb_dequeue(&hst->rx_list);
415                 if (skb != NULL) {
416                         *(unsigned int *)arg = skb->len + 1;
417                         /* Re-Store the SKB for furtur Read operations */
418                         skb_queue_head(&hst->rx_list, skb);
419                 } else {
420                         *(unsigned int *)arg = 0;
421                 }
422                 pr_debug("returning %d\n", *(unsigned int *)arg);
423                 break;
424         default:
425                 pr_debug("Un-Identified IOCTL %d", cmd);
426                 retCode = 0;
427                 break;
428         }
429
430         return retCode;
431 }
432
433 /** hci_tty_poll Function
434  *  This function will wait till some data is received to the hci_tty driver from ST
435  *
436  *  Parameters :
437  *  @file  : File pointer for BT char driver
438  *  @wait  : POLL wait information
439  *  Returns  status of POLL on success
440  *           else suitable error code
441  */
442 static unsigned int hci_tty_poll(struct file *file, poll_table *wait)
443 {
444         struct ti_st    *hst = file->private_data;
445         unsigned long mask = 0;
446
447         pr_debug("@ %s\n", __func__);
448
449         /* wait to be completed by st_receive */
450         poll_wait(file, &hst->data_q, wait);
451         pr_debug("poll broke\n");
452
453         if (!skb_queue_empty(&hst->rx_list)) {
454                 pr_debug("rx list que !empty\n");
455                 mask |= POLLIN; /* TODO: check app for mask */
456         }
457
458         return mask;
459 }
460
461 /* BT Char driver function pointers
462  * These functions are called from USER space by pefroming File Operations
463  * on /dev/hci_tty node exposed by this driver during init
464  */
465 const struct file_operations hci_tty_chrdev_ops = {
466         .owner = THIS_MODULE,
467         .open = hci_tty_open,
468         .read = hci_tty_read,
469         .write = hci_tty_write,
470         .unlocked_ioctl = hci_tty_ioctl,
471         .poll = hci_tty_poll,
472         .release = hci_tty_release,
473 };
474
475 /*********Functions called during insmod and delmod****************************/
476
477 static int hci_tty_major;               /* major number */
478 static struct class *hci_tty_class;     /* class during class_create */
479 static struct device *hci_tty_dev;      /* dev during device_create */
480 /** hci_tty_init Function
481  *  This function Initializes the hci_tty driver parametes and exposes
482  *  /dev/hci_tty node to user space
483  *
484  *  Parameters : NULL
485  *  Returns  0 on success
486  *           else suitable error code
487  */
488 static int __init hci_tty_init(void)
489 {
490         pr_info("inside %s\n", __func__);
491
492         /* Expose the device DEVICE_NAME to user space
493          * And obtain the major number for the device
494          */
495         hci_tty_major = register_chrdev(0, DEVICE_NAME, \
496                         &hci_tty_chrdev_ops);
497         if (0 > hci_tty_major) {
498                 pr_err("Error when registering to char dev");
499                 return hci_tty_major;
500         }
501
502         /*  udev */
503         hci_tty_class = class_create(THIS_MODULE, DEVICE_NAME);
504         if (IS_ERR(hci_tty_class)) {
505                 pr_err("Something went wrong in class_create");
506                 unregister_chrdev(hci_tty_major, DEVICE_NAME);
507                 return -1;
508         }
509
510         hci_tty_dev =
511                 device_create(hci_tty_class, NULL, MKDEV(hci_tty_major, 0),
512                                 NULL, DEVICE_NAME);
513         if (IS_ERR(hci_tty_dev)) {
514                 pr_err("Error in device create");
515                 unregister_chrdev(hci_tty_major, DEVICE_NAME);
516                 class_destroy(hci_tty_class);
517                 return -1;
518         }
519         pr_info("allocated %d, %d\n", hci_tty_major, 0);
520         return 0;
521 }
522
523 /** hci_tty_exit Function
524  *  This function Destroys the hci_tty driver parametes and /dev/hci_tty node
525  *
526  *  Parameters : NULL
527  *  Returns   NULL
528  */
529 static void __exit hci_tty_exit(void)
530 {
531         pr_info("inside %s\n", __func__);
532         pr_info("bye.. freeing up %d\n", hci_tty_major);
533
534         device_destroy(hci_tty_class, MKDEV(hci_tty_major, 0));
535         class_destroy(hci_tty_class);
536         unregister_chrdev(hci_tty_major, DEVICE_NAME);
537 }
538
539 module_init(hci_tty_init);
540 module_exit(hci_tty_exit);
541
542 MODULE_AUTHOR("Pavan Savoy <pavan_savoy@ti.com>");
543 MODULE_LICENSE("GPL");