mtu3_gadget_ep0.c 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * mtu3_gadget_ep0.c - MediaTek USB3 DRD peripheral driver ep0 handling
  4. *
  5. * Copyright (c) 2016 MediaTek Inc.
  6. *
  7. * Author: Chunfeng.Yun <chunfeng.yun@mediatek.com>
  8. */
  9. #include <linux/usb/composite.h>
  10. #include "mtu3.h"
  11. /* ep0 is always mtu3->in_eps[0] */
  12. #define next_ep0_request(mtu) next_request((mtu)->ep0)
  13. /* for high speed test mode; see USB 2.0 spec 7.1.20 */
  14. static const u8 mtu3_test_packet[53] = {
  15. /* implicit SYNC then DATA0 to start */
  16. /* JKJKJKJK x9 */
  17. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  18. /* JJKKJJKK x8 */
  19. 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
  20. /* JJJJKKKK x8 */
  21. 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee,
  22. /* JJJJJJJKKKKKKK x8 */
  23. 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  24. /* JJJJJJJK x8 */
  25. 0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd,
  26. /* JKKKKKKK x10, JK */
  27. 0xfc, 0x7e, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0x7e,
  28. /* implicit CRC16 then EOP to end */
  29. };
  30. static char *decode_ep0_state(struct mtu3 *mtu)
  31. {
  32. switch (mtu->ep0_state) {
  33. case MU3D_EP0_STATE_SETUP:
  34. return "SETUP";
  35. case MU3D_EP0_STATE_TX:
  36. return "IN";
  37. case MU3D_EP0_STATE_RX:
  38. return "OUT";
  39. case MU3D_EP0_STATE_TX_END:
  40. return "TX-END";
  41. case MU3D_EP0_STATE_STALL:
  42. return "STALL";
  43. default:
  44. return "??";
  45. }
  46. }
  47. static void ep0_req_giveback(struct mtu3 *mtu, struct usb_request *req)
  48. {
  49. mtu3_req_complete(mtu->ep0, req, 0);
  50. }
  51. static int
  52. forward_to_driver(struct mtu3 *mtu, const struct usb_ctrlrequest *setup)
  53. __releases(mtu->lock)
  54. __acquires(mtu->lock)
  55. {
  56. int ret;
  57. if (!mtu->gadget_driver)
  58. return -EOPNOTSUPP;
  59. spin_unlock(&mtu->lock);
  60. ret = mtu->gadget_driver->setup(&mtu->g, setup);
  61. spin_lock(&mtu->lock);
  62. dev_dbg(mtu->dev, "%s ret %d\n", __func__, ret);
  63. return ret;
  64. }
  65. static void ep0_write_fifo(struct mtu3_ep *mep, const u8 *src, u16 len)
  66. {
  67. void __iomem *fifo = mep->mtu->mac_base + U3D_FIFO0;
  68. u16 index = 0;
  69. dev_dbg(mep->mtu->dev, "%s: ep%din, len=%d, buf=%p\n",
  70. __func__, mep->epnum, len, src);
  71. if (len >= 4) {
  72. iowrite32_rep(fifo, src, len >> 2);
  73. index = len & ~0x03;
  74. }
  75. if (len & 0x02) {
  76. writew(*(u16 *)&src[index], fifo);
  77. index += 2;
  78. }
  79. if (len & 0x01)
  80. writeb(src[index], fifo);
  81. }
  82. static void ep0_read_fifo(struct mtu3_ep *mep, u8 *dst, u16 len)
  83. {
  84. void __iomem *fifo = mep->mtu->mac_base + U3D_FIFO0;
  85. u32 value;
  86. u16 index = 0;
  87. dev_dbg(mep->mtu->dev, "%s: ep%dout len=%d buf=%p\n",
  88. __func__, mep->epnum, len, dst);
  89. if (len >= 4) {
  90. ioread32_rep(fifo, dst, len >> 2);
  91. index = len & ~0x03;
  92. }
  93. if (len & 0x3) {
  94. value = readl(fifo);
  95. memcpy(&dst[index], &value, len & 0x3);
  96. }
  97. }
  98. static void ep0_load_test_packet(struct mtu3 *mtu)
  99. {
  100. /*
  101. * because the length of test packet is less than max packet of HS ep0,
  102. * write it into fifo directly.
  103. */
  104. ep0_write_fifo(mtu->ep0, mtu3_test_packet, sizeof(mtu3_test_packet));
  105. }
  106. /*
  107. * A. send STALL for setup transfer without data stage:
  108. * set SENDSTALL and SETUPPKTRDY at the same time;
  109. * B. send STALL for other cases:
  110. * set SENDSTALL only.
  111. */
  112. static void ep0_stall_set(struct mtu3_ep *mep0, bool set, u32 pktrdy)
  113. {
  114. struct mtu3 *mtu = mep0->mtu;
  115. void __iomem *mbase = mtu->mac_base;
  116. u32 csr;
  117. /* EP0_SENTSTALL is W1C */
  118. csr = mtu3_readl(mbase, U3D_EP0CSR) & EP0_W1C_BITS;
  119. if (set)
  120. csr |= EP0_SENDSTALL | pktrdy;
  121. else
  122. csr = (csr & ~EP0_SENDSTALL) | EP0_SENTSTALL;
  123. mtu3_writel(mtu->mac_base, U3D_EP0CSR, csr);
  124. mtu->delayed_status = false;
  125. mtu->ep0_state = MU3D_EP0_STATE_SETUP;
  126. dev_dbg(mtu->dev, "ep0: %s STALL, ep0_state: %s\n",
  127. set ? "SEND" : "CLEAR", decode_ep0_state(mtu));
  128. }
  129. static int ep0_queue(struct mtu3_ep *mep0, struct mtu3_request *mreq);
  130. static void ep0_dummy_complete(struct usb_ep *ep, struct usb_request *req)
  131. {}
  132. static void ep0_set_sel_complete(struct usb_ep *ep, struct usb_request *req)
  133. {
  134. struct mtu3_request *mreq;
  135. struct mtu3 *mtu;
  136. struct usb_set_sel_req sel;
  137. memcpy(&sel, req->buf, sizeof(sel));
  138. mreq = to_mtu3_request(req);
  139. mtu = mreq->mtu;
  140. dev_dbg(mtu->dev, "u1sel:%d, u1pel:%d, u2sel:%d, u2pel:%d\n",
  141. sel.u1_sel, sel.u1_pel, sel.u2_sel, sel.u2_pel);
  142. }
  143. /* queue data stage to handle 6 byte SET_SEL request */
  144. static int ep0_set_sel(struct mtu3 *mtu, struct usb_ctrlrequest *setup)
  145. {
  146. int ret;
  147. u16 length = le16_to_cpu(setup->wLength);
  148. if (unlikely(length != 6)) {
  149. dev_err(mtu->dev, "%s wrong wLength:%d\n",
  150. __func__, length);
  151. return -EINVAL;
  152. }
  153. mtu->ep0_req.mep = mtu->ep0;
  154. mtu->ep0_req.request.length = 6;
  155. mtu->ep0_req.request.buf = mtu->setup_buf;
  156. mtu->ep0_req.request.complete = ep0_set_sel_complete;
  157. ret = ep0_queue(mtu->ep0, &mtu->ep0_req);
  158. return ret < 0 ? ret : 1;
  159. }
  160. static int
  161. ep0_get_status(struct mtu3 *mtu, const struct usb_ctrlrequest *setup)
  162. {
  163. struct mtu3_ep *mep = NULL;
  164. int handled = 1;
  165. u8 result[2] = {0, 0};
  166. u8 epnum = 0;
  167. int is_in;
  168. switch (setup->bRequestType & USB_RECIP_MASK) {
  169. case USB_RECIP_DEVICE:
  170. result[0] = mtu->is_self_powered << USB_DEVICE_SELF_POWERED;
  171. result[0] |= mtu->may_wakeup << USB_DEVICE_REMOTE_WAKEUP;
  172. if (mtu->g.speed >= USB_SPEED_SUPER) {
  173. result[0] |= mtu->u1_enable << USB_DEV_STAT_U1_ENABLED;
  174. result[0] |= mtu->u2_enable << USB_DEV_STAT_U2_ENABLED;
  175. }
  176. dev_dbg(mtu->dev, "%s result=%x, U1=%x, U2=%x\n", __func__,
  177. result[0], mtu->u1_enable, mtu->u2_enable);
  178. break;
  179. case USB_RECIP_INTERFACE:
  180. break;
  181. case USB_RECIP_ENDPOINT:
  182. epnum = (u8) le16_to_cpu(setup->wIndex);
  183. is_in = epnum & USB_DIR_IN;
  184. epnum &= USB_ENDPOINT_NUMBER_MASK;
  185. if (epnum >= mtu->num_eps) {
  186. handled = -EINVAL;
  187. break;
  188. }
  189. if (!epnum)
  190. break;
  191. mep = (is_in ? mtu->in_eps : mtu->out_eps) + epnum;
  192. if (!mep->desc) {
  193. handled = -EINVAL;
  194. break;
  195. }
  196. if (mep->flags & MTU3_EP_STALL)
  197. result[0] |= 1 << USB_ENDPOINT_HALT;
  198. break;
  199. default:
  200. /* class, vendor, etc ... delegate */
  201. handled = 0;
  202. break;
  203. }
  204. if (handled > 0) {
  205. int ret;
  206. /* prepare a data stage for GET_STATUS */
  207. dev_dbg(mtu->dev, "get_status=%x\n", *(u16 *)result);
  208. memcpy(mtu->setup_buf, result, sizeof(result));
  209. mtu->ep0_req.mep = mtu->ep0;
  210. mtu->ep0_req.request.length = 2;
  211. mtu->ep0_req.request.buf = &mtu->setup_buf;
  212. mtu->ep0_req.request.complete = ep0_dummy_complete;
  213. ret = ep0_queue(mtu->ep0, &mtu->ep0_req);
  214. if (ret < 0)
  215. handled = ret;
  216. }
  217. return handled;
  218. }
  219. static int handle_test_mode(struct mtu3 *mtu, struct usb_ctrlrequest *setup)
  220. {
  221. void __iomem *mbase = mtu->mac_base;
  222. int handled = 1;
  223. switch (le16_to_cpu(setup->wIndex) >> 8) {
  224. case TEST_J:
  225. dev_dbg(mtu->dev, "TEST_J\n");
  226. mtu->test_mode_nr = TEST_J_MODE;
  227. break;
  228. case TEST_K:
  229. dev_dbg(mtu->dev, "TEST_K\n");
  230. mtu->test_mode_nr = TEST_K_MODE;
  231. break;
  232. case TEST_SE0_NAK:
  233. dev_dbg(mtu->dev, "TEST_SE0_NAK\n");
  234. mtu->test_mode_nr = TEST_SE0_NAK_MODE;
  235. break;
  236. case TEST_PACKET:
  237. dev_dbg(mtu->dev, "TEST_PACKET\n");
  238. mtu->test_mode_nr = TEST_PACKET_MODE;
  239. break;
  240. default:
  241. handled = -EINVAL;
  242. goto out;
  243. }
  244. mtu->test_mode = true;
  245. /* no TX completion interrupt, and need restart platform after test */
  246. if (mtu->test_mode_nr == TEST_PACKET_MODE)
  247. ep0_load_test_packet(mtu);
  248. mtu3_writel(mbase, U3D_USB2_TEST_MODE, mtu->test_mode_nr);
  249. mtu->ep0_state = MU3D_EP0_STATE_SETUP;
  250. out:
  251. return handled;
  252. }
  253. static int ep0_handle_feature_dev(struct mtu3 *mtu,
  254. struct usb_ctrlrequest *setup, bool set)
  255. {
  256. void __iomem *mbase = mtu->mac_base;
  257. int handled = -EINVAL;
  258. u32 lpc;
  259. switch (le16_to_cpu(setup->wValue)) {
  260. case USB_DEVICE_REMOTE_WAKEUP:
  261. mtu->may_wakeup = !!set;
  262. handled = 1;
  263. break;
  264. case USB_DEVICE_TEST_MODE:
  265. if (!set || (mtu->g.speed != USB_SPEED_HIGH) ||
  266. (le16_to_cpu(setup->wIndex) & 0xff))
  267. break;
  268. handled = handle_test_mode(mtu, setup);
  269. break;
  270. case USB_DEVICE_U1_ENABLE:
  271. if (mtu->g.speed < USB_SPEED_SUPER ||
  272. mtu->g.state != USB_STATE_CONFIGURED)
  273. break;
  274. lpc = mtu3_readl(mbase, U3D_LINK_POWER_CONTROL);
  275. if (set)
  276. lpc |= SW_U1_ACCEPT_ENABLE;
  277. else
  278. lpc &= ~SW_U1_ACCEPT_ENABLE;
  279. mtu3_writel(mbase, U3D_LINK_POWER_CONTROL, lpc);
  280. mtu->u1_enable = !!set;
  281. handled = 1;
  282. break;
  283. case USB_DEVICE_U2_ENABLE:
  284. if (mtu->g.speed < USB_SPEED_SUPER ||
  285. mtu->g.state != USB_STATE_CONFIGURED)
  286. break;
  287. lpc = mtu3_readl(mbase, U3D_LINK_POWER_CONTROL);
  288. if (set)
  289. lpc |= SW_U2_ACCEPT_ENABLE;
  290. else
  291. lpc &= ~SW_U2_ACCEPT_ENABLE;
  292. mtu3_writel(mbase, U3D_LINK_POWER_CONTROL, lpc);
  293. mtu->u2_enable = !!set;
  294. handled = 1;
  295. break;
  296. default:
  297. handled = -EINVAL;
  298. break;
  299. }
  300. return handled;
  301. }
  302. static int ep0_handle_feature(struct mtu3 *mtu,
  303. struct usb_ctrlrequest *setup, bool set)
  304. {
  305. struct mtu3_ep *mep;
  306. int handled = -EINVAL;
  307. int is_in;
  308. u16 value;
  309. u16 index;
  310. u8 epnum;
  311. value = le16_to_cpu(setup->wValue);
  312. index = le16_to_cpu(setup->wIndex);
  313. switch (setup->bRequestType & USB_RECIP_MASK) {
  314. case USB_RECIP_DEVICE:
  315. handled = ep0_handle_feature_dev(mtu, setup, set);
  316. break;
  317. case USB_RECIP_INTERFACE:
  318. /* superspeed only */
  319. if (value == USB_INTRF_FUNC_SUSPEND &&
  320. mtu->g.speed >= USB_SPEED_SUPER) {
  321. /*
  322. * forward the request because function drivers
  323. * should handle it
  324. */
  325. handled = 0;
  326. }
  327. break;
  328. case USB_RECIP_ENDPOINT:
  329. epnum = index & USB_ENDPOINT_NUMBER_MASK;
  330. if (epnum == 0 || epnum >= mtu->num_eps ||
  331. value != USB_ENDPOINT_HALT)
  332. break;
  333. is_in = index & USB_DIR_IN;
  334. mep = (is_in ? mtu->in_eps : mtu->out_eps) + epnum;
  335. if (!mep->desc)
  336. break;
  337. handled = 1;
  338. /* ignore request if endpoint is wedged */
  339. if (mep->wedged)
  340. break;
  341. mtu3_ep_stall_set(mep, set);
  342. break;
  343. default:
  344. /* class, vendor, etc ... delegate */
  345. handled = 0;
  346. break;
  347. }
  348. return handled;
  349. }
  350. /*
  351. * handle all control requests can be handled
  352. * returns:
  353. * negative errno - error happened
  354. * zero - need delegate SETUP to gadget driver
  355. * positive - already handled
  356. */
  357. static int handle_standard_request(struct mtu3 *mtu,
  358. struct usb_ctrlrequest *setup)
  359. {
  360. void __iomem *mbase = mtu->mac_base;
  361. enum usb_device_state state = mtu->g.state;
  362. int handled = -EINVAL;
  363. u32 dev_conf;
  364. u16 value;
  365. value = le16_to_cpu(setup->wValue);
  366. /* the gadget driver handles everything except what we must handle */
  367. switch (setup->bRequest) {
  368. case USB_REQ_SET_ADDRESS:
  369. /* change it after the status stage */
  370. mtu->address = (u8) (value & 0x7f);
  371. dev_dbg(mtu->dev, "set address to 0x%x\n", mtu->address);
  372. dev_conf = mtu3_readl(mbase, U3D_DEVICE_CONF);
  373. dev_conf &= ~DEV_ADDR_MSK;
  374. dev_conf |= DEV_ADDR(mtu->address);
  375. mtu3_writel(mbase, U3D_DEVICE_CONF, dev_conf);
  376. if (mtu->address)
  377. usb_gadget_set_state(&mtu->g, USB_STATE_ADDRESS);
  378. else
  379. usb_gadget_set_state(&mtu->g, USB_STATE_DEFAULT);
  380. handled = 1;
  381. break;
  382. case USB_REQ_SET_CONFIGURATION:
  383. if (state == USB_STATE_ADDRESS) {
  384. usb_gadget_set_state(&mtu->g,
  385. USB_STATE_CONFIGURED);
  386. } else if (state == USB_STATE_CONFIGURED) {
  387. /*
  388. * USB2 spec sec 9.4.7, if wValue is 0 then dev
  389. * is moved to addressed state
  390. */
  391. if (!value)
  392. usb_gadget_set_state(&mtu->g,
  393. USB_STATE_ADDRESS);
  394. }
  395. handled = 0;
  396. break;
  397. case USB_REQ_CLEAR_FEATURE:
  398. handled = ep0_handle_feature(mtu, setup, 0);
  399. break;
  400. case USB_REQ_SET_FEATURE:
  401. handled = ep0_handle_feature(mtu, setup, 1);
  402. break;
  403. case USB_REQ_GET_STATUS:
  404. handled = ep0_get_status(mtu, setup);
  405. break;
  406. case USB_REQ_SET_SEL:
  407. handled = ep0_set_sel(mtu, setup);
  408. break;
  409. case USB_REQ_SET_ISOCH_DELAY:
  410. handled = 1;
  411. break;
  412. default:
  413. /* delegate SET_CONFIGURATION, etc */
  414. handled = 0;
  415. }
  416. return handled;
  417. }
  418. /* receive an data packet (OUT) */
  419. static void ep0_rx_state(struct mtu3 *mtu)
  420. {
  421. struct mtu3_request *mreq;
  422. struct usb_request *req;
  423. void __iomem *mbase = mtu->mac_base;
  424. u32 maxp;
  425. u32 csr;
  426. u16 count = 0;
  427. dev_dbg(mtu->dev, "%s\n", __func__);
  428. csr = mtu3_readl(mbase, U3D_EP0CSR) & EP0_W1C_BITS;
  429. mreq = next_ep0_request(mtu);
  430. req = &mreq->request;
  431. /* read packet and ack; or stall because of gadget driver bug */
  432. if (req) {
  433. void *buf = req->buf + req->actual;
  434. unsigned int len = req->length - req->actual;
  435. /* read the buffer */
  436. count = mtu3_readl(mbase, U3D_RXCOUNT0);
  437. if (count > len) {
  438. req->status = -EOVERFLOW;
  439. count = len;
  440. }
  441. ep0_read_fifo(mtu->ep0, buf, count);
  442. req->actual += count;
  443. csr |= EP0_RXPKTRDY;
  444. maxp = mtu->g.ep0->maxpacket;
  445. if (count < maxp || req->actual == req->length) {
  446. mtu->ep0_state = MU3D_EP0_STATE_SETUP;
  447. dev_dbg(mtu->dev, "ep0 state: %s\n",
  448. decode_ep0_state(mtu));
  449. csr |= EP0_DATAEND;
  450. } else {
  451. req = NULL;
  452. }
  453. } else {
  454. csr |= EP0_RXPKTRDY | EP0_SENDSTALL;
  455. dev_dbg(mtu->dev, "%s: SENDSTALL\n", __func__);
  456. }
  457. mtu3_writel(mbase, U3D_EP0CSR, csr);
  458. /* give back the request if have received all data */
  459. if (req)
  460. ep0_req_giveback(mtu, req);
  461. }
  462. /* transmitting to the host (IN) */
  463. static void ep0_tx_state(struct mtu3 *mtu)
  464. {
  465. struct mtu3_request *mreq = next_ep0_request(mtu);
  466. struct usb_request *req;
  467. u32 csr;
  468. u8 *src;
  469. u8 count;
  470. u32 maxp;
  471. dev_dbg(mtu->dev, "%s\n", __func__);
  472. if (!mreq)
  473. return;
  474. maxp = mtu->g.ep0->maxpacket;
  475. req = &mreq->request;
  476. /* load the data */
  477. src = (u8 *)req->buf + req->actual;
  478. count = min(maxp, req->length - req->actual);
  479. if (count)
  480. ep0_write_fifo(mtu->ep0, src, count);
  481. dev_dbg(mtu->dev, "%s act=%d, len=%d, cnt=%d, maxp=%d zero=%d\n",
  482. __func__, req->actual, req->length, count, maxp, req->zero);
  483. req->actual += count;
  484. if ((count < maxp)
  485. || ((req->actual == req->length) && !req->zero))
  486. mtu->ep0_state = MU3D_EP0_STATE_TX_END;
  487. /* send it out, triggering a "txpktrdy cleared" irq */
  488. csr = mtu3_readl(mtu->mac_base, U3D_EP0CSR) & EP0_W1C_BITS;
  489. mtu3_writel(mtu->mac_base, U3D_EP0CSR, csr | EP0_TXPKTRDY);
  490. dev_dbg(mtu->dev, "%s ep0csr=0x%x\n", __func__,
  491. mtu3_readl(mtu->mac_base, U3D_EP0CSR));
  492. }
  493. static void ep0_read_setup(struct mtu3 *mtu, struct usb_ctrlrequest *setup)
  494. {
  495. struct mtu3_request *mreq;
  496. u32 count;
  497. u32 csr;
  498. csr = mtu3_readl(mtu->mac_base, U3D_EP0CSR) & EP0_W1C_BITS;
  499. count = mtu3_readl(mtu->mac_base, U3D_RXCOUNT0);
  500. ep0_read_fifo(mtu->ep0, (u8 *)setup, count);
  501. dev_dbg(mtu->dev, "SETUP req%02x.%02x v%04x i%04x l%04x\n",
  502. setup->bRequestType, setup->bRequest,
  503. le16_to_cpu(setup->wValue), le16_to_cpu(setup->wIndex),
  504. le16_to_cpu(setup->wLength));
  505. /* clean up any leftover transfers */
  506. mreq = next_ep0_request(mtu);
  507. if (mreq)
  508. ep0_req_giveback(mtu, &mreq->request);
  509. if (le16_to_cpu(setup->wLength) == 0) {
  510. ; /* no data stage, nothing to do */
  511. } else if (setup->bRequestType & USB_DIR_IN) {
  512. mtu3_writel(mtu->mac_base, U3D_EP0CSR,
  513. csr | EP0_SETUPPKTRDY | EP0_DPHTX);
  514. mtu->ep0_state = MU3D_EP0_STATE_TX;
  515. } else {
  516. mtu3_writel(mtu->mac_base, U3D_EP0CSR,
  517. (csr | EP0_SETUPPKTRDY) & (~EP0_DPHTX));
  518. mtu->ep0_state = MU3D_EP0_STATE_RX;
  519. }
  520. }
  521. static int ep0_handle_setup(struct mtu3 *mtu)
  522. __releases(mtu->lock)
  523. __acquires(mtu->lock)
  524. {
  525. struct usb_ctrlrequest setup;
  526. struct mtu3_request *mreq;
  527. void __iomem *mbase = mtu->mac_base;
  528. int handled = 0;
  529. ep0_read_setup(mtu, &setup);
  530. if ((setup.bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
  531. handled = handle_standard_request(mtu, &setup);
  532. dev_dbg(mtu->dev, "handled %d, ep0_state: %s\n",
  533. handled, decode_ep0_state(mtu));
  534. if (handled < 0)
  535. goto stall;
  536. else if (handled > 0)
  537. goto finish;
  538. handled = forward_to_driver(mtu, &setup);
  539. if (handled < 0) {
  540. stall:
  541. dev_dbg(mtu->dev, "%s stall (%d)\n", __func__, handled);
  542. ep0_stall_set(mtu->ep0, true,
  543. le16_to_cpu(setup.wLength) ? 0 : EP0_SETUPPKTRDY);
  544. return 0;
  545. }
  546. finish:
  547. if (mtu->test_mode) {
  548. ; /* nothing to do */
  549. } else if (handled == USB_GADGET_DELAYED_STATUS) {
  550. /* handle the delay STATUS phase till receive ep_queue on ep0 */
  551. mtu->delayed_status = true;
  552. } else if (le16_to_cpu(setup.wLength) == 0) { /* no data stage */
  553. mtu3_writel(mbase, U3D_EP0CSR,
  554. (mtu3_readl(mbase, U3D_EP0CSR) & EP0_W1C_BITS)
  555. | EP0_SETUPPKTRDY | EP0_DATAEND);
  556. /* complete zlp request directly */
  557. mreq = next_ep0_request(mtu);
  558. if (mreq && !mreq->request.length)
  559. ep0_req_giveback(mtu, &mreq->request);
  560. }
  561. return 0;
  562. }
  563. irqreturn_t mtu3_ep0_isr(struct mtu3 *mtu)
  564. {
  565. void __iomem *mbase = mtu->mac_base;
  566. struct mtu3_request *mreq;
  567. u32 int_status;
  568. irqreturn_t ret = IRQ_NONE;
  569. u32 csr;
  570. u32 len;
  571. int_status = mtu3_readl(mbase, U3D_EPISR);
  572. int_status &= mtu3_readl(mbase, U3D_EPIER);
  573. mtu3_writel(mbase, U3D_EPISR, int_status); /* W1C */
  574. /* only handle ep0's */
  575. if (!(int_status & EP0ISR))
  576. return IRQ_NONE;
  577. csr = mtu3_readl(mbase, U3D_EP0CSR);
  578. dev_dbg(mtu->dev, "%s csr=0x%x\n", __func__, csr);
  579. /* we sent a stall.. need to clear it now.. */
  580. if (csr & EP0_SENTSTALL) {
  581. ep0_stall_set(mtu->ep0, false, 0);
  582. csr = mtu3_readl(mbase, U3D_EP0CSR);
  583. ret = IRQ_HANDLED;
  584. }
  585. dev_dbg(mtu->dev, "ep0_state: %s\n", decode_ep0_state(mtu));
  586. switch (mtu->ep0_state) {
  587. case MU3D_EP0_STATE_TX:
  588. /* irq on clearing txpktrdy */
  589. if ((csr & EP0_FIFOFULL) == 0) {
  590. ep0_tx_state(mtu);
  591. ret = IRQ_HANDLED;
  592. }
  593. break;
  594. case MU3D_EP0_STATE_RX:
  595. /* irq on set rxpktrdy */
  596. if (csr & EP0_RXPKTRDY) {
  597. ep0_rx_state(mtu);
  598. ret = IRQ_HANDLED;
  599. }
  600. break;
  601. case MU3D_EP0_STATE_TX_END:
  602. mtu3_writel(mbase, U3D_EP0CSR,
  603. (csr & EP0_W1C_BITS) | EP0_DATAEND);
  604. mreq = next_ep0_request(mtu);
  605. if (mreq)
  606. ep0_req_giveback(mtu, &mreq->request);
  607. mtu->ep0_state = MU3D_EP0_STATE_SETUP;
  608. ret = IRQ_HANDLED;
  609. dev_dbg(mtu->dev, "ep0_state: %s\n", decode_ep0_state(mtu));
  610. break;
  611. case MU3D_EP0_STATE_SETUP:
  612. if (!(csr & EP0_SETUPPKTRDY))
  613. break;
  614. len = mtu3_readl(mbase, U3D_RXCOUNT0);
  615. if (len != 8) {
  616. dev_err(mtu->dev, "SETUP packet len %d != 8 ?\n", len);
  617. break;
  618. }
  619. ep0_handle_setup(mtu);
  620. ret = IRQ_HANDLED;
  621. break;
  622. default:
  623. /* can't happen */
  624. ep0_stall_set(mtu->ep0, true, 0);
  625. WARN_ON(1);
  626. break;
  627. }
  628. return ret;
  629. }
  630. static int mtu3_ep0_enable(struct usb_ep *ep,
  631. const struct usb_endpoint_descriptor *desc)
  632. {
  633. /* always enabled */
  634. return -EINVAL;
  635. }
  636. static int mtu3_ep0_disable(struct usb_ep *ep)
  637. {
  638. /* always enabled */
  639. return -EINVAL;
  640. }
  641. static int ep0_queue(struct mtu3_ep *mep, struct mtu3_request *mreq)
  642. {
  643. struct mtu3 *mtu = mep->mtu;
  644. mreq->mtu = mtu;
  645. mreq->request.actual = 0;
  646. mreq->request.status = -EINPROGRESS;
  647. dev_dbg(mtu->dev, "%s %s (ep0_state: %s), len#%d\n", __func__,
  648. mep->name, decode_ep0_state(mtu), mreq->request.length);
  649. switch (mtu->ep0_state) {
  650. case MU3D_EP0_STATE_SETUP:
  651. case MU3D_EP0_STATE_RX: /* control-OUT data */
  652. case MU3D_EP0_STATE_TX: /* control-IN data */
  653. break;
  654. default:
  655. dev_err(mtu->dev, "%s, error in ep0 state %s\n", __func__,
  656. decode_ep0_state(mtu));
  657. return -EINVAL;
  658. }
  659. if (mtu->delayed_status) {
  660. u32 csr;
  661. mtu->delayed_status = false;
  662. csr = mtu3_readl(mtu->mac_base, U3D_EP0CSR) & EP0_W1C_BITS;
  663. csr |= EP0_SETUPPKTRDY | EP0_DATAEND;
  664. mtu3_writel(mtu->mac_base, U3D_EP0CSR, csr);
  665. /* needn't giveback the request for handling delay STATUS */
  666. return 0;
  667. }
  668. if (!list_empty(&mep->req_list))
  669. return -EBUSY;
  670. list_add_tail(&mreq->list, &mep->req_list);
  671. /* sequence #1, IN ... start writing the data */
  672. if (mtu->ep0_state == MU3D_EP0_STATE_TX)
  673. ep0_tx_state(mtu);
  674. return 0;
  675. }
  676. static int mtu3_ep0_queue(struct usb_ep *ep,
  677. struct usb_request *req, gfp_t gfp)
  678. {
  679. struct mtu3_ep *mep;
  680. struct mtu3_request *mreq;
  681. struct mtu3 *mtu;
  682. unsigned long flags;
  683. int ret = 0;
  684. if (!ep || !req)
  685. return -EINVAL;
  686. mep = to_mtu3_ep(ep);
  687. mtu = mep->mtu;
  688. mreq = to_mtu3_request(req);
  689. spin_lock_irqsave(&mtu->lock, flags);
  690. ret = ep0_queue(mep, mreq);
  691. spin_unlock_irqrestore(&mtu->lock, flags);
  692. return ret;
  693. }
  694. static int mtu3_ep0_dequeue(struct usb_ep *ep, struct usb_request *req)
  695. {
  696. /* we just won't support this */
  697. return -EINVAL;
  698. }
  699. static int mtu3_ep0_halt(struct usb_ep *ep, int value)
  700. {
  701. struct mtu3_ep *mep;
  702. struct mtu3 *mtu;
  703. unsigned long flags;
  704. int ret = 0;
  705. if (!ep || !value)
  706. return -EINVAL;
  707. mep = to_mtu3_ep(ep);
  708. mtu = mep->mtu;
  709. dev_dbg(mtu->dev, "%s\n", __func__);
  710. spin_lock_irqsave(&mtu->lock, flags);
  711. if (!list_empty(&mep->req_list)) {
  712. ret = -EBUSY;
  713. goto cleanup;
  714. }
  715. switch (mtu->ep0_state) {
  716. /*
  717. * stalls are usually issued after parsing SETUP packet, either
  718. * directly in irq context from setup() or else later.
  719. */
  720. case MU3D_EP0_STATE_TX:
  721. case MU3D_EP0_STATE_TX_END:
  722. case MU3D_EP0_STATE_RX:
  723. case MU3D_EP0_STATE_SETUP:
  724. ep0_stall_set(mtu->ep0, true, 0);
  725. break;
  726. default:
  727. dev_dbg(mtu->dev, "ep0 can't halt in state %s\n",
  728. decode_ep0_state(mtu));
  729. ret = -EINVAL;
  730. }
  731. cleanup:
  732. spin_unlock_irqrestore(&mtu->lock, flags);
  733. return ret;
  734. }
  735. const struct usb_ep_ops mtu3_ep0_ops = {
  736. .enable = mtu3_ep0_enable,
  737. .disable = mtu3_ep0_disable,
  738. .alloc_request = mtu3_alloc_request,
  739. .free_request = mtu3_free_request,
  740. .queue = mtu3_ep0_queue,
  741. .dequeue = mtu3_ep0_dequeue,
  742. .set_halt = mtu3_ep0_halt,
  743. };