Esempio n. 1
0
int clk_disable_usb(struct clk *clk)
{
	char * clk_name;
	usb_peri_reg_t * peri_a,* peri_b,*peri;
	//usb_dbg_uart_data_t uart;
	
	if(!clk)
		return -1;

	clk_name = (char*)clk->priv;
	peri_a = (usb_peri_reg_t *)P_USB_ADDR0;
	peri_b = (usb_peri_reg_t *)P_USB_ADDR8;

	if(!strcmp(clk_name,"usb0"))
		peri = peri_a;
	else if(!strcmp(clk_name,"usb1"))
		peri = peri_b;
	else{
		printk(KERN_ERR "bad usb clk name: %s\n",clk_name);
		return -1;
	}
#if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6
	switch_mod_gate_by_name(clk_name, 0);
#endif

	if(init_count){
		init_count--;
		//uart.d32 = peri->dbg_uart;
		//uart.b.set_iddq = 1;
		//peri->dbg_uart = uart.d32;
	}
	dmb();
	return 0;
}
Esempio n. 2
0
int  video_dac_disable()
{
    SET_CBUS_REG_MASK(VENC_VDAC_SETTING, 0x1f);
    switch_mod_gate_by_name("venc", 0);

    return 0;
}
/*
*power off the 656 module,clear the parameters
*/
static void am656in_feclose(struct tvin_frontend_s *fe)
{

	struct am656in_dev_s *devp = container_of(fe, am656in_dev_t, frontend);
        enum tvin_port_e port = devp->para.port;
	if((port < TVIN_PORT_BT656)||(port > TVIN_PORT_CAMERA)){
		printk("[bt656..]%s:invaild port %d.\n",__func__, port);
		return;
	}
	#ifdef CONFIG_ARCH_MESON6
	switch_mod_gate_by_name("bt656", 0);
	#endif
	memset(&devp->para, 0, sizeof(vdin_parm_t));
}
Esempio n. 4
0
static int 
ge2d_release(struct inode *inode, struct file *file)
{
	ge2d_context_t *context=(ge2d_context_t *)file->private_data;
	
	if(context && (0==destroy_ge2d_work_queue(context)))
	{
		ge2d_device.open_count--;
		if (ge2d_device.open_count == 0)
			switch_mod_gate_by_name("ge2d", 0);
		return 0;
	}
	amlog_level(LOG_LEVEL_LOW,"release one ge2d device\n");
	return -1;
}
Esempio n. 5
0
void osd_antiflicker_task_stop(void)
{
	if (!ge2d_osd_antiflicker.inited) {
		printk("osd_antiflicker_task already stopped.\n");
		return;
	}

	printk("osd_antiflicker_task stop.\n");
#if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6
	switch_mod_gate_by_name("ge2d", 0);
#endif
	if (ge2d_osd_antiflicker.ge2d_context) {
		destroy_ge2d_work_queue(ge2d_osd_antiflicker.ge2d_context);
		ge2d_osd_antiflicker.ge2d_context = NULL;
	}
	ge2d_osd_antiflicker.inited = false;
}
Esempio n. 6
0
static int 
ge2d_open(struct inode *inode, struct file *file) 
{
	 ge2d_context_t *context;
	 //we create one ge2d workqueue for this file handler.
	 
         if (ge2d_device.open_count == 0)
                switch_mod_gate_by_name("ge2d", 1);
	 if(NULL==(context=create_ge2d_work_queue()))
	 {
	 	amlog_level(LOG_LEVEL_HIGH,"can't create work queue \r\n");
		return -1;		
	 }
	 //amlog_level(LOG_LEVEL_LOW,"open one ge2d device\n");
	 file->private_data=context;
	 ge2d_device.open_count++;
	 return 0;
}
Esempio n. 7
0
int osd_clone_task_start(void)
{
	if (s_osd_clone.inited) {
		printk("osd_clone_task already started.\n");
		return 0;
	}

	printk("osd_clone_task start.\n");
#if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6
	switch_mod_gate_by_name("ge2d", 1);
#endif
	if (s_osd_clone.ge2d_context == NULL)
		s_osd_clone.ge2d_context = create_ge2d_work_queue();

	memset(&s_osd_clone.ge2d_config, 0, sizeof(config_para_ex_t));
	s_osd_clone.inited = true;

	return 0;
}
/*
*power on 656 module&init the parameters,such as color fmt...,will be used by vdin
*/
static void am656in_feopen(struct tvin_frontend_s *fe, enum tvin_port_e port)
{
	struct am656in_dev_s *am656_devp = container_of(fe, am656in_dev_t, frontend);
	struct vdin_parm_s *parm = fe->private_data;
	if((port < TVIN_PORT_BT656)||(port > TVIN_PORT_CAMERA)){
		printk("[bt656..]%s:invaild port %d.\n",__func__, port);
		return;
	}
	/*copy the param from vdin to bt656*/
	if(!memcpy(&am656_devp->para, parm, sizeof(vdin_parm_t))){
		printk("[bt656..]%s memcpy error.\n",__func__);
		return;
	}
        printk("[bt656..] %s color format %s,hsync phase %u,vsync phase %u,"\
                "frame rate %u,hs_bp %u,vs_bp %u.\n", __func__,
                tvin_color_fmt_str(parm->cfmt),parm->hsync_phase,
                parm->vsync_phase,parm->frame_rate,parm->hs_bp,parm->vs_bp);
	#ifdef CONFIG_ARCH_MESON6
	switch_mod_gate_by_name("bt656", 1);
	#endif

}
Esempio n. 9
0
int tvoutc_setmode(tvmode_t mode)
{
    const  reg_t *s;

    if (mode >= TVMODE_MAX) {
        printk(KERN_ERR "Invalid video output modes.\n");
        return -ENODEV;
    }

#if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6   
    switch_mod_gate_by_name("venc", 1);
#endif

    printk(KERN_DEBUG "TV mode %s selected.\n", tvinfoTab[mode].id);
   
    s = tvregsTab[mode];
			
    while (MREG_END_MARKER != s->reg)
        setreg(s++);
    printk("%s[%d]\n", __func__, __LINE__);
   // if (mode < TVMODE_VGA)
    set_tvmode_misc(mode);
#ifdef CONFIG_ARCH_MESON1
	tvoutc_setclk(mode);
    printk("%s[%d]\n", __func__, __LINE__);
    enable_vsync_interrupt();
#endif
#ifdef CONFIG_AM_TV_OUTPUT2
	switch(mode)
	{
		case TVMODE_480I:
		case TVMODE_480CVBS:
		case TVMODE_576I:
		case TVMODE_576CVBS:
        WRITE_CBUS_REG_BITS(VPU_VIU_VENC_MUX_CTRL, 1, 0, 2); //reg0x271a, select ENCI to VIU1
        WRITE_CBUS_REG_BITS(VPU_VIU_VENC_MUX_CTRL, 1, 4, 4); //reg0x271a, Select encI clock to VDIN            
        WRITE_CBUS_REG_BITS(VPU_VIU_VENC_MUX_CTRL, 1, 8, 4); //reg0x271a,Enable VIU of ENC_I domain to VDIN;
			  break;
		case TVMODE_480P:
		case TVMODE_576P:
		case TVMODE_720P:
		case TVMODE_720P_50HZ:
		case TVMODE_1080I: //??
		case TVMODE_1080I_50HZ: //??
		case TVMODE_1080P:
		case TVMODE_1080P_50HZ:
        WRITE_CBUS_REG_BITS(VPU_VIU_VENC_MUX_CTRL, 2, 0, 2); //reg0x271a, select ENCP to VIU1
        WRITE_CBUS_REG_BITS(VPU_VIU_VENC_MUX_CTRL, 2, 4, 4); //reg0x271a, Select encP clock to VDIN            
        WRITE_CBUS_REG_BITS(VPU_VIU_VENC_MUX_CTRL, 2, 8, 4); //reg0x271a,Enable VIU of ENC_P domain to VDIN;
        break;		    
		default:
			printk(KERN_ERR "unsupport tv mode,video clk is not set!!\n");	
	}
#endif
    
    WRITE_MPEG_REG(VPP_POSTBLEND_H_SIZE, tvinfoTab[mode].xres);

#ifdef CONFIG_ARCH_MESON3
printk(" clk_util_clk_msr 6 = %d\n", clk_util_clk_msr(6));
printk(" clk_util_clk_msr 7 = %d\n", clk_util_clk_msr(7));
printk(" clk_util_clk_msr 8 = %d\n", clk_util_clk_msr(8));
printk(" clk_util_clk_msr 9 = %d\n", clk_util_clk_msr(9));
printk(" clk_util_clk_msr 10 = %d\n", clk_util_clk_msr(10));
printk(" clk_util_clk_msr 27 = %d\n", clk_util_clk_msr(27));
printk(" clk_util_clk_msr 29 = %d\n", clk_util_clk_msr(29));
#endif

//while(1);


    return 0;
}
Esempio n. 10
0
int clk_enable_usb(struct clk *clk)
{
	int port_idx,i;
	char * clk_name;
	usb_peri_reg_t * peri_a,* peri_b,*peri;
	usb_config_data_t config;
	usb_ctrl_data_t control;
	//usb_dbg_uart_data_t uart;
	int clk_sel,clk_div,clk_src;
	int time_dly = 500; //usec
	
	if(!clk)
		return -1;

	clk_name = (char*)clk->priv;
#if MESON_CPU_TYPE >= MESON_CPU_TYPE_MESON6
	switch_mod_gate_by_name(clk_name, 1);
#endif
	peri_a = (usb_peri_reg_t *)P_USB_ADDR0;
	peri_b = (usb_peri_reg_t *)P_USB_ADDR8;

	if(!strcmp(clk_name,"usb0")){
		peri = peri_a;
		port_idx = USB_PORT_IDX_A;
	}else if(!strcmp(clk_name,"usb1")){
		peri = peri_b;
		port_idx = USB_PORT_IDX_B;
	}else{
		printk(KERN_ERR "bad usb clk name: %s\n",clk_name);
		return -1;
	}
	
	if(!init_count){
		init_count++;
		aml_set_reg32_bits(P_RESET1_REGISTER, 1, 2, 1);
		for(i = 0; i < 1000; i++)
			udelay(time_dly);

		clk_sel = USB_PHY_CLK_SEL_XTAL;
		clk_div = 1;
		clk_src = 24000000;

		config.d32 = peri_a->config;
		config.b.clk_sel = clk_sel;	
		config.b.clk_div = clk_div; 
	  	config.b.clk_en = 1;
		peri_a->config = config.d32;

		config.d32 = peri_b->config;
		config.b.clk_sel = clk_sel;	
		config.b.clk_div = clk_div; 
	  	config.b.clk_en = 1;
		peri_b->config = config.d32;
		printk(KERN_NOTICE"USB (%d) use clock source: %s\n",port_idx,clock_src_name[clk_sel]);

		control.d32 = peri_b->ctrl;
		control.b.fsel = 2;	/* PHY default is 24M (5), change to 12M (2) */
		control.b.por = 1;
		peri_b->ctrl = control.d32;
		
		control.d32 = peri_a->ctrl;
		control.b.fsel = 2;	/* PHY default is 24M (5), change to 12M (2) */
		control.b.por = 1;
		peri_a->ctrl = control.d32;
		udelay(time_dly);
		control.b.por = 0;
		peri_a->ctrl = control.d32;
		udelay(time_dly);

		/* read back clock detected flag*/
		control.d32 = peri_a->ctrl;
		if(!control.b.clk_detected){
			printk(KERN_ERR"USB (%d) PHY Clock not detected!\n",0);
		}
		control.d32 = peri_b->ctrl;
		if(!control.b.clk_detected){
			printk(KERN_ERR"USB (%d) PHY Clock not detected!\n",1);
		}
	}
	
	//uart.d32 = peri->dbg_uart;
	//uart.b.set_iddq = 0;
	//peri->dbg_uart = uart.d32;	
	
	dmb();
	return 0;
}
Esempio n. 11
0
int clk_enable_usb(struct clk *clk)
{
	int port_idx;
	char * clk_name;
	usb_peri_reg_t * peri_a,* peri_b,*peri;
	usb_config_data_t config;
	usb_ctrl_data_t control;
  usb_adp_bc_data_t adp_bc;
	int clk_sel,clk_div,clk_src;
	int time_dly = 500; //usec

	if(!clk)
		return -1;

	if(!init_count)
	{
		init_count++;
		aml_set_reg32_bits(P_RESET1_REGISTER, 1, 2, 1);
		//for(i = 0; i < 1000; i++)
		//	udelay(time_dly);
	}

	clk_name = (char*)clk->priv;
	switch_mod_gate_by_name(clk_name, 1);

	peri_a = (usb_peri_reg_t *)P_USB_ADDR0;
	peri_b = (usb_peri_reg_t *)P_USB_ADDR8;

	if(!strcmp(clk_name,"usb0")){
		peri = peri_a;
		port_idx = USB_PORT_IDX_A;
	}else if(!strcmp(clk_name,"usb1")){
		peri = peri_b;
		port_idx = USB_PORT_IDX_B;
	}else{
		printk(KERN_ERR "bad usb clk name: %s\n",clk_name);
		return -1;
	}


	clk_sel = USB_PHY_CLK_SEL_XTAL;
	clk_div = 1;
	clk_src = 24000000;

	config.d32 = peri->config;
	config.b.clk_32k_alt_sel= 1;
	peri->config = config.d32;


	printk(KERN_NOTICE"USB (%d) use clock source: %s\n",port_idx,clock_src_name[clk_sel]);

	control.d32 = peri->ctrl;
	control.b.fsel = 5;//2;	/* PHY default is 24M (5), change to 12M (2) */
	control.b.por = 1;
	peri->ctrl = control.d32;
	udelay(time_dly);
	control.b.por = 0;
	peri->ctrl = control.d32;
	udelay(time_dly);


	/* read back clock detected flag*/
	control.d32 = peri->ctrl;
	if(!control.b.clk_detected){
		printk(KERN_ERR"USB (%d) PHY Clock not detected!\n",port_idx);
	}

	/* force ACA enable */
	if(IS_MESON_M8M2_CPU && port_idx == USB_PORT_IDX_B){
		adp_bc.d32 = peri->adp_bc;
		adp_bc.b.aca_enable = 1;
		peri->adp_bc = adp_bc.d32;
		udelay(50);
		adp_bc.d32 = peri->adp_bc;
		if(adp_bc.b.aca_pin_float){
			printk(KERN_ERR "USB-B ID detect failed!\n");
			printk(KERN_ERR "Please use the chip after version RevA1!\n");
			return -1;
		}
	}
	dmb();
	return 0;
}
Esempio n. 12
0
int  video_dac_enable(unsigned char enable_mask)
{
    switch_mod_gate_by_name("venc", 1);
    CLEAR_CBUS_REG_MASK(VENC_VDAC_SETTING, enable_mask & 0x1f);
    return 0;
}
Esempio n. 13
0
/**
 * stmmac_pltfr_probe
 * @pdev: platform device pointer
 * Description: platform_device probe function. It allocates
 * the necessary resources and invokes the main to init
 * the net device, register the mdio bus etc.
 */
static int stmmac_pltfr_probe(struct platform_device *pdev)
{
	int ret = 0;
	//addr =phys_to_virt();
	   struct resource *res;
	 struct device *dev = &pdev->dev;
        void __iomem *addr = NULL;
        struct stmmac_priv *priv = NULL;
        struct plat_stmmacenet_data *plat_dat = NULL;
        const char *mac = NULL;
#ifdef CONFIG_DWMAC_MESON
	switch_mod_gate_by_name("ethernet",1);
#endif
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!res)
                return -ENODEV;

        addr = devm_ioremap_resource(dev, res);
	//addr =  ( void* )(0xfe0c0000);
	printk("ethernet base addr is %x\n", (unsigned int)addr);
	plat_dat = dev_get_platdata(&pdev->dev);
	if (pdev->dev.of_node) {
		if (!plat_dat)
			plat_dat = devm_kzalloc(&pdev->dev,
					sizeof(struct plat_stmmacenet_data),
					GFP_KERNEL);
		if (!plat_dat) {
			pr_err("%s: ERROR: no memory", __func__);
			return  -ENOMEM;
		}

		ret = stmmac_probe_config_dt(pdev, plat_dat, &mac);
		if (ret) {
			pr_err("%s: main dt probe failed", __func__);
			return ret;
		}
	}

	/* Custom setup (if needed) */
	if (plat_dat->setup) {
		plat_dat->bsp_priv = plat_dat->setup(pdev);
		if (IS_ERR(plat_dat->bsp_priv))
			return PTR_ERR(plat_dat->bsp_priv);
	}

	/* Custom initialisation (if needed)*/
	if (plat_dat->init) {
		ret = plat_dat->init(pdev, plat_dat->bsp_priv);
		if (unlikely(ret))
			return ret;
	}

	priv = stmmac_dvr_probe(&(pdev->dev), plat_dat, addr);
	if (IS_ERR(priv)) {
		pr_err("%s: main driver probe failed", __func__);
		return PTR_ERR(priv);
	}

	/* Get MAC address if available (DT) */
	if (mac)
		memcpy(priv->dev->dev_addr, mac, ETH_ALEN);

	/* Get the MAC information */
	priv->dev->irq = platform_get_irq_byname(pdev, "macirq");
	if (priv->dev->irq < 0) {
		if (priv->dev->irq != -EPROBE_DEFER) {
			netdev_err(priv->dev,
				   "MAC IRQ configuration information not found\n");
		}
		return priv->dev->irq;
	}

	/*
	 * On some platforms e.g. SPEAr the wake up irq differs from the mac irq
	 * The external wake up irq can be passed through the platform code
	 * named as "eth_wake_irq"
	 *
	 * In case the wake up interrupt is not passed from the platform
	 * so the driver will continue to use the mac irq (ndev->irq)
	 */
	priv->wol_irq = platform_get_irq_byname(pdev, "eth_wake_irq");
	if (priv->wol_irq < 0) {
		if (priv->wol_irq == -EPROBE_DEFER)
			return -EPROBE_DEFER;
		priv->wol_irq = priv->dev->irq;
	}

	priv->lpi_irq = platform_get_irq_byname(pdev, "eth_lpi");
	if (priv->lpi_irq == -EPROBE_DEFER)
		return -EPROBE_DEFER;

	platform_set_drvdata(pdev, priv->dev);

	pr_debug("STMMAC platform driver registration completed");

	return 0;
}