U盘设备端驱动 -- 基于callback的状态机

vsf_err_t vsfusbd_MSCBOT_class_init(uint8_t iface,

           struct vsfusbd_device_t *device)

{

        struct vsfusbd_config_t *config = &device->config[device->configuration];

        struct vsfusbd_MSCBOT_param_t *param =

                        (struct vsfusbd_MSCBOT_param_t *)config->iface[iface].protocol_param;



        param->scsi_transact = NULL;

        param->device = device;

        vsfscsi_init(&param->scsi_dev);

        vsfusbd_MSCBOT_on_idle(param);

        return VSFERR_NONE;

}



static void vsfusbd_MSCBOT_on_idle(void *p)

{

        struct vsfusbd_MSCBOT_param_t *param = (struct vsfusbd_MSCBOT_param_t *)p;



        param->bufstream.buffer.buffer = (uint8_t *)&param->CBW;

        param->bufstream.buffer.size = sizeof(param->CBW);

        param->bufstream.read = false;

        param->stream.user_mem = &param->bufstream;

        param->stream.op = &buffer_stream_op;

        stream_init(&param->stream);



        param->transact.ep = param->ep_out;

        param->transact.data_size = sizeof(param->CBW);

        param->transact.stream = &param->stream;

        param->transact.cb.on_finish = vsfusbd_MSCBOT_on_cbw;

        param->transact.cb.param = param;

        vsfusbd_ep_recv(param->device, &param->transact);

}

static void vsfusbd_MSCBOT_on_cbw(void *p)

{

        struct vsfusbd_MSCBOT_param_t *param = (struct vsfusbd_MSCBOT_param_t *)p;

        struct vsfusbd_device_t *device = param->device;

        struct vsfscsi_lun_t *lun;



        if ((param->CBW.dCBWSignature != USBMSC_CBW_SIGNATURE) ||

                (param->CBW.bCBWCBLength < 1) || (param->CBW.bCBWCBLength > 16))

        {

                // TODO: invalid CBW, how to process this error?

                return;

        }



        if (param->CBW.bCBWLUN > param->scsi_dev.max_lun)

        {

        reply_failure:

                vsfusbd_MSCBOT_ErrHandler(device, param, USBMSC_CSW_FAIL);

                return;

        }



        param->CSW.dCSWStatus = USBMSC_CSW_OK;

        lun = &param->scsi_dev.lun[param->CBW.bCBWLUN];

        if (vsfscsi_execute(lun, param->CBW.CBWCB))

        {

                goto reply_failure;

        }



        if (param->CBW.dCBWDataTransferLength)

        {

                struct vsfusbd_transact_t *transact = &param->transact;



                if (!lun->transact.data_size)

                {

                        goto reply_failure;

                }

                param->scsi_transact = &lun->transact;

                transact->data_size = param->scsi_transact->data_size;

                transact->stream = param->scsi_transact->stream;

                transact->cb.on_finish = vsfusbd_MSCBOT_on_data_finish;

                transact->cb.param = param;



                if ((param->CBW.bmCBWFlags & USBMSC_CBWFLAGS_DIR_MASK) ==

                                        USBMSC_CBWFLAGS_DIR_IN)

                {

                        transact->ep = param->ep_in;

                        vsfusbd_ep_send(param->device, transact);

                }

                else

                {

                        transact->ep = param->ep_out;

                        vsfusbd_ep_recv(param->device, transact);

                }

        }

        else

        {

                if (param->scsi_transact->data_size && param->scsi_transact)

                {

                        vsfscsi_cancel_transact(param->scsi_transact);

                        param->scsi_transact = NULL;

                }

                vsfusbd_MSCBOT_SendCSW(device, param);

        }

}

static void vsfusbd_MSCBOT_on_data_finish(void *p)

{

        struct vsfusbd_MSCBOT_param_t *param = (struct vsfusbd_MSCBOT_param_t *)p;

        vsfusbd_MSCBOT_SendCSW(param->device, param);

}