1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Bluetooth HCI serdev driver lib 4 * 5 * Copyright (C) 2017 Linaro, Ltd., Rob Herring <robh@kernel.org> 6 * 7 * Based on hci_ldisc.c: 8 * 9 * Copyright (C) 2000-2001 Qualcomm Incorporated 10 * Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com> 11 * Copyright (C) 2004-2005 Marcel Holtmann <marcel@holtmann.org> 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/types.h> 16 #include <linux/serdev.h> 17 #include <linux/skbuff.h> 18 19 #include <net/bluetooth/bluetooth.h> 20 #include <net/bluetooth/hci_core.h> 21 22 #include "hci_uart.h" 23 24 static inline void hci_uart_tx_complete(struct hci_uart *hu, int pkt_type) 25 { 26 struct hci_dev *hdev = hu->hdev; 27 28 /* Update HCI stat counters */ 29 switch (pkt_type) { 30 case HCI_COMMAND_PKT: 31 hdev->stat.cmd_tx++; 32 break; 33 34 case HCI_ACLDATA_PKT: 35 hdev->stat.acl_tx++; 36 break; 37 38 case HCI_SCODATA_PKT: 39 hdev->stat.sco_tx++; 40 break; 41 } 42 } 43 44 static inline struct sk_buff *hci_uart_dequeue(struct hci_uart *hu) 45 { 46 struct sk_buff *skb = hu->tx_skb; 47 48 if (!skb) { 49 if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) 50 skb = hu->proto->dequeue(hu); 51 } else 52 hu->tx_skb = NULL; 53 54 return skb; 55 } 56 57 static void hci_uart_write_work(struct work_struct *work) 58 { 59 struct hci_uart *hu = container_of(work, struct hci_uart, write_work); 60 struct serdev_device *serdev = hu->serdev; 61 struct hci_dev *hdev = hu->hdev; 62 struct sk_buff *skb; 63 64 /* REVISIT: 65 * should we cope with bad skbs or ->write() returning an error value? 66 */ 67 do { 68 clear_bit(HCI_UART_TX_WAKEUP, &hu->tx_state); 69 70 while ((skb = hci_uart_dequeue(hu))) { 71 int len; 72 73 len = serdev_device_write_buf(serdev, 74 skb->data, skb->len); 75 hdev->stat.byte_tx += len; 76 77 skb_pull(skb, len); 78 if (skb->len) { 79 hu->tx_skb = skb; 80 break; 81 } 82 83 hci_uart_tx_complete(hu, hci_skb_pkt_type(skb)); 84 kfree_skb(skb); 85 } 86 87 clear_bit(HCI_UART_SENDING, &hu->tx_state); 88 } while (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state)); 89 } 90 91 /* ------- Interface to HCI layer ------ */ 92 93 /* Reset device */ 94 static int hci_uart_flush(struct hci_dev *hdev) 95 { 96 struct hci_uart *hu = hci_get_drvdata(hdev); 97 98 BT_DBG("hdev %p serdev %p", hdev, hu->serdev); 99 100 if (hu->tx_skb) { 101 kfree_skb(hu->tx_skb); hu->tx_skb = NULL; 102 } 103 104 /* Flush any pending characters in the driver and discipline. */ 105 serdev_device_write_flush(hu->serdev); 106 107 if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) 108 hu->proto->flush(hu); 109 110 return 0; 111 } 112 113 /* Initialize device */ 114 static int hci_uart_open(struct hci_dev *hdev) 115 { 116 struct hci_uart *hu = hci_get_drvdata(hdev); 117 int err; 118 119 BT_DBG("%s %p", hdev->name, hdev); 120 121 /* When Quirk HCI_QUIRK_NON_PERSISTENT_SETUP is set by 122 * driver, BT SoC is completely turned OFF during 123 * BT OFF. Upon next BT ON UART port should be opened. 124 */ 125 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) { 126 err = serdev_device_open(hu->serdev); 127 if (err) 128 return err; 129 set_bit(HCI_UART_PROTO_READY, &hu->flags); 130 } 131 132 /* Undo clearing this from hci_uart_close() */ 133 hdev->flush = hci_uart_flush; 134 135 return 0; 136 } 137 138 /* Close device */ 139 static int hci_uart_close(struct hci_dev *hdev) 140 { 141 struct hci_uart *hu = hci_get_drvdata(hdev); 142 143 BT_DBG("hdev %p", hdev); 144 145 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) 146 return 0; 147 148 hci_uart_flush(hdev); 149 hdev->flush = NULL; 150 151 /* When QUIRK HCI_QUIRK_NON_PERSISTENT_SETUP is set by driver, 152 * BT SOC is completely powered OFF during BT OFF, holding port 153 * open may drain the battery. 154 */ 155 if (test_bit(HCI_QUIRK_NON_PERSISTENT_SETUP, &hdev->quirks)) { 156 clear_bit(HCI_UART_PROTO_READY, &hu->flags); 157 serdev_device_close(hu->serdev); 158 } 159 160 return 0; 161 } 162 163 /* Send frames from HCI layer */ 164 static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 165 { 166 struct hci_uart *hu = hci_get_drvdata(hdev); 167 168 BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb), 169 skb->len); 170 171 hu->proto->enqueue(hu, skb); 172 173 hci_uart_tx_wakeup(hu); 174 175 return 0; 176 } 177 178 static int hci_uart_setup(struct hci_dev *hdev) 179 { 180 struct hci_uart *hu = hci_get_drvdata(hdev); 181 struct hci_rp_read_local_version *ver; 182 struct sk_buff *skb; 183 unsigned int speed; 184 int err; 185 186 /* Init speed if any */ 187 if (hu->init_speed) 188 speed = hu->init_speed; 189 else if (hu->proto->init_speed) 190 speed = hu->proto->init_speed; 191 else 192 speed = 0; 193 194 if (speed) 195 serdev_device_set_baudrate(hu->serdev, speed); 196 197 /* Operational speed if any */ 198 if (hu->oper_speed) 199 speed = hu->oper_speed; 200 else if (hu->proto->oper_speed) 201 speed = hu->proto->oper_speed; 202 else 203 speed = 0; 204 205 if (hu->proto->set_baudrate && speed) { 206 err = hu->proto->set_baudrate(hu, speed); 207 if (err) 208 bt_dev_err(hdev, "Failed to set baudrate"); 209 else 210 serdev_device_set_baudrate(hu->serdev, speed); 211 } 212 213 if (hu->proto->setup) 214 return hu->proto->setup(hu); 215 216 if (!test_bit(HCI_UART_VND_DETECT, &hu->hdev_flags)) 217 return 0; 218 219 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL, 220 HCI_INIT_TIMEOUT); 221 if (IS_ERR(skb)) { 222 bt_dev_err(hdev, "Reading local version info failed (%ld)", 223 PTR_ERR(skb)); 224 return 0; 225 } 226 227 if (skb->len != sizeof(*ver)) 228 bt_dev_err(hdev, "Event length mismatch for version info"); 229 230 kfree_skb(skb); 231 return 0; 232 } 233 234 /** hci_uart_write_wakeup - transmit buffer wakeup 235 * @serdev: serial device 236 * 237 * This function is called by the serdev framework when it accepts 238 * more data being sent. 239 */ 240 static void hci_uart_write_wakeup(struct serdev_device *serdev) 241 { 242 struct hci_uart *hu = serdev_device_get_drvdata(serdev); 243 244 BT_DBG(""); 245 246 if (!hu || serdev != hu->serdev) { 247 WARN_ON(1); 248 return; 249 } 250 251 if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) 252 hci_uart_tx_wakeup(hu); 253 } 254 255 /** hci_uart_receive_buf - receive buffer wakeup 256 * @serdev: serial device 257 * @data: pointer to received data 258 * @count: count of received data in bytes 259 * 260 * This function is called by the serdev framework when it received data 261 * in the RX buffer. 262 * 263 * Return: number of processed bytes 264 */ 265 static int hci_uart_receive_buf(struct serdev_device *serdev, const u8 *data, 266 size_t count) 267 { 268 struct hci_uart *hu = serdev_device_get_drvdata(serdev); 269 270 if (!hu || serdev != hu->serdev) { 271 WARN_ON(1); 272 return 0; 273 } 274 275 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) 276 return 0; 277 278 /* It does not need a lock here as it is already protected by a mutex in 279 * tty caller 280 */ 281 hu->proto->recv(hu, data, count); 282 283 if (hu->hdev) 284 hu->hdev->stat.byte_rx += count; 285 286 return count; 287 } 288 289 static const struct serdev_device_ops hci_serdev_client_ops = { 290 .receive_buf = hci_uart_receive_buf, 291 .write_wakeup = hci_uart_write_wakeup, 292 }; 293 294 int hci_uart_register_device(struct hci_uart *hu, 295 const struct hci_uart_proto *p) 296 { 297 int err; 298 struct hci_dev *hdev; 299 300 BT_DBG(""); 301 302 serdev_device_set_client_ops(hu->serdev, &hci_serdev_client_ops); 303 304 err = serdev_device_open(hu->serdev); 305 if (err) 306 return err; 307 308 percpu_init_rwsem(&hu->proto_lock); 309 310 err = p->open(hu); 311 if (err) 312 goto err_open; 313 314 hu->proto = p; 315 set_bit(HCI_UART_PROTO_READY, &hu->flags); 316 317 /* Initialize and register HCI device */ 318 hdev = hci_alloc_dev(); 319 if (!hdev) { 320 BT_ERR("Can't allocate HCI device"); 321 err = -ENOMEM; 322 goto err_alloc; 323 } 324 325 hu->hdev = hdev; 326 327 hdev->bus = HCI_UART; 328 hci_set_drvdata(hdev, hu); 329 330 INIT_WORK(&hu->init_ready, hci_uart_init_work); 331 INIT_WORK(&hu->write_work, hci_uart_write_work); 332 333 /* Only when vendor specific setup callback is provided, consider 334 * the manufacturer information valid. This avoids filling in the 335 * value for Ericsson when nothing is specified. 336 */ 337 if (hu->proto->setup) 338 hdev->manufacturer = hu->proto->manufacturer; 339 340 hdev->open = hci_uart_open; 341 hdev->close = hci_uart_close; 342 hdev->flush = hci_uart_flush; 343 hdev->send = hci_uart_send_frame; 344 hdev->setup = hci_uart_setup; 345 SET_HCIDEV_DEV(hdev, &hu->serdev->dev); 346 347 if (test_bit(HCI_UART_NO_SUSPEND_NOTIFIER, &hu->flags)) 348 set_bit(HCI_QUIRK_NO_SUSPEND_NOTIFIER, &hdev->quirks); 349 350 if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags)) 351 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks); 352 353 if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags)) 354 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks); 355 356 if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags)) 357 hdev->dev_type = HCI_AMP; 358 else 359 hdev->dev_type = HCI_PRIMARY; 360 361 if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) 362 return 0; 363 364 if (hci_register_dev(hdev) < 0) { 365 BT_ERR("Can't register HCI device"); 366 err = -ENODEV; 367 goto err_register; 368 } 369 370 set_bit(HCI_UART_REGISTERED, &hu->flags); 371 372 return 0; 373 374 err_register: 375 hci_free_dev(hdev); 376 err_alloc: 377 clear_bit(HCI_UART_PROTO_READY, &hu->flags); 378 p->close(hu); 379 err_open: 380 serdev_device_close(hu->serdev); 381 return err; 382 } 383 EXPORT_SYMBOL_GPL(hci_uart_register_device); 384 385 void hci_uart_unregister_device(struct hci_uart *hu) 386 { 387 struct hci_dev *hdev = hu->hdev; 388 389 cancel_work_sync(&hu->init_ready); 390 if (test_bit(HCI_UART_REGISTERED, &hu->flags)) 391 hci_unregister_dev(hdev); 392 hci_free_dev(hdev); 393 394 cancel_work_sync(&hu->write_work); 395 396 hu->proto->close(hu); 397 398 if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) { 399 clear_bit(HCI_UART_PROTO_READY, &hu->flags); 400 serdev_device_close(hu->serdev); 401 } 402 } 403 EXPORT_SYMBOL_GPL(hci_uart_unregister_device); 404