drivers/nfc/nfcmrvl/usb.c

   1 /**
   2  * Marvell NFC-over-USB driver: USB interface related functions
   3  *
   4  * Copyright (C) 2014, Marvell International Ltd.
   5  *
   6  * This software file (the "File") is distributed by Marvell International
   7  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
   8  * (the "License").  You may use, redistribute and/or modify this File in
   9  * accordance with the terms and conditions of the License, a copy of which
  10  * is available on the worldwide web at
  11  * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
  12  *
  13  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
  14  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
  15  * ARE EXPRESSLY DISCLAIMED.  The License provides additional details about
  16  * this warranty disclaimer.
  17  **/
  18
  19 #include <linux/module.h>
  20 #include <linux/usb.h>
  21 #include <linux/nfc.h>
  22 #include <net/nfc/nci.h>
  23 #include <net/nfc/nci_core.h>
  24 #include "nfcmrvl.h"
  25
  26 static struct usb_device_id nfcmrvl_table[] = {
  27         { USB_DEVICE_AND_INTERFACE_INFO(0x1286, 0x2046,
  28                                         USB_CLASS_VENDOR_SPEC, 4, 1) },
  29         { }     /* Terminating entry */
  30 };
  31
  32 MODULE_DEVICE_TABLE(usb, nfcmrvl_table);
  33
  34 #define NFCMRVL_USB_BULK_RUNNING        1
  35 #define NFCMRVL_USB_SUSPENDING          2
  36
  37 struct nfcmrvl_usb_drv_data {
  38         struct usb_device *udev;
  39         struct usb_interface *intf;
  40         unsigned long flags;
  41         struct work_struct waker;
  42         struct usb_anchor tx_anchor;
  43         struct usb_anchor bulk_anchor;
  44         struct usb_anchor deferred;
  45         int tx_in_flight;
  46         /* protects tx_in_flight */
  47         spinlock_t txlock;
  48         struct usb_endpoint_descriptor *bulk_tx_ep;
  49         struct usb_endpoint_descriptor *bulk_rx_ep;
  50         int suspend_count;
  51         struct nfcmrvl_private *priv;
  52 };
  53
  54 static int nfcmrvl_inc_tx(struct nfcmrvl_usb_drv_data *drv_data)
  55 {
  56         unsigned long flags;
  57         int rv;
  58
  59         spin_lock_irqsave(&drv_data->txlock, flags);
  60         rv = test_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
  61         if (!rv)
  62                 drv_data->tx_in_flight++;
  63         spin_unlock_irqrestore(&drv_data->txlock, flags);
  64
  65         return rv;
  66 }
  67
  68 static void nfcmrvl_bulk_complete(struct urb *urb)
  69 {
  70         struct nfcmrvl_usb_drv_data *drv_data = urb->context;
  71         struct sk_buff *skb;
  72         int err;
  73
  74         dev_dbg(&drv_data->udev->dev, "urb %p status %d count %d\n",
  75                 urb, urb->status, urb->actual_length);
  76
  77         if (!test_bit(NFCMRVL_NCI_RUNNING, &drv_data->flags))
  78                 return;
  79
  80         if (!urb->status) {
  81                 skb = nci_skb_alloc(drv_data->priv->ndev, urb->actual_length,
  82                                     GFP_ATOMIC);
  83                 if (!skb) {
  84                         nfc_err(&drv_data->udev->dev, "failed to alloc mem\n");
  85                 } else {
  86                         skb_put_data(skb, urb->transfer_buffer,
  87                                      urb->actual_length);
  88                         if (nfcmrvl_nci_recv_frame(drv_data->priv, skb) < 0)
  89                                 nfc_err(&drv_data->udev->dev,
  90                                         "corrupted Rx packet\n");
  91                 }
  92         }
  93
  94         if (!test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags))
  95                 return;
  96
  97         usb_anchor_urb(urb, &drv_data->bulk_anchor);
  98         usb_mark_last_busy(drv_data->udev);
  99
 100         err = usb_submit_urb(urb, GFP_ATOMIC);
 101         if (err) {
 102                 /* -EPERM: urb is being killed;
 103                  * -ENODEV: device got disconnected
 104                  */
 105                 if (err != -EPERM && err != -ENODEV)
 106                         nfc_err(&drv_data->udev->dev,
 107                                 "urb %p failed to resubmit (%d)\n", urb, -err);
 108                 usb_unanchor_urb(urb);
 109         }
 110 }
 111
 112 static int
 113 nfcmrvl_submit_bulk_urb(struct nfcmrvl_usb_drv_data *drv_data, gfp_t mem_flags)
 114 {
 115         struct urb *urb;
 116         unsigned char *buf;
 117         unsigned int pipe;
 118         int err, size = NFCMRVL_NCI_MAX_EVENT_SIZE;
 119
 120         if (!drv_data->bulk_rx_ep)
 121                 return -ENODEV;
 122
 123         urb = usb_alloc_urb(0, mem_flags);
 124         if (!urb)
 125                 return -ENOMEM;
 126
 127         buf = kmalloc(size, mem_flags);
 128         if (!buf) {
 129                 usb_free_urb(urb);
 130                 return -ENOMEM;
 131         }
 132
 133         pipe = usb_rcvbulkpipe(drv_data->udev,
 134                                drv_data->bulk_rx_ep->bEndpointAddress);
 135
 136         usb_fill_bulk_urb(urb, drv_data->udev, pipe, buf, size,
 137                           nfcmrvl_bulk_complete, drv_data);
 138
 139         urb->transfer_flags |= URB_FREE_BUFFER;
 140
 141         usb_mark_last_busy(drv_data->udev);
 142         usb_anchor_urb(urb, &drv_data->bulk_anchor);
 143
 144         err = usb_submit_urb(urb, mem_flags);
 145         if (err) {
 146                 if (err != -EPERM && err != -ENODEV)
 147                         nfc_err(&drv_data->udev->dev,
 148                                 "urb %p submission failed (%d)\n", urb, -err);
 149                 usb_unanchor_urb(urb);
 150         }
 151
 152         usb_free_urb(urb);
 153
 154         return err;
 155 }
 156
 157 static void nfcmrvl_tx_complete(struct urb *urb)
 158 {
 159         struct sk_buff *skb = urb->context;
 160         struct nci_dev *ndev = (struct nci_dev *)skb->dev;
 161         struct nfcmrvl_private *priv = nci_get_drvdata(ndev);
 162         struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
 163         unsigned long flags;
 164
 165         nfc_info(priv->dev, "urb %p status %d count %d\n",
 166                  urb, urb->status, urb->actual_length);
 167
 168         spin_lock_irqsave(&drv_data->txlock, flags);
 169         drv_data->tx_in_flight--;
 170         spin_unlock_irqrestore(&drv_data->txlock, flags);
 171
 172         kfree(urb->setup_packet);
 173         kfree_skb(skb);
 174 }
 175
 176 static int nfcmrvl_usb_nci_open(struct nfcmrvl_private *priv)
 177 {
 178         struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
 179         int err;
 180
 181         err = usb_autopm_get_interface(drv_data->intf);
 182         if (err)
 183                 return err;
 184
 185         drv_data->intf->needs_remote_wakeup = 1;
 186
 187         err = nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
 188         if (err)
 189                 goto failed;
 190
 191         set_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
 192         nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
 193
 194         usb_autopm_put_interface(drv_data->intf);
 195         return 0;
 196
 197 failed:
 198         usb_autopm_put_interface(drv_data->intf);
 199         return err;
 200 }
 201
 202 static void nfcmrvl_usb_stop_traffic(struct nfcmrvl_usb_drv_data *drv_data)
 203 {
 204         usb_kill_anchored_urbs(&drv_data->bulk_anchor);
 205 }
 206
 207 static int nfcmrvl_usb_nci_close(struct nfcmrvl_private *priv)
 208 {
 209         struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
 210         int err;
 211
 212         cancel_work_sync(&drv_data->waker);
 213
 214         clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
 215
 216         nfcmrvl_usb_stop_traffic(drv_data);
 217         usb_kill_anchored_urbs(&drv_data->tx_anchor);
 218         err = usb_autopm_get_interface(drv_data->intf);
 219         if (err)
 220                 goto failed;
 221
 222         drv_data->intf->needs_remote_wakeup = 0;
 223         usb_autopm_put_interface(drv_data->intf);
 224
 225 failed:
 226         usb_scuttle_anchored_urbs(&drv_data->deferred);
 227         return 0;
 228 }
 229
 230 static int nfcmrvl_usb_nci_send(struct nfcmrvl_private *priv,
 231                                 struct sk_buff *skb)
 232 {
 233         struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
 234         struct urb *urb;
 235         unsigned int pipe;
 236         int err;
 237
 238         if (!drv_data->bulk_tx_ep)
 239                 return -ENODEV;
 240
 241         urb = usb_alloc_urb(0, GFP_ATOMIC);
 242         if (!urb)
 243                 return -ENOMEM;
 244
 245         pipe = usb_sndbulkpipe(drv_data->udev,
 246                                 drv_data->bulk_tx_ep->bEndpointAddress);
 247
 248         usb_fill_bulk_urb(urb, drv_data->udev, pipe, skb->data, skb->len,
 249                           nfcmrvl_tx_complete, skb);
 250
 251         err = nfcmrvl_inc_tx(drv_data);
 252         if (err) {
 253                 usb_anchor_urb(urb, &drv_data->deferred);
 254                 schedule_work(&drv_data->waker);
 255                 err = 0;
 256                 goto done;
 257         }
 258
 259         usb_anchor_urb(urb, &drv_data->tx_anchor);
 260
 261         err = usb_submit_urb(urb, GFP_ATOMIC);
 262         if (err) {
 263                 if (err != -EPERM && err != -ENODEV)
 264                         nfc_err(&drv_data->udev->dev,
 265                                 "urb %p submission failed (%d)\n", urb, -err);
 266                 kfree(urb->setup_packet);
 267                 usb_unanchor_urb(urb);
 268         } else {
 269                 usb_mark_last_busy(drv_data->udev);
 270         }
 271
 272 done:
 273         usb_free_urb(urb);
 274         return err;
 275 }
 276
 277 static struct nfcmrvl_if_ops usb_ops = {
 278         .nci_open = nfcmrvl_usb_nci_open,
 279         .nci_close = nfcmrvl_usb_nci_close,
 280         .nci_send = nfcmrvl_usb_nci_send,
 281 };
 282
 283 static void nfcmrvl_waker(struct work_struct *work)
 284 {
 285         struct nfcmrvl_usb_drv_data *drv_data =
 286                         container_of(work, struct nfcmrvl_usb_drv_data, waker);
 287         int err;
 288
 289         err = usb_autopm_get_interface(drv_data->intf);
 290         if (err)
 291                 return;
 292
 293         usb_autopm_put_interface(drv_data->intf);
 294 }
 295
 296 static int nfcmrvl_probe(struct usb_interface *intf,
 297                          const struct usb_device_id *id)
 298 {
 299         struct usb_endpoint_descriptor *ep_desc;
 300         struct nfcmrvl_usb_drv_data *drv_data;
 301         struct nfcmrvl_private *priv;
 302         int i;
 303         struct usb_device *udev = interface_to_usbdev(intf);
 304         struct nfcmrvl_platform_data config;
 305
 306         /* No configuration for USB */
 307         memset(&config, 0, sizeof(config));
 308         config.reset_n_io = -EINVAL;
 309
 310         nfc_info(&udev->dev, "intf %p id %p\n", intf, id);
 311
 312         drv_data = devm_kzalloc(&intf->dev, sizeof(*drv_data), GFP_KERNEL);
 313         if (!drv_data)
 314                 return -ENOMEM;
 315
 316         for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
 317                 ep_desc = &intf->cur_altsetting->endpoint[i].desc;
 318
 319                 if (!drv_data->bulk_tx_ep &&
 320                     usb_endpoint_is_bulk_out(ep_desc)) {
 321                         drv_data->bulk_tx_ep = ep_desc;
 322                         continue;
 323                 }
 324
 325                 if (!drv_data->bulk_rx_ep &&
 326                     usb_endpoint_is_bulk_in(ep_desc)) {
 327                         drv_data->bulk_rx_ep = ep_desc;
 328                         continue;
 329                 }
 330         }
 331
 332         if (!drv_data->bulk_tx_ep || !drv_data->bulk_rx_ep)
 333                 return -ENODEV;
 334
 335         drv_data->udev = udev;
 336         drv_data->intf = intf;
 337
 338         INIT_WORK(&drv_data->waker, nfcmrvl_waker);
 339         spin_lock_init(&drv_data->txlock);
 340
 341         init_usb_anchor(&drv_data->tx_anchor);
 342         init_usb_anchor(&drv_data->bulk_anchor);
 343         init_usb_anchor(&drv_data->deferred);
 344
 345         priv = nfcmrvl_nci_register_dev(NFCMRVL_PHY_USB, drv_data, &usb_ops,
 346                                         &intf->dev, &config);
 347         if (IS_ERR(priv))
 348                 return PTR_ERR(priv);
 349
 350         drv_data->priv = priv;
 351         drv_data->priv->support_fw_dnld = false;
 352
 353         usb_set_intfdata(intf, drv_data);
 354
 355         return 0;
 356 }
 357
 358 static void nfcmrvl_disconnect(struct usb_interface *intf)
 359 {
 360         struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
 361
 362         if (!drv_data)
 363                 return;
 364
 365         nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
 366
 367         nfcmrvl_nci_unregister_dev(drv_data->priv);
 368
 369         usb_set_intfdata(drv_data->intf, NULL);
 370 }
 371
 372 #ifdef CONFIG_PM
 373 static int nfcmrvl_suspend(struct usb_interface *intf, pm_message_t message)
 374 {
 375         struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
 376
 377         nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
 378
 379         if (drv_data->suspend_count++)
 380                 return 0;
 381
 382         spin_lock_irq(&drv_data->txlock);
 383         if (!(PMSG_IS_AUTO(message) && drv_data->tx_in_flight)) {
 384                 set_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
 385                 spin_unlock_irq(&drv_data->txlock);
 386         } else {
 387                 spin_unlock_irq(&drv_data->txlock);
 388                 drv_data->suspend_count--;
 389                 return -EBUSY;
 390         }
 391
 392         nfcmrvl_usb_stop_traffic(drv_data);
 393         usb_kill_anchored_urbs(&drv_data->tx_anchor);
 394
 395         return 0;
 396 }
 397
 398 static void nfcmrvl_play_deferred(struct nfcmrvl_usb_drv_data *drv_data)
 399 {
 400         struct urb *urb;
 401         int err;
 402
 403         while ((urb = usb_get_from_anchor(&drv_data->deferred))) {
 404                 err = usb_submit_urb(urb, GFP_ATOMIC);
 405                 if (err)
 406                         break;
 407
 408                 drv_data->tx_in_flight++;
 409         }
 410         usb_scuttle_anchored_urbs(&drv_data->deferred);
 411 }
 412
 413 static int nfcmrvl_resume(struct usb_interface *intf)
 414 {
 415         struct nfcmrvl_usb_drv_data *drv_data = usb_get_intfdata(intf);
 416         int err = 0;
 417
 418         nfc_info(&drv_data->udev->dev, "intf %p\n", intf);
 419
 420         if (--drv_data->suspend_count)
 421                 return 0;
 422
 423         if (!test_bit(NFCMRVL_NCI_RUNNING, &drv_data->flags))
 424                 goto done;
 425
 426         if (test_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags)) {
 427                 err = nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);
 428                 if (err) {
 429                         clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
 430                         goto failed;
 431                 }
 432
 433                 nfcmrvl_submit_bulk_urb(drv_data, GFP_NOIO);
 434         }
 435
 436         spin_lock_irq(&drv_data->txlock);
 437         nfcmrvl_play_deferred(drv_data);
 438         clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
 439         spin_unlock_irq(&drv_data->txlock);
 440
 441         return 0;
 442
 443 failed:
 444         usb_scuttle_anchored_urbs(&drv_data->deferred);
 445 done:
 446         spin_lock_irq(&drv_data->txlock);
 447         clear_bit(NFCMRVL_USB_SUSPENDING, &drv_data->flags);
 448         spin_unlock_irq(&drv_data->txlock);
 449
 450         return err;
 451 }
 452 #endif
 453
 454 static struct usb_driver nfcmrvl_usb_driver = {
 455         .name           = "nfcmrvl",
 456         .probe          = nfcmrvl_probe,
 457         .disconnect     = nfcmrvl_disconnect,
 458 #ifdef CONFIG_PM
 459         .suspend        = nfcmrvl_suspend,
 460         .resume         = nfcmrvl_resume,
 461         .reset_resume   = nfcmrvl_resume,
 462 #endif
 463         .id_table       = nfcmrvl_table,
 464         .supports_autosuspend = 1,
 465         .disable_hub_initiated_lpm = 1,
 466         .soft_unbind = 1,
 467 };
 468 module_usb_driver(nfcmrvl_usb_driver);
 469
 470 MODULE_AUTHOR("Marvell International Ltd.");
 471 MODULE_DESCRIPTION("Marvell NFC-over-USB driver");
 472 MODULE_LICENSE("GPL v2");