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;
}
