1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Intel La Jolla Cove Adapter USB driver 4 * 5 * Copyright (c) 2023, Intel Corporation. 6 */ 7 8 #include <linux/acpi.h> 9 #include <linux/auxiliary_bus.h> 10 #include <linux/dev_printk.h> 11 #include <linux/kernel.h> 12 #include <linux/mod_devicetable.h> 13 #include <linux/module.h> 14 #include <linux/mutex.h> 15 #include <linux/slab.h> 16 #include <linux/spinlock.h> 17 #include <linux/types.h> 18 #include <linux/usb.h> 19 #include <linux/usb/ljca.h> 20 21 #include <linux/unaligned.h> 22 23 /* command flags */ 24 #define LJCA_ACK_FLAG BIT(0) 25 #define LJCA_RESP_FLAG BIT(1) 26 #define LJCA_CMPL_FLAG BIT(2) 27 28 #define LJCA_MAX_PACKET_SIZE 64u 29 #define LJCA_MAX_PAYLOAD_SIZE \ 30 (LJCA_MAX_PACKET_SIZE - sizeof(struct ljca_msg)) 31 32 #define LJCA_WRITE_TIMEOUT_MS 200 33 #define LJCA_WRITE_ACK_TIMEOUT_MS 500 34 #define LJCA_ENUM_CLIENT_TIMEOUT_MS 20 35 36 /* ljca client type */ 37 enum ljca_client_type { 38 LJCA_CLIENT_MNG = 1, 39 LJCA_CLIENT_GPIO = 3, 40 LJCA_CLIENT_I2C = 4, 41 LJCA_CLIENT_SPI = 5, 42 }; 43 44 /* MNG client commands */ 45 enum ljca_mng_cmd { 46 LJCA_MNG_RESET = 2, 47 LJCA_MNG_ENUM_GPIO = 4, 48 LJCA_MNG_ENUM_I2C = 5, 49 LJCA_MNG_ENUM_SPI = 8, 50 }; 51 52 /* ljca client acpi _ADR */ 53 enum ljca_client_acpi_adr { 54 LJCA_GPIO_ACPI_ADR, 55 LJCA_I2C1_ACPI_ADR, 56 LJCA_I2C2_ACPI_ADR, 57 LJCA_SPI1_ACPI_ADR, 58 LJCA_SPI2_ACPI_ADR, 59 LJCA_CLIENT_ACPI_ADR_MAX, 60 }; 61 62 /* ljca cmd message structure */ 63 struct ljca_msg { 64 u8 type; 65 u8 cmd; 66 u8 flags; 67 u8 len; 68 u8 data[] __counted_by(len); 69 } __packed; 70 71 struct ljca_i2c_ctr_info { 72 u8 id; 73 u8 capacity; 74 u8 intr_pin; 75 } __packed; 76 77 struct ljca_i2c_descriptor { 78 u8 num; 79 struct ljca_i2c_ctr_info info[] __counted_by(num); 80 } __packed; 81 82 struct ljca_spi_ctr_info { 83 u8 id; 84 u8 capacity; 85 u8 intr_pin; 86 } __packed; 87 88 struct ljca_spi_descriptor { 89 u8 num; 90 struct ljca_spi_ctr_info info[] __counted_by(num); 91 } __packed; 92 93 struct ljca_bank_descriptor { 94 u8 bank_id; 95 u8 pin_num; 96 97 /* 1 bit for each gpio, 1 means valid */ 98 __le32 valid_pins; 99 } __packed; 100 101 struct ljca_gpio_descriptor { 102 u8 pins_per_bank; 103 u8 bank_num; 104 struct ljca_bank_descriptor bank_desc[] __counted_by(bank_num); 105 } __packed; 106 107 /** 108 * struct ljca_adapter - represent a ljca adapter 109 * 110 * @intf: the usb interface for this ljca adapter 111 * @usb_dev: the usb device for this ljca adapter 112 * @dev: the specific device info of the usb interface 113 * @rx_pipe: bulk in pipe for receive data from firmware 114 * @tx_pipe: bulk out pipe for send data to firmware 115 * @rx_urb: urb used for the bulk in pipe 116 * @rx_buf: buffer used to receive command response and event 117 * @rx_len: length of rx buffer 118 * @ex_buf: external buffer to save command response 119 * @ex_buf_len: length of external buffer 120 * @actual_length: actual length of data copied to external buffer 121 * @tx_buf: buffer used to download command to firmware 122 * @tx_buf_len: length of tx buffer 123 * @lock: spinlock to protect tx_buf and ex_buf 124 * @cmd_completion: completion object as the command receives ack 125 * @mutex: mutex to avoid command download concurrently 126 * @client_list: client device list 127 * @disconnect: usb disconnect ongoing or not 128 * @reset_id: used to reset firmware 129 */ 130 struct ljca_adapter { 131 struct usb_interface *intf; 132 struct usb_device *usb_dev; 133 struct device *dev; 134 135 unsigned int rx_pipe; 136 unsigned int tx_pipe; 137 138 struct urb *rx_urb; 139 void *rx_buf; 140 unsigned int rx_len; 141 142 u8 *ex_buf; 143 u8 ex_buf_len; 144 u8 actual_length; 145 146 void *tx_buf; 147 u8 tx_buf_len; 148 149 spinlock_t lock; 150 151 struct completion cmd_completion; 152 struct mutex mutex; 153 154 struct list_head client_list; 155 156 bool disconnect; 157 158 u32 reset_id; 159 }; 160 161 struct ljca_match_ids_walk_data { 162 const struct acpi_device_id *ids; 163 const char *uid; 164 struct acpi_device *adev; 165 }; 166 167 static const struct acpi_device_id ljca_gpio_hids[] = { 168 { "INTC1074" }, 169 { "INTC1096" }, 170 { "INTC100B" }, 171 { "INTC10D1" }, 172 { "INTC10B5" }, 173 {}, 174 }; 175 176 static const struct acpi_device_id ljca_i2c_hids[] = { 177 { "INTC1075" }, 178 { "INTC1097" }, 179 { "INTC100C" }, 180 { "INTC10D2" }, 181 {}, 182 }; 183 184 static const struct acpi_device_id ljca_spi_hids[] = { 185 { "INTC1091" }, 186 { "INTC1098" }, 187 { "INTC100D" }, 188 { "INTC10D3" }, 189 {}, 190 }; 191 192 static void ljca_handle_event(struct ljca_adapter *adap, 193 struct ljca_msg *header) 194 { 195 struct ljca_client *client; 196 197 list_for_each_entry(client, &adap->client_list, link) { 198 /* 199 * Currently only GPIO register event callback, but 200 * firmware message structure should include id when 201 * multiple same type clients register event callback. 202 */ 203 if (client->type == header->type) { 204 unsigned long flags; 205 206 spin_lock_irqsave(&client->event_cb_lock, flags); 207 client->event_cb(client->context, header->cmd, 208 header->data, header->len); 209 spin_unlock_irqrestore(&client->event_cb_lock, flags); 210 211 break; 212 } 213 } 214 } 215 216 /* process command ack and received data if available */ 217 static void ljca_handle_cmd_ack(struct ljca_adapter *adap, struct ljca_msg *header) 218 { 219 struct ljca_msg *tx_header = adap->tx_buf; 220 u8 ibuf_len, actual_len = 0; 221 unsigned long flags; 222 u8 *ibuf; 223 224 spin_lock_irqsave(&adap->lock, flags); 225 226 if (tx_header->type != header->type || tx_header->cmd != header->cmd) { 227 spin_unlock_irqrestore(&adap->lock, flags); 228 dev_err(adap->dev, "cmd ack mismatch error\n"); 229 return; 230 } 231 232 ibuf_len = adap->ex_buf_len; 233 ibuf = adap->ex_buf; 234 235 if (ibuf && ibuf_len) { 236 actual_len = min(header->len, ibuf_len); 237 238 /* copy received data to external buffer */ 239 memcpy(ibuf, header->data, actual_len); 240 } 241 /* update copied data length */ 242 adap->actual_length = actual_len; 243 244 spin_unlock_irqrestore(&adap->lock, flags); 245 246 complete(&adap->cmd_completion); 247 } 248 249 static void ljca_recv(struct urb *urb) 250 { 251 struct ljca_msg *header = urb->transfer_buffer; 252 struct ljca_adapter *adap = urb->context; 253 int ret; 254 255 switch (urb->status) { 256 case 0: 257 /* success */ 258 break; 259 case -ENOENT: 260 /* 261 * directly complete the possible ongoing transfer 262 * during disconnect 263 */ 264 if (adap->disconnect) 265 complete(&adap->cmd_completion); 266 return; 267 case -ECONNRESET: 268 case -ESHUTDOWN: 269 case -EPIPE: 270 /* rx urb is terminated */ 271 dev_dbg(adap->dev, "rx urb terminated with status: %d\n", 272 urb->status); 273 return; 274 default: 275 dev_dbg(adap->dev, "rx urb error: %d\n", urb->status); 276 goto resubmit; 277 } 278 279 if (header->len + sizeof(*header) != urb->actual_length) 280 goto resubmit; 281 282 if (header->flags & LJCA_ACK_FLAG) 283 ljca_handle_cmd_ack(adap, header); 284 else 285 ljca_handle_event(adap, header); 286 287 resubmit: 288 ret = usb_submit_urb(urb, GFP_ATOMIC); 289 if (ret && ret != -EPERM) 290 dev_err(adap->dev, "resubmit rx urb error %d\n", ret); 291 } 292 293 static int ljca_send(struct ljca_adapter *adap, u8 type, u8 cmd, 294 const u8 *obuf, u8 obuf_len, u8 *ibuf, u8 ibuf_len, 295 bool ack, unsigned long timeout) 296 { 297 unsigned int msg_len = sizeof(struct ljca_msg) + obuf_len; 298 struct ljca_msg *header = adap->tx_buf; 299 unsigned int transferred; 300 unsigned long flags; 301 int ret; 302 303 if (adap->disconnect) 304 return -ENODEV; 305 306 if (msg_len > adap->tx_buf_len) 307 return -EINVAL; 308 309 mutex_lock(&adap->mutex); 310 311 spin_lock_irqsave(&adap->lock, flags); 312 313 header->type = type; 314 header->cmd = cmd; 315 header->len = obuf_len; 316 if (obuf) 317 memcpy(header->data, obuf, obuf_len); 318 319 header->flags = LJCA_CMPL_FLAG | (ack ? LJCA_ACK_FLAG : 0); 320 321 adap->ex_buf = ibuf; 322 adap->ex_buf_len = ibuf_len; 323 adap->actual_length = 0; 324 325 spin_unlock_irqrestore(&adap->lock, flags); 326 327 reinit_completion(&adap->cmd_completion); 328 329 ret = usb_autopm_get_interface(adap->intf); 330 if (ret < 0) 331 goto out; 332 333 ret = usb_bulk_msg(adap->usb_dev, adap->tx_pipe, header, 334 msg_len, &transferred, LJCA_WRITE_TIMEOUT_MS); 335 336 usb_autopm_put_interface(adap->intf); 337 338 if (ret < 0) 339 goto out; 340 if (transferred != msg_len) { 341 ret = -EIO; 342 goto out; 343 } 344 345 if (ack) { 346 ret = wait_for_completion_timeout(&adap->cmd_completion, 347 timeout); 348 if (!ret) { 349 ret = -ETIMEDOUT; 350 goto out; 351 } 352 } 353 ret = adap->actual_length; 354 355 out: 356 spin_lock_irqsave(&adap->lock, flags); 357 adap->ex_buf = NULL; 358 adap->ex_buf_len = 0; 359 360 memset(header, 0, sizeof(*header)); 361 spin_unlock_irqrestore(&adap->lock, flags); 362 363 mutex_unlock(&adap->mutex); 364 365 return ret; 366 } 367 368 int ljca_transfer(struct ljca_client *client, u8 cmd, const u8 *obuf, 369 u8 obuf_len, u8 *ibuf, u8 ibuf_len) 370 { 371 return ljca_send(client->adapter, client->type, cmd, 372 obuf, obuf_len, ibuf, ibuf_len, true, 373 LJCA_WRITE_ACK_TIMEOUT_MS); 374 } 375 EXPORT_SYMBOL_NS_GPL(ljca_transfer, LJCA); 376 377 int ljca_transfer_noack(struct ljca_client *client, u8 cmd, const u8 *obuf, 378 u8 obuf_len) 379 { 380 return ljca_send(client->adapter, client->type, cmd, obuf, 381 obuf_len, NULL, 0, false, LJCA_WRITE_ACK_TIMEOUT_MS); 382 } 383 EXPORT_SYMBOL_NS_GPL(ljca_transfer_noack, LJCA); 384 385 int ljca_register_event_cb(struct ljca_client *client, ljca_event_cb_t event_cb, 386 void *context) 387 { 388 unsigned long flags; 389 390 if (!event_cb) 391 return -EINVAL; 392 393 spin_lock_irqsave(&client->event_cb_lock, flags); 394 395 if (client->event_cb) { 396 spin_unlock_irqrestore(&client->event_cb_lock, flags); 397 return -EALREADY; 398 } 399 400 client->event_cb = event_cb; 401 client->context = context; 402 403 spin_unlock_irqrestore(&client->event_cb_lock, flags); 404 405 return 0; 406 } 407 EXPORT_SYMBOL_NS_GPL(ljca_register_event_cb, LJCA); 408 409 void ljca_unregister_event_cb(struct ljca_client *client) 410 { 411 unsigned long flags; 412 413 spin_lock_irqsave(&client->event_cb_lock, flags); 414 415 client->event_cb = NULL; 416 client->context = NULL; 417 418 spin_unlock_irqrestore(&client->event_cb_lock, flags); 419 } 420 EXPORT_SYMBOL_NS_GPL(ljca_unregister_event_cb, LJCA); 421 422 static int ljca_match_device_ids(struct acpi_device *adev, void *data) 423 { 424 struct ljca_match_ids_walk_data *wd = data; 425 const char *uid = acpi_device_uid(adev); 426 427 if (acpi_match_device_ids(adev, wd->ids)) 428 return 0; 429 430 if (!wd->uid) 431 goto match; 432 433 if (!uid) 434 /* 435 * Some DSDTs have only one ACPI companion for the two I2C 436 * controllers and they don't set a UID at all (e.g. Dell 437 * Latitude 9420). On these platforms only the first I2C 438 * controller is used, so if a HID match has no UID we use 439 * "0" as the UID and assign ACPI companion to the first 440 * I2C controller. 441 */ 442 uid = "0"; 443 else 444 uid = strchr(uid, wd->uid[0]); 445 446 if (!uid || strcmp(uid, wd->uid)) 447 return 0; 448 449 match: 450 wd->adev = adev; 451 452 return 1; 453 } 454 455 /* bind auxiliary device to acpi device */ 456 static void ljca_auxdev_acpi_bind(struct ljca_adapter *adap, 457 struct auxiliary_device *auxdev, 458 u64 adr, u8 id) 459 { 460 struct ljca_match_ids_walk_data wd = { 0 }; 461 struct device *dev = adap->dev; 462 struct acpi_device *parent; 463 char uid[4]; 464 465 parent = ACPI_COMPANION(dev); 466 if (!parent) 467 return; 468 469 /* 470 * Currently LJCA hw doesn't use _ADR instead the shipped 471 * platforms use _HID to distinguish children devices. 472 */ 473 switch (adr) { 474 case LJCA_GPIO_ACPI_ADR: 475 wd.ids = ljca_gpio_hids; 476 break; 477 case LJCA_I2C1_ACPI_ADR: 478 case LJCA_I2C2_ACPI_ADR: 479 snprintf(uid, sizeof(uid), "%d", id); 480 wd.uid = uid; 481 wd.ids = ljca_i2c_hids; 482 break; 483 case LJCA_SPI1_ACPI_ADR: 484 case LJCA_SPI2_ACPI_ADR: 485 wd.ids = ljca_spi_hids; 486 break; 487 default: 488 dev_warn(dev, "unsupported _ADR\n"); 489 return; 490 } 491 492 acpi_dev_for_each_child(parent, ljca_match_device_ids, &wd); 493 if (wd.adev) { 494 ACPI_COMPANION_SET(&auxdev->dev, wd.adev); 495 return; 496 } 497 498 parent = ACPI_COMPANION(dev->parent->parent); 499 if (!parent) 500 return; 501 502 acpi_dev_for_each_child(parent, ljca_match_device_ids, &wd); 503 if (wd.adev) 504 ACPI_COMPANION_SET(&auxdev->dev, wd.adev); 505 } 506 507 static void ljca_auxdev_release(struct device *dev) 508 { 509 struct auxiliary_device *auxdev = to_auxiliary_dev(dev); 510 511 kfree(auxdev->dev.platform_data); 512 } 513 514 static int ljca_new_client_device(struct ljca_adapter *adap, u8 type, u8 id, 515 char *name, void *data, u64 adr) 516 { 517 struct auxiliary_device *auxdev; 518 struct ljca_client *client; 519 int ret; 520 521 client = kzalloc(sizeof *client, GFP_KERNEL); 522 if (!client) { 523 kfree(data); 524 return -ENOMEM; 525 } 526 527 client->type = type; 528 client->id = id; 529 client->adapter = adap; 530 spin_lock_init(&client->event_cb_lock); 531 532 auxdev = &client->auxdev; 533 auxdev->name = name; 534 auxdev->id = id; 535 536 auxdev->dev.parent = adap->dev; 537 auxdev->dev.platform_data = data; 538 auxdev->dev.release = ljca_auxdev_release; 539 540 ret = auxiliary_device_init(auxdev); 541 if (ret) { 542 kfree(data); 543 goto err_free; 544 } 545 546 ljca_auxdev_acpi_bind(adap, auxdev, adr, id); 547 548 ret = auxiliary_device_add(auxdev); 549 if (ret) 550 goto err_uninit; 551 552 list_add_tail(&client->link, &adap->client_list); 553 554 return 0; 555 556 err_uninit: 557 auxiliary_device_uninit(auxdev); 558 559 err_free: 560 kfree(client); 561 562 return ret; 563 } 564 565 static int ljca_enumerate_gpio(struct ljca_adapter *adap) 566 { 567 u32 valid_pin[LJCA_MAX_GPIO_NUM / BITS_PER_TYPE(u32)]; 568 struct ljca_gpio_descriptor *desc; 569 struct ljca_gpio_info *gpio_info; 570 u8 buf[LJCA_MAX_PAYLOAD_SIZE]; 571 int ret, gpio_num; 572 unsigned int i; 573 574 ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_GPIO, NULL, 0, buf, 575 sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS); 576 if (ret < 0) 577 return ret; 578 579 /* check firmware response */ 580 desc = (struct ljca_gpio_descriptor *)buf; 581 if (ret != struct_size(desc, bank_desc, desc->bank_num)) 582 return -EINVAL; 583 584 gpio_num = desc->pins_per_bank * desc->bank_num; 585 if (gpio_num > LJCA_MAX_GPIO_NUM) 586 return -EINVAL; 587 588 /* construct platform data */ 589 gpio_info = kzalloc(sizeof *gpio_info, GFP_KERNEL); 590 if (!gpio_info) 591 return -ENOMEM; 592 gpio_info->num = gpio_num; 593 594 for (i = 0; i < desc->bank_num; i++) 595 valid_pin[i] = get_unaligned_le32(&desc->bank_desc[i].valid_pins); 596 bitmap_from_arr32(gpio_info->valid_pin_map, valid_pin, gpio_num); 597 598 return ljca_new_client_device(adap, LJCA_CLIENT_GPIO, 0, "ljca-gpio", 599 gpio_info, LJCA_GPIO_ACPI_ADR); 600 } 601 602 static int ljca_enumerate_i2c(struct ljca_adapter *adap) 603 { 604 struct ljca_i2c_descriptor *desc; 605 struct ljca_i2c_info *i2c_info; 606 u8 buf[LJCA_MAX_PAYLOAD_SIZE]; 607 unsigned int i; 608 int ret; 609 610 ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_I2C, NULL, 0, buf, 611 sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS); 612 if (ret < 0) 613 return ret; 614 615 /* check firmware response */ 616 desc = (struct ljca_i2c_descriptor *)buf; 617 if (ret != struct_size(desc, info, desc->num)) 618 return -EINVAL; 619 620 for (i = 0; i < desc->num; i++) { 621 /* construct platform data */ 622 i2c_info = kzalloc(sizeof *i2c_info, GFP_KERNEL); 623 if (!i2c_info) 624 return -ENOMEM; 625 626 i2c_info->id = desc->info[i].id; 627 i2c_info->capacity = desc->info[i].capacity; 628 i2c_info->intr_pin = desc->info[i].intr_pin; 629 630 ret = ljca_new_client_device(adap, LJCA_CLIENT_I2C, i, 631 "ljca-i2c", i2c_info, 632 LJCA_I2C1_ACPI_ADR + i); 633 if (ret) 634 return ret; 635 } 636 637 return 0; 638 } 639 640 static int ljca_enumerate_spi(struct ljca_adapter *adap) 641 { 642 struct ljca_spi_descriptor *desc; 643 struct ljca_spi_info *spi_info; 644 u8 buf[LJCA_MAX_PAYLOAD_SIZE]; 645 unsigned int i; 646 int ret; 647 648 /* Not all LJCA chips implement SPI, a timeout reading the descriptors is normal */ 649 ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_ENUM_SPI, NULL, 0, buf, 650 sizeof(buf), true, LJCA_ENUM_CLIENT_TIMEOUT_MS); 651 if (ret < 0) 652 return (ret == -ETIMEDOUT) ? 0 : ret; 653 654 /* check firmware response */ 655 desc = (struct ljca_spi_descriptor *)buf; 656 if (ret != struct_size(desc, info, desc->num)) 657 return -EINVAL; 658 659 for (i = 0; i < desc->num; i++) { 660 /* construct platform data */ 661 spi_info = kzalloc(sizeof *spi_info, GFP_KERNEL); 662 if (!spi_info) 663 return -ENOMEM; 664 665 spi_info->id = desc->info[i].id; 666 spi_info->capacity = desc->info[i].capacity; 667 668 ret = ljca_new_client_device(adap, LJCA_CLIENT_SPI, i, 669 "ljca-spi", spi_info, 670 LJCA_SPI1_ACPI_ADR + i); 671 if (ret) 672 return ret; 673 } 674 675 return 0; 676 } 677 678 static int ljca_reset_handshake(struct ljca_adapter *adap) 679 { 680 __le32 reset_id = cpu_to_le32(adap->reset_id); 681 __le32 reset_id_ret = 0; 682 int ret; 683 684 adap->reset_id++; 685 686 ret = ljca_send(adap, LJCA_CLIENT_MNG, LJCA_MNG_RESET, (u8 *)&reset_id, 687 sizeof(__le32), (u8 *)&reset_id_ret, sizeof(__le32), 688 true, LJCA_WRITE_ACK_TIMEOUT_MS); 689 if (ret < 0) 690 return ret; 691 692 if (reset_id_ret != reset_id) 693 return -EINVAL; 694 695 return 0; 696 } 697 698 static int ljca_enumerate_clients(struct ljca_adapter *adap) 699 { 700 struct ljca_client *client, *next; 701 int ret; 702 703 ret = ljca_reset_handshake(adap); 704 if (ret) 705 goto err_kill; 706 707 ret = ljca_enumerate_gpio(adap); 708 if (ret) { 709 dev_err(adap->dev, "enumerate GPIO error\n"); 710 goto err_kill; 711 } 712 713 ret = ljca_enumerate_i2c(adap); 714 if (ret) { 715 dev_err(adap->dev, "enumerate I2C error\n"); 716 goto err_kill; 717 } 718 719 ret = ljca_enumerate_spi(adap); 720 if (ret) { 721 dev_err(adap->dev, "enumerate SPI error\n"); 722 goto err_kill; 723 } 724 725 return 0; 726 727 err_kill: 728 adap->disconnect = true; 729 730 usb_kill_urb(adap->rx_urb); 731 732 list_for_each_entry_safe_reverse(client, next, &adap->client_list, link) { 733 auxiliary_device_delete(&client->auxdev); 734 auxiliary_device_uninit(&client->auxdev); 735 736 list_del_init(&client->link); 737 kfree(client); 738 } 739 740 return ret; 741 } 742 743 static int ljca_probe(struct usb_interface *interface, 744 const struct usb_device_id *id) 745 { 746 struct usb_device *usb_dev = interface_to_usbdev(interface); 747 struct usb_host_interface *alt = interface->cur_altsetting; 748 struct usb_endpoint_descriptor *ep_in, *ep_out; 749 struct device *dev = &interface->dev; 750 struct ljca_adapter *adap; 751 int ret; 752 753 adap = devm_kzalloc(dev, sizeof(*adap), GFP_KERNEL); 754 if (!adap) 755 return -ENOMEM; 756 757 /* separate tx buffer allocation for alignment */ 758 adap->tx_buf = devm_kzalloc(dev, LJCA_MAX_PACKET_SIZE, GFP_KERNEL); 759 if (!adap->tx_buf) 760 return -ENOMEM; 761 adap->tx_buf_len = LJCA_MAX_PACKET_SIZE; 762 763 mutex_init(&adap->mutex); 764 spin_lock_init(&adap->lock); 765 init_completion(&adap->cmd_completion); 766 INIT_LIST_HEAD(&adap->client_list); 767 768 adap->intf = usb_get_intf(interface); 769 adap->usb_dev = usb_dev; 770 adap->dev = dev; 771 772 /* 773 * find the first bulk in and out endpoints. 774 * ignore any others. 775 */ 776 ret = usb_find_common_endpoints(alt, &ep_in, &ep_out, NULL, NULL); 777 if (ret) { 778 dev_err(dev, "bulk endpoints not found\n"); 779 goto err_put; 780 } 781 adap->rx_pipe = usb_rcvbulkpipe(usb_dev, usb_endpoint_num(ep_in)); 782 adap->tx_pipe = usb_sndbulkpipe(usb_dev, usb_endpoint_num(ep_out)); 783 784 /* setup rx buffer */ 785 adap->rx_len = usb_endpoint_maxp(ep_in); 786 adap->rx_buf = devm_kzalloc(dev, adap->rx_len, GFP_KERNEL); 787 if (!adap->rx_buf) { 788 ret = -ENOMEM; 789 goto err_put; 790 } 791 792 /* alloc rx urb */ 793 adap->rx_urb = usb_alloc_urb(0, GFP_KERNEL); 794 if (!adap->rx_urb) { 795 ret = -ENOMEM; 796 goto err_put; 797 } 798 usb_fill_bulk_urb(adap->rx_urb, usb_dev, adap->rx_pipe, 799 adap->rx_buf, adap->rx_len, ljca_recv, adap); 800 801 usb_set_intfdata(interface, adap); 802 803 /* submit rx urb before enumerate clients */ 804 ret = usb_submit_urb(adap->rx_urb, GFP_KERNEL); 805 if (ret) { 806 dev_err(dev, "submit rx urb failed: %d\n", ret); 807 goto err_free; 808 } 809 810 ret = ljca_enumerate_clients(adap); 811 if (ret) 812 goto err_free; 813 814 usb_enable_autosuspend(usb_dev); 815 816 return 0; 817 818 err_free: 819 usb_free_urb(adap->rx_urb); 820 821 err_put: 822 usb_put_intf(adap->intf); 823 824 mutex_destroy(&adap->mutex); 825 826 return ret; 827 } 828 829 static void ljca_disconnect(struct usb_interface *interface) 830 { 831 struct ljca_adapter *adap = usb_get_intfdata(interface); 832 struct ljca_client *client, *next; 833 834 adap->disconnect = true; 835 836 usb_kill_urb(adap->rx_urb); 837 838 list_for_each_entry_safe_reverse(client, next, &adap->client_list, link) { 839 auxiliary_device_delete(&client->auxdev); 840 auxiliary_device_uninit(&client->auxdev); 841 842 list_del_init(&client->link); 843 kfree(client); 844 } 845 846 usb_free_urb(adap->rx_urb); 847 848 usb_put_intf(adap->intf); 849 850 mutex_destroy(&adap->mutex); 851 } 852 853 static int ljca_suspend(struct usb_interface *interface, pm_message_t message) 854 { 855 struct ljca_adapter *adap = usb_get_intfdata(interface); 856 857 usb_kill_urb(adap->rx_urb); 858 859 return 0; 860 } 861 862 static int ljca_resume(struct usb_interface *interface) 863 { 864 struct ljca_adapter *adap = usb_get_intfdata(interface); 865 866 return usb_submit_urb(adap->rx_urb, GFP_KERNEL); 867 } 868 869 static const struct usb_device_id ljca_table[] = { 870 { USB_DEVICE(0x8086, 0x0b63) }, 871 { /* sentinel */ } 872 }; 873 MODULE_DEVICE_TABLE(usb, ljca_table); 874 875 static struct usb_driver ljca_driver = { 876 .name = "ljca", 877 .id_table = ljca_table, 878 .probe = ljca_probe, 879 .disconnect = ljca_disconnect, 880 .suspend = ljca_suspend, 881 .resume = ljca_resume, 882 .supports_autosuspend = 1, 883 }; 884 module_usb_driver(ljca_driver); 885 886 MODULE_AUTHOR("Wentong Wu <wentong.wu@intel.com>"); 887 MODULE_AUTHOR("Zhifeng Wang <zhifeng.wang@intel.com>"); 888 MODULE_AUTHOR("Lixu Zhang <lixu.zhang@intel.com>"); 889 MODULE_DESCRIPTION("Intel La Jolla Cove Adapter USB driver"); 890 MODULE_LICENSE("GPL"); 891