omap24xx: Add 3.1 patchset.
[openwrt/svn-archive/archive.git] / target / linux / omap24xx / patches-3.1 / 400-bluetooth-hci_h4p.patch
1 ---
2 drivers/bluetooth/Kconfig | 10
3 drivers/bluetooth/Makefile | 1
4 drivers/bluetooth/hci_h4p/Makefile | 7
5 drivers/bluetooth/hci_h4p/core.c | 1043 ++++++++++++++++++++++++++++++++++++
6 drivers/bluetooth/hci_h4p/fw-csr.c | 149 +++++
7 drivers/bluetooth/hci_h4p/fw-ti.c | 90 +++
8 drivers/bluetooth/hci_h4p/fw.c | 155 +++++
9 drivers/bluetooth/hci_h4p/hci_h4p.h | 183 ++++++
10 drivers/bluetooth/hci_h4p/sysfs.c | 84 ++
11 drivers/bluetooth/hci_h4p/uart.c | 169 +++++
12 10 files changed, 1891 insertions(+)
13
14 --- /dev/null
15 +++ b/drivers/bluetooth/hci_h4p/core.c
16 @@ -0,0 +1,1043 @@
17 +/*
18 + * This file is part of hci_h4p bluetooth driver
19 + *
20 + * Copyright (C) 2005, 2006 Nokia Corporation.
21 + *
22 + * Contact: Ville Tervo <ville.tervo@nokia.com>
23 + *
24 + * This program is free software; you can redistribute it and/or
25 + * modify it under the terms of the GNU General Public License
26 + * version 2 as published by the Free Software Foundation.
27 + *
28 + * This program is distributed in the hope that it will be useful, but
29 + * WITHOUT ANY WARRANTY; without even the implied warranty of
30 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
31 + * General Public License for more details.
32 + *
33 + * You should have received a copy of the GNU General Public License
34 + * along with this program; if not, write to the Free Software
35 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
36 + * 02110-1301 USA
37 + *
38 + */
39 +
40 +#include <linux/module.h>
41 +
42 +#include <linux/kernel.h>
43 +#include <linux/init.h>
44 +#include <linux/errno.h>
45 +#include <linux/delay.h>
46 +#include <linux/spinlock.h>
47 +#include <linux/serial_reg.h>
48 +#include <linux/skbuff.h>
49 +#include <linux/timer.h>
50 +#include <linux/device.h>
51 +#include <linux/platform_device.h>
52 +#include <linux/clk.h>
53 +#include <linux/gpio.h>
54 +
55 +#include <mach/hardware.h>
56 +#include <mach/board.h>
57 +#include <mach/irqs.h>
58 +#include <plat/serial.h>
59 +
60 +#include <net/bluetooth/bluetooth.h>
61 +#include <net/bluetooth/hci_core.h>
62 +#include <net/bluetooth/hci.h>
63 +
64 +#include "hci_h4p.h"
65 +
66 +#define PM_TIMEOUT 200
67 +
68 +struct omap_bluetooth_config {
69 + u8 chip_type;
70 + u8 bt_wakeup_gpio;
71 + u8 host_wakeup_gpio;
72 + u8 reset_gpio;
73 + u8 bt_uart;
74 + u8 bd_addr[6];
75 + u8 bt_sysclk;
76 +};
77 +
78 +/* This should be used in function that cannot release clocks */
79 +static void hci_h4p_set_clk(struct hci_h4p_info *info, int *clock, int enable)
80 +{
81 + unsigned long flags;
82 +
83 + spin_lock_irqsave(&info->clocks_lock, flags);
84 + if (enable && !*clock) {
85 + NBT_DBG_POWER("Enabling %p\n", clock);
86 + clk_enable(info->uart_fclk);
87 +#ifdef CONFIG_ARCH_OMAP2
88 + if (cpu_is_omap24xx()) {
89 + clk_enable(info->uart_iclk);
90 + //omap2_block_sleep();
91 + }
92 +#endif
93 + }
94 + if (!enable && *clock) {
95 + NBT_DBG_POWER("Disabling %p\n", clock);
96 + clk_disable(info->uart_fclk);
97 +#ifdef CONFIG_ARCH_OMAP2
98 + if (cpu_is_omap24xx()) {
99 + clk_disable(info->uart_iclk);
100 + //omap2_allow_sleep();
101 + }
102 +#endif
103 + }
104 +
105 + *clock = enable;
106 + spin_unlock_irqrestore(&info->clocks_lock, flags);
107 +}
108 +
109 +/* Power management functions */
110 +static void hci_h4p_disable_tx(struct hci_h4p_info *info)
111 +{
112 + NBT_DBG_POWER("\n");
113 +
114 + if (!info->pm_enabled)
115 + return;
116 +
117 + mod_timer(&info->tx_pm_timer, jiffies + msecs_to_jiffies(PM_TIMEOUT));
118 +}
119 +
120 +static void hci_h4p_enable_tx(struct hci_h4p_info *info)
121 +{
122 + NBT_DBG_POWER("\n");
123 +
124 + if (!info->pm_enabled)
125 + return;
126 +
127 + del_timer_sync(&info->tx_pm_timer);
128 + if (info->tx_pm_enabled) {
129 + info->tx_pm_enabled = 0;
130 + hci_h4p_set_clk(info, &info->tx_clocks_en, 1);
131 + gpio_set_value(info->bt_wakeup_gpio, 1);
132 + }
133 +}
134 +
135 +static void hci_h4p_tx_pm_timer(unsigned long data)
136 +{
137 + struct hci_h4p_info *info;
138 +
139 + NBT_DBG_POWER("\n");
140 +
141 + info = (struct hci_h4p_info *)data;
142 +
143 + if (hci_h4p_inb(info, UART_LSR) & UART_LSR_TEMT) {
144 + gpio_set_value(info->bt_wakeup_gpio, 0);
145 + hci_h4p_set_clk(info, &info->tx_clocks_en, 0);
146 + info->tx_pm_enabled = 1;
147 + }
148 + else {
149 + mod_timer(&info->tx_pm_timer, jiffies + msecs_to_jiffies(PM_TIMEOUT));
150 + }
151 +}
152 +
153 +static void hci_h4p_disable_rx(struct hci_h4p_info *info)
154 +{
155 + if (!info->pm_enabled)
156 + return;
157 +
158 + mod_timer(&info->rx_pm_timer, jiffies + msecs_to_jiffies(PM_TIMEOUT));
159 +}
160 +
161 +static void hci_h4p_enable_rx(struct hci_h4p_info *info)
162 +{
163 + unsigned long flags;
164 +
165 + if (!info->pm_enabled)
166 + return;
167 +
168 + del_timer_sync(&info->rx_pm_timer);
169 + spin_lock_irqsave(&info->lock, flags);
170 + if (info->rx_pm_enabled) {
171 + hci_h4p_set_clk(info, &info->rx_clocks_en, 1);
172 + hci_h4p_outb(info, UART_IER, hci_h4p_inb(info, UART_IER) | UART_IER_RDI);
173 + __hci_h4p_set_auto_ctsrts(info, 1, UART_EFR_RTS);
174 + info->rx_pm_enabled = 0;
175 + }
176 + spin_unlock_irqrestore(&info->lock, flags);
177 +}
178 +
179 +static void hci_h4p_rx_pm_timer(unsigned long data)
180 +{
181 + unsigned long flags;
182 + struct hci_h4p_info *info = (struct hci_h4p_info *)data;
183 +
184 + spin_lock_irqsave(&info->lock, flags);
185 + if (!(hci_h4p_inb(info, UART_LSR) & UART_LSR_DR)) {
186 + __hci_h4p_set_auto_ctsrts(info, 0, UART_EFR_RTS);
187 + hci_h4p_set_rts(info, 0);
188 + hci_h4p_outb(info, UART_IER, hci_h4p_inb(info, UART_IER) & ~UART_IER_RDI);
189 + hci_h4p_set_clk(info, &info->rx_clocks_en, 0);
190 + info->rx_pm_enabled = 1;
191 + }
192 + else {
193 + mod_timer(&info->rx_pm_timer, jiffies + msecs_to_jiffies(PM_TIMEOUT));
194 + }
195 + spin_unlock_irqrestore(&info->lock, flags);
196 +}
197 +
198 +/* Negotiation functions */
199 +int hci_h4p_send_alive_packet(struct hci_h4p_info *info)
200 +{
201 + NBT_DBG("Sending alive packet\n");
202 +
203 + if (!info->alive_cmd_skb)
204 + return -EINVAL;
205 +
206 + /* Keep reference to buffer so we can reuse it */
207 + info->alive_cmd_skb = skb_get(info->alive_cmd_skb);
208 +
209 + skb_queue_tail(&info->txq, info->alive_cmd_skb);
210 + tasklet_schedule(&info->tx_task);
211 +
212 + NBT_DBG("Alive packet sent\n");
213 +
214 + return 0;
215 +}
216 +
217 +static void hci_h4p_alive_packet(struct hci_h4p_info *info, struct sk_buff *skb)
218 +{
219 + NBT_DBG("Received alive packet\n");
220 + if (skb->data[1] == 0xCC) {
221 + complete(&info->init_completion);
222 + }
223 +
224 + kfree_skb(skb);
225 +}
226 +
227 +static int hci_h4p_send_negotiation(struct hci_h4p_info *info, struct sk_buff *skb)
228 +{
229 + NBT_DBG("Sending negotiation..\n");
230 +
231 + hci_h4p_change_speed(info, INIT_SPEED);
232 +
233 + info->init_error = 0;
234 + init_completion(&info->init_completion);
235 + skb_queue_tail(&info->txq, skb);
236 + tasklet_schedule(&info->tx_task);
237 +
238 + if (!wait_for_completion_interruptible_timeout(&info->init_completion,
239 + msecs_to_jiffies(1000)))
240 + return -ETIMEDOUT;
241 +
242 + NBT_DBG("Negotiation sent\n");
243 + return info->init_error;
244 +}
245 +
246 +static void hci_h4p_negotiation_packet(struct hci_h4p_info *info,
247 + struct sk_buff *skb)
248 +{
249 + int err = 0;
250 +
251 + if (skb->data[1] == 0x20) {
252 + /* Change to operational settings */
253 + hci_h4p_set_rts(info, 0);
254 +
255 + err = hci_h4p_wait_for_cts(info, 0, 100);
256 + if (err < 0)
257 + goto neg_ret;
258 +
259 + hci_h4p_change_speed(info, MAX_BAUD_RATE);
260 +
261 + err = hci_h4p_wait_for_cts(info, 1, 100);
262 + if (err < 0)
263 + goto neg_ret;
264 +
265 + hci_h4p_set_auto_ctsrts(info, 1, UART_EFR_CTS | UART_EFR_RTS);
266 +
267 + err = hci_h4p_send_alive_packet(info);
268 + if (err < 0)
269 + goto neg_ret;
270 + } else {
271 + dev_err(info->dev, "Could not negotiate hci_h4p settings\n");
272 + err = -EINVAL;
273 + goto neg_ret;
274 + }
275 +
276 + kfree_skb(skb);
277 + return;
278 +
279 +neg_ret:
280 + info->init_error = err;
281 + complete(&info->init_completion);
282 + kfree_skb(skb);
283 +}
284 +
285 +/* H4 packet handling functions */
286 +static int hci_h4p_get_hdr_len(struct hci_h4p_info *info, u8 pkt_type)
287 +{
288 + long retval;
289 +
290 + switch (pkt_type) {
291 + case H4_EVT_PKT:
292 + retval = HCI_EVENT_HDR_SIZE;
293 + break;
294 + case H4_ACL_PKT:
295 + retval = HCI_ACL_HDR_SIZE;
296 + break;
297 + case H4_SCO_PKT:
298 + retval = HCI_SCO_HDR_SIZE;
299 + break;
300 + case H4_NEG_PKT:
301 + retval = 11;
302 + break;
303 + case H4_ALIVE_PKT:
304 + retval = 3;
305 + break;
306 + default:
307 + dev_err(info->dev, "Unknown H4 packet type 0x%.2x\n", pkt_type);
308 + retval = -1;
309 + break;
310 + }
311 +
312 + return retval;
313 +}
314 +
315 +static unsigned int hci_h4p_get_data_len(struct hci_h4p_info *info,
316 + struct sk_buff *skb)
317 +{
318 + long retval = -1;
319 + struct hci_event_hdr *evt_hdr;
320 + struct hci_acl_hdr *acl_hdr;
321 + struct hci_sco_hdr *sco_hdr;
322 +
323 + switch (bt_cb(skb)->pkt_type) {
324 + case H4_EVT_PKT:
325 + evt_hdr = (struct hci_event_hdr *)skb->data;
326 + retval = evt_hdr->plen;
327 + break;
328 + case H4_ACL_PKT:
329 + acl_hdr = (struct hci_acl_hdr *)skb->data;
330 + retval = le16_to_cpu(acl_hdr->dlen);
331 + break;
332 + case H4_SCO_PKT:
333 + sco_hdr = (struct hci_sco_hdr *)skb->data;
334 + retval = sco_hdr->dlen;
335 + break;
336 + case H4_NEG_PKT:
337 + retval = 0;
338 + break;
339 + case H4_ALIVE_PKT:
340 + retval = 0;
341 + break;
342 + }
343 +
344 + return retval;
345 +}
346 +
347 +static inline void hci_h4p_recv_frame(struct hci_h4p_info *info,
348 + struct sk_buff *skb)
349 +{
350 +
351 + if (unlikely(!test_bit(HCI_RUNNING, &info->hdev->flags))) {
352 + NBT_DBG("fw_event\n");
353 + hci_h4p_parse_fw_event(info, skb);
354 + } else {
355 + hci_recv_frame(skb);
356 + NBT_DBG("Frame sent to upper layer\n");
357 + }
358 +}
359 +
360 +static void hci_h4p_rx_tasklet(unsigned long data)
361 +{
362 + u8 byte;
363 + unsigned long flags;
364 + struct hci_h4p_info *info = (struct hci_h4p_info *)data;
365 +
366 + NBT_DBG("tasklet woke up\n");
367 + NBT_DBG_TRANSFER("rx_tasklet woke up\ndata ");
368 +
369 + while (hci_h4p_inb(info, UART_LSR) & UART_LSR_DR) {
370 + byte = hci_h4p_inb(info, UART_RX);
371 + if (info->garbage_bytes) {
372 + info->garbage_bytes--;
373 + continue;
374 + }
375 + if (info->rx_skb == NULL) {
376 + info->rx_skb = bt_skb_alloc(HCI_MAX_FRAME_SIZE, GFP_ATOMIC | GFP_DMA);
377 + if (!info->rx_skb) {
378 + dev_err(info->dev, "Can't allocate memory for new packet\n");
379 + goto finish_task;
380 + }
381 + info->rx_state = WAIT_FOR_PKT_TYPE;
382 + info->rx_skb->dev = (void *)info->hdev;
383 + }
384 + info->hdev->stat.byte_rx++;
385 + NBT_DBG_TRANSFER_NF("0x%.2x ", byte);
386 + switch (info->rx_state) {
387 + case WAIT_FOR_PKT_TYPE:
388 + bt_cb(info->rx_skb)->pkt_type = byte;
389 + info->rx_count = hci_h4p_get_hdr_len(info, byte);
390 + if (info->rx_count < 0) {
391 + info->hdev->stat.err_rx++;
392 + kfree_skb(info->rx_skb);
393 + info->rx_skb = NULL;
394 + } else {
395 + info->rx_state = WAIT_FOR_HEADER;
396 + }
397 + break;
398 + case WAIT_FOR_HEADER:
399 + info->rx_count--;
400 + *skb_put(info->rx_skb, 1) = byte;
401 + if (info->rx_count == 0) {
402 + info->rx_count = hci_h4p_get_data_len(info, info->rx_skb);
403 + if (info->rx_count > skb_tailroom(info->rx_skb)) {
404 + dev_err(info->dev, "Frame is %ld bytes too long.\n",
405 + info->rx_count - skb_tailroom(info->rx_skb));
406 + kfree_skb(info->rx_skb);
407 + info->rx_skb = NULL;
408 + info->garbage_bytes = info->rx_count - skb_tailroom(info->rx_skb);
409 + break;
410 + }
411 + info->rx_state = WAIT_FOR_DATA;
412 +
413 + if (bt_cb(info->rx_skb)->pkt_type == H4_NEG_PKT) {
414 + hci_h4p_negotiation_packet(info, info->rx_skb);
415 + info->rx_skb = NULL;
416 + info->rx_state = WAIT_FOR_PKT_TYPE;
417 + goto finish_task;
418 + }
419 + if (bt_cb(info->rx_skb)->pkt_type == H4_ALIVE_PKT) {
420 + hci_h4p_alive_packet(info, info->rx_skb);
421 + info->rx_skb = NULL;
422 + info->rx_state = WAIT_FOR_PKT_TYPE;
423 + goto finish_task;
424 + }
425 + }
426 + break;
427 + case WAIT_FOR_DATA:
428 + info->rx_count--;
429 + *skb_put(info->rx_skb, 1) = byte;
430 + if (info->rx_count == 0) {
431 + /* H4+ devices should allways send word aligned packets */
432 + if (!(info->rx_skb->len % 2)) {
433 + info->garbage_bytes++;
434 + }
435 + hci_h4p_recv_frame(info, info->rx_skb);
436 + info->rx_skb = NULL;
437 + }
438 + break;
439 + default:
440 + WARN_ON(1);
441 + break;
442 + }
443 + }
444 +
445 +finish_task:
446 + spin_lock_irqsave(&info->lock, flags);
447 + hci_h4p_outb(info, UART_IER, hci_h4p_inb(info, UART_IER) | UART_IER_RDI);
448 + spin_unlock_irqrestore(&info->lock, flags);
449 +
450 + NBT_DBG_TRANSFER_NF("\n");
451 + NBT_DBG("rx_ended\n");
452 +}
453 +
454 +static void hci_h4p_tx_tasklet(unsigned long data)
455 +{
456 + unsigned int sent = 0;
457 + unsigned long flags;
458 + struct sk_buff *skb;
459 + struct hci_h4p_info *info = (struct hci_h4p_info *)data;
460 +
461 + NBT_DBG("tasklet woke up\n");
462 + NBT_DBG_TRANSFER("tx_tasklet woke up\n data ");
463 +
464 + skb = skb_dequeue(&info->txq);
465 + if (!skb) {
466 + /* No data in buffer */
467 + NBT_DBG("skb ready\n");
468 + hci_h4p_disable_tx(info);
469 + return;
470 + }
471 +
472 + /* Copy data to tx fifo */
473 + while (!(hci_h4p_inb(info, UART_OMAP_SSR) & UART_OMAP_SSR_TXFULL) &&
474 + (sent < skb->len)) {
475 + NBT_DBG_TRANSFER_NF("0x%.2x ", skb->data[sent]);
476 + hci_h4p_outb(info, UART_TX, skb->data[sent]);
477 + sent++;
478 + }
479 +
480 + info->hdev->stat.byte_tx += sent;
481 + NBT_DBG_TRANSFER_NF("\n");
482 + if (skb->len == sent) {
483 + kfree_skb(skb);
484 + } else {
485 + skb_pull(skb, sent);
486 + skb_queue_head(&info->txq, skb);
487 + }
488 +
489 + spin_lock_irqsave(&info->lock, flags);
490 + hci_h4p_outb(info, UART_IER, hci_h4p_inb(info, UART_IER) | UART_IER_THRI);
491 + spin_unlock_irqrestore(&info->lock, flags);
492 +}
493 +
494 +static irqreturn_t hci_h4p_interrupt(int irq, void *data)
495 +{
496 + struct hci_h4p_info *info = (struct hci_h4p_info *)data;
497 + u8 iir, msr;
498 + int ret;
499 + unsigned long flags;
500 +
501 + ret = IRQ_NONE;
502 +
503 + iir = hci_h4p_inb(info, UART_IIR);
504 + if (iir & UART_IIR_NO_INT) {
505 + dev_err(info->dev, "Interrupt but no reason irq 0x%.2x\n", iir);
506 + return IRQ_HANDLED;
507 + }
508 +
509 + NBT_DBG("In interrupt handler iir 0x%.2x\n", iir);
510 +
511 + iir &= UART_IIR_ID;
512 +
513 + if (iir == UART_IIR_MSI) {
514 + msr = hci_h4p_inb(info, UART_MSR);
515 + ret = IRQ_HANDLED;
516 + }
517 + if (iir == UART_IIR_RLSI) {
518 + hci_h4p_inb(info, UART_RX);
519 + hci_h4p_inb(info, UART_LSR);
520 + ret = IRQ_HANDLED;
521 + }
522 +
523 + if (iir == UART_IIR_RDI) {
524 + spin_lock_irqsave(&info->lock, flags);
525 + hci_h4p_outb(info, UART_IER, hci_h4p_inb(info, UART_IER) & ~UART_IER_RDI);
526 + spin_unlock_irqrestore(&info->lock, flags);
527 + tasklet_schedule(&info->rx_task);
528 + ret = IRQ_HANDLED;
529 + }
530 +
531 + if (iir == UART_IIR_THRI) {
532 + spin_lock_irqsave(&info->lock, flags);
533 + hci_h4p_outb(info, UART_IER, hci_h4p_inb(info, UART_IER) & ~UART_IER_THRI);
534 + spin_unlock_irqrestore(&info->lock, flags);
535 + tasklet_schedule(&info->tx_task);
536 + ret = IRQ_HANDLED;
537 + }
538 +
539 + return ret;
540 +}
541 +
542 +static irqreturn_t hci_h4p_wakeup_interrupt(int irq, void *dev_inst)
543 +{
544 + struct hci_h4p_info *info = dev_inst;
545 + int should_wakeup;
546 + struct hci_dev *hdev;
547 +
548 + if (!info->hdev)
549 + return IRQ_HANDLED;
550 +
551 + hdev = info->hdev;
552 +
553 + if (!test_bit(HCI_RUNNING, &hdev->flags))
554 + return IRQ_HANDLED;
555 +
556 + should_wakeup = gpio_get_value(info->host_wakeup_gpio);
557 + NBT_DBG_POWER("gpio interrupt %d\n", should_wakeup);
558 + if (should_wakeup) {
559 + hci_h4p_enable_rx(info);
560 + } else {
561 + hci_h4p_disable_rx(info);
562 + }
563 +
564 + return IRQ_HANDLED;
565 +}
566 +
567 +static int hci_h4p_reset(struct hci_h4p_info *info)
568 +{
569 + int err;
570 +
571 + hci_h4p_init_uart(info);
572 + hci_h4p_set_rts(info, 0);
573 +
574 + gpio_set_value(info->reset_gpio, 0);
575 + msleep(100);
576 + gpio_set_value(info->bt_wakeup_gpio, 1);
577 + gpio_set_value(info->reset_gpio, 1);
578 + msleep(100);
579 +
580 + err = hci_h4p_wait_for_cts(info, 1, 10);
581 + if (err < 0) {
582 + dev_err(info->dev, "No cts from bt chip\n");
583 + return err;
584 + }
585 +
586 + hci_h4p_set_rts(info, 1);
587 +
588 + return 0;
589 +}
590 +
591 +/* hci callback functions */
592 +static int hci_h4p_hci_flush(struct hci_dev *hdev)
593 +{
594 + struct hci_h4p_info *info;
595 + info = hdev->driver_data;
596 +
597 + skb_queue_purge(&info->txq);
598 +
599 + return 0;
600 +}
601 +
602 +static int hci_h4p_hci_open(struct hci_dev *hdev)
603 +{
604 + struct hci_h4p_info *info;
605 + int err;
606 + struct sk_buff *neg_cmd_skb;
607 + struct sk_buff_head fw_queue;
608 +
609 + info = hdev->driver_data;
610 +
611 + if (test_bit(HCI_RUNNING, &hdev->flags))
612 + return 0;
613 +
614 + skb_queue_head_init(&fw_queue);
615 + err = hci_h4p_read_fw(info, &fw_queue);
616 + if (err < 0) {
617 + dev_err(info->dev, "Cannot read firmware\n");
618 + return err;
619 + }
620 + neg_cmd_skb = skb_dequeue(&fw_queue);
621 + if (!neg_cmd_skb) {
622 + err = -EPROTO;
623 + goto err_clean;
624 + }
625 + info->alive_cmd_skb = skb_dequeue(&fw_queue);
626 + if (!info->alive_cmd_skb) {
627 + err = -EPROTO;
628 + goto err_clean;
629 + }
630 +
631 + hci_h4p_set_clk(info, &info->tx_clocks_en, 1);
632 + hci_h4p_set_clk(info, &info->rx_clocks_en, 1);
633 +
634 + tasklet_enable(&info->tx_task);
635 + tasklet_enable(&info->rx_task);
636 + info->rx_state = WAIT_FOR_PKT_TYPE;
637 + info->rx_count = 0;
638 + info->garbage_bytes = 0;
639 + info->rx_skb = NULL;
640 + info->pm_enabled = 0;
641 + init_completion(&info->fw_completion);
642 +
643 + err = hci_h4p_reset(info);
644 + if (err < 0)
645 + goto err_clean;
646 +
647 + err = hci_h4p_send_negotiation(info, neg_cmd_skb);
648 + neg_cmd_skb = NULL;
649 + if (err < 0)
650 + goto err_clean;
651 +
652 + err = hci_h4p_send_fw(info, &fw_queue);
653 + if (err < 0) {
654 + dev_err(info->dev, "Sending firmware failed.\n");
655 + goto err_clean;
656 + }
657 +
658 + kfree_skb(info->alive_cmd_skb);
659 + info->alive_cmd_skb = NULL;
660 + info->pm_enabled = 1;
661 + info->tx_pm_enabled = 1;
662 + info->rx_pm_enabled = 0;
663 + set_bit(HCI_RUNNING, &hdev->flags);
664 +
665 + NBT_DBG("hci up and running\n");
666 + return 0;
667 +
668 +err_clean:
669 + hci_h4p_hci_flush(hdev);
670 + tasklet_disable(&info->tx_task);
671 + tasklet_disable(&info->rx_task);
672 + hci_h4p_reset_uart(info);
673 + hci_h4p_set_clk(info, &info->tx_clocks_en, 0);
674 + hci_h4p_set_clk(info, &info->rx_clocks_en, 0);
675 + gpio_set_value(info->reset_gpio, 0);
676 + gpio_set_value(info->bt_wakeup_gpio, 0);
677 + skb_queue_purge(&fw_queue);
678 + kfree_skb(neg_cmd_skb);
679 + neg_cmd_skb = NULL;
680 + kfree_skb(info->alive_cmd_skb);
681 + info->alive_cmd_skb = NULL;
682 + kfree_skb(info->rx_skb);
683 +
684 + return err;
685 +}
686 +
687 +static int hci_h4p_hci_close(struct hci_dev *hdev)
688 +{
689 + struct hci_h4p_info *info = hdev->driver_data;
690 +
691 + if (!test_and_clear_bit(HCI_RUNNING, &hdev->flags))
692 + return 0;
693 +
694 + hci_h4p_hci_flush(hdev);
695 + del_timer_sync(&info->tx_pm_timer);
696 + del_timer_sync(&info->rx_pm_timer);
697 + tasklet_disable(&info->tx_task);
698 + tasklet_disable(&info->rx_task);
699 + hci_h4p_set_clk(info, &info->tx_clocks_en, 1);
700 + hci_h4p_set_clk(info, &info->rx_clocks_en, 1);
701 + hci_h4p_reset_uart(info);
702 + hci_h4p_set_clk(info, &info->tx_clocks_en, 0);
703 + hci_h4p_set_clk(info, &info->rx_clocks_en, 0);
704 + gpio_set_value(info->reset_gpio, 0);
705 + gpio_set_value(info->bt_wakeup_gpio, 0);
706 + kfree_skb(info->rx_skb);
707 +
708 + return 0;
709 +}
710 +
711 +static void hci_h4p_hci_destruct(struct hci_dev *hdev)
712 +{
713 +}
714 +
715 +static int hci_h4p_hci_send_frame(struct sk_buff *skb)
716 +{
717 + struct hci_h4p_info *info;
718 + struct hci_dev *hdev = (struct hci_dev *)skb->dev;
719 + int err = 0;
720 +
721 + if (!hdev) {
722 + printk(KERN_WARNING "hci_h4p: Frame for unknown device\n");
723 + return -ENODEV;
724 + }
725 +
726 + NBT_DBG("dev %p, skb %p\n", hdev, skb);
727 +
728 + info = hdev->driver_data;
729 +
730 + if (!test_bit(HCI_RUNNING, &hdev->flags)) {
731 + dev_warn(info->dev, "Frame for non-running device\n");
732 + return -EIO;
733 + }
734 +
735 + switch (bt_cb(skb)->pkt_type) {
736 + case HCI_COMMAND_PKT:
737 + hdev->stat.cmd_tx++;
738 + break;
739 + case HCI_ACLDATA_PKT:
740 + hdev->stat.acl_tx++;
741 + break;
742 + case HCI_SCODATA_PKT:
743 + hdev->stat.sco_tx++;
744 + break;
745 + }
746 +
747 + /* Push frame type to skb */
748 + *skb_push(skb, 1) = (bt_cb(skb)->pkt_type);
749 + /* We should allways send word aligned data to h4+ devices */
750 + if (skb->len % 2) {
751 + err = skb_pad(skb, 1);
752 + }
753 + if (err)
754 + return err;
755 +
756 + hci_h4p_enable_tx(info);
757 + skb_queue_tail(&info->txq, skb);
758 + tasklet_schedule(&info->tx_task);
759 +
760 + return 0;
761 +}
762 +
763 +static int hci_h4p_hci_ioctl(struct hci_dev *hdev, unsigned int cmd, unsigned long arg)
764 +{
765 + return -ENOIOCTLCMD;
766 +}
767 +
768 +static int hci_h4p_register_hdev(struct hci_h4p_info *info)
769 +{
770 + struct hci_dev *hdev;
771 +
772 + /* Initialize and register HCI device */
773 +
774 + hdev = hci_alloc_dev();
775 + if (!hdev) {
776 + dev_err(info->dev, "Can't allocate memory for device\n");
777 + return -ENOMEM;
778 + }
779 + info->hdev = hdev;
780 +
781 + hdev->dev_type = HCI_UART;
782 + hdev->driver_data = info;
783 +
784 + hdev->open = hci_h4p_hci_open;
785 + hdev->close = hci_h4p_hci_close;
786 + hdev->flush = hci_h4p_hci_flush;
787 + hdev->send = hci_h4p_hci_send_frame;
788 + hdev->destruct = hci_h4p_hci_destruct;
789 + hdev->ioctl = hci_h4p_hci_ioctl;
790 +
791 + hdev->owner = THIS_MODULE;
792 +
793 + if (hci_register_dev(hdev) < 0) {
794 + dev_err(info->dev, "hci_h4p: Can't register HCI device %s.\n", hdev->name);
795 + return -ENODEV;
796 + }
797 +
798 + return 0;
799 +}
800 +
801 +static int hci_h4p_probe(struct platform_device *pdev)
802 +{
803 + struct omap_bluetooth_config *bt_config;
804 + struct hci_h4p_info *info;
805 + int irq, err;
806 +
807 + dev_info(&pdev->dev, "Registering HCI H4P device\n");
808 + info = kzalloc(sizeof(struct hci_h4p_info), GFP_KERNEL);
809 + if (!info)
810 + return -ENOMEM;
811 +
812 + info->dev = &pdev->dev;
813 + info->pm_enabled = 0;
814 + info->tx_pm_enabled = 0;
815 + info->rx_pm_enabled = 0;
816 + info->garbage_bytes = 0;
817 + info->tx_clocks_en = 0;
818 + info->rx_clocks_en = 0;
819 + tasklet_init(&info->tx_task, hci_h4p_tx_tasklet, (unsigned long)info);
820 + tasklet_init(&info->rx_task, hci_h4p_rx_tasklet, (unsigned long)info);
821 + /* hci_h4p_hci_open assumes that tasklet is disabled in startup */
822 + tasklet_disable(&info->tx_task);
823 + tasklet_disable(&info->rx_task);
824 + spin_lock_init(&info->lock);
825 + spin_lock_init(&info->clocks_lock);
826 + skb_queue_head_init(&info->txq);
827 + init_timer(&info->tx_pm_timer);
828 + info->tx_pm_timer.function = hci_h4p_tx_pm_timer;
829 + info->tx_pm_timer.data = (unsigned long)info;
830 + init_timer(&info->rx_pm_timer);
831 + info->rx_pm_timer.function = hci_h4p_rx_pm_timer;
832 + info->rx_pm_timer.data = (unsigned long)info;
833 +
834 + if (pdev->dev.platform_data == NULL) {
835 + dev_err(&pdev->dev, "Could not get Bluetooth config data\n");
836 + return -ENODATA;
837 + }
838 +
839 + bt_config = pdev->dev.platform_data;
840 + info->chip_type = bt_config->chip_type;
841 + info->bt_wakeup_gpio = bt_config->bt_wakeup_gpio;
842 + info->host_wakeup_gpio = bt_config->host_wakeup_gpio;
843 + info->reset_gpio = bt_config->reset_gpio;
844 + info->bt_sysclk = bt_config->bt_sysclk;
845 +
846 + NBT_DBG("RESET gpio: %d\n", info->reset_gpio);
847 + NBT_DBG("BTWU gpio: %d\n", info->bt_wakeup_gpio);
848 + NBT_DBG("HOSTWU gpio: %d\n", info->host_wakeup_gpio);
849 + NBT_DBG("Uart: %d\n", bt_config->bt_uart);
850 + NBT_DBG("sysclk: %d\n", info->bt_sysclk);
851 +
852 + err = gpio_request(info->reset_gpio, "BT reset");
853 + if (err < 0) {
854 + dev_err(&pdev->dev, "Cannot get GPIO line %d\n",
855 + info->reset_gpio);
856 + kfree(info);
857 + goto cleanup;
858 + }
859 +
860 + err = gpio_request(info->bt_wakeup_gpio, "BT wakeup");
861 + if (err < 0)
862 + {
863 + dev_err(info->dev, "Cannot get GPIO line 0x%d",
864 + info->bt_wakeup_gpio);
865 + gpio_free(info->reset_gpio);
866 + kfree(info);
867 + goto cleanup;
868 + }
869 +
870 + err = gpio_request(info->host_wakeup_gpio, "BT host wakeup");
871 + if (err < 0)
872 + {
873 + dev_err(info->dev, "Cannot get GPIO line %d",
874 + info->host_wakeup_gpio);
875 + gpio_free(info->reset_gpio);
876 + gpio_free(info->bt_wakeup_gpio);
877 + kfree(info);
878 + goto cleanup;
879 + }
880 +
881 + gpio_direction_output(info->reset_gpio, 0);
882 + gpio_direction_output(info->bt_wakeup_gpio, 0);
883 + gpio_direction_input(info->host_wakeup_gpio);
884 +
885 +//FIXME
886 +#if defined(CONFIG_ARCH_OMAP1)
887 +# define OMAP_UART1_BASE OMAP1_UART1_BASE
888 +# define OMAP_UART2_BASE OMAP1_UART2_BASE
889 +# define OMAP_UART3_BASE OMAP1_UART3_BASE
890 +#elif defined(CONFIG_ARCH_OMAP2)
891 +# define OMAP_UART1_BASE OMAP2_UART1_BASE
892 +# define OMAP_UART2_BASE OMAP2_UART2_BASE
893 +# define OMAP_UART3_BASE OMAP2_UART3_BASE
894 +#elif defined(CONFIG_ARCH_OMAP3)
895 +# define OMAP_UART1_BASE OMAP3_UART1_BASE
896 +# define OMAP_UART2_BASE OMAP3_UART2_BASE
897 +# define OMAP_UART3_BASE OMAP3_UART3_BASE
898 +#elif defined(CONFIG_ARCH_OMAP4)
899 +# define OMAP_UART1_BASE OMAP4_UART1_BASE
900 +# define OMAP_UART2_BASE OMAP4_UART2_BASE
901 +# define OMAP_UART3_BASE OMAP4_UART3_BASE
902 +#else
903 +# error
904 +#endif
905 + switch (bt_config->bt_uart) {
906 + case 1:
907 + if (cpu_is_omap16xx()) {
908 + irq = INT_UART1;
909 + info->uart_fclk = clk_get(NULL, "uart1_ck");
910 + } else if (cpu_is_omap24xx()) {
911 + irq = INT_24XX_UART1_IRQ;
912 + info->uart_iclk = clk_get(NULL, "uart1_ick");
913 + info->uart_fclk = clk_get(NULL, "uart1_fck");
914 + }
915 + /* FIXME: Use platform_get_resource for the port */
916 + info->uart_base = ioremap(OMAP_UART1_BASE, 0x16);
917 + if (!info->uart_base)
918 + goto cleanup;
919 + break;
920 + case 2:
921 + if (cpu_is_omap16xx()) {
922 + irq = INT_UART2;
923 + info->uart_fclk = clk_get(NULL, "uart2_ck");
924 + } else {
925 + irq = INT_24XX_UART2_IRQ;
926 + info->uart_iclk = clk_get(NULL, "uart2_ick");
927 + info->uart_fclk = clk_get(NULL, "uart2_fck");
928 + }
929 + /* FIXME: Use platform_get_resource for the port */
930 + info->uart_base = ioremap(OMAP_UART2_BASE, 0x16);
931 + if (!info->uart_base)
932 + goto cleanup;
933 + break;
934 + case 3:
935 + if (cpu_is_omap16xx()) {
936 + irq = INT_UART3;
937 + info->uart_fclk = clk_get(NULL, "uart3_ck");
938 + } else {
939 + irq = INT_24XX_UART3_IRQ;
940 + info->uart_iclk = clk_get(NULL, "uart3_ick");
941 + info->uart_fclk = clk_get(NULL, "uart3_fck");
942 + }
943 + /* FIXME: Use platform_get_resource for the port */
944 + info->uart_base = ioremap(OMAP_UART3_BASE, 0x16);
945 + if (!info->uart_base)
946 + goto cleanup;
947 + break;
948 + default:
949 + dev_err(info->dev, "No uart defined\n");
950 + goto cleanup;
951 + }
952 +
953 + info->irq = irq;
954 + err = request_irq(irq, hci_h4p_interrupt, 0, "hci_h4p", (void *)info);
955 + if (err < 0) {
956 + dev_err(info->dev, "hci_h4p: unable to get IRQ %d\n", irq);
957 + goto cleanup;
958 + }
959 +
960 + err = request_irq(gpio_to_irq(info->host_wakeup_gpio),
961 + hci_h4p_wakeup_interrupt,
962 + IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
963 + "hci_h4p_wkup", (void *)info);
964 + if (err < 0) {
965 + dev_err(info->dev, "hci_h4p: unable to get wakeup IRQ %d\n",
966 + gpio_to_irq(info->host_wakeup_gpio));
967 + free_irq(irq, (void *)info);
968 + goto cleanup;
969 + }
970 +
971 + hci_h4p_set_clk(info, &info->tx_clocks_en, 1);
972 + hci_h4p_set_auto_ctsrts(info, 0, UART_EFR_CTS | UART_EFR_RTS);
973 + err = hci_h4p_init_uart(info);
974 + if (err < 0)
975 + goto cleanup_irq;
976 + err = hci_h4p_reset(info);
977 + if (err < 0)
978 + goto cleanup_irq;
979 + err = hci_h4p_wait_for_cts(info, 1, 10);
980 + if (err < 0)
981 + goto cleanup_irq;
982 + hci_h4p_set_clk(info, &info->tx_clocks_en, 0);
983 +
984 + platform_set_drvdata(pdev, info);
985 + err = hci_h4p_sysfs_create_files(info->dev);
986 + if (err < 0)
987 + goto cleanup_irq;
988 +
989 + if (hci_h4p_register_hdev(info) < 0) {
990 + dev_err(info->dev, "failed to register hci_h4p hci device\n");
991 + goto cleanup_irq;
992 + }
993 + gpio_set_value(info->reset_gpio, 0);
994 +
995 + return 0;
996 +
997 +cleanup_irq:
998 + free_irq(irq, (void *)info);
999 + free_irq(gpio_to_irq(info->host_wakeup_gpio), (void *)info);
1000 +cleanup:
1001 + gpio_set_value(info->reset_gpio, 0);
1002 + gpio_free(info->reset_gpio);
1003 + gpio_free(info->bt_wakeup_gpio);
1004 + gpio_free(info->host_wakeup_gpio);
1005 + kfree(info);
1006 +
1007 + return err;
1008 +
1009 +}
1010 +
1011 +static int hci_h4p_remove(struct platform_device *dev)
1012 +{
1013 + struct hci_h4p_info *info;
1014 +
1015 + info = platform_get_drvdata(dev);
1016 +
1017 + hci_h4p_hci_close(info->hdev);
1018 + free_irq(gpio_to_irq(info->host_wakeup_gpio), (void *) info);
1019 + hci_free_dev(info->hdev);
1020 + gpio_free(info->reset_gpio);
1021 + gpio_free(info->bt_wakeup_gpio);
1022 + gpio_free(info->host_wakeup_gpio);
1023 + free_irq(info->irq, (void *) info);
1024 + kfree(info);
1025 +
1026 + return 0;
1027 +}
1028 +
1029 +static struct platform_driver hci_h4p_driver = {
1030 + .probe = hci_h4p_probe,
1031 + .remove = hci_h4p_remove,
1032 + .driver = {
1033 + .name = "hci_h4p",
1034 + },
1035 +};
1036 +
1037 +static int __init hci_h4p_init(void)
1038 +{
1039 + int err = 0;
1040 +
1041 + /* Register the driver with LDM */
1042 + err = platform_driver_register(&hci_h4p_driver);
1043 + if (err < 0)
1044 + printk(KERN_WARNING "failed to register hci_h4p driver\n");
1045 +
1046 + return err;
1047 +}
1048 +
1049 +static void __exit hci_h4p_exit(void)
1050 +{
1051 + platform_driver_unregister(&hci_h4p_driver);
1052 +}
1053 +
1054 +module_init(hci_h4p_init);
1055 +module_exit(hci_h4p_exit);
1056 +
1057 +MODULE_DESCRIPTION("h4 driver with nokia extensions");
1058 +MODULE_LICENSE("GPL");
1059 +MODULE_AUTHOR("Ville Tervo");
1060 --- /dev/null
1061 +++ b/drivers/bluetooth/hci_h4p/fw.c
1062 @@ -0,0 +1,155 @@
1063 +/*
1064 + * This file is part of hci_h4p bluetooth driver
1065 + *
1066 + * Copyright (C) 2005, 2006 Nokia Corporation.
1067 + *
1068 + * Contact: Ville Tervo <ville.tervo@nokia.com>
1069 + *
1070 + * This program is free software; you can redistribute it and/or
1071 + * modify it under the terms of the GNU General Public License
1072 + * version 2 as published by the Free Software Foundation.
1073 + *
1074 + * This program is distributed in the hope that it will be useful, but
1075 + * WITHOUT ANY WARRANTY; without even the implied warranty of
1076 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1077 + * General Public License for more details.
1078 + *
1079 + * You should have received a copy of the GNU General Public License
1080 + * along with this program; if not, write to the Free Software
1081 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
1082 + * 02110-1301 USA
1083 + *
1084 + */
1085 +
1086 +#include <linux/skbuff.h>
1087 +#include <linux/firmware.h>
1088 +#include <linux/clk.h>
1089 +
1090 +#include <net/bluetooth/bluetooth.h>
1091 +
1092 +#include "hci_h4p.h"
1093 +
1094 +#define BT_CHIP_TI 2
1095 +#define BT_CHIP_CSR 1
1096 +
1097 +static int fw_pos;
1098 +
1099 +/* Firmware handling */
1100 +static int hci_h4p_open_firmware(struct hci_h4p_info *info,
1101 + const struct firmware **fw_entry)
1102 +{
1103 + int err;
1104 +
1105 + fw_pos = 0;
1106 + NBT_DBG_FW("Opening %d firmware\n", info->chip_type);
1107 + switch (info->chip_type) {
1108 + case BT_CHIP_TI:
1109 + err = request_firmware(fw_entry, "brf6150fw.bin", info->dev);
1110 + break;
1111 + case BT_CHIP_CSR:
1112 + err = request_firmware(fw_entry, "bc4fw.bin", info->dev);
1113 + break;
1114 + default:
1115 + dev_err(info->dev, "Invalid chip type\n");
1116 + *fw_entry = NULL;
1117 + err = -EINVAL;
1118 + }
1119 +
1120 + return err;
1121 +}
1122 +
1123 +static void hci_h4p_close_firmware(const struct firmware *fw_entry)
1124 +{
1125 + release_firmware(fw_entry);
1126 +}
1127 +
1128 +/* Read fw. Return length of the command. If no more commands in
1129 + * fw 0 is returned. In error case return value is negative.
1130 + */
1131 +static int hci_h4p_read_fw_cmd(struct hci_h4p_info *info, struct sk_buff **skb,
1132 + const struct firmware *fw_entry, int how)
1133 +{
1134 + unsigned int cmd_len;
1135 +
1136 + if (fw_pos >= fw_entry->size) {
1137 + return 0;
1138 + }
1139 +
1140 + cmd_len = fw_entry->data[fw_pos++];
1141 + if (!cmd_len)
1142 + return 0;
1143 +
1144 + if (fw_pos + cmd_len > fw_entry->size) {
1145 + dev_err(info->dev, "Corrupted firmware image\n");
1146 + return -EMSGSIZE;
1147 + }
1148 +
1149 + *skb = bt_skb_alloc(cmd_len, how);
1150 + if (!*skb) {
1151 + dev_err(info->dev, "Cannot reserve memory for buffer\n");
1152 + return -ENOMEM;
1153 + }
1154 + memcpy(skb_put(*skb, cmd_len), &fw_entry->data[fw_pos], cmd_len);
1155 +
1156 + fw_pos += cmd_len;
1157 +
1158 + return (*skb)->len;
1159 +}
1160 +
1161 +int hci_h4p_read_fw(struct hci_h4p_info *info, struct sk_buff_head *fw_queue)
1162 +{
1163 + const struct firmware *fw_entry = NULL;
1164 + struct sk_buff *skb = NULL;
1165 + int err;
1166 +
1167 + err = hci_h4p_open_firmware(info, &fw_entry);
1168 + if (err < 0 || !fw_entry)
1169 + goto err_clean;
1170 +
1171 + while ((err = hci_h4p_read_fw_cmd(info, &skb, fw_entry, GFP_KERNEL))) {
1172 + if (err < 0 || !skb)
1173 + goto err_clean;
1174 +
1175 + skb_queue_tail(fw_queue, skb);
1176 + }
1177 +
1178 +err_clean:
1179 + hci_h4p_close_firmware(fw_entry);
1180 + return err;
1181 +}
1182 +
1183 +int hci_h4p_send_fw(struct hci_h4p_info *info, struct sk_buff_head *fw_queue)
1184 +{
1185 + int err;
1186 +
1187 + switch(info->chip_type) {
1188 + case BT_CHIP_CSR:
1189 + err = hci_h4p_bc4_send_fw(info, fw_queue);
1190 + break;
1191 + case BT_CHIP_TI:
1192 + err = hci_h4p_brf6150_send_fw(info, fw_queue);
1193 + break;
1194 + default:
1195 + dev_err(info->dev, "Don't know how to send firmware\n");
1196 + err = -EINVAL;
1197 + }
1198 +
1199 + return err;
1200 +}
1201 +
1202 +void hci_h4p_parse_fw_event(struct hci_h4p_info *info, struct sk_buff *skb)
1203 +{
1204 + switch (info->chip_type) {
1205 + case BT_CHIP_CSR:
1206 + hci_h4p_bc4_parse_fw_event(info, skb);
1207 + break;
1208 + case BT_CHIP_TI:
1209 + hci_h4p_brf6150_parse_fw_event(info, skb);
1210 + break;
1211 + default:
1212 + dev_err(info->dev, "Don't know how to parse fw event\n");
1213 + info->fw_error = -EINVAL;
1214 + }
1215 +
1216 + return;
1217 +}
1218 --- /dev/null
1219 +++ b/drivers/bluetooth/hci_h4p/fw-csr.c
1220 @@ -0,0 +1,149 @@
1221 +/*
1222 + * This file is part of hci_h4p bluetooth driver
1223 + *
1224 + * Copyright (C) 2005, 2006 Nokia Corporation.
1225 + *
1226 + * Contact: Ville Tervo <ville.tervo@nokia.com>
1227 + *
1228 + * This program is free software; you can redistribute it and/or
1229 + * modify it under the terms of the GNU General Public License
1230 + * version 2 as published by the Free Software Foundation.
1231 + *
1232 + * This program is distributed in the hope that it will be useful, but
1233 + * WITHOUT ANY WARRANTY; without even the implied warranty of
1234 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1235 + * General Public License for more details.
1236 + *
1237 + * You should have received a copy of the GNU General Public License
1238 + * along with this program; if not, write to the Free Software
1239 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
1240 + * 02110-1301 USA
1241 + *
1242 + */
1243 +
1244 +#include <linux/skbuff.h>
1245 +#include <linux/delay.h>
1246 +#include <linux/serial_reg.h>
1247 +
1248 +#include "hci_h4p.h"
1249 +
1250 +void hci_h4p_bc4_parse_fw_event(struct hci_h4p_info *info, struct sk_buff *skb)
1251 +{
1252 + /* Check if this is fw packet */
1253 + if (skb->data[0] != 0xff) {
1254 + hci_recv_frame(skb);
1255 + return;
1256 + }
1257 +
1258 + if (skb->data[11] || skb->data[12]) {
1259 + dev_err(info->dev, "Firmware sending command failed\n");
1260 + info->fw_error = -EPROTO;
1261 + }
1262 +
1263 + kfree_skb(skb);
1264 + complete(&info->fw_completion);
1265 +}
1266 +
1267 +int hci_h4p_bc4_send_fw(struct hci_h4p_info *info,
1268 + struct sk_buff_head *fw_queue)
1269 +{
1270 + struct sk_buff *skb;
1271 + unsigned int offset;
1272 + int retries, count, i;
1273 +
1274 + info->fw_error = 0;
1275 +
1276 + NBT_DBG_FW("Sending firmware\n");
1277 + skb = skb_dequeue(fw_queue);
1278 +
1279 + if (!skb)
1280 + return -ENOMSG;
1281 +
1282 + info->bdaddr[0] = 0x00;
1283 + info->bdaddr[1] = 0x1D;
1284 + info->bdaddr[2] = 0x6E;
1285 + info->bdaddr[3] = 0xD4;
1286 + info->bdaddr[4] = 0xF0;
1287 + info->bdaddr[5] = 0x37;
1288 +
1289 + /* Check if this is bd_address packet */
1290 + if (skb->data[15] == 0x01 && skb->data[16] == 0x00) {
1291 + dev_info(info->dev, "bd_address packet found\n");
1292 + offset = 21;
1293 + skb->data[offset + 1] = 0x00;
1294 + skb->data[offset + 5] = 0x00;
1295 + skb->data[offset + 7] = info->bdaddr[0];
1296 + skb->data[offset + 6] = info->bdaddr[1];
1297 + skb->data[offset + 4] = info->bdaddr[2];
1298 + skb->data[offset + 0] = info->bdaddr[3];
1299 + skb->data[offset + 3] = info->bdaddr[4];
1300 + skb->data[offset + 2] = info->bdaddr[5];
1301 + }
1302 +
1303 + for (i = 0; i < 6; i++) {
1304 + if (info->bdaddr[i] != 0x00)
1305 + break;
1306 + }
1307 +
1308 + /* if (i > 5) {
1309 + dev_info(info->dev, "Valid bluetooth address not found.\n");
1310 + kfree_skb(skb);
1311 + return -ENODEV;
1312 + } */
1313 +
1314 + for (count = 1; ; count++) {
1315 + NBT_DBG_FW("Sending firmware command %d\n", count);
1316 + init_completion(&info->fw_completion);
1317 + skb_queue_tail(&info->txq, skb);
1318 + tasklet_schedule(&info->tx_task);
1319 +
1320 + skb = skb_dequeue(fw_queue);
1321 + if (!skb)
1322 + break;
1323 +
1324 + if (!wait_for_completion_timeout(&info->fw_completion,
1325 + msecs_to_jiffies(1000))) {
1326 + dev_err(info->dev, "No reply to fw command\n");
1327 + return -ETIMEDOUT;
1328 + }
1329 +
1330 + if (info->fw_error) {
1331 + dev_err(info->dev, "FW error\n");
1332 + return -EPROTO;
1333 + }
1334 + };
1335 +
1336 + /* Wait for chip warm reset */
1337 + retries = 100;
1338 + while ((!skb_queue_empty(&info->txq) ||
1339 + !(hci_h4p_inb(info, UART_LSR) & UART_LSR_TEMT)) &&
1340 + retries--) {
1341 + msleep(10);
1342 + }
1343 + if (!retries) {
1344 + dev_err(info->dev, "Transmitter not empty\n");
1345 + return -ETIMEDOUT;
1346 + }
1347 +
1348 + hci_h4p_change_speed(info, BC4_MAX_BAUD_RATE);
1349 +
1350 + if (hci_h4p_wait_for_cts(info, 1, 100)) {
1351 + dev_err(info->dev, "cts didn't go down after final speed change\n");
1352 + return -ETIMEDOUT;
1353 + }
1354 +
1355 + retries = 100;
1356 + do {
1357 + init_completion(&info->init_completion);
1358 + hci_h4p_send_alive_packet(info);
1359 + retries--;
1360 + } while (!wait_for_completion_timeout(&info->init_completion, 100) &&
1361 + retries > 0);
1362 +
1363 + if (!retries) {
1364 + dev_err(info->dev, "No alive reply after speed change\n");
1365 + return -ETIMEDOUT;
1366 + }
1367 +
1368 + return 0;
1369 +}
1370 --- /dev/null
1371 +++ b/drivers/bluetooth/hci_h4p/fw-ti.c
1372 @@ -0,0 +1,90 @@
1373 +/*
1374 + * This file is part of hci_h4p bluetooth driver
1375 + *
1376 + * Copyright (C) 2005, 2006 Nokia Corporation.
1377 + *
1378 + * Contact: Ville Tervo <ville.tervo@nokia.com>
1379 + *
1380 + * This program is free software; you can redistribute it and/or
1381 + * modify it under the terms of the GNU General Public License
1382 + * version 2 as published by the Free Software Foundation.
1383 + *
1384 + * This program is distributed in the hope that it will be useful, but
1385 + * WITHOUT ANY WARRANTY; without even the implied warranty of
1386 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1387 + * General Public License for more details.
1388 + *
1389 + * You should have received a copy of the GNU General Public License
1390 + * along with this program; if not, write to the Free Software
1391 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
1392 + * 02110-1301 USA
1393 + *
1394 + */
1395 +
1396 +#include <linux/skbuff.h>
1397 +
1398 +#include "hci_h4p.h"
1399 +
1400 +void hci_h4p_brf6150_parse_fw_event(struct hci_h4p_info *info,
1401 + struct sk_buff *skb)
1402 +{
1403 + struct hci_fw_event *ev;
1404 + int err = 0;
1405 +
1406 + if (bt_cb(skb)->pkt_type != H4_EVT_PKT) {
1407 + dev_err(info->dev, "Got non event fw packet.\n");
1408 + err = -EPROTO;
1409 + goto ret;
1410 + }
1411 +
1412 + ev = (struct hci_fw_event *)skb->data;
1413 + if (ev->hev.evt != HCI_EV_CMD_COMPLETE) {
1414 + dev_err(info->dev, "Got non cmd complete fw event\n");
1415 + err = -EPROTO;
1416 + goto ret;
1417 + }
1418 +
1419 + if (ev->status != 0) {
1420 + dev_err(info->dev, "Got error status from fw command\n");
1421 + err = -EPROTO;
1422 + goto ret;
1423 + }
1424 +
1425 +ret:
1426 + info->fw_error = err;
1427 + complete(&info->fw_completion);
1428 +}
1429 +
1430 +int hci_h4p_brf6150_send_fw(struct hci_h4p_info *info, struct sk_buff_head *fw_queue)
1431 +{
1432 + struct sk_buff *skb;
1433 + int err = 0;
1434 +
1435 + info->fw_error = 0;
1436 +
1437 + while ((skb = skb_dequeue(fw_queue)) != NULL) {
1438 + /* We should allways send word aligned data to h4+ devices */
1439 + if (skb->len % 2) {
1440 + err = skb_pad(skb, 1);
1441 + }
1442 + if (err)
1443 + return err;
1444 +
1445 + init_completion(&info->fw_completion);
1446 + skb_queue_tail(&info->txq, skb);
1447 + tasklet_schedule(&info->tx_task);
1448 +
1449 + if (!wait_for_completion_timeout(&info->fw_completion, HZ)) {
1450 + dev_err(info->dev, "Timeout while sending brf6150 fw\n");
1451 + return -ETIMEDOUT;
1452 + }
1453 +
1454 + if (info->fw_error) {
1455 + dev_err(info->dev, "There was fw_error while sending bfr6150 fw\n");
1456 + return -EPROTO;
1457 + }
1458 + }
1459 + NBT_DBG_FW("Firmware sent\n");
1460 +
1461 + return 0;
1462 +}
1463 --- /dev/null
1464 +++ b/drivers/bluetooth/hci_h4p/hci_h4p.h
1465 @@ -0,0 +1,183 @@
1466 +/*
1467 + * This file is part of hci_h4p bluetooth driver
1468 + *
1469 + * Copyright (C) 2005, 2006 Nokia Corporation.
1470 + *
1471 + * Contact: Ville Tervo <ville.tervo@nokia.com>
1472 + *
1473 + * This program is free software; you can redistribute it and/or
1474 + * modify it under the terms of the GNU General Public License
1475 + * version 2 as published by the Free Software Foundation.
1476 + *
1477 + * This program is distributed in the hope that it will be useful, but
1478 + * WITHOUT ANY WARRANTY; without even the implied warranty of
1479 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1480 + * General Public License for more details.
1481 + *
1482 + * You should have received a copy of the GNU General Public License
1483 + * along with this program; if not, write to the Free Software
1484 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
1485 + * 02110-1301 USA
1486 + *
1487 + */
1488 +
1489 +#include <mach/board.h>
1490 +
1491 +#include <net/bluetooth/bluetooth.h>
1492 +#include <net/bluetooth/hci_core.h>
1493 +#include <net/bluetooth/hci.h>
1494 +
1495 +#ifndef __DRIVERS_BLUETOOTH_HCI_H4P_H
1496 +#define __DRIVERS_BLUETOOTH_HCI_H4P_H
1497 +
1498 +#define UART_SYSC_OMAP_RESET 0x03
1499 +#define UART_SYSS_RESETDONE 0x01
1500 +#define UART_OMAP_SCR_EMPTY_THR 0x08
1501 +#define UART_OMAP_SCR_WAKEUP 0x10
1502 +#define UART_OMAP_SSR_WAKEUP 0x02
1503 +#define UART_OMAP_SSR_TXFULL 0x01
1504 +
1505 +#if 0
1506 +#define NBT_DBG(fmt, arg...) printk("%s: " fmt "" , __FUNCTION__ , ## arg)
1507 +#else
1508 +#define NBT_DBG(...)
1509 +#endif
1510 +
1511 +#if 0
1512 +#define NBT_DBG_FW(fmt, arg...) printk("%s: " fmt "" , __FUNCTION__ , ## arg)
1513 +#else
1514 +#define NBT_DBG_FW(...)
1515 +#endif
1516 +
1517 +#if 0
1518 +#define NBT_DBG_POWER(fmt, arg...) printk("%s: " fmt "" , __FUNCTION__ , ## arg)
1519 +#else
1520 +#define NBT_DBG_POWER(...)
1521 +#endif
1522 +
1523 +#if 0
1524 +#define NBT_DBG_TRANSFER(fmt, arg...) printk("%s: " fmt "" , __FUNCTION__ , ## arg)
1525 +#else
1526 +#define NBT_DBG_TRANSFER(...)
1527 +#endif
1528 +
1529 +#if 0
1530 +#define NBT_DBG_TRANSFER_NF(fmt, arg...) printk(fmt "" , ## arg)
1531 +#else
1532 +#define NBT_DBG_TRANSFER_NF(...)
1533 +#endif
1534 +
1535 +#if 0
1536 +#define NBT_DBG_DMA(fmt, arg...) printk("%s: " fmt "" , __FUNCTION__ , ## arg)
1537 +#else
1538 +#define NBT_DBG_DMA(...)
1539 +#endif
1540 +
1541 +struct hci_h4p_info {
1542 + struct hci_dev *hdev;
1543 + spinlock_t lock;
1544 +
1545 + void __iomem *uart_base;
1546 + unsigned long uart_phys_base;
1547 + int irq;
1548 + struct device *dev;
1549 + u8 bdaddr[6];
1550 + u8 chip_type;
1551 + u8 bt_wakeup_gpio;
1552 + u8 host_wakeup_gpio;
1553 + u8 reset_gpio;
1554 + u8 bt_sysclk;
1555 +
1556 +
1557 + struct sk_buff_head fw_queue;
1558 + struct sk_buff *alive_cmd_skb;
1559 + struct completion init_completion;
1560 + struct completion fw_completion;
1561 + int fw_error;
1562 + int init_error;
1563 +
1564 + struct sk_buff_head txq;
1565 + struct tasklet_struct tx_task;
1566 +
1567 + struct sk_buff *rx_skb;
1568 + long rx_count;
1569 + unsigned long rx_state;
1570 + unsigned long garbage_bytes;
1571 + struct tasklet_struct rx_task;
1572 +
1573 + int pm_enabled;
1574 + int tx_pm_enabled;
1575 + int rx_pm_enabled;
1576 + struct timer_list tx_pm_timer;
1577 + struct timer_list rx_pm_timer;
1578 +
1579 + int tx_clocks_en;
1580 + int rx_clocks_en;
1581 + spinlock_t clocks_lock;
1582 + struct clk *uart_iclk;
1583 + struct clk *uart_fclk;
1584 +};
1585 +
1586 +#define MAX_BAUD_RATE 921600
1587 +#define BC4_MAX_BAUD_RATE 3692300
1588 +#define UART_CLOCK 48000000
1589 +#define BT_INIT_DIVIDER 320
1590 +#define BT_BAUDRATE_DIVIDER 384000000
1591 +#define BT_SYSCLK_DIV 1000
1592 +#define INIT_SPEED 120000
1593 +
1594 +#define H4_TYPE_SIZE 1
1595 +
1596 +/* H4+ packet types */
1597 +#define H4_CMD_PKT 0x01
1598 +#define H4_ACL_PKT 0x02
1599 +#define H4_SCO_PKT 0x03
1600 +#define H4_EVT_PKT 0x04
1601 +#define H4_NEG_PKT 0x06
1602 +#define H4_ALIVE_PKT 0x07
1603 +
1604 +/* TX states */
1605 +#define WAIT_FOR_PKT_TYPE 1
1606 +#define WAIT_FOR_HEADER 2
1607 +#define WAIT_FOR_DATA 3
1608 +
1609 +struct hci_fw_event {
1610 + struct hci_event_hdr hev;
1611 + struct hci_ev_cmd_complete cmd;
1612 + u8 status;
1613 +} __attribute__ ((packed));
1614 +
1615 +struct hci_bc4_set_bdaddr {
1616 + u8 type;
1617 + struct hci_command_hdr cmd_hdr;
1618 +} __attribute__ ((packed));
1619 +
1620 +int hci_h4p_send_alive_packet(struct hci_h4p_info *info);
1621 +
1622 +void hci_h4p_bc4_parse_fw_event(struct hci_h4p_info *info,
1623 + struct sk_buff *skb);
1624 +int hci_h4p_bc4_send_fw(struct hci_h4p_info *info,
1625 + struct sk_buff_head *fw_queue);
1626 +
1627 +void hci_h4p_brf6150_parse_fw_event(struct hci_h4p_info *info,
1628 + struct sk_buff *skb);
1629 +int hci_h4p_brf6150_send_fw(struct hci_h4p_info *info,
1630 + struct sk_buff_head *fw_queue);
1631 +
1632 +int hci_h4p_read_fw(struct hci_h4p_info *info, struct sk_buff_head *fw_queue);
1633 +int hci_h4p_send_fw(struct hci_h4p_info *info, struct sk_buff_head *fw_queue);
1634 +void hci_h4p_parse_fw_event(struct hci_h4p_info *info, struct sk_buff *skb);
1635 +
1636 +int hci_h4p_sysfs_create_files(struct device *dev);
1637 +
1638 +void hci_h4p_outb(struct hci_h4p_info *info, unsigned int offset, u8 val);
1639 +u8 hci_h4p_inb(struct hci_h4p_info *info, unsigned int offset);
1640 +void hci_h4p_set_rts(struct hci_h4p_info *info, int active);
1641 +int hci_h4p_wait_for_cts(struct hci_h4p_info *info, int active, int timeout_ms);
1642 +void __hci_h4p_set_auto_ctsrts(struct hci_h4p_info *info, int on, u8 which);
1643 +void hci_h4p_set_auto_ctsrts(struct hci_h4p_info *info, int on, u8 which);
1644 +void hci_h4p_change_speed(struct hci_h4p_info *info, unsigned long speed);
1645 +int hci_h4p_reset_uart(struct hci_h4p_info *info);
1646 +int hci_h4p_init_uart(struct hci_h4p_info *info);
1647 +
1648 +#endif /* __DRIVERS_BLUETOOTH_HCI_H4P_H */
1649 --- /dev/null
1650 +++ b/drivers/bluetooth/hci_h4p/Makefile
1651 @@ -0,0 +1,7 @@
1652 +#
1653 +# Makefile for the Linux Bluetooth HCI device drivers.
1654 +#
1655 +
1656 +obj-$(CONFIG_BT_HCIH4P) += hci_h4p.o
1657 +
1658 +hci_h4p-objs := core.o fw.o uart.o sysfs.o fw-ti.o fw-csr.o
1659 --- /dev/null
1660 +++ b/drivers/bluetooth/hci_h4p/sysfs.c
1661 @@ -0,0 +1,84 @@
1662 +/*
1663 + * This file is part of hci_h4p bluetooth driver
1664 + *
1665 + * Copyright (C) 2005, 2006 Nokia Corporation.
1666 + *
1667 + * Contact: Ville Tervo <ville.tervo@nokia.com>
1668 + *
1669 + * This program is free software; you can redistribute it and/or
1670 + * modify it under the terms of the GNU General Public License
1671 + * version 2 as published by the Free Software Foundation.
1672 + *
1673 + * This program is distributed in the hope that it will be useful, but
1674 + * WITHOUT ANY WARRANTY; without even the implied warranty of
1675 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1676 + * General Public License for more details.
1677 + *
1678 + * You should have received a copy of the GNU General Public License
1679 + * along with this program; if not, write to the Free Software
1680 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
1681 + * 02110-1301 USA
1682 + *
1683 + */
1684 +
1685 +#include <linux/kernel.h>
1686 +#include <linux/init.h>
1687 +#include <linux/device.h>
1688 +#include <linux/platform_device.h>
1689 +
1690 +#include "hci_h4p.h"
1691 +
1692 +#ifdef CONFIG_SYSFS
1693 +
1694 +static ssize_t hci_h4p_store_bdaddr(struct device *dev, struct device_attribute *attr,
1695 + const char *buf, size_t count)
1696 +{
1697 + struct hci_h4p_info *info = (struct hci_h4p_info*)dev_get_drvdata(dev);
1698 + unsigned int bdaddr[6];
1699 + int ret, i;
1700 +
1701 + dev_info(info->dev, "HCI_H4P_STORE_BDADDR called\n");
1702 +
1703 + ret = sscanf(buf, "%2x:%2x:%2x:%2x:%2x:%2x\n",
1704 + &bdaddr[0], &bdaddr[1], &bdaddr[2],
1705 + &bdaddr[3], &bdaddr[4], &bdaddr[5]);
1706 +
1707 + if (ret != 6) {
1708 + dev_info(info->dev, "bdaddr isn't found\n");
1709 + return -EINVAL;
1710 + }
1711 +
1712 + //for (i = 0; i < 6; i++)
1713 + //info->bdaddr[i] = bdaddr[i] & 0xff;
1714 +
1715 + info->bdaddr[0] = 0x00;
1716 + info->bdaddr[1] = 0x1D;
1717 + info->bdaddr[2] = 0x6E;
1718 + info->bdaddr[3] = 0xD4;
1719 + info->bdaddr[4] = 0xF0;
1720 + info->bdaddr[5] = 0x37;
1721 +
1722 + return count;
1723 +}
1724 +
1725 +static ssize_t hci_h4p_show_bdaddr(struct device *dev, struct device_attribute *attr,
1726 + char *buf)
1727 +{
1728 + struct hci_h4p_info *info = (struct hci_h4p_info*)dev_get_drvdata(dev);
1729 +
1730 + return sprintf(buf, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n",
1731 + info->bdaddr[0],
1732 + info->bdaddr[1],
1733 + info->bdaddr[2],
1734 + info->bdaddr[3],
1735 + info->bdaddr[4],
1736 + info->bdaddr[5]);
1737 +}
1738 +
1739 +static DEVICE_ATTR(bdaddr, S_IRUGO | S_IWUSR, hci_h4p_show_bdaddr, hci_h4p_store_bdaddr);
1740 +int hci_h4p_sysfs_create_files(struct device *dev)
1741 +{
1742 + return device_create_file(dev, &dev_attr_bdaddr);
1743 +}
1744 +
1745 +#endif
1746 --- /dev/null
1747 +++ b/drivers/bluetooth/hci_h4p/uart.c
1748 @@ -0,0 +1,169 @@
1749 +/*
1750 + * This file is part of hci_h4p bluetooth driver
1751 + *
1752 + * Copyright (C) 2005, 2006 Nokia Corporation.
1753 + *
1754 + * Contact: Ville Tervo <ville.tervo@nokia.com>
1755 + *
1756 + * This program is free software; you can redistribute it and/or
1757 + * modify it under the terms of the GNU General Public License
1758 + * version 2 as published by the Free Software Foundation.
1759 + *
1760 + * This program is distributed in the hope that it will be useful, but
1761 + * WITHOUT ANY WARRANTY; without even the implied warranty of
1762 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1763 + * General Public License for more details.
1764 + *
1765 + * You should have received a copy of the GNU General Public License
1766 + * along with this program; if not, write to the Free Software
1767 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
1768 + * 02110-1301 USA
1769 + *
1770 + */
1771 +
1772 +#include <linux/serial_reg.h>
1773 +#include <linux/delay.h>
1774 +#include <linux/clk.h>
1775 +
1776 +#include <asm/io.h>
1777 +
1778 +#include "hci_h4p.h"
1779 +
1780 +inline void hci_h4p_outb(struct hci_h4p_info *info, unsigned int offset, u8 val)
1781 +{
1782 + offset <<= 2;
1783 + __raw_writeb(val, info->uart_base + offset);
1784 + //outb(val, info->uart_base + (offset << 2));
1785 +}
1786 +
1787 +inline u8 hci_h4p_inb(struct hci_h4p_info *info, unsigned int offset)
1788 +{
1789 + offset <<= 2;
1790 + return (u8)__raw_readb(info->uart_base + offset);
1791 + //return (unsigned int)__raw_readb(up->membase + offset);
1792 + //return inb(info->uart_base + (offset << 2));
1793 +}
1794 +
1795 +void hci_h4p_set_rts(struct hci_h4p_info *info, int active)
1796 +{
1797 + u8 b;
1798 +
1799 + b = hci_h4p_inb(info, UART_MCR);
1800 + if (active)
1801 + b |= UART_MCR_RTS;
1802 + else
1803 + b &= ~UART_MCR_RTS;
1804 + hci_h4p_outb(info, UART_MCR, b);
1805 +}
1806 +
1807 +int hci_h4p_wait_for_cts(struct hci_h4p_info *info, int active,
1808 + int timeout_ms)
1809 +{
1810 + int okay;
1811 + unsigned long timeout;
1812 +
1813 + okay = 0;
1814 + timeout = jiffies + msecs_to_jiffies(timeout_ms);
1815 + for (;;) {
1816 + int state;
1817 +
1818 + state = hci_h4p_inb(info, UART_MSR) & UART_MSR_CTS;
1819 + if (active) {
1820 + if (state)
1821 + return 0;
1822 + } else {
1823 + if (!state)
1824 + return 0;
1825 + }
1826 + if (time_after(jiffies, timeout))
1827 + return -ETIMEDOUT;
1828 + }
1829 +}
1830 +
1831 +void __hci_h4p_set_auto_ctsrts(struct hci_h4p_info *info, int on, u8 which)
1832 +{
1833 + u8 lcr, b;
1834 +
1835 + lcr = hci_h4p_inb(info, UART_LCR);
1836 + hci_h4p_outb(info, UART_LCR, 0xbf);
1837 + b = hci_h4p_inb(info, UART_EFR);
1838 + if (on)
1839 + b |= which;
1840 + else
1841 + b &= ~which;
1842 + hci_h4p_outb(info, UART_EFR, b);
1843 + hci_h4p_outb(info, UART_LCR, lcr);
1844 +}
1845 +
1846 +void hci_h4p_set_auto_ctsrts(struct hci_h4p_info *info, int on, u8 which)
1847 +{
1848 + unsigned long flags;
1849 +
1850 + spin_lock_irqsave(&info->lock, flags);
1851 + __hci_h4p_set_auto_ctsrts(info, on, which);
1852 + spin_unlock_irqrestore(&info->lock, flags);
1853 +}
1854 +
1855 +void hci_h4p_change_speed(struct hci_h4p_info *info, unsigned long speed)
1856 +{
1857 + unsigned int divisor;
1858 + u8 lcr, mdr1;
1859 +
1860 + NBT_DBG("Setting speed %lu\n", speed);
1861 +
1862 + if (speed >= 460800) {
1863 + divisor = UART_CLOCK / 13 / speed;
1864 + mdr1 = 3;
1865 + } else {
1866 + divisor = UART_CLOCK / 16 / speed;
1867 + mdr1 = 0;
1868 + }
1869 +
1870 + hci_h4p_outb(info, UART_OMAP_MDR1, 7); /* Make sure UART mode is disabled */
1871 + lcr = hci_h4p_inb(info, UART_LCR);
1872 + hci_h4p_outb(info, UART_LCR, UART_LCR_DLAB); /* Set DLAB */
1873 + hci_h4p_outb(info, UART_DLL, divisor & 0xff); /* Set speed */
1874 + hci_h4p_outb(info, UART_DLM, divisor >> 8);
1875 + hci_h4p_outb(info, UART_LCR, lcr);
1876 + hci_h4p_outb(info, UART_OMAP_MDR1, mdr1); /* Make sure UART mode is enabled */
1877 +}
1878 +
1879 +int hci_h4p_reset_uart(struct hci_h4p_info *info)
1880 +{
1881 + int count = 0;
1882 +
1883 + /* Reset the UART */
1884 + hci_h4p_outb(info, UART_OMAP_SYSC, UART_SYSC_OMAP_RESET);
1885 + while (!(hci_h4p_inb(info, UART_OMAP_SYSS) & UART_SYSS_RESETDONE)) {
1886 + if (count++ > 20000) {
1887 + dev_err(info->dev, "hci_h4p: UART reset timeout\n");
1888 + return -ENODEV;
1889 + }
1890 + udelay(1);
1891 + }
1892 +
1893 + return 0;
1894 +}
1895 +
1896 +int hci_h4p_init_uart(struct hci_h4p_info *info)
1897 +{
1898 + int err;
1899 +
1900 + err = hci_h4p_reset_uart(info);
1901 + if (err < 0)
1902 + return err;
1903 +
1904 + /* Enable and setup FIFO */
1905 + hci_h4p_outb(info, UART_LCR, UART_LCR_WLEN8);
1906 + hci_h4p_outb(info, UART_OMAP_MDR1, 0x00); /* Make sure UART mode is enabled */
1907 + hci_h4p_outb(info, UART_OMAP_SCR, 0x80);
1908 + hci_h4p_outb(info, UART_EFR, UART_EFR_ECB);
1909 + hci_h4p_outb(info, UART_MCR, UART_MCR_TCRTLR);
1910 + hci_h4p_outb(info, UART_TI752_TLR, 0x1f);
1911 + hci_h4p_outb(info, UART_TI752_TCR, 0xef);
1912 + hci_h4p_outb(info, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR |
1913 + UART_FCR_CLEAR_XMIT | UART_FCR_R_TRIG_00);
1914 + hci_h4p_outb(info, UART_IER, UART_IER_RDI);
1915 +
1916 + return 0;
1917 +}
1918 --- a/drivers/bluetooth/Kconfig
1919 +++ b/drivers/bluetooth/Kconfig
1920 @@ -173,6 +173,16 @@ config BT_HCIBTUART
1921 Say Y here to compile support for HCI UART devices into the
1922 kernel or say M to compile it as module (btuart_cs).
1923
1924 +config BT_HCIH4P
1925 + tristate "HCI driver with H4 Nokia extensions"
1926 + depends on BT && ARCH_OMAP
1927 + help
1928 + Bluetooth HCI driver with H4 extensions. This driver provides
1929 + support for H4+ Bluetooth chip with vendor-specific H4 extensions.
1930 +
1931 + Say Y here to compile support for h4 extended devices into the kernel
1932 + or say M to compile it as module (hci_h4p).
1933 +
1934 config BT_HCIVHCI
1935 tristate "HCI VHCI (Virtual HCI device) driver"
1936 help
1937 --- a/drivers/bluetooth/Makefile
1938 +++ b/drivers/bluetooth/Makefile
1939 @@ -11,6 +11,7 @@ obj-$(CONFIG_BT_HCIDTL1) += dtl1_cs.o
1940 obj-$(CONFIG_BT_HCIBT3C) += bt3c_cs.o
1941 obj-$(CONFIG_BT_HCIBLUECARD) += bluecard_cs.o
1942 obj-$(CONFIG_BT_HCIBTUART) += btuart_cs.o
1943 +obj-$(CONFIG_BT_HCIH4P) += hci_h4p/
1944
1945 obj-$(CONFIG_BT_HCIBTUSB) += btusb.o
1946 obj-$(CONFIG_BT_HCIBTSDIO) += btsdio.o