072a77a61e67d9e7ac817006d9b19c1dff8bbb49
[sfrench/cifs-2.6.git] / drivers / bluetooth / hci_nokia.c
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
88 struct hci_nokia_neg_hdr {
89         u8      dlen;
90 } __packed;
91
92 struct 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
104 struct hci_nokia_alive_hdr {
105         u8      dlen;
106 } __packed;
107
108 struct hci_nokia_alive_pkt {
109         u8      mid;
110         u8      unused;
111 } __packed;
112
113 struct 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
128 struct hci_nokia_radio_hdr {
129         u8      evt;
130         u8      dlen;
131 } __packed;
132
133 struct 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
158 static int nokia_enqueue(struct hci_uart *hu, struct sk_buff *skb);
159
160 static 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
171 static 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
190 static 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
230 static 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
270 static 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
333 static 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
397 done:
398         release_firmware(fw);
399         return err;
400 }
401
402 static 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;
468 out:
469         pm_runtime_put(dev);
470
471         return err;
472 }
473
474 static 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
487 static 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
498 static 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) */
522 static 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                 *(u8 *)skb_put(skb, 1) = 0x00;
536         }
537
538         skb_queue_tail(&btdev->txq, skb);
539
540         return 0;
541 }
542
543 static 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
575 finish_neg:
576         complete(&btdev->init_completion);
577         kfree_skb(skb);
578         return ret;
579 }
580
581 static 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
610 finish_alive:
611         complete(&btdev->init_completion);
612         kfree_skb(skb);
613         return ret;
614 }
615
616 static 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 */
626 static 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
635 static 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
656 static 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
682 static 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
695 static 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
767 static void nokia_bluetooth_serdev_remove(struct serdev_device *serdev)
768 {
769         struct nokia_bt_dev *btdev = serdev_device_get_drvdata(serdev);
770         struct hci_uart *hu = &btdev->hu;
771         struct hci_dev *hdev = hu->hdev;
772
773         cancel_work_sync(&hu->write_work);
774
775         hci_unregister_dev(hdev);
776         hci_free_dev(hdev);
777         hu->proto->close(hu);
778
779         pm_runtime_disable(&btdev->serdev->dev);
780 }
781
782 static int nokia_bluetooth_runtime_suspend(struct device *dev)
783 {
784         struct serdev_device *serdev = to_serdev_device(dev);
785
786         nokia_flow_control(serdev, false);
787         return 0;
788 }
789
790 static int nokia_bluetooth_runtime_resume(struct device *dev)
791 {
792         struct serdev_device *serdev = to_serdev_device(dev);
793
794         nokia_flow_control(serdev, true);
795         return 0;
796 }
797
798 static const struct dev_pm_ops nokia_bluetooth_pm_ops = {
799         SET_RUNTIME_PM_OPS(nokia_bluetooth_runtime_suspend,
800                            nokia_bluetooth_runtime_resume,
801                            NULL)
802 };
803
804 #ifdef CONFIG_OF
805 static const struct of_device_id nokia_bluetooth_of_match[] = {
806         { .compatible = "nokia,h4p-bluetooth", },
807         {},
808 };
809 MODULE_DEVICE_TABLE(of, nokia_bluetooth_of_match);
810 #endif
811
812 static struct serdev_device_driver nokia_bluetooth_serdev_driver = {
813         .probe = nokia_bluetooth_serdev_probe,
814         .remove = nokia_bluetooth_serdev_remove,
815         .driver = {
816                 .name = "nokia-bluetooth",
817                 .pm = &nokia_bluetooth_pm_ops,
818                 .of_match_table = of_match_ptr(nokia_bluetooth_of_match),
819         },
820 };
821
822 module_serdev_device_driver(nokia_bluetooth_serdev_driver);
823
824 MODULE_AUTHOR("Sebastian Reichel <sre@kernel.org>");
825 MODULE_DESCRIPTION("Bluetooth HCI UART Nokia H4+ driver ver " VERSION);
826 MODULE_VERSION(VERSION);
827 MODULE_LICENSE("GPL");