drivers/usb/gadget/udc/max3420_udc.c

   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
 151 struct max3420_req {
 152         struct usb_request usb_req;
 153         struct list_head queue;
 154         struct max3420_ep *ep;
 155 };
 156
 157 struct 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
 169 struct 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"
 192 static const char driver_name[] = "max3420-udc";
 193
 194 /* Control endpoint configuration.*/
 195 static 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
 201 static 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
 220 static 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
 242 static u8 spi_rd8(struct max3420_udc *udc, u8 reg)
 243 {
 244         return spi_rd8_ack(udc, reg, 0);
 245 }
 246
 247 static 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
 268 static void spi_wr8(struct max3420_udc *udc, u8 reg, u8 val)
 269 {
 270         spi_wr8_ack(udc, reg, val, 0);
 271 }
 272
 273 static 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
 295 static 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
 316 static 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
 348 static 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
 381 static 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
 412 static void max3420_nuke(struct max3420_ep *ep, int status);
 413 static 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
 434 static 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
 477 static 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
 498 static 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
 518 static 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
 537 static 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;
 572 stall:
 573         dev_err(udc->dev, "Can't respond to getstatus request\n");
 574         spi_wr8(udc, MAX3420_REG_EPSTALLS, STLEP0IN | STLEP0OUT | STLSTAT);
 575 }
 576
 577 static 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
 621 static 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
 668 static 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
 686 static 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
 729 xfer_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
 746 static 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
 841 static 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                 }
 896 loop:
 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
 905 static 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
 927 static 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
 944 static 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
 957 static 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
 975 static 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
 992 static 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
1006 static 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
1021 static void max3420_free_request(struct usb_ep *_ep, struct usb_request *_req)
1022 {
1023         kfree(to_max3420_req(_req));
1024 }
1025
1026 static 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
1045 static 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
1068 static 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
1078 static 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
1099 static 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
1123 static 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
1142 static 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
1148 static 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
1197 static 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                 return err;
1259
1260         udc->thread_task = kthread_create(max3420_thread, udc,
1261                                           "max3420-thread");
1262         if (IS_ERR(udc->thread_task))
1263                 return PTR_ERR(udc->thread_task);
1264
1265         irq = of_irq_get_byname(spi->dev.of_node, "vbus");
1266         if (irq <= 0) { /* no vbus irq implies self-powered design */
1267                 udc->is_selfpowered = 1;
1268                 udc->vbus_active = true;
1269                 udc->todo |= UDC_START;
1270                 usb_udc_vbus_handler(&udc->gadget, udc->vbus_active);
1271                 usb_gadget_set_state(&udc->gadget, USB_STATE_POWERED);
1272                 max3420_start(udc);
1273         } else {
1274                 udc->is_selfpowered = 0;
1275                 /* Detect current vbus status */
1276                 spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8);
1277                 if (reg[7] != 0xff)
1278                         udc->vbus_active = true;
1279
1280                 err = devm_request_irq(&spi->dev, irq,
1281                                        max3420_vbus_handler, 0, "vbus", udc);
1282                 if (err < 0)
1283                         return err;
1284         }
1285
1286         return 0;
1287 }
1288
1289 static int max3420_remove(struct spi_device *spi)
1290 {
1291         struct max3420_udc *udc = spi_get_drvdata(spi);
1292         unsigned long flags;
1293
1294         usb_del_gadget_udc(&udc->gadget);
1295
1296         spin_lock_irqsave(&udc->lock, flags);
1297
1298         kthread_stop(udc->thread_task);
1299
1300         spin_unlock_irqrestore(&udc->lock, flags);
1301
1302         return 0;
1303 }
1304
1305 static const struct of_device_id max3420_udc_of_match[] = {
1306         { .compatible = "maxim,max3420-udc"},
1307         { .compatible = "maxim,max3421-udc"},
1308         {},
1309 };
1310 MODULE_DEVICE_TABLE(of, max3420_udc_of_match);
1311
1312 static struct spi_driver max3420_driver = {
1313         .driver = {
1314                 .name = "max3420-udc",
1315                 .of_match_table = of_match_ptr(max3420_udc_of_match),
1316         },
1317         .probe = max3420_probe,
1318         .remove = max3420_remove,
1319 };
1320
1321 module_spi_driver(max3420_driver);
1322
1323 MODULE_DESCRIPTION(DRIVER_DESC);
1324 MODULE_AUTHOR("Jassi Brar <jaswinder.singh@linaro.org>");
1325 MODULE_LICENSE("GPL");