示例#1
0
/* init for the Master*/
void misc_init_r_dec_win(void)
{
#if defined(MV_INCLUDE_USB)
	{
		char *env;

		env = getenv("usb0Mode");
		if((!env) || (strcmp(env,"device") == 0) || (strcmp(env,"Device") == 0) )
		{
			printf("USB 0: Device Mode\n");	
			mvSysUsbInit(0, MV_FALSE);
		}
		else
		{
			printf("USB 0: Host Mode\n");	
			mvSysUsbInit(0, MV_TRUE);
		}
	}
#endif/* #if defined(MV_INCLUDE_USB) */

#if defined(MV_INCLUDE_XOR)
	mvSysXorInit();
#endif

#if defined(MV_INCLUDE_CLK_PWR_CNTRL)
	mv_set_power_scheme();
#endif

    return;
}
void misc_init_r_dec_win(void)
{
	char *env;

#if defined(MV_INCLUDE_USB)
	mvSysUsbInit();	/* initialize USB2.0 / USB3.0 */
#endif

#if defined(MV_INCLUDE_XOR)
	mvSysXorInit();
#endif

#if defined(MV_INCLUDE_CLK_PWR_CNTRL)
	env = getenv("enaClockGating");
	if ((strcmp(env, "yes") == 0) || (strcmp(env, "Yes") == 0))
		mv_set_power_scheme();
#endif
}
示例#3
0
int mv_usb_resume(int dev)
{
	int status, isHost;
	char *name_ptr;

	if (MV_FALSE == mvCtrlPwrClckGet(USB_UNIT_ID, dev)) {
		printk(KERN_DEBUG "\nWarning Integrated USB %d is Powered Off\n", dev);
		return -EINVAL;
	}

	/* Check if this USB is mapped to this AMP group - YY */
	if(MV_FALSE == mvUnitMapIsMine(USB0 + dev))
		return -EINVAL;

	isHost = mvIsUsbHost & (1 << dev);
	name_ptr = isHost ? usb_host_name : usb_dev_name;

	printk(KERN_DEBUG "registered dev#%d as a %s\n", dev, name_ptr);
	status = mvSysUsbInit(dev, isHost);

	return status;
}
示例#4
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;
}