Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * MAX3420 Device Controller driver for USB.
0004  *
0005  * Author: Jaswinder Singh Brar <jaswinder.singh@linaro.org>
0006  * (C) Copyright 2019-2020 Linaro Ltd
0007  *
0008  * Based on:
0009  *  o MAX3420E datasheet
0010  *      https://datasheets.maximintegrated.com/en/ds/MAX3420E.pdf
0011  *  o MAX342{0,1}E Programming Guides
0012  *      https://pdfserv.maximintegrated.com/en/an/AN3598.pdf
0013  *      https://pdfserv.maximintegrated.com/en/an/AN3785.pdf
0014  */
0015 
0016 #include <linux/delay.h>
0017 #include <linux/device.h>
0018 #include <linux/interrupt.h>
0019 #include <linux/io.h>
0020 #include <linux/module.h>
0021 #include <linux/bitfield.h>
0022 #include <linux/of_address.h>
0023 #include <linux/of_device.h>
0024 #include <linux/of_platform.h>
0025 #include <linux/of_irq.h>
0026 #include <linux/prefetch.h>
0027 #include <linux/usb/ch9.h>
0028 #include <linux/usb/gadget.h>
0029 #include <linux/spi/spi.h>
0030 #include <linux/gpio/consumer.h>
0031 
0032 #define MAX3420_MAX_EPS     4
0033 #define MAX3420_EP_MAX_PACKET       64  /* Same for all Endpoints */
0034 #define MAX3420_EPNAME_SIZE     16  /* Buffer size for endpoint name */
0035 
0036 #define MAX3420_ACKSTAT     BIT(0)
0037 
0038 #define MAX3420_SPI_DIR_RD  0   /* read register from MAX3420 */
0039 #define MAX3420_SPI_DIR_WR  1   /* write register to MAX3420 */
0040 
0041 /* SPI commands: */
0042 #define MAX3420_SPI_DIR_SHIFT   1
0043 #define MAX3420_SPI_REG_SHIFT   3
0044 
0045 #define MAX3420_REG_EP0FIFO 0
0046 #define MAX3420_REG_EP1FIFO 1
0047 #define MAX3420_REG_EP2FIFO 2
0048 #define MAX3420_REG_EP3FIFO 3
0049 #define MAX3420_REG_SUDFIFO 4
0050 #define MAX3420_REG_EP0BC   5
0051 #define MAX3420_REG_EP1BC   6
0052 #define MAX3420_REG_EP2BC   7
0053 #define MAX3420_REG_EP3BC   8
0054 
0055 #define MAX3420_REG_EPSTALLS    9
0056     #define ACKSTAT     BIT(6)
0057     #define STLSTAT     BIT(5)
0058     #define STLEP3IN    BIT(4)
0059     #define STLEP2IN    BIT(3)
0060     #define STLEP1OUT   BIT(2)
0061     #define STLEP0OUT   BIT(1)
0062     #define STLEP0IN    BIT(0)
0063 
0064 #define MAX3420_REG_CLRTOGS 10
0065     #define EP3DISAB    BIT(7)
0066     #define EP2DISAB    BIT(6)
0067     #define EP1DISAB    BIT(5)
0068     #define CTGEP3IN    BIT(4)
0069     #define CTGEP2IN    BIT(3)
0070     #define CTGEP1OUT   BIT(2)
0071 
0072 #define MAX3420_REG_EPIRQ   11
0073 #define MAX3420_REG_EPIEN   12
0074     #define SUDAVIRQ    BIT(5)
0075     #define IN3BAVIRQ   BIT(4)
0076     #define IN2BAVIRQ   BIT(3)
0077     #define OUT1DAVIRQ  BIT(2)
0078     #define OUT0DAVIRQ  BIT(1)
0079     #define IN0BAVIRQ   BIT(0)
0080 
0081 #define MAX3420_REG_USBIRQ  13
0082 #define MAX3420_REG_USBIEN  14
0083     #define OSCOKIRQ    BIT(0)
0084     #define RWUDNIRQ    BIT(1)
0085     #define BUSACTIRQ   BIT(2)
0086     #define URESIRQ     BIT(3)
0087     #define SUSPIRQ     BIT(4)
0088     #define NOVBUSIRQ   BIT(5)
0089     #define VBUSIRQ     BIT(6)
0090     #define URESDNIRQ   BIT(7)
0091 
0092 #define MAX3420_REG_USBCTL  15
0093     #define HOSCSTEN    BIT(7)
0094     #define VBGATE      BIT(6)
0095     #define CHIPRES     BIT(5)
0096     #define PWRDOWN     BIT(4)
0097     #define CONNECT     BIT(3)
0098     #define SIGRWU      BIT(2)
0099 
0100 #define MAX3420_REG_CPUCTL  16
0101     #define IE      BIT(0)
0102 
0103 #define MAX3420_REG_PINCTL  17
0104     #define EP3INAK     BIT(7)
0105     #define EP2INAK     BIT(6)
0106     #define EP0INAK     BIT(5)
0107     #define FDUPSPI     BIT(4)
0108     #define INTLEVEL    BIT(3)
0109     #define POSINT      BIT(2)
0110     #define GPXB        BIT(1)
0111     #define GPXA        BIT(0)
0112 
0113 #define MAX3420_REG_REVISION    18
0114 
0115 #define MAX3420_REG_FNADDR  19
0116     #define FNADDR_MASK 0x7f
0117 
0118 #define MAX3420_REG_IOPINS  20
0119 #define MAX3420_REG_IOPINS2 21
0120 #define MAX3420_REG_GPINIRQ 22
0121 #define MAX3420_REG_GPINIEN 23
0122 #define MAX3420_REG_GPINPOL 24
0123 #define MAX3420_REG_HIRQ    25
0124 #define MAX3420_REG_HIEN    26
0125 #define MAX3420_REG_MODE    27
0126 #define MAX3420_REG_PERADDR 28
0127 #define MAX3420_REG_HCTL    29
0128 #define MAX3420_REG_HXFR    30
0129 #define MAX3420_REG_HRSL    31
0130 
0131 #define ENABLE_IRQ  BIT(0)
0132 #define IOPIN_UPDATE    BIT(1)
0133 #define REMOTE_WAKEUP   BIT(2)
0134 #define CONNECT_HOST    GENMASK(4, 3)
0135 #define HCONNECT    (1 << 3)
0136 #define HDISCONNECT (3 << 3)
0137 #define UDC_START   GENMASK(6, 5)
0138 #define START       (1 << 5)
0139 #define STOP        (3 << 5)
0140 #define ENABLE_EP   GENMASK(8, 7)
0141 #define ENABLE      (1 << 7)
0142 #define DISABLE     (3 << 7)
0143 #define STALL_EP    GENMASK(10, 9)
0144 #define STALL       (1 << 9)
0145 #define UNSTALL     (3 << 9)
0146 
0147 #define MAX3420_CMD(c)      FIELD_PREP(GENMASK(7, 3), c)
0148 #define MAX3420_SPI_CMD_RD(c)   (MAX3420_CMD(c) | (0 << 1))
0149 #define MAX3420_SPI_CMD_WR(c)   (MAX3420_CMD(c) | (1 << 1))
0150 
0151 struct max3420_req {
0152     struct usb_request usb_req;
0153     struct list_head queue;
0154     struct max3420_ep *ep;
0155 };
0156 
0157 struct max3420_ep {
0158     struct usb_ep ep_usb;
0159     struct max3420_udc *udc;
0160     struct list_head queue;
0161     char name[MAX3420_EPNAME_SIZE];
0162     unsigned int maxpacket;
0163     spinlock_t lock;
0164     int halted;
0165     u32 todo;
0166     int id;
0167 };
0168 
0169 struct max3420_udc {
0170     struct usb_gadget gadget;
0171     struct max3420_ep ep[MAX3420_MAX_EPS];
0172     struct usb_gadget_driver *driver;
0173     struct task_struct *thread_task;
0174     int remote_wkp, is_selfpowered;
0175     bool vbus_active, softconnect;
0176     struct usb_ctrlrequest setup;
0177     struct mutex spi_bus_mutex;
0178     struct max3420_req ep0req;
0179     struct spi_device *spi;
0180     struct device *dev;
0181     spinlock_t lock;
0182     bool suspended;
0183     u8 ep0buf[64];
0184     u32 todo;
0185 };
0186 
0187 #define to_max3420_req(r)   container_of((r), struct max3420_req, usb_req)
0188 #define to_max3420_ep(e)    container_of((e), struct max3420_ep, ep_usb)
0189 #define to_udc(g)       container_of((g), struct max3420_udc, gadget)
0190 
0191 #define DRIVER_DESC     "MAX3420 USB Device-Mode Driver"
0192 static const char driver_name[] = "max3420-udc";
0193 
0194 /* Control endpoint configuration.*/
0195 static const struct usb_endpoint_descriptor ep0_desc = {
0196     .bEndpointAddress   = USB_DIR_OUT,
0197     .bmAttributes       = USB_ENDPOINT_XFER_CONTROL,
0198     .wMaxPacketSize     = cpu_to_le16(MAX3420_EP_MAX_PACKET),
0199 };
0200 
0201 static void spi_ack_ctrl(struct max3420_udc *udc)
0202 {
0203     struct spi_device *spi = udc->spi;
0204     struct spi_transfer transfer;
0205     struct spi_message msg;
0206     u8 txdata[1];
0207 
0208     memset(&transfer, 0, sizeof(transfer));
0209 
0210     spi_message_init(&msg);
0211 
0212     txdata[0] = MAX3420_ACKSTAT;
0213     transfer.tx_buf = txdata;
0214     transfer.len = 1;
0215 
0216     spi_message_add_tail(&transfer, &msg);
0217     spi_sync(spi, &msg);
0218 }
0219 
0220 static u8 spi_rd8_ack(struct max3420_udc *udc, u8 reg, int actstat)
0221 {
0222     struct spi_device *spi = udc->spi;
0223     struct spi_transfer transfer;
0224     struct spi_message msg;
0225     u8 txdata[2], rxdata[2];
0226 
0227     memset(&transfer, 0, sizeof(transfer));
0228 
0229     spi_message_init(&msg);
0230 
0231     txdata[0] = MAX3420_SPI_CMD_RD(reg) | (actstat ? MAX3420_ACKSTAT : 0);
0232     transfer.tx_buf = txdata;
0233     transfer.rx_buf = rxdata;
0234     transfer.len = 2;
0235 
0236     spi_message_add_tail(&transfer, &msg);
0237     spi_sync(spi, &msg);
0238 
0239     return rxdata[1];
0240 }
0241 
0242 static u8 spi_rd8(struct max3420_udc *udc, u8 reg)
0243 {
0244     return spi_rd8_ack(udc, reg, 0);
0245 }
0246 
0247 static void spi_wr8_ack(struct max3420_udc *udc, u8 reg, u8 val, int actstat)
0248 {
0249     struct spi_device *spi = udc->spi;
0250     struct spi_transfer transfer;
0251     struct spi_message msg;
0252     u8 txdata[2];
0253 
0254     memset(&transfer, 0, sizeof(transfer));
0255 
0256     spi_message_init(&msg);
0257 
0258     txdata[0] = MAX3420_SPI_CMD_WR(reg) | (actstat ? MAX3420_ACKSTAT : 0);
0259     txdata[1] = val;
0260 
0261     transfer.tx_buf = txdata;
0262     transfer.len = 2;
0263 
0264     spi_message_add_tail(&transfer, &msg);
0265     spi_sync(spi, &msg);
0266 }
0267 
0268 static void spi_wr8(struct max3420_udc *udc, u8 reg, u8 val)
0269 {
0270     spi_wr8_ack(udc, reg, val, 0);
0271 }
0272 
0273 static void spi_rd_buf(struct max3420_udc *udc, u8 reg, void *buf, u8 len)
0274 {
0275     struct spi_device *spi = udc->spi;
0276     struct spi_transfer transfer;
0277     struct spi_message msg;
0278     u8 local_buf[MAX3420_EP_MAX_PACKET + 1] = {};
0279 
0280     memset(&transfer, 0, sizeof(transfer));
0281 
0282     spi_message_init(&msg);
0283 
0284     local_buf[0] = MAX3420_SPI_CMD_RD(reg);
0285     transfer.tx_buf = &local_buf[0];
0286     transfer.rx_buf = &local_buf[0];
0287     transfer.len = len + 1;
0288 
0289     spi_message_add_tail(&transfer, &msg);
0290     spi_sync(spi, &msg);
0291 
0292     memcpy(buf, &local_buf[1], len);
0293 }
0294 
0295 static void spi_wr_buf(struct max3420_udc *udc, u8 reg, void *buf, u8 len)
0296 {
0297     struct spi_device *spi = udc->spi;
0298     struct spi_transfer transfer;
0299     struct spi_message msg;
0300     u8 local_buf[MAX3420_EP_MAX_PACKET + 1] = {};
0301 
0302     memset(&transfer, 0, sizeof(transfer));
0303 
0304     spi_message_init(&msg);
0305 
0306     local_buf[0] = MAX3420_SPI_CMD_WR(reg);
0307     memcpy(&local_buf[1], buf, len);
0308 
0309     transfer.tx_buf = local_buf;
0310     transfer.len = len + 1;
0311 
0312     spi_message_add_tail(&transfer, &msg);
0313     spi_sync(spi, &msg);
0314 }
0315 
0316 static int spi_max3420_enable(struct max3420_ep *ep)
0317 {
0318     struct max3420_udc *udc = ep->udc;
0319     unsigned long flags;
0320     u8 epdis, epien;
0321     int todo;
0322 
0323     spin_lock_irqsave(&ep->lock, flags);
0324     todo = ep->todo & ENABLE_EP;
0325     ep->todo &= ~ENABLE_EP;
0326     spin_unlock_irqrestore(&ep->lock, flags);
0327 
0328     if (!todo || ep->id == 0)
0329         return false;
0330 
0331     epien = spi_rd8(udc, MAX3420_REG_EPIEN);
0332     epdis = spi_rd8(udc, MAX3420_REG_CLRTOGS);
0333 
0334     if (todo == ENABLE) {
0335         epdis &= ~BIT(ep->id + 4);
0336         epien |= BIT(ep->id + 1);
0337     } else {
0338         epdis |= BIT(ep->id + 4);
0339         epien &= ~BIT(ep->id + 1);
0340     }
0341 
0342     spi_wr8(udc, MAX3420_REG_CLRTOGS, epdis);
0343     spi_wr8(udc, MAX3420_REG_EPIEN, epien);
0344 
0345     return true;
0346 }
0347 
0348 static int spi_max3420_stall(struct max3420_ep *ep)
0349 {
0350     struct max3420_udc *udc = ep->udc;
0351     unsigned long flags;
0352     u8 epstalls;
0353     int todo;
0354 
0355     spin_lock_irqsave(&ep->lock, flags);
0356     todo = ep->todo & STALL_EP;
0357     ep->todo &= ~STALL_EP;
0358     spin_unlock_irqrestore(&ep->lock, flags);
0359 
0360     if (!todo || ep->id == 0)
0361         return false;
0362 
0363     epstalls = spi_rd8(udc, MAX3420_REG_EPSTALLS);
0364     if (todo == STALL) {
0365         ep->halted = 1;
0366         epstalls |= BIT(ep->id + 1);
0367     } else {
0368         u8 clrtogs;
0369 
0370         ep->halted = 0;
0371         epstalls &= ~BIT(ep->id + 1);
0372         clrtogs = spi_rd8(udc, MAX3420_REG_CLRTOGS);
0373         clrtogs |= BIT(ep->id + 1);
0374         spi_wr8(udc, MAX3420_REG_CLRTOGS, clrtogs);
0375     }
0376     spi_wr8(udc, MAX3420_REG_EPSTALLS, epstalls | ACKSTAT);
0377 
0378     return true;
0379 }
0380 
0381 static int spi_max3420_rwkup(struct max3420_udc *udc)
0382 {
0383     unsigned long flags;
0384     int wake_remote;
0385     u8 usbctl;
0386 
0387     spin_lock_irqsave(&udc->lock, flags);
0388     wake_remote = udc->todo & REMOTE_WAKEUP;
0389     udc->todo &= ~REMOTE_WAKEUP;
0390     spin_unlock_irqrestore(&udc->lock, flags);
0391 
0392     if (!wake_remote || !udc->suspended)
0393         return false;
0394 
0395     /* Set Remote-WkUp Signal*/
0396     usbctl = spi_rd8(udc, MAX3420_REG_USBCTL);
0397     usbctl |= SIGRWU;
0398     spi_wr8(udc, MAX3420_REG_USBCTL, usbctl);
0399 
0400     msleep_interruptible(5);
0401 
0402     /* Clear Remote-WkUp Signal*/
0403     usbctl = spi_rd8(udc, MAX3420_REG_USBCTL);
0404     usbctl &= ~SIGRWU;
0405     spi_wr8(udc, MAX3420_REG_USBCTL, usbctl);
0406 
0407     udc->suspended = false;
0408 
0409     return true;
0410 }
0411 
0412 static void max3420_nuke(struct max3420_ep *ep, int status);
0413 static void __max3420_stop(struct max3420_udc *udc)
0414 {
0415     u8 val;
0416     int i;
0417 
0418     /* clear all pending requests */
0419     for (i = 1; i < MAX3420_MAX_EPS; i++)
0420         max3420_nuke(&udc->ep[i], -ECONNRESET);
0421 
0422     /* Disable IRQ to CPU */
0423     spi_wr8(udc, MAX3420_REG_CPUCTL, 0);
0424 
0425     val = spi_rd8(udc, MAX3420_REG_USBCTL);
0426     val |= PWRDOWN;
0427     if (udc->is_selfpowered)
0428         val &= ~HOSCSTEN;
0429     else
0430         val |= HOSCSTEN;
0431     spi_wr8(udc, MAX3420_REG_USBCTL, val);
0432 }
0433 
0434 static void __max3420_start(struct max3420_udc *udc)
0435 {
0436     u8 val;
0437 
0438     /* Need this delay if bus-powered,
0439      * but even for self-powered it helps stability
0440      */
0441     msleep_interruptible(250);
0442 
0443     /* configure SPI */
0444     spi_wr8(udc, MAX3420_REG_PINCTL, FDUPSPI);
0445 
0446     /* Chip Reset */
0447     spi_wr8(udc, MAX3420_REG_USBCTL, CHIPRES);
0448     msleep_interruptible(5);
0449     spi_wr8(udc, MAX3420_REG_USBCTL, 0);
0450 
0451     /* Poll for OSC to stabilize */
0452     while (1) {
0453         val = spi_rd8(udc, MAX3420_REG_USBIRQ);
0454         if (val & OSCOKIRQ)
0455             break;
0456         cond_resched();
0457     }
0458 
0459     /* Enable PULL-UP only when Vbus detected */
0460     val = spi_rd8(udc, MAX3420_REG_USBCTL);
0461     val |= VBGATE | CONNECT;
0462     spi_wr8(udc, MAX3420_REG_USBCTL, val);
0463 
0464     val = URESDNIRQ | URESIRQ;
0465     if (udc->is_selfpowered)
0466         val |= NOVBUSIRQ;
0467     spi_wr8(udc, MAX3420_REG_USBIEN, val);
0468 
0469     /* Enable only EP0 interrupts */
0470     val = IN0BAVIRQ | OUT0DAVIRQ | SUDAVIRQ;
0471     spi_wr8(udc, MAX3420_REG_EPIEN, val);
0472 
0473     /* Enable IRQ to CPU */
0474     spi_wr8(udc, MAX3420_REG_CPUCTL, IE);
0475 }
0476 
0477 static int max3420_start(struct max3420_udc *udc)
0478 {
0479     unsigned long flags;
0480     int todo;
0481 
0482     spin_lock_irqsave(&udc->lock, flags);
0483     todo = udc->todo & UDC_START;
0484     udc->todo &= ~UDC_START;
0485     spin_unlock_irqrestore(&udc->lock, flags);
0486 
0487     if (!todo)
0488         return false;
0489 
0490     if (udc->vbus_active && udc->softconnect)
0491         __max3420_start(udc);
0492     else
0493         __max3420_stop(udc);
0494 
0495     return true;
0496 }
0497 
0498 static irqreturn_t max3420_vbus_handler(int irq, void *dev_id)
0499 {
0500     struct max3420_udc *udc = dev_id;
0501     unsigned long flags;
0502 
0503     spin_lock_irqsave(&udc->lock, flags);
0504     /* its a vbus change interrupt */
0505     udc->vbus_active = !udc->vbus_active;
0506     udc->todo |= UDC_START;
0507     usb_udc_vbus_handler(&udc->gadget, udc->vbus_active);
0508     usb_gadget_set_state(&udc->gadget, udc->vbus_active
0509                  ? USB_STATE_POWERED : USB_STATE_NOTATTACHED);
0510     spin_unlock_irqrestore(&udc->lock, flags);
0511 
0512     if (udc->thread_task)
0513         wake_up_process(udc->thread_task);
0514 
0515     return IRQ_HANDLED;
0516 }
0517 
0518 static irqreturn_t max3420_irq_handler(int irq, void *dev_id)
0519 {
0520     struct max3420_udc *udc = dev_id;
0521     struct spi_device *spi = udc->spi;
0522     unsigned long flags;
0523 
0524     spin_lock_irqsave(&udc->lock, flags);
0525     if ((udc->todo & ENABLE_IRQ) == 0) {
0526         disable_irq_nosync(spi->irq);
0527         udc->todo |= ENABLE_IRQ;
0528     }
0529     spin_unlock_irqrestore(&udc->lock, flags);
0530 
0531     if (udc->thread_task)
0532         wake_up_process(udc->thread_task);
0533 
0534     return IRQ_HANDLED;
0535 }
0536 
0537 static void max3420_getstatus(struct max3420_udc *udc)
0538 {
0539     struct max3420_ep *ep;
0540     u16 status = 0;
0541 
0542     switch (udc->setup.bRequestType & USB_RECIP_MASK) {
0543     case USB_RECIP_DEVICE:
0544         /* Get device status */
0545         status = udc->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED;
0546         status |= (udc->remote_wkp << USB_DEVICE_REMOTE_WAKEUP);
0547         break;
0548     case USB_RECIP_INTERFACE:
0549         if (udc->driver->setup(&udc->gadget, &udc->setup) < 0)
0550             goto stall;
0551         break;
0552     case USB_RECIP_ENDPOINT:
0553         ep = &udc->ep[udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK];
0554         if (udc->setup.wIndex & USB_DIR_IN) {
0555             if (!ep->ep_usb.caps.dir_in)
0556                 goto stall;
0557         } else {
0558             if (!ep->ep_usb.caps.dir_out)
0559                 goto stall;
0560         }
0561         if (ep->halted)
0562             status = 1 << USB_ENDPOINT_HALT;
0563         break;
0564     default:
0565         goto stall;
0566     }
0567 
0568     status = cpu_to_le16(status);
0569     spi_wr_buf(udc, MAX3420_REG_EP0FIFO, &status, 2);
0570     spi_wr8_ack(udc, MAX3420_REG_EP0BC, 2, 1);
0571     return;
0572 stall:
0573     dev_err(udc->dev, "Can't respond to getstatus request\n");
0574     spi_wr8(udc, MAX3420_REG_EPSTALLS, STLEP0IN | STLEP0OUT | STLSTAT);
0575 }
0576 
0577 static void max3420_set_clear_feature(struct max3420_udc *udc)
0578 {
0579     struct max3420_ep *ep;
0580     int set = udc->setup.bRequest == USB_REQ_SET_FEATURE;
0581     unsigned long flags;
0582     int id;
0583 
0584     switch (udc->setup.bRequestType) {
0585     case USB_RECIP_DEVICE:
0586         if (udc->setup.wValue != USB_DEVICE_REMOTE_WAKEUP)
0587             break;
0588 
0589         if (udc->setup.bRequest == USB_REQ_SET_FEATURE)
0590             udc->remote_wkp = 1;
0591         else
0592             udc->remote_wkp = 0;
0593 
0594         return spi_ack_ctrl(udc);
0595 
0596     case USB_RECIP_ENDPOINT:
0597         if (udc->setup.wValue != USB_ENDPOINT_HALT)
0598             break;
0599 
0600         id = udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK;
0601         ep = &udc->ep[id];
0602 
0603         spin_lock_irqsave(&ep->lock, flags);
0604         ep->todo &= ~STALL_EP;
0605         if (set)
0606             ep->todo |= STALL;
0607         else
0608             ep->todo |= UNSTALL;
0609         spin_unlock_irqrestore(&ep->lock, flags);
0610 
0611         spi_max3420_stall(ep);
0612         return;
0613     default:
0614         break;
0615     }
0616 
0617     dev_err(udc->dev, "Can't respond to SET/CLEAR FEATURE\n");
0618     spi_wr8(udc, MAX3420_REG_EPSTALLS, STLEP0IN | STLEP0OUT | STLSTAT);
0619 }
0620 
0621 static void max3420_handle_setup(struct max3420_udc *udc)
0622 {
0623     struct usb_ctrlrequest setup;
0624 
0625     spi_rd_buf(udc, MAX3420_REG_SUDFIFO, (void *)&setup, 8);
0626 
0627     udc->setup = setup;
0628     udc->setup.wValue = cpu_to_le16(setup.wValue);
0629     udc->setup.wIndex = cpu_to_le16(setup.wIndex);
0630     udc->setup.wLength = cpu_to_le16(setup.wLength);
0631 
0632     switch (udc->setup.bRequest) {
0633     case USB_REQ_GET_STATUS:
0634         /* Data+Status phase form udc */
0635         if ((udc->setup.bRequestType &
0636                 (USB_DIR_IN | USB_TYPE_MASK)) !=
0637                 (USB_DIR_IN | USB_TYPE_STANDARD)) {
0638             break;
0639         }
0640         return max3420_getstatus(udc);
0641     case USB_REQ_SET_ADDRESS:
0642         /* Status phase from udc */
0643         if (udc->setup.bRequestType != (USB_DIR_OUT |
0644                 USB_TYPE_STANDARD | USB_RECIP_DEVICE)) {
0645             break;
0646         }
0647         spi_rd8_ack(udc, MAX3420_REG_FNADDR, 1);
0648         dev_dbg(udc->dev, "Assigned Address=%d\n", udc->setup.wValue);
0649         return;
0650     case USB_REQ_CLEAR_FEATURE:
0651     case USB_REQ_SET_FEATURE:
0652         /* Requests with no data phase, status phase from udc */
0653         if ((udc->setup.bRequestType & USB_TYPE_MASK)
0654                 != USB_TYPE_STANDARD)
0655             break;
0656         return max3420_set_clear_feature(udc);
0657     default:
0658         break;
0659     }
0660 
0661     if (udc->driver->setup(&udc->gadget, &setup) < 0) {
0662         /* Stall EP0 */
0663         spi_wr8(udc, MAX3420_REG_EPSTALLS,
0664             STLEP0IN | STLEP0OUT | STLSTAT);
0665     }
0666 }
0667 
0668 static void max3420_req_done(struct max3420_req *req, int status)
0669 {
0670     struct max3420_ep *ep = req->ep;
0671     struct max3420_udc *udc = ep->udc;
0672 
0673     if (req->usb_req.status == -EINPROGRESS)
0674         req->usb_req.status = status;
0675     else
0676         status = req->usb_req.status;
0677 
0678     if (status && status != -ESHUTDOWN)
0679         dev_err(udc->dev, "%s done %p, status %d\n",
0680             ep->ep_usb.name, req, status);
0681 
0682     if (req->usb_req.complete)
0683         req->usb_req.complete(&ep->ep_usb, &req->usb_req);
0684 }
0685 
0686 static int max3420_do_data(struct max3420_udc *udc, int ep_id, int in)
0687 {
0688     struct max3420_ep *ep = &udc->ep[ep_id];
0689     struct max3420_req *req;
0690     int done, length, psz;
0691     void *buf;
0692 
0693     if (list_empty(&ep->queue))
0694         return false;
0695 
0696     req = list_first_entry(&ep->queue, struct max3420_req, queue);
0697     buf = req->usb_req.buf + req->usb_req.actual;
0698 
0699     psz = ep->ep_usb.maxpacket;
0700     length = req->usb_req.length - req->usb_req.actual;
0701     length = min(length, psz);
0702 
0703     if (length == 0) {
0704         done = 1;
0705         goto xfer_done;
0706     }
0707 
0708     done = 0;
0709     if (in) {
0710         prefetch(buf);
0711         spi_wr_buf(udc, MAX3420_REG_EP0FIFO + ep_id, buf, length);
0712         spi_wr8(udc, MAX3420_REG_EP0BC + ep_id, length);
0713         if (length < psz)
0714             done = 1;
0715     } else {
0716         psz = spi_rd8(udc, MAX3420_REG_EP0BC + ep_id);
0717         length = min(length, psz);
0718         prefetchw(buf);
0719         spi_rd_buf(udc, MAX3420_REG_EP0FIFO + ep_id, buf, length);
0720         if (length < ep->ep_usb.maxpacket)
0721             done = 1;
0722     }
0723 
0724     req->usb_req.actual += length;
0725 
0726     if (req->usb_req.actual == req->usb_req.length)
0727         done = 1;
0728 
0729 xfer_done:
0730     if (done) {
0731         unsigned long flags;
0732 
0733         spin_lock_irqsave(&ep->lock, flags);
0734         list_del_init(&req->queue);
0735         spin_unlock_irqrestore(&ep->lock, flags);
0736 
0737         if (ep_id == 0)
0738             spi_ack_ctrl(udc);
0739 
0740         max3420_req_done(req, 0);
0741     }
0742 
0743     return true;
0744 }
0745 
0746 static int max3420_handle_irqs(struct max3420_udc *udc)
0747 {
0748     u8 epien, epirq, usbirq, usbien, reg[4];
0749     bool ret = false;
0750 
0751     spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 4);
0752     epirq = reg[0];
0753     epien = reg[1];
0754     usbirq = reg[2];
0755     usbien = reg[3];
0756 
0757     usbirq &= usbien;
0758     epirq &= epien;
0759 
0760     if (epirq & SUDAVIRQ) {
0761         spi_wr8(udc, MAX3420_REG_EPIRQ, SUDAVIRQ);
0762         max3420_handle_setup(udc);
0763         return true;
0764     }
0765 
0766     if (usbirq & VBUSIRQ) {
0767         spi_wr8(udc, MAX3420_REG_USBIRQ, VBUSIRQ);
0768         dev_dbg(udc->dev, "Cable plugged in\n");
0769         return true;
0770     }
0771 
0772     if (usbirq & NOVBUSIRQ) {
0773         spi_wr8(udc, MAX3420_REG_USBIRQ, NOVBUSIRQ);
0774         dev_dbg(udc->dev, "Cable pulled out\n");
0775         return true;
0776     }
0777 
0778     if (usbirq & URESIRQ) {
0779         spi_wr8(udc, MAX3420_REG_USBIRQ, URESIRQ);
0780         dev_dbg(udc->dev, "USB Reset - Start\n");
0781         return true;
0782     }
0783 
0784     if (usbirq & URESDNIRQ) {
0785         spi_wr8(udc, MAX3420_REG_USBIRQ, URESDNIRQ);
0786         dev_dbg(udc->dev, "USB Reset - END\n");
0787         spi_wr8(udc, MAX3420_REG_USBIEN, URESDNIRQ | URESIRQ);
0788         spi_wr8(udc, MAX3420_REG_EPIEN, SUDAVIRQ | IN0BAVIRQ
0789             | OUT0DAVIRQ);
0790         return true;
0791     }
0792 
0793     if (usbirq & SUSPIRQ) {
0794         spi_wr8(udc, MAX3420_REG_USBIRQ, SUSPIRQ);
0795         dev_dbg(udc->dev, "USB Suspend - Enter\n");
0796         udc->suspended = true;
0797         return true;
0798     }
0799 
0800     if (usbirq & BUSACTIRQ) {
0801         spi_wr8(udc, MAX3420_REG_USBIRQ, BUSACTIRQ);
0802         dev_dbg(udc->dev, "USB Suspend - Exit\n");
0803         udc->suspended = false;
0804         return true;
0805     }
0806 
0807     if (usbirq & RWUDNIRQ) {
0808         spi_wr8(udc, MAX3420_REG_USBIRQ, RWUDNIRQ);
0809         dev_dbg(udc->dev, "Asked Host to wakeup\n");
0810         return true;
0811     }
0812 
0813     if (usbirq & OSCOKIRQ) {
0814         spi_wr8(udc, MAX3420_REG_USBIRQ, OSCOKIRQ);
0815         dev_dbg(udc->dev, "Osc stabilized, start work\n");
0816         return true;
0817     }
0818 
0819     if (epirq & OUT0DAVIRQ && max3420_do_data(udc, 0, 0)) {
0820         spi_wr8_ack(udc, MAX3420_REG_EPIRQ, OUT0DAVIRQ, 1);
0821         ret = true;
0822     }
0823 
0824     if (epirq & IN0BAVIRQ && max3420_do_data(udc, 0, 1))
0825         ret = true;
0826 
0827     if (epirq & OUT1DAVIRQ && max3420_do_data(udc, 1, 0)) {
0828         spi_wr8_ack(udc, MAX3420_REG_EPIRQ, OUT1DAVIRQ, 1);
0829         ret = true;
0830     }
0831 
0832     if (epirq & IN2BAVIRQ && max3420_do_data(udc, 2, 1))
0833         ret = true;
0834 
0835     if (epirq & IN3BAVIRQ && max3420_do_data(udc, 3, 1))
0836         ret = true;
0837 
0838     return ret;
0839 }
0840 
0841 static int max3420_thread(void *dev_id)
0842 {
0843     struct max3420_udc *udc = dev_id;
0844     struct spi_device *spi = udc->spi;
0845     int i, loop_again = 1;
0846     unsigned long flags;
0847 
0848     while (!kthread_should_stop()) {
0849         if (!loop_again) {
0850             ktime_t kt = ns_to_ktime(1000 * 1000 * 250); /* 250ms */
0851 
0852             set_current_state(TASK_INTERRUPTIBLE);
0853 
0854             spin_lock_irqsave(&udc->lock, flags);
0855             if (udc->todo & ENABLE_IRQ) {
0856                 enable_irq(spi->irq);
0857                 udc->todo &= ~ENABLE_IRQ;
0858             }
0859             spin_unlock_irqrestore(&udc->lock, flags);
0860 
0861             schedule_hrtimeout(&kt, HRTIMER_MODE_REL);
0862         }
0863         loop_again = 0;
0864 
0865         mutex_lock(&udc->spi_bus_mutex);
0866 
0867         /* If bus-vbus_active and disconnected */
0868         if (!udc->vbus_active || !udc->softconnect)
0869             goto loop;
0870 
0871         if (max3420_start(udc)) {
0872             loop_again = 1;
0873             goto loop;
0874         }
0875 
0876         if (max3420_handle_irqs(udc)) {
0877             loop_again = 1;
0878             goto loop;
0879         }
0880 
0881         if (spi_max3420_rwkup(udc)) {
0882             loop_again = 1;
0883             goto loop;
0884         }
0885 
0886         max3420_do_data(udc, 0, 1); /* get done with the EP0 ZLP */
0887 
0888         for (i = 1; i < MAX3420_MAX_EPS; i++) {
0889             struct max3420_ep *ep = &udc->ep[i];
0890 
0891             if (spi_max3420_enable(ep))
0892                 loop_again = 1;
0893             if (spi_max3420_stall(ep))
0894                 loop_again = 1;
0895         }
0896 loop:
0897         mutex_unlock(&udc->spi_bus_mutex);
0898     }
0899 
0900     set_current_state(TASK_RUNNING);
0901     dev_info(udc->dev, "SPI thread exiting\n");
0902     return 0;
0903 }
0904 
0905 static int max3420_ep_set_halt(struct usb_ep *_ep, int stall)
0906 {
0907     struct max3420_ep *ep = to_max3420_ep(_ep);
0908     struct max3420_udc *udc = ep->udc;
0909     unsigned long flags;
0910 
0911     spin_lock_irqsave(&ep->lock, flags);
0912 
0913     ep->todo &= ~STALL_EP;
0914     if (stall)
0915         ep->todo |= STALL;
0916     else
0917         ep->todo |= UNSTALL;
0918 
0919     spin_unlock_irqrestore(&ep->lock, flags);
0920 
0921     wake_up_process(udc->thread_task);
0922 
0923     dev_dbg(udc->dev, "%sStall %s\n", stall ? "" : "Un", ep->name);
0924     return 0;
0925 }
0926 
0927 static int __max3420_ep_enable(struct max3420_ep *ep,
0928                    const struct usb_endpoint_descriptor *desc)
0929 {
0930     unsigned int maxp = usb_endpoint_maxp(desc);
0931     unsigned long flags;
0932 
0933     spin_lock_irqsave(&ep->lock, flags);
0934     ep->ep_usb.desc = desc;
0935     ep->ep_usb.maxpacket = maxp;
0936 
0937     ep->todo &= ~ENABLE_EP;
0938     ep->todo |= ENABLE;
0939     spin_unlock_irqrestore(&ep->lock, flags);
0940 
0941     return 0;
0942 }
0943 
0944 static int max3420_ep_enable(struct usb_ep *_ep,
0945                  const struct usb_endpoint_descriptor *desc)
0946 {
0947     struct max3420_ep *ep = to_max3420_ep(_ep);
0948     struct max3420_udc *udc = ep->udc;
0949 
0950     __max3420_ep_enable(ep, desc);
0951 
0952     wake_up_process(udc->thread_task);
0953 
0954     return 0;
0955 }
0956 
0957 static void max3420_nuke(struct max3420_ep *ep, int status)
0958 {
0959     struct max3420_req *req, *r;
0960     unsigned long flags;
0961 
0962     spin_lock_irqsave(&ep->lock, flags);
0963 
0964     list_for_each_entry_safe(req, r, &ep->queue, queue) {
0965         list_del_init(&req->queue);
0966 
0967         spin_unlock_irqrestore(&ep->lock, flags);
0968         max3420_req_done(req, status);
0969         spin_lock_irqsave(&ep->lock, flags);
0970     }
0971 
0972     spin_unlock_irqrestore(&ep->lock, flags);
0973 }
0974 
0975 static void __max3420_ep_disable(struct max3420_ep *ep)
0976 {
0977     struct max3420_udc *udc = ep->udc;
0978     unsigned long flags;
0979 
0980     spin_lock_irqsave(&ep->lock, flags);
0981 
0982     ep->ep_usb.desc = NULL;
0983 
0984     ep->todo &= ~ENABLE_EP;
0985     ep->todo |= DISABLE;
0986 
0987     spin_unlock_irqrestore(&ep->lock, flags);
0988 
0989     dev_dbg(udc->dev, "Disabled %s\n", ep->name);
0990 }
0991 
0992 static int max3420_ep_disable(struct usb_ep *_ep)
0993 {
0994     struct max3420_ep *ep = to_max3420_ep(_ep);
0995     struct max3420_udc *udc = ep->udc;
0996 
0997     max3420_nuke(ep, -ESHUTDOWN);
0998 
0999     __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 = NULL;
1048     struct max3420_req *req = to_max3420_req(_req);
1049     struct max3420_req *iter;
1050     struct max3420_ep *ep = to_max3420_ep(_ep);
1051     unsigned long flags;
1052 
1053     spin_lock_irqsave(&ep->lock, flags);
1054 
1055     /* Pluck the descriptor from queue */
1056     list_for_each_entry(iter, &ep->queue, queue) {
1057         if (iter != req)
1058             continue;
1059         list_del_init(&req->queue);
1060         t = iter;
1061         break;
1062     }
1063 
1064     spin_unlock_irqrestore(&ep->lock, flags);
1065 
1066     if (t)
1067         max3420_req_done(req, -ECONNRESET);
1068 
1069     return 0;
1070 }
1071 
1072 static const struct usb_ep_ops max3420_ep_ops = {
1073     .enable     = max3420_ep_enable,
1074     .disable    = max3420_ep_disable,
1075     .alloc_request  = max3420_alloc_request,
1076     .free_request   = max3420_free_request,
1077     .queue      = max3420_ep_queue,
1078     .dequeue    = max3420_ep_dequeue,
1079     .set_halt   = max3420_ep_set_halt,
1080 };
1081 
1082 static int max3420_wakeup(struct usb_gadget *gadget)
1083 {
1084     struct max3420_udc *udc = to_udc(gadget);
1085     unsigned long flags;
1086     int ret = -EINVAL;
1087 
1088     spin_lock_irqsave(&udc->lock, flags);
1089 
1090     /* Only if wakeup allowed by host */
1091     if (udc->remote_wkp) {
1092         udc->todo |= REMOTE_WAKEUP;
1093         ret = 0;
1094     }
1095 
1096     spin_unlock_irqrestore(&udc->lock, flags);
1097 
1098     if (udc->thread_task)
1099         wake_up_process(udc->thread_task);
1100     return ret;
1101 }
1102 
1103 static int max3420_udc_start(struct usb_gadget *gadget,
1104                  struct usb_gadget_driver *driver)
1105 {
1106     struct max3420_udc *udc = to_udc(gadget);
1107     unsigned long flags;
1108 
1109     spin_lock_irqsave(&udc->lock, flags);
1110     /* hook up the driver */
1111     driver->driver.bus = NULL;
1112     udc->driver = driver;
1113     udc->gadget.speed = USB_SPEED_FULL;
1114 
1115     udc->gadget.is_selfpowered = udc->is_selfpowered;
1116     udc->remote_wkp = 0;
1117     udc->softconnect = true;
1118     udc->todo |= UDC_START;
1119     spin_unlock_irqrestore(&udc->lock, flags);
1120 
1121     if (udc->thread_task)
1122         wake_up_process(udc->thread_task);
1123 
1124     return 0;
1125 }
1126 
1127 static int max3420_udc_stop(struct usb_gadget *gadget)
1128 {
1129     struct max3420_udc *udc = to_udc(gadget);
1130     unsigned long flags;
1131 
1132     spin_lock_irqsave(&udc->lock, flags);
1133     udc->is_selfpowered = udc->gadget.is_selfpowered;
1134     udc->gadget.speed = USB_SPEED_UNKNOWN;
1135     udc->driver = NULL;
1136     udc->softconnect = false;
1137     udc->todo |= UDC_START;
1138     spin_unlock_irqrestore(&udc->lock, flags);
1139 
1140     if (udc->thread_task)
1141         wake_up_process(udc->thread_task);
1142 
1143     return 0;
1144 }
1145 
1146 static const struct usb_gadget_ops max3420_udc_ops = {
1147     .udc_start  = max3420_udc_start,
1148     .udc_stop   = max3420_udc_stop,
1149     .wakeup     = max3420_wakeup,
1150 };
1151 
1152 static void max3420_eps_init(struct max3420_udc *udc)
1153 {
1154     int idx;
1155 
1156     INIT_LIST_HEAD(&udc->gadget.ep_list);
1157 
1158     for (idx = 0; idx < MAX3420_MAX_EPS; idx++) {
1159         struct max3420_ep *ep = &udc->ep[idx];
1160 
1161         spin_lock_init(&ep->lock);
1162         INIT_LIST_HEAD(&ep->queue);
1163 
1164         ep->udc = udc;
1165         ep->id = idx;
1166         ep->halted = 0;
1167         ep->maxpacket = 0;
1168         ep->ep_usb.name = ep->name;
1169         ep->ep_usb.ops = &max3420_ep_ops;
1170         usb_ep_set_maxpacket_limit(&ep->ep_usb, MAX3420_EP_MAX_PACKET);
1171 
1172         if (idx == 0) { /* For EP0 */
1173             ep->ep_usb.desc = &ep0_desc;
1174             ep->ep_usb.maxpacket = usb_endpoint_maxp(&ep0_desc);
1175             ep->ep_usb.caps.type_control = true;
1176             ep->ep_usb.caps.dir_in = true;
1177             ep->ep_usb.caps.dir_out = true;
1178             snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep0");
1179             continue;
1180         }
1181 
1182         if (idx == 1) { /* EP1 is OUT */
1183             ep->ep_usb.caps.dir_in = false;
1184             ep->ep_usb.caps.dir_out = true;
1185             snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep1-bulk-out");
1186         } else { /* EP2 & EP3 are IN */
1187             ep->ep_usb.caps.dir_in = true;
1188             ep->ep_usb.caps.dir_out = false;
1189             snprintf(ep->name, MAX3420_EPNAME_SIZE,
1190                  "ep%d-bulk-in", idx);
1191         }
1192         ep->ep_usb.caps.type_iso = false;
1193         ep->ep_usb.caps.type_int = false;
1194         ep->ep_usb.caps.type_bulk = true;
1195 
1196         list_add_tail(&ep->ep_usb.ep_list,
1197                   &udc->gadget.ep_list);
1198     }
1199 }
1200 
1201 static int max3420_probe(struct spi_device *spi)
1202 {
1203     struct max3420_udc *udc;
1204     int err, irq;
1205     u8 reg[8];
1206 
1207     if (spi->master->flags & SPI_MASTER_HALF_DUPLEX) {
1208         dev_err(&spi->dev, "UDC needs full duplex to work\n");
1209         return -EINVAL;
1210     }
1211 
1212     spi->mode = SPI_MODE_3;
1213     spi->bits_per_word = 8;
1214 
1215     err = spi_setup(spi);
1216     if (err) {
1217         dev_err(&spi->dev, "Unable to setup SPI bus\n");
1218         return -EFAULT;
1219     }
1220 
1221     udc = devm_kzalloc(&spi->dev, sizeof(*udc), GFP_KERNEL);
1222     if (!udc)
1223         return -ENOMEM;
1224 
1225     udc->spi = spi;
1226 
1227     udc->remote_wkp = 0;
1228 
1229     /* Setup gadget structure */
1230     udc->gadget.ops = &max3420_udc_ops;
1231     udc->gadget.max_speed = USB_SPEED_FULL;
1232     udc->gadget.speed = USB_SPEED_UNKNOWN;
1233     udc->gadget.ep0 = &udc->ep[0].ep_usb;
1234     udc->gadget.name = driver_name;
1235 
1236     spin_lock_init(&udc->lock);
1237     mutex_init(&udc->spi_bus_mutex);
1238 
1239     udc->ep0req.ep = &udc->ep[0];
1240     udc->ep0req.usb_req.buf = udc->ep0buf;
1241     INIT_LIST_HEAD(&udc->ep0req.queue);
1242 
1243     /* setup Endpoints */
1244     max3420_eps_init(udc);
1245 
1246     /* configure SPI */
1247     spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8);
1248     spi_wr8(udc, MAX3420_REG_PINCTL, FDUPSPI);
1249 
1250     err = usb_add_gadget_udc(&spi->dev, &udc->gadget);
1251     if (err)
1252         return err;
1253 
1254     udc->dev = &udc->gadget.dev;
1255 
1256     spi_set_drvdata(spi, udc);
1257 
1258     irq = of_irq_get_byname(spi->dev.of_node, "udc");
1259     err = devm_request_irq(&spi->dev, irq, max3420_irq_handler, 0,
1260                    "max3420", udc);
1261     if (err < 0)
1262         goto del_gadget;
1263 
1264     udc->thread_task = kthread_create(max3420_thread, udc,
1265                       "max3420-thread");
1266     if (IS_ERR(udc->thread_task)) {
1267         err = PTR_ERR(udc->thread_task);
1268         goto del_gadget;
1269     }
1270 
1271     irq = of_irq_get_byname(spi->dev.of_node, "vbus");
1272     if (irq <= 0) { /* no vbus irq implies self-powered design */
1273         udc->is_selfpowered = 1;
1274         udc->vbus_active = true;
1275         udc->todo |= UDC_START;
1276         usb_udc_vbus_handler(&udc->gadget, udc->vbus_active);
1277         usb_gadget_set_state(&udc->gadget, USB_STATE_POWERED);
1278         max3420_start(udc);
1279     } else {
1280         udc->is_selfpowered = 0;
1281         /* Detect current vbus status */
1282         spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8);
1283         if (reg[7] != 0xff)
1284             udc->vbus_active = true;
1285 
1286         err = devm_request_irq(&spi->dev, irq,
1287                        max3420_vbus_handler, 0, "vbus", udc);
1288         if (err < 0)
1289             goto del_gadget;
1290     }
1291 
1292     return 0;
1293 
1294 del_gadget:
1295     usb_del_gadget_udc(&udc->gadget);
1296     return err;
1297 }
1298 
1299 static void max3420_remove(struct spi_device *spi)
1300 {
1301     struct max3420_udc *udc = spi_get_drvdata(spi);
1302     unsigned long flags;
1303 
1304     usb_del_gadget_udc(&udc->gadget);
1305 
1306     spin_lock_irqsave(&udc->lock, flags);
1307 
1308     kthread_stop(udc->thread_task);
1309 
1310     spin_unlock_irqrestore(&udc->lock, flags);
1311 }
1312 
1313 static const struct of_device_id max3420_udc_of_match[] = {
1314     { .compatible = "maxim,max3420-udc"},
1315     { .compatible = "maxim,max3421-udc"},
1316     {},
1317 };
1318 MODULE_DEVICE_TABLE(of, max3420_udc_of_match);
1319 
1320 static struct spi_driver max3420_driver = {
1321     .driver = {
1322         .name = "max3420-udc",
1323         .of_match_table = of_match_ptr(max3420_udc_of_match),
1324     },
1325     .probe = max3420_probe,
1326     .remove = max3420_remove,
1327 };
1328 
1329 module_spi_driver(max3420_driver);
1330 
1331 MODULE_DESCRIPTION(DRIVER_DESC);
1332 MODULE_AUTHOR("Jassi Brar <jaswinder.singh@linaro.org>");
1333 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!