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 } while (test_bit(HCI_UART_TX_WAKEUP, &hu->tx_state)); 87 88 clear_bit(HCI_UART_SENDING, &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 BT_DBG("%s %p", hdev->name, hdev); 117 118 /* Undo clearing this from hci_uart_close() */ 119 hdev->flush = hci_uart_flush; 120 121 return 0; 122 } 123 124 /* Close device */ 125 static int hci_uart_close(struct hci_dev *hdev) 126 { 127 BT_DBG("hdev %p", hdev); 128 129 hci_uart_flush(hdev); 130 hdev->flush = NULL; 131 132 return 0; 133 } 134 135 /* Send frames from HCI layer */ 136 static int hci_uart_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 137 { 138 struct hci_uart *hu = hci_get_drvdata(hdev); 139 140 BT_DBG("%s: type %d len %d", hdev->name, hci_skb_pkt_type(skb), 141 skb->len); 142 143 hu->proto->enqueue(hu, skb); 144 145 hci_uart_tx_wakeup(hu); 146 147 return 0; 148 } 149 150 static int hci_uart_setup(struct hci_dev *hdev) 151 { 152 struct hci_uart *hu = hci_get_drvdata(hdev); 153 struct hci_rp_read_local_version *ver; 154 struct sk_buff *skb; 155 unsigned int speed; 156 int err; 157 158 /* Init speed if any */ 159 if (hu->init_speed) 160 speed = hu->init_speed; 161 else if (hu->proto->init_speed) 162 speed = hu->proto->init_speed; 163 else 164 speed = 0; 165 166 if (speed) 167 serdev_device_set_baudrate(hu->serdev, speed); 168 169 /* Operational speed if any */ 170 if (hu->oper_speed) 171 speed = hu->oper_speed; 172 else if (hu->proto->oper_speed) 173 speed = hu->proto->oper_speed; 174 else 175 speed = 0; 176 177 if (hu->proto->set_baudrate && speed) { 178 err = hu->proto->set_baudrate(hu, speed); 179 if (err) 180 bt_dev_err(hdev, "Failed to set baudrate"); 181 else 182 serdev_device_set_baudrate(hu->serdev, speed); 183 } 184 185 if (hu->proto->setup) 186 return hu->proto->setup(hu); 187 188 if (!test_bit(HCI_UART_VND_DETECT, &hu->hdev_flags)) 189 return 0; 190 191 skb = __hci_cmd_sync(hdev, HCI_OP_READ_LOCAL_VERSION, 0, NULL, 192 HCI_INIT_TIMEOUT); 193 if (IS_ERR(skb)) { 194 bt_dev_err(hdev, "Reading local version info failed (%ld)", 195 PTR_ERR(skb)); 196 return 0; 197 } 198 199 if (skb->len != sizeof(*ver)) 200 bt_dev_err(hdev, "Event length mismatch for version info"); 201 202 kfree_skb(skb); 203 return 0; 204 } 205 206 /** hci_uart_write_wakeup - transmit buffer wakeup 207 * @serdev: serial device 208 * 209 * This function is called by the serdev framework when it accepts 210 * more data being sent. 211 */ 212 static void hci_uart_write_wakeup(struct serdev_device *serdev) 213 { 214 struct hci_uart *hu = serdev_device_get_drvdata(serdev); 215 216 BT_DBG(""); 217 218 if (!hu || serdev != hu->serdev) { 219 WARN_ON(1); 220 return; 221 } 222 223 if (test_bit(HCI_UART_PROTO_READY, &hu->flags)) 224 hci_uart_tx_wakeup(hu); 225 } 226 227 /** hci_uart_receive_buf - receive buffer wakeup 228 * @serdev: serial device 229 * @data: pointer to received data 230 * @count: count of received data in bytes 231 * 232 * This function is called by the serdev framework when it received data 233 * in the RX buffer. 234 * 235 * Return: number of processed bytes 236 */ 237 static int hci_uart_receive_buf(struct serdev_device *serdev, const u8 *data, 238 size_t count) 239 { 240 struct hci_uart *hu = serdev_device_get_drvdata(serdev); 241 242 if (!hu || serdev != hu->serdev) { 243 WARN_ON(1); 244 return 0; 245 } 246 247 if (!test_bit(HCI_UART_PROTO_READY, &hu->flags)) 248 return 0; 249 250 /* It does not need a lock here as it is already protected by a mutex in 251 * tty caller 252 */ 253 hu->proto->recv(hu, data, count); 254 255 if (hu->hdev) 256 hu->hdev->stat.byte_rx += count; 257 258 return count; 259 } 260 261 static const struct serdev_device_ops hci_serdev_client_ops = { 262 .receive_buf = hci_uart_receive_buf, 263 .write_wakeup = hci_uart_write_wakeup, 264 }; 265 266 int hci_uart_register_device(struct hci_uart *hu, 267 const struct hci_uart_proto *p) 268 { 269 int err; 270 struct hci_dev *hdev; 271 272 BT_DBG(""); 273 274 serdev_device_set_client_ops(hu->serdev, &hci_serdev_client_ops); 275 276 err = serdev_device_open(hu->serdev); 277 if (err) 278 return err; 279 280 err = p->open(hu); 281 if (err) 282 goto err_open; 283 284 hu->proto = p; 285 set_bit(HCI_UART_PROTO_READY, &hu->flags); 286 287 /* Initialize and register HCI device */ 288 hdev = hci_alloc_dev(); 289 if (!hdev) { 290 BT_ERR("Can't allocate HCI device"); 291 err = -ENOMEM; 292 goto err_alloc; 293 } 294 295 hu->hdev = hdev; 296 297 hdev->bus = HCI_UART; 298 hci_set_drvdata(hdev, hu); 299 300 INIT_WORK(&hu->init_ready, hci_uart_init_work); 301 INIT_WORK(&hu->write_work, hci_uart_write_work); 302 percpu_init_rwsem(&hu->proto_lock); 303 304 /* Only when vendor specific setup callback is provided, consider 305 * the manufacturer information valid. This avoids filling in the 306 * value for Ericsson when nothing is specified. 307 */ 308 if (hu->proto->setup) 309 hdev->manufacturer = hu->proto->manufacturer; 310 311 hdev->open = hci_uart_open; 312 hdev->close = hci_uart_close; 313 hdev->flush = hci_uart_flush; 314 hdev->send = hci_uart_send_frame; 315 hdev->setup = hci_uart_setup; 316 SET_HCIDEV_DEV(hdev, &hu->serdev->dev); 317 318 if (test_bit(HCI_UART_RAW_DEVICE, &hu->hdev_flags)) 319 set_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks); 320 321 if (test_bit(HCI_UART_EXT_CONFIG, &hu->hdev_flags)) 322 set_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks); 323 324 if (test_bit(HCI_UART_CREATE_AMP, &hu->hdev_flags)) 325 hdev->dev_type = HCI_AMP; 326 else 327 hdev->dev_type = HCI_PRIMARY; 328 329 if (test_bit(HCI_UART_INIT_PENDING, &hu->hdev_flags)) 330 return 0; 331 332 if (hci_register_dev(hdev) < 0) { 333 BT_ERR("Can't register HCI device"); 334 err = -ENODEV; 335 goto err_register; 336 } 337 338 set_bit(HCI_UART_REGISTERED, &hu->flags); 339 340 return 0; 341 342 err_register: 343 hci_free_dev(hdev); 344 err_alloc: 345 clear_bit(HCI_UART_PROTO_READY, &hu->flags); 346 p->close(hu); 347 err_open: 348 serdev_device_close(hu->serdev); 349 return err; 350 } 351 EXPORT_SYMBOL_GPL(hci_uart_register_device); 352 353 void hci_uart_unregister_device(struct hci_uart *hu) 354 { 355 struct hci_dev *hdev = hu->hdev; 356 357 clear_bit(HCI_UART_PROTO_READY, &hu->flags); 358 hci_unregister_dev(hdev); 359 hci_free_dev(hdev); 360 361 cancel_work_sync(&hu->write_work); 362 363 hu->proto->close(hu); 364 serdev_device_close(hu->serdev); 365 } 366 EXPORT_SYMBOL_GPL(hci_uart_unregister_device); 367