ep0.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Cadence USBSS DRD Driver - gadget side.
  4. *
  5. * Copyright (C) 2018 Cadence Design Systems.
  6. * Copyright (C) 2017-2018 NXP
  7. *
  8. * Authors: Pawel Jez <pjez@cadence.com>,
  9. * Pawel Laszczak <pawell@cadence.com>
  10. * Peter Chen <peter.chen@nxp.com>
  11. */
  12. #include <cpu_func.h>
  13. #include <dm.h>
  14. #include <dm/device_compat.h>
  15. #include <asm/cache.h>
  16. #include <linux/bitops.h>
  17. #include <linux/delay.h>
  18. #include <linux/usb/composite.h>
  19. #include <linux/iopoll.h>
  20. #include "gadget.h"
  21. #include "trace.h"
  22. #define readl_poll_timeout_atomic readl_poll_timeout
  23. #define usleep_range(a, b) udelay((b))
  24. static struct usb_endpoint_descriptor cdns3_gadget_ep0_desc = {
  25. .bLength = USB_DT_ENDPOINT_SIZE,
  26. .bDescriptorType = USB_DT_ENDPOINT,
  27. .bmAttributes = USB_ENDPOINT_XFER_CONTROL,
  28. };
  29. /**
  30. * cdns3_ep0_run_transfer - Do transfer on default endpoint hardware
  31. * @priv_dev: extended gadget object
  32. * @dma_addr: physical address where data is/will be stored
  33. * @length: data length
  34. * @erdy: set it to 1 when ERDY packet should be sent -
  35. * exit from flow control state
  36. */
  37. static void cdns3_ep0_run_transfer(struct cdns3_device *priv_dev,
  38. dma_addr_t dma_addr,
  39. unsigned int length, int erdy, int zlp)
  40. {
  41. struct cdns3_usb_regs __iomem *regs = priv_dev->regs;
  42. struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
  43. priv_ep->trb_pool[0].buffer = TRB_BUFFER(dma_addr);
  44. priv_ep->trb_pool[0].length = TRB_LEN(length);
  45. if (zlp) {
  46. priv_ep->trb_pool[0].control = TRB_CYCLE | TRB_TYPE(TRB_NORMAL);
  47. priv_ep->trb_pool[1].buffer = TRB_BUFFER(dma_addr);
  48. priv_ep->trb_pool[1].length = TRB_LEN(0);
  49. priv_ep->trb_pool[1].control = TRB_CYCLE | TRB_IOC |
  50. TRB_TYPE(TRB_NORMAL);
  51. } else {
  52. priv_ep->trb_pool[0].control = TRB_CYCLE | TRB_IOC |
  53. TRB_TYPE(TRB_NORMAL);
  54. priv_ep->trb_pool[1].control = 0;
  55. }
  56. /* Flush both TRBs */
  57. flush_dcache_range((unsigned long)priv_ep->trb_pool,
  58. (unsigned long)priv_ep->trb_pool +
  59. ROUND(sizeof(struct cdns3_trb) * 2,
  60. CONFIG_SYS_CACHELINE_SIZE));
  61. trace_cdns3_prepare_trb(priv_ep, priv_ep->trb_pool);
  62. cdns3_select_ep(priv_dev, priv_dev->ep0_data_dir);
  63. writel(EP_STS_TRBERR, &regs->ep_sts);
  64. writel(EP_TRADDR_TRADDR(priv_ep->trb_pool_dma), &regs->ep_traddr);
  65. trace_cdns3_doorbell_ep0(priv_dev->ep0_data_dir ? "ep0in" : "ep0out",
  66. readl(&regs->ep_traddr));
  67. /* TRB should be prepared before starting transfer. */
  68. writel(EP_CMD_DRDY, &regs->ep_cmd);
  69. /* Resume controller before arming transfer. */
  70. __cdns3_gadget_wakeup(priv_dev);
  71. if (erdy)
  72. writel(EP_CMD_ERDY, &priv_dev->regs->ep_cmd);
  73. }
  74. /**
  75. * cdns3_ep0_delegate_req - Returns status of handling setup packet
  76. * Setup is handled by gadget driver
  77. * @priv_dev: extended gadget object
  78. * @ctrl_req: pointer to received setup packet
  79. *
  80. * Returns zero on success or negative value on failure
  81. */
  82. static int cdns3_ep0_delegate_req(struct cdns3_device *priv_dev,
  83. struct usb_ctrlrequest *ctrl_req)
  84. {
  85. int ret;
  86. spin_unlock(&priv_dev->lock);
  87. priv_dev->setup_pending = 1;
  88. ret = priv_dev->gadget_driver->setup(&priv_dev->gadget, ctrl_req);
  89. priv_dev->setup_pending = 0;
  90. spin_lock(&priv_dev->lock);
  91. return ret;
  92. }
  93. static void cdns3_prepare_setup_packet(struct cdns3_device *priv_dev)
  94. {
  95. priv_dev->ep0_data_dir = 0;
  96. priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
  97. cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
  98. sizeof(struct usb_ctrlrequest), 0, 0);
  99. }
  100. static void cdns3_ep0_complete_setup(struct cdns3_device *priv_dev,
  101. u8 send_stall, u8 send_erdy)
  102. {
  103. struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
  104. struct usb_request *request;
  105. request = cdns3_next_request(&priv_ep->pending_req_list);
  106. if (request)
  107. list_del_init(&request->list);
  108. if (send_stall) {
  109. trace_cdns3_halt(priv_ep, send_stall, 0);
  110. /* set_stall on ep0 */
  111. cdns3_select_ep(priv_dev, 0x00);
  112. writel(EP_CMD_SSTALL, &priv_dev->regs->ep_cmd);
  113. } else {
  114. cdns3_prepare_setup_packet(priv_dev);
  115. }
  116. priv_dev->ep0_stage = CDNS3_SETUP_STAGE;
  117. writel((send_erdy ? EP_CMD_ERDY : 0) | EP_CMD_REQ_CMPL,
  118. &priv_dev->regs->ep_cmd);
  119. cdns3_allow_enable_l1(priv_dev, 1);
  120. }
  121. /**
  122. * cdns3_req_ep0_set_configuration - Handling of SET_CONFIG standard USB request
  123. * @priv_dev: extended gadget object
  124. * @ctrl_req: pointer to received setup packet
  125. *
  126. * Returns 0 if success, USB_GADGET_DELAYED_STATUS on deferred status stage,
  127. * error code on error
  128. */
  129. static int cdns3_req_ep0_set_configuration(struct cdns3_device *priv_dev,
  130. struct usb_ctrlrequest *ctrl_req)
  131. {
  132. enum usb_device_state device_state = priv_dev->gadget.state;
  133. struct cdns3_endpoint *priv_ep;
  134. u32 config = le16_to_cpu(ctrl_req->wValue);
  135. int result = 0;
  136. int i;
  137. switch (device_state) {
  138. case USB_STATE_ADDRESS:
  139. /* Configure non-control EPs */
  140. for (i = 0; i < CDNS3_ENDPOINTS_MAX_COUNT; i++) {
  141. priv_ep = priv_dev->eps[i];
  142. if (!priv_ep)
  143. continue;
  144. if (priv_ep->flags & EP_CLAIMED)
  145. cdns3_ep_config(priv_ep);
  146. }
  147. result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
  148. if (result)
  149. return result;
  150. if (config) {
  151. cdns3_set_hw_configuration(priv_dev);
  152. } else {
  153. cdns3_hw_reset_eps_config(priv_dev);
  154. usb_gadget_set_state(&priv_dev->gadget,
  155. USB_STATE_ADDRESS);
  156. }
  157. break;
  158. case USB_STATE_CONFIGURED:
  159. result = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
  160. if (!config && !result) {
  161. cdns3_hw_reset_eps_config(priv_dev);
  162. usb_gadget_set_state(&priv_dev->gadget,
  163. USB_STATE_ADDRESS);
  164. }
  165. break;
  166. default:
  167. result = -EINVAL;
  168. }
  169. return result;
  170. }
  171. /**
  172. * cdns3_req_ep0_set_address - Handling of SET_ADDRESS standard USB request
  173. * @priv_dev: extended gadget object
  174. * @ctrl_req: pointer to received setup packet
  175. *
  176. * Returns 0 if success, error code on error
  177. */
  178. static int cdns3_req_ep0_set_address(struct cdns3_device *priv_dev,
  179. struct usb_ctrlrequest *ctrl_req)
  180. {
  181. enum usb_device_state device_state = priv_dev->gadget.state;
  182. u32 reg;
  183. u32 addr;
  184. addr = le16_to_cpu(ctrl_req->wValue);
  185. if (addr > USB_DEVICE_MAX_ADDRESS) {
  186. dev_err(priv_dev->dev,
  187. "Device address (%d) cannot be greater than %d\n",
  188. addr, USB_DEVICE_MAX_ADDRESS);
  189. return -EINVAL;
  190. }
  191. if (device_state == USB_STATE_CONFIGURED) {
  192. dev_err(priv_dev->dev,
  193. "can't set_address from configured state\n");
  194. return -EINVAL;
  195. }
  196. reg = readl(&priv_dev->regs->usb_cmd);
  197. writel(reg | USB_CMD_FADDR(addr) | USB_CMD_SET_ADDR,
  198. &priv_dev->regs->usb_cmd);
  199. usb_gadget_set_state(&priv_dev->gadget,
  200. (addr ? USB_STATE_ADDRESS : USB_STATE_DEFAULT));
  201. return 0;
  202. }
  203. /**
  204. * cdns3_req_ep0_get_status - Handling of GET_STATUS standard USB request
  205. * @priv_dev: extended gadget object
  206. * @ctrl_req: pointer to received setup packet
  207. *
  208. * Returns 0 if success, error code on error
  209. */
  210. static int cdns3_req_ep0_get_status(struct cdns3_device *priv_dev,
  211. struct usb_ctrlrequest *ctrl)
  212. {
  213. __le16 *response_pkt;
  214. u16 usb_status = 0;
  215. u32 recip;
  216. recip = ctrl->bRequestType & USB_RECIP_MASK;
  217. switch (recip) {
  218. case USB_RECIP_DEVICE:
  219. /* self powered */
  220. if (priv_dev->is_selfpowered)
  221. usb_status = BIT(USB_DEVICE_SELF_POWERED);
  222. if (priv_dev->wake_up_flag)
  223. usb_status |= BIT(USB_DEVICE_REMOTE_WAKEUP);
  224. if (priv_dev->gadget.speed != USB_SPEED_SUPER)
  225. break;
  226. if (priv_dev->u1_allowed)
  227. usb_status |= BIT(USB_DEV_STAT_U1_ENABLED);
  228. if (priv_dev->u2_allowed)
  229. usb_status |= BIT(USB_DEV_STAT_U2_ENABLED);
  230. break;
  231. case USB_RECIP_INTERFACE:
  232. return cdns3_ep0_delegate_req(priv_dev, ctrl);
  233. case USB_RECIP_ENDPOINT:
  234. /* check if endpoint is stalled */
  235. cdns3_select_ep(priv_dev, ctrl->wIndex);
  236. if (EP_STS_STALL(readl(&priv_dev->regs->ep_sts)))
  237. usb_status = BIT(USB_ENDPOINT_HALT);
  238. break;
  239. default:
  240. return -EINVAL;
  241. }
  242. response_pkt = (__le16 *)priv_dev->setup_buf;
  243. *response_pkt = cpu_to_le16(usb_status);
  244. /* Flush setup response */
  245. flush_dcache_range((unsigned long)priv_dev->setup_buf,
  246. (unsigned long)priv_dev->setup_buf +
  247. ROUND(sizeof(struct usb_ctrlrequest),
  248. CONFIG_SYS_CACHELINE_SIZE));
  249. cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma,
  250. sizeof(*response_pkt), 1, 0);
  251. return 0;
  252. }
  253. static int cdns3_ep0_feature_handle_device(struct cdns3_device *priv_dev,
  254. struct usb_ctrlrequest *ctrl,
  255. int set)
  256. {
  257. enum usb_device_state state;
  258. enum usb_device_speed speed;
  259. int ret = 0;
  260. u16 tmode;
  261. state = priv_dev->gadget.state;
  262. speed = priv_dev->gadget.speed;
  263. switch (ctrl->wValue) {
  264. case USB_DEVICE_REMOTE_WAKEUP:
  265. priv_dev->wake_up_flag = !!set;
  266. break;
  267. case USB_DEVICE_U1_ENABLE:
  268. if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
  269. return -EINVAL;
  270. priv_dev->u1_allowed = !!set;
  271. break;
  272. case USB_DEVICE_U2_ENABLE:
  273. if (state != USB_STATE_CONFIGURED || speed != USB_SPEED_SUPER)
  274. return -EINVAL;
  275. priv_dev->u2_allowed = !!set;
  276. break;
  277. case USB_DEVICE_LTM_ENABLE:
  278. ret = -EINVAL;
  279. break;
  280. case USB_DEVICE_TEST_MODE:
  281. if (state != USB_STATE_CONFIGURED || speed > USB_SPEED_HIGH)
  282. return -EINVAL;
  283. tmode = le16_to_cpu(ctrl->wIndex);
  284. if (!set || (tmode & 0xff) != 0)
  285. return -EINVAL;
  286. switch (tmode >> 8) {
  287. case TEST_J:
  288. case TEST_K:
  289. case TEST_SE0_NAK:
  290. case TEST_PACKET:
  291. cdns3_ep0_complete_setup(priv_dev, 0, 1);
  292. /**
  293. * Little delay to give the controller some time
  294. * for sending status stage.
  295. * This time should be less then 3ms.
  296. */
  297. usleep_range(1000, 2000);
  298. cdns3_set_register_bit(&priv_dev->regs->usb_cmd,
  299. USB_CMD_STMODE |
  300. USB_STS_TMODE_SEL(tmode - 1));
  301. break;
  302. default:
  303. ret = -EINVAL;
  304. }
  305. break;
  306. default:
  307. ret = -EINVAL;
  308. }
  309. return ret;
  310. }
  311. static int cdns3_ep0_feature_handle_intf(struct cdns3_device *priv_dev,
  312. struct usb_ctrlrequest *ctrl,
  313. int set)
  314. {
  315. u32 wValue;
  316. int ret = 0;
  317. wValue = le16_to_cpu(ctrl->wValue);
  318. switch (wValue) {
  319. case USB_INTRF_FUNC_SUSPEND:
  320. break;
  321. default:
  322. ret = -EINVAL;
  323. }
  324. return ret;
  325. }
  326. static int cdns3_ep0_feature_handle_endpoint(struct cdns3_device *priv_dev,
  327. struct usb_ctrlrequest *ctrl,
  328. int set)
  329. {
  330. struct cdns3_endpoint *priv_ep;
  331. int ret = 0;
  332. u8 index;
  333. if (le16_to_cpu(ctrl->wValue) != USB_ENDPOINT_HALT)
  334. return -EINVAL;
  335. if (!(ctrl->wIndex & ~USB_DIR_IN))
  336. return 0;
  337. index = cdns3_ep_addr_to_index(ctrl->wIndex);
  338. priv_ep = priv_dev->eps[index];
  339. cdns3_select_ep(priv_dev, ctrl->wIndex);
  340. if (set)
  341. __cdns3_gadget_ep_set_halt(priv_ep);
  342. else if (!(priv_ep->flags & EP_WEDGE))
  343. ret = __cdns3_gadget_ep_clear_halt(priv_ep);
  344. cdns3_select_ep(priv_dev, 0x00);
  345. return ret;
  346. }
  347. /**
  348. * cdns3_req_ep0_handle_feature -
  349. * Handling of GET/SET_FEATURE standard USB request
  350. *
  351. * @priv_dev: extended gadget object
  352. * @ctrl_req: pointer to received setup packet
  353. * @set: must be set to 1 for SET_FEATURE request
  354. *
  355. * Returns 0 if success, error code on error
  356. */
  357. static int cdns3_req_ep0_handle_feature(struct cdns3_device *priv_dev,
  358. struct usb_ctrlrequest *ctrl,
  359. int set)
  360. {
  361. int ret = 0;
  362. u32 recip;
  363. recip = ctrl->bRequestType & USB_RECIP_MASK;
  364. switch (recip) {
  365. case USB_RECIP_DEVICE:
  366. ret = cdns3_ep0_feature_handle_device(priv_dev, ctrl, set);
  367. break;
  368. case USB_RECIP_INTERFACE:
  369. ret = cdns3_ep0_feature_handle_intf(priv_dev, ctrl, set);
  370. break;
  371. case USB_RECIP_ENDPOINT:
  372. ret = cdns3_ep0_feature_handle_endpoint(priv_dev, ctrl, set);
  373. break;
  374. default:
  375. return -EINVAL;
  376. }
  377. return ret;
  378. }
  379. /**
  380. * cdns3_req_ep0_set_sel - Handling of SET_SEL standard USB request
  381. * @priv_dev: extended gadget object
  382. * @ctrl_req: pointer to received setup packet
  383. *
  384. * Returns 0 if success, error code on error
  385. */
  386. static int cdns3_req_ep0_set_sel(struct cdns3_device *priv_dev,
  387. struct usb_ctrlrequest *ctrl_req)
  388. {
  389. if (priv_dev->gadget.state < USB_STATE_ADDRESS)
  390. return -EINVAL;
  391. if (ctrl_req->wLength != 6) {
  392. dev_err(priv_dev->dev, "Set SEL should be 6 bytes, got %d\n",
  393. ctrl_req->wLength);
  394. return -EINVAL;
  395. }
  396. cdns3_ep0_run_transfer(priv_dev, priv_dev->setup_dma, 6, 1, 0);
  397. return 0;
  398. }
  399. /**
  400. * cdns3_req_ep0_set_isoch_delay -
  401. * Handling of GET_ISOCH_DELAY standard USB request
  402. * @priv_dev: extended gadget object
  403. * @ctrl_req: pointer to received setup packet
  404. *
  405. * Returns 0 if success, error code on error
  406. */
  407. static int cdns3_req_ep0_set_isoch_delay(struct cdns3_device *priv_dev,
  408. struct usb_ctrlrequest *ctrl_req)
  409. {
  410. if (ctrl_req->wIndex || ctrl_req->wLength)
  411. return -EINVAL;
  412. priv_dev->isoch_delay = ctrl_req->wValue;
  413. return 0;
  414. }
  415. /**
  416. * cdns3_ep0_standard_request - Handling standard USB requests
  417. * @priv_dev: extended gadget object
  418. * @ctrl_req: pointer to received setup packet
  419. *
  420. * Returns 0 if success, error code on error
  421. */
  422. static int cdns3_ep0_standard_request(struct cdns3_device *priv_dev,
  423. struct usb_ctrlrequest *ctrl_req)
  424. {
  425. int ret;
  426. switch (ctrl_req->bRequest) {
  427. case USB_REQ_SET_ADDRESS:
  428. ret = cdns3_req_ep0_set_address(priv_dev, ctrl_req);
  429. break;
  430. case USB_REQ_SET_CONFIGURATION:
  431. ret = cdns3_req_ep0_set_configuration(priv_dev, ctrl_req);
  432. break;
  433. case USB_REQ_GET_STATUS:
  434. ret = cdns3_req_ep0_get_status(priv_dev, ctrl_req);
  435. break;
  436. case USB_REQ_CLEAR_FEATURE:
  437. ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 0);
  438. break;
  439. case USB_REQ_SET_FEATURE:
  440. ret = cdns3_req_ep0_handle_feature(priv_dev, ctrl_req, 1);
  441. break;
  442. case USB_REQ_SET_SEL:
  443. ret = cdns3_req_ep0_set_sel(priv_dev, ctrl_req);
  444. break;
  445. case USB_REQ_SET_ISOCH_DELAY:
  446. ret = cdns3_req_ep0_set_isoch_delay(priv_dev, ctrl_req);
  447. break;
  448. default:
  449. ret = cdns3_ep0_delegate_req(priv_dev, ctrl_req);
  450. break;
  451. }
  452. return ret;
  453. }
  454. static void __pending_setup_status_handler(struct cdns3_device *priv_dev)
  455. {
  456. struct usb_request *request = priv_dev->pending_status_request;
  457. if (priv_dev->status_completion_no_call && request &&
  458. request->complete) {
  459. request->complete(&priv_dev->eps[0]->endpoint, request);
  460. priv_dev->status_completion_no_call = 0;
  461. }
  462. }
  463. void cdns3_pending_setup_status_handler(struct work_struct *work)
  464. {
  465. struct cdns3_device *priv_dev = container_of(work, struct cdns3_device,
  466. pending_status_wq);
  467. unsigned long flags;
  468. spin_lock_irqsave(&priv_dev->lock, flags);
  469. __pending_setup_status_handler(priv_dev);
  470. spin_unlock_irqrestore(&priv_dev->lock, flags);
  471. }
  472. /**
  473. * cdns3_ep0_setup_phase - Handling setup USB requests
  474. * @priv_dev: extended gadget object
  475. */
  476. static void cdns3_ep0_setup_phase(struct cdns3_device *priv_dev)
  477. {
  478. struct usb_ctrlrequest *ctrl = priv_dev->setup_buf;
  479. struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
  480. int result;
  481. /* Invalidate Setup Packet received */
  482. invalidate_dcache_range(priv_dev->setup_dma,
  483. priv_dev->setup_dma + ARCH_DMA_MINALIGN);
  484. priv_dev->ep0_data_dir = ctrl->bRequestType & USB_DIR_IN;
  485. trace_cdns3_ctrl_req(ctrl);
  486. if (!list_empty(&priv_ep->pending_req_list)) {
  487. struct usb_request *request;
  488. request = cdns3_next_request(&priv_ep->pending_req_list);
  489. priv_ep->dir = priv_dev->ep0_data_dir;
  490. cdns3_gadget_giveback(priv_ep, to_cdns3_request(request),
  491. -ECONNRESET);
  492. }
  493. if (le16_to_cpu(ctrl->wLength))
  494. priv_dev->ep0_stage = CDNS3_DATA_STAGE;
  495. else
  496. priv_dev->ep0_stage = CDNS3_STATUS_STAGE;
  497. if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD)
  498. result = cdns3_ep0_standard_request(priv_dev, ctrl);
  499. else
  500. result = cdns3_ep0_delegate_req(priv_dev, ctrl);
  501. if (result == USB_GADGET_DELAYED_STATUS)
  502. return;
  503. if (result < 0)
  504. cdns3_ep0_complete_setup(priv_dev, 1, 1);
  505. else if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE)
  506. cdns3_ep0_complete_setup(priv_dev, 0, 1);
  507. }
  508. static void cdns3_transfer_completed(struct cdns3_device *priv_dev)
  509. {
  510. struct cdns3_endpoint *priv_ep = priv_dev->eps[0];
  511. if (!list_empty(&priv_ep->pending_req_list)) {
  512. struct usb_request *request;
  513. trace_cdns3_complete_trb(priv_ep, priv_ep->trb_pool);
  514. request = cdns3_next_request(&priv_ep->pending_req_list);
  515. /* Invalidate TRB before accessing it */
  516. invalidate_dcache_range((unsigned long)priv_ep->trb_pool,
  517. (unsigned long)priv_ep->trb_pool +
  518. ROUND(sizeof(struct cdns3_trb),
  519. CONFIG_SYS_CACHELINE_SIZE));
  520. request->actual =
  521. TRB_LEN(le32_to_cpu(priv_ep->trb_pool->length));
  522. priv_ep->dir = priv_dev->ep0_data_dir;
  523. cdns3_gadget_giveback(priv_ep, to_cdns3_request(request), 0);
  524. }
  525. cdns3_ep0_complete_setup(priv_dev, 0, 0);
  526. }
  527. /**
  528. * cdns3_check_new_setup - Check if controller receive new SETUP packet.
  529. * @priv_dev: extended gadget object
  530. *
  531. * The SETUP packet can be kept in on-chip memory or in system memory.
  532. */
  533. static bool cdns3_check_new_setup(struct cdns3_device *priv_dev)
  534. {
  535. u32 ep_sts_reg;
  536. cdns3_select_ep(priv_dev, 0 | USB_DIR_OUT);
  537. ep_sts_reg = readl(&priv_dev->regs->ep_sts);
  538. return !!(ep_sts_reg & (EP_STS_SETUP | EP_STS_STPWAIT));
  539. }
  540. /**
  541. * cdns3_check_ep0_interrupt_proceed - Processes interrupt related to endpoint 0
  542. * @priv_dev: extended gadget object
  543. * @dir: USB_DIR_IN for IN direction, USB_DIR_OUT for OUT direction
  544. */
  545. void cdns3_check_ep0_interrupt_proceed(struct cdns3_device *priv_dev, int dir)
  546. {
  547. u32 ep_sts_reg;
  548. cdns3_select_ep(priv_dev, dir);
  549. ep_sts_reg = readl(&priv_dev->regs->ep_sts);
  550. writel(ep_sts_reg, &priv_dev->regs->ep_sts);
  551. trace_cdns3_ep0_irq(priv_dev, ep_sts_reg);
  552. __pending_setup_status_handler(priv_dev);
  553. if (ep_sts_reg & EP_STS_SETUP)
  554. priv_dev->wait_for_setup = 1;
  555. if (priv_dev->wait_for_setup && ep_sts_reg & EP_STS_IOC) {
  556. priv_dev->wait_for_setup = 0;
  557. cdns3_allow_enable_l1(priv_dev, 0);
  558. cdns3_ep0_setup_phase(priv_dev);
  559. } else if ((ep_sts_reg & EP_STS_IOC) || (ep_sts_reg & EP_STS_ISP)) {
  560. priv_dev->ep0_data_dir = dir;
  561. cdns3_transfer_completed(priv_dev);
  562. }
  563. if (ep_sts_reg & EP_STS_DESCMIS) {
  564. if (dir == 0 && !priv_dev->setup_pending)
  565. cdns3_prepare_setup_packet(priv_dev);
  566. }
  567. }
  568. /**
  569. * cdns3_gadget_ep0_enable
  570. * Function shouldn't be called by gadget driver,
  571. * endpoint 0 is allways active
  572. */
  573. static int cdns3_gadget_ep0_enable(struct usb_ep *ep,
  574. const struct usb_endpoint_descriptor *desc)
  575. {
  576. return -EINVAL;
  577. }
  578. /**
  579. * cdns3_gadget_ep0_disable
  580. * Function shouldn't be called by gadget driver,
  581. * endpoint 0 is allways active
  582. */
  583. static int cdns3_gadget_ep0_disable(struct usb_ep *ep)
  584. {
  585. return -EINVAL;
  586. }
  587. /**
  588. * cdns3_gadget_ep0_set_halt
  589. * @ep: pointer to endpoint zero object
  590. * @value: 1 for set stall, 0 for clear stall
  591. *
  592. * Returns 0
  593. */
  594. static int cdns3_gadget_ep0_set_halt(struct usb_ep *ep, int value)
  595. {
  596. /* TODO */
  597. return 0;
  598. }
  599. /**
  600. * cdns3_gadget_ep0_queue Transfer data on endpoint zero
  601. * @ep: pointer to endpoint zero object
  602. * @request: pointer to request object
  603. * @gfp_flags: gfp flags
  604. *
  605. * Returns 0 on success, error code elsewhere
  606. */
  607. static int cdns3_gadget_ep0_queue(struct usb_ep *ep,
  608. struct usb_request *request,
  609. gfp_t gfp_flags)
  610. {
  611. struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
  612. struct cdns3_device *priv_dev = priv_ep->cdns3_dev;
  613. unsigned long flags;
  614. int erdy_sent = 0;
  615. int ret = 0;
  616. u8 zlp = 0;
  617. trace_cdns3_ep0_queue(priv_dev, request);
  618. /* cancel the request if controller receive new SETUP packet. */
  619. if (cdns3_check_new_setup(priv_dev))
  620. return -ECONNRESET;
  621. /* send STATUS stage. Should be called only for SET_CONFIGURATION */
  622. if (priv_dev->ep0_stage == CDNS3_STATUS_STAGE) {
  623. spin_lock_irqsave(&priv_dev->lock, flags);
  624. cdns3_select_ep(priv_dev, 0x00);
  625. erdy_sent = !priv_dev->hw_configured_flag;
  626. cdns3_set_hw_configuration(priv_dev);
  627. if (!erdy_sent)
  628. cdns3_ep0_complete_setup(priv_dev, 0, 1);
  629. cdns3_allow_enable_l1(priv_dev, 1);
  630. request->actual = 0;
  631. priv_dev->status_completion_no_call = true;
  632. priv_dev->pending_status_request = request;
  633. spin_unlock_irqrestore(&priv_dev->lock, flags);
  634. /*
  635. * Since there is no completion interrupt for status stage,
  636. * it needs to call ->completion in software after
  637. * ep0_queue is back.
  638. */
  639. #ifndef __UBOOT__
  640. queue_work(system_freezable_wq, &priv_dev->pending_status_wq);
  641. #else
  642. __pending_setup_status_handler(priv_dev);
  643. #endif
  644. return 0;
  645. }
  646. spin_lock_irqsave(&priv_dev->lock, flags);
  647. if (!list_empty(&priv_ep->pending_req_list)) {
  648. dev_err(priv_dev->dev,
  649. "can't handle multiple requests for ep0\n");
  650. spin_unlock_irqrestore(&priv_dev->lock, flags);
  651. return -EBUSY;
  652. }
  653. ret = usb_gadget_map_request(&priv_dev->gadget, request,
  654. priv_dev->ep0_data_dir);
  655. if (ret) {
  656. spin_unlock_irqrestore(&priv_dev->lock, flags);
  657. dev_err(priv_dev->dev, "failed to map request\n");
  658. return -EINVAL;
  659. }
  660. request->status = -EINPROGRESS;
  661. list_add_tail(&request->list, &priv_ep->pending_req_list);
  662. if (request->zero && request->length &&
  663. (request->length % ep->maxpacket == 0))
  664. zlp = 1;
  665. cdns3_ep0_run_transfer(priv_dev, request->dma, request->length, 1, zlp);
  666. spin_unlock_irqrestore(&priv_dev->lock, flags);
  667. return ret;
  668. }
  669. /**
  670. * cdns3_gadget_ep_set_wedge Set wedge on selected endpoint
  671. * @ep: endpoint object
  672. *
  673. * Returns 0
  674. */
  675. int cdns3_gadget_ep_set_wedge(struct usb_ep *ep)
  676. {
  677. struct cdns3_endpoint *priv_ep = ep_to_cdns3_ep(ep);
  678. dev_dbg(priv_ep->cdns3_dev->dev, "Wedge for %s\n", ep->name);
  679. cdns3_gadget_ep_set_halt(ep, 1);
  680. priv_ep->flags |= EP_WEDGE;
  681. return 0;
  682. }
  683. const struct usb_ep_ops cdns3_gadget_ep0_ops = {
  684. .enable = cdns3_gadget_ep0_enable,
  685. .disable = cdns3_gadget_ep0_disable,
  686. .alloc_request = cdns3_gadget_ep_alloc_request,
  687. .free_request = cdns3_gadget_ep_free_request,
  688. .queue = cdns3_gadget_ep0_queue,
  689. .dequeue = cdns3_gadget_ep_dequeue,
  690. .set_halt = cdns3_gadget_ep0_set_halt,
  691. .set_wedge = cdns3_gadget_ep_set_wedge,
  692. };
  693. /**
  694. * cdns3_ep0_config - Configures default endpoint
  695. * @priv_dev: extended gadget object
  696. *
  697. * Functions sets parameters: maximal packet size and enables interrupts
  698. */
  699. void cdns3_ep0_config(struct cdns3_device *priv_dev)
  700. {
  701. struct cdns3_usb_regs __iomem *regs;
  702. struct cdns3_endpoint *priv_ep;
  703. u32 max_packet_size = 64;
  704. regs = priv_dev->regs;
  705. if (priv_dev->gadget.speed == USB_SPEED_SUPER)
  706. max_packet_size = 512;
  707. priv_ep = priv_dev->eps[0];
  708. if (!list_empty(&priv_ep->pending_req_list)) {
  709. struct usb_request *request;
  710. request = cdns3_next_request(&priv_ep->pending_req_list);
  711. list_del_init(&request->list);
  712. }
  713. priv_dev->u1_allowed = 0;
  714. priv_dev->u2_allowed = 0;
  715. priv_dev->gadget.ep0->maxpacket = max_packet_size;
  716. cdns3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(max_packet_size);
  717. /* init ep out */
  718. cdns3_select_ep(priv_dev, USB_DIR_OUT);
  719. if (priv_dev->dev_ver >= DEV_VER_V3) {
  720. cdns3_set_register_bit(&priv_dev->regs->dtrans,
  721. BIT(0) | BIT(16));
  722. cdns3_set_register_bit(&priv_dev->regs->tdl_from_trb,
  723. BIT(0) | BIT(16));
  724. }
  725. writel(EP_CFG_ENABLE | EP_CFG_MAXPKTSIZE(max_packet_size),
  726. &regs->ep_cfg);
  727. writel(EP_STS_EN_SETUPEN | EP_STS_EN_DESCMISEN | EP_STS_EN_TRBERREN,
  728. &regs->ep_sts_en);
  729. /* init ep in */
  730. cdns3_select_ep(priv_dev, USB_DIR_IN);
  731. writel(EP_CFG_ENABLE | EP_CFG_MAXPKTSIZE(max_packet_size),
  732. &regs->ep_cfg);
  733. writel(EP_STS_EN_SETUPEN | EP_STS_EN_TRBERREN, &regs->ep_sts_en);
  734. cdns3_set_register_bit(&regs->usb_conf, USB_CONF_U1DS | USB_CONF_U2DS);
  735. }
  736. /**
  737. * cdns3_init_ep0 Initializes software endpoint 0 of gadget
  738. * @priv_dev: extended gadget object
  739. * @ep_priv: extended endpoint object
  740. *
  741. * Returns 0 on success else error code.
  742. */
  743. int cdns3_init_ep0(struct cdns3_device *priv_dev,
  744. struct cdns3_endpoint *priv_ep)
  745. {
  746. sprintf(priv_ep->name, "ep0");
  747. /* fill linux fields */
  748. priv_ep->endpoint.ops = &cdns3_gadget_ep0_ops;
  749. priv_ep->endpoint.maxburst = 1;
  750. usb_ep_set_maxpacket_limit(&priv_ep->endpoint,
  751. CDNS3_EP0_MAX_PACKET_LIMIT);
  752. #ifndef __UBOOT__
  753. priv_ep->endpoint.address = 0;
  754. #endif
  755. priv_ep->endpoint.caps.type_control = 1;
  756. priv_ep->endpoint.caps.dir_in = 1;
  757. priv_ep->endpoint.caps.dir_out = 1;
  758. priv_ep->endpoint.name = priv_ep->name;
  759. priv_ep->endpoint.desc = &cdns3_gadget_ep0_desc;
  760. priv_dev->gadget.ep0 = &priv_ep->endpoint;
  761. priv_ep->type = USB_ENDPOINT_XFER_CONTROL;
  762. return cdns3_allocate_trb_pool(priv_ep);
  763. }