at91_udc.c 37 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * from linux:
  4. * c94e289f195e: usb: gadget: remove incorrect __init/__exit annotations
  5. *
  6. * at91_udc -- driver for at91-series USB peripheral controller
  7. *
  8. * Copyright (C) 2004 by Thomas Rathbone
  9. * Copyright (C) 2005 by HP Labs
  10. * Copyright (C) 2005 by David Brownell
  11. */
  12. #undef VERBOSE_DEBUG
  13. #undef PACKET_TRACE
  14. #include <common.h>
  15. #include <dm/devres.h>
  16. #include <linux/bug.h>
  17. #include <linux/err.h>
  18. #include <linux/errno.h>
  19. #include <asm/io.h>
  20. #include <asm/gpio.h>
  21. #include <asm/hardware.h>
  22. #include <mach/at91_matrix.h>
  23. #include <linux/list.h>
  24. #include <linux/usb/ch9.h>
  25. #include <linux/usb/gadget.h>
  26. #include <linux/usb/at91_udc.h>
  27. #include <malloc.h>
  28. #include "at91_udc.h"
  29. /*
  30. * This controller is simple and PIO-only. It's used in many AT91-series
  31. * full speed USB controllers, including the at91rm9200 (arm920T, with MMU),
  32. * at91sam926x (arm926ejs, with MMU), and several no-mmu versions.
  33. *
  34. * This driver expects the board has been wired with two GPIOs supporting
  35. * a VBUS sensing IRQ, and a D+ pullup. (They may be omitted, but the
  36. * testing hasn't covered such cases.)
  37. *
  38. * The pullup is most important (so it's integrated on sam926x parts). It
  39. * provides software control over whether the host enumerates the device.
  40. *
  41. * The VBUS sensing helps during enumeration, and allows both USB clocks
  42. * (and the transceiver) to stay gated off until they're necessary, saving
  43. * power. During USB suspend, the 48 MHz clock is gated off in hardware;
  44. * it may also be gated off by software during some Linux sleep states.
  45. */
  46. #define DRIVER_VERSION "3 May 2006"
  47. static const char driver_name [] = "at91_udc";
  48. static const char * const ep_names[] = {
  49. "ep0",
  50. "ep1",
  51. "ep2",
  52. "ep3-int",
  53. "ep4",
  54. "ep5",
  55. };
  56. #define ep0name ep_names[0]
  57. #define at91_udp_read(udc, reg) \
  58. __raw_readl((udc)->udp_baseaddr + (reg))
  59. #define at91_udp_write(udc, reg, val) \
  60. __raw_writel((val), (udc)->udp_baseaddr + (reg))
  61. static struct at91_udc *controller;
  62. /*-------------------------------------------------------------------------*/
  63. static void done(struct at91_ep *ep, struct at91_request *req, int status)
  64. {
  65. unsigned stopped = ep->stopped;
  66. struct at91_udc *udc = ep->udc;
  67. list_del_init(&req->queue);
  68. if (req->req.status == -EINPROGRESS)
  69. req->req.status = status;
  70. else
  71. status = req->req.status;
  72. if (status && status != -ESHUTDOWN)
  73. VDBG("%s done %p, status %d\n", ep->ep.name, req, status);
  74. ep->stopped = 1;
  75. spin_unlock(&udc->lock);
  76. req->req.complete(&ep->ep, &req->req);
  77. spin_lock(&udc->lock);
  78. ep->stopped = stopped;
  79. /* ep0 is always ready; other endpoints need a non-empty queue */
  80. if (list_empty(&ep->queue) && ep->int_mask != (1 << 0))
  81. at91_udp_write(udc, AT91_UDP_IDR, ep->int_mask);
  82. }
  83. /*-------------------------------------------------------------------------*/
  84. /* bits indicating OUT fifo has data ready */
  85. #define RX_DATA_READY (AT91_UDP_RX_DATA_BK0 | AT91_UDP_RX_DATA_BK1)
  86. /*
  87. * Endpoint FIFO CSR bits have a mix of bits, making it unsafe to just write
  88. * back most of the value you just read (because of side effects, including
  89. * bits that may change after reading and before writing).
  90. *
  91. * Except when changing a specific bit, always write values which:
  92. * - clear SET_FX bits (setting them could change something)
  93. * - set CLR_FX bits (clearing them could change something)
  94. *
  95. * There are also state bits like FORCESTALL, EPEDS, DIR, and EPTYPE
  96. * that shouldn't normally be changed.
  97. *
  98. * NOTE at91sam9260 docs mention synch between UDPCK and MCK clock domains,
  99. * implying a need to wait for one write to complete (test relevant bits)
  100. * before starting the next write. This shouldn't be an issue given how
  101. * infrequently we write, except maybe for write-then-read idioms.
  102. */
  103. #define SET_FX (AT91_UDP_TXPKTRDY)
  104. #define CLR_FX (RX_DATA_READY | AT91_UDP_RXSETUP \
  105. | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)
  106. /* pull OUT packet data from the endpoint's fifo */
  107. static int read_fifo (struct at91_ep *ep, struct at91_request *req)
  108. {
  109. u32 __iomem *creg = ep->creg;
  110. u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
  111. u32 csr;
  112. u8 *buf;
  113. unsigned int count, bufferspace, is_done;
  114. buf = req->req.buf + req->req.actual;
  115. bufferspace = req->req.length - req->req.actual;
  116. /*
  117. * there might be nothing to read if ep_queue() calls us,
  118. * or if we already emptied both pingpong buffers
  119. */
  120. rescan:
  121. csr = __raw_readl(creg);
  122. if ((csr & RX_DATA_READY) == 0)
  123. return 0;
  124. count = (csr & AT91_UDP_RXBYTECNT) >> 16;
  125. if (count > ep->ep.maxpacket)
  126. count = ep->ep.maxpacket;
  127. if (count > bufferspace) {
  128. DBG("%s buffer overflow\n", ep->ep.name);
  129. req->req.status = -EOVERFLOW;
  130. count = bufferspace;
  131. }
  132. __raw_readsb((unsigned long)dreg, buf, count);
  133. /* release and swap pingpong mem bank */
  134. csr |= CLR_FX;
  135. if (ep->is_pingpong) {
  136. if (ep->fifo_bank == 0) {
  137. csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
  138. ep->fifo_bank = 1;
  139. } else {
  140. csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK1);
  141. ep->fifo_bank = 0;
  142. }
  143. } else
  144. csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
  145. __raw_writel(csr, creg);
  146. req->req.actual += count;
  147. is_done = (count < ep->ep.maxpacket);
  148. if (count == bufferspace)
  149. is_done = 1;
  150. PACKET("%s %p out/%d%s\n", ep->ep.name, &req->req, count,
  151. is_done ? " (done)" : "");
  152. /*
  153. * avoid extra trips through IRQ logic for packets already in
  154. * the fifo ... maybe preventing an extra (expensive) OUT-NAK
  155. */
  156. if (is_done)
  157. done(ep, req, 0);
  158. else if (ep->is_pingpong) {
  159. /*
  160. * One dummy read to delay the code because of a HW glitch:
  161. * CSR returns bad RXCOUNT when read too soon after updating
  162. * RX_DATA_BK flags.
  163. */
  164. csr = __raw_readl(creg);
  165. bufferspace -= count;
  166. buf += count;
  167. goto rescan;
  168. }
  169. return is_done;
  170. }
  171. /* load fifo for an IN packet */
  172. static int write_fifo(struct at91_ep *ep, struct at91_request *req)
  173. {
  174. u32 __iomem *creg = ep->creg;
  175. u32 csr = __raw_readl(creg);
  176. u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
  177. unsigned total, count, is_last;
  178. u8 *buf;
  179. /*
  180. * TODO: allow for writing two packets to the fifo ... that'll
  181. * reduce the amount of IN-NAKing, but probably won't affect
  182. * throughput much. (Unlike preventing OUT-NAKing!)
  183. */
  184. /*
  185. * If ep_queue() calls us, the queue is empty and possibly in
  186. * odd states like TXCOMP not yet cleared (we do it, saving at
  187. * least one IRQ) or the fifo not yet being free. Those aren't
  188. * issues normally (IRQ handler fast path).
  189. */
  190. if (unlikely(csr & (AT91_UDP_TXCOMP | AT91_UDP_TXPKTRDY))) {
  191. if (csr & AT91_UDP_TXCOMP) {
  192. csr |= CLR_FX;
  193. csr &= ~(SET_FX | AT91_UDP_TXCOMP);
  194. __raw_writel(csr, creg);
  195. csr = __raw_readl(creg);
  196. }
  197. if (csr & AT91_UDP_TXPKTRDY)
  198. return 0;
  199. }
  200. buf = req->req.buf + req->req.actual;
  201. prefetch(buf);
  202. total = req->req.length - req->req.actual;
  203. if (ep->ep.maxpacket < total) {
  204. count = ep->ep.maxpacket;
  205. is_last = 0;
  206. } else {
  207. count = total;
  208. is_last = (count < ep->ep.maxpacket) || !req->req.zero;
  209. }
  210. /*
  211. * Write the packet, maybe it's a ZLP.
  212. *
  213. * NOTE: incrementing req->actual before we receive the ACK means
  214. * gadget driver IN bytecounts can be wrong in fault cases. That's
  215. * fixable with PIO drivers like this one (save "count" here, and
  216. * do the increment later on TX irq), but not for most DMA hardware.
  217. *
  218. * So all gadget drivers must accept that potential error. Some
  219. * hardware supports precise fifo status reporting, letting them
  220. * recover when the actual bytecount matters (e.g. for USB Test
  221. * and Measurement Class devices).
  222. */
  223. __raw_writesb((unsigned long)dreg, buf, count);
  224. csr &= ~SET_FX;
  225. csr |= CLR_FX | AT91_UDP_TXPKTRDY;
  226. __raw_writel(csr, creg);
  227. req->req.actual += count;
  228. PACKET("%s %p in/%d%s\n", ep->ep.name, &req->req, count,
  229. is_last ? " (done)" : "");
  230. if (is_last)
  231. done(ep, req, 0);
  232. return is_last;
  233. }
  234. static void nuke(struct at91_ep *ep, int status)
  235. {
  236. struct at91_request *req;
  237. /* terminate any request in the queue */
  238. ep->stopped = 1;
  239. if (list_empty(&ep->queue))
  240. return;
  241. VDBG("%s %s\n", __func__, ep->ep.name);
  242. while (!list_empty(&ep->queue)) {
  243. req = list_entry(ep->queue.next, struct at91_request, queue);
  244. done(ep, req, status);
  245. }
  246. }
  247. /*-------------------------------------------------------------------------*/
  248. static int at91_ep_enable(struct usb_ep *_ep,
  249. const struct usb_endpoint_descriptor *desc)
  250. {
  251. struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
  252. struct at91_udc *udc;
  253. u16 maxpacket;
  254. u32 tmp;
  255. unsigned long flags;
  256. if (!_ep || !ep
  257. || !desc || _ep->name == ep0name
  258. || desc->bDescriptorType != USB_DT_ENDPOINT
  259. || (maxpacket = usb_endpoint_maxp(desc)) == 0
  260. || maxpacket > ep->maxpacket) {
  261. DBG("bad ep or descriptor\n");
  262. return -EINVAL;
  263. }
  264. udc = ep->udc;
  265. if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
  266. DBG("bogus device state\n");
  267. return -ESHUTDOWN;
  268. }
  269. tmp = usb_endpoint_type(desc);
  270. switch (tmp) {
  271. case USB_ENDPOINT_XFER_CONTROL:
  272. DBG("only one control endpoint\n");
  273. return -EINVAL;
  274. case USB_ENDPOINT_XFER_INT:
  275. if (maxpacket > 64)
  276. goto bogus_max;
  277. break;
  278. case USB_ENDPOINT_XFER_BULK:
  279. switch (maxpacket) {
  280. case 8:
  281. case 16:
  282. case 32:
  283. case 64:
  284. goto ok;
  285. }
  286. bogus_max:
  287. DBG("bogus maxpacket %d\n", maxpacket);
  288. return -EINVAL;
  289. case USB_ENDPOINT_XFER_ISOC:
  290. if (!ep->is_pingpong) {
  291. DBG("iso requires double buffering\n");
  292. return -EINVAL;
  293. }
  294. break;
  295. }
  296. ok:
  297. spin_lock_irqsave(&udc->lock, flags);
  298. /* initialize endpoint to match this descriptor */
  299. ep->is_in = usb_endpoint_dir_in(desc);
  300. ep->is_iso = (tmp == USB_ENDPOINT_XFER_ISOC);
  301. ep->stopped = 0;
  302. if (ep->is_in)
  303. tmp |= 0x04;
  304. tmp <<= 8;
  305. tmp |= AT91_UDP_EPEDS;
  306. __raw_writel(tmp, ep->creg);
  307. ep->ep.maxpacket = maxpacket;
  308. /*
  309. * reset/init endpoint fifo. NOTE: leaves fifo_bank alone,
  310. * since endpoint resets don't reset hw pingpong state.
  311. */
  312. at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
  313. at91_udp_write(udc, AT91_UDP_RST_EP, 0);
  314. spin_unlock_irqrestore(&udc->lock, flags);
  315. return 0;
  316. }
  317. static int at91_ep_disable (struct usb_ep * _ep)
  318. {
  319. struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
  320. struct at91_udc *udc = ep->udc;
  321. unsigned long flags;
  322. if (ep == &ep->udc->ep[0])
  323. return -EINVAL;
  324. spin_lock_irqsave(&udc->lock, flags);
  325. nuke(ep, -ESHUTDOWN);
  326. /* restore the endpoint's pristine config */
  327. ep->ep.desc = NULL;
  328. ep->ep.maxpacket = ep->maxpacket;
  329. /* reset fifos and endpoint */
  330. if (ep->udc->clocked) {
  331. at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
  332. at91_udp_write(udc, AT91_UDP_RST_EP, 0);
  333. __raw_writel(0, ep->creg);
  334. }
  335. spin_unlock_irqrestore(&udc->lock, flags);
  336. return 0;
  337. }
  338. /*
  339. * this is a PIO-only driver, so there's nothing
  340. * interesting for request or buffer allocation.
  341. */
  342. static struct usb_request *
  343. at91_ep_alloc_request(struct usb_ep *_ep, gfp_t gfp_flags)
  344. {
  345. struct at91_request *req;
  346. req = kzalloc(sizeof (struct at91_request), gfp_flags);
  347. if (!req)
  348. return NULL;
  349. INIT_LIST_HEAD(&req->queue);
  350. return &req->req;
  351. }
  352. static void at91_ep_free_request(struct usb_ep *_ep, struct usb_request *_req)
  353. {
  354. struct at91_request *req;
  355. req = container_of(_req, struct at91_request, req);
  356. BUG_ON(!list_empty(&req->queue));
  357. kfree(req);
  358. }
  359. static int at91_ep_queue(struct usb_ep *_ep,
  360. struct usb_request *_req, gfp_t gfp_flags)
  361. {
  362. struct at91_request *req;
  363. struct at91_ep *ep;
  364. struct at91_udc *udc;
  365. int status;
  366. unsigned long flags;
  367. req = container_of(_req, struct at91_request, req);
  368. ep = container_of(_ep, struct at91_ep, ep);
  369. if (!_req || !_req->complete
  370. || !_req->buf || !list_empty(&req->queue)) {
  371. DBG("invalid request\n");
  372. return -EINVAL;
  373. }
  374. if (!_ep || (!ep->ep.desc && ep->ep.name != ep0name)) {
  375. DBG("invalid ep\n");
  376. return -EINVAL;
  377. }
  378. udc = ep->udc;
  379. if (!udc || !udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
  380. DBG("invalid device\n");
  381. return -EINVAL;
  382. }
  383. _req->status = -EINPROGRESS;
  384. _req->actual = 0;
  385. spin_lock_irqsave(&udc->lock, flags);
  386. /* try to kickstart any empty and idle queue */
  387. if (list_empty(&ep->queue) && !ep->stopped) {
  388. int is_ep0;
  389. /*
  390. * If this control request has a non-empty DATA stage, this
  391. * will start that stage. It works just like a non-control
  392. * request (until the status stage starts, maybe early).
  393. *
  394. * If the data stage is empty, then this starts a successful
  395. * IN/STATUS stage. (Unsuccessful ones use set_halt.)
  396. */
  397. is_ep0 = (ep->ep.name == ep0name);
  398. if (is_ep0) {
  399. u32 tmp;
  400. if (!udc->req_pending) {
  401. status = -EINVAL;
  402. goto done;
  403. }
  404. /*
  405. * defer changing CONFG until after the gadget driver
  406. * reconfigures the endpoints.
  407. */
  408. if (udc->wait_for_config_ack) {
  409. tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
  410. tmp ^= AT91_UDP_CONFG;
  411. VDBG("toggle config\n");
  412. at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
  413. }
  414. if (req->req.length == 0) {
  415. ep0_in_status:
  416. PACKET("ep0 in/status\n");
  417. status = 0;
  418. tmp = __raw_readl(ep->creg);
  419. tmp &= ~SET_FX;
  420. tmp |= CLR_FX | AT91_UDP_TXPKTRDY;
  421. __raw_writel(tmp, ep->creg);
  422. udc->req_pending = 0;
  423. goto done;
  424. }
  425. }
  426. if (ep->is_in)
  427. status = write_fifo(ep, req);
  428. else {
  429. status = read_fifo(ep, req);
  430. /* IN/STATUS stage is otherwise triggered by irq */
  431. if (status && is_ep0)
  432. goto ep0_in_status;
  433. }
  434. } else
  435. status = 0;
  436. if (req && !status) {
  437. list_add_tail (&req->queue, &ep->queue);
  438. at91_udp_write(udc, AT91_UDP_IER, ep->int_mask);
  439. }
  440. done:
  441. spin_unlock_irqrestore(&udc->lock, flags);
  442. return (status < 0) ? status : 0;
  443. }
  444. static int at91_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req)
  445. {
  446. struct at91_ep *ep;
  447. struct at91_request *req;
  448. unsigned long flags;
  449. ep = container_of(_ep, struct at91_ep, ep);
  450. if (!_ep || ep->ep.name == ep0name)
  451. return -EINVAL;
  452. spin_lock_irqsave(&udc->lock, flags);
  453. /* make sure it's actually queued on this endpoint */
  454. list_for_each_entry (req, &ep->queue, queue) {
  455. if (&req->req == _req)
  456. break;
  457. }
  458. if (&req->req != _req) {
  459. spin_unlock_irqrestore(&udc->lock, flags);
  460. return -EINVAL;
  461. }
  462. done(ep, req, -ECONNRESET);
  463. spin_unlock_irqrestore(&udc->lock, flags);
  464. return 0;
  465. }
  466. static int at91_ep_set_halt(struct usb_ep *_ep, int value)
  467. {
  468. struct at91_ep *ep = container_of(_ep, struct at91_ep, ep);
  469. struct at91_udc *udc = ep->udc;
  470. u32 __iomem *creg;
  471. u32 csr;
  472. unsigned long flags;
  473. int status = 0;
  474. if (!_ep || ep->is_iso || !ep->udc->clocked)
  475. return -EINVAL;
  476. creg = ep->creg;
  477. spin_lock_irqsave(&udc->lock, flags);
  478. csr = __raw_readl(creg);
  479. /*
  480. * fail with still-busy IN endpoints, ensuring correct sequencing
  481. * of data tx then stall. note that the fifo rx bytecount isn't
  482. * completely accurate as a tx bytecount.
  483. */
  484. if (ep->is_in && (!list_empty(&ep->queue) || (csr >> 16) != 0))
  485. status = -EAGAIN;
  486. else {
  487. csr |= CLR_FX;
  488. csr &= ~SET_FX;
  489. if (value) {
  490. csr |= AT91_UDP_FORCESTALL;
  491. VDBG("halt %s\n", ep->ep.name);
  492. } else {
  493. at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
  494. at91_udp_write(udc, AT91_UDP_RST_EP, 0);
  495. csr &= ~AT91_UDP_FORCESTALL;
  496. }
  497. __raw_writel(csr, creg);
  498. }
  499. spin_unlock_irqrestore(&udc->lock, flags);
  500. return status;
  501. }
  502. static const struct usb_ep_ops at91_ep_ops = {
  503. .enable = at91_ep_enable,
  504. .disable = at91_ep_disable,
  505. .alloc_request = at91_ep_alloc_request,
  506. .free_request = at91_ep_free_request,
  507. .queue = at91_ep_queue,
  508. .dequeue = at91_ep_dequeue,
  509. .set_halt = at91_ep_set_halt,
  510. /* there's only imprecise fifo status reporting */
  511. };
  512. /*-------------------------------------------------------------------------*/
  513. static int at91_get_frame(struct usb_gadget *gadget)
  514. {
  515. struct at91_udc *udc = to_udc(gadget);
  516. if (!to_udc(gadget)->clocked)
  517. return -EINVAL;
  518. return at91_udp_read(udc, AT91_UDP_FRM_NUM) & AT91_UDP_NUM;
  519. }
  520. static int at91_wakeup(struct usb_gadget *gadget)
  521. {
  522. struct at91_udc *udc = to_udc(gadget);
  523. u32 glbstate;
  524. int status = -EINVAL;
  525. unsigned long flags;
  526. DBG("%s\n", __func__ );
  527. spin_lock_irqsave(&udc->lock, flags);
  528. if (!udc->clocked || !udc->suspended)
  529. goto done;
  530. /* NOTE: some "early versions" handle ESR differently ... */
  531. glbstate = at91_udp_read(udc, AT91_UDP_GLB_STAT);
  532. if (!(glbstate & AT91_UDP_ESR))
  533. goto done;
  534. glbstate |= AT91_UDP_ESR;
  535. at91_udp_write(udc, AT91_UDP_GLB_STAT, glbstate);
  536. done:
  537. spin_unlock_irqrestore(&udc->lock, flags);
  538. return status;
  539. }
  540. /* reinit == restore initial software state */
  541. static void udc_reinit(struct at91_udc *udc)
  542. {
  543. u32 i;
  544. INIT_LIST_HEAD(&udc->gadget.ep_list);
  545. INIT_LIST_HEAD(&udc->gadget.ep0->ep_list);
  546. for (i = 0; i < NUM_ENDPOINTS; i++) {
  547. struct at91_ep *ep = &udc->ep[i];
  548. if (i != 0)
  549. list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
  550. ep->ep.desc = NULL;
  551. ep->stopped = 0;
  552. ep->fifo_bank = 0;
  553. usb_ep_set_maxpacket_limit(&ep->ep, ep->maxpacket);
  554. ep->creg = (void __iomem *) udc->udp_baseaddr + AT91_UDP_CSR(i);
  555. /* initialize one queue per endpoint */
  556. INIT_LIST_HEAD(&ep->queue);
  557. }
  558. }
  559. static void reset_gadget(struct at91_udc *udc)
  560. {
  561. struct usb_gadget_driver *driver = udc->driver;
  562. int i;
  563. if (udc->gadget.speed == USB_SPEED_UNKNOWN)
  564. driver = NULL;
  565. udc->gadget.speed = USB_SPEED_UNKNOWN;
  566. udc->suspended = 0;
  567. for (i = 0; i < NUM_ENDPOINTS; i++) {
  568. struct at91_ep *ep = &udc->ep[i];
  569. ep->stopped = 1;
  570. nuke(ep, -ESHUTDOWN);
  571. }
  572. if (driver) {
  573. spin_unlock(&udc->lock);
  574. udc->driver->disconnect(&udc->gadget);
  575. spin_lock(&udc->lock);
  576. }
  577. udc_reinit(udc);
  578. }
  579. static void stop_activity(struct at91_udc *udc)
  580. {
  581. struct usb_gadget_driver *driver = udc->driver;
  582. int i;
  583. if (udc->gadget.speed == USB_SPEED_UNKNOWN)
  584. driver = NULL;
  585. udc->gadget.speed = USB_SPEED_UNKNOWN;
  586. udc->suspended = 0;
  587. for (i = 0; i < NUM_ENDPOINTS; i++) {
  588. struct at91_ep *ep = &udc->ep[i];
  589. ep->stopped = 1;
  590. nuke(ep, -ESHUTDOWN);
  591. }
  592. if (driver) {
  593. spin_unlock(&udc->lock);
  594. driver->disconnect(&udc->gadget);
  595. spin_lock(&udc->lock);
  596. }
  597. udc_reinit(udc);
  598. }
  599. static void clk_on(struct at91_udc *udc)
  600. {
  601. if (udc->clocked)
  602. return;
  603. udc->clocked = 1;
  604. }
  605. static void clk_off(struct at91_udc *udc)
  606. {
  607. if (!udc->clocked)
  608. return;
  609. udc->clocked = 0;
  610. udc->gadget.speed = USB_SPEED_UNKNOWN;
  611. }
  612. /*
  613. * activate/deactivate link with host; minimize power usage for
  614. * inactive links by cutting clocks and transceiver power.
  615. */
  616. static void pullup(struct at91_udc *udc, int is_on)
  617. {
  618. if (!udc->enabled || !udc->vbus)
  619. is_on = 0;
  620. DBG("%sactive\n", is_on ? "" : "in");
  621. if (is_on) {
  622. clk_on(udc);
  623. at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
  624. at91_udp_write(udc, AT91_UDP_TXVC, 0);
  625. } else {
  626. stop_activity(udc);
  627. at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
  628. at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
  629. clk_off(udc);
  630. }
  631. if (udc->caps && udc->caps->pullup)
  632. udc->caps->pullup(udc, is_on);
  633. }
  634. /* vbus is here! turn everything on that's ready */
  635. static int at91_vbus_session(struct usb_gadget *gadget, int is_active)
  636. {
  637. struct at91_udc *udc = to_udc(gadget);
  638. unsigned long flags;
  639. /* VDBG("vbus %s\n", is_active ? "on" : "off"); */
  640. spin_lock_irqsave(&udc->lock, flags);
  641. udc->vbus = (is_active != 0);
  642. if (udc->driver)
  643. pullup(udc, is_active);
  644. else
  645. pullup(udc, 0);
  646. spin_unlock_irqrestore(&udc->lock, flags);
  647. return 0;
  648. }
  649. static int at91_pullup(struct usb_gadget *gadget, int is_on)
  650. {
  651. struct at91_udc *udc = to_udc(gadget);
  652. unsigned long flags;
  653. spin_lock_irqsave(&udc->lock, flags);
  654. udc->enabled = is_on = !!is_on;
  655. pullup(udc, is_on);
  656. spin_unlock_irqrestore(&udc->lock, flags);
  657. return 0;
  658. }
  659. static int at91_set_selfpowered(struct usb_gadget *gadget, int is_on)
  660. {
  661. struct at91_udc *udc = to_udc(gadget);
  662. unsigned long flags;
  663. spin_lock_irqsave(&udc->lock, flags);
  664. udc->selfpowered = (is_on != 0);
  665. spin_unlock_irqrestore(&udc->lock, flags);
  666. return 0;
  667. }
  668. static int at91_start(struct usb_gadget *gadget,
  669. struct usb_gadget_driver *driver);
  670. static int at91_stop(struct usb_gadget *gadget);
  671. static const struct usb_gadget_ops at91_udc_ops = {
  672. .get_frame = at91_get_frame,
  673. .wakeup = at91_wakeup,
  674. .set_selfpowered = at91_set_selfpowered,
  675. .vbus_session = at91_vbus_session,
  676. .pullup = at91_pullup,
  677. .udc_start = at91_start,
  678. .udc_stop = at91_stop,
  679. /*
  680. * VBUS-powered devices may also also want to support bigger
  681. * power budgets after an appropriate SET_CONFIGURATION.
  682. */
  683. /* .vbus_power = at91_vbus_power, */
  684. };
  685. /*-------------------------------------------------------------------------*/
  686. static int handle_ep(struct at91_ep *ep)
  687. {
  688. struct at91_request *req;
  689. u32 __iomem *creg = ep->creg;
  690. u32 csr = __raw_readl(creg);
  691. if (!list_empty(&ep->queue))
  692. req = list_entry(ep->queue.next,
  693. struct at91_request, queue);
  694. else
  695. req = NULL;
  696. if (ep->is_in) {
  697. if (csr & (AT91_UDP_STALLSENT | AT91_UDP_TXCOMP)) {
  698. csr |= CLR_FX;
  699. csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_TXCOMP);
  700. __raw_writel(csr, creg);
  701. }
  702. if (req)
  703. return write_fifo(ep, req);
  704. } else {
  705. if (csr & AT91_UDP_STALLSENT) {
  706. /* STALLSENT bit == ISOERR */
  707. if (ep->is_iso && req)
  708. req->req.status = -EILSEQ;
  709. csr |= CLR_FX;
  710. csr &= ~(SET_FX | AT91_UDP_STALLSENT);
  711. __raw_writel(csr, creg);
  712. csr = __raw_readl(creg);
  713. }
  714. if (req && (csr & RX_DATA_READY))
  715. return read_fifo(ep, req);
  716. }
  717. return 0;
  718. }
  719. union setup {
  720. u8 raw[8];
  721. struct usb_ctrlrequest r;
  722. };
  723. static void handle_setup(struct at91_udc *udc, struct at91_ep *ep, u32 csr)
  724. {
  725. u32 __iomem *creg = ep->creg;
  726. u8 __iomem *dreg = ep->creg + (AT91_UDP_FDR(0) - AT91_UDP_CSR(0));
  727. unsigned rxcount, i = 0;
  728. u32 tmp;
  729. union setup pkt;
  730. int status = 0;
  731. /* read and ack SETUP; hard-fail for bogus packets */
  732. rxcount = (csr & AT91_UDP_RXBYTECNT) >> 16;
  733. if (likely(rxcount == 8)) {
  734. while (rxcount--)
  735. pkt.raw[i++] = __raw_readb(dreg);
  736. if (pkt.r.bRequestType & USB_DIR_IN) {
  737. csr |= AT91_UDP_DIR;
  738. ep->is_in = 1;
  739. } else {
  740. csr &= ~AT91_UDP_DIR;
  741. ep->is_in = 0;
  742. }
  743. } else {
  744. /* REVISIT this happens sometimes under load; why?? */
  745. ERR("SETUP len %d, csr %08x\n", rxcount, csr);
  746. status = -EINVAL;
  747. }
  748. csr |= CLR_FX;
  749. csr &= ~(SET_FX | AT91_UDP_RXSETUP);
  750. __raw_writel(csr, creg);
  751. udc->wait_for_addr_ack = 0;
  752. udc->wait_for_config_ack = 0;
  753. ep->stopped = 0;
  754. if (unlikely(status != 0))
  755. goto stall;
  756. #define w_index le16_to_cpu(pkt.r.wIndex)
  757. #define w_value le16_to_cpu(pkt.r.wValue)
  758. #define w_length le16_to_cpu(pkt.r.wLength)
  759. VDBG("SETUP %02x.%02x v%04x i%04x l%04x\n",
  760. pkt.r.bRequestType, pkt.r.bRequest,
  761. w_value, w_index, w_length);
  762. /*
  763. * A few standard requests get handled here, ones that touch
  764. * hardware ... notably for device and endpoint features.
  765. */
  766. udc->req_pending = 1;
  767. csr = __raw_readl(creg);
  768. csr |= CLR_FX;
  769. csr &= ~SET_FX;
  770. switch ((pkt.r.bRequestType << 8) | pkt.r.bRequest) {
  771. case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
  772. | USB_REQ_SET_ADDRESS:
  773. __raw_writel(csr | AT91_UDP_TXPKTRDY, creg);
  774. udc->addr = w_value;
  775. udc->wait_for_addr_ack = 1;
  776. udc->req_pending = 0;
  777. /* FADDR is set later, when we ack host STATUS */
  778. return;
  779. case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
  780. | USB_REQ_SET_CONFIGURATION:
  781. tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_CONFG;
  782. if (pkt.r.wValue)
  783. udc->wait_for_config_ack = (tmp == 0);
  784. else
  785. udc->wait_for_config_ack = (tmp != 0);
  786. if (udc->wait_for_config_ack)
  787. VDBG("wait for config\n");
  788. /* CONFG is toggled later, if gadget driver succeeds */
  789. break;
  790. /*
  791. * Hosts may set or clear remote wakeup status, and
  792. * devices may report they're VBUS powered.
  793. */
  794. case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
  795. | USB_REQ_GET_STATUS:
  796. tmp = (udc->selfpowered << USB_DEVICE_SELF_POWERED);
  797. if (at91_udp_read(udc, AT91_UDP_GLB_STAT) & AT91_UDP_ESR)
  798. tmp |= (1 << USB_DEVICE_REMOTE_WAKEUP);
  799. PACKET("get device status\n");
  800. __raw_writeb(tmp, dreg);
  801. __raw_writeb(0, dreg);
  802. goto write_in;
  803. /* then STATUS starts later, automatically */
  804. case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
  805. | USB_REQ_SET_FEATURE:
  806. if (w_value != USB_DEVICE_REMOTE_WAKEUP)
  807. goto stall;
  808. tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
  809. tmp |= AT91_UDP_ESR;
  810. at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
  811. goto succeed;
  812. case ((USB_TYPE_STANDARD|USB_RECIP_DEVICE) << 8)
  813. | USB_REQ_CLEAR_FEATURE:
  814. if (w_value != USB_DEVICE_REMOTE_WAKEUP)
  815. goto stall;
  816. tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
  817. tmp &= ~AT91_UDP_ESR;
  818. at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
  819. goto succeed;
  820. /*
  821. * Interfaces have no feature settings; this is pretty useless.
  822. * we won't even insist the interface exists...
  823. */
  824. case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
  825. | USB_REQ_GET_STATUS:
  826. PACKET("get interface status\n");
  827. __raw_writeb(0, dreg);
  828. __raw_writeb(0, dreg);
  829. goto write_in;
  830. /* then STATUS starts later, automatically */
  831. case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
  832. | USB_REQ_SET_FEATURE:
  833. case ((USB_TYPE_STANDARD|USB_RECIP_INTERFACE) << 8)
  834. | USB_REQ_CLEAR_FEATURE:
  835. goto stall;
  836. /*
  837. * Hosts may clear bulk/intr endpoint halt after the gadget
  838. * driver sets it (not widely used); or set it (for testing)
  839. */
  840. case ((USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
  841. | USB_REQ_GET_STATUS:
  842. tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
  843. ep = &udc->ep[tmp];
  844. if (tmp >= NUM_ENDPOINTS || (tmp && !ep->ep.desc))
  845. goto stall;
  846. if (tmp) {
  847. if ((w_index & USB_DIR_IN)) {
  848. if (!ep->is_in)
  849. goto stall;
  850. } else if (ep->is_in)
  851. goto stall;
  852. }
  853. PACKET("get %s status\n", ep->ep.name);
  854. if (__raw_readl(ep->creg) & AT91_UDP_FORCESTALL)
  855. tmp = (1 << USB_ENDPOINT_HALT);
  856. else
  857. tmp = 0;
  858. __raw_writeb(tmp, dreg);
  859. __raw_writeb(0, dreg);
  860. goto write_in;
  861. /* then STATUS starts later, automatically */
  862. case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
  863. | USB_REQ_SET_FEATURE:
  864. tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
  865. ep = &udc->ep[tmp];
  866. if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
  867. goto stall;
  868. if (!ep->ep.desc || ep->is_iso)
  869. goto stall;
  870. if ((w_index & USB_DIR_IN)) {
  871. if (!ep->is_in)
  872. goto stall;
  873. } else if (ep->is_in)
  874. goto stall;
  875. tmp = __raw_readl(ep->creg);
  876. tmp &= ~SET_FX;
  877. tmp |= CLR_FX | AT91_UDP_FORCESTALL;
  878. __raw_writel(tmp, ep->creg);
  879. goto succeed;
  880. case ((USB_TYPE_STANDARD|USB_RECIP_ENDPOINT) << 8)
  881. | USB_REQ_CLEAR_FEATURE:
  882. tmp = w_index & USB_ENDPOINT_NUMBER_MASK;
  883. ep = &udc->ep[tmp];
  884. if (w_value != USB_ENDPOINT_HALT || tmp >= NUM_ENDPOINTS)
  885. goto stall;
  886. if (tmp == 0)
  887. goto succeed;
  888. if (!ep->ep.desc || ep->is_iso)
  889. goto stall;
  890. if ((w_index & USB_DIR_IN)) {
  891. if (!ep->is_in)
  892. goto stall;
  893. } else if (ep->is_in)
  894. goto stall;
  895. at91_udp_write(udc, AT91_UDP_RST_EP, ep->int_mask);
  896. at91_udp_write(udc, AT91_UDP_RST_EP, 0);
  897. tmp = __raw_readl(ep->creg);
  898. tmp |= CLR_FX;
  899. tmp &= ~(SET_FX | AT91_UDP_FORCESTALL);
  900. __raw_writel(tmp, ep->creg);
  901. if (!list_empty(&ep->queue))
  902. handle_ep(ep);
  903. goto succeed;
  904. }
  905. #undef w_value
  906. #undef w_index
  907. #undef w_length
  908. /* pass request up to the gadget driver */
  909. if (udc->driver) {
  910. spin_unlock(&udc->lock);
  911. status = udc->driver->setup(&udc->gadget, &pkt.r);
  912. spin_lock(&udc->lock);
  913. }
  914. else
  915. status = -ENODEV;
  916. if (status < 0) {
  917. stall:
  918. VDBG("req %02x.%02x protocol STALL; stat %d\n",
  919. pkt.r.bRequestType, pkt.r.bRequest, status);
  920. csr |= AT91_UDP_FORCESTALL;
  921. __raw_writel(csr, creg);
  922. udc->req_pending = 0;
  923. }
  924. return;
  925. succeed:
  926. /* immediate successful (IN) STATUS after zero length DATA */
  927. PACKET("ep0 in/status\n");
  928. write_in:
  929. csr |= AT91_UDP_TXPKTRDY;
  930. __raw_writel(csr, creg);
  931. udc->req_pending = 0;
  932. }
  933. static void handle_ep0(struct at91_udc *udc)
  934. {
  935. struct at91_ep *ep0 = &udc->ep[0];
  936. u32 __iomem *creg = ep0->creg;
  937. u32 csr = __raw_readl(creg);
  938. struct at91_request *req;
  939. if (unlikely(csr & AT91_UDP_STALLSENT)) {
  940. nuke(ep0, -EPROTO);
  941. udc->req_pending = 0;
  942. csr |= CLR_FX;
  943. csr &= ~(SET_FX | AT91_UDP_STALLSENT | AT91_UDP_FORCESTALL);
  944. __raw_writel(csr, creg);
  945. VDBG("ep0 stalled\n");
  946. csr = __raw_readl(creg);
  947. }
  948. if (csr & AT91_UDP_RXSETUP) {
  949. nuke(ep0, 0);
  950. udc->req_pending = 0;
  951. handle_setup(udc, ep0, csr);
  952. return;
  953. }
  954. if (list_empty(&ep0->queue))
  955. req = NULL;
  956. else
  957. req = list_entry(ep0->queue.next, struct at91_request, queue);
  958. /* host ACKed an IN packet that we sent */
  959. if (csr & AT91_UDP_TXCOMP) {
  960. csr |= CLR_FX;
  961. csr &= ~(SET_FX | AT91_UDP_TXCOMP);
  962. /* write more IN DATA? */
  963. if (req && ep0->is_in) {
  964. if (handle_ep(ep0))
  965. udc->req_pending = 0;
  966. /*
  967. * Ack after:
  968. * - last IN DATA packet (including GET_STATUS)
  969. * - IN/STATUS for OUT DATA
  970. * - IN/STATUS for any zero-length DATA stage
  971. * except for the IN DATA case, the host should send
  972. * an OUT status later, which we'll ack.
  973. */
  974. } else {
  975. udc->req_pending = 0;
  976. __raw_writel(csr, creg);
  977. /*
  978. * SET_ADDRESS takes effect only after the STATUS
  979. * (to the original address) gets acked.
  980. */
  981. if (udc->wait_for_addr_ack) {
  982. u32 tmp;
  983. at91_udp_write(udc, AT91_UDP_FADDR,
  984. AT91_UDP_FEN | udc->addr);
  985. tmp = at91_udp_read(udc, AT91_UDP_GLB_STAT);
  986. tmp &= ~AT91_UDP_FADDEN;
  987. if (udc->addr)
  988. tmp |= AT91_UDP_FADDEN;
  989. at91_udp_write(udc, AT91_UDP_GLB_STAT, tmp);
  990. udc->wait_for_addr_ack = 0;
  991. VDBG("address %d\n", udc->addr);
  992. }
  993. }
  994. }
  995. /* OUT packet arrived ... */
  996. else if (csr & AT91_UDP_RX_DATA_BK0) {
  997. csr |= CLR_FX;
  998. csr &= ~(SET_FX | AT91_UDP_RX_DATA_BK0);
  999. /* OUT DATA stage */
  1000. if (!ep0->is_in) {
  1001. if (req) {
  1002. if (handle_ep(ep0)) {
  1003. /* send IN/STATUS */
  1004. PACKET("ep0 in/status\n");
  1005. csr = __raw_readl(creg);
  1006. csr &= ~SET_FX;
  1007. csr |= CLR_FX | AT91_UDP_TXPKTRDY;
  1008. __raw_writel(csr, creg);
  1009. udc->req_pending = 0;
  1010. }
  1011. } else if (udc->req_pending) {
  1012. /*
  1013. * AT91 hardware has a hard time with this
  1014. * "deferred response" mode for control-OUT
  1015. * transfers. (For control-IN it's fine.)
  1016. *
  1017. * The normal solution leaves OUT data in the
  1018. * fifo until the gadget driver is ready.
  1019. * We couldn't do that here without disabling
  1020. * the IRQ that tells about SETUP packets,
  1021. * e.g. when the host gets impatient...
  1022. *
  1023. * Working around it by copying into a buffer
  1024. * would almost be a non-deferred response,
  1025. * except that it wouldn't permit reliable
  1026. * stalling of the request. Instead, demand
  1027. * that gadget drivers not use this mode.
  1028. */
  1029. DBG("no control-OUT deferred responses!\n");
  1030. __raw_writel(csr | AT91_UDP_FORCESTALL, creg);
  1031. udc->req_pending = 0;
  1032. }
  1033. /* STATUS stage for control-IN; ack. */
  1034. } else {
  1035. PACKET("ep0 out/status ACK\n");
  1036. __raw_writel(csr, creg);
  1037. /* "early" status stage */
  1038. if (req)
  1039. done(ep0, req, 0);
  1040. }
  1041. }
  1042. }
  1043. static irqreturn_t at91_udc_irq(struct at91_udc *udc)
  1044. {
  1045. u32 rescans = 5;
  1046. int disable_clock = 0;
  1047. unsigned long flags;
  1048. spin_lock_irqsave(&udc->lock, flags);
  1049. if (!udc->clocked) {
  1050. clk_on(udc);
  1051. disable_clock = 1;
  1052. }
  1053. while (rescans--) {
  1054. u32 status;
  1055. status = at91_udp_read(udc, AT91_UDP_ISR)
  1056. & at91_udp_read(udc, AT91_UDP_IMR);
  1057. if (!status)
  1058. break;
  1059. /* USB reset irq: not maskable */
  1060. if (status & AT91_UDP_ENDBUSRES) {
  1061. at91_udp_write(udc, AT91_UDP_IDR, ~MINIMUS_INTERRUPTUS);
  1062. at91_udp_write(udc, AT91_UDP_IER, MINIMUS_INTERRUPTUS);
  1063. /* Atmel code clears this irq twice */
  1064. at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
  1065. at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_ENDBUSRES);
  1066. VDBG("end bus reset\n");
  1067. udc->addr = 0;
  1068. reset_gadget(udc);
  1069. /* enable ep0 */
  1070. at91_udp_write(udc, AT91_UDP_CSR(0),
  1071. AT91_UDP_EPEDS | AT91_UDP_EPTYPE_CTRL);
  1072. udc->gadget.speed = USB_SPEED_FULL;
  1073. udc->suspended = 0;
  1074. at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_EP(0));
  1075. /*
  1076. * NOTE: this driver keeps clocks off unless the
  1077. * USB host is present. That saves power, but for
  1078. * boards that don't support VBUS detection, both
  1079. * clocks need to be active most of the time.
  1080. */
  1081. /* host initiated suspend (3+ms bus idle) */
  1082. } else if (status & AT91_UDP_RXSUSP) {
  1083. at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXSUSP);
  1084. at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXRSM);
  1085. at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXSUSP);
  1086. /* VDBG("bus suspend\n"); */
  1087. if (udc->suspended)
  1088. continue;
  1089. udc->suspended = 1;
  1090. /*
  1091. * NOTE: when suspending a VBUS-powered device, the
  1092. * gadget driver should switch into slow clock mode
  1093. * and then into standby to avoid drawing more than
  1094. * 500uA power (2500uA for some high-power configs).
  1095. */
  1096. if (udc->driver && udc->driver->suspend) {
  1097. spin_unlock(&udc->lock);
  1098. udc->driver->suspend(&udc->gadget);
  1099. spin_lock(&udc->lock);
  1100. }
  1101. /* host initiated resume */
  1102. } else if (status & AT91_UDP_RXRSM) {
  1103. at91_udp_write(udc, AT91_UDP_IDR, AT91_UDP_RXRSM);
  1104. at91_udp_write(udc, AT91_UDP_IER, AT91_UDP_RXSUSP);
  1105. at91_udp_write(udc, AT91_UDP_ICR, AT91_UDP_RXRSM);
  1106. /* VDBG("bus resume\n"); */
  1107. if (!udc->suspended)
  1108. continue;
  1109. udc->suspended = 0;
  1110. /*
  1111. * NOTE: for a VBUS-powered device, the gadget driver
  1112. * would normally want to switch out of slow clock
  1113. * mode into normal mode.
  1114. */
  1115. if (udc->driver && udc->driver->resume) {
  1116. spin_unlock(&udc->lock);
  1117. udc->driver->resume(&udc->gadget);
  1118. spin_lock(&udc->lock);
  1119. }
  1120. /* endpoint IRQs are cleared by handling them */
  1121. } else {
  1122. int i;
  1123. unsigned mask = 1;
  1124. struct at91_ep *ep = &udc->ep[1];
  1125. if (status & mask)
  1126. handle_ep0(udc);
  1127. for (i = 1; i < NUM_ENDPOINTS; i++) {
  1128. mask <<= 1;
  1129. if (status & mask)
  1130. handle_ep(ep);
  1131. ep++;
  1132. }
  1133. }
  1134. }
  1135. if (disable_clock)
  1136. clk_off(udc);
  1137. spin_unlock_irqrestore(&udc->lock, flags);
  1138. return IRQ_HANDLED;
  1139. }
  1140. /*-------------------------------------------------------------------------*/
  1141. static int at91_start(struct usb_gadget *gadget,
  1142. struct usb_gadget_driver *driver)
  1143. {
  1144. struct at91_udc *udc = controller;
  1145. udc->driver = driver;
  1146. udc->enabled = 1;
  1147. udc->selfpowered = 1;
  1148. return 0;
  1149. }
  1150. static int at91_stop(struct usb_gadget *gadget)
  1151. {
  1152. struct at91_udc *udc = controller;
  1153. unsigned long flags;
  1154. spin_lock_irqsave(&udc->lock, flags);
  1155. udc->enabled = 0;
  1156. at91_udp_write(udc, AT91_UDP_IDR, ~0);
  1157. spin_unlock_irqrestore(&udc->lock, flags);
  1158. udc->driver = NULL;
  1159. return 0;
  1160. }
  1161. /*-------------------------------------------------------------------------*/
  1162. #if defined(CONFIG_AT91SAM9260) || defined(CONFIG_AT91SAM9G20)
  1163. static int at91sam9260_udc_init(struct at91_udc *udc)
  1164. {
  1165. struct at91_ep *ep;
  1166. int i;
  1167. for (i = 0; i < NUM_ENDPOINTS; i++) {
  1168. ep = &udc->ep[i];
  1169. switch (i) {
  1170. case 0 ... 3:
  1171. ep->maxpacket = 64;
  1172. break;
  1173. case 4 ... 5:
  1174. ep->maxpacket = 512;
  1175. break;
  1176. }
  1177. }
  1178. return 0;
  1179. }
  1180. static void at91sam9260_udc_pullup(struct at91_udc *udc, int is_on)
  1181. {
  1182. u32 txvc = at91_udp_read(udc, AT91_UDP_TXVC);
  1183. if (is_on)
  1184. txvc |= AT91_UDP_TXVC_PUON;
  1185. else
  1186. txvc &= ~AT91_UDP_TXVC_PUON;
  1187. at91_udp_write(udc, AT91_UDP_TXVC, txvc);
  1188. }
  1189. static const struct at91_udc_caps at91sam9260_udc_caps = {
  1190. .init = at91sam9260_udc_init,
  1191. .pullup = at91sam9260_udc_pullup,
  1192. };
  1193. #endif
  1194. #if defined(CONFIG_AT91SAM9261)
  1195. static int at91sam9261_udc_init(struct at91_udc *udc)
  1196. {
  1197. struct at91_ep *ep;
  1198. int i;
  1199. for (i = 0; i < NUM_ENDPOINTS; i++) {
  1200. ep = &udc->ep[i];
  1201. switch (i) {
  1202. case 0:
  1203. ep->maxpacket = 8;
  1204. break;
  1205. case 1 ... 3:
  1206. ep->maxpacket = 64;
  1207. break;
  1208. case 4 ... 5:
  1209. ep->maxpacket = 256;
  1210. break;
  1211. }
  1212. }
  1213. udc->matrix = (struct at91_matrix *)ATMEL_BASE_MATRIX;
  1214. if (IS_ERR(udc->matrix))
  1215. return PTR_ERR(udc->matrix);
  1216. return 0;
  1217. }
  1218. static void at91sam9261_udc_pullup(struct at91_udc *udc, int is_on)
  1219. {
  1220. u32 usbpucr = 0;
  1221. usbpucr = readl(&udc->matrix->pucr);
  1222. if (is_on)
  1223. usbpucr |= AT91_MATRIX_USBPUCR_PUON;
  1224. writel(usbpucr, &udc->matrix->pucr);
  1225. }
  1226. static const struct at91_udc_caps at91sam9261_udc_caps = {
  1227. .init = at91sam9261_udc_init,
  1228. .pullup = at91sam9261_udc_pullup,
  1229. };
  1230. #endif
  1231. int usb_gadget_handle_interrupts(int index)
  1232. {
  1233. struct at91_udc *udc = controller;
  1234. return at91_udc_irq(udc);
  1235. }
  1236. int usb_gadget_register_driver(struct usb_gadget_driver *driver)
  1237. {
  1238. struct at91_udc *udc = controller;
  1239. int ret;
  1240. if (!driver || !driver->bind || !driver->setup) {
  1241. printf("bad paramter\n");
  1242. return -EINVAL;
  1243. }
  1244. if (udc->driver) {
  1245. printf("UDC already has a gadget driver\n");
  1246. return -EBUSY;
  1247. }
  1248. at91_start(&udc->gadget, driver);
  1249. udc->driver = driver;
  1250. ret = driver->bind(&udc->gadget);
  1251. if (ret) {
  1252. pr_err("driver->bind() returned %d\n", ret);
  1253. udc->driver = NULL;
  1254. }
  1255. return ret;
  1256. }
  1257. int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
  1258. {
  1259. struct at91_udc *udc = controller;
  1260. if (!driver || !driver->unbind || !driver->disconnect) {
  1261. pr_err("bad paramter\n");
  1262. return -EINVAL;
  1263. }
  1264. driver->disconnect(&udc->gadget);
  1265. driver->unbind(&udc->gadget);
  1266. udc->driver = NULL;
  1267. at91_stop(&udc->gadget);
  1268. return 0;
  1269. }
  1270. int at91_udc_probe(struct at91_udc_data *pdata)
  1271. {
  1272. struct at91_udc *udc;
  1273. int retval;
  1274. struct at91_ep *ep;
  1275. int i;
  1276. udc = kzalloc(sizeof(*udc), GFP_KERNEL);
  1277. if (!udc)
  1278. return -ENOMEM;
  1279. controller = udc;
  1280. memcpy(&udc->board, pdata, sizeof(struct at91_udc_data));
  1281. if (udc->board.vbus_pin) {
  1282. printf("%s: gpio vbus pin not supported yet.\n", __func__);
  1283. return -ENXIO;
  1284. } else {
  1285. DBG("no VBUS detection, assuming always-on\n");
  1286. udc->vbus = 1;
  1287. }
  1288. #if defined(CONFIG_AT91SAM9260) || defined(CONFIG_AT91SAM9G20)
  1289. udc->caps = &at91sam9260_udc_caps;
  1290. #endif
  1291. udc->enabled = 0;
  1292. spin_lock_init(&udc->lock);
  1293. udc->gadget.ops = &at91_udc_ops;
  1294. udc->gadget.ep0 = &udc->ep[0].ep;
  1295. udc->gadget.name = driver_name;
  1296. for (i = 0; i < NUM_ENDPOINTS; i++) {
  1297. ep = &udc->ep[i];
  1298. ep->ep.name = ep_names[i];
  1299. ep->ep.ops = &at91_ep_ops;
  1300. ep->udc = udc;
  1301. ep->int_mask = (1 << i);
  1302. if (i != 0 && i != 3)
  1303. ep->is_pingpong = 1;
  1304. }
  1305. udc->udp_baseaddr = (void *)udc->board.baseaddr;
  1306. if (IS_ERR(udc->udp_baseaddr))
  1307. return PTR_ERR(udc->udp_baseaddr);
  1308. if (udc->caps && udc->caps->init) {
  1309. retval = udc->caps->init(udc);
  1310. if (retval)
  1311. return retval;
  1312. }
  1313. udc_reinit(udc);
  1314. at91_udp_write(udc, AT91_UDP_TXVC, AT91_UDP_TXVC_TXVDIS);
  1315. at91_udp_write(udc, AT91_UDP_IDR, 0xffffffff);
  1316. /* Clear all pending interrupts - UDP may be used by bootloader. */
  1317. at91_udp_write(udc, AT91_UDP_ICR, 0xffffffff);
  1318. INFO("%s version %s\n", driver_name, DRIVER_VERSION);
  1319. return 0;
  1320. }