usbd_24x0.c

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

/*
 *      A     EEEE  SSSS   OOO  PPPP 
 *     A A    E     S     O   O P   P
 *    AAAAA   EEEE  SSSS  O   O PPPP
 *   A     A  E         S O   O P
 *   A     A  EEEE  SSSS   OOO  P
 *
 *  An Entertainment Solution On a Platform (AESOP) is a completely Open Source 
 *  based graphical user environment and suite of applications for PDAs and other 
 *  devices running Linux. It is included in various embedded Linux distributions 
 *  such as OpenZaurus - http://www.aesop-embedded.org 
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *
 *	Title           : usbd_24x0.c
 *	Author          : 
 *	Created date    : 2005. 06. 26. 23:07:52 KST
 *	Description     : 
 *
 *	$Revision: 1.2 $
 *	$Log: usbd_24x0.c,v $
 *	Revision 1.2  2005/07/05 14:16:41  jeenspa
 *	usbdmass fixup, nand, mkyaffs
 *	
 *	Revision 1.1.1.1  2005/06/27 17:04:30  linuxpark
 *	Initial import.
 *	
 *	
 *
 */ 
#ident  "@(*) $Header: /cvsroot/aesop-embedded/u-boot-aesop/board/aesop2440/usbd_24x0.c,v 1.2 2005/07/05 14:16:41 jeenspa Exp $"


/*
 * Copyright (c) 2005
 * Junyoung Song, kernelproject.org, <[e-mail]>
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#if 0
#define DEBUGJY 3
#endif

#include <common.h>

#ifdef CONFIG_AESOP_USBDMASS

#include <s3c2440.h>
#include "usbd_common.h"
#include "usbd_24x0.h"

#define USB_VBUS_BIT 8
#define USB_PULLUP_BIT 5
#define PORT_MASK 0x3
#define PORT_IN 0x0
#define PORT_OUT 0x1

/* ------------------------------------------------------------------------- */
int usbd_24x0_chk_ep1_busy(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;
	return (in_csr1 & EPI_IN_PKT_READY);
}

int usbd_24x0_chk_ep1_stall(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;
	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__);
		return TRUE;
	}
	return FALSE;
}

int usbd_24x0_chk_ep2_stall(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;
	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__);
		return TRUE;
	}
	return FALSE;
}

void usbd_24x0_set_ep1_in_pkt_ready(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, "Set EP1 IN_PKT_RDY :: IN_CSR1 %02x\n", in_csr1);
	usbd->EP0_CSR_IN_CSR1_REG = ((in_csr1 & (~EPI_WR_BITS)) | EPI_IN_PKT_READY);
	return;
}

void usbd_24x0_clr_ep1_sent_stall(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(1, "Clear EP1 SENT STALL :: IN_CSR1 %02x\n", in_csr1);
	usbd->EP0_CSR_IN_CSR1_REG = ((in_csr1 & (~EPI_WR_BITS)) & ~(EPI_SENT_STALL | EPI_SEND_STALL));
	usbd->EP0_CSR_IN_CSR1_REG |= 0x40;
	debugvs(2, "after Clear EP1 SENT STALL :: IN_CSR1 %02x\n", usbd->EP0_CSR_IN_CSR1_REG);
	return;
}

void usbd_24x0_set_ep1_send_stall(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(1, "Set EP1 SEND STALL :: IN_CSR1 %02x\n", in_csr1);
	usbd->EP0_CSR_IN_CSR1_REG = ((in_csr1 & (~EPI_WR_BITS)) | EPI_SEND_STALL);
	return;
}

void usbd_24x0_clr_ep2_sent_stall(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(1, "Clear EP2 SENT STALL :: OUT_CSR1 %02x\n", out_csr1);
	usbd->OUT_CSR1_REG = ((out_csr1 & (~EPO_WR_BITS)) & ~(EPO_SENT_STALL | EPO_SEND_STALL));
	usbd->OUT_CSR1_REG |= 0x40;
	debugvs(2, "after Clear EP2 SENT STALL :: OUT_CSR1 %02x\n", usbd->OUT_CSR1_REG);
	return;
}

void usbd_24x0_clr_ep2_out_pkt_ready(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, "Clear EP2 OUT_PKT_RDY :: OUT_CSR1 %02x\n", out_csr1);
	usbd->OUT_CSR1_REG = (( out_csr1 & (~EPO_WR_BITS)) & (~EPO_OUT_PKT_READY));
	return;
}

void usbd_24x0_set_ep2_send_stall(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(1, "Set EP2 SEND STALL :: OUT_CSR1 %02x\n", out_csr1);
	usbd->OUT_CSR1_REG = (( out_csr1 & (~EPO_WR_BITS)) | EPO_SEND_STALL);
	return;
}

void usbd_24x0_clr_ep0_out_pkt_rdy(void)
{
	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, "clr_ep0_out_pkt_rdy :: CSR %02x\n", ep0_csr);
	usbd->EP0_CSR_IN_CSR1_REG = ((ep0_csr & (~EP0_WR_BITS)) | EP0_SERVICED_OUT_PKT_RDY);
	return;
}

void usbd_24x0_clr_ep0_outpktrdy_dataend(void)
{
	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, "clr_ep0_outpktrdy_dataend :: CSR %02x\n", ep0_csr);
	usbd->EP0_CSR_IN_CSR1_REG = ((ep0_csr & (~EP0_WR_BITS)) | (EP0_SERVICED_OUT_PKT_RDY | EP0_DATA_END));
	return;
}

void usbd_24x0_set_address(unsigned char address)
{
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();

	debugvs(2, "set_address [%02x] :: CSR %02x\n", address, usbd->EP0_CSR_IN_CSR1_REG);
	usbd->FUNC_ADDR_REG = address | 0x80;
	return;
}

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

	debugvs(1, "%s : %s - GPIO init for USB device\n", __FILE__, __FUNCTION__);
/*	
	gpio->GPGCON = gpio->GPGCON & ~(PORT_MASK << (USB_VBUS_BIT * 2));
	gpio->GPBDAT = gpio->GPBDAT | (1 << USB_PULLUP_BIT);
	gpio->GPBCON = (gpio->GPBCON & ~(PORT_MASK << (USB_PULLUP_BIT * 2))) | (PORT_OUT << (USB_PULLUP_BIT * 2));
*/
	gpio->MISCCR = gpio->MISCCR & 0xfffffff7;	/* Use pads related USB for USB device */
	return;
}

/* ------------------------------------------------------------------------- */
void usbd_24x0_init_usb_reset(void) {
	S3C24X0_USB_DEVICE * const usbd = S3C24X0_GetBase_USB_DEVICE();

	usbd->FUNC_ADDR_REG = ADDR_UPDATE | 0;	/* usb address <- 0 */
	usbd->PWR_REG = DISABLE_SUSPEND;
/* EP0 init */
	usbd->INDEX_REG = INDEX_EP0;
#if (EP0_PKT_SIZE == 8)
	usbd->MAXP_REG = FIFO_SIZE_8;
#else
#error "USB Device EP0 Max Packet Size should be 8"
#endif
	usbd->EP0_CSR_IN_CSR1_REG = EP0_SERVICED_OUT_PKT_RDY | EP0_SERVICED_SETUP_END;
/* EP1 init */
	usbd->INDEX_REG = INDEX_EP1;
#if (EP1_PKT_SIZE == 64)
	usbd->MAXP_REG = FIFO_SIZE_64;
#else
#error "USB Device EP1 Max Packet Size should be 64"
#endif
	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;
	
/* EP2 init */
	usbd->INDEX_REG = INDEX_EP2;
#if (EP2_PKT_SIZE == 64)
	usbd->MAXP_REG = FIFO_SIZE_64;
#else
#error "USB Device EP2 Max Packet Size should be 64"
#endif
	usbd->EP0_CSR_IN_CSR1_REG = EPI_FIFO_FLUSH | EPI_CDT;
	usbd->IN_CSR2_REG = EPI_MODE_OUT | EPI_IN_DMA_INT_MASK | EPI_BULK;
	usbd->OUT_CSR1_REG = EPO_CDT | EPO_FIFO_FLUSH;
	usbd->OUT_CSR2_REG = EPO_BULK | EPO_OUT_DMA_INT_MASK;

/* Interrupt init */
	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->INDEX_REG = INDEX_EP0;
	debugvs(3, "usb_reset :: CSR %02x\n", usbd->EP0_CSR_IN_CSR1_REG);
	return;
}
	
/* ------------------------------------------------------------------------- */
int usbd_24x0_check_vbus(void) {
	S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
	
	debugvs(1, "%s : %s - Check USBD VBUS\n", __FILE__, __FUNCTION__);
	return ((gpio->GPGDAT & (1 << USB_VBUS_BIT)) == 0) ? FALSE : TRUE;