1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for the Diolan DLN-2 USB adapter 4 * 5 * Copyright (c) 2014 Intel Corporation 6 * 7 * Derived from: 8 * i2c-diolan-u2c.c 9 * Copyright (c) 2010-2011 Ericsson AB 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/module.h> 14 #include <linux/types.h> 15 #include <linux/slab.h> 16 #include <linux/usb.h> 17 #include <linux/i2c.h> 18 #include <linux/mutex.h> 19 #include <linux/platform_device.h> 20 #include <linux/mfd/core.h> 21 #include <linux/mfd/dln2.h> 22 #include <linux/rculist.h> 23 24 struct dln2_header { 25 __le16 size; 26 __le16 id; 27 __le16 echo; 28 __le16 handle; 29 }; 30 31 struct dln2_response { 32 struct dln2_header hdr; 33 __le16 result; 34 }; 35 36 #define DLN2_GENERIC_MODULE_ID 0x00 37 #define DLN2_GENERIC_CMD(cmd) DLN2_CMD(cmd, DLN2_GENERIC_MODULE_ID) 38 #define CMD_GET_DEVICE_VER DLN2_GENERIC_CMD(0x30) 39 #define CMD_GET_DEVICE_SN DLN2_GENERIC_CMD(0x31) 40 41 #define DLN2_HW_ID 0x200 42 #define DLN2_USB_TIMEOUT 200 /* in ms */ 43 #define DLN2_MAX_RX_SLOTS 16 44 #define DLN2_MAX_URBS 16 45 #define DLN2_RX_BUF_SIZE 512 46 47 enum dln2_handle { 48 DLN2_HANDLE_EVENT = 0, /* don't change, hardware defined */ 49 DLN2_HANDLE_CTRL, 50 DLN2_HANDLE_GPIO, 51 DLN2_HANDLE_I2C, 52 DLN2_HANDLE_SPI, 53 DLN2_HANDLE_ADC, 54 DLN2_HANDLES 55 }; 56 57 /* 58 * Receive context used between the receive demultiplexer and the transfer 59 * routine. While sending a request the transfer routine will look for a free 60 * receive context and use it to wait for a response and to receive the URB and 61 * thus the response data. 62 */ 63 struct dln2_rx_context { 64 /* completion used to wait for a response */ 65 struct completion done; 66 67 /* if non-NULL the URB contains the response */ 68 struct urb *urb; 69 70 /* if true then this context is used to wait for a response */ 71 bool in_use; 72 }; 73 74 /* 75 * Receive contexts for a particular DLN2 module (i2c, gpio, etc.). We use the 76 * handle header field to identify the module in dln2_dev.mod_rx_slots and then 77 * the echo header field to index the slots field and find the receive context 78 * for a particular request. 79 */ 80 struct dln2_mod_rx_slots { 81 /* RX slots bitmap */ 82 DECLARE_BITMAP(bmap, DLN2_MAX_RX_SLOTS); 83 84 /* used to wait for a free RX slot */ 85 wait_queue_head_t wq; 86 87 /* used to wait for an RX operation to complete */ 88 struct dln2_rx_context slots[DLN2_MAX_RX_SLOTS]; 89 90 /* avoid races between alloc/free_rx_slot and dln2_rx_transfer */ 91 spinlock_t lock; 92 }; 93 94 enum dln2_endpoint { 95 DLN2_EP_OUT = 0, 96 DLN2_EP_IN = 1, 97 }; 98 99 struct dln2_dev { 100 struct usb_device *usb_dev; 101 struct usb_interface *interface; 102 u8 ep_in; 103 u8 ep_out; 104 105 struct urb *rx_urb[DLN2_MAX_URBS]; 106 void *rx_buf[DLN2_MAX_URBS]; 107 108 struct dln2_mod_rx_slots mod_rx_slots[DLN2_HANDLES]; 109 110 struct list_head event_cb_list; 111 spinlock_t event_cb_lock; 112 113 bool disconnect; 114 int active_transfers; 115 wait_queue_head_t disconnect_wq; 116 spinlock_t disconnect_lock; 117 }; 118 119 struct dln2_event_cb_entry { 120 struct list_head list; 121 u16 id; 122 struct platform_device *pdev; 123 dln2_event_cb_t callback; 124 }; 125 126 int dln2_register_event_cb(struct platform_device *pdev, u16 id, 127 dln2_event_cb_t event_cb) 128 { 129 struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent); 130 struct dln2_event_cb_entry *i, *entry; 131 unsigned long flags; 132 int ret = 0; 133 134 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 135 if (!entry) 136 return -ENOMEM; 137 138 entry->id = id; 139 entry->callback = event_cb; 140 entry->pdev = pdev; 141 142 spin_lock_irqsave(&dln2->event_cb_lock, flags); 143 144 list_for_each_entry(i, &dln2->event_cb_list, list) { 145 if (i->id == id) { 146 ret = -EBUSY; 147 break; 148 } 149 } 150 151 if (!ret) 152 list_add_rcu(&entry->list, &dln2->event_cb_list); 153 154 spin_unlock_irqrestore(&dln2->event_cb_lock, flags); 155 156 if (ret) 157 kfree(entry); 158 159 return ret; 160 } 161 EXPORT_SYMBOL(dln2_register_event_cb); 162 163 void dln2_unregister_event_cb(struct platform_device *pdev, u16 id) 164 { 165 struct dln2_dev *dln2 = dev_get_drvdata(pdev->dev.parent); 166 struct dln2_event_cb_entry *i; 167 unsigned long flags; 168 bool found = false; 169 170 spin_lock_irqsave(&dln2->event_cb_lock, flags); 171 172 list_for_each_entry(i, &dln2->event_cb_list, list) { 173 if (i->id == id) { 174 list_del_rcu(&i->list); 175 found = true; 176 break; 177 } 178 } 179 180 spin_unlock_irqrestore(&dln2->event_cb_lock, flags); 181 182 if (found) { 183 synchronize_rcu(); 184 kfree(i); 185 } 186 } 187 EXPORT_SYMBOL(dln2_unregister_event_cb); 188 189 /* 190 * Returns true if a valid transfer slot is found. In this case the URB must not 191 * be resubmitted immediately in dln2_rx as we need the data when dln2_transfer 192 * is woke up. It will be resubmitted there. 193 */ 194 static bool dln2_transfer_complete(struct dln2_dev *dln2, struct urb *urb, 195 u16 handle, u16 rx_slot) 196 { 197 struct device *dev = &dln2->interface->dev; 198 struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; 199 struct dln2_rx_context *rxc; 200 unsigned long flags; 201 bool valid_slot = false; 202 203 if (rx_slot >= DLN2_MAX_RX_SLOTS) 204 goto out; 205 206 rxc = &rxs->slots[rx_slot]; 207 208 spin_lock_irqsave(&rxs->lock, flags); 209 if (rxc->in_use && !rxc->urb) { 210 rxc->urb = urb; 211 complete(&rxc->done); 212 valid_slot = true; 213 } 214 spin_unlock_irqrestore(&rxs->lock, flags); 215 216 out: 217 if (!valid_slot) 218 dev_warn(dev, "bad/late response %d/%d\n", handle, rx_slot); 219 220 return valid_slot; 221 } 222 223 static void dln2_run_event_callbacks(struct dln2_dev *dln2, u16 id, u16 echo, 224 void *data, int len) 225 { 226 struct dln2_event_cb_entry *i; 227 228 rcu_read_lock(); 229 230 list_for_each_entry_rcu(i, &dln2->event_cb_list, list) { 231 if (i->id == id) { 232 i->callback(i->pdev, echo, data, len); 233 break; 234 } 235 } 236 237 rcu_read_unlock(); 238 } 239 240 static void dln2_rx(struct urb *urb) 241 { 242 struct dln2_dev *dln2 = urb->context; 243 struct dln2_header *hdr = urb->transfer_buffer; 244 struct device *dev = &dln2->interface->dev; 245 u16 id, echo, handle, size; 246 u8 *data; 247 int len; 248 int err; 249 250 switch (urb->status) { 251 case 0: 252 /* success */ 253 break; 254 case -ECONNRESET: 255 case -ENOENT: 256 case -ESHUTDOWN: 257 case -EPIPE: 258 /* this urb is terminated, clean up */ 259 dev_dbg(dev, "urb shutting down with status %d\n", urb->status); 260 return; 261 default: 262 dev_dbg(dev, "nonzero urb status received %d\n", urb->status); 263 goto out; 264 } 265 266 if (urb->actual_length < sizeof(struct dln2_header)) { 267 dev_err(dev, "short response: %d\n", urb->actual_length); 268 goto out; 269 } 270 271 handle = le16_to_cpu(hdr->handle); 272 id = le16_to_cpu(hdr->id); 273 echo = le16_to_cpu(hdr->echo); 274 size = le16_to_cpu(hdr->size); 275 276 if (size != urb->actual_length) { 277 dev_err(dev, "size mismatch: handle %x cmd %x echo %x size %d actual %d\n", 278 handle, id, echo, size, urb->actual_length); 279 goto out; 280 } 281 282 if (handle >= DLN2_HANDLES) { 283 dev_warn(dev, "invalid handle %d\n", handle); 284 goto out; 285 } 286 287 data = urb->transfer_buffer + sizeof(struct dln2_header); 288 len = urb->actual_length - sizeof(struct dln2_header); 289 290 if (handle == DLN2_HANDLE_EVENT) { 291 unsigned long flags; 292 293 spin_lock_irqsave(&dln2->event_cb_lock, flags); 294 dln2_run_event_callbacks(dln2, id, echo, data, len); 295 spin_unlock_irqrestore(&dln2->event_cb_lock, flags); 296 } else { 297 /* URB will be re-submitted in _dln2_transfer (free_rx_slot) */ 298 if (dln2_transfer_complete(dln2, urb, handle, echo)) 299 return; 300 } 301 302 out: 303 err = usb_submit_urb(urb, GFP_ATOMIC); 304 if (err < 0) 305 dev_err(dev, "failed to resubmit RX URB: %d\n", err); 306 } 307 308 static void *dln2_prep_buf(u16 handle, u16 cmd, u16 echo, const void *obuf, 309 int *obuf_len, gfp_t gfp) 310 { 311 int len; 312 void *buf; 313 struct dln2_header *hdr; 314 315 len = *obuf_len + sizeof(*hdr); 316 buf = kmalloc(len, gfp); 317 if (!buf) 318 return NULL; 319 320 hdr = (struct dln2_header *)buf; 321 hdr->id = cpu_to_le16(cmd); 322 hdr->size = cpu_to_le16(len); 323 hdr->echo = cpu_to_le16(echo); 324 hdr->handle = cpu_to_le16(handle); 325 326 memcpy(buf + sizeof(*hdr), obuf, *obuf_len); 327 328 *obuf_len = len; 329 330 return buf; 331 } 332 333 static int dln2_send_wait(struct dln2_dev *dln2, u16 handle, u16 cmd, u16 echo, 334 const void *obuf, int obuf_len) 335 { 336 int ret = 0; 337 int len = obuf_len; 338 void *buf; 339 int actual; 340 341 buf = dln2_prep_buf(handle, cmd, echo, obuf, &len, GFP_KERNEL); 342 if (!buf) 343 return -ENOMEM; 344 345 ret = usb_bulk_msg(dln2->usb_dev, 346 usb_sndbulkpipe(dln2->usb_dev, dln2->ep_out), 347 buf, len, &actual, DLN2_USB_TIMEOUT); 348 349 kfree(buf); 350 351 return ret; 352 } 353 354 static bool find_free_slot(struct dln2_dev *dln2, u16 handle, int *slot) 355 { 356 struct dln2_mod_rx_slots *rxs; 357 unsigned long flags; 358 359 if (dln2->disconnect) { 360 *slot = -ENODEV; 361 return true; 362 } 363 364 rxs = &dln2->mod_rx_slots[handle]; 365 366 spin_lock_irqsave(&rxs->lock, flags); 367 368 *slot = find_first_zero_bit(rxs->bmap, DLN2_MAX_RX_SLOTS); 369 370 if (*slot < DLN2_MAX_RX_SLOTS) { 371 struct dln2_rx_context *rxc = &rxs->slots[*slot]; 372 373 set_bit(*slot, rxs->bmap); 374 rxc->in_use = true; 375 } 376 377 spin_unlock_irqrestore(&rxs->lock, flags); 378 379 return *slot < DLN2_MAX_RX_SLOTS; 380 } 381 382 static int alloc_rx_slot(struct dln2_dev *dln2, u16 handle) 383 { 384 int ret; 385 int slot; 386 387 /* 388 * No need to timeout here, the wait is bounded by the timeout in 389 * _dln2_transfer. 390 */ 391 ret = wait_event_interruptible(dln2->mod_rx_slots[handle].wq, 392 find_free_slot(dln2, handle, &slot)); 393 if (ret < 0) 394 return ret; 395 396 return slot; 397 } 398 399 static void free_rx_slot(struct dln2_dev *dln2, u16 handle, int slot) 400 { 401 struct dln2_mod_rx_slots *rxs; 402 struct urb *urb = NULL; 403 unsigned long flags; 404 struct dln2_rx_context *rxc; 405 406 rxs = &dln2->mod_rx_slots[handle]; 407 408 spin_lock_irqsave(&rxs->lock, flags); 409 410 clear_bit(slot, rxs->bmap); 411 412 rxc = &rxs->slots[slot]; 413 rxc->in_use = false; 414 urb = rxc->urb; 415 rxc->urb = NULL; 416 reinit_completion(&rxc->done); 417 418 spin_unlock_irqrestore(&rxs->lock, flags); 419 420 if (urb) { 421 int err; 422 struct device *dev = &dln2->interface->dev; 423 424 err = usb_submit_urb(urb, GFP_KERNEL); 425 if (err < 0) 426 dev_err(dev, "failed to resubmit RX URB: %d\n", err); 427 } 428 429 wake_up_interruptible(&rxs->wq); 430 } 431 432 static int _dln2_transfer(struct dln2_dev *dln2, u16 handle, u16 cmd, 433 const void *obuf, unsigned obuf_len, 434 void *ibuf, unsigned *ibuf_len) 435 { 436 int ret = 0; 437 int rx_slot; 438 struct dln2_response *rsp; 439 struct dln2_rx_context *rxc; 440 struct device *dev = &dln2->interface->dev; 441 const unsigned long timeout = msecs_to_jiffies(DLN2_USB_TIMEOUT); 442 struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[handle]; 443 int size; 444 445 spin_lock(&dln2->disconnect_lock); 446 if (!dln2->disconnect) 447 dln2->active_transfers++; 448 else 449 ret = -ENODEV; 450 spin_unlock(&dln2->disconnect_lock); 451 452 if (ret) 453 return ret; 454 455 rx_slot = alloc_rx_slot(dln2, handle); 456 if (rx_slot < 0) { 457 ret = rx_slot; 458 goto out_decr; 459 } 460 461 ret = dln2_send_wait(dln2, handle, cmd, rx_slot, obuf, obuf_len); 462 if (ret < 0) { 463 dev_err(dev, "USB write failed: %d\n", ret); 464 goto out_free_rx_slot; 465 } 466 467 rxc = &rxs->slots[rx_slot]; 468 469 ret = wait_for_completion_interruptible_timeout(&rxc->done, timeout); 470 if (ret <= 0) { 471 if (!ret) 472 ret = -ETIMEDOUT; 473 goto out_free_rx_slot; 474 } else { 475 ret = 0; 476 } 477 478 if (dln2->disconnect) { 479 ret = -ENODEV; 480 goto out_free_rx_slot; 481 } 482 483 /* if we got here we know that the response header has been checked */ 484 rsp = rxc->urb->transfer_buffer; 485 size = le16_to_cpu(rsp->hdr.size); 486 487 if (size < sizeof(*rsp)) { 488 ret = -EPROTO; 489 goto out_free_rx_slot; 490 } 491 492 if (le16_to_cpu(rsp->result) > 0x80) { 493 dev_dbg(dev, "%d received response with error %d\n", 494 handle, le16_to_cpu(rsp->result)); 495 ret = -EREMOTEIO; 496 goto out_free_rx_slot; 497 } 498 499 if (!ibuf) 500 goto out_free_rx_slot; 501 502 if (*ibuf_len > size - sizeof(*rsp)) 503 *ibuf_len = size - sizeof(*rsp); 504 505 memcpy(ibuf, rsp + 1, *ibuf_len); 506 507 out_free_rx_slot: 508 free_rx_slot(dln2, handle, rx_slot); 509 out_decr: 510 spin_lock(&dln2->disconnect_lock); 511 dln2->active_transfers--; 512 spin_unlock(&dln2->disconnect_lock); 513 if (dln2->disconnect) 514 wake_up(&dln2->disconnect_wq); 515 516 return ret; 517 } 518 519 int dln2_transfer(struct platform_device *pdev, u16 cmd, 520 const void *obuf, unsigned obuf_len, 521 void *ibuf, unsigned *ibuf_len) 522 { 523 struct dln2_platform_data *dln2_pdata; 524 struct dln2_dev *dln2; 525 u16 handle; 526 527 dln2 = dev_get_drvdata(pdev->dev.parent); 528 dln2_pdata = dev_get_platdata(&pdev->dev); 529 handle = dln2_pdata->handle; 530 531 return _dln2_transfer(dln2, handle, cmd, obuf, obuf_len, ibuf, 532 ibuf_len); 533 } 534 EXPORT_SYMBOL(dln2_transfer); 535 536 static int dln2_check_hw(struct dln2_dev *dln2) 537 { 538 int ret; 539 __le32 hw_type; 540 int len = sizeof(hw_type); 541 542 ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_VER, 543 NULL, 0, &hw_type, &len); 544 if (ret < 0) 545 return ret; 546 if (len < sizeof(hw_type)) 547 return -EREMOTEIO; 548 549 if (le32_to_cpu(hw_type) != DLN2_HW_ID) { 550 dev_err(&dln2->interface->dev, "Device ID 0x%x not supported\n", 551 le32_to_cpu(hw_type)); 552 return -ENODEV; 553 } 554 555 return 0; 556 } 557 558 static int dln2_print_serialno(struct dln2_dev *dln2) 559 { 560 int ret; 561 __le32 serial_no; 562 int len = sizeof(serial_no); 563 struct device *dev = &dln2->interface->dev; 564 565 ret = _dln2_transfer(dln2, DLN2_HANDLE_CTRL, CMD_GET_DEVICE_SN, NULL, 0, 566 &serial_no, &len); 567 if (ret < 0) 568 return ret; 569 if (len < sizeof(serial_no)) 570 return -EREMOTEIO; 571 572 dev_info(dev, "Diolan DLN2 serial %u\n", le32_to_cpu(serial_no)); 573 574 return 0; 575 } 576 577 static int dln2_hw_init(struct dln2_dev *dln2) 578 { 579 int ret; 580 581 ret = dln2_check_hw(dln2); 582 if (ret < 0) 583 return ret; 584 585 return dln2_print_serialno(dln2); 586 } 587 588 static void dln2_free_rx_urbs(struct dln2_dev *dln2) 589 { 590 int i; 591 592 for (i = 0; i < DLN2_MAX_URBS; i++) { 593 usb_free_urb(dln2->rx_urb[i]); 594 kfree(dln2->rx_buf[i]); 595 } 596 } 597 598 static void dln2_stop_rx_urbs(struct dln2_dev *dln2) 599 { 600 int i; 601 602 for (i = 0; i < DLN2_MAX_URBS; i++) 603 usb_kill_urb(dln2->rx_urb[i]); 604 } 605 606 static void dln2_free(struct dln2_dev *dln2) 607 { 608 dln2_free_rx_urbs(dln2); 609 usb_put_dev(dln2->usb_dev); 610 kfree(dln2); 611 } 612 613 static int dln2_setup_rx_urbs(struct dln2_dev *dln2, 614 struct usb_host_interface *hostif) 615 { 616 int i; 617 const int rx_max_size = DLN2_RX_BUF_SIZE; 618 619 for (i = 0; i < DLN2_MAX_URBS; i++) { 620 dln2->rx_buf[i] = kmalloc(rx_max_size, GFP_KERNEL); 621 if (!dln2->rx_buf[i]) 622 return -ENOMEM; 623 624 dln2->rx_urb[i] = usb_alloc_urb(0, GFP_KERNEL); 625 if (!dln2->rx_urb[i]) 626 return -ENOMEM; 627 628 usb_fill_bulk_urb(dln2->rx_urb[i], dln2->usb_dev, 629 usb_rcvbulkpipe(dln2->usb_dev, dln2->ep_in), 630 dln2->rx_buf[i], rx_max_size, dln2_rx, dln2); 631 } 632 633 return 0; 634 } 635 636 static int dln2_start_rx_urbs(struct dln2_dev *dln2, gfp_t gfp) 637 { 638 struct device *dev = &dln2->interface->dev; 639 int ret; 640 int i; 641 642 for (i = 0; i < DLN2_MAX_URBS; i++) { 643 ret = usb_submit_urb(dln2->rx_urb[i], gfp); 644 if (ret < 0) { 645 dev_err(dev, "failed to submit RX URB: %d\n", ret); 646 return ret; 647 } 648 } 649 650 return 0; 651 } 652 653 enum { 654 DLN2_ACPI_MATCH_GPIO = 0, 655 DLN2_ACPI_MATCH_I2C = 1, 656 DLN2_ACPI_MATCH_SPI = 2, 657 DLN2_ACPI_MATCH_ADC = 3, 658 }; 659 660 static struct dln2_platform_data dln2_pdata_gpio = { 661 .handle = DLN2_HANDLE_GPIO, 662 }; 663 664 static struct mfd_cell_acpi_match dln2_acpi_match_gpio = { 665 .adr = DLN2_ACPI_MATCH_GPIO, 666 }; 667 668 /* Only one I2C port seems to be supported on current hardware */ 669 static struct dln2_platform_data dln2_pdata_i2c = { 670 .handle = DLN2_HANDLE_I2C, 671 .port = 0, 672 }; 673 674 static struct mfd_cell_acpi_match dln2_acpi_match_i2c = { 675 .adr = DLN2_ACPI_MATCH_I2C, 676 }; 677 678 /* Only one SPI port supported */ 679 static struct dln2_platform_data dln2_pdata_spi = { 680 .handle = DLN2_HANDLE_SPI, 681 .port = 0, 682 }; 683 684 static struct mfd_cell_acpi_match dln2_acpi_match_spi = { 685 .adr = DLN2_ACPI_MATCH_SPI, 686 }; 687 688 /* Only one ADC port supported */ 689 static struct dln2_platform_data dln2_pdata_adc = { 690 .handle = DLN2_HANDLE_ADC, 691 .port = 0, 692 }; 693 694 static struct mfd_cell_acpi_match dln2_acpi_match_adc = { 695 .adr = DLN2_ACPI_MATCH_ADC, 696 }; 697 698 static const struct mfd_cell dln2_devs[] = { 699 { 700 .name = "dln2-gpio", 701 .acpi_match = &dln2_acpi_match_gpio, 702 .platform_data = &dln2_pdata_gpio, 703 .pdata_size = sizeof(struct dln2_platform_data), 704 }, 705 { 706 .name = "dln2-i2c", 707 .acpi_match = &dln2_acpi_match_i2c, 708 .platform_data = &dln2_pdata_i2c, 709 .pdata_size = sizeof(struct dln2_platform_data), 710 }, 711 { 712 .name = "dln2-spi", 713 .acpi_match = &dln2_acpi_match_spi, 714 .platform_data = &dln2_pdata_spi, 715 .pdata_size = sizeof(struct dln2_platform_data), 716 }, 717 { 718 .name = "dln2-adc", 719 .acpi_match = &dln2_acpi_match_adc, 720 .platform_data = &dln2_pdata_adc, 721 .pdata_size = sizeof(struct dln2_platform_data), 722 }, 723 }; 724 725 static void dln2_stop(struct dln2_dev *dln2) 726 { 727 int i, j; 728 729 /* don't allow starting new transfers */ 730 spin_lock(&dln2->disconnect_lock); 731 dln2->disconnect = true; 732 spin_unlock(&dln2->disconnect_lock); 733 734 /* cancel in progress transfers */ 735 for (i = 0; i < DLN2_HANDLES; i++) { 736 struct dln2_mod_rx_slots *rxs = &dln2->mod_rx_slots[i]; 737 unsigned long flags; 738 739 spin_lock_irqsave(&rxs->lock, flags); 740 741 /* cancel all response waiters */ 742 for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) { 743 struct dln2_rx_context *rxc = &rxs->slots[j]; 744 745 if (rxc->in_use) 746 complete(&rxc->done); 747 } 748 749 spin_unlock_irqrestore(&rxs->lock, flags); 750 } 751 752 /* wait for transfers to end */ 753 wait_event(dln2->disconnect_wq, !dln2->active_transfers); 754 755 dln2_stop_rx_urbs(dln2); 756 } 757 758 static void dln2_disconnect(struct usb_interface *interface) 759 { 760 struct dln2_dev *dln2 = usb_get_intfdata(interface); 761 762 dln2_stop(dln2); 763 764 mfd_remove_devices(&interface->dev); 765 766 dln2_free(dln2); 767 } 768 769 static int dln2_probe(struct usb_interface *interface, 770 const struct usb_device_id *usb_id) 771 { 772 struct usb_host_interface *hostif = interface->cur_altsetting; 773 struct usb_endpoint_descriptor *epin; 774 struct usb_endpoint_descriptor *epout; 775 struct device *dev = &interface->dev; 776 struct dln2_dev *dln2; 777 int ret; 778 int i, j; 779 780 if (hostif->desc.bInterfaceNumber != 0 || 781 hostif->desc.bNumEndpoints < 2) 782 return -ENODEV; 783 784 epout = &hostif->endpoint[DLN2_EP_OUT].desc; 785 if (!usb_endpoint_is_bulk_out(epout)) 786 return -ENODEV; 787 epin = &hostif->endpoint[DLN2_EP_IN].desc; 788 if (!usb_endpoint_is_bulk_in(epin)) 789 return -ENODEV; 790 791 dln2 = kzalloc(sizeof(*dln2), GFP_KERNEL); 792 if (!dln2) 793 return -ENOMEM; 794 795 dln2->ep_out = epout->bEndpointAddress; 796 dln2->ep_in = epin->bEndpointAddress; 797 dln2->usb_dev = usb_get_dev(interface_to_usbdev(interface)); 798 dln2->interface = interface; 799 usb_set_intfdata(interface, dln2); 800 init_waitqueue_head(&dln2->disconnect_wq); 801 802 for (i = 0; i < DLN2_HANDLES; i++) { 803 init_waitqueue_head(&dln2->mod_rx_slots[i].wq); 804 spin_lock_init(&dln2->mod_rx_slots[i].lock); 805 for (j = 0; j < DLN2_MAX_RX_SLOTS; j++) 806 init_completion(&dln2->mod_rx_slots[i].slots[j].done); 807 } 808 809 spin_lock_init(&dln2->event_cb_lock); 810 spin_lock_init(&dln2->disconnect_lock); 811 INIT_LIST_HEAD(&dln2->event_cb_list); 812 813 ret = dln2_setup_rx_urbs(dln2, hostif); 814 if (ret) 815 goto out_free; 816 817 ret = dln2_start_rx_urbs(dln2, GFP_KERNEL); 818 if (ret) 819 goto out_stop_rx; 820 821 ret = dln2_hw_init(dln2); 822 if (ret < 0) { 823 dev_err(dev, "failed to initialize hardware\n"); 824 goto out_stop_rx; 825 } 826 827 ret = mfd_add_hotplug_devices(dev, dln2_devs, ARRAY_SIZE(dln2_devs)); 828 if (ret != 0) { 829 dev_err(dev, "failed to add mfd devices to core\n"); 830 goto out_stop_rx; 831 } 832 833 return 0; 834 835 out_stop_rx: 836 dln2_stop_rx_urbs(dln2); 837 838 out_free: 839 dln2_free(dln2); 840 841 return ret; 842 } 843 844 static int dln2_suspend(struct usb_interface *iface, pm_message_t message) 845 { 846 struct dln2_dev *dln2 = usb_get_intfdata(iface); 847 848 dln2_stop(dln2); 849 850 return 0; 851 } 852 853 static int dln2_resume(struct usb_interface *iface) 854 { 855 struct dln2_dev *dln2 = usb_get_intfdata(iface); 856 857 dln2->disconnect = false; 858 859 return dln2_start_rx_urbs(dln2, GFP_NOIO); 860 } 861 862 static const struct usb_device_id dln2_table[] = { 863 { USB_DEVICE(0xa257, 0x2013) }, 864 { } 865 }; 866 867 MODULE_DEVICE_TABLE(usb, dln2_table); 868 869 static struct usb_driver dln2_driver = { 870 .name = "dln2", 871 .probe = dln2_probe, 872 .disconnect = dln2_disconnect, 873 .id_table = dln2_table, 874 .suspend = dln2_suspend, 875 .resume = dln2_resume, 876 }; 877 878 module_usb_driver(dln2_driver); 879 880 MODULE_AUTHOR("Octavian Purdila <octavian.purdila@intel.com>"); 881 MODULE_DESCRIPTION("Core driver for the Diolan DLN2 interface adapter"); 882 MODULE_LICENSE("GPL v2"); 883