Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-13 22:53:20 +00:00
Code Issues Packages Projects Releases Wiki Activity
2860d45a58
linux/drivers/usb/gadget/udc/max3420_udc.c
Alexander A. Klimov 10fadd5e81 usb: gadget: Replace HTTP links with HTTPS ones 
Rationale:
Reduces attack surface on kernel devs opening the links for MITM
as HTTPS traffic is much harder to manipulate.

Deterministic algorithm:
For each file:
  If not .svg:
    For each line:
      If doesn't contain `\bxmlns\b`:
        For each link, `\bhttp://[^# \t\r\n]*(?:\w|/)`:
	  If neither `\bgnu\.org/license`, nor `\bmozilla\.org/MPL\b`:
            If both the HTTP and HTTPS versions
            return 200 OK and serve the same content:
              Replace HTTP with HTTPS.

Signed-off-by: Alexander A. Klimov <grandmaster@al2klimov.de>
Link: https://lore.kernel.org/r/20200710190919.31464-1-grandmaster@al2klimov.de
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2020-07-15 16:33:52 +02:00

1331 lines
30 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0+
/*
* MAX3420 Device Controller driver for USB.
*
* Author: Jaswinder Singh Brar <jaswinder.singh@linaro.org>
* (C) Copyright 2019-2020 Linaro Ltd
*
* Based on:
* o MAX3420E datasheet
* https://datasheets.maximintegrated.com/en/ds/MAX3420E.pdf
* o MAX342{0,1}E Programming Guides
* https://pdfserv.maximintegrated.com/en/an/AN3598.pdf
* https://pdfserv.maximintegrated.com/en/an/AN3785.pdf
*/
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/module.h>
#include <linux/bitfield.h>
#include <linux/of_address.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>
#include <linux/of_irq.h>
#include <linux/prefetch.h>
#include <linux/usb/ch9.h>
#include <linux/usb/gadget.h>
#include <linux/spi/spi.h>
#include <linux/gpio/consumer.h>
#define MAX3420_MAX_EPS 4
#define MAX3420_EP_MAX_PACKET 64 /* Same for all Endpoints */
#define MAX3420_EPNAME_SIZE 16 /* Buffer size for endpoint name */
#define MAX3420_ACKSTAT BIT(0)
#define MAX3420_SPI_DIR_RD 0 /* read register from MAX3420 */
#define MAX3420_SPI_DIR_WR 1 /* write register to MAX3420 */
/* SPI commands: */
#define MAX3420_SPI_DIR_SHIFT 1
#define MAX3420_SPI_REG_SHIFT 3
#define MAX3420_REG_EP0FIFO 0
#define MAX3420_REG_EP1FIFO 1
#define MAX3420_REG_EP2FIFO 2
#define MAX3420_REG_EP3FIFO 3
#define MAX3420_REG_SUDFIFO 4
#define MAX3420_REG_EP0BC 5
#define MAX3420_REG_EP1BC 6
#define MAX3420_REG_EP2BC 7
#define MAX3420_REG_EP3BC 8
#define MAX3420_REG_EPSTALLS 9
#define ACKSTAT BIT(6)
#define STLSTAT BIT(5)
#define STLEP3IN BIT(4)
#define STLEP2IN BIT(3)
#define STLEP1OUT BIT(2)
#define STLEP0OUT BIT(1)
#define STLEP0IN BIT(0)
#define MAX3420_REG_CLRTOGS 10
#define EP3DISAB BIT(7)
#define EP2DISAB BIT(6)
#define EP1DISAB BIT(5)
#define CTGEP3IN BIT(4)
#define CTGEP2IN BIT(3)
#define CTGEP1OUT BIT(2)
#define MAX3420_REG_EPIRQ 11
#define MAX3420_REG_EPIEN 12
#define SUDAVIRQ BIT(5)
#define IN3BAVIRQ BIT(4)
#define IN2BAVIRQ BIT(3)
#define OUT1DAVIRQ BIT(2)
#define OUT0DAVIRQ BIT(1)
#define IN0BAVIRQ BIT(0)
#define MAX3420_REG_USBIRQ 13
#define MAX3420_REG_USBIEN 14
#define OSCOKIRQ BIT(0)
#define RWUDNIRQ BIT(1)
#define BUSACTIRQ BIT(2)
#define URESIRQ BIT(3)
#define SUSPIRQ BIT(4)
#define NOVBUSIRQ BIT(5)
#define VBUSIRQ BIT(6)
#define URESDNIRQ BIT(7)
#define MAX3420_REG_USBCTL 15
#define HOSCSTEN BIT(7)
#define VBGATE BIT(6)
#define CHIPRES BIT(5)
#define PWRDOWN BIT(4)
#define CONNECT BIT(3)
#define SIGRWU BIT(2)
#define MAX3420_REG_CPUCTL 16
#define IE BIT(0)
#define MAX3420_REG_PINCTL 17
#define EP3INAK BIT(7)
#define EP2INAK BIT(6)
#define EP0INAK BIT(5)
#define FDUPSPI BIT(4)
#define INTLEVEL BIT(3)
#define POSINT BIT(2)
#define GPXB BIT(1)
#define GPXA BIT(0)
#define MAX3420_REG_REVISION 18
#define MAX3420_REG_FNADDR 19
#define FNADDR_MASK 0x7f
#define MAX3420_REG_IOPINS 20
#define MAX3420_REG_IOPINS2 21
#define MAX3420_REG_GPINIRQ 22
#define MAX3420_REG_GPINIEN 23
#define MAX3420_REG_GPINPOL 24
#define MAX3420_REG_HIRQ 25
#define MAX3420_REG_HIEN 26
#define MAX3420_REG_MODE 27
#define MAX3420_REG_PERADDR 28
#define MAX3420_REG_HCTL 29
#define MAX3420_REG_HXFR 30
#define MAX3420_REG_HRSL 31
#define ENABLE_IRQ BIT(0)
#define IOPIN_UPDATE BIT(1)
#define REMOTE_WAKEUP BIT(2)
#define CONNECT_HOST GENMASK(4, 3)
#define HCONNECT (1 << 3)
#define HDISCONNECT (3 << 3)
#define UDC_START GENMASK(6, 5)
#define START (1 << 5)
#define STOP (3 << 5)
#define ENABLE_EP GENMASK(8, 7)
#define ENABLE (1 << 7)
#define DISABLE (3 << 7)
#define STALL_EP GENMASK(10, 9)
#define STALL (1 << 9)
#define UNSTALL (3 << 9)
#define MAX3420_CMD(c) FIELD_PREP(GENMASK(7, 3), c)
#define MAX3420_SPI_CMD_RD(c) (MAX3420_CMD(c) | (0 << 1))
#define MAX3420_SPI_CMD_WR(c) (MAX3420_CMD(c) | (1 << 1))
struct max3420_req {
struct usb_request usb_req;
struct list_head queue;
struct max3420_ep *ep;
};
struct max3420_ep {
struct usb_ep ep_usb;
struct max3420_udc *udc;
struct list_head queue;
char name[MAX3420_EPNAME_SIZE];
unsigned int maxpacket;
spinlock_t lock;
int halted;
u32 todo;
int id;
};
struct max3420_udc {
struct usb_gadget gadget;
struct max3420_ep ep[MAX3420_MAX_EPS];
struct usb_gadget_driver *driver;
struct task_struct *thread_task;
int remote_wkp, is_selfpowered;
bool vbus_active, softconnect;
struct usb_ctrlrequest setup;
struct mutex spi_bus_mutex;
struct max3420_req ep0req;
struct spi_device *spi;
struct device *dev;
spinlock_t lock;
bool suspended;
u8 ep0buf[64];
u32 todo;
};
#define to_max3420_req(r) container_of((r), struct max3420_req, usb_req)
#define to_max3420_ep(e) container_of((e), struct max3420_ep, ep_usb)
#define to_udc(g) container_of((g), struct max3420_udc, gadget)
#define DRIVER_DESC "MAX3420 USB Device-Mode Driver"
static const char driver_name[] = "max3420-udc";
/* Control endpoint configuration.*/
static const struct usb_endpoint_descriptor ep0_desc = {
.bEndpointAddress = USB_DIR_OUT,
.bmAttributes = USB_ENDPOINT_XFER_CONTROL,
.wMaxPacketSize = cpu_to_le16(MAX3420_EP_MAX_PACKET),
};
static void spi_ack_ctrl(struct max3420_udc *udc)
{
struct spi_device *spi = udc->spi;
struct spi_transfer transfer;
struct spi_message msg;
u8 txdata[1];
memset(&transfer, 0, sizeof(transfer));
spi_message_init(&msg);
txdata[0] = MAX3420_ACKSTAT;
transfer.tx_buf = txdata;
transfer.len = 1;
spi_message_add_tail(&transfer, &msg);
spi_sync(spi, &msg);
}
static u8 spi_rd8_ack(struct max3420_udc *udc, u8 reg, int actstat)
{
struct spi_device *spi = udc->spi;
struct spi_transfer transfer;
struct spi_message msg;
u8 txdata[2], rxdata[2];
memset(&transfer, 0, sizeof(transfer));
spi_message_init(&msg);
txdata[0] = MAX3420_SPI_CMD_RD(reg) | (actstat ? MAX3420_ACKSTAT : 0);
transfer.tx_buf = txdata;
transfer.rx_buf = rxdata;
transfer.len = 2;
spi_message_add_tail(&transfer, &msg);
spi_sync(spi, &msg);
return rxdata[1];
}
static u8 spi_rd8(struct max3420_udc *udc, u8 reg)
{
return spi_rd8_ack(udc, reg, 0);
}
static void spi_wr8_ack(struct max3420_udc *udc, u8 reg, u8 val, int actstat)
{
struct spi_device *spi = udc->spi;
struct spi_transfer transfer;
struct spi_message msg;
u8 txdata[2];
memset(&transfer, 0, sizeof(transfer));
spi_message_init(&msg);
txdata[0] = MAX3420_SPI_CMD_WR(reg) | (actstat ? MAX3420_ACKSTAT : 0);
txdata[1] = val;
transfer.tx_buf = txdata;
transfer.len = 2;
spi_message_add_tail(&transfer, &msg);
spi_sync(spi, &msg);
}
static void spi_wr8(struct max3420_udc *udc, u8 reg, u8 val)
{
spi_wr8_ack(udc, reg, val, 0);
}
static void spi_rd_buf(struct max3420_udc *udc, u8 reg, void *buf, u8 len)
{
struct spi_device *spi = udc->spi;
struct spi_transfer transfer;
struct spi_message msg;
u8 local_buf[MAX3420_EP_MAX_PACKET + 1] = {};
memset(&transfer, 0, sizeof(transfer));
spi_message_init(&msg);
local_buf[0] = MAX3420_SPI_CMD_RD(reg);
transfer.tx_buf = &local_buf[0];
transfer.rx_buf = &local_buf[0];
transfer.len = len + 1;
spi_message_add_tail(&transfer, &msg);
spi_sync(spi, &msg);
memcpy(buf, &local_buf[1], len);
}
static void spi_wr_buf(struct max3420_udc *udc, u8 reg, void *buf, u8 len)
{
struct spi_device *spi = udc->spi;
struct spi_transfer transfer;
struct spi_message msg;
u8 local_buf[MAX3420_EP_MAX_PACKET + 1] = {};
memset(&transfer, 0, sizeof(transfer));
spi_message_init(&msg);
local_buf[0] = MAX3420_SPI_CMD_WR(reg);
memcpy(&local_buf[1], buf, len);
transfer.tx_buf = local_buf;
transfer.len = len + 1;
spi_message_add_tail(&transfer, &msg);
spi_sync(spi, &msg);
}
static int spi_max3420_enable(struct max3420_ep *ep)
{
struct max3420_udc *udc = ep->udc;
unsigned long flags;
u8 epdis, epien;
int todo;
spin_lock_irqsave(&ep->lock, flags);
todo = ep->todo & ENABLE_EP;
ep->todo &= ~ENABLE_EP;
spin_unlock_irqrestore(&ep->lock, flags);
if (!todo || ep->id == 0)
return false;
epien = spi_rd8(udc, MAX3420_REG_EPIEN);
epdis = spi_rd8(udc, MAX3420_REG_CLRTOGS);
if (todo == ENABLE) {
epdis &= ~BIT(ep->id + 4);
epien |= BIT(ep->id + 1);
} else {
epdis |= BIT(ep->id + 4);
epien &= ~BIT(ep->id + 1);
}
spi_wr8(udc, MAX3420_REG_CLRTOGS, epdis);
spi_wr8(udc, MAX3420_REG_EPIEN, epien);
return true;
}
static int spi_max3420_stall(struct max3420_ep *ep)
{
struct max3420_udc *udc = ep->udc;
unsigned long flags;
u8 epstalls;
int todo;
spin_lock_irqsave(&ep->lock, flags);
todo = ep->todo & STALL_EP;
ep->todo &= ~STALL_EP;
spin_unlock_irqrestore(&ep->lock, flags);
if (!todo || ep->id == 0)
return false;
epstalls = spi_rd8(udc, MAX3420_REG_EPSTALLS);
if (todo == STALL) {
ep->halted = 1;
epstalls |= BIT(ep->id + 1);
} else {
u8 clrtogs;
ep->halted = 0;
epstalls &= ~BIT(ep->id + 1);
clrtogs = spi_rd8(udc, MAX3420_REG_CLRTOGS);
clrtogs |= BIT(ep->id + 1);
spi_wr8(udc, MAX3420_REG_CLRTOGS, clrtogs);
}
spi_wr8(udc, MAX3420_REG_EPSTALLS, epstalls | ACKSTAT);
return true;
}
static int spi_max3420_rwkup(struct max3420_udc *udc)
{
unsigned long flags;
int wake_remote;
u8 usbctl;
spin_lock_irqsave(&udc->lock, flags);
wake_remote = udc->todo & REMOTE_WAKEUP;
udc->todo &= ~REMOTE_WAKEUP;
spin_unlock_irqrestore(&udc->lock, flags);
if (!wake_remote || !udc->suspended)
return false;
/* Set Remote-WkUp Signal*/
usbctl = spi_rd8(udc, MAX3420_REG_USBCTL);
usbctl |= SIGRWU;
spi_wr8(udc, MAX3420_REG_USBCTL, usbctl);
msleep_interruptible(5);
/* Clear Remote-WkUp Signal*/
usbctl = spi_rd8(udc, MAX3420_REG_USBCTL);
usbctl &= ~SIGRWU;
spi_wr8(udc, MAX3420_REG_USBCTL, usbctl);
udc->suspended = false;
return true;
}
static void max3420_nuke(struct max3420_ep *ep, int status);
static void __max3420_stop(struct max3420_udc *udc)
{
u8 val;
int i;
/* clear all pending requests */
for (i = 1; i < MAX3420_MAX_EPS; i++)
max3420_nuke(&udc->ep[i], -ECONNRESET);
/* Disable IRQ to CPU */
spi_wr8(udc, MAX3420_REG_CPUCTL, 0);
val = spi_rd8(udc, MAX3420_REG_USBCTL);
val |= PWRDOWN;
if (udc->is_selfpowered)
val &= ~HOSCSTEN;
else
val |= HOSCSTEN;
spi_wr8(udc, MAX3420_REG_USBCTL, val);
}
static void __max3420_start(struct max3420_udc *udc)
{
u8 val;
/* Need this delay if bus-powered,
* but even for self-powered it helps stability
*/
msleep_interruptible(250);
/* configure SPI */
spi_wr8(udc, MAX3420_REG_PINCTL, FDUPSPI);
/* Chip Reset */
spi_wr8(udc, MAX3420_REG_USBCTL, CHIPRES);
msleep_interruptible(5);
spi_wr8(udc, MAX3420_REG_USBCTL, 0);
/* Poll for OSC to stabilize */
while (1) {
val = spi_rd8(udc, MAX3420_REG_USBIRQ);
if (val & OSCOKIRQ)
break;
cond_resched();
}
/* Enable PULL-UP only when Vbus detected */
val = spi_rd8(udc, MAX3420_REG_USBCTL);
val |= VBGATE | CONNECT;
spi_wr8(udc, MAX3420_REG_USBCTL, val);
val = URESDNIRQ | URESIRQ;
if (udc->is_selfpowered)
val |= NOVBUSIRQ;
spi_wr8(udc, MAX3420_REG_USBIEN, val);
/* Enable only EP0 interrupts */
val = IN0BAVIRQ | OUT0DAVIRQ | SUDAVIRQ;
spi_wr8(udc, MAX3420_REG_EPIEN, val);
/* Enable IRQ to CPU */
spi_wr8(udc, MAX3420_REG_CPUCTL, IE);
}
static int max3420_start(struct max3420_udc *udc)
{
unsigned long flags;
int todo;
spin_lock_irqsave(&udc->lock, flags);
todo = udc->todo & UDC_START;
udc->todo &= ~UDC_START;
spin_unlock_irqrestore(&udc->lock, flags);
if (!todo)
return false;
if (udc->vbus_active && udc->softconnect)
__max3420_start(udc);
else
__max3420_stop(udc);
return true;
}
static irqreturn_t max3420_vbus_handler(int irq, void *dev_id)
{
struct max3420_udc *udc = dev_id;
unsigned long flags;
spin_lock_irqsave(&udc->lock, flags);
/* its a vbus change interrupt */
udc->vbus_active = !udc->vbus_active;
udc->todo |= UDC_START;
usb_udc_vbus_handler(&udc->gadget, udc->vbus_active);
usb_gadget_set_state(&udc->gadget, udc->vbus_active
? USB_STATE_POWERED : USB_STATE_NOTATTACHED);
spin_unlock_irqrestore(&udc->lock, flags);
if (udc->thread_task &&
udc->thread_task->state != TASK_RUNNING)
wake_up_process(udc->thread_task);
return IRQ_HANDLED;
}
static irqreturn_t max3420_irq_handler(int irq, void *dev_id)
{
struct max3420_udc *udc = dev_id;
struct spi_device *spi = udc->spi;
unsigned long flags;
spin_lock_irqsave(&udc->lock, flags);
if ((udc->todo & ENABLE_IRQ) == 0) {
disable_irq_nosync(spi->irq);
udc->todo |= ENABLE_IRQ;
}
spin_unlock_irqrestore(&udc->lock, flags);
if (udc->thread_task &&
udc->thread_task->state != TASK_RUNNING)
wake_up_process(udc->thread_task);
return IRQ_HANDLED;
}
static void max3420_getstatus(struct max3420_udc *udc)
{
struct max3420_ep *ep;
u16 status = 0;
switch (udc->setup.bRequestType & USB_RECIP_MASK) {
case USB_RECIP_DEVICE:
/* Get device status */
status = udc->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED;
status |= (udc->remote_wkp << USB_DEVICE_REMOTE_WAKEUP);
break;
case USB_RECIP_INTERFACE:
if (udc->driver->setup(&udc->gadget, &udc->setup) < 0)
goto stall;
break;
case USB_RECIP_ENDPOINT:
ep = &udc->ep[udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK];
if (udc->setup.wIndex & USB_DIR_IN) {
if (!ep->ep_usb.caps.dir_in)
goto stall;
} else {
if (!ep->ep_usb.caps.dir_out)
goto stall;
}
if (ep->halted)
status = 1 << USB_ENDPOINT_HALT;
break;
default:
goto stall;
}
status = cpu_to_le16(status);
spi_wr_buf(udc, MAX3420_REG_EP0FIFO, &status, 2);
spi_wr8_ack(udc, MAX3420_REG_EP0BC, 2, 1);
return;
stall:
dev_err(udc->dev, "Can't respond to getstatus request\n");
spi_wr8(udc, MAX3420_REG_EPSTALLS, STLEP0IN | STLEP0OUT | STLSTAT);
}
static void max3420_set_clear_feature(struct max3420_udc *udc)
{
struct max3420_ep *ep;
int set = udc->setup.bRequest == USB_REQ_SET_FEATURE;
unsigned long flags;
int id;
switch (udc->setup.bRequestType) {
case USB_RECIP_DEVICE:
if (udc->setup.wValue != USB_DEVICE_REMOTE_WAKEUP)
break;
if (udc->setup.bRequest == USB_REQ_SET_FEATURE)
udc->remote_wkp = 1;
else
udc->remote_wkp = 0;
return spi_ack_ctrl(udc);
case USB_RECIP_ENDPOINT:
if (udc->setup.wValue != USB_ENDPOINT_HALT)
break;
id = udc->setup.wIndex & USB_ENDPOINT_NUMBER_MASK;
ep = &udc->ep[id];
spin_lock_irqsave(&ep->lock, flags);
ep->todo &= ~STALL_EP;
if (set)
ep->todo |= STALL;
else
ep->todo |= UNSTALL;
spin_unlock_irqrestore(&ep->lock, flags);
spi_max3420_stall(ep);
return;
default:
break;
}
dev_err(udc->dev, "Can't respond to SET/CLEAR FEATURE\n");
spi_wr8(udc, MAX3420_REG_EPSTALLS, STLEP0IN | STLEP0OUT | STLSTAT);
}
static void max3420_handle_setup(struct max3420_udc *udc)
{
struct usb_ctrlrequest setup;
spi_rd_buf(udc, MAX3420_REG_SUDFIFO, (void *)&setup, 8);
udc->setup = setup;
udc->setup.wValue = cpu_to_le16(setup.wValue);
udc->setup.wIndex = cpu_to_le16(setup.wIndex);
udc->setup.wLength = cpu_to_le16(setup.wLength);
switch (udc->setup.bRequest) {
case USB_REQ_GET_STATUS:
/* Data+Status phase form udc */
if ((udc->setup.bRequestType &
(USB_DIR_IN | USB_TYPE_MASK)) !=
(USB_DIR_IN | USB_TYPE_STANDARD)) {
break;
}
return max3420_getstatus(udc);
case USB_REQ_SET_ADDRESS:
/* Status phase from udc */
if (udc->setup.bRequestType != (USB_DIR_OUT |
USB_TYPE_STANDARD | USB_RECIP_DEVICE)) {
break;
}
spi_rd8_ack(udc, MAX3420_REG_FNADDR, 1);
dev_dbg(udc->dev, "Assigned Address=%d\n", udc->setup.wValue);
return;
case USB_REQ_CLEAR_FEATURE:
case USB_REQ_SET_FEATURE:
/* Requests with no data phase, status phase from udc */
if ((udc->setup.bRequestType & USB_TYPE_MASK)
!= USB_TYPE_STANDARD)
break;
return max3420_set_clear_feature(udc);
default:
break;
}
if (udc->driver->setup(&udc->gadget, &setup) < 0) {
/* Stall EP0 */
spi_wr8(udc, MAX3420_REG_EPSTALLS,
STLEP0IN | STLEP0OUT | STLSTAT);
}
}
static void max3420_req_done(struct max3420_req *req, int status)
{
struct max3420_ep *ep = req->ep;
struct max3420_udc *udc = ep->udc;
if (req->usb_req.status == -EINPROGRESS)
req->usb_req.status = status;
else
status = req->usb_req.status;
if (status && status != -ESHUTDOWN)
dev_err(udc->dev, "%s done %p, status %d\n",
ep->ep_usb.name, req, status);
if (req->usb_req.complete)
req->usb_req.complete(&ep->ep_usb, &req->usb_req);
}
static int max3420_do_data(struct max3420_udc *udc, int ep_id, int in)
{
struct max3420_ep *ep = &udc->ep[ep_id];
struct max3420_req *req;
int done, length, psz;
void *buf;
if (list_empty(&ep->queue))
return false;
req = list_first_entry(&ep->queue, struct max3420_req, queue);
buf = req->usb_req.buf + req->usb_req.actual;
psz = ep->ep_usb.maxpacket;
length = req->usb_req.length - req->usb_req.actual;
length = min(length, psz);
if (length == 0) {
done = 1;
goto xfer_done;
}
done = 0;
if (in) {
prefetch(buf);
spi_wr_buf(udc, MAX3420_REG_EP0FIFO + ep_id, buf, length);
spi_wr8(udc, MAX3420_REG_EP0BC + ep_id, length);
if (length < psz)
done = 1;
} else {
psz = spi_rd8(udc, MAX3420_REG_EP0BC + ep_id);
length = min(length, psz);
prefetchw(buf);
spi_rd_buf(udc, MAX3420_REG_EP0FIFO + ep_id, buf, length);
if (length < ep->ep_usb.maxpacket)
done = 1;
}
req->usb_req.actual += length;
if (req->usb_req.actual == req->usb_req.length)
done = 1;
xfer_done:
if (done) {
unsigned long flags;
spin_lock_irqsave(&ep->lock, flags);
list_del_init(&req->queue);
spin_unlock_irqrestore(&ep->lock, flags);
if (ep_id == 0)
spi_ack_ctrl(udc);
max3420_req_done(req, 0);
}
return true;
}
static int max3420_handle_irqs(struct max3420_udc *udc)
{
u8 epien, epirq, usbirq, usbien, reg[4];
bool ret = false;
spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 4);
epirq = reg[0];
epien = reg[1];
usbirq = reg[2];
usbien = reg[3];
usbirq &= usbien;
epirq &= epien;
if (epirq & SUDAVIRQ) {
spi_wr8(udc, MAX3420_REG_EPIRQ, SUDAVIRQ);
max3420_handle_setup(udc);
return true;
}
if (usbirq & VBUSIRQ) {
spi_wr8(udc, MAX3420_REG_USBIRQ, VBUSIRQ);
dev_dbg(udc->dev, "Cable plugged in\n");
return true;
}
if (usbirq & NOVBUSIRQ) {
spi_wr8(udc, MAX3420_REG_USBIRQ, NOVBUSIRQ);
dev_dbg(udc->dev, "Cable pulled out\n");
return true;
}
if (usbirq & URESIRQ) {
spi_wr8(udc, MAX3420_REG_USBIRQ, URESIRQ);
dev_dbg(udc->dev, "USB Reset - Start\n");
return true;
}
if (usbirq & URESDNIRQ) {
spi_wr8(udc, MAX3420_REG_USBIRQ, URESDNIRQ);
dev_dbg(udc->dev, "USB Reset - END\n");
spi_wr8(udc, MAX3420_REG_USBIEN, URESDNIRQ | URESIRQ);
spi_wr8(udc, MAX3420_REG_EPIEN, SUDAVIRQ | IN0BAVIRQ
| OUT0DAVIRQ);
return true;
}
if (usbirq & SUSPIRQ) {
spi_wr8(udc, MAX3420_REG_USBIRQ, SUSPIRQ);
dev_dbg(udc->dev, "USB Suspend - Enter\n");
udc->suspended = true;
return true;
}
if (usbirq & BUSACTIRQ) {
spi_wr8(udc, MAX3420_REG_USBIRQ, BUSACTIRQ);
dev_dbg(udc->dev, "USB Suspend - Exit\n");
udc->suspended = false;
return true;
}
if (usbirq & RWUDNIRQ) {
spi_wr8(udc, MAX3420_REG_USBIRQ, RWUDNIRQ);
dev_dbg(udc->dev, "Asked Host to wakeup\n");
return true;
}
if (usbirq & OSCOKIRQ) {
spi_wr8(udc, MAX3420_REG_USBIRQ, OSCOKIRQ);
dev_dbg(udc->dev, "Osc stabilized, start work\n");
return true;
}
if (epirq & OUT0DAVIRQ && max3420_do_data(udc, 0, 0)) {
spi_wr8_ack(udc, MAX3420_REG_EPIRQ, OUT0DAVIRQ, 1);
ret = true;
}
if (epirq & IN0BAVIRQ && max3420_do_data(udc, 0, 1))
ret = true;
if (epirq & OUT1DAVIRQ && max3420_do_data(udc, 1, 0)) {
spi_wr8_ack(udc, MAX3420_REG_EPIRQ, OUT1DAVIRQ, 1);
ret = true;
}
if (epirq & IN2BAVIRQ && max3420_do_data(udc, 2, 1))
ret = true;
if (epirq & IN3BAVIRQ && max3420_do_data(udc, 3, 1))
ret = true;
return ret;
}
static int max3420_thread(void *dev_id)
{
struct max3420_udc *udc = dev_id;
struct spi_device *spi = udc->spi;
int i, loop_again = 1;
unsigned long flags;
while (!kthread_should_stop()) {
if (!loop_again) {
ktime_t kt = ns_to_ktime(1000 * 1000 * 250); /* 250ms */
set_current_state(TASK_INTERRUPTIBLE);
spin_lock_irqsave(&udc->lock, flags);
if (udc->todo & ENABLE_IRQ) {
enable_irq(spi->irq);
udc->todo &= ~ENABLE_IRQ;
}
spin_unlock_irqrestore(&udc->lock, flags);
schedule_hrtimeout(&kt, HRTIMER_MODE_REL);
}
loop_again = 0;
mutex_lock(&udc->spi_bus_mutex);
/* If bus-vbus_active and disconnected */
if (!udc->vbus_active || !udc->softconnect)
goto loop;
if (max3420_start(udc)) {
loop_again = 1;
goto loop;
}
if (max3420_handle_irqs(udc)) {
loop_again = 1;
goto loop;
}
if (spi_max3420_rwkup(udc)) {
loop_again = 1;
goto loop;
}
max3420_do_data(udc, 0, 1); /* get done with the EP0 ZLP */
for (i = 1; i < MAX3420_MAX_EPS; i++) {
struct max3420_ep *ep = &udc->ep[i];
if (spi_max3420_enable(ep))
loop_again = 1;
if (spi_max3420_stall(ep))
loop_again = 1;
}
loop:
mutex_unlock(&udc->spi_bus_mutex);
}
set_current_state(TASK_RUNNING);
dev_info(udc->dev, "SPI thread exiting\n");
return 0;
}
static int max3420_ep_set_halt(struct usb_ep *_ep, int stall)
{
struct max3420_ep *ep = to_max3420_ep(_ep);
struct max3420_udc *udc = ep->udc;
unsigned long flags;
spin_lock_irqsave(&ep->lock, flags);
ep->todo &= ~STALL_EP;
if (stall)
ep->todo |= STALL;
else
ep->todo |= UNSTALL;
spin_unlock_irqrestore(&ep->lock, flags);
wake_up_process(udc->thread_task);
dev_dbg(udc->dev, "%sStall %s\n", stall ? "" : "Un", ep->name);
return 0;
}
static int __max3420_ep_enable(struct max3420_ep *ep,
const struct usb_endpoint_descriptor *desc)
{
unsigned int maxp = usb_endpoint_maxp(desc);
unsigned long flags;
spin_lock_irqsave(&ep->lock, flags);
ep->ep_usb.desc = desc;
ep->ep_usb.maxpacket = maxp;
ep->todo &= ~ENABLE_EP;
ep->todo |= ENABLE;
spin_unlock_irqrestore(&ep->lock, flags);
return 0;
}
static int max3420_ep_enable(struct usb_ep *_ep,
const struct usb_endpoint_descriptor *desc)
{
struct max3420_ep *ep = to_max3420_ep(_ep);
struct max3420_udc *udc = ep->udc;
__max3420_ep_enable(ep, desc);
wake_up_process(udc->thread_task);
return 0;
}
static void max3420_nuke(struct max3420_ep *ep, int status)
{
struct max3420_req *req, *r;
unsigned long flags;
spin_lock_irqsave(&ep->lock, flags);
list_for_each_entry_safe(req, r, &ep->queue, queue) {
list_del_init(&req->queue);
spin_unlock_irqrestore(&ep->lock, flags);
max3420_req_done(req, status);
spin_lock_irqsave(&ep->lock, flags);
}
spin_unlock_irqrestore(&ep->lock, flags);
}
static void __max3420_ep_disable(struct max3420_ep *ep)
{
struct max3420_udc *udc = ep->udc;
unsigned long flags;
spin_lock_irqsave(&ep->lock, flags);
ep->ep_usb.desc = NULL;
ep->todo &= ~ENABLE_EP;
ep->todo |= DISABLE;
spin_unlock_irqrestore(&ep->lock, flags);
dev_dbg(udc->dev, "Disabled %s\n", ep->name);
}
static int max3420_ep_disable(struct usb_ep *_ep)
{
struct max3420_ep *ep = to_max3420_ep(_ep);
struct max3420_udc *udc = ep->udc;
max3420_nuke(ep, -ESHUTDOWN);
__max3420_ep_disable(ep);
wake_up_process(udc->thread_task);
return 0;
}
static struct usb_request *max3420_alloc_request(struct usb_ep *_ep,
gfp_t gfp_flags)
{
struct max3420_ep *ep = to_max3420_ep(_ep);
struct max3420_req *req;
req = kzalloc(sizeof(*req), gfp_flags);
if (!req)
return NULL;
req->ep = ep;
return &req->usb_req;
}
static void max3420_free_request(struct usb_ep *_ep, struct usb_request *_req)
{
kfree(to_max3420_req(_req));
}
static int max3420_ep_queue(struct usb_ep *_ep, struct usb_request *_req,
gfp_t ignored)
{
struct max3420_req *req = to_max3420_req(_req);
struct max3420_ep *ep = to_max3420_ep(_ep);
struct max3420_udc *udc = ep->udc;
unsigned long flags;
_req->status = -EINPROGRESS;
_req->actual = 0;
spin_lock_irqsave(&ep->lock, flags);
list_add_tail(&req->queue, &ep->queue);
spin_unlock_irqrestore(&ep->lock, flags);
wake_up_process(udc->thread_task);
return 0;
}
static int max3420_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
{
struct max3420_req *t, *req = to_max3420_req(_req);
struct max3420_ep *ep = to_max3420_ep(_ep);
unsigned long flags;
spin_lock_irqsave(&ep->lock, flags);
/* Pluck the descriptor from queue */
list_for_each_entry(t, &ep->queue, queue)
if (t == req) {
list_del_init(&req->queue);
break;
}
spin_unlock_irqrestore(&ep->lock, flags);
if (t == req)
max3420_req_done(req, -ECONNRESET);
return 0;
}
static const struct usb_ep_ops max3420_ep_ops = {
.enable = max3420_ep_enable,
.disable = max3420_ep_disable,
.alloc_request = max3420_alloc_request,
.free_request = max3420_free_request,
.queue = max3420_ep_queue,
.dequeue = max3420_ep_dequeue,
.set_halt = max3420_ep_set_halt,
};
static int max3420_wakeup(struct usb_gadget *gadget)
{
struct max3420_udc *udc = to_udc(gadget);
unsigned long flags;
int ret = -EINVAL;
spin_lock_irqsave(&udc->lock, flags);
/* Only if wakeup allowed by host */
if (udc->remote_wkp) {
udc->todo |= REMOTE_WAKEUP;
ret = 0;
}
spin_unlock_irqrestore(&udc->lock, flags);
if (udc->thread_task &&
udc->thread_task->state != TASK_RUNNING)
wake_up_process(udc->thread_task);
return ret;
}
static int max3420_udc_start(struct usb_gadget *gadget,
struct usb_gadget_driver *driver)
{
struct max3420_udc *udc = to_udc(gadget);
unsigned long flags;
spin_lock_irqsave(&udc->lock, flags);
/* hook up the driver */
driver->driver.bus = NULL;
udc->driver = driver;
udc->gadget.speed = USB_SPEED_FULL;
udc->gadget.is_selfpowered = udc->is_selfpowered;
udc->remote_wkp = 0;
udc->softconnect = true;
udc->todo |= UDC_START;
spin_unlock_irqrestore(&udc->lock, flags);
if (udc->thread_task &&
udc->thread_task->state != TASK_RUNNING)
wake_up_process(udc->thread_task);
return 0;
}
static int max3420_udc_stop(struct usb_gadget *gadget)
{
struct max3420_udc *udc = to_udc(gadget);
unsigned long flags;
spin_lock_irqsave(&udc->lock, flags);
udc->is_selfpowered = udc->gadget.is_selfpowered;
udc->gadget.speed = USB_SPEED_UNKNOWN;
udc->driver = NULL;
udc->softconnect = false;
udc->todo |= UDC_START;
spin_unlock_irqrestore(&udc->lock, flags);
if (udc->thread_task &&
udc->thread_task->state != TASK_RUNNING)
wake_up_process(udc->thread_task);
return 0;
}
static const struct usb_gadget_ops max3420_udc_ops = {
.udc_start = max3420_udc_start,
.udc_stop = max3420_udc_stop,
.wakeup = max3420_wakeup,
};
static void max3420_eps_init(struct max3420_udc *udc)
{
int idx;
INIT_LIST_HEAD(&udc->gadget.ep_list);
for (idx = 0; idx < MAX3420_MAX_EPS; idx++) {
struct max3420_ep *ep = &udc->ep[idx];
spin_lock_init(&ep->lock);
INIT_LIST_HEAD(&ep->queue);
ep->udc = udc;
ep->id = idx;
ep->halted = 0;
ep->maxpacket = 0;
ep->ep_usb.name = ep->name;
ep->ep_usb.ops = &max3420_ep_ops;
usb_ep_set_maxpacket_limit(&ep->ep_usb, MAX3420_EP_MAX_PACKET);
if (idx == 0) { /* For EP0 */
ep->ep_usb.desc = &ep0_desc;
ep->ep_usb.maxpacket = usb_endpoint_maxp(&ep0_desc);
ep->ep_usb.caps.type_control = true;
ep->ep_usb.caps.dir_in = true;
ep->ep_usb.caps.dir_out = true;
snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep0");
continue;
}
if (idx == 1) { /* EP1 is OUT */
ep->ep_usb.caps.dir_in = false;
ep->ep_usb.caps.dir_out = true;
snprintf(ep->name, MAX3420_EPNAME_SIZE, "ep1-bulk-out");
} else { /* EP2 & EP3 are IN */
ep->ep_usb.caps.dir_in = true;
ep->ep_usb.caps.dir_out = false;
snprintf(ep->name, MAX3420_EPNAME_SIZE,
"ep%d-bulk-in", idx);
}
ep->ep_usb.caps.type_iso = false;
ep->ep_usb.caps.type_int = false;
ep->ep_usb.caps.type_bulk = true;
list_add_tail(&ep->ep_usb.ep_list,
&udc->gadget.ep_list);
}
}
static int max3420_probe(struct spi_device *spi)
{
struct max3420_udc *udc;
int err, irq;
u8 reg[8];
if (spi->master->flags & SPI_MASTER_HALF_DUPLEX) {
dev_err(&spi->dev, "UDC needs full duplex to work\n");
return -EINVAL;
}
spi->mode = SPI_MODE_3;
spi->bits_per_word = 8;
err = spi_setup(spi);
if (err) {
dev_err(&spi->dev, "Unable to setup SPI bus\n");
return -EFAULT;
}
udc = devm_kzalloc(&spi->dev, sizeof(*udc), GFP_KERNEL);
if (!udc)
return -ENOMEM;
udc->spi = spi;
udc->remote_wkp = 0;
/* Setup gadget structure */
udc->gadget.ops = &max3420_udc_ops;
udc->gadget.max_speed = USB_SPEED_FULL;
udc->gadget.speed = USB_SPEED_UNKNOWN;
udc->gadget.ep0 = &udc->ep[0].ep_usb;
udc->gadget.name = driver_name;
spin_lock_init(&udc->lock);
mutex_init(&udc->spi_bus_mutex);
udc->ep0req.ep = &udc->ep[0];
udc->ep0req.usb_req.buf = udc->ep0buf;
INIT_LIST_HEAD(&udc->ep0req.queue);
/* setup Endpoints */
max3420_eps_init(udc);
/* configure SPI */
spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8);
spi_wr8(udc, MAX3420_REG_PINCTL, FDUPSPI);
err = usb_add_gadget_udc(&spi->dev, &udc->gadget);
if (err)
return err;
udc->dev = &udc->gadget.dev;
spi_set_drvdata(spi, udc);
irq = of_irq_get_byname(spi->dev.of_node, "udc");
err = devm_request_irq(&spi->dev, irq, max3420_irq_handler, 0,
"max3420", udc);
if (err < 0)
return err;
udc->thread_task = kthread_create(max3420_thread, udc,
"max3420-thread");
if (IS_ERR(udc->thread_task))
return PTR_ERR(udc->thread_task);
irq = of_irq_get_byname(spi->dev.of_node, "vbus");
if (irq <= 0) { /* no vbus irq implies self-powered design */
udc->is_selfpowered = 1;
udc->vbus_active = true;
udc->todo |= UDC_START;
usb_udc_vbus_handler(&udc->gadget, udc->vbus_active);
usb_gadget_set_state(&udc->gadget, USB_STATE_POWERED);
max3420_start(udc);
} else {
udc->is_selfpowered = 0;
/* Detect current vbus status */
spi_rd_buf(udc, MAX3420_REG_EPIRQ, reg, 8);
if (reg[7] != 0xff)
udc->vbus_active = true;
err = devm_request_irq(&spi->dev, irq,
max3420_vbus_handler, 0, "vbus", udc);
if (err < 0)
return err;
}
return 0;
}
static int max3420_remove(struct spi_device *spi)
{
struct max3420_udc *udc = spi_get_drvdata(spi);
unsigned long flags;
usb_del_gadget_udc(&udc->gadget);
spin_lock_irqsave(&udc->lock, flags);
kthread_stop(udc->thread_task);
spin_unlock_irqrestore(&udc->lock, flags);
return 0;
}
static const struct of_device_id max3420_udc_of_match[] = {
{ .compatible = "maxim,max3420-udc"},
{ .compatible = "maxim,max3421-udc"},
{},
};
MODULE_DEVICE_TABLE(of, max3420_udc_of_match);
static struct spi_driver max3420_driver = {
.driver = {
.name = "max3420-udc",
.of_match_table = of_match_ptr(max3420_udc_of_match),
},
.probe = max3420_probe,
.remove = max3420_remove,
};
module_spi_driver(max3420_driver);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_AUTHOR("Jassi Brar <jaswinder.singh@linaro.org>");
MODULE_LICENSE("GPL");
Reference in New Issue View Git Blame Copy Permalink