Lines Matching defs:pdev
75 static int cdns2_get_dma_pos(struct cdns2_device *pdev,
80 dma_index = readl(&pdev->adma_regs->ep_traddr) - pep->ring.dma;
91 void cdns2_select_ep(struct cdns2_device *pdev, u32 ep)
93 if (pdev->selected_ep == ep)
96 pdev->selected_ep = ep;
97 writel(ep, &pdev->adma_regs->ep_sel);
110 struct cdns2_device *pdev = pep->pdev;
114 dma_pool_free(pdev->eps_dma_pool, ring->trbs, ring->dma);
122 struct cdns2_device *pdev = pep->pdev;
129 ring->trbs = dma_pool_alloc(pdev->eps_dma_pool,
156 struct cdns2_device *pdev = pep->pdev;
161 writel(DMA_EP_CMD_DFLUSH, &pdev->adma_regs->ep_cmd);
164 readl_poll_timeout_atomic(&pdev->adma_regs->ep_cmd, val,
206 static void cdns2_enable_l1(struct cdns2_device *pdev, int enable)
209 clear_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_LPMNYET);
210 writeb(LPMCLOCK_SLEEP_ENTRY, &pdev->usb_regs->lpmclock);
212 set_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_LPMNYET);
216 static enum usb_device_speed cdns2_get_speed(struct cdns2_device *pdev)
218 u8 speed = readb(&pdev->usb_regs->speedctrl);
242 struct cdns2_device *pdev = pep->pdev;
249 usb_gadget_unmap_request_by_dev(pdev->dev, request, pep->dir);
257 spin_unlock(&pdev->lock);
259 spin_lock(&pdev->lock);
262 if (request->buf == pdev->zlp_buf)
284 struct cdns2_device *pdev = pep->pdev;
289 doorbell = !!(readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY);
303 static void cdns2_wa1_tray_restore_cycle_bit(struct cdns2_device *pdev,
309 doorbell = !!(readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY);
310 dma_index = cdns2_get_dma_pos(pdev, pep);
316 static int cdns2_prepare_ring(struct cdns2_device *pdev,
334 doorbell = !!(readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY);
335 dma_index = cdns2_get_dma_pos(pdev, pep);
472 static void cdsn2_isoc_burst_opt(struct cdns2_device *pdev)
493 pdev->burst_opt[i] = axi_burst_option[j];
585 TRB_BURST(pep->pdev->burst_opt[trb_buff_len]);
689 static void cdns2_set_drdy(struct cdns2_device *pdev,
701 &pdev->adma_regs->ep_sts);
702 writel(DMA_EP_CMD_DRDY, &pdev->adma_regs->ep_cmd);
704 if (readl(&pdev->adma_regs->ep_sts) & DMA_EP_STS_TRBERR) {
705 writel(DMA_EP_STS_TRBERR, &pdev->adma_regs->ep_sts);
706 writel(DMA_EP_CMD_DRDY, &pdev->adma_regs->ep_cmd);
709 trace_cdns2_doorbell_epx(pep, readl(&pdev->adma_regs->ep_traddr));
712 static int cdns2_prepare_first_isoc_transfer(struct cdns2_device *pdev,
719 if ((readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY))
723 set_reg_bit_32(&pdev->adma_regs->ep_cfg, DMA_EP_CFG_ENABLE);
725 &pdev->adma_regs->ep_traddr);
734 hw_ccs = !!DMA_EP_STS_CCS(readl(&pdev->adma_regs->ep_sts));
754 set_reg_bit_32(&pdev->adma_regs->ep_cfg, DMA_EP_CFG_ENABLE);
756 &pdev->adma_regs->ep_traddr);
765 struct cdns2_device *pdev = pep->pdev;
771 cdns2_select_ep(pdev, pep->endpoint.address);
779 ret = cdns2_prepare_ring(pdev, pep, num_trbs);
805 cdns2_wa1_tray_restore_cycle_bit(pdev, pep);
810 ret = cdns2_prepare_first_isoc_transfer(pdev, pep);
815 cdns2_set_drdy(pdev, pep);
822 static int cdns2_start_all_request(struct cdns2_device *pdev,
882 struct cdns2_device *pdev = pep->pdev;
890 current_index = cdns2_get_dma_pos(pdev, pep);
891 doorbell = !!(readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY);
950 static void cdns2_skip_isoc_td(struct cdns2_device *pdev,
967 cdns2_prepare_first_isoc_transfer(pdev, pep);
969 cdns2_set_drdy(pdev, pep);
972 static void cdns2_transfer_completed(struct cdns2_device *pdev,
998 cdns2_select_ep(pdev, pep->endpoint.address);
1036 cdns2_skip_isoc_td(pdev, pep, preq);
1040 cdns2_start_all_request(pdev, pep);
1043 static void cdns2_wakeup(struct cdns2_device *pdev)
1045 if (!pdev->may_wakeup)
1049 set_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_SIGRSUME);
1054 struct cdns2_device *pdev = pep->pdev;
1064 writel(DMA_EP_CMD_DRDY, &pdev->adma_regs->ep_cmd);
1066 cdns2_wakeup(pdev);
1069 readl(&pdev->adma_regs->ep_traddr));
1075 struct cdns2_device *pdev = pep->pdev;
1080 cdns2_select_ep(pdev, pep->endpoint.address);
1082 trace_cdns2_epx_irq(pdev, pep);
1084 ep_sts_reg = readl(&pdev->adma_regs->ep_sts);
1085 writel(ep_sts_reg, &pdev->adma_regs->ep_sts);
1092 cs = pep->dir ? readb(&pdev->epx_regs->ep[pep->num - 1].txcs) :
1093 readb(&pdev->epx_regs->ep[pep->num - 1].rxcs);
1104 clear_reg_bit_32(&pdev->adma_regs->ep_cfg, DMA_EP_CFG_ENABLE);
1107 readl_poll_timeout_atomic(&pdev->adma_regs->ep_sts, val,
1110 writel(DMA_EP_CMD_DFLUSH, &pep->pdev->adma_regs->ep_cmd);
1113 readl_poll_timeout_atomic(&pep->pdev->adma_regs->ep_cmd, val,
1133 clear_reg_bit_32(&pdev->adma_regs->ep_cfg,
1136 cdns2_transfer_completed(pdev, pep);
1139 cdns2_set_drdy(pdev, pep);
1145 cdns2_transfer_completed(pdev, pep);
1151 cdns2_start_all_request(pdev, pep);
1161 cdns2_transfer_completed(pdev, pep);
1164 static void cdns2_disconnect_gadget(struct cdns2_device *pdev)
1166 if (pdev->gadget_driver && pdev->gadget_driver->disconnect)
1167 pdev->gadget_driver->disconnect(&pdev->gadget);
1172 struct cdns2_device *pdev = data;
1179 if (pdev->in_lpm)
1182 reg_usb_irq_m = readb(&pdev->interrupt_regs->usbien);
1183 reg_ext_irq_m = readb(&pdev->interrupt_regs->extien);
1186 writeb(0, &pdev->interrupt_regs->usbien);
1187 writeb(0, &pdev->interrupt_regs->extien);
1188 writel(0, &pdev->adma_regs->ep_ien);
1191 writel(0, &pdev->adma_regs->ep_sts);
1192 writeb(0, &pdev->interrupt_regs->usbirq);
1193 writeb(0, &pdev->interrupt_regs->extirq);
1195 reg_ep_ists = readl(&pdev->adma_regs->ep_ists);
1196 reg_usb_irq = readb(&pdev->interrupt_regs->usbirq);
1197 reg_ext_irq = readb(&pdev->interrupt_regs->extirq);
1203 writeb(USB_IEN_INIT, &pdev->interrupt_regs->usbien);
1204 writeb(EXTIRQ_WAKEUP, &pdev->interrupt_regs->extien);
1205 writel(~0, &pdev->adma_regs->ep_ien);
1210 static irqreturn_t cdns2_thread_usb_irq_handler(struct cdns2_device *pdev)
1216 ext_irq = readb(&pdev->interrupt_regs->extirq) & EXTIRQ_WAKEUP;
1217 writeb(ext_irq, &pdev->interrupt_regs->extirq);
1219 usb_irq = readb(&pdev->interrupt_regs->usbirq) & USB_IEN_INIT;
1220 writeb(usb_irq, &pdev->interrupt_regs->usbirq);
1228 if (pdev->gadget_driver && pdev->gadget_driver->resume) {
1229 spin_unlock(&pdev->lock);
1230 pdev->gadget_driver->resume(&pdev->gadget);
1231 spin_lock(&pdev->lock);
1236 u8 reg = readb(&pdev->usb_regs->lpmctrl);
1240 writeb(0, &pdev->usb_regs->sleep_clkgate);
1244 if (pdev->gadget_driver && pdev->gadget_driver->suspend) {
1245 spin_unlock(&pdev->lock);
1246 pdev->gadget_driver->suspend(&pdev->gadget);
1247 spin_lock(&pdev->lock);
1252 if (pdev->gadget_driver) {
1253 pdev->dev_address = 0;
1255 spin_unlock(&pdev->lock);
1256 usb_gadget_udc_reset(&pdev->gadget,
1257 pdev->gadget_driver);
1258 spin_lock(&pdev->lock);
1268 speed = cdns2_get_speed(pdev);
1273 pdev->gadget.speed = speed;
1274 cdns2_enable_l1(pdev, 0);
1275 cdns2_ep0_config(pdev);
1276 pdev->may_wakeup = 0;
1281 pdev->ep0_stage = CDNS2_SETUP_STAGE;
1282 cdns2_handle_setup_packet(pdev);
1291 struct cdns2_device *pdev = data;
1297 spin_lock_irqsave(&pdev->lock, flags);
1299 cdns2_thread_usb_irq_handler(pdev);
1301 dma_ep_ists = readl(&pdev->adma_regs->ep_ists);
1309 cdns2_handle_ep0_interrupt(pdev, USB_DIR_OUT);
1313 cdns2_handle_ep0_interrupt(pdev, USB_DIR_IN);
1321 * Endpoints in pdev->eps[] are held in order:
1326 cdns2_handle_epx_interrupt(&pdev->eps[ep_idx]);
1330 writel(~0, &pdev->adma_regs->ep_ien);
1331 writeb(USB_IEN_INIT, &pdev->interrupt_regs->usbien);
1332 writeb(EXTIRQ_WAKEUP, &pdev->interrupt_regs->extien);
1334 spin_unlock_irqrestore(&pdev->lock, flags);
1341 static void cdns2_eps_onchip_buffer_init(struct cdns2_device *pdev)
1352 pep = &pdev->eps[i];
1364 pep = &pdev->eps[i];
1370 free = pdev->onchip_tx_buf - min_buf_tx;
1382 &pdev->epx_regs->txstaddr[pep->num - 1]);
1383 pdev->epx_regs->txstaddr[pep->num - 1] = tx_offset;
1385 dev_dbg(pdev->dev, "%s onchip address %04x, buffering: %d\n",
1390 free = pdev->onchip_rx_buf - min_buf_rx;
1401 &pdev->epx_regs->rxstaddr[pep->num - 1]);
1403 dev_dbg(pdev->dev, "%s onchip address %04x, buffering: %d\n",
1415 struct cdns2_device *pdev = pep->pdev;
1436 set_reg_bit_8(&pdev->epx_regs->isoautoarm, BIT(pep->num));
1437 set_reg_bit_8(&pdev->epx_regs->isoautodump, BIT(pep->num));
1438 set_reg_bit_8(&pdev->epx_regs->isodctrl, BIT(pep->num));
1442 switch (pdev->gadget.speed) {
1458 writew(max_packet_size, &pdev->epx_regs->txmaxpack[pep->num - 1]);
1459 writeb(ep_cfg, &pdev->epx_regs->ep[pep->num - 1].txcon);
1461 writew(max_packet_size, &pdev->epx_regs->rxmaxpack[pep->num - 1]);
1462 writeb(ep_cfg, &pdev->epx_regs->ep[pep->num - 1].rxcon);
1466 &pdev->usb_regs->fifoctrl);
1467 writeb(pep->num | dir, &pdev->epx_regs->endprst);
1469 &pdev->epx_regs->endprst);
1478 cdns2_select_ep(pdev, pep->num | pep->dir);
1479 writel(DMA_EP_CMD_EPRST | DMA_EP_CMD_DFLUSH, &pdev->adma_regs->ep_cmd);
1481 ret = readl_poll_timeout_atomic(&pdev->adma_regs->ep_cmd, val,
1489 writel(DMA_EP_STS_TRBERR | DMA_EP_STS_ISOERR, &pdev->adma_regs->ep_sts_en);
1492 writel(DMA_EP_CFG_ENABLE, &pdev->adma_regs->ep_cfg);
1494 trace_cdns2_epx_hw_cfg(pdev, pep);
1496 dev_dbg(pdev->dev, "Configure %s: with MPS: %08x, ep con: %02x\n",
1533 struct cdns2_device *pdev;
1544 pdev = pep->pdev;
1546 if (dev_WARN_ONCE(pdev->dev, pep->ep_state & EP_ENABLED,
1550 spin_lock_irqsave(&pdev->lock, flags);
1555 if (pdev->gadget.speed == USB_SPEED_FULL)
1561 dev_err(pdev->dev, "ISO period is limited to %d (current: %d)\n",
1597 reg = readl(&pdev->adma_regs->ep_sts);
1601 writel(pep->ring.dma, &pdev->adma_regs->ep_traddr);
1607 spin_unlock_irqrestore(&pdev->lock, flags);
1616 struct cdns2_device *pdev;
1624 pdev = pep->pdev;
1626 if (dev_WARN_ONCE(pdev->dev, !(pep->ep_state & EP_ENABLED),
1630 spin_lock_irqsave(&pdev->lock, flags);
1634 cdns2_select_ep(pdev, ep->desc->bEndpointAddress);
1636 clear_reg_bit_32(&pdev->adma_regs->ep_cfg, DMA_EP_CFG_ENABLE);
1643 readl_poll_timeout_atomic(&pdev->adma_regs->ep_sts, val,
1645 writel(DMA_EP_CMD_EPRST, &pdev->adma_regs->ep_cmd);
1647 readl_poll_timeout_atomic(&pdev->adma_regs->ep_cmd, val,
1664 spin_unlock_irqrestore(&pdev->lock, flags);
1673 struct cdns2_device *pdev = pep->pdev;
1681 ret = usb_gadget_map_request_by_dev(pdev->dev, request, pep->dir);
1691 cdns2_start_all_request(pdev, pep);
1702 struct cdns2_device *pdev;
1710 pdev = pep->pdev;
1713 dev_err(pdev->dev, "%s: can't queue to disabled endpoint\n",
1718 spin_lock_irqsave(&pdev->lock, flags);
1728 zlp_request->buf = pdev->zlp_buf;
1735 spin_unlock_irqrestore(&pdev->lock, flags);
1755 dev_err(pep->pdev->dev, "%s: can't dequeue to disabled endpoint\n",
1764 spin_lock_irqsave(&pep->pdev->lock, flags);
1789 writel(DMA_EP_CMD_DFLUSH, &pep->pdev->adma_regs->ep_cmd);
1792 readl_poll_timeout_atomic(&pep->pdev->adma_regs->ep_cmd, val,
1819 spin_unlock_irqrestore(&pep->pdev->lock, flags);
1823 int cdns2_halt_endpoint(struct cdns2_device *pdev,
1835 conf = &pdev->epx_regs->ep[pep->num - 1].txcon;
1837 conf = &pdev->epx_regs->ep[pep->num - 1].rxcon;
1857 writeb(dir | pep->num, &pdev->epx_regs->endprst);
1859 &pdev->epx_regs->endprst);
1872 cdns2_start_all_request(pdev, pep);
1876 writeb(dir | pep->num, &pdev->epx_regs->endprst);
1878 &pdev->epx_regs->endprst);
1889 struct cdns2_device *pdev = pep->pdev;
1894 spin_lock_irqsave(&pdev->lock, flags);
1906 ret = cdns2_halt_endpoint(pdev, pep, value);
1909 spin_unlock_irqrestore(&pdev->lock, flags);
1924 cdns2_endpoint *cdns2_find_available_ep(struct cdns2_device *pdev,
1931 list_for_each_entry(ep, &pdev->gadget.ep_list, ep_list) {
1966 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
1970 pep = cdns2_find_available_ep(pdev, desc);
1972 dev_err(pdev->dev, "no available ep\n");
1976 spin_lock_irqsave(&pdev->lock, flags);
1984 spin_unlock_irqrestore(&pdev->lock, flags);
2002 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2004 return readw(&pdev->usb_regs->frmnr);
2009 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2012 spin_lock_irqsave(&pdev->lock, flags);
2013 cdns2_wakeup(pdev);
2014 spin_unlock_irqrestore(&pdev->lock, flags);
2022 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2025 spin_lock_irqsave(&pdev->lock, flags);
2026 pdev->is_selfpowered = !!is_selfpowered;
2027 spin_unlock_irqrestore(&pdev->lock, flags);
2032 static void cdns2_quiesce(struct cdns2_device *pdev)
2034 set_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_DISCON);
2037 writeb(0, &pdev->interrupt_regs->extien);
2038 writeb(0, &pdev->interrupt_regs->usbien);
2039 writew(0, &pdev->adma_regs->ep_ien);
2042 writeb(0x0, &pdev->interrupt_regs->usbirq);
2045 static void cdns2_gadget_config(struct cdns2_device *pdev)
2047 cdns2_ep0_config(pdev);
2050 writel(~0x0, &pdev->adma_regs->ep_ien);
2051 cdns2_enable_l1(pdev, 0);
2052 writeb(USB_IEN_INIT, &pdev->interrupt_regs->usbien);
2053 writeb(EXTIRQ_WAKEUP, &pdev->interrupt_regs->extien);
2054 writel(DMA_CONF_DMULT, &pdev->adma_regs->conf);
2059 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2068 disable_irq(pdev->irq);
2069 spin_lock_irqsave(&pdev->lock, flags);
2072 cdns2_gadget_config(pdev);
2073 clear_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_DISCON);
2075 cdns2_quiesce(pdev);
2078 spin_unlock_irqrestore(&pdev->lock, flags);
2079 enable_irq(pdev->irq);
2087 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2091 spin_lock_irqsave(&pdev->lock, flags);
2092 pdev->gadget_driver = driver;
2099 writeb(SPEEDCTRL_HSDISABLE, &pdev->usb_regs->speedctrl);
2102 writeb(0, &pdev->usb_regs->speedctrl);
2105 dev_err(pdev->dev, "invalid maximum_speed parameter %d\n",
2115 writeb(ENDPRST_IO_TX, &pdev->usb_regs->endprst);
2117 &pdev->usb_regs->endprst);
2118 writeb(ENDPRST_FIFORST | ENDPRST_TOGRST, &pdev->usb_regs->endprst);
2120 cdns2_eps_onchip_buffer_init(pdev);
2122 cdns2_gadget_config(pdev);
2123 spin_unlock_irqrestore(&pdev->lock, flags);
2130 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2136 pdev->gadget_driver = NULL;
2137 pdev->gadget.speed = USB_SPEED_UNKNOWN;
2139 list_for_each_entry(ep, &pdev->gadget.ep_list, ep_list) {
2142 cdns2_select_ep(pdev, bEndpointAddress);
2143 writel(DMA_EP_CMD_EPRST, &pdev->adma_regs->ep_cmd);
2144 readl_poll_timeout_atomic(&pdev->adma_regs->ep_cmd, val,
2148 cdns2_quiesce(pdev);
2150 writeb(ENDPRST_IO_TX, &pdev->usb_regs->endprst);
2152 &pdev->epx_regs->endprst);
2153 writeb(ENDPRST_FIFORST | ENDPRST_TOGRST, &pdev->epx_regs->endprst);
2168 static void cdns2_free_all_eps(struct cdns2_device *pdev)
2173 cdns2_free_tr_segment(&pdev->eps[i]);
2177 static int cdns2_init_eps(struct cdns2_device *pdev)
2187 * Endpoints are being held in pdev->eps[] in form:
2190 if (!CDNS2_IF_EP_EXIST(pdev, epnum, direction))
2193 pep = &pdev->eps[i];
2194 pep->pdev = pdev;
2200 /* Ep0in and ep0out are represented by pdev->eps[0]. */
2207 cdns2_init_ep0(pdev, pep);
2211 dev_err(pdev->dev, "Failed to init ep0\n");
2221 list_add_tail(&pep->endpoint.ep_list, &pdev->gadget.ep_list);
2234 dev_dbg(pdev->dev, "Init %s, SupType: CTRL: %s, INT: %s, "
2251 static int cdns2_gadget_start(struct cdns2_device *pdev)
2257 pdev->usb_regs = pdev->regs;
2258 pdev->ep0_regs = pdev->regs;
2259 pdev->epx_regs = pdev->regs;
2260 pdev->interrupt_regs = pdev->regs;
2261 pdev->adma_regs = pdev->regs + CDNS2_ADMA_REGS_OFFSET;
2265 &pdev->usb_regs->cpuctrl);
2268 usb_initialize_gadget(pdev->dev, &pdev->gadget, NULL);
2270 device_property_read_u16(pdev->dev, "cdns,on-chip-tx-buff-size",
2271 &pdev->onchip_tx_buf);
2272 device_property_read_u16(pdev->dev, "cdns,on-chip-rx-buff-size",
2273 &pdev->onchip_rx_buf);
2274 device_property_read_u32(pdev->dev, "cdns,avail-endpoints",
2275 &pdev->eps_supported);
2281 if (!pdev->onchip_tx_buf && !pdev->onchip_rx_buf) {
2283 dev_err(pdev->dev, "Invalid on-chip memory configuration\n");
2287 if (!(pdev->eps_supported & ~0x00010001)) {
2289 dev_err(pdev->dev, "No hardware endpoints available\n");
2293 max_speed = usb_get_maximum_speed(pdev->dev);
2300 dev_err(pdev->dev, "invalid maximum_speed parameter %d\n",
2308 pdev->gadget.max_speed = max_speed;
2309 pdev->gadget.speed = USB_SPEED_UNKNOWN;
2310 pdev->gadget.ops = &cdns2_gadget_ops;
2311 pdev->gadget.name = "usbhs-gadget";
2312 pdev->gadget.quirk_avoids_skb_reserve = 1;
2313 pdev->gadget.irq = pdev->irq;
2315 spin_lock_init(&pdev->lock);
2316 INIT_WORK(&pdev->pending_status_wq, cdns2_pending_setup_status_handler);
2319 INIT_LIST_HEAD(&pdev->gadget.ep_list);
2320 pdev->eps_dma_pool = dma_pool_create("cdns2_eps_dma_pool", pdev->dev,
2322 if (!pdev->eps_dma_pool) {
2323 dev_err(pdev->dev, "Failed to create TRB dma pool\n");
2328 ret = cdns2_init_eps(pdev);
2330 dev_err(pdev->dev, "Failed to create endpoints\n");
2334 pdev->gadget.sg_supported = 1;
2336 pdev->zlp_buf = kzalloc(CDNS2_EP_ZLP_BUF_SIZE, GFP_KERNEL);
2337 if (!pdev->zlp_buf) {
2343 buf = dma_alloc_coherent(pdev->dev, 8, &pdev->ep0_preq.request.dma,
2345 pdev->ep0_preq.request.buf = buf;
2347 if (!pdev->ep0_preq.request.buf) {
2353 ret = usb_add_gadget(&pdev->gadget);
2355 dev_err(pdev->dev, "Failed to add gadget\n");
2362 dma_free_coherent(pdev->dev, 8, pdev->ep0_preq.request.buf,
2363 pdev->ep0_preq.request.dma);
2365 kfree(pdev->zlp_buf);
2367 dma_pool_destroy(pdev->eps_dma_pool);
2369 usb_put_gadget(&pdev->gadget);
2374 int cdns2_gadget_suspend(struct cdns2_device *pdev)
2378 cdns2_disconnect_gadget(pdev);
2380 spin_lock_irqsave(&pdev->lock, flags);
2381 pdev->gadget.speed = USB_SPEED_UNKNOWN;
2384 usb_gadget_set_state(&pdev->gadget, USB_STATE_NOTATTACHED);
2385 cdns2_enable_l1(pdev, 0);
2388 writeb(0, &pdev->interrupt_regs->usbien);
2389 writel(0, &pdev->adma_regs->ep_ien);
2390 spin_unlock_irqrestore(&pdev->lock, flags);
2395 int cdns2_gadget_resume(struct cdns2_device *pdev, bool hibernated)
2399 spin_lock_irqsave(&pdev->lock, flags);
2401 if (!pdev->gadget_driver) {
2402 spin_unlock_irqrestore(&pdev->lock, flags);
2406 cdns2_gadget_config(pdev);
2409 clear_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_DISCON);
2411 spin_unlock_irqrestore(&pdev->lock, flags);
2416 void cdns2_gadget_remove(struct cdns2_device *pdev)
2418 pm_runtime_mark_last_busy(pdev->dev);
2419 pm_runtime_put_autosuspend(pdev->dev);
2421 usb_del_gadget(&pdev->gadget);
2422 cdns2_free_all_eps(pdev);
2424 dma_pool_destroy(pdev->eps_dma_pool);
2425 kfree(pdev->zlp_buf);
2426 usb_put_gadget(&pdev->gadget);
2429 int cdns2_gadget_init(struct cdns2_device *pdev)
2434 ret = dma_set_mask_and_coherent(pdev->dev, DMA_BIT_MASK(32));
2436 dev_err(pdev->dev, "Failed to set dma mask: %d\n", ret);
2440 pm_runtime_get_sync(pdev->dev);
2442 cdsn2_isoc_burst_opt(pdev);
2444 ret = cdns2_gadget_start(pdev);
2446 pm_runtime_put_sync(pdev->dev);
2454 ret = devm_request_threaded_irq(pdev->dev, pdev->irq,
2458 dev_name(pdev->dev),
2459 pdev);
2466 cdns2_gadget_remove(pdev);