usbd_24x0.c

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

}
	
/* ------------------------------------------------------------------------- */
int usbd_24x0_init_usb(void) {
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();
	S3C24X0_INTERRUPT * const interrupt = S3C24X0_GetBase_INTERRUPT();
	S3C24X0_CLOCK_POWER * const clockpower = S3C24X0_GetBase_CLOCK_POWER();

	debugvs(1, "%s : %s - USB device init\n", __FILE__, __FUNCTION__);
	
	usbd_24x0_init_gpio();

/*
#if 0
	udelay(10000);		// delay 10msec
	clockpower->UPLLCON = (120 << 12) | (2 << 4) | (3 << 0);
	udelay(10000);		// delay 10msec
	clockpower->CLKCON = clockpower->CLKCON | 0x80;
#else
	udelay(10000);		// delay 10msec
	clockpower->UPLLCON = (0x38 << 12) | (2 << 4) | (2 << 0);
	udelay(10000);		// delay 10msec
	clockpower->CLKCON = clockpower->CLKCON | 0x80;
#endif
*/

#ifndef IGNORE_VBUS
	if (!usbd_24x0_check_vbus()) return FALSE;
#endif

	usbd_24x0_init_usb_reset();
	
/* EP3 init */
	usbd->INDEX_REG = INDEX_EP3;
	usbd->MAXP_REG = FIFO_SIZE_64;
	usbd->EP0_CSR_IN_CSR1_REG = EPI_FIFO_FLUSH | EPI_CDT;
	usbd->IN_CSR2_REG = EPI_MODE_IN | EPI_IN_DMA_INT_MASK | EPI_BULK;
	usbd->OUT_CSR1_REG = EPO_CDT;
	usbd->OUT_CSR2_REG = EPO_BULK | EPO_OUT_DMA_INT_MASK;
/* EP4 init */
	usbd->INDEX_REG = INDEX_EP4;
	usbd->MAXP_REG = FIFO_SIZE_64;
	usbd->EP0_CSR_IN_CSR1_REG = EPI_FIFO_FLUSH | EPI_CDT;
	usbd->IN_CSR2_REG = EPI_MODE_IN | EPI_IN_DMA_INT_MASK | EPI_BULK;
	usbd->OUT_CSR1_REG = EPO_CDT;
	usbd->OUT_CSR2_REG = EPO_BULK | EPO_OUT_DMA_INT_MASK;
	
/* Interrupt init */
	interrupt->INTMSK |= BIT_USBD;
	usbd->EP_INT_REG = EP0_INT | EP1_INT | EP2_INT | EP3_INT | EP4_INT;
	usbd->USB_INT_REG = RESET_INT | SUSPEND_INT | RESUME_INT;
	usbd->EP_INT_EN_REG = EP0_INT | EP1_INT | EP2_INT | EP3_INT | EP4_INT;
	usbd->USB_INT_EN_REG = RESET_INT | SUSPEND_INT;

	return TRUE;
}

/* ------------------------------------------------------------------------- */
void usbd_24x0_connect(void) {
	S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();

	debugvs(1, "%s : %s - USBD DP Pull-up\n", __FILE__, __FUNCTION__);
	gpio->GPBDAT &= ~(1 << USB_PULLUP_BIT);
	/* erase pending interrupt */
	usbd->EP_INT_REG = EP0_INT | EP1_INT | EP2_INT | EP3_INT | EP4_INT;
	usbd->USB_INT_REG = RESET_INT | SUSPEND_INT | RESUME_INT;
	return;
}

/* ------------------------------------------------------------------------- */
void usbd_24x0_disconnect(void) {
	S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();

	debugvs(1, "%s : %s - USB DP Pull-up release\n", __FILE__, __FUNCTION__);
	gpio->GPBDAT |= (1 << USB_PULLUP_BIT);
	return;
}

/* ------------------------------------------------------------------------- */
int usbd_24x0_chk_int(void)
{
	int return_value;
	unsigned char value;
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();

#if 0
	S3C24X0_INTERRUPT * const interrupt = S3C24X0_GetBase_INTERRUPT();

	if (!(interrupt->SRCPND & BIT_USBD)) return 0;
	interrupt->SRCPND = BIT_USBD;
#endif

	value = usbd->USB_INT_REG;
	usbd->USB_INT_REG = value;	/* clear pending interrupt */
	if (value & SUSPEND_INT) {
		/* usbd->USB_INT_REG = SUSPEND_INT; */
		debugvs(1, "%s : %s - unexpected interrupt :: SUSPEND_INT\n", __FILE__, __FUNCTION__);
	}
	if (value & RESUME_INT) {
		/* usbd->USB_INT_REG = RESUME_INT; */
		debugvs(1, "%s : %s - unexpected interrupt :: RESUME_INT\n", __FILE__, __FUNCTION__);
	}

	return_value = (value & RESET_INT) << 1;

	value = usbd->EP_INT_REG;
	usbd->EP_INT_REG = value;	/* clear pending interrupt */
	if (value & EP3_INT) {
		/* usbd->EP_INT_REG = EP3_INT; */
		debugvs(1, "%s : %s - unexpected interrupt :: EP3_INT\n", __FILE__, __FUNCTION__);
	}
	if (value & EP4_INT) {
		/* usbd->EP_INT_REG = EP4_INT; */
		debugvs(1, "%s : %s - unexpected interrupt :: EP4_INT\n", __FILE__, __FUNCTION__);
	}
	return_value |= value & (EP0_INT | EP1_INT | EP2_INT);
	return return_value;
}

unsigned char usbd_24x0_read_fifo(unsigned char *buff, unsigned char endpoint)
{
	int i;
	unsigned char len;

	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();

	usbd->INDEX_REG = endpoint;
	len = usbd->OUT_FIFO_CNT1_REG;
	for (i = 0; i < len; i++)
		buff[i] = usbd->fifo[endpoint].EP_FIFO_REG;
	return len;
}

void usbd_24x0_write_fifo(unsigned char *buff, unsigned char length, unsigned char endpoint)
{
	int i;
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();

	debugvs(3, "Write FIFO [%d]: ", endpoint);
	for (i = 0; i < length; i++) {
		usbd->fifo[endpoint].EP_FIFO_REG = buff[i];
		debugvs(3, "%02x ", buff[i]);
	}
	debugvs(3, "\n");
	return;
}

void usbd_24x0_ep0_in_process(usbd_ep0_instance *ep0)
{
	int i, pkt_size;
	unsigned char ep0_csr;
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();

	usbd->INDEX_REG = INDEX_EP0;
	ep0_csr = usbd->EP0_CSR_IN_CSR1_REG;
	
	if((ep0->length == ep0->buff_ptr) && (ep0->state == TRANS)) {
		debugvs(3, "%s : %s - EP0 Handler :: DATAEND\n", __FILE__, __FUNCTION__);
		usbd->EP0_CSR_IN_CSR1_REG = ((ep0_csr & (~EP0_WR_BITS)) | (EP0_IN_PKT_READY | EP0_DATA_END));
		ep0->state = IDLE;
		return;		
	}
	
	i = ep0->length - ep0->buff_ptr;
	pkt_size = (i > EP0_PKT_SIZE) ? EP0_PKT_SIZE : i;
	debugvs(2, "%s : %s - EP0 Handler :: Total length %d, Send data %dBytes\n", __FILE__, __FUNCTION__, ep0->length, pkt_size);
	debugvs(3, "EP0 IN Packet :: ");
	debughd(3, ep0->buff + ep0->buff_ptr, pkt_size);

	if (usbd->USB_INT_REG & RESET_INT) {
		debugvs(2, "%s : %s - EP0 Handler :: RESET INT , IN packet canceled\n", __FILE__, __FUNCTION__);
		ep0->state = IDLE;
		return;
	}		

	usbd_24x0_write_fifo(ep0->buff + ep0->buff_ptr, pkt_size, INDEX_EP0);
	ep0->buff_ptr += pkt_size;
	if ((ep0->length == ep0->buff_ptr) && (pkt_size != EP0_PKT_SIZE)) {
		usbd->EP0_CSR_IN_CSR1_REG = ((ep0_csr & (~EP0_WR_BITS)) | (EP0_IN_PKT_READY | EP0_DATA_END));
		ep0->state = IDLE;
	}
	else
	{
		usbd->EP0_CSR_IN_CSR1_REG = ((ep0_csr & (~EP0_WR_BITS)) | (EP0_IN_PKT_READY));
		ep0->state = TRANS;
	}
	debugvs(3, "EP0 CSR : %02x\n", usbd->EP0_CSR_IN_CSR1_REG);
	return;
}

void usbd_24x0_ep0_handler(usbd_ep0_instance *ep0)
{
	unsigned char ep0_csr;
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();

	usbd->INDEX_REG = INDEX_EP0;
	ep0_csr = usbd->EP0_CSR_IN_CSR1_REG;
	
	debugvs(3, "%s : %s - EP0 CSR :: %02x\n", __FILE__, __FUNCTION__, ep0_csr);

	if (ep0_csr & EP0_SETUP_END) {
		debugvs(1, "%s : %s - EP0 Handler :: SETUP_END\n", __FILE__, __FUNCTION__);
		ep0->buff_ptr = 0;
		ep0->length = usbd_24x0_read_fifo(ep0->buff, INDEX_EP0);
		debugvs(3, "EP0 OUT Packet %dBytes :: ", ep0->length);
		debughd(3, ep0->buff, ep0->length);
		usbd->EP0_CSR_IN_CSR1_REG = ((ep0_csr & (~EP0_WR_BITS)) | (EP0_SERVICED_SETUP_END));
		
		if (ep0_csr & EP0_OUT_PKT_READY) {
			while(usbd->OUT_FIFO_CNT1_REG)
				usbd->fifo[0].EP_FIFO_REG;
			usbd->EP0_CSR_IN_CSR1_REG = ((ep0_csr & (~EP0_WR_BITS)) | EP0_SERVICED_OUT_PKT_RDY);
		}
		ep0->state = IDLE;
		return;
	}

	if (ep0_csr & EP0_SENT_STALL) {
		debugvs(1, "%s : %s - EP0 Handler :: SENT_STALL\n", __FILE__, __FUNCTION__);
		usbd->EP0_CSR_IN_CSR1_REG = (ep0_csr & (~EP0_WR_BITS) & (~EP0_SENT_STALL));
		if (ep0_csr & EP0_OUT_PKT_READY) {
			usbd->EP0_CSR_IN_CSR1_REG = ((ep0_csr & (~EP0_WR_BITS)) | EP0_SERVICED_OUT_PKT_RDY);
		}
		ep0->state = IDLE;
		return;
	}

	if (ep0_csr & EP0_OUT_PKT_READY) {
		ep0->buff_ptr = 0;
		ep0->length = usbd_24x0_read_fifo(ep0->buff, INDEX_EP0);
		debugvs(2, "%s : %s - EP0 Handler :: SETUP PACKET %dBytes\n", __FILE__, __FUNCTION__, ep0->length);
		debugvs(3, "EP0 OUT Packet :: ");
		debughd(3, ep0->buff, ep0->length);
		ep0->state = SETUP;
		return;
	}

	if (ep0->state == TRANS) usbd_24x0_ep0_in_process(ep0);
	
	return;	
}

/* check EP1 Interrupt */
int usbd_24x0_isr_ep1_chk(void)
{
	unsigned char in_csr1;
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();
	usbd->INDEX_REG = INDEX_EP1;
	in_csr1 = usbd->EP0_CSR_IN_CSR1_REG;
	debugvs(2, "%s : %s - EP1 IN_CSR1 - %02x\n", __FILE__, __FUNCTION__, in_csr1);
	if (in_csr1 & EPI_SENT_STALL) {
		usbd->EP0_CSR_IN_CSR1_REG = ((in_csr1 & (~EPI_WR_BITS)) & (~EPI_SENT_STALL));
		debugvs(2, "%s : %s - EP1 SENT STALL Clear\n", __FILE__, __FUNCTION__);
	}
	if (in_csr1 & EPI_IN_PKT_READY) return TRUE;
	return FALSE;
}

/* check EP2 Interrupt */
int usbd_24x0_isr_ep2_chk(void)
{
	unsigned char out_csr1;
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();
	usbd->INDEX_REG = INDEX_EP2;
	out_csr1 = usbd->OUT_CSR1_REG;
	debugvs(2, "%s : %s - EP2 OUT_CSR1 - %02x\n", __FILE__, __FUNCTION__, out_csr1);
	if (out_csr1 & EPO_SENT_STALL) {
		usbd->OUT_CSR1_REG = (( out_csr1 & (~EPO_WR_BITS)) & (~EPO_SENT_STALL));
		debugvs(2, "%s : %s - EP2 SENT STALL Clear\n", __FILE__, __FUNCTION__);
	}
	if (out_csr1 & EPO_OUT_PKT_READY) return TRUE;
	return FALSE;
}

/* Get CBW */
int usbd_24x0_get_cbw(unsigned char *buff)
{
	int i;
	unsigned char out_csr1, fifo_count;
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();

	usbd->INDEX_REG = INDEX_EP2;
	out_csr1 = usbd->OUT_CSR1_REG;
	fifo_count = usbd->OUT_FIFO_CNT1_REG;
	if (fifo_count != sizeof(struct cbw)) {
		debugvs(1, "%s : %s - Wrong CBW :: size %dBytes\n", __FILE__, __FUNCTION__, fifo_count);
		usbd->OUT_CSR1_REG = (( out_csr1 & (~EPO_WR_BITS)) | EPO_FIFO_FLUSH);
		usbd->OUT_CSR1_REG = (( out_csr1 & (~EPO_WR_BITS)) & (~EPO_OUT_PKT_READY));
		return FALSE;
	}

	for(i = 0; i < fifo_count; i++)
		buff[i] = usbd->fifo[2].EP_FIFO_REG;
	usbd->OUT_CSR1_REG = (( out_csr1 & (~EPO_WR_BITS)) & (~EPO_OUT_PKT_READY));
	return TRUE;
}

#endif /* CONFIG_AESOP_USBDMASS */