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"); 473