tegra: Make tegra_vi01_device accessible
[linux-2.6.git] / drivers / bluetooth / bluesleep.c
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License version 2 as
4  * published by the Free Software Foundation.
5  *
6  * You should have received a copy of the GNU General Public License
7  * along with this program; if not, write to the Free Software
8  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
13  * for more details.
14  *
15  * Copyright (C) 2006-2007 - Motorola
16  * Copyright (c) 2008-2009, Code Aurora Forum. All rights reserved.
17  *
18  *  Date         Author           Comment
19  * -----------  --------------   --------------------------------
20  * 2006-Apr-28  Motorola         The kernel module for running the Bluetooth(R)
21  *                               Sleep-Mode Protocol from the Host side
22  * 2006-Sep-08  Motorola         Added workqueue for handling sleep work.
23  * 2007-Jan-24  Motorola         Added mbm_handle_ioi() call to ISR.
24  * 2009-Aug-10  Motorola         Changed "add_timer" to "mod_timer" to solve
25  *                               race when flurry of queued work comes in.
26 */
27
28 #include <linux/module.h>       /* kernel module definitions */
29 #include <linux/errno.h>
30 #include <linux/init.h>
31 #include <linux/interrupt.h>
32 #include <linux/kernel.h>
33 #include <linux/notifier.h>
34 #include <linux/proc_fs.h>
35 #include <linux/spinlock.h>
36 #include <linux/timer.h>
37 #include <linux/uaccess.h>
38 #include <linux/version.h>
39 #include <linux/workqueue.h>
40 #include <linux/platform_device.h>
41
42 #include <linux/irq.h>
43 #include <linux/ioport.h>
44 #include <linux/param.h>
45 #include <linux/bitops.h>
46 #include <linux/termios.h>
47 #include <linux/wakelock.h>
48 #include <mach/gpio.h>
49 #include <linux/serial_core.h>
50 #include <linux/tegra_uart.h>
51
52 #include <net/bluetooth/bluetooth.h>
53 #include <net/bluetooth/hci_core.h> /* event notifications */
54 #include "hci_uart.h"
55
56 #define BT_SLEEP_DBG
57 #ifndef BT_SLEEP_DBG
58 #define BT_DBG(fmt, arg...)
59 #endif
60 /*
61  * Defines
62  */
63
64 #define VERSION  "1.1"
65 #define PROC_DIR        "bluetooth/sleep"
66
67 #define POLARITY_LOW 0
68 #define POLARITY_HIGH 1
69
70 /* enable/disable wake-on-bluetooth */
71 #define BT_ENABLE_IRQ_WAKE 1
72
73 struct bluesleep_info {
74         unsigned host_wake;
75         unsigned ext_wake;
76         unsigned host_wake_irq;
77         struct uart_port *uport;
78         struct wake_lock wake_lock;
79         int irq_polarity;
80         int has_ext_wake;
81 };
82
83 /* work function */
84 static void bluesleep_sleep_work(struct work_struct *work);
85
86 /* work queue */
87 DECLARE_DELAYED_WORK(sleep_workqueue, bluesleep_sleep_work);
88
89 /* Macros for handling sleep work */
90 #define bluesleep_rx_busy()     schedule_delayed_work(&sleep_workqueue, 0)
91 #define bluesleep_tx_busy()     schedule_delayed_work(&sleep_workqueue, 0)
92 #define bluesleep_rx_idle()     schedule_delayed_work(&sleep_workqueue, 0)
93 #define bluesleep_tx_idle()     schedule_delayed_work(&sleep_workqueue, 0)
94
95 /* 10 second timeout */
96 #define TX_TIMER_INTERVAL  10
97
98 /* state variable names and bit positions */
99 #define BT_PROTO         0x01
100 #define BT_TXDATA        0x02
101 #define BT_ASLEEP        0x04
102 #define BT_EXT_WAKE     0x08
103 #define BT_SUSPEND      0x10
104
105 /* global pointer to a single hci device. */
106 static struct hci_dev *bluesleep_hdev;
107
108 static struct bluesleep_info *bsi;
109
110 /* module usage */
111 static atomic_t open_count = ATOMIC_INIT(1);
112
113 /*
114  * Local function prototypes
115  */
116 static int bluesleep_hci_event(struct notifier_block *this,
117                         unsigned long event, void *data);
118 static int bluesleep_start(void);
119 static void bluesleep_stop(void);
120
121 /*
122  * Global variables
123  */
124 /** Global state flags */
125 static unsigned long flags;
126
127 /** Tasklet to respond to change in hostwake line */
128 static struct tasklet_struct hostwake_task;
129
130 /** Transmission timer */
131 static void bluesleep_tx_timer_expire(unsigned long data);
132 static DEFINE_TIMER(tx_timer, bluesleep_tx_timer_expire, 0, 0);
133
134 /** Lock for state transitions */
135 static spinlock_t rw_lock;
136
137 /** Notifier block for HCI events */
138 struct notifier_block hci_event_nblock = {
139         .notifier_call = bluesleep_hci_event,
140 };
141
142 struct proc_dir_entry *bluetooth_dir, *sleep_dir;
143
144 /*
145  * Local functions
146  */
147 static void hsuart_power(int on)
148 {
149         if (test_bit(BT_SUSPEND, &flags))
150                 return;
151         if (on) {
152                 tegra_uart_request_clock_on(bsi->uport);
153                 tegra_uart_set_mctrl(bsi->uport, TIOCM_RTS);
154         } else {
155                 tegra_uart_set_mctrl(bsi->uport, 0);
156                 tegra_uart_request_clock_off(bsi->uport);
157         }
158 }
159
160 /**
161  * @return 1 if the Host can go to sleep, 0 otherwise.
162  */
163 int bluesleep_can_sleep(void)
164 {
165         /* check if WAKE_BT_GPIO and BT_WAKE_GPIO are both deasserted */
166         return ((gpio_get_value(bsi->host_wake) != bsi->irq_polarity) &&
167                 (!test_bit(BT_EXT_WAKE, &flags)) &&
168                 (bsi->uport != NULL));
169 }
170
171 void bluesleep_sleep_wakeup(void)
172 {
173         if (test_bit(BT_ASLEEP, &flags)) {
174                 BT_DBG("waking up...");
175                 wake_lock(&bsi->wake_lock);
176                 /* Start the timer */
177                 mod_timer(&tx_timer, jiffies + (TX_TIMER_INTERVAL * HZ));
178                 if (bsi->has_ext_wake == 1)
179                         gpio_set_value(bsi->ext_wake, 1);
180                 set_bit(BT_EXT_WAKE, &flags);
181                 clear_bit(BT_ASLEEP, &flags);
182                 /*Activating UART */
183         }
184 }
185
186 /**
187  * @brief@  main sleep work handling function which update the flags
188  * and activate and deactivate UART ,check FIFO.
189  */
190 static void bluesleep_sleep_work(struct work_struct *work)
191 {
192         if (bluesleep_can_sleep()) {
193                 /* already asleep, this is an error case */
194                 if (test_bit(BT_ASLEEP, &flags)) {
195                         BT_DBG("already asleep");
196                         return;
197                 }
198
199                 if (tegra_uart_is_tx_empty(bsi->uport)) {
200                         BT_DBG("going to sleep...");
201                         set_bit(BT_ASLEEP, &flags);
202                         /*Deactivating UART */
203                         /* UART clk is not turned off immediately. Release
204                          * wakelock after 500 ms.
205                          */
206                         wake_lock_timeout(&bsi->wake_lock, HZ / 2);
207                 } else {
208                         mod_timer(&tx_timer, jiffies + TX_TIMER_INTERVAL * HZ);
209                         return;
210                 }
211         } else if (!test_bit(BT_EXT_WAKE, &flags)
212                         && !test_bit(BT_ASLEEP, &flags)) {
213                 mod_timer(&tx_timer, jiffies + (TX_TIMER_INTERVAL * HZ));
214                 if (bsi->has_ext_wake == 1)
215                         gpio_set_value(bsi->ext_wake, 1);
216                 set_bit(BT_EXT_WAKE, &flags);
217         } else {
218                 bluesleep_sleep_wakeup();
219         }
220 }
221
222 /**
223  * A tasklet function that runs in tasklet context and reads the value
224  * of the HOST_WAKE GPIO pin and further defer the work.
225  * @param data Not used.
226  */
227 static void bluesleep_hostwake_task(unsigned long data)
228 {
229         BT_DBG("hostwake line change");
230
231         spin_lock(&rw_lock);
232         if ((gpio_get_value(bsi->host_wake) == bsi->irq_polarity))
233                 bluesleep_rx_busy();
234         else
235                 bluesleep_rx_idle();
236         spin_unlock(&rw_lock);
237
238 }
239
240 /**
241  * Handles proper timer action when outgoing data is delivered to the
242  * HCI line discipline. Sets BT_TXDATA.
243  */
244 static void bluesleep_outgoing_data(void)
245 {
246         unsigned long irq_flags;
247
248         spin_lock_irqsave(&rw_lock, irq_flags);
249         /* log data passing by */
250         set_bit(BT_TXDATA, &flags);
251         /* if the tx side is sleeping... */
252         if (!test_bit(BT_EXT_WAKE, &flags)) {
253                 BT_DBG("tx was sleeping");
254                 bluesleep_sleep_wakeup();
255         }
256         spin_unlock_irqrestore(&rw_lock, irq_flags);
257 }
258
259 /**
260  * Handles HCI device events.
261  * @param this Not used.
262  * @param event The event that occurred.
263  * @param data The HCI device associated with the event.
264  * @return <code>NOTIFY_DONE</code>.
265  */
266 static int bluesleep_hci_event(struct notifier_block *this,
267                                 unsigned long event, void *data)
268 {
269         struct hci_dev *hdev = (struct hci_dev *) data;
270         struct hci_uart *hu;
271         struct uart_state *state;
272
273         if (!hdev)
274                 return NOTIFY_DONE;
275
276         switch (event) {
277         case HCI_DEV_REG:
278                 if (!bluesleep_hdev) {
279                         bluesleep_hdev = hdev;
280                         if (bsi->has_ext_wake == 1) {
281                                 hu  = (struct hci_uart *) hdev->driver_data;
282                                 state = (struct uart_state *) \
283                                                          hu->tty->driver_data;
284                                 bsi->uport = state->uart_port;
285                         }
286                         /* if bluetooth started, start bluesleep*/
287                         bluesleep_start();
288                 }
289                 break;
290         case HCI_DEV_UP:
291 #if BT_ENABLE_IRQ_WAKE
292                 if (enable_irq_wake(bsi->host_wake_irq))
293                         BT_ERR("Couldn't enable BT_HOST_WAKE as wakeup interrupt");
294 #endif
295                 break;
296         case HCI_DEV_DOWN:
297 #if BT_ENABLE_IRQ_WAKE
298                 if (disable_irq_wake(bsi->host_wake_irq))
299                         BT_ERR("Couldn't disable hostwake IRQ wakeup mode\n");
300 #endif
301                 break;
302         case HCI_DEV_UNREG:
303                 bluesleep_stop();
304                 bluesleep_hdev = NULL;
305                 bsi->uport = NULL;
306                 /* if bluetooth stopped, stop bluesleep also */
307                 break;
308         case HCI_DEV_WRITE:
309                 if (bsi->has_ext_wake == 1)
310                         bluesleep_outgoing_data();
311                 break;
312         }
313
314         return NOTIFY_DONE;
315 }
316
317 /**
318  * Handles transmission timer expiration.
319  * @param data Not used.
320  */
321 static void bluesleep_tx_timer_expire(unsigned long data)
322 {
323         unsigned long irq_flags;
324
325         BT_DBG("Tx timer expired");
326
327         spin_lock_irqsave(&rw_lock, irq_flags);
328
329         /* were we silent during the last timeout? */
330         if (!test_bit(BT_TXDATA, &flags)) {
331                 BT_DBG("Tx has been idle");
332                 if (bsi->has_ext_wake == 1)
333                         gpio_set_value(bsi->ext_wake, 0);
334                 clear_bit(BT_EXT_WAKE, &flags);
335                 bluesleep_tx_idle();
336         } else {
337                 BT_DBG("Tx data during last period");
338                 mod_timer(&tx_timer, jiffies + (TX_TIMER_INTERVAL*HZ));
339         }
340
341         /* clear the incoming data flag */
342         clear_bit(BT_TXDATA, &flags);
343
344         spin_unlock_irqrestore(&rw_lock, irq_flags);
345 }
346
347 /**
348  * Schedules a tasklet to run when receiving an interrupt on the
349  * <code>HOST_WAKE</code> GPIO pin.
350  * @param irq Not used.
351  * @param dev_id Not used.
352  */
353 static irqreturn_t bluesleep_hostwake_isr(int irq, void *dev_id)
354 {
355         /* schedule a tasklet to handle the change in the host wake line */
356         if (bsi->has_ext_wake == 1)
357                 tasklet_schedule(&hostwake_task);
358         return IRQ_HANDLED;
359 }
360
361 /**
362  * Starts the Sleep-Mode Protocol on the Host.
363  * @return On success, 0. On error, -1, and <code>errno</code> is set
364  * appropriately.
365  */
366 static int bluesleep_start(void)
367 {
368         unsigned long irq_flags;
369
370         spin_lock_irqsave(&rw_lock, irq_flags);
371         if (test_bit(BT_PROTO, &flags)) {
372                 spin_unlock_irqrestore(&rw_lock, irq_flags);
373                 return 0;
374         }
375         spin_unlock_irqrestore(&rw_lock, irq_flags);
376
377         if (!atomic_dec_and_test(&open_count)) {
378                 atomic_inc(&open_count);
379                 return -EBUSY;
380         }
381
382         /* assert BT_WAKE */
383         if (bsi->has_ext_wake == 1) {
384                 /* start the timer */
385                 mod_timer(&tx_timer, jiffies + (TX_TIMER_INTERVAL * HZ));
386                 gpio_set_value(bsi->ext_wake, 1);
387                 wake_lock(&bsi->wake_lock);
388                 set_bit(BT_EXT_WAKE, &flags);
389         }
390
391         set_bit(BT_PROTO, &flags);
392         return 0;
393 fail:
394         if (bsi->has_ext_wake == 1)
395                 del_timer(&tx_timer);
396         atomic_inc(&open_count);
397
398         return 0;
399 }
400
401 /**
402  * Stops the Sleep-Mode Protocol on the Host.
403  */
404 static void bluesleep_stop(void)
405 {
406         unsigned long irq_flags;
407
408         spin_lock_irqsave(&rw_lock, irq_flags);
409         if (!test_bit(BT_PROTO, &flags)) {
410                 spin_unlock_irqrestore(&rw_lock, irq_flags);
411                 return;
412         }
413         /* assert BT_WAKE */
414         if (bsi->has_ext_wake == 1) {
415                 gpio_set_value(bsi->ext_wake, 1);
416                 set_bit(BT_EXT_WAKE, &flags);
417                 del_timer(&tx_timer);
418                 wake_lock_timeout(&bsi->wake_lock, HZ / 2);
419                 if (test_bit(BT_ASLEEP, &flags)) {
420                         clear_bit(BT_ASLEEP, &flags);
421                         hsuart_power(1);
422                 }
423         }
424         clear_bit(BT_PROTO, &flags);
425
426         atomic_inc(&open_count);
427         spin_unlock_irqrestore(&rw_lock, irq_flags);
428 }
429 /**
430  * Read the <code>BT_WAKE</code> GPIO pin value via the proc interface.
431  * When this function returns, <code>page</code> will contain a 1 if the
432  * pin is high, 0 otherwise.
433  * @param page Buffer for writing data.
434  * @param start Not used.
435  * @param offset Not used.
436  * @param count Not used.
437  * @param eof Whether or not there is more data to be read.
438  * @param data Not used.
439  * @return The number of bytes written.
440  */
441 static int bluepower_read_proc_btwake(char *page, char **start, off_t offset,
442                                         int count, int *eof, void *data)
443 {
444         *eof = 1;
445         return sprintf(page, "btwake:%u\n",test_bit(BT_EXT_WAKE, &flags));
446 }
447
448 /**
449  * Write the <code>BT_WAKE</code> GPIO pin value via the proc interface.
450  * @param file Not used.
451  * @param buffer The buffer to read from.
452  * @param count The number of bytes to be written.
453  * @param data Not used.
454  * @return On success, the number of bytes written. On error, -1, and
455  * <code>errno</code> is set appropriately.
456  */
457 static int bluepower_write_proc_btwake(struct file *file, const char *buffer,
458                                         unsigned long count, void *data)
459 {
460         char *buf;
461
462         if (count < 1)
463                 return -EINVAL;
464
465         buf = kmalloc(count, GFP_KERNEL);
466         if (!buf)
467                 return -ENOMEM;
468
469         if (copy_from_user(buf, buffer, count)) {
470                 kfree(buf);
471                 return -EFAULT;
472         }
473         if (buf[0] == '0') {
474                 if (bsi->has_ext_wake == 1)
475                         gpio_set_value(bsi->ext_wake, 0);
476                 clear_bit(BT_EXT_WAKE, &flags);
477         } else if (buf[0] == '1') {
478                 if (bsi->has_ext_wake == 1)
479                         gpio_set_value(bsi->ext_wake, 1);
480                 set_bit(BT_EXT_WAKE, &flags);
481         } else {
482                 kfree(buf);
483                 return -EINVAL;
484         }
485
486         kfree(buf);
487         return count;
488 }
489
490 /**
491  * Read the <code>BT_HOST_WAKE</code> GPIO pin value via the proc interface.
492  * When this function returns, <code>page</code> will contain a 1 if the pin
493  * is high, 0 otherwise.
494  * @param page Buffer for writing data.
495  * @param start Not used.
496  * @param offset Not used.
497  * @param count Not used.
498  * @param eof Whether or not there is more data to be read.
499  * @param data Not used.
500  * @return The number of bytes written.
501  */
502 static int bluepower_read_proc_hostwake(char *page, char **start, off_t offset,
503                                         int count, int *eof, void *data)
504 {
505         *eof = 1;
506         return sprintf(page, "hostwake: %u\n", gpio_get_value(bsi->host_wake));
507 }
508
509
510 /**
511  * Read the low-power status of the Host via the proc interface.
512  * When this function returns, <code>page</code> contains a 1 if the Host
513  * is asleep, 0 otherwise.
514  * @param page Buffer for writing data.
515  * @param start Not used.
516  * @param offset Not used.
517  * @param count Not used.
518  * @param eof Whether or not there is more data to be read.
519  * @param data Not used.
520  * @return The number of bytes written.
521  */
522 static int bluesleep_read_proc_asleep(char *page, char **start, off_t offset,
523                                         int count, int *eof, void *data)
524 {
525         unsigned int asleep;
526
527         asleep = test_bit(BT_ASLEEP, &flags) ? 1 : 0;
528         *eof = 1;
529         return sprintf(page, "asleep: %u\n", asleep);
530 }
531
532 /**
533  * Read the low-power protocol being used by the Host via the proc interface.
534  * When this function returns, <code>page</code> will contain a 1 if the Host
535  * is using the Sleep Mode Protocol, 0 otherwise.
536  * @param page Buffer for writing data.
537  * @param start Not used.
538  * @param offset Not used.
539  * @param count Not used.
540  * @param eof Whether or not there is more data to be read.
541  * @param data Not used.
542  * @return The number of bytes written.
543  */
544 static int bluesleep_read_proc_proto(char *page, char **start, off_t offset,
545                                         int count, int *eof, void *data)
546 {
547         unsigned int proto;
548
549         proto = test_bit(BT_PROTO, &flags) ? 1 : 0;
550         *eof = 1;
551         return sprintf(page, "proto: %u\n", proto);
552 }
553
554 /**
555  * Modify the low-power protocol used by the Host via the proc interface.
556  * @param file Not used.
557  * @param buffer The buffer to read from.
558  * @param count The number of bytes to be written.
559  * @param data Not used.
560  * @return On success, the number of bytes written. On error, -1, and
561  * <code>errno</code> is set appropriately.
562  */
563 static int bluesleep_write_proc_proto(struct file *file, const char *buffer,
564                                         unsigned long count, void *data)
565 {
566         char proto;
567
568         if (count < 1)
569                 return -EINVAL;
570
571         if (copy_from_user(&proto, buffer, 1))
572                 return -EFAULT;
573
574         if (proto == '0')
575                 bluesleep_stop();
576         else
577                 bluesleep_start();
578
579         /* claim that we wrote everything */
580         return count;
581 }
582
583
584 static int bluesleep_probe(struct platform_device *pdev)
585 {
586         int ret;
587         struct resource *res;
588
589         bsi = kzalloc(sizeof(struct bluesleep_info), GFP_KERNEL);
590         if (!bsi)
591                 return -ENOMEM;
592
593         res = platform_get_resource_byname(pdev, IORESOURCE_IO,
594                                 "gpio_host_wake");
595         if (!res) {
596                 BT_ERR("couldn't find host_wake gpio\n");
597                 ret = -ENODEV;
598                 goto free_bsi;
599         }
600         bsi->host_wake = res->start;
601
602         ret = gpio_request(bsi->host_wake, "bt_host_wake");
603         if (ret)
604                 goto free_bsi;
605
606         /* configure host_wake as input */
607         ret = gpio_direction_input(bsi->host_wake);
608         if (ret < 0) {
609                 pr_err("gpio-keys: failed to configure input"
610                                 " direction for GPIO %d, error %d\n",
611                                 bsi->host_wake, ret);
612                 gpio_free(bsi->host_wake);
613                 goto free_bsi;
614         }
615
616         res = platform_get_resource_byname(pdev, IORESOURCE_IO,
617                                 "gpio_ext_wake");
618
619         if (!res)
620                 bsi->has_ext_wake = 0;
621         else
622                 bsi->has_ext_wake = 1;
623
624         if (bsi->has_ext_wake) {
625                 bsi->ext_wake = res->start;
626                 ret = gpio_request(bsi->ext_wake, "bt_ext_wake");
627                 if (ret)
628                         goto free_bt_host_wake;
629
630                 /* configure ext_wake as output mode*/
631                 ret = gpio_direction_output(bsi->ext_wake, 1);
632                 if (ret < 0) {
633                         pr_err("gpio-keys: failed to configure output"
634                                 " direction for GPIO %d, error %d\n",
635                                   bsi->ext_wake, ret);
636                         gpio_free(bsi->ext_wake);
637                         goto free_bt_host_wake;
638                 }
639         } else
640                 set_bit(BT_EXT_WAKE, &flags);
641
642         res = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
643                                                 "host_wake");
644         if (!res) {
645                 BT_ERR("couldn't find host_wake irq\n");
646                 ret = -ENODEV;
647                 goto free_bt_host_wake;
648         }
649         bsi->host_wake_irq = res->start;
650         if (bsi->host_wake_irq < 0) {
651                 BT_ERR("couldn't find host_wake irq\n");
652                 ret = -ENODEV;
653                 goto free_bt_ext_wake;
654         }
655         if (res->flags & IORESOURCE_IRQ_LOWEDGE)
656                 bsi->irq_polarity = POLARITY_LOW;/*low edge (falling edge)*/
657         else
658                 bsi->irq_polarity = POLARITY_HIGH;/*anything else*/
659
660         wake_lock_init(&bsi->wake_lock, WAKE_LOCK_SUSPEND, "bluesleep");
661         clear_bit(BT_SUSPEND, &flags);
662
663         if (bsi->irq_polarity == POLARITY_LOW) {
664                 ret = request_irq(bsi->host_wake_irq, bluesleep_hostwake_isr,
665                                 IRQF_DISABLED | IRQF_TRIGGER_FALLING,
666                                 "bluetooth hostwake", NULL);
667         } else {
668                 ret = request_irq(bsi->host_wake_irq, bluesleep_hostwake_isr,
669                                 IRQF_DISABLED | IRQF_TRIGGER_RISING,
670                                 "bluetooth hostwake", NULL);
671         }
672         if (ret  < 0) {
673                 BT_ERR("Couldn't acquire BT_HOST_WAKE IRQ");
674                 goto free_bt_ext_wake;
675         }
676
677         return 0;
678
679 free_bt_ext_wake:
680         gpio_free(bsi->ext_wake);
681 free_bt_host_wake:
682         gpio_free(bsi->host_wake);
683 free_bsi:
684         kfree(bsi);
685         return ret;
686 }
687
688 static int bluesleep_remove(struct platform_device *pdev)
689 {
690         free_irq(bsi->host_wake_irq, NULL);
691         gpio_free(bsi->host_wake);
692         gpio_free(bsi->ext_wake);
693         wake_lock_destroy(&bsi->wake_lock);
694         kfree(bsi);
695         return 0;
696 }
697
698
699 static int bluesleep_resume(struct platform_device *pdev)
700 {
701         if (test_bit(BT_SUSPEND, &flags)) {
702                 BT_DBG("bluesleep resuming...\n");
703         if ((bsi->uport != NULL) &&
704                 (gpio_get_value(bsi->host_wake) == bsi->irq_polarity)) {
705                         BT_DBG("bluesleep resume form BT event...\n");
706                         tegra_uart_request_clock_on(bsi->uport);
707                         tegra_uart_set_mctrl(bsi->uport, TIOCM_RTS);
708                 }
709                 clear_bit(BT_SUSPEND, &flags);
710         }
711         return 0;
712 }
713
714 static int bluesleep_suspend(struct platform_device *pdev, pm_message_t state)
715 {
716         BT_DBG("bluesleep suspending...\n");
717         set_bit(BT_SUSPEND, &flags);
718         return 0;
719 }
720
721 static struct platform_driver bluesleep_driver = {
722         .probe = bluesleep_probe,
723         .remove = bluesleep_remove,
724         .suspend = bluesleep_suspend,
725         .resume = bluesleep_resume,
726         .driver = {
727                 .name = "bluesleep",
728                 .owner = THIS_MODULE,
729         },
730 };
731 /**
732  * Initializes the module.
733  * @return On success, 0. On error, -1, and <code>errno</code> is set
734  * appropriately.
735  */
736 static int __init bluesleep_init(void)
737 {
738         int retval;
739         struct proc_dir_entry *ent;
740
741         BT_INFO("BlueSleep Mode Driver Ver %s", VERSION);
742
743         retval = platform_driver_register(&bluesleep_driver);
744         if (retval)
745                 return retval;
746
747         if (bsi == NULL)
748                 return 0;
749
750         bluesleep_hdev = NULL;
751
752         bluetooth_dir = proc_mkdir("bluetooth", NULL);
753         if (bluetooth_dir == NULL) {
754                 BT_ERR("Unable to create /proc/bluetooth directory");
755                 return -ENOMEM;
756         }
757
758         sleep_dir = proc_mkdir("sleep", bluetooth_dir);
759         if (sleep_dir == NULL) {
760                 BT_ERR("Unable to create /proc/%s directory", PROC_DIR);
761                 return -ENOMEM;
762         }
763
764         /* Creating read/write "btwake" entry */
765         ent = create_proc_entry("btwake", 0, sleep_dir);
766         if (ent == NULL) {
767                 BT_ERR("Unable to create /proc/%s/btwake entry", PROC_DIR);
768                 retval = -ENOMEM;
769                 goto fail;
770         }
771         ent->read_proc = bluepower_read_proc_btwake;
772         ent->write_proc = bluepower_write_proc_btwake;
773
774         /* read only proc entries */
775         if (create_proc_read_entry("hostwake", 0, sleep_dir,
776                                 bluepower_read_proc_hostwake, NULL) == NULL) {
777                 BT_ERR("Unable to create /proc/%s/hostwake entry", PROC_DIR);
778                 retval = -ENOMEM;
779                 goto fail;
780         }
781
782         /* read/write proc entries */
783         ent = create_proc_entry("proto", 0, sleep_dir);
784         if (ent == NULL) {
785                 BT_ERR("Unable to create /proc/%s/proto entry", PROC_DIR);
786                 retval = -ENOMEM;
787                 goto fail;
788         }
789         ent->read_proc = bluesleep_read_proc_proto;
790         ent->write_proc = bluesleep_write_proc_proto;
791
792         /* read only proc entries */
793         if (create_proc_read_entry("asleep", 0,
794                         sleep_dir, bluesleep_read_proc_asleep, NULL) == NULL) {
795                 BT_ERR("Unable to create /proc/%s/asleep entry", PROC_DIR);
796                 retval = -ENOMEM;
797                 goto fail;
798         }
799
800         flags = 0; /* clear all status bits */
801
802         /* Initialize spinlock. */
803         spin_lock_init(&rw_lock);
804
805         /* assert bt wake */
806         if (bsi->has_ext_wake == 1) {
807                 /* Initialize timer */
808                 init_timer(&tx_timer);
809                 tx_timer.function = bluesleep_tx_timer_expire;
810                 tx_timer.data = 0;
811
812                 /* initialize host wake tasklet */
813                 tasklet_init(&hostwake_task, bluesleep_hostwake_task, 0);
814
815                 gpio_set_value(bsi->ext_wake, 1);
816                 set_bit(BT_EXT_WAKE, &flags);
817         }
818         hci_register_notifier(&hci_event_nblock);
819
820         return 0;
821
822 fail:
823         remove_proc_entry("asleep", sleep_dir);
824         remove_proc_entry("proto", sleep_dir);
825         remove_proc_entry("hostwake", sleep_dir);
826         remove_proc_entry("btwake", sleep_dir);
827         remove_proc_entry("sleep", bluetooth_dir);
828         remove_proc_entry("bluetooth", 0);
829         return retval;
830 }
831
832 /**
833  * Cleans up the module.
834  */
835 static void __exit bluesleep_exit(void)
836 {
837         if (bsi == NULL)
838                 return;
839
840         /* assert bt wake */
841         if (bsi->has_ext_wake == 1) {
842                 gpio_set_value(bsi->ext_wake, 1);
843                 del_timer(&tx_timer);
844                 if (test_bit(BT_ASLEEP, &flags))
845                         hsuart_power(1);
846                 set_bit(BT_EXT_WAKE, &flags);
847         }
848         if (test_bit(BT_PROTO, &flags)) {
849                 if (disable_irq_wake(bsi->host_wake_irq))
850                         BT_ERR("Couldn't disable hostwake IRQ wakeup mode\n");
851                 free_irq(bsi->host_wake_irq, NULL);
852         }
853
854         hci_unregister_notifier(&hci_event_nblock);
855         platform_driver_unregister(&bluesleep_driver);
856
857         remove_proc_entry("asleep", sleep_dir);
858         remove_proc_entry("proto", sleep_dir);
859         remove_proc_entry("hostwake", sleep_dir);
860         remove_proc_entry("btwake", sleep_dir);
861         remove_proc_entry("sleep", bluetooth_dir);
862         remove_proc_entry("bluetooth", 0);
863 }
864
865 module_init(bluesleep_init);
866 module_exit(bluesleep_exit);
867
868 MODULE_DESCRIPTION("Bluetooth Sleep Mode Driver ver %s " VERSION);
869 #ifdef MODULE_LICENSE
870 MODULE_LICENSE("GPL");
871 #endif
872