Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Bluetooth HCI UART H4 driver with Nokia Extensions AKA Nokia H4+
4 *
5 * Copyright (C) 2015 Marcel Holtmann <marcel@holtmann.org>
6 * Copyright (C) 2015-2017 Sebastian Reichel <sre@kernel.org>
7 */
8
9#include <linux/clk.h>
10#include <linux/errno.h>
11#include <linux/firmware.h>
12#include <linux/gpio/consumer.h>
13#include <linux/interrupt.h>
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/of.h>
17#include <linux/pm_runtime.h>
18#include <linux/serdev.h>
19#include <linux/skbuff.h>
20#include <linux/slab.h>
21#include <linux/string.h>
22#include <linux/types.h>
23#include <linux/unaligned.h>
24#include <net/bluetooth/bluetooth.h>
25#include <net/bluetooth/hci_core.h>
26
27#include "hci_uart.h"
28#include "btbcm.h"
29
30#define VERSION "0.1"
31
32#define NOKIA_ID_BCM2048 0x04
33#define NOKIA_ID_TI1271 0x31
34
35#define FIRMWARE_BCM2048 "nokia/bcmfw.bin"
36#define FIRMWARE_TI1271 "nokia/ti1273.bin"
37
38#define HCI_NOKIA_NEG_PKT 0x06
39#define HCI_NOKIA_ALIVE_PKT 0x07
40#define HCI_NOKIA_RADIO_PKT 0x08
41
42#define HCI_NOKIA_NEG_HDR_SIZE 1
43#define HCI_NOKIA_MAX_NEG_SIZE 255
44#define HCI_NOKIA_ALIVE_HDR_SIZE 1
45#define HCI_NOKIA_MAX_ALIVE_SIZE 255
46#define HCI_NOKIA_RADIO_HDR_SIZE 2
47#define HCI_NOKIA_MAX_RADIO_SIZE 255
48
49#define NOKIA_PROTO_PKT 0x44
50#define NOKIA_PROTO_BYTE 0x4c
51
52#define NOKIA_NEG_REQ 0x00
53#define NOKIA_NEG_ACK 0x20
54#define NOKIA_NEG_NAK 0x40
55
56#define H4_TYPE_SIZE 1
57
58#define NOKIA_RECV_ALIVE \
59 .type = HCI_NOKIA_ALIVE_PKT, \
60 .hlen = HCI_NOKIA_ALIVE_HDR_SIZE, \
61 .loff = 0, \
62 .lsize = 1, \
63 .maxlen = HCI_NOKIA_MAX_ALIVE_SIZE \
64
65#define NOKIA_RECV_NEG \
66 .type = HCI_NOKIA_NEG_PKT, \
67 .hlen = HCI_NOKIA_NEG_HDR_SIZE, \
68 .loff = 0, \
69 .lsize = 1, \
70 .maxlen = HCI_NOKIA_MAX_NEG_SIZE \
71
72#define NOKIA_RECV_RADIO \
73 .type = HCI_NOKIA_RADIO_PKT, \
74 .hlen = HCI_NOKIA_RADIO_HDR_SIZE, \
75 .loff = 1, \
76 .lsize = 1, \
77 .maxlen = HCI_NOKIA_MAX_RADIO_SIZE \
78
79struct hci_nokia_neg_hdr {
80 u8 dlen;
81} __packed;
82
83struct hci_nokia_neg_cmd {
84 u8 ack;
85 u16 baud;
86 u16 unused1;
87 u8 proto;
88 u16 sys_clk;
89 u16 unused2;
90} __packed;
91
92#define NOKIA_ALIVE_REQ 0x55
93#define NOKIA_ALIVE_RESP 0xcc
94
95struct hci_nokia_alive_hdr {
96 u8 dlen;
97} __packed;
98
99struct hci_nokia_alive_pkt {
100 u8 mid;
101 u8 unused;
102} __packed;
103
104struct hci_nokia_neg_evt {
105 u8 ack;
106 u16 baud;
107 u16 unused1;
108 u8 proto;
109 u16 sys_clk;
110 u16 unused2;
111 u8 man_id;
112 u8 ver_id;
113} __packed;
114
115#define MAX_BAUD_RATE 3692300
116#define SETUP_BAUD_RATE 921600
117#define INIT_BAUD_RATE 120000
118
119struct nokia_bt_dev {
120 struct hci_uart hu;
121 struct serdev_device *serdev;
122
123 struct gpio_desc *reset;
124 struct gpio_desc *wakeup_host;
125 struct gpio_desc *wakeup_bt;
126 unsigned long sysclk_speed;
127
128 int wake_irq;
129 struct sk_buff *rx_skb;
130 struct sk_buff_head txq;
131 bdaddr_t bdaddr;
132
133 int init_error;
134 struct completion init_completion;
135
136 u8 man_id;
137 u8 ver_id;
138
139 bool initialized;
140 bool tx_enabled;
141 bool rx_enabled;
142};
143
144static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb);
145
146static void nokia_flow_control(struct serdev_device *serdev, bool enable)
147{
148 if (enable) {
149 serdev_device_set_rts(serdev, true);
150 serdev_device_set_flow_control(serdev, true);
151 } else {
152 serdev_device_set_flow_control(serdev, false);
153 serdev_device_set_rts(serdev, false);
154 }
155}
156
157static irqreturn_t wakeup_handler(int irq, void *data)
158{
159 struct nokia_bt_dev *btdev = data;
160 struct device *dev = &btdev->serdev->dev;
161 int wake_state = gpiod_get_value(btdev->wakeup_host);
162
163 if (btdev->rx_enabled == wake_state)
164 return IRQ_HANDLED;
165
166 if (wake_state)
167 pm_runtime_get(dev);
168 else
169 pm_runtime_put(dev);
170
171 btdev->rx_enabled = wake_state;
172
173 return IRQ_HANDLED;
174}
175
176static int nokia_reset(struct hci_uart *hu)
177{
178 struct nokia_bt_dev *btdev = hu->priv;
179 struct device *dev = &btdev->serdev->dev;
180 int err;
181
182 /* reset routine */
183 gpiod_set_value_cansleep(btdev->reset, 1);
184 gpiod_set_value_cansleep(btdev->wakeup_bt, 1);
185
186 msleep(100);
187
188 /* safety check */
189 err = gpiod_get_value_cansleep(btdev->wakeup_host);
190 if (err == 1) {
191 dev_err(dev, "reset: host wakeup not low!");
192 return -EPROTO;
193 }
194
195 /* flush queue */
196 serdev_device_write_flush(btdev->serdev);
197
198 /* init uart */
199 nokia_flow_control(btdev->serdev, false);
200 serdev_device_set_baudrate(btdev->serdev, INIT_BAUD_RATE);
201
202 gpiod_set_value_cansleep(btdev->reset, 0);
203
204 /* wait for cts */
205 err = serdev_device_wait_for_cts(btdev->serdev, true, 200);
206 if (err < 0) {
207 dev_err(dev, "CTS not received: %d", err);
208 return err;
209 }
210
211 nokia_flow_control(btdev->serdev, true);
212
213 return 0;
214}
215
216static int nokia_send_alive_packet(struct hci_uart *hu)
217{
218 struct nokia_bt_dev *btdev = hu->priv;
219 struct device *dev = &btdev->serdev->dev;
220 struct hci_nokia_alive_hdr *hdr;
221 struct hci_nokia_alive_pkt *pkt;
222 struct sk_buff *skb;
223 int len;
224
225 init_completion(&btdev->init_completion);
226
227 len = H4_TYPE_SIZE + sizeof(*hdr) + sizeof(*pkt);
228 skb = bt_skb_alloc(len, GFP_KERNEL);
229 if (!skb)
230 return -ENOMEM;
231
232 hci_skb_pkt_type(skb) = HCI_NOKIA_ALIVE_PKT;
233 memset(skb->data, 0x00, len);
234
235 hdr = skb_put(skb, sizeof(*hdr));
236 hdr->dlen = sizeof(*pkt);
237 pkt = skb_put(skb, sizeof(*pkt));
238 pkt->mid = NOKIA_ALIVE_REQ;
239
240 nokia_enqueue(hu, skb);
241 hci_uart_tx_wakeup(hu);
242
243 dev_dbg(dev, "Alive sent");
244
245 if (!wait_for_completion_interruptible_timeout(&btdev->init_completion,
246 msecs_to_jiffies(1000))) {
247 return -ETIMEDOUT;
248 }
249
250 if (btdev->init_error < 0)
251 return btdev->init_error;
252
253 return 0;
254}
255
256static int nokia_send_negotiation(struct hci_uart *hu)
257{
258 struct nokia_bt_dev *btdev = hu->priv;
259 struct device *dev = &btdev->serdev->dev;
260 struct hci_nokia_neg_cmd *neg_cmd;
261 struct hci_nokia_neg_hdr *neg_hdr;
262 struct sk_buff *skb;
263 int len, err;
264 u16 baud = DIV_ROUND_CLOSEST(btdev->sysclk_speed * 10, SETUP_BAUD_RATE);
265 int sysclk = btdev->sysclk_speed / 1000;
266
267 len = H4_TYPE_SIZE + sizeof(*neg_hdr) + sizeof(*neg_cmd);
268 skb = bt_skb_alloc(len, GFP_KERNEL);
269 if (!skb)
270 return -ENOMEM;
271
272 hci_skb_pkt_type(skb) = HCI_NOKIA_NEG_PKT;
273
274 neg_hdr = skb_put(skb, sizeof(*neg_hdr));
275 neg_hdr->dlen = sizeof(*neg_cmd);
276
277 neg_cmd = skb_put(skb, sizeof(*neg_cmd));
278 neg_cmd->ack = NOKIA_NEG_REQ;
279 neg_cmd->baud = cpu_to_le16(baud);
280 neg_cmd->unused1 = 0x0000;
281 neg_cmd->proto = NOKIA_PROTO_BYTE;
282 neg_cmd->sys_clk = cpu_to_le16(sysclk);
283 neg_cmd->unused2 = 0x0000;
284
285 btdev->init_error = 0;
286 init_completion(&btdev->init_completion);
287
288 nokia_enqueue(hu, skb);
289 hci_uart_tx_wakeup(hu);
290
291 dev_dbg(dev, "Negotiation sent");
292
293 if (!wait_for_completion_interruptible_timeout(&btdev->init_completion,
294 msecs_to_jiffies(10000))) {
295 return -ETIMEDOUT;
296 }
297
298 if (btdev->init_error < 0)
299 return btdev->init_error;
300
301 /* Change to previously negotiated speed. Flow Control
302 * is disabled until bluetooth adapter is ready to avoid
303 * broken bytes being received.
304 */
305 nokia_flow_control(btdev->serdev, false);
306 serdev_device_set_baudrate(btdev->serdev, SETUP_BAUD_RATE);
307 err = serdev_device_wait_for_cts(btdev->serdev, true, 200);
308 if (err < 0) {
309 dev_err(dev, "CTS not received: %d", err);
310 return err;
311 }
312 nokia_flow_control(btdev->serdev, true);
313
314 dev_dbg(dev, "Negotiation successful");
315
316 return 0;
317}
318
319static int nokia_setup_fw(struct hci_uart *hu)
320{
321 struct nokia_bt_dev *btdev = hu->priv;
322 struct device *dev = &btdev->serdev->dev;
323 const char *fwname;
324 const struct firmware *fw;
325 const u8 *fw_ptr;
326 size_t fw_size;
327 int err;
328
329 dev_dbg(dev, "setup firmware");
330
331 if (btdev->man_id == NOKIA_ID_BCM2048) {
332 fwname = FIRMWARE_BCM2048;
333 } else if (btdev->man_id == NOKIA_ID_TI1271) {
334 fwname = FIRMWARE_TI1271;
335 } else {
336 dev_err(dev, "Unsupported bluetooth device!");
337 return -ENODEV;
338 }
339
340 err = request_firmware(&fw, fwname, dev);
341 if (err < 0) {
342 dev_err(dev, "%s: Failed to load Nokia firmware file (%d)",
343 hu->hdev->name, err);
344 return err;
345 }
346
347 fw_ptr = fw->data;
348 fw_size = fw->size;
349
350 while (fw_size >= 4) {
351 u16 pkt_size = get_unaligned_le16(fw_ptr);
352 u8 pkt_type = fw_ptr[2];
353 const struct hci_command_hdr *cmd;
354 u16 opcode;
355 struct sk_buff *skb;
356
357 switch (pkt_type) {
358 case HCI_COMMAND_PKT:
359 cmd = (struct hci_command_hdr *)(fw_ptr + 3);
360 opcode = le16_to_cpu(cmd->opcode);
361
362 skb = __hci_cmd_sync(hu->hdev, opcode, cmd->plen,
363 fw_ptr + 3 + HCI_COMMAND_HDR_SIZE,
364 HCI_INIT_TIMEOUT);
365 if (IS_ERR(skb)) {
366 err = PTR_ERR(skb);
367 dev_err(dev, "%s: FW command %04x failed (%d)",
368 hu->hdev->name, opcode, err);
369 goto done;
370 }
371 kfree_skb(skb);
372 break;
373 case HCI_NOKIA_RADIO_PKT:
374 case HCI_NOKIA_NEG_PKT:
375 case HCI_NOKIA_ALIVE_PKT:
376 break;
377 }
378
379 fw_ptr += pkt_size + 2;
380 fw_size -= pkt_size + 2;
381 }
382
383done:
384 release_firmware(fw);
385 return err;
386}
387
388static int nokia_setup(struct hci_uart *hu)
389{
390 struct nokia_bt_dev *btdev = hu->priv;
391 struct device *dev = &btdev->serdev->dev;
392 int err;
393
394 btdev->initialized = false;
395
396 nokia_flow_control(btdev->serdev, false);
397
398 pm_runtime_get_sync(dev);
399
400 if (btdev->tx_enabled) {
401 gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
402 pm_runtime_put(&btdev->serdev->dev);
403 btdev->tx_enabled = false;
404 }
405
406 dev_dbg(dev, "protocol setup");
407
408 /* 0. reset connection */
409 err = nokia_reset(hu);
410 if (err < 0) {
411 dev_err(dev, "Reset failed: %d", err);
412 goto out;
413 }
414
415 /* 1. negotiate speed etc */
416 err = nokia_send_negotiation(hu);
417 if (err < 0) {
418 dev_err(dev, "Negotiation failed: %d", err);
419 goto out;
420 }
421
422 /* 2. verify correct setup using alive packet */
423 err = nokia_send_alive_packet(hu);
424 if (err < 0) {
425 dev_err(dev, "Alive check failed: %d", err);
426 goto out;
427 }
428
429 /* 3. send firmware */
430 err = nokia_setup_fw(hu);
431 if (err < 0) {
432 dev_err(dev, "Could not setup FW: %d", err);
433 goto out;
434 }
435
436 nokia_flow_control(btdev->serdev, false);
437 serdev_device_set_baudrate(btdev->serdev, MAX_BAUD_RATE);
438 nokia_flow_control(btdev->serdev, true);
439
440 if (btdev->man_id == NOKIA_ID_BCM2048) {
441 hu->hdev->set_bdaddr = btbcm_set_bdaddr;
442 set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks);
443 dev_dbg(dev, "bcm2048 has invalid bluetooth address!");
444 }
445
446 dev_dbg(dev, "protocol setup done!");
447
448 gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
449 pm_runtime_put(dev);
450 btdev->tx_enabled = false;
451 btdev->initialized = true;
452
453 return 0;
454out:
455 pm_runtime_put(dev);
456
457 return err;
458}
459
460static int nokia_open(struct hci_uart *hu)
461{
462 struct device *dev = &hu->serdev->dev;
463
464 dev_dbg(dev, "protocol open");
465
466 pm_runtime_enable(dev);
467
468 return 0;
469}
470
471static int nokia_flush(struct hci_uart *hu)
472{
473 struct nokia_bt_dev *btdev = hu->priv;
474
475 dev_dbg(&btdev->serdev->dev, "flush device");
476
477 skb_queue_purge(&btdev->txq);
478
479 return 0;
480}
481
482static int nokia_close(struct hci_uart *hu)
483{
484 struct nokia_bt_dev *btdev = hu->priv;
485 struct device *dev = &btdev->serdev->dev;
486
487 dev_dbg(dev, "close device");
488
489 btdev->initialized = false;
490
491 skb_queue_purge(&btdev->txq);
492
493 kfree_skb(btdev->rx_skb);
494
495 /* disable module */
496 gpiod_set_value(btdev->reset, 1);
497 gpiod_set_value(btdev->wakeup_bt, 0);
498
499 pm_runtime_disable(&btdev->serdev->dev);
500
501 return 0;
502}
503
504/* Enqueue frame for transmission (padding, crc, etc) */
505static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb)
506{
507 struct nokia_bt_dev *btdev = hu->priv;
508 int err;
509
510 /* Prepend skb with frame type */
511 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
512
513 /* Packets must be word aligned */
514 if (skb->len % 2) {
515 err = skb_pad(skb, 1);
516 if (err)
517 return err;
518 skb_put(skb, 1);
519 }
520
521 skb_queue_tail(&btdev->txq, skb);
522
523 return 0;
524}
525
526static int nokia_recv_negotiation_packet(struct hci_dev *hdev,
527 struct sk_buff *skb)
528{
529 struct hci_uart *hu = hci_get_drvdata(hdev);
530 struct nokia_bt_dev *btdev = hu->priv;
531 struct device *dev = &btdev->serdev->dev;
532 struct hci_nokia_neg_hdr *hdr;
533 struct hci_nokia_neg_evt *evt;
534 int ret = 0;
535
536 hdr = (struct hci_nokia_neg_hdr *)skb->data;
537 if (hdr->dlen != sizeof(*evt)) {
538 btdev->init_error = -EIO;
539 ret = -EIO;
540 goto finish_neg;
541 }
542
543 evt = skb_pull(skb, sizeof(*hdr));
544
545 if (evt->ack != NOKIA_NEG_ACK) {
546 dev_err(dev, "Negotiation received: wrong reply");
547 btdev->init_error = -EINVAL;
548 ret = -EINVAL;
549 goto finish_neg;
550 }
551
552 btdev->man_id = evt->man_id;
553 btdev->ver_id = evt->ver_id;
554
555 dev_dbg(dev, "Negotiation received: baud=%u:clk=%u:manu=%u:vers=%u",
556 evt->baud, evt->sys_clk, evt->man_id, evt->ver_id);
557
558finish_neg:
559 complete(&btdev->init_completion);
560 kfree_skb(skb);
561 return ret;
562}
563
564static int nokia_recv_alive_packet(struct hci_dev *hdev, struct sk_buff *skb)
565{
566 struct hci_uart *hu = hci_get_drvdata(hdev);
567 struct nokia_bt_dev *btdev = hu->priv;
568 struct device *dev = &btdev->serdev->dev;
569 struct hci_nokia_alive_hdr *hdr;
570 struct hci_nokia_alive_pkt *pkt;
571 int ret = 0;
572
573 hdr = (struct hci_nokia_alive_hdr *)skb->data;
574 if (hdr->dlen != sizeof(*pkt)) {
575 dev_err(dev, "Corrupted alive message");
576 btdev->init_error = -EIO;
577 ret = -EIO;
578 goto finish_alive;
579 }
580
581 pkt = skb_pull(skb, sizeof(*hdr));
582
583 if (pkt->mid != NOKIA_ALIVE_RESP) {
584 dev_err(dev, "Alive received: invalid response: 0x%02x!",
585 pkt->mid);
586 btdev->init_error = -EINVAL;
587 ret = -EINVAL;
588 goto finish_alive;
589 }
590
591 dev_dbg(dev, "Alive received");
592
593finish_alive:
594 complete(&btdev->init_completion);
595 kfree_skb(skb);
596 return ret;
597}
598
599static int nokia_recv_radio(struct hci_dev *hdev, struct sk_buff *skb)
600{
601 /* Packets received on the dedicated radio channel are
602 * HCI events and so feed them back into the core.
603 */
604 hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
605 return hci_recv_frame(hdev, skb);
606}
607
608/* Recv data */
609static const struct h4_recv_pkt nokia_recv_pkts[] = {
610 { H4_RECV_ACL, .recv = hci_recv_frame },
611 { H4_RECV_SCO, .recv = hci_recv_frame },
612 { H4_RECV_EVENT, .recv = hci_recv_frame },
613 { NOKIA_RECV_ALIVE, .recv = nokia_recv_alive_packet },
614 { NOKIA_RECV_NEG, .recv = nokia_recv_negotiation_packet },
615 { NOKIA_RECV_RADIO, .recv = nokia_recv_radio },
616};
617
618static int nokia_recv(struct hci_uart *hu, const void *data, int count)
619{
620 struct nokia_bt_dev *btdev = hu->priv;
621 struct device *dev = &btdev->serdev->dev;
622 int err;
623
624 if (!test_bit(HCI_UART_REGISTERED, &hu->flags))
625 return -EUNATCH;
626
627 btdev->rx_skb = h4_recv_buf(hu->hdev, btdev->rx_skb, data, count,
628 nokia_recv_pkts, ARRAY_SIZE(nokia_recv_pkts));
629 if (IS_ERR(btdev->rx_skb)) {
630 err = PTR_ERR(btdev->rx_skb);
631 dev_err(dev, "Frame reassembly failed (%d)", err);
632 btdev->rx_skb = NULL;
633 return err;
634 }
635
636 return count;
637}
638
639static struct sk_buff *nokia_dequeue(struct hci_uart *hu)
640{
641 struct nokia_bt_dev *btdev = hu->priv;
642 struct device *dev = &btdev->serdev->dev;
643 struct sk_buff *result = skb_dequeue(&btdev->txq);
644
645 if (!btdev->initialized)
646 return result;
647
648 if (btdev->tx_enabled == !!result)
649 return result;
650
651 if (result) {
652 pm_runtime_get_sync(dev);
653 gpiod_set_value_cansleep(btdev->wakeup_bt, 1);
654 } else {
655 serdev_device_wait_until_sent(btdev->serdev, 0);
656 gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
657 pm_runtime_put(dev);
658 }
659
660 btdev->tx_enabled = !!result;
661
662 return result;
663}
664
665static const struct hci_uart_proto nokia_proto = {
666 .id = HCI_UART_NOKIA,
667 .name = "Nokia",
668 .open = nokia_open,
669 .close = nokia_close,
670 .recv = nokia_recv,
671 .enqueue = nokia_enqueue,
672 .dequeue = nokia_dequeue,
673 .flush = nokia_flush,
674 .setup = nokia_setup,
675 .manufacturer = 1,
676};
677
678static int nokia_bluetooth_serdev_probe(struct serdev_device *serdev)
679{
680 struct device *dev = &serdev->dev;
681 struct nokia_bt_dev *btdev;
682 struct clk *sysclk;
683 int err = 0;
684
685 btdev = devm_kzalloc(dev, sizeof(*btdev), GFP_KERNEL);
686 if (!btdev)
687 return -ENOMEM;
688
689 btdev->hu.serdev = btdev->serdev = serdev;
690 serdev_device_set_drvdata(serdev, btdev);
691
692 btdev->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
693 if (IS_ERR(btdev->reset)) {
694 err = PTR_ERR(btdev->reset);
695 dev_err(dev, "could not get reset gpio: %d", err);
696 return err;
697 }
698
699 btdev->wakeup_host = devm_gpiod_get(dev, "host-wakeup", GPIOD_IN);
700 if (IS_ERR(btdev->wakeup_host)) {
701 err = PTR_ERR(btdev->wakeup_host);
702 dev_err(dev, "could not get host wakeup gpio: %d", err);
703 return err;
704 }
705
706 btdev->wake_irq = gpiod_to_irq(btdev->wakeup_host);
707
708 err = devm_request_threaded_irq(dev, btdev->wake_irq, NULL,
709 wakeup_handler,
710 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
711 "wakeup", btdev);
712 if (err) {
713 dev_err(dev, "could request wakeup irq: %d", err);
714 return err;
715 }
716
717 btdev->wakeup_bt = devm_gpiod_get(dev, "bluetooth-wakeup",
718 GPIOD_OUT_LOW);
719 if (IS_ERR(btdev->wakeup_bt)) {
720 err = PTR_ERR(btdev->wakeup_bt);
721 dev_err(dev, "could not get BT wakeup gpio: %d", err);
722 return err;
723 }
724
725 sysclk = devm_clk_get(dev, "sysclk");
726 if (IS_ERR(sysclk)) {
727 err = PTR_ERR(sysclk);
728 dev_err(dev, "could not get sysclk: %d", err);
729 return err;
730 }
731
732 err = clk_prepare_enable(sysclk);
733 if (err) {
734 dev_err(dev, "could not enable sysclk: %d", err);
735 return err;
736 }
737 btdev->sysclk_speed = clk_get_rate(sysclk);
738 clk_disable_unprepare(sysclk);
739
740 skb_queue_head_init(&btdev->txq);
741
742 btdev->hu.priv = btdev;
743 btdev->hu.alignment = 2; /* Nokia H4+ is word aligned */
744
745 err = hci_uart_register_device(&btdev->hu, &nokia_proto);
746 if (err) {
747 dev_err(dev, "could not register bluetooth uart: %d", err);
748 return err;
749 }
750
751 return 0;
752}
753
754static void nokia_bluetooth_serdev_remove(struct serdev_device *serdev)
755{
756 struct nokia_bt_dev *btdev = serdev_device_get_drvdata(serdev);
757
758 hci_uart_unregister_device(&btdev->hu);
759}
760
761static int nokia_bluetooth_runtime_suspend(struct device *dev)
762{
763 struct serdev_device *serdev = to_serdev_device(dev);
764
765 nokia_flow_control(serdev, false);
766 return 0;
767}
768
769static int nokia_bluetooth_runtime_resume(struct device *dev)
770{
771 struct serdev_device *serdev = to_serdev_device(dev);
772
773 nokia_flow_control(serdev, true);
774 return 0;
775}
776
777static const struct dev_pm_ops nokia_bluetooth_pm_ops = {
778 SET_RUNTIME_PM_OPS(nokia_bluetooth_runtime_suspend,
779 nokia_bluetooth_runtime_resume,
780 NULL)
781};
782
783#ifdef CONFIG_OF
784static const struct of_device_id nokia_bluetooth_of_match[] = {
785 { .compatible = "nokia,h4p-bluetooth", },
786 {},
787};
788MODULE_DEVICE_TABLE(of, nokia_bluetooth_of_match);
789#endif
790
791static struct serdev_device_driver nokia_bluetooth_serdev_driver = {
792 .probe = nokia_bluetooth_serdev_probe,
793 .remove = nokia_bluetooth_serdev_remove,
794 .driver = {
795 .name = "nokia-bluetooth",
796 .pm = &nokia_bluetooth_pm_ops,
797 .of_match_table = of_match_ptr(nokia_bluetooth_of_match),
798 },
799};
800
801module_serdev_device_driver(nokia_bluetooth_serdev_driver);
802
803MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>");
804MODULE_DESCRIPTION("Bluetooth HCI UART Nokia H4+ driver ver " VERSION);
805MODULE_VERSION(VERSION);
806MODULE_LICENSE("GPL");
1/*
2 * Bluetooth HCI UART H4 driver with Nokia Extensions AKA Nokia H4+
3 *
4 * Copyright (C) 2015 Marcel Holtmann <marcel@holtmann.org>
5 * Copyright (C) 2015-2017 Sebastian Reichel <sre@kernel.org>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 */
17
18#include <linux/clk.h>
19#include <linux/errno.h>
20#include <linux/firmware.h>
21#include <linux/gpio/consumer.h>
22#include <linux/interrupt.h>
23#include <linux/kernel.h>
24#include <linux/module.h>
25#include <linux/of.h>
26#include <linux/pm_runtime.h>
27#include <linux/serdev.h>
28#include <linux/skbuff.h>
29#include <linux/slab.h>
30#include <linux/string.h>
31#include <linux/types.h>
32#include <linux/unaligned/le_struct.h>
33#include <net/bluetooth/bluetooth.h>
34#include <net/bluetooth/hci_core.h>
35
36#include "hci_uart.h"
37#include "btbcm.h"
38
39#define VERSION "0.1"
40
41#define NOKIA_ID_BCM2048 0x04
42#define NOKIA_ID_TI1271 0x31
43
44#define FIRMWARE_BCM2048 "nokia/bcmfw.bin"
45#define FIRMWARE_TI1271 "nokia/ti1273.bin"
46
47#define HCI_NOKIA_NEG_PKT 0x06
48#define HCI_NOKIA_ALIVE_PKT 0x07
49#define HCI_NOKIA_RADIO_PKT 0x08
50
51#define HCI_NOKIA_NEG_HDR_SIZE 1
52#define HCI_NOKIA_MAX_NEG_SIZE 255
53#define HCI_NOKIA_ALIVE_HDR_SIZE 1
54#define HCI_NOKIA_MAX_ALIVE_SIZE 255
55#define HCI_NOKIA_RADIO_HDR_SIZE 2
56#define HCI_NOKIA_MAX_RADIO_SIZE 255
57
58#define NOKIA_PROTO_PKT 0x44
59#define NOKIA_PROTO_BYTE 0x4c
60
61#define NOKIA_NEG_REQ 0x00
62#define NOKIA_NEG_ACK 0x20
63#define NOKIA_NEG_NAK 0x40
64
65#define H4_TYPE_SIZE 1
66
67#define NOKIA_RECV_ALIVE \
68 .type = HCI_NOKIA_ALIVE_PKT, \
69 .hlen = HCI_NOKIA_ALIVE_HDR_SIZE, \
70 .loff = 0, \
71 .lsize = 1, \
72 .maxlen = HCI_NOKIA_MAX_ALIVE_SIZE \
73
74#define NOKIA_RECV_NEG \
75 .type = HCI_NOKIA_NEG_PKT, \
76 .hlen = HCI_NOKIA_NEG_HDR_SIZE, \
77 .loff = 0, \
78 .lsize = 1, \
79 .maxlen = HCI_NOKIA_MAX_NEG_SIZE \
80
81#define NOKIA_RECV_RADIO \
82 .type = HCI_NOKIA_RADIO_PKT, \
83 .hlen = HCI_NOKIA_RADIO_HDR_SIZE, \
84 .loff = 1, \
85 .lsize = 1, \
86 .maxlen = HCI_NOKIA_MAX_RADIO_SIZE \
87
88struct hci_nokia_neg_hdr {
89 u8 dlen;
90} __packed;
91
92struct hci_nokia_neg_cmd {
93 u8 ack;
94 u16 baud;
95 u16 unused1;
96 u8 proto;
97 u16 sys_clk;
98 u16 unused2;
99} __packed;
100
101#define NOKIA_ALIVE_REQ 0x55
102#define NOKIA_ALIVE_RESP 0xcc
103
104struct hci_nokia_alive_hdr {
105 u8 dlen;
106} __packed;
107
108struct hci_nokia_alive_pkt {
109 u8 mid;
110 u8 unused;
111} __packed;
112
113struct hci_nokia_neg_evt {
114 u8 ack;
115 u16 baud;
116 u16 unused1;
117 u8 proto;
118 u16 sys_clk;
119 u16 unused2;
120 u8 man_id;
121 u8 ver_id;
122} __packed;
123
124#define MAX_BAUD_RATE 3692300
125#define SETUP_BAUD_RATE 921600
126#define INIT_BAUD_RATE 120000
127
128struct hci_nokia_radio_hdr {
129 u8 evt;
130 u8 dlen;
131} __packed;
132
133struct nokia_bt_dev {
134 struct hci_uart hu;
135 struct serdev_device *serdev;
136
137 struct gpio_desc *reset;
138 struct gpio_desc *wakeup_host;
139 struct gpio_desc *wakeup_bt;
140 unsigned long sysclk_speed;
141
142 int wake_irq;
143 struct sk_buff *rx_skb;
144 struct sk_buff_head txq;
145 bdaddr_t bdaddr;
146
147 int init_error;
148 struct completion init_completion;
149
150 u8 man_id;
151 u8 ver_id;
152
153 bool initialized;
154 bool tx_enabled;
155 bool rx_enabled;
156};
157
158static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb);
159
160static void nokia_flow_control(struct serdev_device *serdev, bool enable)
161{
162 if (enable) {
163 serdev_device_set_rts(serdev, true);
164 serdev_device_set_flow_control(serdev, true);
165 } else {
166 serdev_device_set_flow_control(serdev, false);
167 serdev_device_set_rts(serdev, false);
168 }
169}
170
171static irqreturn_t wakeup_handler(int irq, void *data)
172{
173 struct nokia_bt_dev *btdev = data;
174 struct device *dev = &btdev->serdev->dev;
175 int wake_state = gpiod_get_value(btdev->wakeup_host);
176
177 if (btdev->rx_enabled == wake_state)
178 return IRQ_HANDLED;
179
180 if (wake_state)
181 pm_runtime_get(dev);
182 else
183 pm_runtime_put(dev);
184
185 btdev->rx_enabled = wake_state;
186
187 return IRQ_HANDLED;
188}
189
190static int nokia_reset(struct hci_uart *hu)
191{
192 struct nokia_bt_dev *btdev = hu->priv;
193 struct device *dev = &btdev->serdev->dev;
194 int err;
195
196 /* reset routine */
197 gpiod_set_value_cansleep(btdev->reset, 1);
198 gpiod_set_value_cansleep(btdev->wakeup_bt, 1);
199
200 msleep(100);
201
202 /* safety check */
203 err = gpiod_get_value_cansleep(btdev->wakeup_host);
204 if (err == 1) {
205 dev_err(dev, "reset: host wakeup not low!");
206 return -EPROTO;
207 }
208
209 /* flush queue */
210 serdev_device_write_flush(btdev->serdev);
211
212 /* init uart */
213 nokia_flow_control(btdev->serdev, false);
214 serdev_device_set_baudrate(btdev->serdev, INIT_BAUD_RATE);
215
216 gpiod_set_value_cansleep(btdev->reset, 0);
217
218 /* wait for cts */
219 err = serdev_device_wait_for_cts(btdev->serdev, true, 200);
220 if (err < 0) {
221 dev_err(dev, "CTS not received: %d", err);
222 return err;
223 }
224
225 nokia_flow_control(btdev->serdev, true);
226
227 return 0;
228}
229
230static int nokia_send_alive_packet(struct hci_uart *hu)
231{
232 struct nokia_bt_dev *btdev = hu->priv;
233 struct device *dev = &btdev->serdev->dev;
234 struct hci_nokia_alive_hdr *hdr;
235 struct hci_nokia_alive_pkt *pkt;
236 struct sk_buff *skb;
237 int len;
238
239 init_completion(&btdev->init_completion);
240
241 len = H4_TYPE_SIZE + sizeof(*hdr) + sizeof(*pkt);
242 skb = bt_skb_alloc(len, GFP_KERNEL);
243 if (!skb)
244 return -ENOMEM;
245
246 hci_skb_pkt_type(skb) = HCI_NOKIA_ALIVE_PKT;
247 memset(skb->data, 0x00, len);
248
249 hdr = skb_put(skb, sizeof(*hdr));
250 hdr->dlen = sizeof(*pkt);
251 pkt = skb_put(skb, sizeof(*pkt));
252 pkt->mid = NOKIA_ALIVE_REQ;
253
254 nokia_enqueue(hu, skb);
255 hci_uart_tx_wakeup(hu);
256
257 dev_dbg(dev, "Alive sent");
258
259 if (!wait_for_completion_interruptible_timeout(&btdev->init_completion,
260 msecs_to_jiffies(1000))) {
261 return -ETIMEDOUT;
262 }
263
264 if (btdev->init_error < 0)
265 return btdev->init_error;
266
267 return 0;
268}
269
270static int nokia_send_negotiation(struct hci_uart *hu)
271{
272 struct nokia_bt_dev *btdev = hu->priv;
273 struct device *dev = &btdev->serdev->dev;
274 struct hci_nokia_neg_cmd *neg_cmd;
275 struct hci_nokia_neg_hdr *neg_hdr;
276 struct sk_buff *skb;
277 int len, err;
278 u16 baud = DIV_ROUND_CLOSEST(btdev->sysclk_speed * 10, SETUP_BAUD_RATE);
279 int sysclk = btdev->sysclk_speed / 1000;
280
281 len = H4_TYPE_SIZE + sizeof(*neg_hdr) + sizeof(*neg_cmd);
282 skb = bt_skb_alloc(len, GFP_KERNEL);
283 if (!skb)
284 return -ENOMEM;
285
286 hci_skb_pkt_type(skb) = HCI_NOKIA_NEG_PKT;
287
288 neg_hdr = skb_put(skb, sizeof(*neg_hdr));
289 neg_hdr->dlen = sizeof(*neg_cmd);
290
291 neg_cmd = skb_put(skb, sizeof(*neg_cmd));
292 neg_cmd->ack = NOKIA_NEG_REQ;
293 neg_cmd->baud = cpu_to_le16(baud);
294 neg_cmd->unused1 = 0x0000;
295 neg_cmd->proto = NOKIA_PROTO_BYTE;
296 neg_cmd->sys_clk = cpu_to_le16(sysclk);
297 neg_cmd->unused2 = 0x0000;
298
299 btdev->init_error = 0;
300 init_completion(&btdev->init_completion);
301
302 nokia_enqueue(hu, skb);
303 hci_uart_tx_wakeup(hu);
304
305 dev_dbg(dev, "Negotiation sent");
306
307 if (!wait_for_completion_interruptible_timeout(&btdev->init_completion,
308 msecs_to_jiffies(10000))) {
309 return -ETIMEDOUT;
310 }
311
312 if (btdev->init_error < 0)
313 return btdev->init_error;
314
315 /* Change to previously negotiated speed. Flow Control
316 * is disabled until bluetooth adapter is ready to avoid
317 * broken bytes being received.
318 */
319 nokia_flow_control(btdev->serdev, false);
320 serdev_device_set_baudrate(btdev->serdev, SETUP_BAUD_RATE);
321 err = serdev_device_wait_for_cts(btdev->serdev, true, 200);
322 if (err < 0) {
323 dev_err(dev, "CTS not received: %d", err);
324 return err;
325 }
326 nokia_flow_control(btdev->serdev, true);
327
328 dev_dbg(dev, "Negotiation successful");
329
330 return 0;
331}
332
333static int nokia_setup_fw(struct hci_uart *hu)
334{
335 struct nokia_bt_dev *btdev = hu->priv;
336 struct device *dev = &btdev->serdev->dev;
337 const char *fwname;
338 const struct firmware *fw;
339 const u8 *fw_ptr;
340 size_t fw_size;
341 int err;
342
343 dev_dbg(dev, "setup firmware");
344
345 if (btdev->man_id == NOKIA_ID_BCM2048) {
346 fwname = FIRMWARE_BCM2048;
347 } else if (btdev->man_id == NOKIA_ID_TI1271) {
348 fwname = FIRMWARE_TI1271;
349 } else {
350 dev_err(dev, "Unsupported bluetooth device!");
351 return -ENODEV;
352 }
353
354 err = request_firmware(&fw, fwname, dev);
355 if (err < 0) {
356 dev_err(dev, "%s: Failed to load Nokia firmware file (%d)",
357 hu->hdev->name, err);
358 return err;
359 }
360
361 fw_ptr = fw->data;
362 fw_size = fw->size;
363
364 while (fw_size >= 4) {
365 u16 pkt_size = get_unaligned_le16(fw_ptr);
366 u8 pkt_type = fw_ptr[2];
367 const struct hci_command_hdr *cmd;
368 u16 opcode;
369 struct sk_buff *skb;
370
371 switch (pkt_type) {
372 case HCI_COMMAND_PKT:
373 cmd = (struct hci_command_hdr *)(fw_ptr + 3);
374 opcode = le16_to_cpu(cmd->opcode);
375
376 skb = __hci_cmd_sync(hu->hdev, opcode, cmd->plen,
377 fw_ptr + 3 + HCI_COMMAND_HDR_SIZE,
378 HCI_INIT_TIMEOUT);
379 if (IS_ERR(skb)) {
380 err = PTR_ERR(skb);
381 dev_err(dev, "%s: FW command %04x failed (%d)",
382 hu->hdev->name, opcode, err);
383 goto done;
384 }
385 kfree_skb(skb);
386 break;
387 case HCI_NOKIA_RADIO_PKT:
388 case HCI_NOKIA_NEG_PKT:
389 case HCI_NOKIA_ALIVE_PKT:
390 break;
391 }
392
393 fw_ptr += pkt_size + 2;
394 fw_size -= pkt_size + 2;
395 }
396
397done:
398 release_firmware(fw);
399 return err;
400}
401
402static int nokia_setup(struct hci_uart *hu)
403{
404 struct nokia_bt_dev *btdev = hu->priv;
405 struct device *dev = &btdev->serdev->dev;
406 int err;
407
408 btdev->initialized = false;
409
410 nokia_flow_control(btdev->serdev, false);
411
412 pm_runtime_get_sync(dev);
413
414 if (btdev->tx_enabled) {
415 gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
416 pm_runtime_put(&btdev->serdev->dev);
417 btdev->tx_enabled = false;
418 }
419
420 dev_dbg(dev, "protocol setup");
421
422 /* 0. reset connection */
423 err = nokia_reset(hu);
424 if (err < 0) {
425 dev_err(dev, "Reset failed: %d", err);
426 goto out;
427 }
428
429 /* 1. negotiate speed etc */
430 err = nokia_send_negotiation(hu);
431 if (err < 0) {
432 dev_err(dev, "Negotiation failed: %d", err);
433 goto out;
434 }
435
436 /* 2. verify correct setup using alive packet */
437 err = nokia_send_alive_packet(hu);
438 if (err < 0) {
439 dev_err(dev, "Alive check failed: %d", err);
440 goto out;
441 }
442
443 /* 3. send firmware */
444 err = nokia_setup_fw(hu);
445 if (err < 0) {
446 dev_err(dev, "Could not setup FW: %d", err);
447 goto out;
448 }
449
450 nokia_flow_control(btdev->serdev, false);
451 serdev_device_set_baudrate(btdev->serdev, MAX_BAUD_RATE);
452 nokia_flow_control(btdev->serdev, true);
453
454 if (btdev->man_id == NOKIA_ID_BCM2048) {
455 hu->hdev->set_bdaddr = btbcm_set_bdaddr;
456 set_bit(HCI_QUIRK_INVALID_BDADDR, &hu->hdev->quirks);
457 dev_dbg(dev, "bcm2048 has invalid bluetooth address!");
458 }
459
460 dev_dbg(dev, "protocol setup done!");
461
462 gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
463 pm_runtime_put(dev);
464 btdev->tx_enabled = false;
465 btdev->initialized = true;
466
467 return 0;
468out:
469 pm_runtime_put(dev);
470
471 return err;
472}
473
474static int nokia_open(struct hci_uart *hu)
475{
476 struct device *dev = &hu->serdev->dev;
477
478 dev_dbg(dev, "protocol open");
479
480 serdev_device_open(hu->serdev);
481
482 pm_runtime_enable(dev);
483
484 return 0;
485}
486
487static int nokia_flush(struct hci_uart *hu)
488{
489 struct nokia_bt_dev *btdev = hu->priv;
490
491 dev_dbg(&btdev->serdev->dev, "flush device");
492
493 skb_queue_purge(&btdev->txq);
494
495 return 0;
496}
497
498static int nokia_close(struct hci_uart *hu)
499{
500 struct nokia_bt_dev *btdev = hu->priv;
501 struct device *dev = &btdev->serdev->dev;
502
503 dev_dbg(dev, "close device");
504
505 btdev->initialized = false;
506
507 skb_queue_purge(&btdev->txq);
508
509 kfree_skb(btdev->rx_skb);
510
511 /* disable module */
512 gpiod_set_value(btdev->reset, 1);
513 gpiod_set_value(btdev->wakeup_bt, 0);
514
515 pm_runtime_disable(&btdev->serdev->dev);
516 serdev_device_close(btdev->serdev);
517
518 return 0;
519}
520
521/* Enqueue frame for transmittion (padding, crc, etc) */
522static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb)
523{
524 struct nokia_bt_dev *btdev = hu->priv;
525 int err;
526
527 /* Prepend skb with frame type */
528 memcpy(skb_push(skb, 1), &bt_cb(skb)->pkt_type, 1);
529
530 /* Packets must be word aligned */
531 if (skb->len % 2) {
532 err = skb_pad(skb, 1);
533 if (err)
534 return err;
535 skb_put_u8(skb, 0x00);
536 }
537
538 skb_queue_tail(&btdev->txq, skb);
539
540 return 0;
541}
542
543static int nokia_recv_negotiation_packet(struct hci_dev *hdev,
544 struct sk_buff *skb)
545{
546 struct hci_uart *hu = hci_get_drvdata(hdev);
547 struct nokia_bt_dev *btdev = hu->priv;
548 struct device *dev = &btdev->serdev->dev;
549 struct hci_nokia_neg_hdr *hdr;
550 struct hci_nokia_neg_evt *evt;
551 int ret = 0;
552
553 hdr = (struct hci_nokia_neg_hdr *)skb->data;
554 if (hdr->dlen != sizeof(*evt)) {
555 btdev->init_error = -EIO;
556 ret = -EIO;
557 goto finish_neg;
558 }
559
560 evt = skb_pull(skb, sizeof(*hdr));
561
562 if (evt->ack != NOKIA_NEG_ACK) {
563 dev_err(dev, "Negotiation received: wrong reply");
564 btdev->init_error = -EINVAL;
565 ret = -EINVAL;
566 goto finish_neg;
567 }
568
569 btdev->man_id = evt->man_id;
570 btdev->ver_id = evt->ver_id;
571
572 dev_dbg(dev, "Negotiation received: baud=%u:clk=%u:manu=%u:vers=%u",
573 evt->baud, evt->sys_clk, evt->man_id, evt->ver_id);
574
575finish_neg:
576 complete(&btdev->init_completion);
577 kfree_skb(skb);
578 return ret;
579}
580
581static int nokia_recv_alive_packet(struct hci_dev *hdev, struct sk_buff *skb)
582{
583 struct hci_uart *hu = hci_get_drvdata(hdev);
584 struct nokia_bt_dev *btdev = hu->priv;
585 struct device *dev = &btdev->serdev->dev;
586 struct hci_nokia_alive_hdr *hdr;
587 struct hci_nokia_alive_pkt *pkt;
588 int ret = 0;
589
590 hdr = (struct hci_nokia_alive_hdr *)skb->data;
591 if (hdr->dlen != sizeof(*pkt)) {
592 dev_err(dev, "Corrupted alive message");
593 btdev->init_error = -EIO;
594 ret = -EIO;
595 goto finish_alive;
596 }
597
598 pkt = skb_pull(skb, sizeof(*hdr));
599
600 if (pkt->mid != NOKIA_ALIVE_RESP) {
601 dev_err(dev, "Alive received: invalid response: 0x%02x!",
602 pkt->mid);
603 btdev->init_error = -EINVAL;
604 ret = -EINVAL;
605 goto finish_alive;
606 }
607
608 dev_dbg(dev, "Alive received");
609
610finish_alive:
611 complete(&btdev->init_completion);
612 kfree_skb(skb);
613 return ret;
614}
615
616static int nokia_recv_radio(struct hci_dev *hdev, struct sk_buff *skb)
617{
618 /* Packets received on the dedicated radio channel are
619 * HCI events and so feed them back into the core.
620 */
621 hci_skb_pkt_type(skb) = HCI_EVENT_PKT;
622 return hci_recv_frame(hdev, skb);
623}
624
625/* Recv data */
626static const struct h4_recv_pkt nokia_recv_pkts[] = {
627 { H4_RECV_ACL, .recv = hci_recv_frame },
628 { H4_RECV_SCO, .recv = hci_recv_frame },
629 { H4_RECV_EVENT, .recv = hci_recv_frame },
630 { NOKIA_RECV_ALIVE, .recv = nokia_recv_alive_packet },
631 { NOKIA_RECV_NEG, .recv = nokia_recv_negotiation_packet },
632 { NOKIA_RECV_RADIO, .recv = nokia_recv_radio },
633};
634
635static int nokia_recv(struct hci_uart *hu, const void *data, int count)
636{
637 struct nokia_bt_dev *btdev = hu->priv;
638 struct device *dev = &btdev->serdev->dev;
639 int err;
640
641 if (!test_bit(HCI_UART_REGISTERED, &hu->flags))
642 return -EUNATCH;
643
644 btdev->rx_skb = h4_recv_buf(hu->hdev, btdev->rx_skb, data, count,
645 nokia_recv_pkts, ARRAY_SIZE(nokia_recv_pkts));
646 if (IS_ERR(btdev->rx_skb)) {
647 err = PTR_ERR(btdev->rx_skb);
648 dev_err(dev, "Frame reassembly failed (%d)", err);
649 btdev->rx_skb = NULL;
650 return err;
651 }
652
653 return count;
654}
655
656static struct sk_buff *nokia_dequeue(struct hci_uart *hu)
657{
658 struct nokia_bt_dev *btdev = hu->priv;
659 struct device *dev = &btdev->serdev->dev;
660 struct sk_buff *result = skb_dequeue(&btdev->txq);
661
662 if (!btdev->initialized)
663 return result;
664
665 if (btdev->tx_enabled == !!result)
666 return result;
667
668 if (result) {
669 pm_runtime_get_sync(dev);
670 gpiod_set_value_cansleep(btdev->wakeup_bt, 1);
671 } else {
672 serdev_device_wait_until_sent(btdev->serdev, 0);
673 gpiod_set_value_cansleep(btdev->wakeup_bt, 0);
674 pm_runtime_put(dev);
675 }
676
677 btdev->tx_enabled = !!result;
678
679 return result;
680}
681
682static const struct hci_uart_proto nokia_proto = {
683 .id = HCI_UART_NOKIA,
684 .name = "Nokia",
685 .open = nokia_open,
686 .close = nokia_close,
687 .recv = nokia_recv,
688 .enqueue = nokia_enqueue,
689 .dequeue = nokia_dequeue,
690 .flush = nokia_flush,
691 .setup = nokia_setup,
692 .manufacturer = 1,
693};
694
695static int nokia_bluetooth_serdev_probe(struct serdev_device *serdev)
696{
697 struct device *dev = &serdev->dev;
698 struct nokia_bt_dev *btdev;
699 struct clk *sysclk;
700 int err = 0;
701
702 btdev = devm_kzalloc(dev, sizeof(*btdev), GFP_KERNEL);
703 if (!btdev)
704 return -ENOMEM;
705
706 btdev->hu.serdev = btdev->serdev = serdev;
707 serdev_device_set_drvdata(serdev, btdev);
708
709 btdev->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
710 if (IS_ERR(btdev->reset)) {
711 err = PTR_ERR(btdev->reset);
712 dev_err(dev, "could not get reset gpio: %d", err);
713 return err;
714 }
715
716 btdev->wakeup_host = devm_gpiod_get(dev, "host-wakeup", GPIOD_IN);
717 if (IS_ERR(btdev->wakeup_host)) {
718 err = PTR_ERR(btdev->wakeup_host);
719 dev_err(dev, "could not get host wakeup gpio: %d", err);
720 return err;
721 }
722
723 btdev->wake_irq = gpiod_to_irq(btdev->wakeup_host);
724
725 err = devm_request_threaded_irq(dev, btdev->wake_irq, NULL,
726 wakeup_handler,
727 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
728 "wakeup", btdev);
729 if (err) {
730 dev_err(dev, "could request wakeup irq: %d", err);
731 return err;
732 }
733
734 btdev->wakeup_bt = devm_gpiod_get(dev, "bluetooth-wakeup",
735 GPIOD_OUT_LOW);
736 if (IS_ERR(btdev->wakeup_bt)) {
737 err = PTR_ERR(btdev->wakeup_bt);
738 dev_err(dev, "could not get BT wakeup gpio: %d", err);
739 return err;
740 }
741
742 sysclk = devm_clk_get(dev, "sysclk");
743 if (IS_ERR(sysclk)) {
744 err = PTR_ERR(sysclk);
745 dev_err(dev, "could not get sysclk: %d", err);
746 return err;
747 }
748
749 clk_prepare_enable(sysclk);
750 btdev->sysclk_speed = clk_get_rate(sysclk);
751 clk_disable_unprepare(sysclk);
752
753 skb_queue_head_init(&btdev->txq);
754
755 btdev->hu.priv = btdev;
756 btdev->hu.alignment = 2; /* Nokia H4+ is word aligned */
757
758 err = hci_uart_register_device(&btdev->hu, &nokia_proto);
759 if (err) {
760 dev_err(dev, "could not register bluetooth uart: %d", err);
761 return err;
762 }
763
764 return 0;
765}
766
767static void nokia_bluetooth_serdev_remove(struct serdev_device *serdev)
768{
769 struct nokia_bt_dev *btdev = serdev_device_get_drvdata(serdev);
770
771 hci_uart_unregister_device(&btdev->hu);
772}
773
774static int nokia_bluetooth_runtime_suspend(struct device *dev)
775{
776 struct serdev_device *serdev = to_serdev_device(dev);
777
778 nokia_flow_control(serdev, false);
779 return 0;
780}
781
782static int nokia_bluetooth_runtime_resume(struct device *dev)
783{
784 struct serdev_device *serdev = to_serdev_device(dev);
785
786 nokia_flow_control(serdev, true);
787 return 0;
788}
789
790static const struct dev_pm_ops nokia_bluetooth_pm_ops = {
791 SET_RUNTIME_PM_OPS(nokia_bluetooth_runtime_suspend,
792 nokia_bluetooth_runtime_resume,
793 NULL)
794};
795
796#ifdef CONFIG_OF
797static const struct of_device_id nokia_bluetooth_of_match[] = {
798 { .compatible = "nokia,h4p-bluetooth", },
799 {},
800};
801MODULE_DEVICE_TABLE(of, nokia_bluetooth_of_match);
802#endif
803
804static struct serdev_device_driver nokia_bluetooth_serdev_driver = {
805 .probe = nokia_bluetooth_serdev_probe,
806 .remove = nokia_bluetooth_serdev_remove,
807 .driver = {
808 .name = "nokia-bluetooth",
809 .pm = &nokia_bluetooth_pm_ops,
810 .of_match_table = of_match_ptr(nokia_bluetooth_of_match),
811 },
812};
813
814module_serdev_device_driver(nokia_bluetooth_serdev_driver);
815
816MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>");
817MODULE_DESCRIPTION("Bluetooth HCI UART Nokia H4+ driver ver " VERSION);
818MODULE_VERSION(VERSION);
819MODULE_LICENSE("GPL");