1/*
   2 * at91_udc -- driver for at91-series USB peripheral controller
   3 *
   4 * Copyright (C) 2004 by Thomas Rathbone
   5 * Copyright (C) 2005 by HP Labs
   6 * Copyright (C) 2005 by David Brownell
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License as published by
  10 * the Free Software Foundation; either version 2 of the License, or
  11 * (at your option) any later version.
 
 
 
 
 
 
 
 
 
 
  12 */
  13
  14#undef	VERBOSE_DEBUG
  15#undef	PACKET_TRACE
  16
  17#include <linux/kernel.h>
  18#include <linux/module.h>
  19#include <linux/platform_device.h>
  20#include <linux/delay.h>
  21#include <linux/ioport.h>
  22#include <linux/slab.h>
  23#include <linux/errno.h>
 
  24#include <linux/list.h>
  25#include <linux/interrupt.h>
  26#include <linux/proc_fs.h>
  27#include <linux/prefetch.h>
  28#include <linux/clk.h>
  29#include <linux/usb/ch9.h>
  30#include <linux/usb/gadget.h>
  31#include <linux/of.h>
  32#include <linux/of_gpio.h>
  33#include <linux/platform_data/atmel.h>
  34
  35#include <asm/byteorder.h>
  36#include <mach/hardware.h>
  37#include <asm/io.h>
  38#include <asm/irq.h>
 
  39#include <asm/gpio.h>
  40
 
  41#include <mach/cpu.h>
  42#include <mach/at91sam9261_matrix.h>
  43#include <mach/at91_matrix.h>
  44
  45#include "at91_udc.h"
  46
  47
  48/*
  49 * This controller is simple and PIO-only.  It's used in many AT91-series
  50 * full speed USB controllers, including the at91rm9200 (arm920T, with MMU),
  51 * at91sam926x (arm926ejs, with MMU), and several no-mmu versions.
  52 *
  53 * This driver expects the board has been wired with two GPIOs supporting
  54 * a VBUS sensing IRQ, and a D+ pullup.  (They may be omitted, but the
  55 * testing hasn't covered such cases.)
  56 *
  57 * The pullup is most important (so it's integrated on sam926x parts).  It
  58 * provides software control over whether the host enumerates the device.
  59 *
  60 * The VBUS sensing helps during enumeration, and allows both USB clocks
  61 * (and the transceiver) to stay gated off until they're necessary, saving
  62 * power.  During USB suspend, the 48 MHz clock is gated off in hardware;
  63 * it may also be gated off by software during some Linux sleep states.
  64 */
  65
  66#define	DRIVER_VERSION	"3 May 2006"
  67
  68static const char driver_name [] = "at91_udc";
  69static const char ep0name[] = "ep0";
  70
  71#define VBUS_POLL_TIMEOUT	msecs_to_jiffies(1000)
  72
  73#define at91_udp_read(udc, reg) \
  74	__raw_readl((udc)->udp_baseaddr + (reg))
  75#define at91_udp_write(udc, reg, val) \
  76	__raw_writel((val), (udc)->udp_baseaddr + (reg))
  77
  78/*-------------------------------------------------------------------------*/
  79
  80#ifdef CONFIG_USB_GADGET_DEBUG_FILES
  81
  82#include <linux/seq_file.h>
  83
  84static const char debug_filename[] = "driver/udc";
  85
  86#define FOURBITS "%s%s%s%s"
  87#define EIGHTBITS FOURBITS FOURBITS
  88
  89static void proc_ep_show(struct seq_file *s, struct at91_ep *ep)
  90{
  91	static char		*types[] = {
  92		"control", "out-iso", "out-bulk", "out-int",
  93		"BOGUS",   "in-iso",  "in-bulk",  "in-int"};
  94
  95	u32			csr;
  96	struct at91_request	*req;
  97	unsigned long	flags;
  98	struct at91_udc	*udc = ep->udc;
  99
 100	spin_lock_irqsave(&udc->lock, flags);
 101
 102	csr = __raw_readl(ep->creg);
 103
 104	/* NOTE:  not collecting per-endpoint irq statistics... */
 105
 106	seq_printf(s, "\n");
 107	seq_printf(s, "%s, maxpacket %d %s%s %s%s\n",
 108			ep->ep.name, ep->ep.maxpacket,
 109			ep->is_in ? "in" : "out",
 110			ep->is_iso ? " iso" : "",
 111			ep->is_pingpong
 112				? (ep->fifo_bank ? "pong" : "ping")
 113				: "",
 114			ep->stopped ? " stopped" : "");
 115	seq_printf(s, "csr %08x rxbytes=%d %s %s %s" EIGHTBITS "\n",
 116		csr,
 117		(csr & 0x07ff0000) >> 16,
 118		(csr & (1 << 15)) ? "enabled" : "disabled",
 119		(csr & (1 << 11)) ? "DATA1" : "DATA0",
 120		types[(csr & 0x700) >> 8],
 121
 122		/* iff type is control then print current direction */
 123		(!(csr & 0x700))
 124			? ((csr & (1 << 7)) ? " IN" : " OUT")
 125			: "",
 126		(csr & (1 << 6)) ? " rxdatabk1" : "",
 127		(csr & (1 << 5)) ? " forcestall" : "",
 128		(csr & (1 << 4)) ? " txpktrdy" : "",
 129
 130		(csr & (1 << 3)) ? " stallsent" : "",
 131		(csr & (1 << 2)) ? " rxsetup" : "",
 132		(csr & (1 << 1)) ? " rxdatabk0" : "",
 133		(csr & (1 << 0)) ? " txcomp" : "");
 134	if (list_empty (&ep->queue))
 135		seq_printf(s, "\t(queue empty)\n");
 136
 137	else list_for_each_entry (req, &ep->queue, queue) {
 138		unsigned	length = req->req.actual;
 139
 140		seq_printf(s, "\treq %p len %d/%d buf %p\n",
 141				&req->req, length,
 142				req->req.length, req->req.buf);
 143	}
 144	spin_unlock_irqrestore(&udc->lock, flags);
 145}
 146
 147static void proc_irq_show(struct seq_file *s, const char *label, u32 mask)
 148{
 149	int i;
 150
 151	seq_printf(s, "%s %04x:%s%s" FOURBITS, label, mask,
 152		(mask & (1 << 13)) ? " wakeup" : "",
 153		(mask & (1 << 12)) ? " endbusres" : "",
 154
 155		(mask & (1 << 11)) ? " sofint" : "",
 156		(mask & (1 << 10)) ? " extrsm" : "",
 157		(mask & (1 << 9)) ? " rxrsm" : "",
 158		(mask & (1 << 8)) ? " rxsusp" : "");
 159	for (i = 0; i < 8; i++) {
 160		if (mask & (1 << i))
 161			seq_printf(s, " ep%d", i);
 162	}
 163	seq_printf(s, "\n");
 164}
 165
 166static int proc_udc_show(struct seq_file *s, void *unused)
 167{
 168	struct at91_udc	*udc = s->private;
 169	struct at91_ep	*ep;
 170	u32		tmp;
 171
 172	seq_printf(s, "%s: version %s\n", driver_name, DRIVER_VERSION);
 173
 174	seq_printf(s, "vbus %s, pullup %s, %s powered%s, gadget %s\n\n",
 175		udc->vbus ? "present" : "off",
 176		udc->enabled
 177			? (udc->vbus ? "active" : "enabled")
 178			: "disabled",
 179		udc->selfpowered ? "self" : "VBUS",
 180		udc->suspended ? ", suspended" : "",
 181		udc->driver ? udc->driver->driver.name : "(none)");
 182
 183	/* don't access registers when interface isn't clocked */
 184	if (!udc->clocked) {
 185		seq_printf(s, "(not clocked)\n");
 186		return 0;
 187	}
 188
 189	tmp = at91_udp_read(udc, AT91_UDP_FRM_NUM);
 190	seq_printf(s, "frame %05x:%s%s frame=%d\n", tmp,
 191		(tmp & AT91_UDP_FRM_OK) ? " ok" : "",
 192		(tmp & AT91_UDP_FRM_ERR) ? " err" : "",
 193		(tmp & AT91_UDP_NUM));
 194
 195	tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
 196	seq_printf(s, "glbstate %02x:%s" FOURBITS "\n", tmp,
 197		(tmp & AT91_UDP_RMWUPE) ? " rmwupe" : "",
 198		(tmp & AT91_UDP_RSMINPR) ? " rsminpr" : "",
 199		(tmp & AT91_UDP_ESR) ? " esr" : "",
 200		(tmp & AT91_UDP_CONFG) ? " confg" : "",
 201		(tmp & AT91_UDP_FADDEN) ? " fadden" : "");
 202
 203	tmp = at91_udp_read(udc, AT91_UDP_FADDR);
 204	seq_printf(s, "faddr   %03x:%s fadd=%d\n", tmp,
 205		(tmp & AT91_UDP_FEN) ? " fen" : "",
 206		(tmp & AT91_UDP_FADD));
 207
 208	proc_irq_show(s, "imr   ", at91_udp_read(udc, AT91_UDP_IMR));
 209	proc_irq_show(s, "isr   ", at91_udp_read(udc, AT91_UDP_ISR));
 210
 211	if (udc->enabled && udc->vbus) {
 212		proc_ep_show(s, &udc->ep[0]);
 213		list_for_each_entry (ep, &udc->gadget.ep_list, ep.ep_list) {
 214			if (ep->ep.desc)
 215				proc_ep_show(s, ep);
 216		}
 217	}
 218	return 0;
 219}
 220
 221static int proc_udc_open(struct inode *inode, struct file *file)
 222{
 223	return single_open(file, proc_udc_show, PDE_DATA(inode));
 224}
 225
 226static const struct file_operations proc_ops = {
 227	.owner		= THIS_MODULE,
 228	.open		= proc_udc_open,
 229	.read		= seq_read,
 230	.llseek		= seq_lseek,
 231	.release	= single_release,
 232};
 233
 234static void create_debug_file(struct at91_udc *udc)
 235{
 236	udc->pde = proc_create_data(debug_filename, 0, NULL, &proc_ops, udc);
 237}
 238
 239static void remove_debug_file(struct at91_udc *udc)
 240{
 241	if (udc->pde)
 242		remove_proc_entry(debug_filename, NULL);
 243}
 244
 245#else
 246
 247static inline void create_debug_file(struct at91_udc *udc) {}
 248static inline void remove_debug_file(struct at91_udc *udc) {}
 249
 250#endif
 251
 252
 253/*-------------------------------------------------------------------------*/
 254
 255static void done(struct at91_ep *ep, struct at91_request *req, int status)
 256{
 257	unsigned	stopped = ep->stopped;
 258	struct at91_udc	*udc = ep->udc;
 259
 260	list_del_init(&req->queue);
 261	if (req->req.status == -EINPROGRESS)
 262		req->req.status = status;
 263	else
 264		status = req->req.status;
 265	if (status && status != -ESHUTDOWN)
 266		VDBG("%s done %p, status %d\n", ep->ep.name, req, status);
 267
 268	ep->stopped = 1;
 269	spin_unlock(&udc->lock);
 270	req->req.complete(&ep->ep, &req->req);
 271	spin_lock(&udc->lock);
 272	ep->stopped = stopped;
 273
 274	/* ep0 is always ready; other endpoints need a non-empty queue */
 275	if (list_empty(&ep->queue) && ep->int_mask != (1 << 0))
 276		at91_udp_write(udc, AT91_UDP_IDR, ep->int_mask);
 277}
 278
 279/*-------------------------------------------------------------------------*/
 280
 281/* bits indicating OUT fifo has data ready */
 282#define	RX_DATA_READY	(AT91_UDP_RX_DATA_BK0 | AT91_UDP_RX_DATA_BK1)
 283
 284/*
 285 * Endpoint FIFO CSR bits have a mix of bits, making it unsafe to just write
 286 * back most of the value you just read (because of side effects, including
 287 * bits that may change after reading and before writing).
 288 *
 289 * Except when changing a specific bit, always write values which:
 290 *  - clear SET_FX bits (setting them could change something)
 291 *  - set CLR_FX bits (clearing them could change something)
 292 *
 293 * There are also state bits like FORCESTALL, EPEDS, DIR, and EPTYPE
 294 * that shouldn't normally be changed.
 295 *
 296 * NOTE at91sam9260 docs mention synch between UDPCK and MCK clock domains,
 297 * implying a need to wait for one write to complete (test relevant bits)
 298 * before starting the next write.  This shouldn't be an issue given how
 299 * infrequently we write, except maybe for write-then-read idioms.
 300 */
 301#define	SET_FX	(AT91_UDP_TXPKTRDY)
 302#define	CLR_FX	(RX_DATA_READY | AT91_UDP_RXSETUP \
 303		| AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)
 304
 305/* pull OUT packet data from the endpoint's fifo */
 306static int read_fifo (struct at91_ep *ep, struct at91_request *req)
 307{
 308	u32 __iomem	*creg = ep->creg;
 309	u8 __iomem	*dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
 310	u32		csr;
 311	u8		*buf;
 312	unsigned int	count, bufferspace, is_done;
 313
 314	buf = req->req.buf + req->req.actual;
 315	bufferspace = req->req.length - req->req.actual;
 316
 317	/*
 318	 * there might be nothing to read if ep_queue() calls us,
 319	 * or if we already emptied both pingpong buffers
 320	 */
 321rescan:
 322	csr = __raw_readl(creg);
 323	if ((csr & RX_DATA_READY) == 0)
 324		return 0;
 325
 326	count = (csr & AT91_UDP_RXBYTECNT) >> 16;
 327	if (count > ep->ep.maxpacket)
 328		count = ep->ep.maxpacket;
 329	if (count > bufferspace) {
 330		DBG("%s buffer overflow\n", ep->ep.name);
 331		req->req.status = -EOVERFLOW;
 332		count = bufferspace;
 333	}
 334	__raw_readsb(dreg, buf, count);
 335
 336	/* release and swap pingpong mem bank */
 337	csr |= CLR_FX;
 338	if (ep->is_pingpong) {
 339		if (ep->fifo_bank == 0) {
 340			csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
 341			ep->fifo_bank = 1;
 342		} else {
 343			csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK1);
 344			ep->fifo_bank = 0;
 345		}
 346	} else
 347		csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
 348	__raw_writel(csr, creg);
 349
 350	req->req.actual += count;
 351	is_done = (count < ep->ep.maxpacket);
 352	if (count == bufferspace)
 353		is_done = 1;
 354
 355	PACKET("%s %p out/%d%s\n", ep->ep.name, &req->req, count,
 356			is_done ? " (done)" : "");
 357
 358	/*
 359	 * avoid extra trips through IRQ logic for packets already in
 360	 * the fifo ... maybe preventing an extra (expensive) OUT-NAK
 361	 */
 362	if (is_done)
 363		done(ep, req, 0);
 364	else if (ep->is_pingpong) {
 365		/*
 366		 * One dummy read to delay the code because of a HW glitch:
 367		 * CSR returns bad RXCOUNT when read too soon after updating
 368		 * RX_DATA_BK flags.
 369		 */
 370		csr = __raw_readl(creg);
 371
 372		bufferspace -= count;
 373		buf += count;
 374		goto rescan;
 375	}
 376
 377	return is_done;
 378}
 379
 380/* load fifo for an IN packet */
 381static int write_fifo(struct at91_ep *ep, struct at91_request *req)
 382{
 383	u32 __iomem	*creg = ep->creg;
 384	u32		csr = __raw_readl(creg);
 385	u8 __iomem	*dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
 386	unsigned	total, count, is_last;
 387	u8		*buf;
 388
 389	/*
 390	 * TODO: allow for writing two packets to the fifo ... that'll
 391	 * reduce the amount of IN-NAKing, but probably won't affect
 392	 * throughput much.  (Unlike preventing OUT-NAKing!)
 393	 */
 394
 395	/*
 396	 * If ep_queue() calls us, the queue is empty and possibly in
 397	 * odd states like TXCOMP not yet cleared (we do it, saving at
 398	 * least one IRQ) or the fifo not yet being free.  Those aren't
 399	 * issues normally (IRQ handler fast path).
 400	 */
 401	if (unlikely(csr & (AT91_UDP_TXCOMP | AT91_UDP_TXPKTRDY))) {
 402		if (csr & AT91_UDP_TXCOMP) {
 403			csr |= CLR_FX;
 404			csr &= ~(SET_FX | AT91_UDP_TXCOMP);
 405			__raw_writel(csr, creg);
 406			csr = __raw_readl(creg);
 407		}
 408		if (csr & AT91_UDP_TXPKTRDY)
 409			return 0;
 410	}
 411
 412	buf = req->req.buf + req->req.actual;
 413	prefetch(buf);
 414	total = req->req.length - req->req.actual;
 415	if (ep->ep.maxpacket < total) {
 416		count = ep->ep.maxpacket;
 417		is_last = 0;
 418	} else {
 419		count = total;
 420		is_last = (count < ep->ep.maxpacket) || !req->req.zero;
 421	}
 422
 423	/*
 424	 * Write the packet, maybe it's a ZLP.
 425	 *
 426	 * NOTE:  incrementing req->actual before we receive the ACK means
 427	 * gadget driver IN bytecounts can be wrong in fault cases.  That's
 428	 * fixable with PIO drivers like this one (save "count" here, and
 429	 * do the increment later on TX irq), but not for most DMA hardware.
 430	 *
 431	 * So all gadget drivers must accept that potential error.  Some
 432	 * hardware supports precise fifo status reporting, letting them
 433	 * recover when the actual bytecount matters (e.g. for USB Test
 434	 * and Measurement Class devices).
 435	 */
 436	__raw_writesb(dreg, buf, count);
 437	csr &= ~SET_FX;
 438	csr |= CLR_FX | AT91_UDP_TXPKTRDY;
 439	__raw_writel(csr, creg);
 440	req->req.actual += count;
 441
 442	PACKET("%s %p in/%d%s\n", ep->ep.name, &req->req, count,
 443			is_last ? " (done)" : "");
 444	if (is_last)
 445		done(ep, req, 0);
 446	return is_last;
 447}
 448
 449static void nuke(struct at91_ep *ep, int status)
 450{
 451	struct at91_request *req;
 452
 453	/* terminate any request in the queue */
 454	ep->stopped = 1;
 455	if (list_empty(&ep->queue))
 456		return;
 457
 458	VDBG("%s %s\n", __func__, ep->ep.name);
 459	while (!list_empty(&ep->queue)) {
 460		req = list_entry(ep->queue.next, struct at91_request, queue);
 461		done(ep, req, status);
 462	}
 463}
 464
 465/*-------------------------------------------------------------------------*/
 466
 467static int at91_ep_enable(struct usb_ep *_ep,
 468				const struct usb_endpoint_descriptor *desc)
 469{
 470	struct at91_ep	*ep = container_of(_ep, struct at91_ep, ep);
 471	struct at91_udc *udc;
 472	u16		maxpacket;
 473	u32		tmp;
 474	unsigned long	flags;
 475
 476	if (!_ep || !ep
 477			|| !desc || _ep->name == ep0name
 
 478			|| desc->bDescriptorType != USB_DT_ENDPOINT
 479			|| (maxpacket = usb_endpoint_maxp(desc)) == 0
 480			|| maxpacket > ep->maxpacket) {
 481		DBG("bad ep or descriptor\n");
 482		return -EINVAL;
 483	}
 484
 485	udc = ep->udc;
 486	if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
 487		DBG("bogus device state\n");
 488		return -ESHUTDOWN;
 489	}
 490
 491	tmp = usb_endpoint_type(desc);
 492	switch (tmp) {
 493	case USB_ENDPOINT_XFER_CONTROL:
 494		DBG("only one control endpoint\n");
 495		return -EINVAL;
 496	case USB_ENDPOINT_XFER_INT:
 497		if (maxpacket > 64)
 498			goto bogus_max;
 499		break;
 500	case USB_ENDPOINT_XFER_BULK:
 501		switch (maxpacket) {
 502		case 8:
 503		case 16:
 504		case 32:
 505		case 64:
 506			goto ok;
 507		}
 508bogus_max:
 509		DBG("bogus maxpacket %d\n", maxpacket);
 510		return -EINVAL;
 511	case USB_ENDPOINT_XFER_ISOC:
 512		if (!ep->is_pingpong) {
 513			DBG("iso requires double buffering\n");
 514			return -EINVAL;
 515		}
 516		break;
 517	}
 518
 519ok:
 520	spin_lock_irqsave(&udc->lock, flags);
 521
 522	/* initialize endpoint to match this descriptor */
 523	ep->is_in = usb_endpoint_dir_in(desc);
 524	ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC);
 525	ep->stopped = 0;
 526	if (ep->is_in)
 527		tmp |= 0x04;
 528	tmp <<= 8;
 529	tmp |= AT91_UDP_EPEDS;
 530	__raw_writel(tmp, ep->creg);
 531
 
 532	ep->ep.maxpacket = maxpacket;
 533
 534	/*
 535	 * reset/init endpoint fifo.  NOTE:  leaves fifo_bank alone,
 536	 * since endpoint resets don't reset hw pingpong state.
 537	 */
 538	at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
 539	at91_udp_write(udc, AT91_UDP_RST_EP, 0);
 540
 541	spin_unlock_irqrestore(&udc->lock, flags);
 542	return 0;
 543}
 544
 545static int at91_ep_disable (struct usb_ep * _ep)
 546{
 547	struct at91_ep	*ep = container_of(_ep, struct at91_ep, ep);
 548	struct at91_udc	*udc = ep->udc;
 549	unsigned long	flags;
 550
 551	if (ep == &ep->udc->ep[0])
 552		return -EINVAL;
 553
 554	spin_lock_irqsave(&udc->lock, flags);
 555
 556	nuke(ep, -ESHUTDOWN);
 557
 558	/* restore the endpoint's pristine config */
 559	ep->ep.desc = NULL;
 560	ep->ep.maxpacket = ep->maxpacket;
 561
 562	/* reset fifos and endpoint */
 563	if (ep->udc->clocked) {
 564		at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
 565		at91_udp_write(udc, AT91_UDP_RST_EP, 0);
 566		__raw_writel(0, ep->creg);
 567	}
 568
 569	spin_unlock_irqrestore(&udc->lock, flags);
 570	return 0;
 571}
 572
 573/*
 574 * this is a PIO-only driver, so there's nothing
 575 * interesting for request or buffer allocation.
 576 */
 577
 578static struct usb_request *
 579at91_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
 580{
 581	struct at91_request *req;
 582
 583	req = kzalloc(sizeof (struct at91_request), gfp_flags);
 584	if (!req)
 585		return NULL;
 586
 587	INIT_LIST_HEAD(&req->queue);
 588	return &req->req;
 589}
 590
 591static void at91_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
 592{
 593	struct at91_request *req;
 594
 595	req = container_of(_req, struct at91_request, req);
 596	BUG_ON(!list_empty(&req->queue));
 597	kfree(req);
 598}
 599
 600static int at91_ep_queue(struct usb_ep *_ep,
 601			struct usb_request *_req, gfp_t gfp_flags)
 602{
 603	struct at91_request	*req;
 604	struct at91_ep		*ep;
 605	struct at91_udc		*udc;
 606	int			status;
 607	unsigned long		flags;
 608
 609	req = container_of(_req, struct at91_request, req);
 610	ep = container_of(_ep, struct at91_ep, ep);
 611
 612	if (!_req || !_req->complete
 613			|| !_req->buf || !list_empty(&req->queue)) {
 614		DBG("invalid request\n");
 615		return -EINVAL;
 616	}
 617
 618	if (!_ep || (!ep->ep.desc && ep->ep.name != ep0name)) {
 619		DBG("invalid ep\n");
 620		return -EINVAL;
 621	}
 622
 623	udc = ep->udc;
 624
 625	if (!udc || !udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
 626		DBG("invalid device\n");
 627		return -EINVAL;
 628	}
 629
 630	_req->status = -EINPROGRESS;
 631	_req->actual = 0;
 632
 633	spin_lock_irqsave(&udc->lock, flags);
 634
 635	/* try to kickstart any empty and idle queue */
 636	if (list_empty(&ep->queue) && !ep->stopped) {
 637		int	is_ep0;
 638
 639		/*
 640		 * If this control request has a non-empty DATA stage, this
 641		 * will start that stage.  It works just like a non-control
 642		 * request (until the status stage starts, maybe early).
 643		 *
 644		 * If the data stage is empty, then this starts a successful
 645		 * IN/STATUS stage.  (Unsuccessful ones use set_halt.)
 646		 */
 647		is_ep0 = (ep->ep.name == ep0name);
 648		if (is_ep0) {
 649			u32	tmp;
 650
 651			if (!udc->req_pending) {
 652				status = -EINVAL;
 653				goto done;
 654			}
 655
 656			/*
 657			 * defer changing CONFG until after the gadget driver
 658			 * reconfigures the endpoints.
 659			 */
 660			if (udc->wait_for_config_ack) {
 661				tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
 662				tmp ^= AT91_UDP_CONFG;
 663				VDBG("toggle config\n");
 664				at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
 665			}
 666			if (req->req.length == 0) {
 667ep0_in_status:
 668				PACKET("ep0 in/status\n");
 669				status = 0;
 670				tmp = __raw_readl(ep->creg);
 671				tmp &= ~SET_FX;
 672				tmp |= CLR_FX | AT91_UDP_TXPKTRDY;
 673				__raw_writel(tmp, ep->creg);
 674				udc->req_pending = 0;
 675				goto done;
 676			}
 677		}
 678
 679		if (ep->is_in)
 680			status = write_fifo(ep, req);
 681		else {
 682			status = read_fifo(ep, req);
 683
 684			/* IN/STATUS stage is otherwise triggered by irq */
 685			if (status && is_ep0)
 686				goto ep0_in_status;
 687		}
 688	} else
 689		status = 0;
 690
 691	if (req && !status) {
 692		list_add_tail (&req->queue, &ep->queue);
 693		at91_udp_write(udc, AT91_UDP_IER, ep->int_mask);
 694	}
 695done:
 696	spin_unlock_irqrestore(&udc->lock, flags);
 697	return (status < 0) ? status : 0;
 698}
 699
 700static int at91_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
 701{
 702	struct at91_ep		*ep;
 703	struct at91_request	*req;
 704	unsigned long		flags;
 705	struct at91_udc		*udc;
 706
 707	ep = container_of(_ep, struct at91_ep, ep);
 708	if (!_ep || ep->ep.name == ep0name)
 709		return -EINVAL;
 710
 711	udc = ep->udc;
 712
 713	spin_lock_irqsave(&udc->lock, flags);
 714
 715	/* make sure it's actually queued on this endpoint */
 716	list_for_each_entry (req, &ep->queue, queue) {
 717		if (&req->req == _req)
 718			break;
 719	}
 720	if (&req->req != _req) {
 721		spin_unlock_irqrestore(&udc->lock, flags);
 722		return -EINVAL;
 723	}
 724
 725	done(ep, req, -ECONNRESET);
 726	spin_unlock_irqrestore(&udc->lock, flags);
 727	return 0;
 728}
 729
 730static int at91_ep_set_halt(struct usb_ep *_ep, int value)
 731{
 732	struct at91_ep	*ep = container_of(_ep, struct at91_ep, ep);
 733	struct at91_udc	*udc = ep->udc;
 734	u32 __iomem	*creg;
 735	u32		csr;
 736	unsigned long	flags;
 737	int		status = 0;
 738
 739	if (!_ep || ep->is_iso || !ep->udc->clocked)
 740		return -EINVAL;
 741
 742	creg = ep->creg;
 743	spin_lock_irqsave(&udc->lock, flags);
 744
 745	csr = __raw_readl(creg);
 746
 747	/*
 748	 * fail with still-busy IN endpoints, ensuring correct sequencing
 749	 * of data tx then stall.  note that the fifo rx bytecount isn't
 750	 * completely accurate as a tx bytecount.
 751	 */
 752	if (ep->is_in && (!list_empty(&ep->queue) || (csr >> 16) != 0))
 753		status = -EAGAIN;
 754	else {
 755		csr |= CLR_FX;
 756		csr &= ~SET_FX;
 757		if (value) {
 758			csr |= AT91_UDP_FORCESTALL;
 759			VDBG("halt %s\n", ep->ep.name);
 760		} else {
 761			at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
 762			at91_udp_write(udc, AT91_UDP_RST_EP, 0);
 763			csr &= ~AT91_UDP_FORCESTALL;
 764		}
 765		__raw_writel(csr, creg);
 766	}
 767
 768	spin_unlock_irqrestore(&udc->lock, flags);
 769	return status;
 770}
 771
 772static const struct usb_ep_ops at91_ep_ops = {
 773	.enable		= at91_ep_enable,
 774	.disable	= at91_ep_disable,
 775	.alloc_request	= at91_ep_alloc_request,
 776	.free_request	= at91_ep_free_request,
 777	.queue		= at91_ep_queue,
 778	.dequeue	= at91_ep_dequeue,
 779	.set_halt	= at91_ep_set_halt,
 780	/* there's only imprecise fifo status reporting */
 781};
 782
 783/*-------------------------------------------------------------------------*/
 784
 785static int at91_get_frame(struct usb_gadget *gadget)
 786{
 787	struct at91_udc *udc = to_udc(gadget);
 788
 789	if (!to_udc(gadget)->clocked)
 790		return -EINVAL;
 791	return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM;
 792}
 793
 794static int at91_wakeup(struct usb_gadget *gadget)
 795{
 796	struct at91_udc	*udc = to_udc(gadget);
 797	u32		glbstate;
 798	int		status = -EINVAL;
 799	unsigned long	flags;
 800
 801	DBG("%s\n", __func__ );
 802	spin_lock_irqsave(&udc->lock, flags);
 803
 804	if (!udc->clocked || !udc->suspended)
 805		goto done;
 806
 807	/* NOTE:  some "early versions" handle ESR differently ... */
 808
 809	glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT);
 810	if (!(glbstate & AT91_UDP_ESR))
 811		goto done;
 812	glbstate |= AT91_UDP_ESR;
 813	at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate);
 814
 815done:
 816	spin_unlock_irqrestore(&udc->lock, flags);
 817	return status;
 818}
 819
 820/* reinit == restore initial software state */
 821static void udc_reinit(struct at91_udc *udc)
 822{
 823	u32 i;
 824
 825	INIT_LIST_HEAD(&udc->gadget.ep_list);
 826	INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
 827
 828	for (i = 0; i < NUM_ENDPOINTS; i++) {
 829		struct at91_ep *ep = &udc->ep[i];
 830
 831		if (i != 0)
 832			list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
 833		ep->ep.desc = NULL;
 834		ep->stopped = 0;
 835		ep->fifo_bank = 0;
 836		usb_ep_set_maxpacket_limit(&ep->ep, ep->maxpacket);
 837		ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i);
 838		/* initialize one queue per endpoint */
 839		INIT_LIST_HEAD(&ep->queue);
 840	}
 841}
 842
 843static void stop_activity(struct at91_udc *udc)
 844{
 845	struct usb_gadget_driver *driver = udc->driver;
 846	int i;
 847
 848	if (udc->gadget.speed == USB_SPEED_UNKNOWN)
 849		driver = NULL;
 850	udc->gadget.speed = USB_SPEED_UNKNOWN;
 851	udc->suspended = 0;
 852
 853	for (i = 0; i < NUM_ENDPOINTS; i++) {
 854		struct at91_ep *ep = &udc->ep[i];
 855		ep->stopped = 1;
 856		nuke(ep, -ESHUTDOWN);
 857	}
 858	if (driver) {
 859		spin_unlock(&udc->lock);
 860		driver->disconnect(&udc->gadget);
 861		spin_lock(&udc->lock);
 862	}
 863
 864	udc_reinit(udc);
 865}
 866
 867static void clk_on(struct at91_udc *udc)
 868{
 869	if (udc->clocked)
 870		return;
 871	udc->clocked = 1;
 872
 873	if (IS_ENABLED(CONFIG_COMMON_CLK)) {
 874		clk_set_rate(udc->uclk, 48000000);
 875		clk_prepare_enable(udc->uclk);
 876	}
 877	clk_prepare_enable(udc->iclk);
 878	clk_prepare_enable(udc->fclk);
 879}
 880
 881static void clk_off(struct at91_udc *udc)
 882{
 883	if (!udc->clocked)
 884		return;
 885	udc->clocked = 0;
 886	udc->gadget.speed = USB_SPEED_UNKNOWN;
 887	clk_disable_unprepare(udc->fclk);
 888	clk_disable_unprepare(udc->iclk);
 889	if (IS_ENABLED(CONFIG_COMMON_CLK))
 890		clk_disable_unprepare(udc->uclk);
 891}
 892
 893/*
 894 * activate/deactivate link with host; minimize power usage for
 895 * inactive links by cutting clocks and transceiver power.
 896 */
 897static void pullup(struct at91_udc *udc, int is_on)
 898{
 899	int	active = !udc->board.pullup_active_low;
 900
 901	if (!udc->enabled || !udc->vbus)
 902		is_on = 0;
 903	DBG("%sactive\n", is_on ? "" : "in");
 904
 905	if (is_on) {
 906		clk_on(udc);
 907		at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
 908		at91_udp_write(udc, AT91_UDP_TXVC, 0);
 909		if (cpu_is_at91rm9200())
 910			gpio_set_value(udc->board.pullup_pin, active);
 911		else if (cpu_is_at91sam9260() || cpu_is_at91sam9263() || cpu_is_at91sam9g20()) {
 912			u32	txvc = at91_udp_read(udc, AT91_UDP_TXVC);
 913
 914			txvc |= AT91_UDP_TXVC_PUON;
 915			at91_udp_write(udc, AT91_UDP_TXVC, txvc);
 916		} else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
 917			u32	usbpucr;
 918
 919			usbpucr = at91_matrix_read(AT91_MATRIX_USBPUCR);
 920			usbpucr |= AT91_MATRIX_USBPUCR_PUON;
 921			at91_matrix_write(AT91_MATRIX_USBPUCR, usbpucr);
 922		}
 923	} else {
 924		stop_activity(udc);
 925		at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
 926		at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
 927		if (cpu_is_at91rm9200())
 928			gpio_set_value(udc->board.pullup_pin, !active);
 929		else if (cpu_is_at91sam9260() || cpu_is_at91sam9263() || cpu_is_at91sam9g20()) {
 930			u32	txvc = at91_udp_read(udc, AT91_UDP_TXVC);
 931
 932			txvc &= ~AT91_UDP_TXVC_PUON;
 933			at91_udp_write(udc, AT91_UDP_TXVC, txvc);
 934		} else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
 935			u32	usbpucr;
 936
 937			usbpucr = at91_matrix_read(AT91_MATRIX_USBPUCR);
 938			usbpucr &= ~AT91_MATRIX_USBPUCR_PUON;
 939			at91_matrix_write(AT91_MATRIX_USBPUCR, usbpucr);
 940		}
 941		clk_off(udc);
 942	}
 943}
 944
 945/* vbus is here!  turn everything on that's ready */
 946static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
 947{
 948	struct at91_udc	*udc = to_udc(gadget);
 949	unsigned long	flags;
 950
 951	/* VDBG("vbus %s\n", is_active ? "on" : "off"); */
 952	spin_lock_irqsave(&udc->lock, flags);
 953	udc->vbus = (is_active != 0);
 954	if (udc->driver)
 955		pullup(udc, is_active);
 956	else
 957		pullup(udc, 0);
 958	spin_unlock_irqrestore(&udc->lock, flags);
 959	return 0;
 960}
 961
 962static int at91_pullup(struct usb_gadget *gadget, int is_on)
 963{
 964	struct at91_udc	*udc = to_udc(gadget);
 965	unsigned long	flags;
 966
 967	spin_lock_irqsave(&udc->lock, flags);
 968	udc->enabled = is_on = !!is_on;
 969	pullup(udc, is_on);
 970	spin_unlock_irqrestore(&udc->lock, flags);
 971	return 0;
 972}
 973
 974static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
 975{
 976	struct at91_udc	*udc = to_udc(gadget);
 977	unsigned long	flags;
 978
 979	spin_lock_irqsave(&udc->lock, flags);
 980	udc->selfpowered = (is_on != 0);
 981	spin_unlock_irqrestore(&udc->lock, flags);
 982	return 0;
 983}
 984
 985static int at91_start(struct usb_gadget *gadget,
 986		struct usb_gadget_driver *driver);
 987static int at91_stop(struct usb_gadget *gadget,
 988		struct usb_gadget_driver *driver);
 989static const struct usb_gadget_ops at91_udc_ops = {
 990	.get_frame		= at91_get_frame,
 991	.wakeup			= at91_wakeup,
 992	.set_selfpowered	= at91_set_selfpowered,
 993	.vbus_session		= at91_vbus_session,
 994	.pullup			= at91_pullup,
 995	.udc_start		= at91_start,
 996	.udc_stop		= at91_stop,
 997
 998	/*
 999	 * VBUS-powered devices may also also want to support bigger
1000	 * power budgets after an appropriate SET_CONFIGURATION.
1001	 */
1002	/* .vbus_power		= at91_vbus_power, */
1003};
1004
1005/*-------------------------------------------------------------------------*/
1006
1007static int handle_ep(struct at91_ep *ep)
1008{
1009	struct at91_request	*req;
1010	u32 __iomem		*creg = ep->creg;
1011	u32			csr = __raw_readl(creg);
1012
1013	if (!list_empty(&ep->queue))
1014		req = list_entry(ep->queue.next,
1015			struct at91_request, queue);
1016	else
1017		req = NULL;
1018
1019	if (ep->is_in) {
1020		if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
1021			csr |= CLR_FX;
1022			csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
1023			__raw_writel(csr, creg);
1024		}
1025		if (req)
1026			return write_fifo(ep, req);
1027
1028	} else {
1029		if (csr & AT91_UDP_STALLSENT) {
1030			/* STALLSENT bit == ISOERR */
1031			if (ep->is_iso && req)
1032				req->req.status = -EILSEQ;
1033			csr |= CLR_FX;
1034			csr &= ~(SET_FX | AT91_UDP_STALLSENT);
1035			__raw_writel(csr, creg);
1036			csr = __raw_readl(creg);
1037		}
1038		if (req && (csr & RX_DATA_READY))
1039			return read_fifo(ep, req);
1040	}
1041	return 0;
1042}
1043
1044union setup {
1045	u8			raw[8];
1046	struct usb_ctrlrequest	r;
1047};
1048
1049static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
1050{
1051	u32 __iomem	*creg = ep->creg;
1052	u8 __iomem	*dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
1053	unsigned	rxcount, i = 0;
1054	u32		tmp;
1055	union setup	pkt;
1056	int		status = 0;
1057
1058	/* read and ack SETUP; hard-fail for bogus packets */
1059	rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
1060	if (likely(rxcount == 8)) {
1061		while (rxcount--)
1062			pkt.raw[i++] = __raw_readb(dreg);
1063		if (pkt.r.bRequestType & USB_DIR_IN) {
1064			csr |= AT91_UDP_DIR;
1065			ep->is_in = 1;
1066		} else {
1067			csr &= ~AT91_UDP_DIR;
1068			ep->is_in = 0;
1069		}
1070	} else {
1071		/* REVISIT this happens sometimes under load; why?? */
1072		ERR("SETUP len %d, csr %08x\n", rxcount, csr);
1073		status = -EINVAL;
1074	}
1075	csr |= CLR_FX;
1076	csr &= ~(SET_FX | AT91_UDP_RXSETUP);
1077	__raw_writel(csr, creg);
1078	udc->wait_for_addr_ack = 0;
1079	udc->wait_for_config_ack = 0;
1080	ep->stopped = 0;
1081	if (unlikely(status != 0))
1082		goto stall;
1083
1084#define w_index		le16_to_cpu(pkt.r.wIndex)
1085#define w_value		le16_to_cpu(pkt.r.wValue)
1086#define w_length	le16_to_cpu(pkt.r.wLength)
1087
1088	VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
1089			pkt.r.bRequestType, pkt.r.bRequest,
1090			w_value, w_index, w_length);
1091
1092	/*
1093	 * A few standard requests get handled here, ones that touch
1094	 * hardware ... notably for device and endpoint features.
1095	 */
1096	udc->req_pending = 1;
1097	csr = __raw_readl(creg);
1098	csr |= CLR_FX;
1099	csr &= ~SET_FX;
1100	switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
1101
1102	case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1103			| USB_REQ_SET_ADDRESS:
1104		__raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
1105		udc->addr = w_value;
1106		udc->wait_for_addr_ack = 1;
1107		udc->req_pending = 0;
1108		/* FADDR is set later, when we ack host STATUS */
1109		return;
1110
1111	case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1112			| USB_REQ_SET_CONFIGURATION:
1113		tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
1114		if (pkt.r.wValue)
1115			udc->wait_for_config_ack = (tmp == 0);
1116		else
1117			udc->wait_for_config_ack = (tmp != 0);
1118		if (udc->wait_for_config_ack)
1119			VDBG("wait for config\n");
1120		/* CONFG is toggled later, if gadget driver succeeds */
1121		break;
1122
1123	/*
1124	 * Hosts may set or clear remote wakeup status, and
1125	 * devices may report they're VBUS powered.
1126	 */
1127	case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1128			| USB_REQ_GET_STATUS:
1129		tmp = (udc->selfpowered << USB_DEVICE_SELF_POWERED);
1130		if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
1131			tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
1132		PACKET("get device status\n");
1133		__raw_writeb(tmp, dreg);
1134		__raw_writeb(0, dreg);
1135		goto write_in;
1136		/* then STATUS starts later, automatically */
1137	case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1138			| USB_REQ_SET_FEATURE:
1139		if (w_value != USB_DEVICE_REMOTE_WAKEUP)
1140			goto stall;
1141		tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1142		tmp |= AT91_UDP_ESR;
1143		at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1144		goto succeed;
1145	case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
1146			| USB_REQ_CLEAR_FEATURE:
1147		if (w_value != USB_DEVICE_REMOTE_WAKEUP)
1148			goto stall;
1149		tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1150		tmp &= ~AT91_UDP_ESR;
1151		at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1152		goto succeed;
1153
1154	/*
1155	 * Interfaces have no feature settings; this is pretty useless.
1156	 * we won't even insist the interface exists...
1157	 */
1158	case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1159			| USB_REQ_GET_STATUS:
1160		PACKET("get interface status\n");
1161		__raw_writeb(0, dreg);
1162		__raw_writeb(0, dreg);
1163		goto write_in;
1164		/* then STATUS starts later, automatically */
1165	case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1166			| USB_REQ_SET_FEATURE:
1167	case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
1168			| USB_REQ_CLEAR_FEATURE:
1169		goto stall;
1170
1171	/*
1172	 * Hosts may clear bulk/intr endpoint halt after the gadget
1173	 * driver sets it (not widely used); or set it (for testing)
1174	 */
1175	case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1176			| USB_REQ_GET_STATUS:
1177		tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1178		ep = &udc->ep[tmp];
1179		if (tmp >= NUM_ENDPOINTS || (tmp && !ep->ep.desc))
1180			goto stall;
1181
1182		if (tmp) {
1183			if ((w_index & USB_DIR_IN)) {
1184				if (!ep->is_in)
1185					goto stall;
1186			} else if (ep->is_in)
1187				goto stall;
1188		}
1189		PACKET("get %s status\n", ep->ep.name);
1190		if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
1191			tmp = (1 << USB_ENDPOINT_HALT);
1192		else
1193			tmp = 0;
1194		__raw_writeb(tmp, dreg);
1195		__raw_writeb(0, dreg);
1196		goto write_in;
1197		/* then STATUS starts later, automatically */
1198	case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1199			| USB_REQ_SET_FEATURE:
1200		tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1201		ep = &udc->ep[tmp];
1202		if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1203			goto stall;
1204		if (!ep->ep.desc || ep->is_iso)
1205			goto stall;
1206		if ((w_index & USB_DIR_IN)) {
1207			if (!ep->is_in)
1208				goto stall;
1209		} else if (ep->is_in)
1210			goto stall;
1211
1212		tmp = __raw_readl(ep->creg);
1213		tmp &= ~SET_FX;
1214		tmp |= CLR_FX | AT91_UDP_FORCESTALL;
1215		__raw_writel(tmp, ep->creg);
1216		goto succeed;
1217	case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
1218			| USB_REQ_CLEAR_FEATURE:
1219		tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
1220		ep = &udc->ep[tmp];
1221		if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
1222			goto stall;
1223		if (tmp == 0)
1224			goto succeed;
1225		if (!ep->ep.desc || ep->is_iso)
1226			goto stall;
1227		if ((w_index & USB_DIR_IN)) {
1228			if (!ep->is_in)
1229				goto stall;
1230		} else if (ep->is_in)
1231			goto stall;
1232
1233		at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
1234		at91_udp_write(udc, AT91_UDP_RST_EP, 0);
1235		tmp = __raw_readl(ep->creg);
1236		tmp |= CLR_FX;
1237		tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
1238		__raw_writel(tmp, ep->creg);
1239		if (!list_empty(&ep->queue))
1240			handle_ep(ep);
1241		goto succeed;
1242	}
1243
1244#undef w_value
1245#undef w_index
1246#undef w_length
1247
1248	/* pass request up to the gadget driver */
1249	if (udc->driver) {
1250		spin_unlock(&udc->lock);
1251		status = udc->driver->setup(&udc->gadget, &pkt.r);
1252		spin_lock(&udc->lock);
1253	}
1254	else
1255		status = -ENODEV;
1256	if (status < 0) {
1257stall:
1258		VDBG("req %02x.%02x protocol STALL; stat %d\n",
1259				pkt.r.bRequestType, pkt.r.bRequest, status);
1260		csr |= AT91_UDP_FORCESTALL;
1261		__raw_writel(csr, creg);
1262		udc->req_pending = 0;
1263	}
1264	return;
1265
1266succeed:
1267	/* immediate successful (IN) STATUS after zero length DATA */
1268	PACKET("ep0 in/status\n");
1269write_in:
1270	csr |= AT91_UDP_TXPKTRDY;
1271	__raw_writel(csr, creg);
1272	udc->req_pending = 0;
1273}
1274
1275static void handle_ep0(struct at91_udc *udc)
1276{
1277	struct at91_ep		*ep0 = &udc->ep[0];
1278	u32 __iomem		*creg = ep0->creg;
1279	u32			csr = __raw_readl(creg);
1280	struct at91_request	*req;
1281
1282	if (unlikely(csr & AT91_UDP_STALLSENT)) {
1283		nuke(ep0, -EPROTO);
1284		udc->req_pending = 0;
1285		csr |= CLR_FX;
1286		csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
1287		__raw_writel(csr, creg);
1288		VDBG("ep0 stalled\n");
1289		csr = __raw_readl(creg);
1290	}
1291	if (csr & AT91_UDP_RXSETUP) {
1292		nuke(ep0, 0);
1293		udc->req_pending = 0;
1294		handle_setup(udc, ep0, csr);
1295		return;
1296	}
1297
1298	if (list_empty(&ep0->queue))
1299		req = NULL;
1300	else
1301		req = list_entry(ep0->queue.next, struct at91_request, queue);
1302
1303	/* host ACKed an IN packet that we sent */
1304	if (csr & AT91_UDP_TXCOMP) {
1305		csr |= CLR_FX;
1306		csr &= ~(SET_FX | AT91_UDP_TXCOMP);
1307
1308		/* write more IN DATA? */
1309		if (req && ep0->is_in) {
1310			if (handle_ep(ep0))
1311				udc->req_pending = 0;
1312
1313		/*
1314		 * Ack after:
1315		 *  - last IN DATA packet (including GET_STATUS)
1316		 *  - IN/STATUS for OUT DATA
1317		 *  - IN/STATUS for any zero-length DATA stage
1318		 * except for the IN DATA case, the host should send
1319		 * an OUT status later, which we'll ack.
1320		 */
1321		} else {
1322			udc->req_pending = 0;
1323			__raw_writel(csr, creg);
1324
1325			/*
1326			 * SET_ADDRESS takes effect only after the STATUS
1327			 * (to the original address) gets acked.
1328			 */
1329			if (udc->wait_for_addr_ack) {
1330				u32	tmp;
1331
1332				at91_udp_write(udc, AT91_UDP_FADDR,
1333						AT91_UDP_FEN | udc->addr);
1334				tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
1335				tmp &= ~AT91_UDP_FADDEN;
1336				if (udc->addr)
1337					tmp |= AT91_UDP_FADDEN;
1338				at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
1339
1340				udc->wait_for_addr_ack = 0;
1341				VDBG("address %d\n", udc->addr);
1342			}
1343		}
1344	}
1345
1346	/* OUT packet arrived ... */
1347	else if (csr & AT91_UDP_RX_DATA_BK0) {
1348		csr |= CLR_FX;
1349		csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
1350
1351		/* OUT DATA stage */
1352		if (!ep0->is_in) {
1353			if (req) {
1354				if (handle_ep(ep0)) {
1355					/* send IN/STATUS */
1356					PACKET("ep0 in/status\n");
1357					csr = __raw_readl(creg);
1358					csr &= ~SET_FX;
1359					csr |= CLR_FX | AT91_UDP_TXPKTRDY;
1360					__raw_writel(csr, creg);
1361					udc->req_pending = 0;
1362				}
1363			} else if (udc->req_pending) {
1364				/*
1365				 * AT91 hardware has a hard time with this
1366				 * "deferred response" mode for control-OUT
1367				 * transfers.  (For control-IN it's fine.)
1368				 *
1369				 * The normal solution leaves OUT data in the
1370				 * fifo until the gadget driver is ready.
1371				 * We couldn't do that here without disabling
1372				 * the IRQ that tells about SETUP packets,
1373				 * e.g. when the host gets impatient...
1374				 *
1375				 * Working around it by copying into a buffer
1376				 * would almost be a non-deferred response,
1377				 * except that it wouldn't permit reliable
1378				 * stalling of the request.  Instead, demand
1379				 * that gadget drivers not use this mode.
1380				 */
1381				DBG("no control-OUT deferred responses!\n");
1382				__raw_writel(csr | AT91_UDP_FORCESTALL, creg);
1383				udc->req_pending = 0;
1384			}
1385
1386		/* STATUS stage for control-IN; ack.  */
1387		} else {
1388			PACKET("ep0 out/status ACK\n");
1389			__raw_writel(csr, creg);
1390
1391			/* "early" status stage */
1392			if (req)
1393				done(ep0, req, 0);
1394		}
1395	}
1396}
1397
1398static irqreturn_t at91_udc_irq (int irq, void *_udc)
1399{
1400	struct at91_udc		*udc = _udc;
1401	u32			rescans = 5;
1402	int			disable_clock = 0;
1403	unsigned long		flags;
1404
1405	spin_lock_irqsave(&udc->lock, flags);
1406
1407	if (!udc->clocked) {
1408		clk_on(udc);
1409		disable_clock = 1;
1410	}
1411
1412	while (rescans--) {
1413		u32 status;
1414
1415		status = at91_udp_read(udc, AT91_UDP_ISR)
1416			& at91_udp_read(udc, AT91_UDP_IMR);
1417		if (!status)
1418			break;
1419
1420		/* USB reset irq:  not maskable */
1421		if (status & AT91_UDP_ENDBUSRES) {
1422			at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
1423			at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS);
1424			/* Atmel code clears this irq twice */
1425			at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1426			at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
1427			VDBG("end bus reset\n");
1428			udc->addr = 0;
1429			stop_activity(udc);
1430
1431			/* enable ep0 */
1432			at91_udp_write(udc, AT91_UDP_CSR(0),
1433					AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
1434			udc->gadget.speed = USB_SPEED_FULL;
1435			udc->suspended = 0;
1436			at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0));
1437
1438			/*
1439			 * NOTE:  this driver keeps clocks off unless the
1440			 * USB host is present.  That saves power, but for
1441			 * boards that don't support VBUS detection, both
1442			 * clocks need to be active most of the time.
1443			 */
1444
1445		/* host initiated suspend (3+ms bus idle) */
1446		} else if (status & AT91_UDP_RXSUSP) {
1447			at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP);
1448			at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM);
1449			at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP);
1450			/* VDBG("bus suspend\n"); */
1451			if (udc->suspended)
1452				continue;
1453			udc->suspended = 1;
1454
1455			/*
1456			 * NOTE:  when suspending a VBUS-powered device, the
1457			 * gadget driver should switch into slow clock mode
1458			 * and then into standby to avoid drawing more than
1459			 * 500uA power (2500uA for some high-power configs).
1460			 */
1461			if (udc->driver && udc->driver->suspend) {
1462				spin_unlock(&udc->lock);
1463				udc->driver->suspend(&udc->gadget);
1464				spin_lock(&udc->lock);
1465			}
1466
1467		/* host initiated resume */
1468		} else if (status & AT91_UDP_RXRSM) {
1469			at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
1470			at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP);
1471			at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
1472			/* VDBG("bus resume\n"); */
1473			if (!udc->suspended)
1474				continue;
1475			udc->suspended = 0;
1476
1477			/*
1478			 * NOTE:  for a VBUS-powered device, the gadget driver
1479			 * would normally want to switch out of slow clock
1480			 * mode into normal mode.
1481			 */
1482			if (udc->driver && udc->driver->resume) {
1483				spin_unlock(&udc->lock);
1484				udc->driver->resume(&udc->gadget);
1485				spin_lock(&udc->lock);
1486			}
1487
1488		/* endpoint IRQs are cleared by handling them */
1489		} else {
1490			int		i;
1491			unsigned	mask = 1;
1492			struct at91_ep	*ep = &udc->ep[1];
1493
1494			if (status & mask)
1495				handle_ep0(udc);
1496			for (i = 1; i < NUM_ENDPOINTS; i++) {
1497				mask <<= 1;
1498				if (status & mask)
1499					handle_ep(ep);
1500				ep++;
1501			}
1502		}
1503	}
1504
1505	if (disable_clock)
1506		clk_off(udc);
1507
1508	spin_unlock_irqrestore(&udc->lock, flags);
1509
1510	return IRQ_HANDLED;
1511}
1512
1513/*-------------------------------------------------------------------------*/
1514
1515static void nop_release(struct device *dev)
1516{
1517	/* nothing to free */
1518}
1519
1520static struct at91_udc controller = {
1521	.gadget = {
1522		.ops	= &at91_udc_ops,
1523		.ep0	= &controller.ep[0].ep,
1524		.name	= driver_name,
1525		.dev	= {
1526			.init_name = "gadget",
1527			.release = nop_release,
1528		}
1529	},
1530	.ep[0] = {
1531		.ep = {
1532			.name	= ep0name,
1533			.ops	= &at91_ep_ops,
1534		},
1535		.udc		= &controller,
1536		.maxpacket	= 8,
1537		.int_mask	= 1 << 0,
1538	},
1539	.ep[1] = {
1540		.ep = {
1541			.name	= "ep1",
1542			.ops	= &at91_ep_ops,
1543		},
1544		.udc		= &controller,
1545		.is_pingpong	= 1,
1546		.maxpacket	= 64,
1547		.int_mask	= 1 << 1,
1548	},
1549	.ep[2] = {
1550		.ep = {
1551			.name	= "ep2",
1552			.ops	= &at91_ep_ops,
1553		},
1554		.udc		= &controller,
1555		.is_pingpong	= 1,
1556		.maxpacket	= 64,
1557		.int_mask	= 1 << 2,
1558	},
1559	.ep[3] = {
1560		.ep = {
1561			/* could actually do bulk too */
1562			.name	= "ep3-int",
1563			.ops	= &at91_ep_ops,
1564		},
1565		.udc		= &controller,
1566		.maxpacket	= 8,
1567		.int_mask	= 1 << 3,
1568	},
1569	.ep[4] = {
1570		.ep = {
1571			.name	= "ep4",
1572			.ops	= &at91_ep_ops,
1573		},
1574		.udc		= &controller,
1575		.is_pingpong	= 1,
1576		.maxpacket	= 256,
1577		.int_mask	= 1 << 4,
1578	},
1579	.ep[5] = {
1580		.ep = {
1581			.name	= "ep5",
1582			.ops	= &at91_ep_ops,
1583		},
1584		.udc		= &controller,
1585		.is_pingpong	= 1,
1586		.maxpacket	= 256,
1587		.int_mask	= 1 << 5,
1588	},
1589	/* ep6 and ep7 are also reserved (custom silicon might use them) */
1590};
1591
1592static void at91_vbus_update(struct at91_udc *udc, unsigned value)
1593{
1594	value ^= udc->board.vbus_active_low;
1595	if (value != udc->vbus)
1596		at91_vbus_session(&udc->gadget, value);
1597}
1598
1599static irqreturn_t at91_vbus_irq(int irq, void *_udc)
1600{
1601	struct at91_udc	*udc = _udc;
1602
1603	/* vbus needs at least brief debouncing */
1604	udelay(10);
1605	at91_vbus_update(udc, gpio_get_value(udc->board.vbus_pin));
1606
1607	return IRQ_HANDLED;
1608}
1609
1610static void at91_vbus_timer_work(struct work_struct *work)
1611{
1612	struct at91_udc *udc = container_of(work, struct at91_udc,
1613					    vbus_timer_work);
1614
1615	at91_vbus_update(udc, gpio_get_value_cansleep(udc->board.vbus_pin));
1616
1617	if (!timer_pending(&udc->vbus_timer))
1618		mod_timer(&udc->vbus_timer, jiffies + VBUS_POLL_TIMEOUT);
1619}
1620
1621static void at91_vbus_timer(unsigned long data)
1622{
1623	struct at91_udc *udc = (struct at91_udc *)data;
1624
1625	/*
1626	 * If we are polling vbus it is likely that the gpio is on an
1627	 * bus such as i2c or spi which may sleep, so schedule some work
1628	 * to read the vbus gpio
1629	 */
1630	schedule_work(&udc->vbus_timer_work);
 
1631}
1632
1633static int at91_start(struct usb_gadget *gadget,
1634		struct usb_gadget_driver *driver)
1635{
1636	struct at91_udc	*udc;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1637
1638	udc = container_of(gadget, struct at91_udc, gadget);
1639	udc->driver = driver;
1640	udc->gadget.dev.of_node = udc->pdev->dev.of_node;
 
1641	udc->enabled = 1;
1642	udc->selfpowered = 1;
1643
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1644	DBG("bound to %s\n", driver->driver.name);
1645	return 0;
1646}
1647
1648static int at91_stop(struct usb_gadget *gadget,
1649		struct usb_gadget_driver *driver)
1650{
1651	struct at91_udc *udc;
1652	unsigned long	flags;
1653
1654	udc = container_of(gadget, struct at91_udc, gadget);
 
 
1655	spin_lock_irqsave(&udc->lock, flags);
1656	udc->enabled = 0;
1657	at91_udp_write(udc, AT91_UDP_IDR, ~0);
 
1658	spin_unlock_irqrestore(&udc->lock, flags);
1659
 
 
 
1660	udc->driver = NULL;
1661
1662	DBG("unbound from %s\n", driver->driver.name);
1663	return 0;
1664}
1665
1666/*-------------------------------------------------------------------------*/
1667
1668static void at91udc_shutdown(struct platform_device *dev)
1669{
1670	struct at91_udc *udc = platform_get_drvdata(dev);
1671	unsigned long	flags;
1672
1673	/* force disconnect on reboot */
1674	spin_lock_irqsave(&udc->lock, flags);
1675	pullup(platform_get_drvdata(dev), 0);
1676	spin_unlock_irqrestore(&udc->lock, flags);
1677}
1678
1679static void at91udc_of_init(struct at91_udc *udc,
1680				     struct device_node *np)
1681{
1682	struct at91_udc_data *board = &udc->board;
1683	u32 val;
1684	enum of_gpio_flags flags;
1685
1686	if (of_property_read_u32(np, "atmel,vbus-polled", &val) == 0)
1687		board->vbus_polled = 1;
1688
1689	board->vbus_pin = of_get_named_gpio_flags(np, "atmel,vbus-gpio", 0,
1690						  &flags);
1691	board->vbus_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
1692
1693	board->pullup_pin = of_get_named_gpio_flags(np, "atmel,pullup-gpio", 0,
1694						  &flags);
1695
1696	board->pullup_active_low = (flags & OF_GPIO_ACTIVE_LOW) ? 1 : 0;
1697}
1698
1699static int at91udc_probe(struct platform_device *pdev)
1700{
1701	struct device	*dev = &pdev->dev;
1702	struct at91_udc	*udc;
1703	int		retval;
1704	struct resource	*res;
1705
1706	if (!dev_get_platdata(dev) && !pdev->dev.of_node) {
1707		/* small (so we copy it) but critical! */
1708		DBG("missing platform_data\n");
1709		return -ENODEV;
1710	}
1711
 
 
 
 
 
 
 
 
 
 
1712	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1713	if (!res)
1714		return -ENXIO;
1715
1716	if (!request_mem_region(res->start, resource_size(res), driver_name)) {
1717		DBG("someone's using UDC memory\n");
1718		return -EBUSY;
1719	}
1720
1721	/* init software state */
1722	udc = &controller;
1723	udc->gadget.dev.parent = dev;
1724	if (IS_ENABLED(CONFIG_OF) && pdev->dev.of_node)
1725		at91udc_of_init(udc, pdev->dev.of_node);
1726	else
1727		memcpy(&udc->board, dev_get_platdata(dev),
1728		       sizeof(struct at91_udc_data));
1729	udc->pdev = pdev;
1730	udc->enabled = 0;
1731	spin_lock_init(&udc->lock);
1732
1733	/* rm9200 needs manual D+ pullup; off by default */
1734	if (cpu_is_at91rm9200()) {
1735		if (!gpio_is_valid(udc->board.pullup_pin)) {
1736			DBG("no D+ pullup?\n");
1737			retval = -ENODEV;
1738			goto fail0;
1739		}
1740		retval = gpio_request(udc->board.pullup_pin, "udc_pullup");
1741		if (retval) {
1742			DBG("D+ pullup is busy\n");
1743			goto fail0;
1744		}
1745		gpio_direction_output(udc->board.pullup_pin,
1746				udc->board.pullup_active_low);
1747	}
1748
1749	/* newer chips have more FIFO memory than rm9200 */
1750	if (cpu_is_at91sam9260() || cpu_is_at91sam9g20()) {
1751		udc->ep[0].maxpacket = 64;
1752		udc->ep[3].maxpacket = 64;
1753		udc->ep[4].maxpacket = 512;
1754		udc->ep[5].maxpacket = 512;
1755	} else if (cpu_is_at91sam9261() || cpu_is_at91sam9g10()) {
1756		udc->ep[3].maxpacket = 64;
1757	} else if (cpu_is_at91sam9263()) {
1758		udc->ep[0].maxpacket = 64;
1759		udc->ep[3].maxpacket = 64;
1760	}
1761
1762	udc->udp_baseaddr = ioremap(res->start, resource_size(res));
1763	if (!udc->udp_baseaddr) {
1764		retval = -ENOMEM;
1765		goto fail0a;
1766	}
1767
1768	udc_reinit(udc);
1769
1770	/* get interface and function clocks */
1771	udc->iclk = clk_get(dev, "udc_clk");
1772	udc->fclk = clk_get(dev, "udpck");
1773	if (IS_ENABLED(CONFIG_COMMON_CLK))
1774		udc->uclk = clk_get(dev, "usb_clk");
1775	if (IS_ERR(udc->iclk) || IS_ERR(udc->fclk) ||
1776	    (IS_ENABLED(CONFIG_COMMON_CLK) && IS_ERR(udc->uclk))) {
1777		DBG("clocks missing\n");
1778		retval = -ENODEV;
1779		goto fail1;
 
 
 
 
 
 
 
1780	}
1781
1782	/* don't do anything until we have both gadget driver and VBUS */
1783	retval = clk_prepare_enable(udc->iclk);
1784	if (retval)
1785		goto fail1;
1786	at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
1787	at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
1788	/* Clear all pending interrupts - UDP may be used by bootloader. */
1789	at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
1790	clk_disable_unprepare(udc->iclk);
1791
1792	/* request UDC and maybe VBUS irqs */
1793	udc->udp_irq = platform_get_irq(pdev, 0);
1794	retval = request_irq(udc->udp_irq, at91_udc_irq,
1795			0, driver_name, udc);
1796	if (retval < 0) {
1797		DBG("request irq %d failed\n", udc->udp_irq);
1798		goto fail1;
1799	}
1800	if (gpio_is_valid(udc->board.vbus_pin)) {
1801		retval = gpio_request(udc->board.vbus_pin, "udc_vbus");
1802		if (retval < 0) {
1803			DBG("request vbus pin failed\n");
1804			goto fail2;
1805		}
1806		gpio_direction_input(udc->board.vbus_pin);
1807
1808		/*
1809		 * Get the initial state of VBUS - we cannot expect
1810		 * a pending interrupt.
1811		 */
1812		udc->vbus = gpio_get_value_cansleep(udc->board.vbus_pin) ^
1813			udc->board.vbus_active_low;
1814
1815		if (udc->board.vbus_polled) {
1816			INIT_WORK(&udc->vbus_timer_work, at91_vbus_timer_work);
1817			setup_timer(&udc->vbus_timer, at91_vbus_timer,
1818				    (unsigned long)udc);
1819			mod_timer(&udc->vbus_timer,
1820				  jiffies + VBUS_POLL_TIMEOUT);
1821		} else {
1822			if (request_irq(gpio_to_irq(udc->board.vbus_pin),
1823					at91_vbus_irq, 0, driver_name, udc)) {
1824				DBG("request vbus irq %d failed\n",
1825				    udc->board.vbus_pin);
1826				retval = -EBUSY;
1827				goto fail3;
1828			}
1829		}
1830	} else {
1831		DBG("no VBUS detection, assuming always-on\n");
1832		udc->vbus = 1;
1833	}
1834	retval = usb_add_gadget_udc(dev, &udc->gadget);
1835	if (retval)
1836		goto fail4;
1837	dev_set_drvdata(dev, udc);
1838	device_init_wakeup(dev, 1);
1839	create_debug_file(udc);
1840
1841	INFO("%s version %s\n", driver_name, DRIVER_VERSION);
1842	return 0;
1843fail4:
1844	if (gpio_is_valid(udc->board.vbus_pin) && !udc->board.vbus_polled)
1845		free_irq(gpio_to_irq(udc->board.vbus_pin), udc);
1846fail3:
1847	if (gpio_is_valid(udc->board.vbus_pin))
1848		gpio_free(udc->board.vbus_pin);
1849fail2:
1850	free_irq(udc->udp_irq, udc);
1851fail1:
1852	if (IS_ENABLED(CONFIG_COMMON_CLK) && !IS_ERR(udc->uclk))
1853		clk_put(udc->uclk);
1854	if (!IS_ERR(udc->fclk))
1855		clk_put(udc->fclk);
1856	if (!IS_ERR(udc->iclk))
1857		clk_put(udc->iclk);
1858	iounmap(udc->udp_baseaddr);
1859fail0a:
1860	if (cpu_is_at91rm9200())
1861		gpio_free(udc->board.pullup_pin);
1862fail0:
1863	release_mem_region(res->start, resource_size(res));
1864	DBG("%s probe failed, %d\n", driver_name, retval);
1865	return retval;
1866}
1867
1868static int __exit at91udc_remove(struct platform_device *pdev)
1869{
1870	struct at91_udc *udc = platform_get_drvdata(pdev);
1871	struct resource *res;
1872	unsigned long	flags;
1873
1874	DBG("remove\n");
1875
1876	usb_del_gadget_udc(&udc->gadget);
1877	if (udc->driver)
1878		return -EBUSY;
1879
1880	spin_lock_irqsave(&udc->lock, flags);
1881	pullup(udc, 0);
1882	spin_unlock_irqrestore(&udc->lock, flags);
1883
1884	device_init_wakeup(&pdev->dev, 0);
1885	remove_debug_file(udc);
1886	if (gpio_is_valid(udc->board.vbus_pin)) {
1887		free_irq(gpio_to_irq(udc->board.vbus_pin), udc);
1888		gpio_free(udc->board.vbus_pin);
1889	}
1890	free_irq(udc->udp_irq, udc);
 
 
1891	iounmap(udc->udp_baseaddr);
1892
1893	if (cpu_is_at91rm9200())
1894		gpio_free(udc->board.pullup_pin);
1895
1896	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1897	release_mem_region(res->start, resource_size(res));
1898
1899	clk_put(udc->iclk);
1900	clk_put(udc->fclk);
1901	if (IS_ENABLED(CONFIG_COMMON_CLK))
1902		clk_put(udc->uclk);
1903
1904	return 0;
1905}
1906
1907#ifdef CONFIG_PM
1908static int at91udc_suspend(struct platform_device *pdev, pm_message_t mesg)
1909{
1910	struct at91_udc *udc = platform_get_drvdata(pdev);
1911	int		wake = udc->driver && device_may_wakeup(&pdev->dev);
1912	unsigned long	flags;
1913
1914	/* Unless we can act normally to the host (letting it wake us up
1915	 * whenever it has work for us) force disconnect.  Wakeup requires
1916	 * PLLB for USB events (signaling for reset, wakeup, or incoming
1917	 * tokens) and VBUS irqs (on systems which support them).
1918	 */
1919	if ((!udc->suspended && udc->addr)
1920			|| !wake
1921			|| at91_suspend_entering_slow_clock()) {
1922		spin_lock_irqsave(&udc->lock, flags);
1923		pullup(udc, 0);
1924		wake = 0;
1925		spin_unlock_irqrestore(&udc->lock, flags);
1926	} else
1927		enable_irq_wake(udc->udp_irq);
1928
1929	udc->active_suspend = wake;
1930	if (gpio_is_valid(udc->board.vbus_pin) && !udc->board.vbus_polled && wake)
1931		enable_irq_wake(udc->board.vbus_pin);
1932	return 0;
1933}
1934
1935static int at91udc_resume(struct platform_device *pdev)
1936{
1937	struct at91_udc *udc = platform_get_drvdata(pdev);
1938	unsigned long	flags;
1939
1940	if (gpio_is_valid(udc->board.vbus_pin) && !udc->board.vbus_polled &&
1941	    udc->active_suspend)
1942		disable_irq_wake(udc->board.vbus_pin);
1943
1944	/* maybe reconnect to host; if so, clocks on */
1945	if (udc->active_suspend)
1946		disable_irq_wake(udc->udp_irq);
1947	else {
1948		spin_lock_irqsave(&udc->lock, flags);
1949		pullup(udc, 1);
1950		spin_unlock_irqrestore(&udc->lock, flags);
1951	}
1952	return 0;
1953}
1954#else
1955#define	at91udc_suspend	NULL
1956#define	at91udc_resume	NULL
1957#endif
1958
1959#if defined(CONFIG_OF)
1960static const struct of_device_id at91_udc_dt_ids[] = {
1961	{ .compatible = "atmel,at91rm9200-udc" },
1962	{ /* sentinel */ }
1963};
1964
1965MODULE_DEVICE_TABLE(of, at91_udc_dt_ids);
1966#endif
1967
1968static struct platform_driver at91_udc_driver = {
1969	.remove		= __exit_p(at91udc_remove),
1970	.shutdown	= at91udc_shutdown,
1971	.suspend	= at91udc_suspend,
1972	.resume		= at91udc_resume,
1973	.driver		= {
1974		.name	= (char *) driver_name,
1975		.owner	= THIS_MODULE,
1976		.of_match_table	= of_match_ptr(at91_udc_dt_ids),
1977	},
1978};
1979
1980module_platform_driver_probe(at91_udc_driver, at91udc_probe);
 
 
 
 
 
 
 
 
 
 
1981
1982MODULE_DESCRIPTION("AT91 udc driver");
1983MODULE_AUTHOR("Thomas Rathbone, David Brownell");
1984MODULE_LICENSE("GPL");
1985MODULE_ALIAS("platform:at91_udc");