usbd_mass.c

F:worksip2440a board可启动u-boot-like.tar.gz F:worksip2440a board可启动u-boot-like.tar.gz

	usbd_24x0_clr_ep1_sent_stall();
	usbd_24x0_clr_ep2_sent_stall();
	return;
}

/*********************************************************************
 *
 *	USB Endpoint0 Handling
 * 
 ********************************************************************/

/* USBDevice ep0 (CONTROL) interrupt handler */
void usbdmass_isr_ep0(void)
{
	devrequest *request;
	debugvs(2, "%s : %s - USBD EP0 Interrupt\n", __FILE__, __FUNCTION__);
	usbd_24x0_ep0_handler(&ep0);
	request = (devrequest *)ep0.buff;
	
	if (ep0.state == SETUP) {
		switch (request->requesttype & USB_TYPE_MASK) {
			case USB_TYPE_STANDARD:
				usbdmass_ep0_setup_standard();
				break;
			case USB_TYPE_CLASS:
				usbdmass_ep0_setup_class();
				break;
			case USB_TYPE_VENDOR:
			case USB_TYPE_RESERVED:
			default:
				break;
		}
	}
	return;
}

/*--------------------------------------------------------------------
 *	USB EP0 Setup - Request : Standard
--------------------------------------------------------------------*/

void usbdmass_ep0_setup_standard(void)
{
	devrequest *request;
	request = (devrequest *)ep0.buff;

	switch(request->request) {
		case USB_REQ_GET_STATUS:
			usbdmass_ep0_setup_get_status();
			break;
		case USB_REQ_CLEAR_FEATURE:
			usbdmass_ep0_setup_clear_feature();
			break;
		case USB_REQ_SET_ADDRESS:
			usbdmass_ep0_setup_set_address();
			break;
		case USB_REQ_GET_DESCRIPTOR:
			usbdmass_ep0_setup_get_descriptor();
			break;
		default:
			usbdmass_ep0_setup_default();
			break;
	}
	return;		
}

void usbdmass_ep0_setup_get_status(void)
{
	debugvs(2, "%s : %s - SETUP Standard :: Get Status\n", __FILE__, __FUNCTION__);

	usbd_24x0_clr_ep0_out_pkt_rdy();
	ep0.length = 2;
	ep0.buff_ptr = 0;
	ep0.buff[0] = 1;	/* self powered */
	ep0.buff[1] = 0;
	usbd_24x0_ep0_in_process(&ep0);
	return;
}

void usbdmass_ep0_setup_clear_feature(void)
{

	debugvs(2, "%s : %s - SETUP Standard :: Clear Feature\n", __FILE__, __FUNCTION__);
	ma.stall = NONE;
	usbd_24x0_clr_ep1_sent_stall();
	usbd_24x0_clr_ep2_sent_stall();
	
	usbd_24x0_clr_ep0_outpktrdy_dataend();
	ep0.state = IDLE;
	return;
}

void usbdmass_ep0_setup_set_address(void)
{
	devrequest_b *request_b;
	request_b = (devrequest_b *)ep0.buff;
	
	debugvs(2, "%s : %s - SETUP Standard :: Set Address\n", __FILE__, __FUNCTION__);

	usbd_24x0_set_address(request_b->value_l);
	usbd_24x0_clr_ep0_outpktrdy_dataend();
	ep0.state = IDLE;
	return;
}

void usbdmass_ep0_setup_get_descriptor(void)
{
	devrequest_b *request_b;

	debugvs(2, "%s : %s - SETUP Standard :: Get Descriptor\n", __FILE__, __FUNCTION__);
	request_b = (devrequest_b *)ep0.buff;

	switch (request_b->value_h) {
		case USB_DESCRIPTOR_TYPE_DEVICE:
			debugvs(1, "%s : %s - SETUP Standard :: Get Descriptor - Device\n", __FILE__, __FUNCTION__);
			debugvs(3, "Device Descriptor :: \n");
			debughd(3, (char *)&device_descriptor, device_descriptor.bLength);
			usbdmass_ep0_setup_sendend((unsigned char *)&device_descriptor, request_b->length_l, device_descriptor.bLength);
			break;

		case USB_DESCRIPTOR_TYPE_CONFIGURATION:
			debugvs(1, "%s : %s - SETUP Standard :: Get Descriptor - Configuration\n", __FILE__, __FUNCTION__);
			debugvs(3, "Configuration Descriptor :: \n");
			debughd(3, (char *)&config_descriptor_all, config_descriptor_all.config_descriptor.wTotalLength);
			usbdmass_ep0_setup_sendend((unsigned char *)&config_descriptor_all, request_b->length_l, (unsigned char)config_descriptor_all.config_descriptor.wTotalLength);
			break;

		case USB_DESCRIPTOR_TYPE_STRING:
			debugvs(1, "%s : %s - SETUP Standard :: Get Descriptor - String #%d\n", __FILE__, __FUNCTION__, request_b->value_l);
			usbdmass_ep0_setup_sendend((unsigned char *)usbdmass_string_table[request_b->value_l], request_b->length_l, usbdmass_string_table[request_b->value_l]->bLength);
			break;

		case USB_DESCRIPTOR_TYPE_INTERFACE:
			debugvs(1, "%s : %s - SETUP Standard :: Get Descriptor - Interface\n", __FILE__, __FUNCTION__);
			usbdmass_ep0_setup_sendend((unsigned char *)&config_descriptor_all.interface_descriptor, request_b->length_l, config_descriptor_all.interface_descriptor.bLength);
			break;

		case USB_DESCRIPTOR_TYPE_ENDPOINT:
			debugvs(1, "%s : %s - SETUP Standard :: Get Descriptor - Endpoint #%d\n", __FILE__, __FUNCTION__, request_b->value_l);
			usbdmass_ep0_setup_sendend((unsigned char *)ep_descriptor_ptrs[request_b->value_l], request_b->length_l, ep_descriptor_ptrs[request_b->value_l]->bLength);
			break;

		default:
			usbd_24x0_clr_ep0_outpktrdy_dataend();
			ep0.state = IDLE;
			break;
	}
	return;
}

void usbdmass_ep0_setup_default(void)
{
	debugvs(2, "%s : %s - SETUP :: Nothing to do\n", __FILE__, __FUNCTION__);
	usbd_24x0_clr_ep0_outpktrdy_dataend();
	ep0.state = IDLE;
	return;
}

/*--------------------------------------------------------------------
 *	USB EP0 Setup - Request : Class
--------------------------------------------------------------------*/

void usbdmass_ep0_setup_class(void)
{
	devrequest *request;
	request = (devrequest *)ep0.buff;

	switch(request->request) {
		case USB_REQ_CLASS_RESET:
			usbdmass_ep0_setup_class_reset();
			break;
		case USB_REQ_CLASS_GETMAXLUN:
			usbdmass_ep0_setup_class_getmaxlun();
			break;
		default:
			usbdmass_ep0_setup_default();
			break;
	}
	return;		
}

void usbdmass_ep0_setup_class_reset(void)
{
	devrequest_b *request_b;
	request_b = (devrequest_b *)ep0.buff;
	ma.usb_reset = TRUE;
	
	debugvs(2, "%s : %s - SETUP Class :: Reset\n", __FILE__, __FUNCTION__);
	usbdmass_class_init();
	return;
}

void usbdmass_ep0_setup_class_getmaxlun(void)
{
	devrequest_b *request_b;
	request_b = (devrequest_b *)ep0.buff;
	
	debugvs(2, "%s : %s - SETUP Class :: GetMaxLun\n", __FILE__, __FUNCTION__);
	usbd_24x0_clr_ep0_out_pkt_rdy();
	ep0.length = 1;
	ep0.buff_ptr = 0;
	ep0.buff[0] = 0;	/* MAX LUN = 0 */
	usbd_24x0_ep0_in_process(&ep0);
	return;
}

/*--------------------------------------------------------------------
 *	USB EP0 Sub-routines
--------------------------------------------------------------------*/

void usbdmass_ep0_setup_sendend(unsigned char *msg, unsigned char req_length, unsigned char length)
{
	int i;
	
	usbd_24x0_clr_ep0_out_pkt_rdy();
	if (req_length < length) length = req_length;
	ep0.buff_ptr = 0;
	ep0.length = length;
	for (i = 0; i < length; i++) ep0.buff[i] = msg[i];
	usbd_24x0_ep0_in_process(&ep0);
	return;
}

/*********************************************************************
 *
 *	USB Bulk (EP1,EP2) Handling
 * 
 ********************************************************************/

/* USBDevice ep2 (BULK OUT) interrupt handler */
void usbdmass_isr_ep2(void)
{
	debugvs(2, "%s : %s - USBD EP2 Interrupt\n", __FILE__, __FUNCTION__);

	if (!usbd_24x0_isr_ep2_chk()) return;

	if (ma.state == WAIT_CBW) usbdmass_process_cbw();
	return;	
}

/*********************************************************************
 *
 *	USB Mass-Storage Class
 * 
 ********************************************************************/

int usbdmass_process_cbw(void)
{
	char ret;
	S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
	
	led1_on();
	ma.state = PROCESS_CBW;
	if (!usbd_24x0_get_cbw((unsigned char *)&ma.cbw)) {
		debugvs(3, "CBW Error - Size is not 0x1f.\n");
		usbdmass_process_cbw_error();
		return FALSE;
	}

	debugvs(3, "CBW Received:: \n");
	debughd(3, (char *)&ma.cbw, sizeof(struct cbw));
	if (ma.cbw.dCBWSignature != 0x43425355) {
		debugvs(3, "CBW Error - Wrong Signature\n");
		usbdmass_process_cbw_error();
		return FALSE;
	}

	ma.csw.dCSWDataResidue = ma.cbw.dCBWDataTransferLength;
	ma.buff_length = 0;
	ma.buff_ptr = 0;

	ret = usbd_scsi_command(&ma);

	if (ma.state == SEND_CSW) {
		usbdmass_process_send_csw(ret);
	}
	
	return TRUE;
}

void usbdmass_process_cbw_error(void)
{
	ma.state = CBW_ERROR;
	ma.stall = INOUT_STALL;
	usbd_24x0_set_ep1_send_stall();
	usbd_24x0_set_ep2_send_stall();
	return;
}

void usbdmass_process_send_csw(char status)
{
	ma.csw.dCSWSignature = 0x53425355;
	ma.csw.dCSWTag = ma.cbw.dCBWTag;
	ma.csw.bCSWStatus = status;

	if (ma.usb_reset == TRUE) {
		ma.state = WAIT_CBW;
		return;
	}

	if (status == CSW_STATUS_CommandFailed) {
		if (ma.cbw.bmCMWFlags & IN) {
			usbd_24x0_set_ep1_send_stall();
			ma.stall = IN_STALL;
		}
		else {
			usbd_24x0_set_ep2_send_stall();
			ma.stall = OUT_STALL;
		}
	}

	while(ma.stall != NONE) {
		usbdmass_check_control_int();
	}

	while(usbd_24x0_chk_ep1_busy());
	usbd_24x0_write_fifo((unsigned char *)&ma.csw, sizeof(struct csw), INDEX_EP1);
	usbd_24x0_set_ep1_in_pkt_ready();
	ma.state = WAIT_CBW;
	return;	
}

/*********************************************************************
 *
 *	Utitlty Functions
 * 
 ********************************************************************/

/* utility function for converting char* to wide string used by USB */
void str2wide (char *str, unsigned short * wide)
{
	int i;

	for (i = 0; i < strlen (str) && str[i]; i++)
		wide[i] = (u16) str[i];
}

#endif /* CONFIG_AESOP_USBDMASS */