Lines Matching refs:pdev
74 static int cdns2_get_dma_pos(struct cdns2_device *pdev,
79 dma_index = readl(&pdev->adma_regs->ep_traddr) - pep->ring.dma;
90 void cdns2_select_ep(struct cdns2_device *pdev, u32 ep)
92 if (pdev->selected_ep == ep)
95 pdev->selected_ep = ep;
96 writel(ep, &pdev->adma_regs->ep_sel);
109 struct cdns2_device *pdev = pep->pdev;
113 dma_pool_free(pdev->eps_dma_pool, ring->trbs, ring->dma);
121 struct cdns2_device *pdev = pep->pdev;
128 ring->trbs = dma_pool_alloc(pdev->eps_dma_pool,
155 struct cdns2_device *pdev = pep->pdev;
160 writel(DMA_EP_CMD_DFLUSH, &pdev->adma_regs->ep_cmd);
163 readl_poll_timeout_atomic(&pdev->adma_regs->ep_cmd, val,
205 static void cdns2_enable_l1(struct cdns2_device *pdev, int enable)
208 clear_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_LPMNYET);
209 writeb(LPMCLOCK_SLEEP_ENTRY, &pdev->usb_regs->lpmclock);
211 set_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_LPMNYET);
215 static enum usb_device_speed cdns2_get_speed(struct cdns2_device *pdev)
217 u8 speed = readb(&pdev->usb_regs->speedctrl);
241 struct cdns2_device *pdev = pep->pdev;
248 usb_gadget_unmap_request_by_dev(pdev->dev, request, pep->dir);
256 spin_unlock(&pdev->lock);
258 spin_lock(&pdev->lock);
261 if (request->buf == pdev->zlp_buf)
283 struct cdns2_device *pdev = pep->pdev;
288 doorbell = !!(readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY);
302 static void cdns2_wa1_tray_restore_cycle_bit(struct cdns2_device *pdev,
308 doorbell = !!(readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY);
309 dma_index = cdns2_get_dma_pos(pdev, pep);
315 static int cdns2_prepare_ring(struct cdns2_device *pdev,
333 doorbell = !!(readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY);
334 dma_index = cdns2_get_dma_pos(pdev, pep);
471 static void cdsn2_isoc_burst_opt(struct cdns2_device *pdev)
492 pdev->burst_opt[i] = axi_burst_option[j];
584 TRB_BURST(pep->pdev->burst_opt[trb_buff_len]);
688 static void cdns2_set_drdy(struct cdns2_device *pdev,
700 &pdev->adma_regs->ep_sts);
701 writel(DMA_EP_CMD_DRDY, &pdev->adma_regs->ep_cmd);
703 if (readl(&pdev->adma_regs->ep_sts) & DMA_EP_STS_TRBERR) {
704 writel(DMA_EP_STS_TRBERR, &pdev->adma_regs->ep_sts);
705 writel(DMA_EP_CMD_DRDY, &pdev->adma_regs->ep_cmd);
708 trace_cdns2_doorbell_epx(pep, readl(&pdev->adma_regs->ep_traddr));
711 static int cdns2_prepare_first_isoc_transfer(struct cdns2_device *pdev,
718 if ((readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY))
722 set_reg_bit_32(&pdev->adma_regs->ep_cfg, DMA_EP_CFG_ENABLE);
724 &pdev->adma_regs->ep_traddr);
733 hw_ccs = !!DMA_EP_STS_CCS(readl(&pdev->adma_regs->ep_sts));
753 set_reg_bit_32(&pdev->adma_regs->ep_cfg, DMA_EP_CFG_ENABLE);
755 &pdev->adma_regs->ep_traddr);
764 struct cdns2_device *pdev = pep->pdev;
770 cdns2_select_ep(pdev, pep->endpoint.address);
778 ret = cdns2_prepare_ring(pdev, pep, num_trbs);
804 cdns2_wa1_tray_restore_cycle_bit(pdev, pep);
809 ret = cdns2_prepare_first_isoc_transfer(pdev, pep);
814 cdns2_set_drdy(pdev, pep);
821 static int cdns2_start_all_request(struct cdns2_device *pdev,
881 struct cdns2_device *pdev = pep->pdev;
889 current_index = cdns2_get_dma_pos(pdev, pep);
890 doorbell = !!(readl(&pdev->adma_regs->ep_cmd) & DMA_EP_CMD_DRDY);
949 static void cdns2_skip_isoc_td(struct cdns2_device *pdev,
966 cdns2_prepare_first_isoc_transfer(pdev, pep);
968 cdns2_set_drdy(pdev, pep);
971 static void cdns2_transfer_completed(struct cdns2_device *pdev,
997 cdns2_select_ep(pdev, pep->endpoint.address);
1035 cdns2_skip_isoc_td(pdev, pep, preq);
1039 cdns2_start_all_request(pdev, pep);
1042 static void cdns2_wakeup(struct cdns2_device *pdev)
1044 if (!pdev->may_wakeup)
1048 set_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_SIGRSUME);
1053 struct cdns2_device *pdev = pep->pdev;
1063 writel(DMA_EP_CMD_DRDY, &pdev->adma_regs->ep_cmd);
1065 cdns2_wakeup(pdev);
1068 readl(&pdev->adma_regs->ep_traddr));
1074 struct cdns2_device *pdev = pep->pdev;
1079 cdns2_select_ep(pdev, pep->endpoint.address);
1081 trace_cdns2_epx_irq(pdev, pep);
1083 ep_sts_reg = readl(&pdev->adma_regs->ep_sts);
1084 writel(ep_sts_reg, &pdev->adma_regs->ep_sts);
1091 cs = pep->dir ? readb(&pdev->epx_regs->ep[pep->num - 1].txcs) :
1092 readb(&pdev->epx_regs->ep[pep->num - 1].rxcs);
1103 clear_reg_bit_32(&pdev->adma_regs->ep_cfg, DMA_EP_CFG_ENABLE);
1106 readl_poll_timeout_atomic(&pdev->adma_regs->ep_sts, val,
1109 writel(DMA_EP_CMD_DFLUSH, &pep->pdev->adma_regs->ep_cmd);
1112 readl_poll_timeout_atomic(&pep->pdev->adma_regs->ep_cmd, val,
1132 clear_reg_bit_32(&pdev->adma_regs->ep_cfg,
1135 cdns2_transfer_completed(pdev, pep);
1138 cdns2_set_drdy(pdev, pep);
1144 cdns2_transfer_completed(pdev, pep);
1150 cdns2_start_all_request(pdev, pep);
1160 cdns2_transfer_completed(pdev, pep);
1163 static void cdns2_disconnect_gadget(struct cdns2_device *pdev)
1165 if (pdev->gadget_driver && pdev->gadget_driver->disconnect)
1166 pdev->gadget_driver->disconnect(&pdev->gadget);
1171 struct cdns2_device *pdev = data;
1178 if (pdev->in_lpm)
1181 reg_usb_irq_m = readb(&pdev->interrupt_regs->usbien);
1182 reg_ext_irq_m = readb(&pdev->interrupt_regs->extien);
1185 writeb(0, &pdev->interrupt_regs->usbien);
1186 writeb(0, &pdev->interrupt_regs->extien);
1187 writel(0, &pdev->adma_regs->ep_ien);
1190 writel(0, &pdev->adma_regs->ep_sts);
1191 writeb(0, &pdev->interrupt_regs->usbirq);
1192 writeb(0, &pdev->interrupt_regs->extirq);
1194 reg_ep_ists = readl(&pdev->adma_regs->ep_ists);
1195 reg_usb_irq = readb(&pdev->interrupt_regs->usbirq);
1196 reg_ext_irq = readb(&pdev->interrupt_regs->extirq);
1202 writeb(USB_IEN_INIT, &pdev->interrupt_regs->usbien);
1203 writeb(EXTIRQ_WAKEUP, &pdev->interrupt_regs->extien);
1204 writel(~0, &pdev->adma_regs->ep_ien);
1209 static irqreturn_t cdns2_thread_usb_irq_handler(struct cdns2_device *pdev)
1215 ext_irq = readb(&pdev->interrupt_regs->extirq) & EXTIRQ_WAKEUP;
1216 writeb(ext_irq, &pdev->interrupt_regs->extirq);
1218 usb_irq = readb(&pdev->interrupt_regs->usbirq) & USB_IEN_INIT;
1219 writeb(usb_irq, &pdev->interrupt_regs->usbirq);
1227 if (pdev->gadget_driver && pdev->gadget_driver->resume) {
1228 spin_unlock(&pdev->lock);
1229 pdev->gadget_driver->resume(&pdev->gadget);
1230 spin_lock(&pdev->lock);
1235 u8 reg = readb(&pdev->usb_regs->lpmctrl);
1239 writeb(0, &pdev->usb_regs->sleep_clkgate);
1243 if (pdev->gadget_driver && pdev->gadget_driver->suspend) {
1244 spin_unlock(&pdev->lock);
1245 pdev->gadget_driver->suspend(&pdev->gadget);
1246 spin_lock(&pdev->lock);
1251 if (pdev->gadget_driver) {
1252 pdev->dev_address = 0;
1254 spin_unlock(&pdev->lock);
1255 usb_gadget_udc_reset(&pdev->gadget,
1256 pdev->gadget_driver);
1257 spin_lock(&pdev->lock);
1267 speed = cdns2_get_speed(pdev);
1272 pdev->gadget.speed = speed;
1273 cdns2_enable_l1(pdev, 0);
1274 cdns2_ep0_config(pdev);
1275 pdev->may_wakeup = 0;
1280 pdev->ep0_stage = CDNS2_SETUP_STAGE;
1281 cdns2_handle_setup_packet(pdev);
1290 struct cdns2_device *pdev = data;
1296 spin_lock_irqsave(&pdev->lock, flags);
1298 cdns2_thread_usb_irq_handler(pdev);
1300 dma_ep_ists = readl(&pdev->adma_regs->ep_ists);
1308 cdns2_handle_ep0_interrupt(pdev, USB_DIR_OUT);
1312 cdns2_handle_ep0_interrupt(pdev, USB_DIR_IN);
1320 * Endpoints in pdev->eps[] are held in order:
1325 cdns2_handle_epx_interrupt(&pdev->eps[ep_idx]);
1329 writel(~0, &pdev->adma_regs->ep_ien);
1330 writeb(USB_IEN_INIT, &pdev->interrupt_regs->usbien);
1331 writeb(EXTIRQ_WAKEUP, &pdev->interrupt_regs->extien);
1333 spin_unlock_irqrestore(&pdev->lock, flags);
1340 static void cdns2_eps_onchip_buffer_init(struct cdns2_device *pdev)
1351 pep = &pdev->eps[i];
1363 pep = &pdev->eps[i];
1369 free = pdev->onchip_tx_buf - min_buf_tx;
1381 &pdev->epx_regs->txstaddr[pep->num - 1]);
1382 pdev->epx_regs->txstaddr[pep->num - 1] = tx_offset;
1384 dev_dbg(pdev->dev, "%s onchip address %04x, buffering: %d\n",
1389 free = pdev->onchip_rx_buf - min_buf_rx;
1400 &pdev->epx_regs->rxstaddr[pep->num - 1]);
1402 dev_dbg(pdev->dev, "%s onchip address %04x, buffering: %d\n",
1414 struct cdns2_device *pdev = pep->pdev;
1435 set_reg_bit_8(&pdev->epx_regs->isoautoarm, BIT(pep->num));
1436 set_reg_bit_8(&pdev->epx_regs->isoautodump, BIT(pep->num));
1437 set_reg_bit_8(&pdev->epx_regs->isodctrl, BIT(pep->num));
1441 switch (pdev->gadget.speed) {
1457 writew(max_packet_size, &pdev->epx_regs->txmaxpack[pep->num - 1]);
1458 writeb(ep_cfg, &pdev->epx_regs->ep[pep->num - 1].txcon);
1460 writew(max_packet_size, &pdev->epx_regs->rxmaxpack[pep->num - 1]);
1461 writeb(ep_cfg, &pdev->epx_regs->ep[pep->num - 1].rxcon);
1465 &pdev->usb_regs->fifoctrl);
1466 writeb(pep->num | dir, &pdev->epx_regs->endprst);
1468 &pdev->epx_regs->endprst);
1477 cdns2_select_ep(pdev, pep->num | pep->dir);
1478 writel(DMA_EP_CMD_EPRST | DMA_EP_CMD_DFLUSH, &pdev->adma_regs->ep_cmd);
1480 ret = readl_poll_timeout_atomic(&pdev->adma_regs->ep_cmd, val,
1488 writel(DMA_EP_STS_TRBERR | DMA_EP_STS_ISOERR, &pdev->adma_regs->ep_sts_en);
1491 writel(DMA_EP_CFG_ENABLE, &pdev->adma_regs->ep_cfg);
1493 trace_cdns2_epx_hw_cfg(pdev, pep);
1495 dev_dbg(pdev->dev, "Configure %s: with MPS: %08x, ep con: %02x\n",
1532 struct cdns2_device *pdev;
1543 pdev = pep->pdev;
1545 if (dev_WARN_ONCE(pdev->dev, pep->ep_state & EP_ENABLED,
1549 spin_lock_irqsave(&pdev->lock, flags);
1554 if (pdev->gadget.speed == USB_SPEED_FULL)
1560 dev_err(pdev->dev, "ISO period is limited to %d (current: %d)\n",
1596 reg = readl(&pdev->adma_regs->ep_sts);
1600 writel(pep->ring.dma, &pdev->adma_regs->ep_traddr);
1606 spin_unlock_irqrestore(&pdev->lock, flags);
1615 struct cdns2_device *pdev;
1623 pdev = pep->pdev;
1625 if (dev_WARN_ONCE(pdev->dev, !(pep->ep_state & EP_ENABLED),
1629 spin_lock_irqsave(&pdev->lock, flags);
1633 cdns2_select_ep(pdev, ep->desc->bEndpointAddress);
1635 clear_reg_bit_32(&pdev->adma_regs->ep_cfg, DMA_EP_CFG_ENABLE);
1642 readl_poll_timeout_atomic(&pdev->adma_regs->ep_sts, val,
1644 writel(DMA_EP_CMD_EPRST, &pdev->adma_regs->ep_cmd);
1646 readl_poll_timeout_atomic(&pdev->adma_regs->ep_cmd, val,
1663 spin_unlock_irqrestore(&pdev->lock, flags);
1672 struct cdns2_device *pdev = pep->pdev;
1680 ret = usb_gadget_map_request_by_dev(pdev->dev, request, pep->dir);
1690 cdns2_start_all_request(pdev, pep);
1701 struct cdns2_device *pdev;
1709 pdev = pep->pdev;
1712 dev_err(pdev->dev, "%s: can't queue to disabled endpoint\n",
1717 spin_lock_irqsave(&pdev->lock, flags);
1727 zlp_request->buf = pdev->zlp_buf;
1734 spin_unlock_irqrestore(&pdev->lock, flags);
1754 dev_err(pep->pdev->dev, "%s: can't dequeue to disabled endpoint\n",
1763 spin_lock_irqsave(&pep->pdev->lock, flags);
1788 writel(DMA_EP_CMD_DFLUSH, &pep->pdev->adma_regs->ep_cmd);
1791 readl_poll_timeout_atomic(&pep->pdev->adma_regs->ep_cmd, val,
1818 spin_unlock_irqrestore(&pep->pdev->lock, flags);
1822 int cdns2_halt_endpoint(struct cdns2_device *pdev,
1834 conf = &pdev->epx_regs->ep[pep->num - 1].txcon;
1836 conf = &pdev->epx_regs->ep[pep->num - 1].rxcon;
1856 writeb(dir | pep->num, &pdev->epx_regs->endprst);
1858 &pdev->epx_regs->endprst);
1871 cdns2_start_all_request(pdev, pep);
1875 writeb(dir | pep->num, &pdev->epx_regs->endprst);
1877 &pdev->epx_regs->endprst);
1888 struct cdns2_device *pdev = pep->pdev;
1893 spin_lock_irqsave(&pdev->lock, flags);
1905 ret = cdns2_halt_endpoint(pdev, pep, value);
1908 spin_unlock_irqrestore(&pdev->lock, flags);
1923 cdns2_endpoint *cdns2_find_available_ep(struct cdns2_device *pdev,
1930 list_for_each_entry(ep, &pdev->gadget.ep_list, ep_list) {
1965 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
1969 pep = cdns2_find_available_ep(pdev, desc);
1971 dev_err(pdev->dev, "no available ep\n");
1975 spin_lock_irqsave(&pdev->lock, flags);
1983 spin_unlock_irqrestore(&pdev->lock, flags);
2001 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2003 return readw(&pdev->usb_regs->frmnr);
2008 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2011 spin_lock_irqsave(&pdev->lock, flags);
2012 cdns2_wakeup(pdev);
2013 spin_unlock_irqrestore(&pdev->lock, flags);
2021 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2024 spin_lock_irqsave(&pdev->lock, flags);
2025 pdev->is_selfpowered = !!is_selfpowered;
2026 spin_unlock_irqrestore(&pdev->lock, flags);
2031 static void cdns2_quiesce(struct cdns2_device *pdev)
2033 set_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_DISCON);
2036 writeb(0, &pdev->interrupt_regs->extien),
2037 writeb(0, &pdev->interrupt_regs->usbien),
2038 writew(0, &pdev->adma_regs->ep_ien);
2041 writeb(0x0, &pdev->interrupt_regs->usbirq);
2044 static void cdns2_gadget_config(struct cdns2_device *pdev)
2046 cdns2_ep0_config(pdev);
2049 writel(~0x0, &pdev->adma_regs->ep_ien);
2050 cdns2_enable_l1(pdev, 0);
2051 writeb(USB_IEN_INIT, &pdev->interrupt_regs->usbien);
2052 writeb(EXTIRQ_WAKEUP, &pdev->interrupt_regs->extien);
2053 writel(DMA_CONF_DMULT, &pdev->adma_regs->conf);
2058 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2067 disable_irq(pdev->irq);
2068 spin_lock_irqsave(&pdev->lock, flags);
2071 cdns2_gadget_config(pdev);
2072 clear_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_DISCON);
2074 cdns2_quiesce(pdev);
2077 spin_unlock_irqrestore(&pdev->lock, flags);
2078 enable_irq(pdev->irq);
2086 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2090 spin_lock_irqsave(&pdev->lock, flags);
2091 pdev->gadget_driver = driver;
2098 writeb(SPEEDCTRL_HSDISABLE, &pdev->usb_regs->speedctrl);
2101 writeb(0, &pdev->usb_regs->speedctrl);
2104 dev_err(pdev->dev, "invalid maximum_speed parameter %d\n",
2114 writeb(ENDPRST_IO_TX, &pdev->usb_regs->endprst);
2116 &pdev->usb_regs->endprst);
2117 writeb(ENDPRST_FIFORST | ENDPRST_TOGRST, &pdev->usb_regs->endprst);
2119 cdns2_eps_onchip_buffer_init(pdev);
2121 cdns2_gadget_config(pdev);
2122 spin_unlock_irqrestore(&pdev->lock, flags);
2129 struct cdns2_device *pdev = gadget_to_cdns2_device(gadget);
2135 pdev->gadget_driver = NULL;
2136 pdev->gadget.speed = USB_SPEED_UNKNOWN;
2138 list_for_each_entry(ep, &pdev->gadget.ep_list, ep_list) {
2141 cdns2_select_ep(pdev, bEndpointAddress);
2142 writel(DMA_EP_CMD_EPRST, &pdev->adma_regs->ep_cmd);
2143 readl_poll_timeout_atomic(&pdev->adma_regs->ep_cmd, val,
2147 cdns2_quiesce(pdev);
2149 writeb(ENDPRST_IO_TX, &pdev->usb_regs->endprst);
2151 &pdev->epx_regs->endprst);
2152 writeb(ENDPRST_FIFORST | ENDPRST_TOGRST, &pdev->epx_regs->endprst);
2167 static void cdns2_free_all_eps(struct cdns2_device *pdev)
2172 cdns2_free_tr_segment(&pdev->eps[i]);
2176 static int cdns2_init_eps(struct cdns2_device *pdev)
2186 * Endpoints are being held in pdev->eps[] in form:
2189 if (!CDNS2_IF_EP_EXIST(pdev, epnum, direction))
2192 pep = &pdev->eps[i];
2193 pep->pdev = pdev;
2199 /* Ep0in and ep0out are represented by pdev->eps[0]. */
2206 cdns2_init_ep0(pdev, pep);
2210 dev_err(pdev->dev, "Failed to init ep0\n");
2220 list_add_tail(&pep->endpoint.ep_list, &pdev->gadget.ep_list);
2233 dev_dbg(pdev->dev, "Init %s, SupType: CTRL: %s, INT: %s, "
2250 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;
2264 set_reg_bit_8(&pdev->usb_regs->cpuctrl, CPUCTRL_SW_RST);
2266 ret = readl_poll_timeout_atomic(&pdev->usb_regs->cpuctrl, val,
2269 dev_err(pdev->dev, "Error: reset controller timeout\n");
2273 usb_initialize_gadget(pdev->dev, &pdev->gadget, NULL);
2275 device_property_read_u16(pdev->dev, "cdns,on-chip-tx-buff-size",
2276 &pdev->onchip_tx_buf);
2277 device_property_read_u16(pdev->dev, "cdns,on-chip-rx-buff-size",
2278 &pdev->onchip_rx_buf);
2279 device_property_read_u32(pdev->dev, "cdns,avail-endpoints",
2280 &pdev->eps_supported);
2286 if (!pdev->onchip_tx_buf && !pdev->onchip_rx_buf) {
2288 dev_err(pdev->dev, "Invalid on-chip memory configuration\n");
2292 if (!(pdev->eps_supported & ~0x00010001)) {
2294 dev_err(pdev->dev, "No hardware endpoints available\n");
2298 max_speed = usb_get_maximum_speed(pdev->dev);
2305 dev_err(pdev->dev, "invalid maximum_speed parameter %d\n",
2313 pdev->gadget.max_speed = max_speed;
2314 pdev->gadget.speed = USB_SPEED_UNKNOWN;
2315 pdev->gadget.ops = &cdns2_gadget_ops;
2316 pdev->gadget.name = "usbhs-gadget";
2317 pdev->gadget.quirk_avoids_skb_reserve = 1;
2318 pdev->gadget.irq = pdev->irq;
2320 spin_lock_init(&pdev->lock);
2321 INIT_WORK(&pdev->pending_status_wq, cdns2_pending_setup_status_handler);
2324 INIT_LIST_HEAD(&pdev->gadget.ep_list);
2325 pdev->eps_dma_pool = dma_pool_create("cdns2_eps_dma_pool", pdev->dev,
2327 if (!pdev->eps_dma_pool) {
2328 dev_err(pdev->dev, "Failed to create TRB dma pool\n");
2333 ret = cdns2_init_eps(pdev);
2335 dev_err(pdev->dev, "Failed to create endpoints\n");
2339 pdev->gadget.sg_supported = 1;
2341 pdev->zlp_buf = kzalloc(CDNS2_EP_ZLP_BUF_SIZE, GFP_KERNEL);
2342 if (!pdev->zlp_buf) {
2348 buf = dma_alloc_coherent(pdev->dev, 8, &pdev->ep0_preq.request.dma,
2350 pdev->ep0_preq.request.buf = buf;
2352 if (!pdev->ep0_preq.request.buf) {
2358 ret = usb_add_gadget(&pdev->gadget);
2360 dev_err(pdev->dev, "Failed to add gadget\n");
2367 dma_free_coherent(pdev->dev, 8, pdev->ep0_preq.request.buf,
2368 pdev->ep0_preq.request.dma);
2370 kfree(pdev->zlp_buf);
2372 dma_pool_destroy(pdev->eps_dma_pool);
2374 usb_put_gadget(&pdev->gadget);
2379 int cdns2_gadget_suspend(struct cdns2_device *pdev)
2383 cdns2_disconnect_gadget(pdev);
2385 spin_lock_irqsave(&pdev->lock, flags);
2386 pdev->gadget.speed = USB_SPEED_UNKNOWN;
2389 usb_gadget_set_state(&pdev->gadget, USB_STATE_NOTATTACHED);
2390 cdns2_enable_l1(pdev, 0);
2393 writeb(0, &pdev->interrupt_regs->usbien);
2394 writel(0, &pdev->adma_regs->ep_ien);
2395 spin_unlock_irqrestore(&pdev->lock, flags);
2400 int cdns2_gadget_resume(struct cdns2_device *pdev, bool hibernated)
2404 spin_lock_irqsave(&pdev->lock, flags);
2406 if (!pdev->gadget_driver) {
2407 spin_unlock_irqrestore(&pdev->lock, flags);
2411 cdns2_gadget_config(pdev);
2414 clear_reg_bit_8(&pdev->usb_regs->usbcs, USBCS_DISCON);
2416 spin_unlock_irqrestore(&pdev->lock, flags);
2421 void cdns2_gadget_remove(struct cdns2_device *pdev)
2423 pm_runtime_mark_last_busy(pdev->dev);
2424 pm_runtime_put_autosuspend(pdev->dev);
2426 usb_del_gadget(&pdev->gadget);
2427 cdns2_free_all_eps(pdev);
2429 dma_pool_destroy(pdev->eps_dma_pool);
2430 kfree(pdev->zlp_buf);
2431 usb_put_gadget(&pdev->gadget);
2434 int cdns2_gadget_init(struct cdns2_device *pdev)
2439 ret = dma_set_mask_and_coherent(pdev->dev, DMA_BIT_MASK(32));
2441 dev_err(pdev->dev, "Failed to set dma mask: %d\n", ret);
2445 pm_runtime_get_sync(pdev->dev);
2447 cdsn2_isoc_burst_opt(pdev);
2449 ret = cdns2_gadget_start(pdev);
2451 pm_runtime_put_sync(pdev->dev);
2459 ret = devm_request_threaded_irq(pdev->dev, pdev->irq,
2463 dev_name(pdev->dev),
2464 pdev);
2471 cdns2_gadget_remove(pdev);