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