Lines Matching defs:pdev
26 * pdev: USB handle
30 static enum usb_status usb_core_set_stall(struct usb_handle *pdev, uint8_t ep_addr)
33 struct pcd_handle *hpcd = (struct pcd_handle *)pdev->data;
49 pdev->driver->ep_set_stall(hpcd->instance, ep);
51 pdev->driver->ep0_out_start(hpcd->instance);
60 * pdev : device instance
63 static void usb_core_get_desc(struct usb_handle *pdev, struct usb_setup_req *req)
72 pbuf = pdev->desc->get_device_desc(&len);
76 pbuf = pdev->desc->get_config_desc(&len);
82 pbuf = pdev->desc->get_lang_id_desc(&len);
86 pbuf = pdev->desc->get_manufacturer_desc(&len);
90 pbuf = pdev->desc->get_product_desc(&len);
94 pbuf = pdev->desc->get_serial_desc(&len);
98 pbuf = pdev->desc->get_configuration_desc(&len);
102 pbuf = pdev->desc->get_interface_desc(&len);
108 pbuf = pdev->desc->get_usr_desc(desc_idx - USBD_IDX_USER0_STR, &len);
114 pbuf = pdev->desc->get_device_qualifier_desc(&len);
118 if (pdev->desc->get_other_speed_config_desc == NULL) {
119 usb_core_ctl_error(pdev);
122 pbuf = pdev->desc->get_other_speed_config_desc(&len);
127 usb_core_ctl_error(pdev);
135 usb_core_transmit_ep0(pdev, pbuf, len);
142 * pdev : device instance
145 static void usb_core_set_config(struct usb_handle *pdev, struct usb_setup_req *req)
152 usb_core_ctl_error(pdev);
156 switch (pdev->dev_state) {
159 pdev->dev_config = cfgidx;
160 pdev->dev_state = USBD_STATE_CONFIGURED;
161 if (!pdev->class) {
162 usb_core_ctl_error(pdev);
166 if (pdev->class->init(pdev, cfgidx) != 0U) {
167 usb_core_ctl_error(pdev);
175 pdev->dev_state = USBD_STATE_ADDRESSED;
176 pdev->dev_config = cfgidx;
177 pdev->class->de_init(pdev, cfgidx);
178 } else if (cfgidx != pdev->dev_config) {
179 if (pdev->class == NULL) {
180 usb_core_ctl_error(pdev);
184 pdev->class->de_init(pdev, pdev->dev_config);
186 pdev->dev_config = cfgidx;
188 if (pdev->class->init(pdev, cfgidx) != 0U) {
189 usb_core_ctl_error(pdev);
196 usb_core_ctl_error(pdev);
201 usb_core_transmit_ep0(pdev, NULL, 0U);
207 * pdev : device instance
210 static void usb_core_get_status(struct usb_handle *pdev,
213 if ((pdev->dev_state != USBD_STATE_ADDRESSED) &&
214 (pdev->dev_state != USBD_STATE_CONFIGURED)) {
215 usb_core_ctl_error(pdev);
219 pdev->dev_config_status = USB_CONFIG_SELF_POWERED;
221 if (pdev->dev_remote_wakeup != 0U) {
222 pdev->dev_config_status |= USB_CONFIG_REMOTE_WAKEUP;
226 usb_core_transmit_ep0(pdev, (uint8_t *)&pdev->dev_config_status, 2U);
232 * pdev : device instance
235 static void usb_core_set_address(struct usb_handle *pdev,
241 usb_core_ctl_error(pdev);
246 if (pdev->dev_state != USBD_STATE_DEFAULT) {
247 usb_core_ctl_error(pdev);
251 pdev->dev_address = dev_addr;
252 pdev->driver->set_address(((struct pcd_handle *)(pdev->data))->instance, dev_addr);
255 usb_core_transmit_ep0(pdev, NULL, 0U);
258 pdev->dev_state = USBD_STATE_ADDRESSED;
260 pdev->dev_state = USBD_STATE_DEFAULT;
267 * pdev : device instance
271 static enum usb_status usb_core_dev_req(struct usb_handle *pdev,
277 usb_core_get_desc(pdev, req);
281 usb_core_set_config(pdev, req);
285 usb_core_get_status(pdev, req);
289 usb_core_set_address(pdev, req);
297 usb_core_ctl_error(pdev);
307 * pdev : device instance
311 static enum usb_status usb_core_itf_req(struct usb_handle *pdev,
314 if (pdev->dev_state != USBD_STATE_CONFIGURED) {
315 usb_core_ctl_error(pdev);
320 pdev->class->setup(pdev, req);
323 usb_core_transmit_ep0(pdev, NULL, 0U);
326 usb_core_ctl_error(pdev);
335 * pdev: device instance
339 static enum usb_status usb_core_setup_stage(struct usb_handle *pdev,
342 struct usb_setup_req *req = &pdev->request;
351 pdev->ep0_state = USBD_EP0_SETUP;
352 pdev->ep0_data_len = pdev->request.length;
354 switch (pdev->request.bm_request & USB_REQ_RECIPIENT_MASK) {
356 usb_core_dev_req(pdev, &pdev->request);
360 usb_core_itf_req(pdev, &pdev->request);
366 pdev->request.bm_request & USB_REQ_RECIPIENT_MASK);
367 usb_core_set_stall(pdev, pdev->request.bm_request & USB_REQ_DIRECTION);
377 * pdev: device instance
382 static enum usb_status usb_core_data_out(struct usb_handle *pdev, uint8_t epnum,
388 pep = &pdev->ep_out[0];
389 if (pdev->ep0_state == USBD_EP0_DATA_OUT) {
393 usb_core_receive(pdev, 0U, pdata,
397 if (pdev->class->ep0_rx_ready &&
398 (pdev->dev_state == USBD_STATE_CONFIGURED)) {
399 pdev->class->ep0_rx_ready(pdev);
402 usb_core_transmit_ep0(pdev, NULL, 0U);
405 } else if (pdev->class->data_out != NULL &&
406 (pdev->dev_state == USBD_STATE_CONFIGURED)) {
407 pdev->class->data_out(pdev, epnum);
416 * pdev: device instance
421 static enum usb_status usb_core_data_in(struct usb_handle *pdev, uint8_t epnum,
425 struct usb_endpoint *pep = &pdev->ep_in[0];
427 if (pdev->ep0_state == USBD_EP0_DATA_IN) {
431 usb_core_transmit(pdev, 0U, pdata,
435 usb_core_receive(pdev, 0U, NULL, 0U);
440 (pep->total_length < pdev->ep0_data_len)) {
441 usb_core_transmit(pdev, 0U, NULL, 0U);
443 pdev->ep0_data_len = 0U;
446 usb_core_receive(pdev, 0U, NULL, 0U);
448 if (pdev->class->ep0_tx_sent != NULL &&
449 (pdev->dev_state ==
451 pdev->class->ep0_tx_sent(pdev);
454 usb_core_receive_ep0(pdev, NULL, 0U);
458 } else if ((pdev->class->data_in != NULL) &&
459 (pdev->dev_state == USBD_STATE_CONFIGURED)) {
460 pdev->class->data_in(pdev, epnum);
469 * pdev : device instance
472 static enum usb_status usb_core_suspend(struct usb_handle *pdev)
475 pdev->dev_old_state = pdev->dev_state;
476 pdev->dev_state = USBD_STATE_SUSPENDED;
484 * pdev : device instance
487 static enum usb_status usb_core_resume(struct usb_handle *pdev)
490 pdev->dev_state = pdev->dev_old_state;
498 * pdev : device instance
501 static enum usb_status usb_core_sof(struct usb_handle *pdev)
503 if (pdev->dev_state == USBD_STATE_CONFIGURED) {
504 if (pdev->class->sof != NULL) {
505 pdev->class->sof(pdev);
515 * pdev : device instance
518 static enum usb_status usb_core_disconnect(struct usb_handle *pdev)
521 pdev->dev_state = USBD_STATE_DEFAULT;
522 pdev->class->de_init(pdev, pdev->dev_config);
527 enum usb_status usb_core_handle_it(struct usb_handle *pdev)
533 switch (pdev->driver->it_handler(pdev->data->instance, ¶m)) {
535 usb_core_data_out(pdev, param,
536 pdev->data->out_ep[param].xfer_buff);
540 usb_core_data_in(pdev, param,
541 pdev->data->in_ep[param].xfer_buff);
545 usb_core_setup_stage(pdev, (uint8_t *)pdev->data->setup);
552 ep = &pdev->data->out_ep[param & USBD_OUT_EPNUM_MASK];
554 pdev->driver->read_packet(pdev->data->instance,
561 ep = &pdev->data->out_ep[param & USBD_OUT_EPNUM_MASK];
563 pdev->driver->read_packet(pdev->data->instance,
564 (uint8_t *)pdev->data->setup, 8);
569 pdev->dev_state = USBD_STATE_DEFAULT;
573 if (pdev->data->lpm_state == LPM_L1) {
574 pdev->data->lpm_state = LPM_L0;
576 usb_core_resume(pdev);
581 usb_core_suspend(pdev);
585 if (pdev->data->lpm_state == LPM_L0) {
586 pdev->data->lpm_state = LPM_L1;
588 usb_core_suspend(pdev);
593 usb_core_sof(pdev);
597 usb_core_disconnect(pdev);
601 pdev->driver->write_empty_tx_fifo(pdev->data->instance, param,
602 pdev->data->in_ep[param].xfer_len,
603 (uint32_t *)&pdev->data->in_ep[param].xfer_count,
604 pdev->data->in_ep[param].maxpacket,
605 &pdev->data->in_ep[param].xfer_buff);
616 static void usb_core_start_xfer(struct usb_handle *pdev,
621 pdev->driver->ep0_start_xfer(handle, ep);
623 pdev->driver->ep_start_xfer(handle, ep);
630 * pdev: USB handle
636 enum usb_status usb_core_receive(struct usb_handle *pdev, uint8_t ep_addr,
640 struct pcd_handle *hpcd = (struct pcd_handle *)pdev->data;
656 usb_core_start_xfer(pdev, hpcd->instance, ep);
664 * pdev: USB handle
670 enum usb_status usb_core_transmit(struct usb_handle *pdev, uint8_t ep_addr,
674 struct pcd_handle *hpcd = (struct pcd_handle *)pdev->data;
690 usb_core_start_xfer(pdev, hpcd->instance, ep);
698 * pdev: USB handle
703 enum usb_status usb_core_receive_ep0(struct usb_handle *pdev, uint8_t *buf,
708 pdev->ep0_state = USBD_EP0_DATA_OUT;
710 pdev->ep0_state = USBD_EP0_STATUS_OUT;
713 pdev->ep_out[0].total_length = len;
714 pdev->ep_out[0].rem_length = len;
717 return usb_core_receive(pdev, 0U, buf, len);
723 * pdev: USB handle
728 enum usb_status usb_core_transmit_ep0(struct usb_handle *pdev, uint8_t *buf,
733 pdev->ep0_state = USBD_EP0_DATA_IN;
735 pdev->ep0_state = USBD_EP0_STATUS_IN;
738 pdev->ep_in[0].total_length = len;
739 pdev->ep_in[0].rem_length = len;
742 return usb_core_transmit(pdev, 0U, buf, len);
748 * pdev: device instance
753 void usb_core_ctl_error(struct usb_handle *pdev)
756 usb_core_set_stall(pdev, EP0_IN);
757 usb_core_set_stall(pdev, EP0_OUT);
763 * pdev: Device Handle
766 enum usb_status usb_core_start(struct usb_handle *pdev)
769 pdev->driver->start_device(pdev->data->instance);
777 * pdev: Device Handle
780 enum usb_status usb_core_stop(struct usb_handle *pdev)
783 pdev->class->de_init(pdev, pdev->dev_config);
786 pdev->driver->stop_device(pdev->data->instance);
794 * pdev: Device Handle
800 enum usb_status register_usb_driver(struct usb_handle *pdev,
807 assert(pdev != NULL);
813 pdev->driver = driver;
814 pdev->data = pcd_handle;
815 pdev->data->instance = driver_handle;
816 pdev->dev_state = USBD_STATE_DEFAULT;
817 pdev->ep0_state = USBD_EP0_IDLE;
821 pdev->ep_in[i].maxpacket = pdev->data->in_ep[i].maxpacket;
822 pdev->ep_out[i].maxpacket = pdev->data->out_ep[i].maxpacket;
831 * pdev: Device Handle
835 enum usb_status register_platform(struct usb_handle *pdev,
838 assert(pdev != NULL);
842 pdev->desc = plat_call_back;