Lines Matching refs:pdev
102 void cdnsp_set_link_state(struct cdnsp_device *pdev,
117 if (pdev->active_port)
118 port_num = pdev->active_port->port_num;
125 static void cdnsp_disable_port(struct cdnsp_device *pdev,
133 static void cdnsp_clear_port_change_bit(struct cdnsp_device *pdev,
142 static void cdnsp_set_chicken_bits_2(struct cdnsp_device *pdev, u32 bit)
148 base = &pdev->cap_regs->hc_capbase;
156 static void cdnsp_clear_chicken_bits_2(struct cdnsp_device *pdev, u32 bit)
162 base = &pdev->cap_regs->hc_capbase;
173 static void cdnsp_quiesce(struct cdnsp_device *pdev)
181 halted = readl(&pdev->op_regs->status) & STS_HALT;
185 cmd = readl(&pdev->op_regs->command);
187 writel(cmd, &pdev->op_regs->command);
199 int cdnsp_halt(struct cdnsp_device *pdev)
204 cdnsp_quiesce(pdev);
206 ret = readl_poll_timeout_atomic(&pdev->op_regs->status, val,
210 dev_err(pdev->dev, "ERROR: Device halt failed\n");
214 pdev->cdnsp_state |= CDNSP_STATE_HALTED;
223 void cdnsp_died(struct cdnsp_device *pdev)
225 dev_err(pdev->dev, "ERROR: CDNSP controller not responding\n");
226 pdev->cdnsp_state |= CDNSP_STATE_DYING;
227 cdnsp_halt(pdev);
233 static int cdnsp_start(struct cdnsp_device *pdev)
238 temp = readl(&pdev->op_regs->command);
240 writel(temp, &pdev->op_regs->command);
242 pdev->cdnsp_state = 0;
248 ret = readl_poll_timeout_atomic(&pdev->op_regs->status, temp,
252 pdev->cdnsp_state = CDNSP_STATE_DYING;
253 dev_err(pdev->dev, "ERROR: Controller run failed\n");
266 int cdnsp_reset(struct cdnsp_device *pdev)
272 temp = readl(&pdev->op_regs->status);
275 dev_err(pdev->dev, "Device not accessible, reset failed.\n");
280 dev_err(pdev->dev, "Controller not halted, aborting reset.\n");
284 command = readl(&pdev->op_regs->command);
286 writel(command, &pdev->op_regs->command);
288 ret = readl_poll_timeout_atomic(&pdev->op_regs->command, temp,
292 dev_err(pdev->dev, "ERROR: Controller reset failed\n");
300 ret = readl_poll_timeout_atomic(&pdev->op_regs->status, temp,
305 dev_err(pdev->dev, "ERROR: Controller not ready to work\n");
309 dev_dbg(pdev->dev, "Controller ready to work");
347 struct cdnsp_device *pdev = pep->pdev;
363 ret = usb_gadget_map_request_by_dev(pdev->dev, request, pep->direction);
375 ret = cdnsp_queue_ctrl_tx(pdev, preq);
379 ret = cdnsp_queue_bulk_tx(pdev, preq);
382 ret = cdnsp_queue_isoc_tx(pdev, preq);
391 usb_gadget_unmap_request_by_dev(pdev->dev, &preq->request,
426 struct cdnsp_device *pdev = pep->pdev;
433 ret_stop = cdnsp_cmd_stop_ep(pdev, pep);
435 ret_rem = cdnsp_remove_request(pdev, preq, pep);
440 static void cdnsp_zero_in_ctx(struct cdnsp_device *pdev)
447 ctrl_ctx = cdnsp_get_input_control_ctx(&pdev->in_ctx);
457 slot_ctx = cdnsp_get_slot_ctx(&pdev->in_ctx);
463 ep_ctx = cdnsp_get_ep_ctx(&pdev->in_ctx, i);
472 static int cdnsp_configure_endpoint(struct cdnsp_device *pdev)
476 cdnsp_queue_configure_endpoint(pdev, pdev->cmd.in_ctx->dma);
477 cdnsp_ring_cmd_db(pdev);
478 ret = cdnsp_wait_for_cmd_compl(pdev);
480 dev_err(pdev->dev,
488 static void cdnsp_invalidate_ep_events(struct cdnsp_device *pdev,
496 event = pdev->event_ring->dequeue;
497 segment = pdev->event_ring->deq_seg;
498 cycle_state = pdev->event_ring->cycle_state;
515 segment = pdev->event_ring->deq_seg->next;
523 int cdnsp_wait_for_cmd_compl(struct cdnsp_device *pdev)
534 cmd_trb = pdev->cmd.command_trb;
535 pdev->cmd.status = 0;
537 trace_cdnsp_cmd_wait_for_compl(pdev->cmd_ring, &cmd_trb->generic);
539 ret = readl_poll_timeout_atomic(&pdev->op_regs->cmd_ring, val,
543 dev_err(pdev->dev, "ERR: Timeout while waiting for command\n");
544 trace_cdnsp_cmd_timeout(pdev->cmd_ring, &cmd_trb->generic);
545 pdev->cdnsp_state = CDNSP_STATE_DYING;
549 event = pdev->event_ring->dequeue;
550 event_deq_seg = pdev->event_ring->deq_seg;
551 cycle_state = pdev->event_ring->cycle_state;
553 cmd_deq_dma = cdnsp_trb_virt_to_dma(pdev->cmd_ring->deq_seg, cmd_trb);
577 if (cdnsp_last_trb_on_ring(pdev->event_ring,
586 trace_cdnsp_handle_command(pdev->cmd_ring, &cmd_trb->generic);
588 pdev->cmd.status = GET_COMP_CODE(le32_to_cpu(event->event_cmd.status));
589 if (pdev->cmd.status == COMP_SUCCESS)
592 return -pdev->cmd.status;
596 int cdnsp_halt_endpoint(struct cdnsp_device *pdev,
604 ret = cdnsp_cmd_stop_ep(pdev, pep);
610 cdnsp_queue_halt_endpoint(pdev, pep->idx);
611 cdnsp_ring_cmd_db(pdev);
612 ret = cdnsp_wait_for_cmd_compl(pdev);
617 cdnsp_queue_reset_ep(pdev, pep->idx);
618 cdnsp_ring_cmd_db(pdev);
619 ret = cdnsp_wait_for_cmd_compl(pdev);
628 cdnsp_ring_doorbell_for_active_rings(pdev, pep);
636 static int cdnsp_update_eps_configuration(struct cdnsp_device *pdev,
645 ctrl_ctx = cdnsp_get_input_control_ctx(&pdev->in_ctx);
656 slot_ctx = cdnsp_get_slot_ctx(&pdev->in_ctx);
660 if ((pdev->eps[i - 1].ring && !(ctrl_ctx->drop_flags & le32)) ||
673 ret = cdnsp_configure_endpoint(pdev);
675 trace_cdnsp_configure_endpoint(cdnsp_get_slot_ctx(&pdev->out_ctx));
678 cdnsp_zero_in_ctx(pdev);
689 int cdnsp_reset_device(struct cdnsp_device *pdev)
695 slot_ctx = cdnsp_get_slot_ctx(&pdev->in_ctx);
697 pdev->device_address = 0;
700 slot_ctx = cdnsp_get_slot_ctx(&pdev->out_ctx);
705 pdev->eps[0].ep_state & EP_HALTED) {
706 cdnsp_halt_endpoint(pdev, &pdev->eps[0], 0);
713 pdev->eps[0].ep_state &= ~(EP_STOPPED | EP_HALTED);
714 pdev->eps[0].ep_state |= EP_ENABLED;
719 cdnsp_queue_reset_device(pdev);
720 cdnsp_ring_cmd_db(pdev);
721 ret = cdnsp_wait_for_cmd_compl(pdev);
728 pdev->eps[i].ep_state |= EP_STOPPED | EP_UNCONFIGURED;
733 dev_err(pdev->dev, "Reset device failed with error code %d",
743 static void cdnsp_setup_streams_ep_input_ctx(struct cdnsp_device *pdev,
766 int cdnsp_alloc_streams(struct cdnsp_device *pdev, struct cdnsp_ep *pep)
790 ret = cdnsp_alloc_stream_info(pdev, pep, num_stream_ctxs, num_streams);
794 cdnsp_setup_streams_ep_input_ctx(pdev, pep->in_ctx, &pep->stream_info);
804 int cdnsp_disable_slot(struct cdnsp_device *pdev)
808 cdnsp_queue_slot_control(pdev, TRB_DISABLE_SLOT);
809 cdnsp_ring_cmd_db(pdev);
810 ret = cdnsp_wait_for_cmd_compl(pdev);
812 pdev->slot_id = 0;
813 pdev->active_port = NULL;
815 trace_cdnsp_handle_cmd_disable_slot(cdnsp_get_slot_ctx(&pdev->out_ctx));
817 memset(pdev->in_ctx.bytes, 0, CDNSP_CTX_SIZE);
818 memset(pdev->out_ctx.bytes, 0, CDNSP_CTX_SIZE);
823 int cdnsp_enable_slot(struct cdnsp_device *pdev)
830 slot_ctx = cdnsp_get_slot_ctx(&pdev->out_ctx);
836 cdnsp_queue_slot_control(pdev, TRB_ENABLE_SLOT);
837 cdnsp_ring_cmd_db(pdev);
838 ret = cdnsp_wait_for_cmd_compl(pdev);
842 pdev->slot_id = 1;
845 trace_cdnsp_handle_cmd_enable_slot(cdnsp_get_slot_ctx(&pdev->out_ctx));
854 int cdnsp_setup_device(struct cdnsp_device *pdev, enum cdnsp_setup_dev setup)
861 if (!pdev->slot_id) {
866 if (!pdev->active_port->port_num)
869 slot_ctx = cdnsp_get_slot_ctx(&pdev->out_ctx);
877 slot_ctx = cdnsp_get_slot_ctx(&pdev->in_ctx);
878 ctrl_ctx = cdnsp_get_input_control_ctx(&pdev->in_ctx);
881 ret = cdnsp_setup_addressable_priv_dev(pdev);
886 cdnsp_copy_ep0_dequeue_into_input_ctx(pdev);
893 cdnsp_queue_address_device(pdev, pdev->in_ctx.dma, setup);
894 cdnsp_ring_cmd_db(pdev);
895 ret = cdnsp_wait_for_cmd_compl(pdev);
897 trace_cdnsp_handle_cmd_addr_dev(cdnsp_get_slot_ctx(&pdev->out_ctx));
906 void cdnsp_set_usb2_hardware_lpm(struct cdnsp_device *pdev,
910 if (pdev->active_port != &pdev->usb2_port || !pdev->gadget.lpm_capable)
917 &pdev->active_port->regs->portpmsc);
919 writel(PORT_L1S_NYET, &pdev->active_port->regs->portpmsc);
922 static int cdnsp_get_frame(struct cdnsp_device *pdev)
924 return readl(&pdev->run_regs->microframe_index) >> 3;
931 struct cdnsp_device *pdev;
942 pdev = pep->pdev;
945 if (dev_WARN_ONCE(pdev->dev, pep->ep_state & EP_ENABLED,
949 spin_lock_irqsave(&pdev->lock, flags);
953 dev_err(pdev->dev, "ERROR: Bad endpoint number\n");
960 if (pdev->gadget.speed == USB_SPEED_FULL) {
969 dev_err(pdev->dev, "bInterval %d not supported\n",
974 cdnsp_set_chicken_bits_2(pdev, CHICKEN_XDMA_2_TP_CACHE_DIS);
977 ret = cdnsp_endpoint_init(pdev, pep, GFP_ATOMIC);
981 ctrl_ctx = cdnsp_get_input_control_ctx(&pdev->in_ctx);
985 ret = cdnsp_update_eps_configuration(pdev, pep);
987 cdnsp_free_endpoint_rings(pdev, pep);
996 spin_unlock_irqrestore(&pdev->lock, flags);
1005 struct cdnsp_device *pdev;
1015 pdev = pep->pdev;
1017 spin_lock_irqsave(&pdev->lock, flags);
1020 dev_err(pdev->dev, "%s is already disabled\n", pep->name);
1029 cdnsp_cmd_stop_ep(pdev, pep);
1037 cdnsp_invalidate_ep_events(pdev, pep);
1041 ctrl_ctx = cdnsp_get_input_control_ctx(&pdev->in_ctx);
1045 cdnsp_endpoint_zero(pdev, pep);
1048 ret = cdnsp_update_eps_configuration(pdev, pep);
1050 cdnsp_free_endpoint_rings(pdev, pep);
1057 spin_unlock_irqrestore(&pdev->lock, flags);
1094 struct cdnsp_device *pdev;
1103 pdev = pep->pdev;
1106 dev_err(pdev->dev, "%s: can't queue to disabled endpoint\n",
1112 spin_lock_irqsave(&pdev->lock, flags);
1114 spin_unlock_irqrestore(&pdev->lock, flags);
1123 struct cdnsp_device *pdev = pep->pdev;
1131 dev_err(pdev->dev,
1141 spin_lock_irqsave(&pdev->lock, flags);
1143 spin_unlock_irqrestore(&pdev->lock, flags);
1151 struct cdnsp_device *pdev = pep->pdev;
1156 spin_lock_irqsave(&pdev->lock, flags);
1167 ret = cdnsp_halt_endpoint(pdev, pep, value);
1170 spin_unlock_irqrestore(&pdev->lock, flags);
1177 struct cdnsp_device *pdev = pep->pdev;
1181 spin_lock_irqsave(&pdev->lock, flags);
1183 ret = cdnsp_halt_endpoint(pdev, pep, 1);
1184 spin_unlock_irqrestore(&pdev->lock, flags);
1215 struct cdnsp_device *pdev = pep->pdev;
1222 usb_gadget_unmap_request_by_dev(pdev->dev, &preq->request,
1227 if (preq != &pdev->ep0_preq) {
1228 spin_unlock(&pdev->lock);
1230 spin_lock(&pdev->lock);
1240 static int cdnsp_run(struct cdnsp_device *pdev,
1247 temp = readl(&pdev->ir_set->irq_control);
1250 writel(temp, &pdev->ir_set->irq_control);
1252 temp = readl(&pdev->port3x_regs->mode_addr);
1267 dev_err(pdev->dev, "invalid maximum_speed parameter %d\n",
1277 writel(temp, &pdev->port3x_regs->mode_addr);
1278 cdnsp_set_link_state(pdev, &pdev->usb3_port.regs->portsc,
1281 cdnsp_disable_port(pdev, &pdev->usb3_port.regs->portsc);
1284 cdnsp_set_link_state(pdev, &pdev->usb2_port.regs->portsc,
1289 writel(PORT_REG6_L1_L0_HW_EN | fs_speed, &pdev->port20_regs->port_reg6);
1291 ret = cdnsp_start(pdev);
1297 temp = readl(&pdev->op_regs->command);
1299 writel(temp, &pdev->op_regs->command);
1301 temp = readl(&pdev->ir_set->irq_pending);
1302 writel(IMAN_IE_SET(temp), &pdev->ir_set->irq_pending);
1307 cdnsp_halt(pdev);
1315 struct cdnsp_device *pdev = gadget_to_cdnsp(g);
1319 spin_lock_irqsave(&pdev->lock, flags);
1320 pdev->gadget_driver = driver;
1324 ret = cdnsp_run(pdev, max_speed);
1326 spin_unlock_irqrestore(&pdev->lock, flags);
1336 void cdnsp_update_erst_dequeue(struct cdnsp_device *pdev,
1343 temp_64 = cdnsp_read_64(&pdev->ir_set->erst_dequeue);
1346 if (event_ring_deq != pdev->event_ring->dequeue) {
1347 deq = cdnsp_trb_virt_to_dma(pdev->event_ring->deq_seg,
1348 pdev->event_ring->dequeue);
1359 cdnsp_write_64(temp_64, &pdev->ir_set->erst_dequeue);
1362 static void cdnsp_clear_cmd_ring(struct cdnsp_device *pdev)
1368 cdnsp_initialize_ring_info(pdev->cmd_ring);
1370 seg = pdev->cmd_ring->first_seg;
1371 for (i = 0; i < pdev->cmd_ring->num_segs; i++) {
1378 val_64 = cdnsp_read_64(&pdev->op_regs->cmd_ring);
1380 (pdev->cmd_ring->first_seg->dma & (u64)~CMD_RING_RSVD_BITS) |
1381 pdev->cmd_ring->cycle_state;
1382 cdnsp_write_64(val_64, &pdev->op_regs->cmd_ring);
1385 static void cdnsp_consume_all_events(struct cdnsp_device *pdev)
1392 event_ring_deq = pdev->event_ring->dequeue;
1393 event_deq_seg = pdev->event_ring->deq_seg;
1394 event = pdev->event_ring->dequeue;
1401 if (cycle_bit != pdev->event_ring->cycle_state)
1404 cdnsp_inc_deq(pdev, pdev->event_ring);
1411 if (cdnsp_last_trb_on_ring(pdev->event_ring, event_deq_seg,
1419 cdnsp_update_erst_dequeue(pdev, event_ring_deq, 1);
1422 static void cdnsp_stop(struct cdnsp_device *pdev)
1427 if (!list_empty(&pdev->eps[0].pending_list)) {
1430 req = next_request(&pdev->eps[0].pending_list);
1431 if (req == &pdev->ep0_preq)
1432 cdnsp_ep_dequeue(&pdev->eps[0], req);
1435 cdnsp_disable_port(pdev, &pdev->usb2_port.regs->portsc);
1436 cdnsp_disable_port(pdev, &pdev->usb3_port.regs->portsc);
1437 cdnsp_disable_slot(pdev);
1438 cdnsp_halt(pdev);
1440 temp = readl(&pdev->op_regs->status);
1441 writel((temp & ~0x1fff) | STS_EINT, &pdev->op_regs->status);
1442 temp = readl(&pdev->ir_set->irq_pending);
1443 writel(IMAN_IE_CLEAR(temp), &pdev->ir_set->irq_pending);
1445 cdnsp_clear_port_change_bit(pdev, &pdev->usb2_port.regs->portsc);
1446 cdnsp_clear_port_change_bit(pdev, &pdev->usb3_port.regs->portsc);
1449 temp = readl(&pdev->ir_set->irq_pending);
1451 writel(temp, &pdev->ir_set->irq_pending);
1453 cdnsp_consume_all_events(pdev);
1454 cdnsp_clear_cmd_ring(pdev);
1466 struct cdnsp_device *pdev = gadget_to_cdnsp(g);
1469 spin_lock_irqsave(&pdev->lock, flags);
1470 cdnsp_stop(pdev);
1471 pdev->gadget_driver = NULL;
1472 spin_unlock_irqrestore(&pdev->lock, flags);
1479 struct cdnsp_device *pdev = gadget_to_cdnsp(g);
1481 return cdnsp_get_frame(pdev);
1484 static void __cdnsp_gadget_wakeup(struct cdnsp_device *pdev)
1489 port_regs = pdev->active_port->regs;
1493 if (pdev->gadget.speed < USB_SPEED_SUPER && portsc == XDEV_U2) {
1500 if (portsc == XDEV_U3 && !pdev->may_wakeup)
1503 cdnsp_set_link_state(pdev, &port_regs->portsc, XDEV_U0);
1505 pdev->cdnsp_state |= CDNSP_WAKEUP_PENDING;
1510 struct cdnsp_device *pdev = gadget_to_cdnsp(g);
1513 spin_lock_irqsave(&pdev->lock, flags);
1514 __cdnsp_gadget_wakeup(pdev);
1515 spin_unlock_irqrestore(&pdev->lock, flags);
1523 struct cdnsp_device *pdev = gadget_to_cdnsp(g);
1526 spin_lock_irqsave(&pdev->lock, flags);
1528 spin_unlock_irqrestore(&pdev->lock, flags);
1535 struct cdnsp_device *pdev = gadget_to_cdnsp(gadget);
1536 struct cdns *cdns = dev_get_drvdata(pdev->dev);
1546 spin_lock_irqsave(&pdev->lock, flags);
1549 cdnsp_reset_device(pdev);
1555 spin_unlock_irqrestore(&pdev->lock, flags);
1570 static void cdnsp_get_ep_buffering(struct cdnsp_device *pdev,
1573 void __iomem *reg = &pdev->cap_regs->hc_capbase;
1586 endpoints = HCS_ENDPOINTS(pdev->hcs_params1) / 2;
1597 static int cdnsp_gadget_init_endpoints(struct cdnsp_device *pdev)
1599 int max_streams = HCC_MAX_PSA(pdev->hcc_params);
1603 INIT_LIST_HEAD(&pdev->gadget.ep_list);
1606 dev_err(pdev->dev, "Stream size %d not supported\n",
1617 if (!CDNSP_IF_EP_EXIST(pdev, epnum, direction))
1620 pep = &pdev->eps[i];
1621 pep->pdev = pdev;
1627 * pdev->eps[0]
1643 pdev->ep0_preq.epnum = pep->number;
1644 pdev->ep0_preq.pep = pep;
1645 pdev->gadget.ep0 = &pep->endpoint;
1656 &pdev->gadget.ep_list);
1667 pep->in_ctx = cdnsp_get_ep_ctx(&pdev->in_ctx, pep->idx);
1668 pep->out_ctx = cdnsp_get_ep_ctx(&pdev->out_ctx, pep->idx);
1669 cdnsp_get_ep_buffering(pdev, pep);
1671 dev_dbg(pdev->dev, "Init %s, MPS: %04x SupType: "
1688 static void cdnsp_gadget_free_endpoints(struct cdnsp_device *pdev)
1694 pep = &pdev->eps[i];
1700 void cdnsp_disconnect_gadget(struct cdnsp_device *pdev)
1702 pdev->cdnsp_state |= CDNSP_STATE_DISCONNECT_PENDING;
1704 if (pdev->gadget_driver && pdev->gadget_driver->disconnect) {
1705 spin_unlock(&pdev->lock);
1706 pdev->gadget_driver->disconnect(&pdev->gadget);
1707 spin_lock(&pdev->lock);
1710 pdev->gadget.speed = USB_SPEED_UNKNOWN;
1711 usb_gadget_set_state(&pdev->gadget, USB_STATE_NOTATTACHED);
1713 pdev->cdnsp_state &= ~CDNSP_STATE_DISCONNECT_PENDING;
1716 void cdnsp_suspend_gadget(struct cdnsp_device *pdev)
1718 if (pdev->gadget_driver && pdev->gadget_driver->suspend) {
1719 spin_unlock(&pdev->lock);
1720 pdev->gadget_driver->suspend(&pdev->gadget);
1721 spin_lock(&pdev->lock);
1725 void cdnsp_resume_gadget(struct cdnsp_device *pdev)
1727 if (pdev->gadget_driver && pdev->gadget_driver->resume) {
1728 spin_unlock(&pdev->lock);
1729 pdev->gadget_driver->resume(&pdev->gadget);
1730 spin_lock(&pdev->lock);
1734 void cdnsp_irq_reset(struct cdnsp_device *pdev)
1738 cdnsp_reset_device(pdev);
1740 port_regs = pdev->active_port->regs;
1741 pdev->gadget.speed = cdnsp_port_speed(readl(port_regs));
1743 spin_unlock(&pdev->lock);
1744 usb_gadget_udc_reset(&pdev->gadget, pdev->gadget_driver);
1745 spin_lock(&pdev->lock);
1747 switch (pdev->gadget.speed) {
1751 pdev->gadget.ep0->maxpacket = 512;
1756 pdev->gadget.ep0->maxpacket = 64;
1760 dev_err(pdev->dev, "Unknown device speed\n");
1764 cdnsp_clear_chicken_bits_2(pdev, CHICKEN_XDMA_2_TP_CACHE_DIS);
1765 cdnsp_setup_device(pdev, SETUP_CONTEXT_ONLY);
1766 usb_gadget_set_state(&pdev->gadget, USB_STATE_DEFAULT);
1769 static void cdnsp_get_rev_cap(struct cdnsp_device *pdev)
1771 void __iomem *reg = &pdev->cap_regs->hc_capbase;
1774 pdev->rev_cap = reg;
1776 dev_info(pdev->dev, "Rev: %08x/%08x, eps: %08x, buff: %08x/%08x\n",
1777 readl(&pdev->rev_cap->ctrl_revision),
1778 readl(&pdev->rev_cap->rtl_revision),
1779 readl(&pdev->rev_cap->ep_supported),
1780 readl(&pdev->rev_cap->rx_buff_size),
1781 readl(&pdev->rev_cap->tx_buff_size));
1784 static int cdnsp_gen_setup(struct cdnsp_device *pdev)
1789 pdev->cap_regs = pdev->regs;
1790 pdev->op_regs = pdev->regs +
1791 HC_LENGTH(readl(&pdev->cap_regs->hc_capbase));
1792 pdev->run_regs = pdev->regs +
1793 (readl(&pdev->cap_regs->run_regs_off) & RTSOFF_MASK);
1796 pdev->hcs_params1 = readl(&pdev->cap_regs->hcs_params1);
1797 pdev->hcc_params = readl(&pdev->cap_regs->hc_capbase);
1798 pdev->hci_version = HC_VERSION(pdev->hcc_params);
1799 pdev->hcc_params = readl(&pdev->cap_regs->hcc_params);
1801 cdnsp_get_rev_cap(pdev);
1804 ret = cdnsp_halt(pdev);
1809 ret = cdnsp_reset(pdev);
1817 if (HCC_64BIT_ADDR(pdev->hcc_params) &&
1818 !dma_set_mask(pdev->dev, DMA_BIT_MASK(64))) {
1819 dev_dbg(pdev->dev, "Enabling 64-bit DMA addresses.\n");
1820 dma_set_coherent_mask(pdev->dev, DMA_BIT_MASK(64));
1826 ret = dma_set_mask(pdev->dev, DMA_BIT_MASK(32));
1830 dev_dbg(pdev->dev, "Enabling 32-bit DMA addresses.\n");
1831 dma_set_coherent_mask(pdev->dev, DMA_BIT_MASK(32));
1834 spin_lock_init(&pdev->lock);
1836 ret = cdnsp_mem_init(pdev);
1845 reg = readl(&pdev->port3x_regs->mode_2);
1847 writel(reg, &pdev->port3x_regs->mode_2);
1854 struct cdnsp_device *pdev;
1860 pdev = kzalloc(sizeof(*pdev), GFP_KERNEL);
1861 if (!pdev)
1866 cdns->gadget_dev = pdev;
1867 pdev->dev = cdns->dev;
1868 pdev->regs = cdns->dev_regs;
1886 pdev->gadget.ops = &cdnsp_gadget_ops;
1887 pdev->gadget.name = "cdnsp-gadget";
1888 pdev->gadget.speed = USB_SPEED_UNKNOWN;
1889 pdev->gadget.sg_supported = 1;
1890 pdev->gadget.max_speed = max_speed;
1891 pdev->gadget.lpm_capable = 1;
1893 pdev->setup_buf = kzalloc(CDNSP_EP0_SETUP_SIZE, GFP_KERNEL);
1894 if (!pdev->setup_buf)
1901 pdev->gadget.quirk_ep_out_aligned_size = true;
1903 ret = cdnsp_gen_setup(pdev);
1905 dev_err(pdev->dev, "Generic initialization failed %d\n", ret);
1909 ret = cdnsp_gadget_init_endpoints(pdev);
1911 dev_err(pdev->dev, "failed to initialize endpoints\n");
1915 ret = usb_add_gadget_udc(pdev->dev, &pdev->gadget);
1917 dev_err(pdev->dev, "failed to register udc\n");
1921 ret = devm_request_threaded_irq(pdev->dev, cdns->dev_irq,
1924 dev_name(pdev->dev), pdev);
1931 usb_del_gadget_udc(&pdev->gadget);
1933 cdnsp_gadget_free_endpoints(pdev);
1935 cdnsp_halt(pdev);
1936 cdnsp_reset(pdev);
1937 cdnsp_mem_cleanup(pdev);
1939 kfree(pdev->setup_buf);
1941 kfree(pdev);
1948 struct cdnsp_device *pdev = cdns->gadget_dev;
1950 devm_free_irq(pdev->dev, cdns->dev_irq, pdev);
1953 usb_del_gadget_udc(&pdev->gadget);
1954 cdnsp_gadget_free_endpoints(pdev);
1955 cdnsp_mem_cleanup(pdev);
1956 kfree(pdev);
1963 struct cdnsp_device *pdev = cdns->gadget_dev;
1966 if (pdev->link_state == XDEV_U3)
1969 spin_lock_irqsave(&pdev->lock, flags);
1970 cdnsp_disconnect_gadget(pdev);
1971 cdnsp_stop(pdev);
1972 spin_unlock_irqrestore(&pdev->lock, flags);
1979 struct cdnsp_device *pdev = cdns->gadget_dev;
1984 if (!pdev->gadget_driver)
1987 spin_lock_irqsave(&pdev->lock, flags);
1988 max_speed = pdev->gadget_driver->max_speed;
1991 max_speed = min(max_speed, pdev->gadget.max_speed);
1993 ret = cdnsp_run(pdev, max_speed);
1995 if (pdev->link_state == XDEV_U3)
1996 __cdnsp_gadget_wakeup(pdev);
1998 spin_unlock_irqrestore(&pdev->lock, flags);