drivers/mfd/dln2.c

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