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