/*
* Create the appropriate control structures to manage
* a new EHCI host controller.
*/
int ehci_hcd_init(void)
{
char *env;
int usbActive;
env = getenv("usbActive");
usbActive = simple_strtoul(env, NULL, 10);
printf("Active port:\t");
if (usbActive >= mvCtrlUsbMaxGet()) {
printf("invalid port number %d, switching to port 0\n", usbActive);
usbActive=0;
} else {
printf("%d\n", usbActive);
}
hccr = (struct ehci_hccr *)(INTER_REGS_BASE + MV_USB_REGS_OFFSET(usbActive) + 0x100);
hcor = (struct ehci_hcor *)((uint32_t) hccr + HC_LENGTH(ehci_readl(&hccr->cr_capbase)));
debug ("Marvell init hccr %x and hcor %x hc_length %d\n",
(uint32_t)hccr, (uint32_t)hcor,
(uint32_t)HC_LENGTH(ehci_readl(&hccr->cr_capbase)));
return 0;
}
static int __init mv_usb_init(void)
{
int status, dev, num, isHost;
char* name_ptr;
struct platform_device* mv_usb_dev_ptr;
num = mvCtrlUsbMaxGet();
for(dev=0; dev<num; dev++)
{
#if defined(CONFIG_MV78200) || defined(CONFIG_MV632X)
if (MV_FALSE == mvSocUnitIsMappedToThisCpu(USB0+dev))
{
printk(KERN_INFO"USB %d is not mapped to this CPU\n", dev);
continue;
}
#endif
if (MV_FALSE == mvCtrlPwrClckGet(USB_UNIT_ID, dev))
{
printk("\nWarning Integrated USB %d is Powered Off\n",dev);
continue;
}
isHost = mvIsUsbHost & (1 << dev);
if(isHost)
{
name_ptr = usb_host_name;
}
else
{
name_ptr = usb_dev_name;
}
status = mvUsbInit(dev, isHost);
mv_usb_dev_ptr = kmalloc(sizeof(struct platform_device), GFP_KERNEL);
if(mv_usb_dev_ptr == NULL)
{
printk("Can't allocate platform_device structure - %d bytes\n",
sizeof(struct platform_device) );
return 1;
}
memset(mv_usb_dev_ptr, 0, sizeof(struct platform_device) );
mv_usb_dev_ptr->name = name_ptr;
mv_usb_dev_ptr->id = PCI_VENDOR_ID_MARVELL | (MV_USB_VERSION << 16) | (dev << 24);
mv_usb_dev_ptr->num_resources = 2;
mv_usb_dev_ptr->resource = (struct resource*)kmalloc(2*sizeof(struct resource), GFP_KERNEL);
if(mv_usb_dev_ptr->resource == NULL)
{
printk("Can't allocate 2 resource structure - %d bytes\n",
2*sizeof(struct resource) );
return 1;
}
memset(mv_usb_dev_ptr->resource, 0, 2*sizeof(struct resource));
mv_usb_dev_ptr->resource[0].start =
( INTER_REGS_BASE | MV_USB_CORE_CAP_LENGTH_REG(dev));
mv_usb_dev_ptr->resource[0].end =
((INTER_REGS_BASE | MV_USB_CORE_CAP_LENGTH_REG(dev)) + 4096);
mv_usb_dev_ptr->resource[0].flags = IORESOURCE_DMA;
mv_usb_dev_ptr->resource[1].start = IRQ_USB_CTRL(dev);
mv_usb_dev_ptr->resource[1].flags = IORESOURCE_IRQ;
mv_usb_dev_ptr->dev.dma_mask = kmalloc(sizeof(u64), GFP_KERNEL);
*mv_usb_dev_ptr->dev.dma_mask = MV_USB_DMA_MASK;
mv_usb_dev_ptr->dev.coherent_dma_mask = ~0;
mv_usb_dev_ptr->dev.release = mv_usb_release;
strncpy(mv_usb_dev_ptr->dev.bus_id, usb_bus_name, BUS_ID_SIZE);
printk("Marvell USB EHCI %s controller #%d: %p\n",
isHost ? "Host" : "Gadget", dev, mv_usb_dev_ptr);
status = platform_device_register(mv_usb_dev_ptr);
if (status)
{
printk("Can't register Marvell USB EHCI controller #%d, status=%d\n",
dev, status);
return status;
}
}
return 0;
}
int do_active_units(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
MV_U32 cpuNum, egigaNum, pexNum;
MV_U32 i;
printf("Active: ");
/* CPU */
cpuNum = mvCtrlGetCpuNum();
for (i = 0; i <= cpuNum; i++) {
if (i)
printf(", ");
printf("cpu%d", i);
}
/* PEX */
pexNum = mvCtrlPexActiveUnitNumGet();
for (i = 0; i < pexNum; i++)
printf(", pex%d", i);
/* EGIGA */
egigaNum = mvCtrlEthMaxPortGet();
for (i = 0; i < egigaNum; i++) {
if (mvBoardIsEthActive(i) == MV_TRUE)
printf(", egiga%d", i);
}
#ifdef MV_USB
/* USB */
MV_U32 usbNum = mvCtrlUsbMaxGet() + mvCtrlUsb3MaxGet();
for (i = 0; i < usbNum; i++)
printf(", usb%d", i);
#endif
/* SDIO */
#ifdef CONFIG_MRVL_MMC
if (mvCtrlSdioSupport() == MV_TRUE)
printf(", mmc0");
#endif
/* SATA */
#if defined(MV_INCLUDE_INTEG_SATA)
MV_U32 sataNum = mvCtrlSataMaxPortGet();
for (i = 0; i < sataNum; i++)
printf(", sata%d", i);
#endif
/* SPI */
#if defined(MV_INCLUDE_SPI)
printf(", spi");
#endif
/* NAND */
#if defined(MV_NAND)
printf(", nand");
#endif
/* I2C */
#if defined(MV_INCLUDE_TWSI)
printf(", i2c0");
#endif
#if defined (MV_INCLUDE_TDM)
/* TDM */
if (mvBoardSlicUnitTypeGet() != MV_BOARD_SLIC_DISABLED)
printf(", tdm0");
#endif
printf("\n");
return 0;
}
static int __init mv_usb_init(void)
{
int status, dev, num, isHost;
char* name_ptr;
struct platform_device* mv_usb_dev_ptr;
int irq_num[3] = { IRQ_AURORA_USB0,
IRQ_AURORA_USB1,
IRQ_AURORA_USB2};
num = mvCtrlUsbMaxGet();
if (num > MAX_USB_PORTS) {
printk("WARNING: Limited USB ports number to %d\n", MAX_USB_PORTS);
num = MAX_USB_PORTS;
}
for(dev=0; dev<num; dev++)
{
if (MV_FALSE == mvCtrlPwrClckGet(USB_UNIT_ID, dev))
{
printk("\nWarning Integrated USB %d is Powered Off\n",dev);
continue;
}
/* Check if this USB is mapped to this AMP group - YY */
if(MV_FALSE == mvUnitMapIsMine(USB0 + dev))
{
continue;
}
isHost = mvIsUsbHost & (1 << dev);
if(isHost)
name_ptr = usb_host_name;
else
name_ptr = usb_dev_name;
printk("registered dev#%d asa %s\n",dev,name_ptr);
status = mvSysUsbInit(dev, isHost);
mv_usb_dev_ptr = kmalloc(sizeof(struct platform_device), GFP_KERNEL);
if(mv_usb_dev_ptr == NULL)
{
printk("Can't allocate platform_device structure - %d bytes\n",
sizeof(struct platform_device) );
return 1;
}
memset(mv_usb_dev_ptr, 0, sizeof(struct platform_device) );
mv_usb_dev_ptr->name = name_ptr;
mv_usb_dev_ptr->id = dev;
mv_usb_dev_ptr->num_resources = 2;
mv_usb_dev_ptr->resource = (struct resource*)kmalloc(2*sizeof(struct resource), GFP_KERNEL);
if(mv_usb_dev_ptr->resource == NULL)
{
printk("Can't allocate 2 resource structure - %d bytes\n",
2*sizeof(struct resource) );
kfree(mv_usb_dev_ptr);
return 1;
}
memset(mv_usb_dev_ptr->resource, 0, 2*sizeof(struct resource));
mv_usb_dev_ptr->resource[0].start =
( INTER_REGS_BASE | MV_USB_CORE_CAP_LENGTH_REG(dev));
mv_usb_dev_ptr->resource[0].end =
((INTER_REGS_BASE | MV_USB_CORE_CAP_LENGTH_REG(dev)) + 4096);
mv_usb_dev_ptr->resource[0].flags = IORESOURCE_DMA;
mv_usb_dev_ptr->resource[1].start = irq_num[dev];
mv_usb_dev_ptr->resource[1].flags = IORESOURCE_IRQ;
mv_usb_dev_ptr->dev.dma_mask = kmalloc(sizeof(u64), GFP_KERNEL);
*mv_usb_dev_ptr->dev.dma_mask = MV_USB_DMA_MASK;
mv_usb_dev_ptr->dev.coherent_dma_mask = ~0;
mv_usb_dev_ptr->dev.release = mv_usb_release;
dev_set_name(&mv_usb_dev_ptr->dev, "%s", usb_bus_name);
printk("Marvell USB %s controller #%d: %p\n",
isHost ? "EHCI Host" : "Gadget", dev, mv_usb_dev_ptr);
status = platform_device_register(mv_usb_dev_ptr);
if (status)
{
printk("Can't register Marvell USB EHCI controller #%d, status=%d\n",
dev, status);
return status;
}
}
return 0;
}
/*******************************************************************************
* mvSysUsbHalInit - Initialize the USB subsystem
*
* DESCRIPTION:
*
* INPUT:
* None
* OUTPUT:
* None
* RETURN:
* None
*
*******************************************************************************/
MV_STATUS mvSysUsbInit(MV_VOID)
{
MV_USB_HAL_DATA halData;
MV_STATUS status = MV_OK;
MV_U32 dev;
MV_UNIT_WIN_INFO addrWinMap[MAX_TARGETS + 1];
halData.ctrlModel = mvCtrlModelGet();
halData.ctrlRev = mvCtrlRevGet();
halData.ctrlFamily = mvCtrlDevFamilyIdGet(halData.ctrlModel);
status = mvCtrlAddrWinMapBuild(addrWinMap, MAX_TARGETS + 1);
#ifdef CONFIG_USB_EHCI
MV_BOOL isHost;
char envname[10], *env;
int maxUsbPorts = mvCtrlUsbMaxGet();
/* for ALP/A375: if using single usb2 port, use Virtual MAC ID since
MAC ID0 (usbActive =0) is connected to Physical MAC ID1 */
int id, mac_id[2] = {1, 0};
for (id = 0; id < maxUsbPorts ; id++) {
if (mvBoardIsUsbPortConnected(USB_UNIT_ID,id) == MV_FALSE)
continue;
if (maxUsbPorts == 1 && (halData.ctrlFamily == MV_88F67X0 ||
(halData.ctrlRev == MV_88F66XX_A0_ID && halData.ctrlFamily == MV_88F66X0)))
dev = mac_id[id];
else
dev = id;
sprintf(envname, "usb%dMode", dev);
env = getenv(envname);
if ((!env) || (strcmp(env, "device") == 0) || (strcmp(env, "Device") == 0))
isHost = MV_FALSE;
else
isHost = MV_TRUE;
if (status == MV_OK) /* Map DDR windows to EHCI */
#ifdef CONFIG_USB_XHCI_HCD
/* CONFIG_USB_XHCI_HCD indicate that both xHCI and eHCI are compiled:
* Last Boolean argument is used to indicate the HAL layer which unit is currently initiated */
status = mvUsbWinInit(dev, addrWinMap, MV_FALSE);
#else
status = mvUsbWinInit(dev, addrWinMap);
#endif
if (status == MV_OK)
status = mvUsbHalInit(dev, isHost, &halData);
if (status == MV_OK)
printf("USB2.0 %d: %s Mode\n", dev, (isHost == MV_TRUE ? "Host" : "Device"));
else
mvOsPrintf("%s: Error: USB2.0 initialization failed (port %d).\n", __func__, dev);
}
#endif
#ifdef CONFIG_USB_XHCI
MV_U32 reg;
for (dev = 0; dev < mvCtrlUsb3HostMaxGet(); dev++) {
if (mvBoardIsUsbPortConnected(USB3_UNIT_ID,dev) == MV_FALSE)
continue;
status = mvUsbUtmiPhyInit(dev, &halData);
if (halData.ctrlFamily == MV_88F66X0 || halData.ctrlFamily == MV_88F67X0) {
/* ALP/A375: Set UTMI PHY Selector:
* - Connect UTMI PHY to USB2 port of USB3 Host
* - Powers down the other unit (so USB3.0 unit's registers are accessible) */
reg = MV_REG_READ(USB_CLUSTER_CONTROL);
reg = (reg & (~0x1)) | 0x1;
MV_REG_WRITE(USB_CLUSTER_CONTROL, reg);
}
if (status == MV_OK) /* Map DDR windows to XHCI */
status = mvUsbWinInit(mvCtrlUsbMapGet(USB3_UNIT_ID, dev), addrWinMap, MV_TRUE);
if (status == MV_OK)
printf("USB3.0 %d: Host Mode\n", mvCtrlUsbMapGet(USB3_UNIT_ID, dev));
else
mvOsPrintf("%s: Error: USB3.0 initialization failed (port %d).\n", __func__,
mvCtrlUsbMapGet(USB3_UNIT_ID, dev));
}
#endif
return status;
}
static int __init mv_usb_init(void)
{
int status, dev, num, isHost;
char* name_ptr;
struct platform_device* mv_usb_dev_ptr;
if(mvCtrlModelRevGet() == MV_5181L_A0_ID) {
/* metal problem */
return 0;
}
num = mvCtrlUsbMaxGet();
for(dev=0; dev<num; dev++)
{
isHost = mvIsUsbHost & (1 << dev);
if(isHost)
{
name_ptr = usb_host_name;
}
else
{
name_ptr = usb_dev_name;
}
status = mvUsbInit(dev, isHost);
mv_usb_dev_ptr = kmalloc(sizeof(struct platform_device), GFP_KERNEL);
if(mv_usb_dev_ptr == NULL)
{
printk("Can't allocate platform_device structure - %d bytes\n",
sizeof(struct platform_device) );
return 1;
}
memset(mv_usb_dev_ptr, 0, sizeof(struct platform_device) );
mv_usb_dev_ptr->name = name_ptr;
mv_usb_dev_ptr->id = MV_USB_DEVICE_ID | (dev << 16);
mv_usb_dev_ptr->num_resources = 2;
mv_usb_dev_ptr->resource = (struct resource*)kmalloc(2*sizeof(struct resource), GFP_KERNEL);
if(mv_usb_dev_ptr->resource == NULL)
{
printk("Can't allocate 2 resource structure - %d bytes\n",
2*sizeof(struct resource) );
return 1;
}
memset(mv_usb_dev_ptr->resource, 0, 2*sizeof(struct resource));
mv_usb_dev_ptr->resource[0].start =
( INTER_REGS_BASE | MV_USB_CORE_CAP_LENGTH_REG(dev));
mv_usb_dev_ptr->resource[0].end =
((INTER_REGS_BASE | MV_USB_CORE_CAP_LENGTH_REG(dev)) + 4096);
mv_usb_dev_ptr->resource[0].flags = IORESOURCE_MEM;
mv_usb_dev_ptr->resource[1].start = IRQ_USB_CTRL(dev);
mv_usb_dev_ptr->resource[1].flags = IORESOURCE_IRQ;
mv_usb_dev_ptr->dev.dma_mask = kmalloc(sizeof(u64), GFP_KERNEL);
*mv_usb_dev_ptr->dev.dma_mask = MV_USB_DMA_MASK;
mv_usb_dev_ptr->dev.coherent_dma_mask = ~0;
mv_usb_dev_ptr->dev.release = mv_usb_release;
strncpy(mv_usb_dev_ptr->dev.bus_id, usb_bus_name, BUS_ID_SIZE);
printk("Marvell USB EHCI %s controller #%d: %p\n",
isHost ? "Host" : "Gadget", dev, mv_usb_dev_ptr);
status = platform_device_register(mv_usb_dev_ptr);
if (status)
{
printk("Can't register Marvell USB EHCI controller #%d, status=%d\n",
dev, status);
return status;
}
}
return 0;
}
/*******************************************************************************
* mvUsbAddrDecShow - Print the USB address decode map.
*
* DESCRIPTION:
* This function print the USB address decode map.
*
* INPUT:
* None.
*
* OUTPUT:
* None.
*
* RETURN:
* None.
*
*******************************************************************************/
MV_VOID mvUsbAddrDecShow(MV_VOID)
{
MV_UNIT_WIN_INFO addrDecWin;
int i, winNum;
mvOsOutput( "\n" );
mvOsOutput( "USB:\n" );
mvOsOutput( "----\n" );
for(i=0; i<mvCtrlUsbMaxGet(); i++)
{
mvOsOutput( "Device %d:\n", i);
for(winNum = 0; winNum < MV_USB_MAX_ADDR_DECODE_WIN; winNum++)
{
memset(&addrDecWin, 0, sizeof(MV_DEC_WIN) );
mvOsOutput( "win%d - ", winNum );
if( mvUsbWinRead(i, winNum, &addrDecWin ) == MV_OK )
{
if( addrDecWin.enable )
{
/* In MV88F6781 there is no differentiation between different DRAM Chip Selects, */
/* they all use the same target ID and attributes. So in order to print correctly */
/* we use i as the target. When i is 1 it is SDRAM_CS1 etc. */
if (mvCtrlTargetByWinInfoGet(&addrDecWin) != SDRAM_CS0) {
mvOsOutput( "%s base %08x, ",
mvCtrlTargetNameGet(mvCtrlTargetByWinInfoGet(&addrDecWin)), addrDecWin.addrWin.baseLow );
}
else {
mvOsOutput( "%s base %08x, ",
mvCtrlTargetNameGet(winNum), addrDecWin.addrWin.baseLow);
}
mvSizePrint( addrDecWin.addrWin.size );
#if defined(MV645xx) || defined(MV646xx)
switch( addrDecWin.addrWinAttr.swapType)
{
case MV_BYTE_SWAP:
mvOsOutput( "BYTE_SWAP, " );
break;
case MV_NO_SWAP:
mvOsOutput( "NO_SWAP , " );
break;
case MV_BYTE_WORD_SWAP:
mvOsOutput( "BYTE_WORD_SWAP, " );
break;
case MV_WORD_SWAP:
mvOsOutput( "WORD_SWAP, " );
break;
default:
mvOsOutput( "SWAP N/A , " );
}
switch( addrDecWin.addrWinAttr.cachePolicy )
{
case NO_COHERENCY:
mvOsOutput( "NO_COHERENCY , " );
break;
case WT_COHERENCY:
mvOsOutput( "WT_COHERENCY , " );
break;
case WB_COHERENCY:
mvOsOutput( "WB_COHERENCY , " );
break;
default:
mvOsOutput( "COHERENCY N/A, " );
}
switch( addrDecWin.addrWinAttr.pcixNoSnoop )
{
case 0:
mvOsOutput( "PCI-X NS inactive, " );
break;
case 1:
mvOsOutput( "PCI-X NS active , " );
break;
default:
mvOsOutput( "PCI-X NS N/A , " );
}
switch( addrDecWin.addrWinAttr.p2pReq64 )
{
case 0:
mvOsOutput( "REQ64 force" );
break;
case 1:
mvOsOutput( "REQ64 detect" );
break;
default:
mvOsOutput( "REQ64 N/A" );
}
#endif /* MV645xx || MV646xx */
mvOsOutput( "\n" );
}
else
mvOsOutput( "disable\n" );
}
}
}
}
