static void *vsfusbh_uvc_init(struct vsfusbh_t *usbh, struct vsfusbh_device_t *dev)
{
struct vsfusbh_class_data_t *cdata;
struct vsfusbh_uvc_t *hdata;
cdata = vsf_bufmgr_malloc(sizeof(struct vsfusbh_class_data_t));
if (NULL == cdata)
return NULL;
hdata = vsf_bufmgr_malloc(sizeof(struct vsfusbh_uvc_t));
if (NULL == hdata)
{
vsf_bufmgr_free(cdata);
return NULL;
}
memset(cdata, 0, sizeof(struct vsfusbh_class_data_t));
memset(hdata, 0, sizeof(struct vsfusbh_uvc_t));
cdata->dev = dev;
hdata->dev = dev;
hdata->usbh = usbh;
cdata->param = hdata;
hdata->video_payload.type = VSFUSBH_UVC_PAYLOAD_VIDEO;
hdata->video_payload.buf = hdata->video_urb_buf;
hdata->init_sm.init_state.evt_handler = uvc_evt_handler_init;
hdata->init_sm.user_data = (void*)hdata;
hdata->init_pt.thread = uvc_init_thread;
hdata->init_pt.user_data = hdata;
hdata->init_pt.sm = &hdata->init_sm;
hdata->init_pt.state = 0;
hdata->ctrl_sm.init_state.evt_handler = uvc_evt_handler_ctrl;
hdata->ctrl_sm.user_data = (void*)hdata;
hdata->ctrl_pt.thread = uvc_ctrl_thread;
hdata->ctrl_pt.user_data = hdata;
hdata->ctrl_pt.sm = &hdata->ctrl_sm;
hdata->ctrl_pt.state = 0;
hdata->ctrl_urb.vsfdev = dev;
hdata->ctrl_urb.timeout = 200;
hdata->ctrl_urb.sm = &hdata->init_sm;
hdata->video_sm.init_state.evt_handler = uvc_evt_handler_video;
hdata->video_sm.user_data = (void*)hdata;
hdata->video_urb.vsfdev = dev;
hdata->video_urb.timeout = 200;
hdata->video_urb.sm = &hdata->video_sm;
vsfsm_init(&hdata->init_sm);
vsfsm_init(&hdata->ctrl_sm);
vsfsm_init(&hdata->video_sm);
return cdata;
}
vsf_err_t
vsfusbd_CDCData_class_init(uint8_t iface, struct vsfusbd_device_t *device)
{
struct vsfusbd_config_t *config = &device->config[device->configuration];
struct vsfusbd_iface_t *ifs = &config->iface[iface];
struct vsfusbd_CDC_param_t *param =
(struct vsfusbd_CDC_param_t *)ifs->protocol_param;
if ((NULL == param) || (NULL == param->stream_tx) ||
(NULL == param->stream_rx))
{
return VSFERR_INVALID_PARAMETER;
}
param->device = device;
#ifdef VSFUSBD_CDCCFG_TRANSACT
param->IN_transact.ep = param->ep_in;
param->IN_transact.cb.on_finish = vsfusbd_CDCData_on_IN_finish;
param->IN_transact.cb.param = param;
param->IN_transact.zlp = false;
param->OUT_transact.ep = param->ep_out;
param->OUT_transact.cb.on_finish = vsfusbd_CDCData_on_OUT_finish;
param->OUT_transact.cb.param = param;
param->OUT_transact.zlp = false;
vsfusbd_CDCData_on_IN_finish(param);
vsfusbd_CDCData_on_OUT_finish(param);
return VSFERR_NONE;
#else
ifs->sm.init_state.evt_handler = vsfusbd_CDCData_evt_handler;
param->iface = ifs;
ifs->sm.user_data = (void*)param;
return vsfsm_init(&ifs->sm);
#endif
}
vsf_err_t vsf_malstream_init(struct vsf_malstream_t *malstream)
{
malstream->mal_ready = false;
malstream->sm.init_state.evt_handler = vsf_malstream_init_evt_handler;
malstream->sm.user_data = malstream;
return vsfsm_init(&malstream->sm);
}
vsf_err_t vsfshell_init(struct vsfshell_t *shell)
{
// state machine init
shell->sm.init_state.evt_handler = vsfshell_evt_handler;
shell->sm.user_data = (void*)shell;
return vsfsm_init(&shell->sm);
}
vsf_err_t vsfsm_pt_init(struct vsfsm_t *sm, struct vsfsm_pt_t *pt)
{
sm->user_data = pt;
sm->init_state.evt_handler = vsfsm_pt_evt_handler;
#if (VSFSM_CFG_SM_EN && VSFSM_CFG_SUBSM_EN) || VSFSM_CFG_HSM_EN
sm->init_state.subsm = NULL;
#endif
pt->sm = sm;
return vsfsm_init(sm);
}
vsf_err_t vsfusbd_HID_class_init(uint8_t iface, struct vsfusbd_device_t *device)
{
struct vsfusbd_config_t *config = &device->config[device->configuration];
struct vsfusbd_iface_t *ifs = &config->iface[iface];
struct vsfusbd_HID_param_t *param =
(struct vsfusbd_HID_param_t *)ifs->protocol_param;
// state machine init
ifs->sm.init_state.evt_handler = vsfusbd_HID_evt_handler;
param->iface = ifs;
param->device = device;
ifs->sm.user_data = (void*)param;
return vsfsm_init(&ifs->sm);
}
vsf_err_t vsfusbh_init(struct vsfusbh_t *usbh)
{
if (NULL == usbh->hcd)
{
return VSFERR_INVALID_PARAMETER;
}
memset(&usbh->sm, 0, sizeof(usbh->sm));
usbh->device_bitmap[0] = 1; // remove address 0
usbh->device_bitmap[1] = 0;
usbh->device_bitmap[2] = 0;
usbh->device_bitmap[3] = 0;
usbh->sm.init_state.evt_handler = vsfusbh_init_evt_handler;
usbh->sm.user_data = (void*)usbh;
return vsfsm_init(&usbh->sm);
}
vsf_err_t vsfip_dhcpc_start(struct vsfip_netif_t *netif,
struct vsfip_dhcpc_t *dhcpc)
{
if ((NULL == netif) || (NULL == dhcpc))
{
return VSFERR_FAIL;
}
netif->dhcp.dhcpc = dhcpc;
dhcpc->netif = netif;
dhcpc->sockaddr.sin_port = DHCP_SERVER_PORT;
dhcpc->sockaddr.sin_addr.size = 4;
dhcpc->sm.init_state.evt_handler = vsfip_dhcpc_evt_handler;
dhcpc->sm.user_data = dhcpc;
return vsfsm_init(&dhcpc->sm);
}
static void *vsfusbh_hub_probe(struct vsfusbh_t *usbh,
struct vsfusbh_device_t *dev, struct usb_interface_t *interface,
const struct vsfusbh_device_id_t *id)
{
struct usb_interface_desc_t *intf_desc;
struct usb_endpoint_desc_t *ep_desc;
struct vsfusbh_hub_t *hub;
intf_desc = interface->altsetting + interface->act_altsetting;
if ((intf_desc->bInterfaceSubClass != 0) &&
(intf_desc->bInterfaceSubClass != 1))
return NULL;
if (intf_desc -> bNumEndpoints != 1)
return NULL;
ep_desc = intf_desc->ep_desc;
if ((ep_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
USB_ENDPOINT_XFER_INT)
return NULL;
hub = vsf_bufmgr_malloc(sizeof(struct vsfusbh_hub_t));
if (NULL == hub)
return NULL;
memset(hub, 0, sizeof(struct vsfusbh_hub_t));
hub->vsfurb = usbh->hcd->alloc_urb();
if (hub->vsfurb == NULL)
{
vsf_bufmgr_free(hub);
return NULL;
}
hub->usbh = usbh;
hub->dev = dev;
hub->vsfurb->vsfdev = dev;
hub->vsfurb->timeout = 200;
hub->sm.init_state.evt_handler = vsfusbh_hub_evt_handler_init;
hub->sm.user_data = hub;
vsfsm_init(&hub->sm);
return hub;
}
static void *vsfusbh_uvc_init(struct vsfusbh_t *usbh, struct vsfusbh_device_t *dev)
{
struct vsfusbh_class_data_t *cdata;
struct vsfusbh_uvc_t *hdata;
cdata = vsf_bufmgr_malloc(sizeof(struct vsfusbh_class_data_t));
if (NULL == cdata)
return NULL;
hdata = vsf_bufmgr_malloc(sizeof(struct vsfusbh_uvc_t));
if (NULL == hdata)
{
vsf_bufmgr_free(cdata);
return NULL;
}
memset(cdata, 0, sizeof(struct vsfusbh_class_data_t));
memset(hdata, 0, sizeof(struct vsfusbh_uvc_t));
cdata->dev = dev;
hdata->dev = dev;
hdata->usbh = usbh;
cdata->param = hdata;
//hdata->init_sm.init_state.evt_handler = uvc_evt_handler_init;
//hdata->init_sm.user_data = (void*)hdata;
//hdata->init_pt.thread = uvc_init_thread;
hdata->ctrl_sm.init_state.evt_handler = uvc_evt_handler_ctrl;
hdata->ctrl_sm.user_data = (void*)hdata;
hdata->ctrl_pt.thread = uvc_ctrl_thread;
hdata->ctrl_pt.user_data = hdata;
hdata->ctrl_pt.sm = &hdata->ctrl_sm;
hdata->ctrl_pt.state = 0;
hdata->ctrl_urb.vsfdev = dev;
hdata->ctrl_urb.timeout = 200;
hdata->ctrl_urb.sm = &hdata->ctrl_sm;
hdata->video_sm.init_state.evt_handler = uvc_evt_handler_video;
hdata->video_sm.user_data = (void*)hdata;
hdata->video_urb.vsfdev = dev;
hdata->video_urb.timeout = 200;
hdata->video_urb.sm = &hdata->video_sm;
hdata->audio_sm.init_state.evt_handler = uvc_evt_handler_audio;
hdata->audio_sm.user_data = (void*)hdata;
hdata->audio_urb.vsfdev = dev;
hdata->audio_urb.timeout = 200;
hdata->audio_urb.sm = &hdata->audio_sm;
// test
#if 1
hdata->set_param.connected = 1;
hdata->set_param.video_enable = 1;
#endif // 1
vsfsm_init(&hdata->ctrl_sm);
vsfsm_init(&hdata->video_sm);
vsfsm_init(&hdata->audio_sm);
return cdata;
}
