linux/drivers/nfc/nfcmrvl/usb.c
<<
>>
Prefs
   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
  26static 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
  32MODULE_DEVICE_TABLE(usb, nfcmrvl_table);
  33
  34#define NFCMRVL_USB_BULK_RUNNING        1
  35#define NFCMRVL_USB_SUSPENDING          2
  36
  37struct 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
  54static 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
  68static 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                        memcpy(skb_put(skb, urb->actual_length),
  87                               urb->transfer_buffer, 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
 112static int
 113nfcmrvl_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
 157static 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
 164        nfc_info(priv->dev, "urb %p status %d count %d\n",
 165                 urb, urb->status, urb->actual_length);
 166
 167        spin_lock(&drv_data->txlock);
 168        drv_data->tx_in_flight--;
 169        spin_unlock(&drv_data->txlock);
 170
 171        kfree(urb->setup_packet);
 172        kfree_skb(skb);
 173}
 174
 175static int nfcmrvl_usb_nci_open(struct nfcmrvl_private *priv)
 176{
 177        struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
 178        int err;
 179
 180        err = usb_autopm_get_interface(drv_data->intf);
 181        if (err)
 182                return err;
 183
 184        drv_data->intf->needs_remote_wakeup = 1;
 185
 186        err = nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
 187        if (err)
 188                goto failed;
 189
 190        set_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
 191        nfcmrvl_submit_bulk_urb(drv_data, GFP_KERNEL);
 192
 193        usb_autopm_put_interface(drv_data->intf);
 194        return 0;
 195
 196failed:
 197        usb_autopm_put_interface(drv_data->intf);
 198        return err;
 199}
 200
 201static void nfcmrvl_usb_stop_traffic(struct nfcmrvl_usb_drv_data *drv_data)
 202{
 203        usb_kill_anchored_urbs(&drv_data->bulk_anchor);
 204}
 205
 206static int nfcmrvl_usb_nci_close(struct nfcmrvl_private *priv)
 207{
 208        struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
 209        int err;
 210
 211        cancel_work_sync(&drv_data->waker);
 212
 213        clear_bit(NFCMRVL_USB_BULK_RUNNING, &drv_data->flags);
 214
 215        nfcmrvl_usb_stop_traffic(drv_data);
 216        usb_kill_anchored_urbs(&drv_data->tx_anchor);
 217        err = usb_autopm_get_interface(drv_data->intf);
 218        if (err)
 219                goto failed;
 220
 221        drv_data->intf->needs_remote_wakeup = 0;
 222        usb_autopm_put_interface(drv_data->intf);
 223
 224failed:
 225        usb_scuttle_anchored_urbs(&drv_data->deferred);
 226        return 0;
 227}
 228
 229static int nfcmrvl_usb_nci_send(struct nfcmrvl_private *priv,
 230                                struct sk_buff *skb)
 231{
 232        struct nfcmrvl_usb_drv_data *drv_data = priv->drv_data;
 233        struct urb *urb;
 234        unsigned int pipe;
 235        int err;
 236
 237        if (!drv_data->bulk_tx_ep)
 238                return -ENODEV;
 239
 240        urb = usb_alloc_urb(0, GFP_ATOMIC);
 241        if (!urb)
 242                return -ENOMEM;
 243
 244        pipe = usb_sndbulkpipe(drv_data->udev,
 245                                drv_data->bulk_tx_ep->bEndpointAddress);
 246
 247        usb_fill_bulk_urb(urb, drv_data->udev, pipe, skb->data, skb->len,
 248                          nfcmrvl_tx_complete, skb);
 249
 250        err = nfcmrvl_inc_tx(drv_data);
 251        if (err) {
 252                usb_anchor_urb(urb, &drv_data->deferred);
 253                schedule_work(&drv_data->waker);
 254                err = 0;
 255                goto done;
 256        }
 257
 258        usb_anchor_urb(urb, &drv_data->tx_anchor);
 259
 260        err = usb_submit_urb(urb, GFP_ATOMIC);
 261        if (err) {
 262                if (err != -EPERM && err != -ENODEV)
 263                        nfc_err(&drv_data->udev->dev,
 264                                "urb %p submission failed (%d)\n", urb, -err);
 265                kfree(urb->setup_packet);
 266                usb_unanchor_urb(urb);
 267        } else {
 268                usb_mark_last_busy(drv_data->udev);
 269        }
 270
 271done:
 272        usb_free_urb(urb);
 273        return err;
 274}
 275
 276static struct nfcmrvl_if_ops usb_ops = {
 277        .nci_open = nfcmrvl_usb_nci_open,
 278        .nci_close = nfcmrvl_usb_nci_close,
 279        .nci_send = nfcmrvl_usb_nci_send,
 280};
 281
 282static void nfcmrvl_waker(struct work_struct *work)
 283{
 284        struct nfcmrvl_usb_drv_data *drv_data =
 285                        container_of(work, struct nfcmrvl_usb_drv_data, waker);
 286        int err;
 287
 288        err = usb_autopm_get_interface(drv_data->intf);
 289        if (err)
 290                return;
 291
 292        usb_autopm_put_interface(drv_data->intf);
 293}
 294
 295static int nfcmrvl_probe(struct usb_interface *intf,
 296                         const struct usb_device_id *id)
 297{
 298        struct usb_endpoint_descriptor *ep_desc;
 299        struct nfcmrvl_usb_drv_data *drv_data;
 300        struct nfcmrvl_private *priv;
 301        int i;
 302        struct usb_device *udev = interface_to_usbdev(intf);
 303        struct nfcmrvl_platform_data config;
 304
 305        /* No configuration for USB */
 306        memset(&config, 0, sizeof(config));
 307
 308        nfc_info(&udev->dev, "intf %p id %p\n", intf, id);
 309
 310        drv_data = devm_kzalloc(&intf->dev, sizeof(*drv_data), GFP_KERNEL);
 311        if (!drv_data)
 312                return -ENOMEM;
 313
 314        for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; i++) {
 315                ep_desc = &intf->cur_altsetting->endpoint[i].desc;
 316
 317                if (!drv_data->bulk_tx_ep &&
 318                    usb_endpoint_is_bulk_out(ep_desc)) {
 319                        drv_data->bulk_tx_ep = ep_desc;
 320                        continue;
 321                }
 322
 323                if (!drv_data->bulk_rx_ep &&
 324                    usb_endpoint_is_bulk_in(ep_desc)) {
 325                        drv_data->bulk_rx_ep = ep_desc;
 326                        continue;
 327                }
 328        }
 329
 330        if (!drv_data->bulk_tx_ep || !drv_data->bulk_rx_ep)
 331                return -ENODEV;
 332
 333        drv_data->udev = udev;
 334        drv_data->intf = intf;
 335
 336        INIT_WORK(&drv_data->waker, nfcmrvl_waker);
 337        spin_lock_init(&drv_data->txlock);
 338
 339        init_usb_anchor(&drv_data->tx_anchor);
 340        init_usb_anchor(&drv_data->bulk_anchor);
 341        init_usb_anchor(&drv_data->deferred);
 342
 343        priv = nfcmrvl_nci_register_dev(NFCMRVL_PHY_USB, drv_data, &usb_ops,
 344                                        &drv_data->udev->dev, &config);
 345        if (IS_ERR(priv))
 346                return PTR_ERR(priv);
 347
 348        drv_data->priv = priv;
 349        drv_data->priv->support_fw_dnld = false;
 350
 351        priv->dev = &drv_data->udev->dev;
 352
 353        usb_set_intfdata(intf, drv_data);
 354
 355        return 0;
 356}
 357
 358static 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
 373static 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
 398static 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
 413static 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
 443failed:
 444        usb_scuttle_anchored_urbs(&drv_data->deferred);
 445done:
 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
 454static 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};
 468module_usb_driver(nfcmrvl_usb_driver);
 469
 470MODULE_AUTHOR("Marvell International Ltd.");
 471MODULE_DESCRIPTION("Marvell NFC-over-USB driver");
 472MODULE_LICENSE("GPL v2");
 473
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.