at91_udc.c 37 KB

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