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