void ap6210_gpio_init(void) { struct ap6210_gpio_wifi_ops *ops = &ap6210_wifi_select_pm_ops; int ap6210_lpo = 0; /* CT expected ap6210_lpo as a GPIO */ ap6210_lpo = gpio_request_ex(wifi_para, "ap6xxx_lpo"); if (!ap6210_lpo) { AP6210_ERR("request lpo gpio failed.\n" ); return; } if(ap6210_lpo) { AP6210_DEBUG("config 32k clock.\n" ); ap6210_cfg_gpio_32k_clkout(ap6210_lpo); } ap6210_wl_regon = gpio_request_ex(wifi_para, "ap6xxx_wl_regon"); if (!ap6210_wl_regon) { AP6210_ERR("request wl_regon gpio failed.\n" ); return; } ap6210_bt_regon = gpio_request_ex(wifi_para, "ap6xxx_bt_regon"); if (!ap6210_bt_regon) { AP6210_ERR("request ap6210_bt_regon gpio failed.\n" ); return; } ops->gpio_ctrl = ap6210_gpio_ctrl; ops->power = ap6210_power; }
static int gmac_system_init(struct gmac_priv *priv) { int ret = 0; #ifndef CONFIG_GMAC_SCRIPT_SYS if(priv->gpiobase){ writel(0x55555555, priv->gpiobase + PA_CFG0); writel(0x50555505, priv->gpiobase + PA_CFG1); writel(0x00000005, priv->gpiobase + PA_CFG2); } #else priv->gpio_handle = gpio_request_ex("gmac_para", NULL); if(!priv->gpio_handle) { pr_warning("twi0 request gpio fail!\n"); ret = -1; } priv->phy_power_en = gpio_request_ex("gmac_phy_power", "gmac_phy_power_en"); if(!priv->phy_power_en) { pr_warning("phy power enable request gpio fail!\n"); ret = -1; } #endif return ret; }
/* Init driver */ static int __init dht22_sun5i_init_driver() { int err = 0; int dht22_used = 0; script_gpio_set_t info; dht22_sun5i_proc = proc_mkdir("dht22", NULL); create_proc_read_entry("raw_data", 0444, dht22_sun5i_proc, dht22_sun5i_proc_read, NULL); err = script_parser_fetch("dht22_para", "dht22_used", &dht22_used, sizeof (dht22_used) / sizeof (int)); if (!dht22_used || err) { printk(KERN_INFO "%s: dht22-bus is not used in config\n", __FUNCTION__); return -EINVAL; } err = script_parser_fetch("dht22_para", "dht22_pin", (int *) &info, sizeof (script_gpio_set_t)); if (err) { printk(KERN_INFO "%s: can not get \"dht22_para\" \"dht22_pin\" gpio handler, already used by others?", __FUNCTION__); return -EBUSY; } dht22_sun5i_gpio_handler = gpio_request_ex("dht22_para", "dht22_pin"); dht22_sun5i_gpio_direction = PIN_DIR_OUT; PIN_DIR(PIN_DIR_OUT); return 0; }
static int __init sndspdif_codec_init(void) { int ret, spdif_used = 0; ret = script_parser_fetch("spdif_para", "spdif_used", &spdif_used, 1); if (ret != 0 || !spdif_used) return -ENODEV; spd_gpio_hdle = gpio_request_ex("spdif_para", "spdif_dout"); if (0 == spd_gpio_hdle) { pr_err("try to request spdif_para gpio failed\n"); return -1; } ret = platform_device_register(&sndspdif_codec_device); if (ret < 0) return ret; ret = platform_driver_register(&sndspdif_codec_driver); if (ret < 0) { platform_device_unregister(&sndspdif_codec_device); return ret; } return 0; }
static int __init sun5i_spdif_init(void) { int err = 0; int ret; ret = script_parser_fetch("spdif_para","spdif_used", &spdif_used, sizeof(int)); if (ret) { printk("[SPDIF]sun5i_spdif_init fetch spdif using configuration failed\n"); } if (spdif_used) { spdif_handle = gpio_request_ex("spdif_para", NULL); if((platform_device_register(&sun5i_spdif_device))<0) return err; if ((err = platform_driver_register(&sun5i_spdif_driver)) < 0) return err; } else { printk("[SPDIF]sun5i-spdif cannot find any using configuration for controllers, return directly!\n"); return 0; } return 0; }
static int aw_set_gpio_mode(void) { //int reg_val; //config gpio to io mode printk("config gpio to io mode. \n"); #ifndef GPIO_ENABLE reg_val = readl(gpio_addr + PIOI_CFG3_OFFSET); reg_val &= (~(7<<20)); //reg_val |= (0<<20); writel(reg_val,gpio_addr + PIOI_CFG3_OFFSET); #else if(gpio_hdle) { gpio_release(gpio_hdle, 2); } gpio_hdle = gpio_request_ex("tp_para", "tp_io_port"); if(!gpio_hdle) { printk("request tp_io_port failed. \n"); } #endif return 0; }
static int sw_serial_get_resource(struct sw_serial_port *sport) { char name[16]; struct clk *pclk = NULL; char uart_para[16]; int ret; /* get register base */ sport->mmres = platform_get_resource(sport->pdev, IORESOURCE_MEM, 0); if (!sport->mmres) { ret = -ENODEV; goto err_out; } /* get clock */ pclk = clk_get(&sport->pdev->dev, "apb1"); if (IS_ERR(pclk)) { ret = PTR_ERR(pclk); goto iounmap; } sport->sclk = clk_get_rate(pclk); clk_put(pclk); sprintf(name, "apb_uart%d", sport->port_no); sport->clk = clk_get(&sport->pdev->dev, name); if (IS_ERR(sport->clk)) { ret = PTR_ERR(sport->clk); goto iounmap; } clk_enable(sport->clk); /* get irq */ sport->irq = platform_get_irq(sport->pdev, 0); if (sport->irq == 0) { ret = -EINVAL; goto free_pclk; } /* get gpio resource */ sprintf(uart_para, "uart_para%d", sport->port_no); sport->pio_hdle = gpio_request_ex(uart_para, NULL); if (!sport->pio_hdle) { ret = -EINVAL; goto free_pclk; } return 0; free_pclk: clk_put(sport->clk); iounmap: err_out: return ret; }
static int sw_ahci_start(struct device *dev, void __iomem *addr) { struct clk *hclk; struct clk *mclk; u32 pio_hdle = 0; int ctrl = 0; int rc = 0; script_parser_fetch(sw_ahci_para_name, sw_ahci_used_name, &ctrl, sizeof(int)); if(!ctrl) { dev_err(dev, "AHCI is disable\n"); rc = -EINVAL; goto err2; } /*Enable mclk and hclk for AHCI*/ mclk = clk_get(dev, sw_ahci_mclk_name); if (IS_ERR(mclk)) { dev_err(dev, "Error to get module clk for AHCI\n"); rc = -EINVAL; goto err2; } hclk = clk_get(dev, sw_ahci_hclk_name); if (IS_ERR(hclk)) { dev_err(dev, "Error to get ahb clk for AHCI\n"); rc = -EINVAL; goto err1; } /*Enable SATA Clock in SATA PLL*/ ahci_writel(CCMU_PLL6_VBASE, 0, ahci_readl(CCMU_PLL6_VBASE, 0)|(0x1<<14)); clk_enable(mclk); clk_enable(hclk); sw_ahci_phy_init((unsigned int)addr); pio_hdle = gpio_request_ex(sw_ahci_para_name, NULL); if(pio_hdle) { gpio_write_one_pin_value(pio_hdle, 1, sw_ahci_gpio_name); gpio_release(pio_hdle, 2); } clk_put(hclk); err1: clk_put(mclk); err2: return rc; }
static int __init sun4i_vibrator_init(void) { int vibe_used; int err = -1; pr_info("hello, sun4i_vibrator init\n"); err = script_parser_fetch("motor_para", "motor_used", &vibe_used, sizeof(vibe_used)/sizeof(int)); if(err) { pr_err("%s script_parser_fetch \"motor_para\" \"motor_used\" error = %d\n", __FUNCTION__, err); goto exit; } if(!vibe_used) { pr_err("%s motor is not used in config\n", __FUNCTION__); err = -1; goto exit; } err = script_parser_fetch("motor_para", "motor_shake", (int *)&vibe_gpio, sizeof(vibe_gpio)/sizeof(int)); if(err) { pr_err("%s script_parser_fetch \"motor_para\" \"motor_shaked\" error = %d\n", __FUNCTION__, err); goto exit; } vibe_off = vibe_gpio.data; pr_debug("vibe_off is %d\n", vibe_off); vibe_gpio_handler = gpio_request_ex("motor_para", "motor_shake"); if(!vibe_gpio_handler) { pr_err("%s request motor gpio err\n", __FUNCTION__); err = -1; goto exit; } INIT_WORK(&vibrator_work, update_vibrator); spin_lock_init(&vibe_lock); vibe_state = 0; hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; timed_output_dev_register(&sun4i_vibrator); exit: return err; }
/* ************************************************************************************************************ * * function * * name : * * parmeters : * * return : * * note : 作用:初始化用户配置的gpio * * ************************************************************************************************************ */ int gpio_control(void) { int ret; int used; ret = script_parser_fetch("boot_init_gpio", "used", &used, sizeof(int) / 4); if (!ret && used) { puts("user_gpio config\n"); gpio_request_ex("boot_init_gpio", NULL); puts("user_gpio ok\n"); return 0; } return 0; }
static void sw_bt_fetch_para(void) { int bt_used = -1; printk("=========bt fetch-para============\n"); if(SCRIPT_PARSER_OK != script_parser_fetch("bt_para", "bt_used", &bt_used, 1)){ return; } if(1 != bt_used){ return; } gpio_int_hdle = gpio_request_ex("bt_para", "bt_gpio"); if(!gpio_int_hdle) { pr_warning(" BT gpio_para request gpio fail!\n"); return; } gpio_wakeup_hdle = gpio_request_ex("bt_para", "bt_wakeup"); if(!gpio_wakeup_hdle) { bt_wakeup_enable = 0; }else{ bt_wakeup_enable = 1; } printk("bt_wakeup_enable = %d. \n", bt_wakeup_enable); gpio_reset_hdle = gpio_request_ex("bt_para", "bt_rst"); if(!gpio_reset_hdle) { bt_reset_enable = 0; }else{ bt_reset_enable = 1; } printk("bt_reset_enable = %d. \n", bt_reset_enable); }
/* ************************************************************************************************************ * * function * * name : * * parmeters : * * return : * * note : 作用:初始化用户配置的gpio 主键:[boot_init_gpio] * * ************************************************************************************************************ */ int gpio_control(void) { int ret; int use_data; ret = script_parser_fetch("boot_init_gpio", "use", &use_data, sizeof(int) / 4); if (!ret) { if (use_data) { puts("user_gpio config\n"); gpio_request_ex("boot_init_gpio", NULL); puts("user_gpio ok\n"); return 0; } } printf("donn't initialize ther user_gpio (main_key:boot_init_gpio)\n"); return 0; }
/* Request pin from platform code and setup its sysfs name */ static int sunxi_gpio_request(struct gpio_chip *chip, unsigned offset) { int eint = 0; unsigned long flags; struct sunxi_gpio_chip *sgpio = to_sunxi_gpio(chip); if ((offset > chip->ngpio - 1) || (offset < 0)) return -EINVAL; /* Set sysfs exported gpio name (example "gpio254") */ sprintf((char *)(chip->names[offset]), "gpio%d", offset+chip->base); sgpio->data[offset].gpio_handler = gpio_request_ex("gpio_para", sgpio->data[offset].pin_name); if (!sgpio->data[offset].gpio_handler) { pr_err("%s can't request '[gpio_para]' '%s', already used ?", __func__, sgpio->data[offset].pin_name); return -EINVAL; } /* Save eint in gpio data for irq -> gpio conversion */ eint = sunxi_find_gpio_irq(chip, offset); sgpio->data[offset].eint_mux = -1; if (eint >= 0) { sgpio->data[offset].eint_mux = gpio_eint_list[eint].mux; gpio_eint_list[eint].gpio = offset; } /* Set gpio input mode (gpiolib initial mode) */ spin_lock_irqsave(&sgpio->irq_lock, flags); SUNXI_SET_GPIO_MODE(sgpio->gaddr, sgpio->data[offset].info.port, sgpio->data[offset].info.port_num, SUNXI_GPIO_INPUT); sgpio->data[offset].info.mul_sel = SUNXI_GPIO_INPUT; spin_unlock_irqrestore(&sgpio->irq_lock, flags); return 0; }
static int aw_set_irq_mode(void) { int reg_val; //config gpio to int mode printk("config gpio to int mode. \n"); #ifndef GPIO_ENABLE reg_val = readl(gpio_addr + PIOI_CFG3_OFFSET); reg_val &= (~(7<<20)); reg_val |= (3<<20); writel(reg_val,gpio_addr + PIOI_CFG3_OFFSET); #else if(gpio_hdle) { gpio_release(gpio_hdle, 2); } gpio_hdle = gpio_request_ex("tp_para", "tp_int_port"); if(!gpio_hdle) { printk("request tp_int_port failed. \n"); } #endif //Config IRQ_EINT29 Negative Edge Interrupt reg_val = readl(gpio_addr + PIO_INT_CFG3_OFFSET); reg_val &=(~(7<<20)); reg_val |=(1<<20); writel(reg_val,gpio_addr + PIO_INT_CFG3_OFFSET); aw_clear_penirq(); //Enable IRQ_EINT29 of PIO Interrupt reg_val = readl(gpio_addr + PIO_INT_CTRL_OFFSET); reg_val |=(1<<IRQ_EINT29); writel(reg_val,gpio_addr + PIO_INT_CTRL_OFFSET); mdelay(2); return 0; }
static void sw_ahci_stop(struct device *dev) { struct clk *hclk; struct clk *mclk; u32 pio_hdle = 0; int rc = 0; mclk = clk_get(dev, sw_ahci_mclk_name); if (IS_ERR(mclk)) { dev_err(dev, "Error to get module clk for AHCI\n"); rc = -EINVAL; goto err2; } hclk = clk_get(dev, sw_ahci_hclk_name); if (IS_ERR(hclk)) { dev_err(dev, "Error to get ahb clk for AHCI\n"); rc = -EINVAL; goto err1; } pio_hdle = gpio_request_ex(sw_ahci_para_name, NULL); if(pio_hdle) { gpio_write_one_pin_value(pio_hdle, 0, sw_ahci_gpio_name); gpio_release(pio_hdle, 2); } /*Disable mclk and hclk for AHCI*/ clk_disable(mclk); clk_disable(hclk); clk_put(hclk); err1: clk_put(mclk); err2: return;// rc; }
static int __init sun4i_i2s_init(void) { int err = 0; int ret; ret = script_parser_fetch("i2s_para","i2s_used", &i2s_used, sizeof(int)); if (ret) { printk("[I2S]sun4i_i2s_init fetch i2s using configuration failed\n"); } if (i2s_used) { i2s_handle = gpio_request_ex("i2s_para", NULL); if((err = platform_device_register(&sun4i_i2s_device)) < 0) return err; if ((err = platform_driver_register(&sun4i_i2s_driver)) < 0) return err; } else { printk("[I2S]sun4i-i2s cannot find any using configuration for controllers, return directly!\n"); return 0; } return 0; }
static int __devinit gpio_sw_probe(struct platform_device *dev) { struct gpio_sw *gpio; struct gpio_sw_platdata *pdata = dev->dev.platform_data; unsigned int irq_ctl; int ret; char io_area[16]; gpio = kzalloc(sizeof(struct gpio_sw), GFP_KERNEL); GPIO_SW_DEBUG("kzalloc ok !\n"); if (gpio == NULL) { dev_err(&dev->dev, "No memory for device\n"); return -ENOMEM; } platform_set_drvdata(dev, gpio); GPIO_SW_DEBUG("platform_set_drvdata ok !\n"); gpio->pdata = pdata; gpio->cdev.pio_hdle = gpio_request_ex("gpio_para", pdata->name); GPIO_SW_DEBUG("pio_hdle is %x \n",gpio->cdev.pio_hdle); GPIO_SW_DEBUG("gpio_num = %s\n",pdata->name); GPIO_SW_DEBUG("pd->name = %s\n",gpio->pdata->name); gpio->cdev.port = get_gpio_member_value(gpio->cdev.pio_hdle,pdata->name,port_5 ); gpio->cdev.port_num = get_gpio_member_value(gpio->cdev.pio_hdle,pdata->name,port_num_6 ); gpio->cdev.mul_sel = get_gpio_member_value(gpio->cdev.pio_hdle,pdata->name,mul_sel_1 ); gpio->cdev.pull = get_gpio_member_value(gpio->cdev.pio_hdle,pdata->name,pull_2 ); gpio->cdev.drv_level = get_gpio_member_value(gpio->cdev.pio_hdle,pdata->name,drv_level_3 ); gpio->cdev.data = get_gpio_member_value(gpio->cdev.pio_hdle,pdata->name,data_4 ); gpio->cdev.irq_type = 0x0; sprintf(io_area,"P%c%d",gpio->cdev.port+'A'-1,gpio->cdev.port_num); GPIO_SW_DEBUG("io_area is %s \n",io_area); gpio->cdev.gpio_sw_cfg_set = gpio_sw_cfg_set; gpio->cdev.gpio_sw_pull_set = gpio_sw_pull_set; gpio->cdev.gpio_sw_data_set = gpio_sw_data_set; gpio->cdev.gpio_sw_drv_level_set = gpio_sw_drv_level_set; gpio->cdev.gpio_sw_cfg_get = gpio_sw_cfg_get; gpio->cdev.gpio_sw_pull_get = gpio_sw_pull_get; gpio->cdev.gpio_sw_data_get = gpio_sw_data_get; gpio->cdev.gpio_sw_drv_level_get = gpio_sw_drv_level_get; gpio->cdev.name = io_area; gpio->cdev.flags |= pdata->flags; if(gpio->cdev.mul_sel == 6){ if(gpio->cdev.port== 'H' - 'A' + 1){ if((gpio->cdev.port_num >= 0) && (gpio->cdev.port_num <= 21)){ irq_ctl = REG_RD(GPIO_TEST_BASE + 0x210); __raw_writel((1 << gpio->cdev.port_num) | irq_ctl, GPIO_TEST_BASE + 0x210); gpio->cdev.irq_num = gpio->cdev.port_num + 1; all_irq_enable = 1; }else{ printk("[gpio]: this pin don`t have EINT FUNCTION\n"); kfree(gpio); return 1; } }else if(gpio->cdev.port== 'I' - 'A' + 1){ if((gpio->cdev.port_num >= 10) && (gpio->cdev.port_num <= 19)){ irq_ctl = REG_RD(GPIO_TEST_BASE + 0x210); __raw_writel((1 << (gpio->cdev.port_num + 12)) | irq_ctl, GPIO_TEST_BASE + 0x210); gpio->cdev.irq_num = gpio->cdev.port_num + 12 + 1; all_irq_enable = 1; }else{ printk("[gpio]: this pin don`t have EINT FUNCTION\n"); kfree(gpio); return 1; } } else{ printk("[gpio]: this area don`t have EINT FUNCTION\n"); kfree(gpio); return 1; } } gpio->cdev.irq=all_irq_enable; ret = gpio_sw_classdev_register(&dev->dev, &gpio->cdev); GPIO_SW_DEBUG("gpio_sw_classdev_register ok !\n"); if (ret < 0) { dev_err(&dev->dev, "gpio_sw_classdev_register failed\n"); kfree(gpio); return ret; } GPIO_SW_DEBUG("pio_hdle is %x \n",gpio->cdev.pio_hdle); GPIO_SW_DEBUG("gpio_sw_classdev_register good !\n"); return 0; }
static int sunximmc_resource_request(struct sunxi_mmc_host *smc_host) { struct platform_device *pdev = smc_host->pdev; u32 smc_no = pdev->id; char hclk_name[16] = {0}; char mclk_name[8] = {0}; char pio_para[16] = {0}; u32 pio_hdle = 0; s32 ret = 0; sprintf(pio_para, "mmc%d_para", smc_no); pio_hdle = gpio_request_ex(pio_para, NULL); if (!pio_hdle) { SMC_ERR("sdc %d request pio parameter failed\n", smc_no); goto out; } smc_host->pio_hdle = pio_hdle; //iomap smc_host->smc_base_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!smc_host->smc_base_res) { SMC_ERR("Failed to get io memory region resouce.\n"); ret = -ENOENT; goto release_pin; } /* smc address remap */ smc_host->smc_base_res = request_mem_region(smc_host->smc_base_res->start, RESSIZE(smc_host->smc_base_res), pdev->name); if (!smc_host->smc_base_res) { SMC_ERR("Failed to request io memory region.\n"); ret = -ENOENT; goto release_pin; } smc_host->smc_base = ioremap(smc_host->smc_base_res->start, RESSIZE(smc_host->smc_base_res)); if (!smc_host->smc_base) { SMC_ERR("Failed to ioremap() io memory region.\n"); ret = -EINVAL; goto free_mem_region; } //get hclock sprintf(hclk_name, "ahb_sdc%d", smc_no); smc_host->hclk = clk_get(&pdev->dev, hclk_name); if (IS_ERR(smc_host->hclk)) { ret = PTR_ERR(smc_host->hclk); SMC_ERR("Error to get ahb clk for %s\n", hclk_name); goto iounmap; } sprintf(mclk_name, "sdc%d", smc_no); smc_host->mclk = clk_get(&pdev->dev, mclk_name); if (IS_ERR(smc_host->mclk)) { ret = PTR_ERR(smc_host->mclk); SMC_ERR("Error to get clk for mux_mmc\n"); goto free_hclk; } goto out; free_hclk: clk_put(smc_host->hclk); iounmap: iounmap(smc_host->smc_base); free_mem_region: release_mem_region(smc_host->smc_base_res->start, RESSIZE(smc_host->smc_base_res)); release_pin: gpio_release(smc_host->pio_hdle, 1); out: return ret; }