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