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