linux/drivers/usb/gadget/udc/max3420_udc.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * MAX3420 Device Controller driver for USB.
   4 *
   5 * Author: Jaswinder Singh Brar <jaswinder.singh@linaro.org>
   6 * (C) Copyright 2019-2020 Linaro Ltd
   7 *
   8 * Based on:
   9 *      o MAX3420E datasheet
  10 *              https://datasheets.maximintegrated.com/en/ds/MAX3420E.pdf
  11 *      o MAX342{0,1}E Programming Guides
  12 *              https://pdfserv.maximintegrated.com/en/an/AN3598.pdf
  13 *              https://pdfserv.maximintegrated.com/en/an/AN3785.pdf
  14 */
  15
  16#include <linux/delay.h>
  17#include <linux/device.h>
  18#include <linux/interrupt.h>
  19#include <linux/io.h>
  20#include <linux/module.h>
  21#include <linux/bitfield.h>
  22#include <linux/of_address.h>
  23#include <linux/of_device.h>
  24#include <linux/of_platform.h>
  25#include <linux/of_irq.h>
  26#include <linux/prefetch.h>
  27#include <linux/usb/ch9.h>
  28#include <linux/usb/gadget.h>
  29#include <linux/spi/spi.h>
  30#include <linux/gpio/consumer.h>
  31
  32#define MAX3420_MAX_EPS         4
  33#define MAX3420_EP_MAX_PACKET           64  /* Same for all Endpoints */
  34#define MAX3420_EPNAME_SIZE             16  /* Buffer size for endpoint name */
  35
  36#define MAX3420_ACKSTAT         BIT(0)
  37
  38#define MAX3420_SPI_DIR_RD      0       /* read register from MAX3420 */
  39#define MAX3420_SPI_DIR_WR      1       /* write register to MAX3420 */
  40
  41/* SPI commands: */
  42#define MAX3420_SPI_DIR_SHIFT   1
  43#define MAX3420_SPI_REG_SHIFT   3
  44
  45#define MAX3420_REG_EP0FIFO     0
  46#define MAX3420_REG_EP1FIFO     1
  47#define MAX3420_REG_EP2FIFO     2
  48#define MAX3420_REG_EP3FIFO     3
  49#define MAX3420_REG_SUDFIFO     4
  50#define MAX3420_REG_EP0BC       5
  51#define MAX3420_REG_EP1BC       6
  52#define MAX3420_REG_EP2BC       7
  53#define MAX3420_REG_EP3BC       8
  54
  55#define MAX3420_REG_EPSTALLS    9
  56        #define ACKSTAT         BIT(6)
  57        #define STLSTAT         BIT(5)
  58        #define STLEP3IN        BIT(4)
  59        #define STLEP2IN        BIT(3)
  60        #define STLEP1OUT       BIT(2)
  61        #define STLEP0OUT       BIT(1)
  62        #define STLEP0IN        BIT(0)
  63
  64#define MAX3420_REG_CLRTOGS     10
  65        #define EP3DISAB        BIT(7)
  66        #define EP2DISAB        BIT(6)
  67        #define EP1DISAB        BIT(5)
  68        #define CTGEP3IN        BIT(4)
  69        #define CTGEP2IN        BIT(3)
  70        #define CTGEP1OUT       BIT(2)
  71
  72#define MAX3420_REG_EPIRQ       11
  73#define MAX3420_REG_EPIEN       12
  74        #define SUDAVIRQ        BIT(5)
  75        #define IN3BAVIRQ       BIT(4)
  76        #define IN2BAVIRQ       BIT(3)
  77        #define OUT1DAVIRQ      BIT(2)
  78        #define OUT0DAVIRQ      BIT(1)
  79        #define IN0BAVIRQ       BIT(0)
  80
  81#define MAX3420_REG_USBIRQ      13
  82#define MAX3420_REG_USBIEN      14
  83        #define OSCOKIRQ        BIT(0)
  84        #define RWUDNIRQ        BIT(1)
  85        #define BUSACTIRQ       BIT(2)
  86        #define URESIRQ         BIT(3)
  87        #define SUSPIRQ         BIT(4)
  88        #define NOVBUSIRQ       BIT(5)
  89        #define VBUSIRQ         BIT(6)
  90        #define URESDNIRQ       BIT(7)
  91
  92#define MAX3420_REG_USBCTL      15
  93        #define HOSCSTEN        BIT(7)
  94        #define VBGATE          BIT(6)
  95        #define CHIPRES         BIT(5)
  96        #define PWRDOWN         BIT(4)
  97        #define CONNECT         BIT(3)
  98        #define SIGRWU          BIT(2)
  99
 100#define MAX3420_REG_CPUCTL      16
 101        #define IE              BIT(0)
 102
 103#define MAX3420_REG_PINCTL      17
 104        #define EP3INAK         BIT(7)
 105        #define EP2INAK         BIT(6)
 106        #define EP0INAK         BIT(5)
 107        #define FDUPSPI         BIT(4)
 108        #define INTLEVEL        BIT(3)
 109        #define POSINT          BIT(2)
 110        #define GPXB            BIT(1)
 111        #define GPXA            BIT(0)
 112
 113#define MAX3420_REG_REVISION    18
 114
 115#define MAX3420_REG_FNADDR      19
 116        #define FNADDR_MASK     0x7f
 117
 118#define MAX3420_REG_IOPINS      20
 119#define MAX3420_REG_IOPINS2     21
 120#define MAX3420_REG_GPINIRQ     22
 121#define MAX3420_REG_GPINIEN     23
 122#define MAX3420_REG_GPINPOL     24
 123#define MAX3420_REG_HIRQ        25
 124#define MAX3420_REG_HIEN        26
 125#define MAX3420_REG_MODE        27
 126#define MAX3420_REG_PERADDR     28
 127#define MAX3420_REG_HCTL        29
 128#define MAX3420_REG_HXFR        30
 129#define MAX3420_REG_HRSL        31
 130
 131#define ENABLE_IRQ      BIT(0)
 132#define IOPIN_UPDATE    BIT(1)
 133#define REMOTE_WAKEUP   BIT(2)
 134#define CONNECT_HOST    GENMASK(4, 3)
 135#define HCONNECT        (1 << 3)
 136#define HDISCONNECT     (3 << 3)
 137#define UDC_START       GENMASK(6, 5)
 138#define START           (1 << 5)
 139#define STOP            (3 << 5)
 140#define ENABLE_EP       GENMASK(8, 7)
 141#define ENABLE          (1 << 7)
 142#define DISABLE         (3 << 7)
 143#define STALL_EP        GENMASK(10, 9)
 144#define STALL           (1 << 9)
 145#define UNSTALL         (3 << 9)
 146
 147#define MAX3420_CMD(c)          FIELD_PREP(GENMASK(7, 3), c)
 148#define MAX3420_SPI_CMD_RD(c)   (MAX3420_CMD(c) | (0 << 1))
 149#define MAX3420_SPI_CMD_WR(c)   (MAX3420_CMD(c) | (1 << 1))
 150
 151struct max3420_req {
 152        struct usb_request usb_req;
 153        struct list_head queue;
 154        struct max3420_ep *ep;
 155};
 156
 157struct max3420_ep {
 158        struct usb_ep ep_usb;
 159        struct max3420_udc *udc;
 160        struct list_head queue;
 161        char name[MAX3420_EPNAME_SIZE];
 162        unsigned int maxpacket;
 163        spinlock_t lock;
 164        int halted;
 165        u32 todo;
 166        int id;
 167};
 168
 169struct max3420_udc {
 170        struct usb_gadget gadget;
 171        struct max3420_ep ep[MAX3420_MAX_EPS];
 172        struct usb_gadget_driver *driver;
 173        struct task_struct *thread_task;
 174        int remote_wkp, is_selfpowered;
 175        bool vbus_active, softconnect;
 176        struct usb_ctrlrequest setup;
 177        struct mutex spi_bus_mutex;
 178        struct max3420_req ep0req;
 179        struct spi_device *spi;
 180        struct device *dev;
 181        spinlock_t lock;
 182        bool suspended;
 183        u8 ep0buf[64];
 184        u32 todo;
 185};
 186
 187#define to_max3420_req(r)       container_of((r), struct max3420_req, usb_req)
 188#define to_max3420_ep(e)        container_of((e), struct max3420_ep, ep_usb)
 189#define to_udc(g)               container_of((g), struct max3420_udc, gadget)
 190
 191#define DRIVER_DESC     "MAX3420 USB Device-Mode Driver"
 192static const char driver_name[] = "max3420-udc";
 193
 194/* Control endpoint configuration.*/
 195static const struct usb_endpoint_descriptor ep0_desc = {
 196        .bEndpointAddress       = USB_DIR_OUT,
 197        .bmAttributes           = USB_ENDPOINT_XFER_CONTROL,
 198        .wMaxPacketSize         = cpu_to_le16(MAX3420_EP_MAX_PACKET),
 199};
 200
 201static void spi_ack_ctrl(struct max3420_udc *udc)
 202{
 203        struct spi_device *spi = udc->spi;
 204        struct spi_transfer transfer;
 205        struct spi_message msg;
 206        u8 txdata[1];
 207
 208        memset(&transfer, 0, sizeof(transfer));
 209
 210        spi_message_init(&msg);
 211
 212        txdata[0] = MAX3420_ACKSTAT;
 213        transfer.tx_buf = txdata;
 214        transfer.len = 1;
 215
 216        spi_message_add_tail(&transfer, &msg);
 217        spi_sync(spi, &msg);
 218}
 219
 220static u8 spi_rd8_ack(struct max3420_udc *udc, u8 reg, int actstat)
 221{
 222        struct spi_device *spi = udc->spi;
 223        struct spi_transfer transfer;
 224        struct spi_message msg;
 225        u8 txdata[2], rxdata[2];
 226
 227        memset(&transfer, 0, sizeof(transfer));
 228
 229        spi_message_init(&msg);
 230
 231        txdata[0] = MAX3420_SPI_CMD_RD(reg) | (actstat ? MAX3420_ACKSTAT : 0);
 232        transfer.tx_buf = txdata;
 233        transfer.rx_buf = rxdata;
 234        transfer.len = 2;
 235
 236        spi_message_add_tail(&transfer, &msg);
 237        spi_sync(spi, &msg);
 238
 239        return rxdata[1];
 240}
 241
 242static u8 spi_rd8(struct max3420_udc *udc, u8 reg)
 243{
 244        return spi_rd8_ack(udc, reg, 0);
 245}
 246
 247static void spi_wr8_ack(struct max3420_udc *udc, u8 reg, u8 val, int actstat)
 248{
 249        struct spi_device *spi = udc->spi;
 250        struct spi_transfer transfer;
 251        struct spi_message msg;
 252        u8 txdata[2];
 253
 254        memset(&transfer, 0, sizeof(transfer));
 255
 256        spi_message_init(&msg);
 257
 258        txdata[0] = MAX3420_SPI_CMD_WR(reg) | (actstat ? MAX3420_ACKSTAT : 0);
 259        txdata[1] = val;
 260
 261        transfer.tx_buf = txdata;
 262        transfer.len = 2;
 263
 264        spi_message_add_tail(&transfer, &msg);
 265        spi_sync(spi, &msg);
 266}
 267
 268static void spi_wr8(struct max3420_udc *udc, u8 reg, u8 val)
 269{
 270        spi_wr8_ack(udc, reg, val, 0);
 271}
 272
 273static void spi_rd_buf(struct max3420_udc *udc, u8 reg, void *buf, u8 len)
 274{
 275        struct spi_device *spi = udc->spi;
 276        struct spi_transfer transfer;
 277        struct spi_message msg;
 278        u8 local_buf[MAX3420_EP_MAX_PACKET + 1] = {};
 279
 280        memset(&transfer, 0, sizeof(transfer));
 281
 282        spi_message_init(&msg);
 283
 284        local_buf[0] = MAX3420_SPI_CMD_RD(reg);
 285        transfer.tx_buf = &local_buf[0];
 286        transfer.rx_buf = &local_buf[0];
 287        transfer.len = len + 1;
 288
 289        spi_message_add_tail(&transfer, &msg);
 290        spi_sync(spi, &msg);
 291
 292        memcpy(buf, &local_buf[1], len);
 293}
 294
 295static void spi_wr_buf(struct max3420_udc *udc, u8 reg, void *buf, u8 len)
 296{
 297        struct spi_device *spi = udc->spi;
 298        struct spi_transfer transfer;
 299        struct spi_message msg;
 300        u8 local_buf[MAX3420_EP_MAX_PACKET + 1] = {};
 301
 302        memset(&transfer, 0, sizeof(transfer));
 303
 304        spi_message_init(&msg);
 305
 306        local_buf[0] = MAX3420_SPI_CMD_WR(reg);
 307        memcpy(&local_buf[1], buf, len);
 308
 309        transfer.tx_buf = local_buf;
 310        transfer.len = len + 1;
 311
 312        spi_message_add_tail(&transfer, &msg);
 313        spi_sync(spi, &msg);
 314}
 315
 316static int spi_max3420_enable(struct max3420_ep *ep)
 317{
 318        struct max3420_udc *udc = ep->udc;
 319        unsigned long flags;
 320        u8 epdis, epien;
 321        int todo;
 322
 323        spin_lock_irqsave(&ep->lock, flags);
 324        todo = ep->todo & ENABLE_EP;
 325        ep->todo &= ~ENABLE_EP;
 326        spin_unlock_irqrestore(&ep->lock, flags);
 327
 328        if (!todo || ep->id == 0)
 329                return false;
 330
 331        epien = spi_rd8(udc, MAX3420_REG_EPIEN);
 332        epdis = spi_rd8(udc, MAX3420_REG_CLRTOGS);
 333
 334        if (todo == ENABLE) {
 335                epdis &= ~BIT(ep->id + 4);
 336                epien |= BIT(ep->id + 1);
 337        } else {
 338                epdis |= BIT(ep->id + 4);
 339                epien &= ~BIT(ep->id + 1);
 340        }
 341
 342        spi_wr8(udc, MAX3420_REG_CLRTOGS, epdis);
 343        spi_wr8(udc, MAX3420_REG_EPIEN, epien);
 344
 345        return true;
 346}
 347
 348static int spi_max3420_stall(struct max3420_ep *ep)
 349{
 350        struct max3420_udc *udc = ep->udc;
 351        unsigned long flags;
 352        u8 epstalls;
 353        int todo;
 354
 355        spin_lock_irqsave(&ep->lock, flags);
 356        todo = ep->todo & STALL_EP;
 357        ep->todo &= ~STALL_EP;
 358        spin_unlock_irqrestore(&ep->lock, flags);
 359
 360        if (!todo || ep->id == 0)
 361                return false;
 362
 363        epstalls = spi_rd8(udc, MAX3420_REG_EPSTALLS);
 364        if (todo == STALL) {
 365                ep->halted = 1;
 366                epstalls |= BIT(ep->id + 1);
 367        } else {
 368                u8 clrtogs;
 369
 370                ep->halted = 0;
 371                epstalls &= ~BIT(ep->id + 1);
 372                clrtogs = spi_rd8(udc, MAX3420_REG_CLRTOGS);
 373                clrtogs |= BIT(ep->id + 1);
 374                spi_wr8(udc, MAX3420_REG_CLRTOGS, clrtogs);
 375        }
 376        spi_wr8(udc, MAX3420_REG_EPSTALLS, epstalls | ACKSTAT);
 377
 378        return true;
 379}
 380
 381static int spi_max3420_rwkup(struct max3420_udc *udc)
 382{
 383        unsigned long flags;
 384        int wake_remote;
 385        u8 usbctl;
 386
 387        spin_lock_irqsave(&udc->lock, flags);
 388        wake_remote = udc->todo & REMOTE_WAKEUP;
 389        udc->todo &= ~REMOTE_WAKEUP;
 390        spin_unlock_irqrestore(&udc->lock, flags);
 391
 392        if (!wake_remote || !udc->suspended)
 393                return false;
 394
 395        /* Set Remote-WkUp Signal*/
 396        usbctl = spi_rd8(udc, MAX3420_REG_USBCTL);
 397        usbctl |= SIGRWU;
 398        spi_wr8(udc, MAX3420_REG_USBCTL, usbctl);
 399
 400        msleep_interruptible(5);
 401
 402        /* Clear Remote-WkUp Signal*/
 403        usbctl = spi_rd8(udc, MAX3420_REG_USBCTL);
 404        usbctl &= ~SIGRWU;
 405        spi_wr8(udc, MAX3420_REG_USBCTL, usbctl);
 406
 407        udc->suspended = false;
 408
 409        return true;
 410}
 411
 412static void max3420_nuke(struct max3420_ep *ep, int status);
 413static void __max3420_stop(struct max3420_udc *udc)
 414{
 415        u8 val;
 416        int i;
 417
 418        /* clear all pending requests */
 419        for (i = 1; i < MAX3420_MAX_EPS; i++)
 420                max3420_nuke(&udc->ep[i], -ECONNRESET);
 421
 422        /* Disable IRQ to CPU */
 423        spi_wr8(udc, MAX3420_REG_CPUCTL, 0);
 424
 425        val = spi_rd8(udc, MAX3420_REG_USBCTL);
 426        val |= PWRDOWN;
 427        if (udc->is_selfpowered)
 428                val &= ~HOSCSTEN;
 429        else
 430                val |= HOSCSTEN;
 431        spi_wr8(udc, MAX3420_REG_USBCTL, val);
 432}
 433
 434static void __max3420_start(struct max3420_udc *udc)
 435{
 436        u8 val;
 437
 438        /* Need this delay if bus-powered,
 439         * but even for self-powered it helps stability
 440         */
 441        msleep_interruptible(250);
 442
 443        /* configure SPI */
 444        spi_wr8(udc, MAX3420_REG_PINCTL, FDUPSPI);
 445
 446        /* Chip Reset */
 447        spi_wr8(udc, MAX3420_REG_USBCTL, CHIPRES);
 448        msleep_interruptible(5);
 449        spi_wr8(udc, MAX3420_REG_USBCTL, 0);
 450
 451        /* Poll for OSC to stabilize */
 452        while (1) {
 453                val = spi_rd8(udc, MAX3420_REG_USBIRQ);
 454                if (val & OSCOKIRQ)
 455                        break;
 456                cond_resched();
 457        }
 458
 459        /* Enable PULL-UP only when Vbus detected */
 460        val = spi_rd8(udc, MAX3420_REG_USBCTL);
 461        val |= VBGATE | CONNECT;
 462        spi_wr8(udc, MAX3420_REG_USBCTL, val);
 463
 464        val = URESDNIRQ | URESIRQ;
 465        if (udc->is_selfpowered)
 466                val |= NOVBUSIRQ;
 467        spi_wr8(udc, MAX3420_REG_USBIEN, val);
 468
 469        /* Enable only EP0 interrupts */
 470        val = IN0BAVIRQ | OUT0DAVIRQ | SUDAVIRQ;
 471        spi_wr8(udc, MAX3420_REG_EPIEN, val);
 472
 473        /* Enable IRQ to CPU */
 474        spi_wr8(udc, MAX3420_REG_CPUCTL, IE);
 475}
 476
 477static int max3420_start(struct max3420_udc *udc)
 478{
 479        unsigned long flags;
 480        int todo;
 481
 482        spin_lock_irqsave(&udc->lock, flags);
 483        todo = udc->todo & UDC_START;
 484        udc->todo &= ~UDC_START;
 485        spin_unlock_irqrestore(&udc->lock, flags);
 486
 487        if (!todo)
 488                return false;
 489
 490        if (udc->vbus_active && udc->softconnect)
 491                __max3420_start(udc);
 492        else
 493                __max3420_stop(udc);
 494
 495        return true;
 496}
 497
 498static irqreturn_t max3420_vbus_handler(int irq, void *dev_id)
 499{
 500        struct max3420_udc *udc = dev_id;
 501        unsigned long flags;
 502
 503        spin_lock_irqsave(&udc->lock, flags);
 504        /* its a vbus change interrupt */
 505        udc->vbus_active = !udc->vbus_active;
 506        udc->todo |= UDC_START;
 507        usb_udc_vbus_handler(&udc->gadget, udc->vbus_active);
 508        usb_gadget_set_state(&udc->gadget, udc->vbus_active
 509                             ? USB_STATE_POWERED : USB_STATE_NOTATTACHED);
 510        spin_unlock_irqrestore(&udc->lock, flags);
 511
 512        if (udc->thread_task)
 513                wake_up_process(udc->thread_task);
 514
 515        return IRQ_HANDLED;
 516}
 517
 518static irqreturn_t max3420_irq_handler(int irq, void *dev_id)
 519{
 520        struct max3420_udc *udc = dev_id;
 521        struct spi_device *spi = udc->spi;
 522        unsigned long flags;
 523
 524        spin_lock_irqsave(&udc->lock, flags);
 525        if ((udc->todo & ENABLE_IRQ) == 0) {
 526                disable_irq_nosync(spi->irq);
 527                udc->todo |= ENABLE_IRQ;
 528        }
 529        spin_unlock_irqrestore(&udc->lock, flags);
 530
 531        if (udc->thread_task)
 532                wake_up_process(udc->thread_task);
 533
 534        return IRQ_HANDLED;
 535}
 536
 537static void max3420_getstatus(struct max3420_udc *udc)
 538{
 539        struct max3420_ep *ep;
 540        u16 status = 0;
 541
 542        switch (udc->setup.bRequestType & USB_RECIP_MASK) {
 543        case USB_RECIP_DEVICE:
 544                /* Get device status */
 545                status = udc->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED;
 546                status |= (udc->remote_wkp << USB_DEVICE_REMOTE_WAKEUP);
 547                break;
 548        case USB_RECIP_INTERFACE:
 549                if (udc->driver->setup(&udc->gadget, &udc->setup) < 0)
 550                        goto stall;
 551                break;
 552        case USB_RECIP_ENDPOINT:
 553                ep = &udc->ep[udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK];
 554                if (udc->setup.wIndex & USB_DIR_IN) {
 555                        if (!ep->ep_usb.caps.dir_in)
 556                                goto stall;
 557                } else {
 558                        if (!ep->ep_usb.caps.dir_out)
 559                                goto stall;
 560                }
 561                if (ep->halted)
 562                        status = 1 << USB_ENDPOINT_HALT;
 563                break;
 564        default:
 565                goto stall;
 566        }
 567
 568        status = cpu_to_le16(status);
 569        spi_wr_buf(udc, MAX3420_REG_EP0FIFO, &status, 2);
 570        spi_wr8_ack(udc, MAX3420_REG_EP0BC, 2, 1);
 571        return;
 572stall:
 573        dev_err(udc->dev, "Can't respond to getstatus request\n");
 574        spi_wr8(udc, MAX3420_REG_EPSTALLS, STLEP0IN | STLEP0OUT | STLSTAT);
 575}
 576
 577static void max3420_set_clear_feature(struct max3420_udc *udc)
 578{
 579        struct max3420_ep *ep;
 580        int set = udc->setup.bRequest == USB_REQ_SET_FEATURE;
 581        unsigned long flags;
 582        int id;
 583
 584        switch (udc->setup.bRequestType) {
 585        case USB_RECIP_DEVICE:
 586                if (udc->setup.wValue != USB_DEVICE_REMOTE_WAKEUP)
 587                        break;
 588
 589                if (udc->setup.bRequest == USB_REQ_SET_FEATURE)
 590                        udc->remote_wkp = 1;
 591                else
 592                        udc->remote_wkp = 0;
 593
 594                return spi_ack_ctrl(udc);
 595
 596        case USB_RECIP_ENDPOINT:
 597                if (udc->setup.wValue != USB_ENDPOINT_HALT)
 598                        break;
 599
 600                id = udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK;
 601                ep = &udc->ep[id];
 602
 603                spin_lock_irqsave(&ep->lock, flags);
 604                ep->todo &= ~STALL_EP;
 605                if (set)
 606                        ep->todo |= STALL;
 607                else
 608                        ep->todo |= UNSTALL;
 609                spin_unlock_irqrestore(&ep->lock, flags);
 610
 611                spi_max3420_stall(ep);
 612                return;
 613        default:
 614                break;
 615        }
 616
 617        dev_err(udc->dev, "Can't respond to SET/CLEAR FEATURE\n");
 618        spi_wr8(udc, MAX3420_REG_EPSTALLS, STLEP0IN | STLEP0OUT | STLSTAT);
 619}
 620
 621static void max3420_handle_setup(struct max3420_udc *udc)
 622{
 623        struct usb_ctrlrequest setup;
 624
 625        spi_rd_buf(udc, MAX3420_REG_SUDFIFO, (void *)&setup, 8);
 626
 627        udc->setup = setup;
 628        udc->setup.wValue = cpu_to_le16(setup.wValue);
 629        udc->setup.wIndex = cpu_to_le16(setup.wIndex);
 630        udc->setup.wLength = cpu_to_le16(setup.wLength);
 631
 632        switch (udc->setup.bRequest) {
 633        case USB_REQ_GET_STATUS:
 634                /* Data+Status phase form udc */
 635                if ((udc->setup.bRequestType &
 636                                (USB_DIR_IN | USB_TYPE_MASK)) !=
 637                                (USB_DIR_IN | USB_TYPE_STANDARD)) {
 638                        break;
 639                }
 640                return max3420_getstatus(udc);
 641        case USB_REQ_SET_ADDRESS:
 642                /* Status phase from udc */
 643                if (udc->setup.bRequestType != (USB_DIR_OUT |
 644                                USB_TYPE_STANDARD | USB_RECIP_DEVICE)) {
 645                        break;
 646                }
 647                spi_rd8_ack(udc, MAX3420_REG_FNADDR, 1);
 648                dev_dbg(udc->dev, "Assigned Address=%d\n", udc->setup.wValue);
 649                return;
 650        case USB_REQ_CLEAR_FEATURE:
 651        case USB_REQ_SET_FEATURE:
 652                /* Requests with no data phase, status phase from udc */
 653                if ((udc->setup.bRequestType & USB_TYPE_MASK)
 654                                != USB_TYPE_STANDARD)
 655                        break;
 656                return max3420_set_clear_feature(udc);
 657        default:
 658                break;
 659        }
 660
 661        if (udc->driver->setup(&udc->gadget, &setup) < 0) {
 662                /* Stall EP0 */
 663                spi_wr8(udc, MAX3420_REG_EPSTALLS,
 664                        STLEP0IN | STLEP0OUT | STLSTAT);
 665        }
 666}
 667
 668static void max3420_req_done(struct max3420_req *req, int status)
 669{
 670        struct max3420_ep *ep = req->ep;
 671        struct max3420_udc *udc = ep->udc;
 672
 673        if (req->usb_req.status == -EINPROGRESS)
 674                req->usb_req.status = status;
 675        else
 676                status = req->usb_req.status;
 677
 678        if (status && status != -ESHUTDOWN)
 679                dev_err(udc->dev, "%s done %p, status %d\n",
 680                        ep->ep_usb.name, req, status);
 681
 682        if (req->usb_req.complete)
 683                req->usb_req.complete(&ep->ep_usb, &req->usb_req);
 684}
 685
 686static int max3420_do_data(struct max3420_udc *udc, int ep_id, int in)
 687{
 688        struct max3420_ep *ep = &udc->ep[ep_id];
 689        struct max3420_req *req;
 690        int done, length, psz;
 691        void *buf;
 692
 693        if (list_empty(&ep->queue))
 694                return false;
 695
 696        req = list_first_entry(&ep->queue, struct max3420_req, queue);
 697        buf = req->usb_req.buf + req->usb_req.actual;
 698
 699        psz = ep->ep_usb.maxpacket;
 700        length = req->usb_req.length - req->usb_req.actual;
 701        length = min(length, psz);
 702
 703        if (length == 0) {
 704                done = 1;
 705                goto xfer_done;
 706        }
 707
 708        done = 0;
 709        if (in) {
 710                prefetch(buf);
 711                spi_wr_buf(udc, MAX3420_REG_EP0FIFO + ep_id, buf, length);
 712                spi_wr8(udc, MAX3420_REG_EP0BC + ep_id, length);
 713                if (length < psz)
 714                        done = 1;
 715        } else {
 716                psz = spi_rd8(udc, MAX3420_REG_EP0BC + ep_id);
 717                length = min(length, psz);
 718                prefetchw(buf);
 719                spi_rd_buf(udc, MAX3420_REG_EP0FIFO + ep_id, buf, length);
 720                if (length < ep->ep_usb.maxpacket)
 721                        done = 1;
 722        }
 723
 724        req->usb_req.actual += length;
 725
 726        if (req->usb_req.actual == req->usb_req.length)
 727                done = 1;
 728
 729xfer_done:
 730        if (done) {
 731                unsigned long flags;
 732
 733                spin_lock_irqsave(&ep->lock, flags);
 734                list_del_init(&req->queue);
 735                spin_unlock_irqrestore(&ep->lock, flags);
 736
 737                if (ep_id == 0)
 738                        spi_ack_ctrl(udc);
 739
 740                max3420_req_done(req, 0);
 741        }
 742
 743        return true;
 744}
 745
 746static int max3420_handle_irqs(struct max3420_udc *udc)
 747{
 748        u8 epien, epirq, usbirq, usbien, reg[4];
 749        bool ret = false;
 750
 751        spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 4);
 752        epirq = reg[0];
 753        epien = reg[1];
 754        usbirq = reg[2];
 755        usbien = reg[3];
 756
 757        usbirq &= usbien;
 758        epirq &= epien;
 759
 760        if (epirq & SUDAVIRQ) {
 761                spi_wr8(udc, MAX3420_REG_EPIRQ, SUDAVIRQ);
 762                max3420_handle_setup(udc);
 763                return true;
 764        }
 765
 766        if (usbirq & VBUSIRQ) {
 767                spi_wr8(udc, MAX3420_REG_USBIRQ, VBUSIRQ);
 768                dev_dbg(udc->dev, "Cable plugged in\n");
 769                return true;
 770        }
 771
 772        if (usbirq & NOVBUSIRQ) {
 773                spi_wr8(udc, MAX3420_REG_USBIRQ, NOVBUSIRQ);
 774                dev_dbg(udc->dev, "Cable pulled out\n");
 775                return true;
 776        }
 777
 778        if (usbirq & URESIRQ) {
 779                spi_wr8(udc, MAX3420_REG_USBIRQ, URESIRQ);
 780                dev_dbg(udc->dev, "USB Reset - Start\n");
 781                return true;
 782        }
 783
 784        if (usbirq & URESDNIRQ) {
 785                spi_wr8(udc, MAX3420_REG_USBIRQ, URESDNIRQ);
 786                dev_dbg(udc->dev, "USB Reset - END\n");
 787                spi_wr8(udc, MAX3420_REG_USBIEN, URESDNIRQ | URESIRQ);
 788                spi_wr8(udc, MAX3420_REG_EPIEN, SUDAVIRQ | IN0BAVIRQ
 789                        | OUT0DAVIRQ);
 790                return true;
 791        }
 792
 793        if (usbirq & SUSPIRQ) {
 794                spi_wr8(udc, MAX3420_REG_USBIRQ, SUSPIRQ);
 795                dev_dbg(udc->dev, "USB Suspend - Enter\n");
 796                udc->suspended = true;
 797                return true;
 798        }
 799
 800        if (usbirq & BUSACTIRQ) {
 801                spi_wr8(udc, MAX3420_REG_USBIRQ, BUSACTIRQ);
 802                dev_dbg(udc->dev, "USB Suspend - Exit\n");
 803                udc->suspended = false;
 804                return true;
 805        }
 806
 807        if (usbirq & RWUDNIRQ) {
 808                spi_wr8(udc, MAX3420_REG_USBIRQ, RWUDNIRQ);
 809                dev_dbg(udc->dev, "Asked Host to wakeup\n");
 810                return true;
 811        }
 812
 813        if (usbirq & OSCOKIRQ) {
 814                spi_wr8(udc, MAX3420_REG_USBIRQ, OSCOKIRQ);
 815                dev_dbg(udc->dev, "Osc stabilized, start work\n");
 816                return true;
 817        }
 818
 819        if (epirq & OUT0DAVIRQ && max3420_do_data(udc, 0, 0)) {
 820                spi_wr8_ack(udc, MAX3420_REG_EPIRQ, OUT0DAVIRQ, 1);
 821                ret = true;
 822        }
 823
 824        if (epirq & IN0BAVIRQ && max3420_do_data(udc, 0, 1))
 825                ret = true;
 826
 827        if (epirq & OUT1DAVIRQ && max3420_do_data(udc, 1, 0)) {
 828                spi_wr8_ack(udc, MAX3420_REG_EPIRQ, OUT1DAVIRQ, 1);
 829                ret = true;
 830        }
 831
 832        if (epirq & IN2BAVIRQ && max3420_do_data(udc, 2, 1))
 833                ret = true;
 834
 835        if (epirq & IN3BAVIRQ && max3420_do_data(udc, 3, 1))
 836                ret = true;
 837
 838        return ret;
 839}
 840
 841static int max3420_thread(void *dev_id)
 842{
 843        struct max3420_udc *udc = dev_id;
 844        struct spi_device *spi = udc->spi;
 845        int i, loop_again = 1;
 846        unsigned long flags;
 847
 848        while (!kthread_should_stop()) {
 849                if (!loop_again) {
 850                        ktime_t kt = ns_to_ktime(1000 * 1000 * 250); /* 250ms */
 851
 852                        set_current_state(TASK_INTERRUPTIBLE);
 853
 854                        spin_lock_irqsave(&udc->lock, flags);
 855                        if (udc->todo & ENABLE_IRQ) {
 856                                enable_irq(spi->irq);
 857                                udc->todo &= ~ENABLE_IRQ;
 858                        }
 859                        spin_unlock_irqrestore(&udc->lock, flags);
 860
 861                        schedule_hrtimeout(&kt, HRTIMER_MODE_REL);
 862                }
 863                loop_again = 0;
 864
 865                mutex_lock(&udc->spi_bus_mutex);
 866
 867                /* If bus-vbus_active and disconnected */
 868                if (!udc->vbus_active || !udc->softconnect)
 869                        goto loop;
 870
 871                if (max3420_start(udc)) {
 872                        loop_again = 1;
 873                        goto loop;
 874                }
 875
 876                if (max3420_handle_irqs(udc)) {
 877                        loop_again = 1;
 878                        goto loop;
 879                }
 880
 881                if (spi_max3420_rwkup(udc)) {
 882                        loop_again = 1;
 883                        goto loop;
 884                }
 885
 886                max3420_do_data(udc, 0, 1); /* get done with the EP0 ZLP */
 887
 888                for (i = 1; i < MAX3420_MAX_EPS; i++) {
 889                        struct max3420_ep *ep = &udc->ep[i];
 890
 891                        if (spi_max3420_enable(ep))
 892                                loop_again = 1;
 893                        if (spi_max3420_stall(ep))
 894                                loop_again = 1;
 895                }
 896loop:
 897                mutex_unlock(&udc->spi_bus_mutex);
 898        }
 899
 900        set_current_state(TASK_RUNNING);
 901        dev_info(udc->dev, "SPI thread exiting\n");
 902        return 0;
 903}
 904
 905static int max3420_ep_set_halt(struct usb_ep *_ep, int stall)
 906{
 907        struct max3420_ep *ep = to_max3420_ep(_ep);
 908        struct max3420_udc *udc = ep->udc;
 909        unsigned long flags;
 910
 911        spin_lock_irqsave(&ep->lock, flags);
 912
 913        ep->todo &= ~STALL_EP;
 914        if (stall)
 915                ep->todo |= STALL;
 916        else
 917                ep->todo |= UNSTALL;
 918
 919        spin_unlock_irqrestore(&ep->lock, flags);
 920
 921        wake_up_process(udc->thread_task);
 922
 923        dev_dbg(udc->dev, "%sStall %s\n", stall ? "" : "Un", ep->name);
 924        return 0;
 925}
 926
 927static int __max3420_ep_enable(struct max3420_ep *ep,
 928                               const struct usb_endpoint_descriptor *desc)
 929{
 930        unsigned int maxp = usb_endpoint_maxp(desc);
 931        unsigned long flags;
 932
 933        spin_lock_irqsave(&ep->lock, flags);
 934        ep->ep_usb.desc = desc;
 935        ep->ep_usb.maxpacket = maxp;
 936
 937        ep->todo &= ~ENABLE_EP;
 938        ep->todo |= ENABLE;
 939        spin_unlock_irqrestore(&ep->lock, flags);
 940
 941        return 0;
 942}
 943
 944static int max3420_ep_enable(struct usb_ep *_ep,
 945                             const struct usb_endpoint_descriptor *desc)
 946{
 947        struct max3420_ep *ep = to_max3420_ep(_ep);
 948        struct max3420_udc *udc = ep->udc;
 949
 950        __max3420_ep_enable(ep, desc);
 951
 952        wake_up_process(udc->thread_task);
 953
 954        return 0;
 955}
 956
 957static void max3420_nuke(struct max3420_ep *ep, int status)
 958{
 959        struct max3420_req *req, *r;
 960        unsigned long flags;
 961
 962        spin_lock_irqsave(&ep->lock, flags);
 963
 964        list_for_each_entry_safe(req, r, &ep->queue, queue) {
 965                list_del_init(&req->queue);
 966
 967                spin_unlock_irqrestore(&ep->lock, flags);
 968                max3420_req_done(req, status);
 969                spin_lock_irqsave(&ep->lock, flags);
 970        }
 971
 972        spin_unlock_irqrestore(&ep->lock, flags);
 973}
 974
 975static void __max3420_ep_disable(struct max3420_ep *ep)
 976{
 977        struct max3420_udc *udc = ep->udc;
 978        unsigned long flags;
 979
 980        spin_lock_irqsave(&ep->lock, flags);
 981
 982        ep->ep_usb.desc = NULL;
 983
 984        ep->todo &= ~ENABLE_EP;
 985        ep->todo |= DISABLE;
 986
 987        spin_unlock_irqrestore(&ep->lock, flags);
 988
 989        dev_dbg(udc->dev, "Disabled %s\n", ep->name);
 990}
 991
 992static int max3420_ep_disable(struct usb_ep *_ep)
 993{
 994        struct max3420_ep *ep = to_max3420_ep(_ep);
 995        struct max3420_udc *udc = ep->udc;
 996
 997        max3420_nuke(ep, -ESHUTDOWN);
 998
 999        __max3420_ep_disable(ep);
1000
1001        wake_up_process(udc->thread_task);
1002
1003        return 0;
1004}
1005
1006static struct usb_request *max3420_alloc_request(struct usb_ep *_ep,
1007                                                 gfp_t gfp_flags)
1008{
1009        struct max3420_ep *ep = to_max3420_ep(_ep);
1010        struct max3420_req *req;
1011
1012        req = kzalloc(sizeof(*req), gfp_flags);
1013        if (!req)
1014                return NULL;
1015
1016        req->ep = ep;
1017
1018        return &req->usb_req;
1019}
1020
1021static void max3420_free_request(struct usb_ep *_ep, struct usb_request *_req)
1022{
1023        kfree(to_max3420_req(_req));
1024}
1025
1026static int max3420_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
1027                            gfp_t ignored)
1028{
1029        struct max3420_req *req = to_max3420_req(_req);
1030        struct max3420_ep *ep  = to_max3420_ep(_ep);
1031        struct max3420_udc *udc = ep->udc;
1032        unsigned long flags;
1033
1034        _req->status = -EINPROGRESS;
1035        _req->actual = 0;
1036
1037        spin_lock_irqsave(&ep->lock, flags);
1038        list_add_tail(&req->queue, &ep->queue);
1039        spin_unlock_irqrestore(&ep->lock, flags);
1040
1041        wake_up_process(udc->thread_task);
1042        return 0;
1043}
1044
1045static int max3420_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
1046{
1047        struct max3420_req *t, *req = to_max3420_req(_req);
1048        struct max3420_ep *ep = to_max3420_ep(_ep);
1049        unsigned long flags;
1050
1051        spin_lock_irqsave(&ep->lock, flags);
1052
1053        /* Pluck the descriptor from queue */
1054        list_for_each_entry(t, &ep->queue, queue)
1055                if (t == req) {
1056                        list_del_init(&req->queue);
1057                        break;
1058                }
1059
1060        spin_unlock_irqrestore(&ep->lock, flags);
1061
1062        if (t == req)
1063                max3420_req_done(req, -ECONNRESET);
1064
1065        return 0;
1066}
1067
1068static const struct usb_ep_ops max3420_ep_ops = {
1069        .enable         = max3420_ep_enable,
1070        .disable        = max3420_ep_disable,
1071        .alloc_request  = max3420_alloc_request,
1072        .free_request   = max3420_free_request,
1073        .queue          = max3420_ep_queue,
1074        .dequeue        = max3420_ep_dequeue,
1075        .set_halt       = max3420_ep_set_halt,
1076};
1077
1078static int max3420_wakeup(struct usb_gadget *gadget)
1079{
1080        struct max3420_udc *udc = to_udc(gadget);
1081        unsigned long flags;
1082        int ret = -EINVAL;
1083
1084        spin_lock_irqsave(&udc->lock, flags);
1085
1086        /* Only if wakeup allowed by host */
1087        if (udc->remote_wkp) {
1088                udc->todo |= REMOTE_WAKEUP;
1089                ret = 0;
1090        }
1091
1092        spin_unlock_irqrestore(&udc->lock, flags);
1093
1094        if (udc->thread_task)
1095                wake_up_process(udc->thread_task);
1096        return ret;
1097}
1098
1099static int max3420_udc_start(struct usb_gadget *gadget,
1100                             struct usb_gadget_driver *driver)
1101{
1102        struct max3420_udc *udc = to_udc(gadget);
1103        unsigned long flags;
1104
1105        spin_lock_irqsave(&udc->lock, flags);
1106        /* hook up the driver */
1107        driver->driver.bus = NULL;
1108        udc->driver = driver;
1109        udc->gadget.speed = USB_SPEED_FULL;
1110
1111        udc->gadget.is_selfpowered = udc->is_selfpowered;
1112        udc->remote_wkp = 0;
1113        udc->softconnect = true;
1114        udc->todo |= UDC_START;
1115        spin_unlock_irqrestore(&udc->lock, flags);
1116
1117        if (udc->thread_task)
1118                wake_up_process(udc->thread_task);
1119
1120        return 0;
1121}
1122
1123static int max3420_udc_stop(struct usb_gadget *gadget)
1124{
1125        struct max3420_udc *udc = to_udc(gadget);
1126        unsigned long flags;
1127
1128        spin_lock_irqsave(&udc->lock, flags);
1129        udc->is_selfpowered = udc->gadget.is_selfpowered;
1130        udc->gadget.speed = USB_SPEED_UNKNOWN;
1131        udc->driver = NULL;
1132        udc->softconnect = false;
1133        udc->todo |= UDC_START;
1134        spin_unlock_irqrestore(&udc->lock, flags);
1135
1136        if (udc->thread_task)
1137                wake_up_process(udc->thread_task);
1138
1139        return 0;
1140}
1141
1142static const struct usb_gadget_ops max3420_udc_ops = {
1143        .udc_start      = max3420_udc_start,
1144        .udc_stop       = max3420_udc_stop,
1145        .wakeup         = max3420_wakeup,
1146};
1147
1148static void max3420_eps_init(struct max3420_udc *udc)
1149{
1150        int idx;
1151
1152        INIT_LIST_HEAD(&udc->gadget.ep_list);
1153
1154        for (idx = 0; idx < MAX3420_MAX_EPS; idx++) {
1155                struct max3420_ep *ep = &udc->ep[idx];
1156
1157                spin_lock_init(&ep->lock);
1158                INIT_LIST_HEAD(&ep->queue);
1159
1160                ep->udc = udc;
1161                ep->id = idx;
1162                ep->halted = 0;
1163                ep->maxpacket = 0;
1164                ep->ep_usb.name = ep->name;
1165                ep->ep_usb.ops = &max3420_ep_ops;
1166                usb_ep_set_maxpacket_limit(&ep->ep_usb, MAX3420_EP_MAX_PACKET);
1167
1168                if (idx == 0) { /* For EP0 */
1169                        ep->ep_usb.desc = &ep0_desc;
1170                        ep->ep_usb.maxpacket = usb_endpoint_maxp(&ep0_desc);
1171                        ep->ep_usb.caps.type_control = true;
1172                        ep->ep_usb.caps.dir_in = true;
1173                        ep->ep_usb.caps.dir_out = true;
1174                        snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep0");
1175                        continue;
1176                }
1177
1178                if (idx == 1) { /* EP1 is OUT */
1179                        ep->ep_usb.caps.dir_in = false;
1180                        ep->ep_usb.caps.dir_out = true;
1181                        snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep1-bulk-out");
1182                } else { /* EP2 & EP3 are IN */
1183                        ep->ep_usb.caps.dir_in = true;
1184                        ep->ep_usb.caps.dir_out = false;
1185                        snprintf(ep->name, MAX3420_EPNAME_SIZE,
1186                                 "ep%d-bulk-in", idx);
1187                }
1188                ep->ep_usb.caps.type_iso = false;
1189                ep->ep_usb.caps.type_int = false;
1190                ep->ep_usb.caps.type_bulk = true;
1191
1192                list_add_tail(&ep->ep_usb.ep_list,
1193                              &udc->gadget.ep_list);
1194        }
1195}
1196
1197static int max3420_probe(struct spi_device *spi)
1198{
1199        struct max3420_udc *udc;
1200        int err, irq;
1201        u8 reg[8];
1202
1203        if (spi->master->flags & SPI_MASTER_HALF_DUPLEX) {
1204                dev_err(&spi->dev, "UDC needs full duplex to work\n");
1205                return -EINVAL;
1206        }
1207
1208        spi->mode = SPI_MODE_3;
1209        spi->bits_per_word = 8;
1210
1211        err = spi_setup(spi);
1212        if (err) {
1213                dev_err(&spi->dev, "Unable to setup SPI bus\n");
1214                return -EFAULT;
1215        }
1216
1217        udc = devm_kzalloc(&spi->dev, sizeof(*udc), GFP_KERNEL);
1218        if (!udc)
1219                return -ENOMEM;
1220
1221        udc->spi = spi;
1222
1223        udc->remote_wkp = 0;
1224
1225        /* Setup gadget structure */
1226        udc->gadget.ops = &max3420_udc_ops;
1227        udc->gadget.max_speed = USB_SPEED_FULL;
1228        udc->gadget.speed = USB_SPEED_UNKNOWN;
1229        udc->gadget.ep0 = &udc->ep[0].ep_usb;
1230        udc->gadget.name = driver_name;
1231
1232        spin_lock_init(&udc->lock);
1233        mutex_init(&udc->spi_bus_mutex);
1234
1235        udc->ep0req.ep = &udc->ep[0];
1236        udc->ep0req.usb_req.buf = udc->ep0buf;
1237        INIT_LIST_HEAD(&udc->ep0req.queue);
1238
1239        /* setup Endpoints */
1240        max3420_eps_init(udc);
1241
1242        /* configure SPI */
1243        spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8);
1244        spi_wr8(udc, MAX3420_REG_PINCTL, FDUPSPI);
1245
1246        err = usb_add_gadget_udc(&spi->dev, &udc->gadget);
1247        if (err)
1248                return err;
1249
1250        udc->dev = &udc->gadget.dev;
1251
1252        spi_set_drvdata(spi, udc);
1253
1254        irq = of_irq_get_byname(spi->dev.of_node, "udc");
1255        err = devm_request_irq(&spi->dev, irq, max3420_irq_handler, 0,
1256                               "max3420", udc);
1257        if (err < 0)
1258                goto del_gadget;
1259
1260        udc->thread_task = kthread_create(max3420_thread, udc,
1261                                          "max3420-thread");
1262        if (IS_ERR(udc->thread_task)) {
1263                err = PTR_ERR(udc->thread_task);
1264                goto del_gadget;
1265        }
1266
1267        irq = of_irq_get_byname(spi->dev.of_node, "vbus");
1268        if (irq <= 0) { /* no vbus irq implies self-powered design */
1269                udc->is_selfpowered = 1;
1270                udc->vbus_active = true;
1271                udc->todo |= UDC_START;
1272                usb_udc_vbus_handler(&udc->gadget, udc->vbus_active);
1273                usb_gadget_set_state(&udc->gadget, USB_STATE_POWERED);
1274                max3420_start(udc);
1275        } else {
1276                udc->is_selfpowered = 0;
1277                /* Detect current vbus status */
1278                spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8);
1279                if (reg[7] != 0xff)
1280                        udc->vbus_active = true;
1281
1282                err = devm_request_irq(&spi->dev, irq,
1283                                       max3420_vbus_handler, 0, "vbus", udc);
1284                if (err < 0)
1285                        goto del_gadget;
1286        }
1287
1288        return 0;
1289
1290del_gadget:
1291        usb_del_gadget_udc(&udc->gadget);
1292        return err;
1293}
1294
1295static int max3420_remove(struct spi_device *spi)
1296{
1297        struct max3420_udc *udc = spi_get_drvdata(spi);
1298        unsigned long flags;
1299
1300        usb_del_gadget_udc(&udc->gadget);
1301
1302        spin_lock_irqsave(&udc->lock, flags);
1303
1304        kthread_stop(udc->thread_task);
1305
1306        spin_unlock_irqrestore(&udc->lock, flags);
1307
1308        return 0;
1309}
1310
1311static const struct of_device_id max3420_udc_of_match[] = {
1312        { .compatible = "maxim,max3420-udc"},
1313        { .compatible = "maxim,max3421-udc"},
1314        {},
1315};
1316MODULE_DEVICE_TABLE(of, max3420_udc_of_match);
1317
1318static struct spi_driver max3420_driver = {
1319        .driver = {
1320                .name = "max3420-udc",
1321                .of_match_table = of_match_ptr(max3420_udc_of_match),
1322        },
1323        .probe = max3420_probe,
1324        .remove = max3420_remove,
1325};
1326
1327module_spi_driver(max3420_driver);
1328
1329MODULE_DESCRIPTION(DRIVER_DESC);
1330MODULE_AUTHOR("Jassi Brar <jaswinder.singh@linaro.org>");
1331MODULE_LICENSE("GPL");
1332
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.