void NAND_PIORelease(__u32 nand_index) { int cnt; script_item_u *list = NULL; //printk("[NAND] nand gpio_release\n"); if (nand_index == 0) { cnt = script_get_pio_list("nand0_para", &list); if(0 == cnt) { printk("get nand0_para gpio list failed\n"); return; } while(cnt--) gpio_free(list[cnt].gpio.gpio); } else if (nand_index == 1) { cnt = script_get_pio_list("nand1_para", &list); if(0 == cnt) { printk("get nand1_para gpio list failed\n"); return; } while(cnt--) gpio_free(list[cnt].gpio.gpio); } else { printk("NAND_PIORelease, nand_index error: 0x%x\n", nand_index); } }
void NAND_PIORequest(__u32 nand_index) { script_item_u *pin_list; int pin_count; int pin_index; PRINT_LEVEL = NAND_Print_level(); /* get pin sys_config info */ if(nand_index == 0) { pin_count = script_get_pio_list("nand0_para", &pin_list); NAND_Print_DBG("pin count:%d \n",pin_count); } else if(nand_index == 1) pin_count = script_get_pio_list("nand1_para", &pin_list); else return ; if (pin_count == 0) { /* "lcd0" have no pin configuration */ printk("pin count 0\n"); return ; } /* request pin individually */ for (pin_index = 0; pin_index < pin_count; pin_index++) { struct gpio_config *pin_cfg = &(pin_list[pin_index].gpio); char pin_name[SUNXI_PIN_NAME_MAX_LEN]; unsigned long config; /* valid pin of sunxi-pinctrl, * config pin attributes individually. */ sunxi_gpio_to_name(pin_cfg->gpio, pin_name); config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC, pin_cfg->mul_sel); pin_config_set(SUNXI_PINCTRL, pin_name, config); if (pin_cfg->pull != GPIO_PULL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_PUD, pin_cfg->pull); pin_config_set(SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->drv_level != GPIO_DRVLVL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DRV, pin_cfg->drv_level); pin_config_set(SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->data != GPIO_DATA_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT, pin_cfg->data); pin_config_set(SUNXI_PINCTRL, pin_name, config); } } *((volatile unsigned int *)0xf6000b08)= 0xa; NAND_Print_DBG("nand:gpioc bias config:%x \n",*((volatile unsigned int *)0xf6000b08)); return ; }
static int sw_serial_put_resource(struct sw_serial_port *sport) { script_item_u *list = NULL; char uart_para[16]; int cnt, i; clk_reset(sport->mod_clk, AW_CCU_CLK_RESET); clk_disable(sport->mod_clk); clk_disable(sport->bus_clk); clk_put(sport->mod_clk); clk_put(sport->bus_clk); sprintf(uart_para, "uart_para%d", sport->port_no); cnt = script_get_pio_list(uart_para, &list); if (!cnt) { UART_ERR("%s: uart%d get pio list from sys_config.fex failed\n", __func__, sport->port_no); return 1; } for (i = 0; i < cnt; i++) gpio_free(list[i].gpio.gpio); return 0; }
void NAND_PIORequest(__u32 nand_index) { int cnt, i; script_item_u *list = NULL; if(nand_index == 0) { //printk("[NAND] nand0 gpio_request\n"); /* 获取gpio list */ cnt = script_get_pio_list("nand0_para", &list); if(0 == cnt) { printk("get nand0_para gpio list failed\n"); return; } /* 申请gpio */ for(i = 0; i < cnt; i++) if(0 != gpio_request(list[i].gpio.gpio, NULL)) printk("request nand0_para gpio list failed\n"); /* 配置gpio list */ if(0 != sw_gpio_setall_range(&list[0].gpio, cnt)) printk("sw_gpio_setall_range failed\n"); } else if(nand_index ==1) { //printk("[NAND] nand1 gpio_request\n"); cnt = script_get_pio_list("nand1_para", &list); if(0 == cnt) { printk("get nand1_para gpio list failed\n"); return; } /* 申请gpio */ for(i = 0; i < cnt; i++) if(0 != gpio_request(list[i].gpio.gpio, NULL)) printk("request nand1_para gpio list failed\n"); /* 配置gpio list */ if(0 != sw_gpio_setall_range(&list[0].gpio, cnt)) printk("sw_gpio_setall_range failed\n"); } else { printk("NAND_PIORequest, nand_index error: 0x%x\n", nand_index); } }
static int __init sun6i_i2s_init(void) { int err = 0; int cnt = 0; int i = 0; script_item_u val; script_item_u *list = NULL; script_item_value_type_e type; type = script_get_item("i2s_para", "i2s_used", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { printk("[I2S] type err!\n"); } i2s_used = val.val; type = script_get_item("i2s_para", "i2s_select", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { printk("[I2S] i2s_select type err!\n"); } i2s_select = val.val; if (i2s_used) { /* get gpio list */ cnt = script_get_pio_list("i2s_para", &list); if (0 == cnt) { printk("get i2s_para gpio list failed\n"); return -EFAULT; } /* req gpio */ for (i = 0; i < cnt; i++) { if (0 != gpio_request(list[i].gpio.gpio, NULL)) { printk("[i2s] request some gpio fail\n"); goto end; } } /* config gpio list */ if (0 != sw_gpio_setall_range(&list[0].gpio, cnt)) { printk("sw_gpio_setall_range failed\n"); } if((err = platform_device_register(&sun6i_i2s_device)) < 0) return err; if ((err = platform_driver_register(&sun6i_i2s_driver)) < 0) return err; } else { printk("[I2S]sun6i-i2s cannot find any using configuration for controllers, return directly!\n"); return 0; } end: /* release gpio */ while(i--) gpio_free(list[i].gpio.gpio); return 0; }
static int sunxi_pin_resource_req(struct platform_device *pdev) { script_item_u *pin_list; int pin_count; int pin_index; pr_warn("device [%s] pin resource request enter\n", dev_name(&pdev->dev)); /* get pin sys_config info */ pin_count = script_get_pio_list("lcd0", &pin_list); if (pin_count == 0) { /* "lcd0" have no pin configuration */ return -EINVAL; } /* request pin individually */ for (pin_index = 0; pin_index < pin_count; pin_index++) { struct gpio_config *pin_cfg = &(pin_list[pin_index].gpio); char pin_name[SUNXI_PIN_NAME_MAX_LEN]; unsigned long config; if (IS_AXP_PIN(pin_cfg->gpio)) { /* valid pin of axp-pinctrl, * config pin attributes individually. */ sunxi_gpio_to_name(pin_cfg->gpio, pin_name); config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC, pin_cfg->mul_sel); pin_config_set(AXP_PINCTRL, pin_name, config); if (pin_cfg->data != GPIO_DATA_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT, pin_cfg->data); pin_config_set(AXP_PINCTRL, pin_name, config); } } else { /* valid pin of sunxi-pinctrl, * config pin attributes individually. */ sunxi_gpio_to_name(pin_cfg->gpio, pin_name); config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC, pin_cfg->mul_sel); pin_config_set(SUNXI_PINCTRL, pin_name, config); if (pin_cfg->pull != GPIO_PULL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_PUD, pin_cfg->pull); pin_config_set(SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->drv_level != GPIO_DRVLVL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DRV, pin_cfg->drv_level); pin_config_set(SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->data != GPIO_DATA_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT, pin_cfg->data); pin_config_set(SUNXI_PINCTRL, pin_name, config); } } } pr_debug("device [%s] pin resource request ok\n", dev_name(&pdev->dev)); return 0; }
static int __init gpio_sw_init(void) { int i, ret; int gpio_key_count = 0; script_item_u gpio_used, *list = NULL; script_item_value_type_e type; type = script_get_item("3g_gpio_para", "gpio_used", &gpio_used); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { printk("[gpio_para] gpio_used err!\n"); return -1; } if (1 == gpio_used.val) { gpio_key_count = script_get_pio_list("3g_gpio_para", &list); if (0 == gpio_key_count) { printk("[gpio_para] get gpio list failed\n"); return -1; } } for(i=0; i<gpio_key_count; i++) { pdatesw[i].flags = 0; sprintf(pdatesw[i].name, "gpio_pin_%d", i+1); gpio_sw_dev[i].name = "gpio_sw"; gpio_sw_dev[i].id = i; gpio_sw_dev[i].dev.platform_data= &pdatesw[i]; gpio_sw_dev[i].dev.release = gpio_sw_release; GPIO_SW_DEBUG("pdatesw[%d].gpio_name = %s\n",i,pdatesw[i].name); GPIO_SW_DEBUG("pdatesw[%d] 1addr = %x \n",i,(unsigned int)&pdatesw[i]); GPIO_SW_DEBUG("gpio_sw_dev[%d] addr = %x \n",i,(unsigned int)&gpio_sw_dev[i]); platform_device_register(&gpio_sw_dev[i]); } platform_driver_register(&gpio_sw_driver); if(all_irq_enable) { ret = request_irq(GPIO_IRQ, sunxi_interrupt, IRQF_DISABLED, "gpio_sw", NULL); if (ret) { printk( "gpio: request irq failed\n"); return ret; } } GPIO_SW_DEBUG("gpio_sw_driver addr = %x \n",(unsigned int)&gpio_sw_driver); return 0; }
void sunxi_pwm_get_sys_config(int pwm, struct sunxi_pwm_cfg *sunxi_pwm_cfg) { char primary_key[25]; script_item_u val; script_item_value_type_e type; sprintf(primary_key, "pwm%d_para", pwm); sunxi_pwm_cfg->list = NULL; type = script_get_item(primary_key, "pwm_used", &val); if((SCIRPT_ITEM_VALUE_TYPE_INT == type) && (val.val == 1)) { pwm_pin_count[pwm] = script_get_pio_list(primary_key, &sunxi_pwm_cfg->list); if(pwm_pin_count[pwm] == 0) pr_warn("get pwm%d gpio list fail!\n", pwm); } }
static void __exit gpio_sw_exit(void) { int i, gpio_used; int gpio_cnt; script_item_u val; script_item_value_type_e type; script_item_u *list = NULL; type = script_get_item("3g_gpio_para", "gpio_used", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { printk("[gpio_para] type err! gpio_para is disable\n"); goto EXIT_END; } gpio_used = val.val; if(gpio_used == 0) { GPIO_SW_DEBUG("gpio module is used not \n"); goto EXIT_END; } if(all_irq_enable) { __raw_writel(0x00, GPIO_TEST_BASE + 0x210); free_irq(GPIO_IRQ,NULL); } gpio_cnt = script_get_pio_list("3g_gpio_para", &list); for(i = 0; i < gpio_cnt; i++) { platform_device_unregister(&gpio_sw_dev[i]); } GPIO_SW_DEBUG("platform_device_unregister finish ! \n"); GPIO_SW_DEBUG("gpio_sw_driver addr = %x \n",(unsigned int)&gpio_sw_driver); platform_driver_unregister(&gpio_sw_driver); EXIT_END: GPIO_SW_DEBUG("gpio_exit finish ! \n"); }
__s32 NAND_PIOFuncChange_REc(__u32 nand_index, __u32 en) { unsigned int ndfc_version; script_item_u *pin_list; int pin_count; int pin_index; ndfc_version = NAND_GetNdfcVersion(); if (ndfc_version == 1) { printk("NAND_PIOFuncChange_EnDQScREc: invalid ndfc version!\n"); return 0; } /* get pin sys_config info */ if(nand_index == 0) pin_count = script_get_pio_list("nand0", &pin_list); else if(nand_index == 1) pin_count = script_get_pio_list("nand1", &pin_list); else { pin_count = 0; printk("NAND_PIOFuncChange_DQSc, wrong nand index %d\n", nand_index); } if (pin_count == 0) { /* "lcd0" have no pin configuration */ return 0; } { struct gpio_config *pin_cfg; char pin_name[SUNXI_PIN_NAME_MAX_LEN]; unsigned long config; /* change pin func from CE2 to REc */ pin_index = 17; if (pin_index > pin_count) { printk("NAND_PIOFuncChange_EnREc: pin_index error, %d/%d\n", pin_index, pin_count); return -1; } pin_cfg = &(pin_list[pin_index].gpio); sunxi_gpio_to_name(pin_cfg->gpio, pin_name); config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC, pin_cfg->mul_sel); if (en) { if ((config & 0xffff) == 0x3) printk("REc has already been enabled!\n"); else if ((config & 0xffff) == 0x2){ config &= ~(0xffff); config |= 0x3; pin_config_set(SUNXI_PINCTRL, pin_name, config); } else { printk("NAND_PIOFuncChange_EnREc: wrong pin func status: %d %d\n", pin_index, (__u32)(config & 0xffff)); } } else { if ((config & 0xffff) == 0x2) printk("REc has already been disenabled!\n"); else if ((config & 0xffff) == 0x3){ config &= ~(0xffff); config |= 0x3; pin_config_set(SUNXI_PINCTRL, pin_name, config); } else { printk("NAND_PIOFuncChange_EnREc: wrong pin func status: %d %d\n", pin_index, (__u32)(config & 0xffff)); } } } return 0; }
//static struct pinctrl *daudio_pinctrl; static int __init sunxi_daudio0_dev_probe(struct platform_device *pdev) { int ret = 0; int reg_val = 0; script_item_u val; script_item_value_type_e type; sunxi_daudio.regs = ioremap(SUNXI_DAUDIOBASE, 0x100); if (sunxi_daudio.regs == NULL) { return -ENXIO; } /*for A80 evb pin config*/ daudio_pinctrl = devm_pinctrl_get_select_default(&pdev->dev); if (IS_ERR_OR_NULL(daudio_pinctrl)) { dev_warn(&pdev->dev, "pins are not configured from the driver\n"); } pin_count = script_get_pio_list (TDM_NAME, &pin_daudio0_list); if (pin_count == 0) { /* "daudio0" have no pin configuration */ pr_err("daudio0 have no pin configuration\n"); } #ifdef CONFIG_ARCH_SUN9IW1 /*daudio pll2clk*/ daudio_pll3clk = clk_get(NULL, "pll3"); if ((!daudio_pll3clk)||(IS_ERR(daudio_pll3clk))) { pr_err("try to get daudio_pll2clk failed\n"); } if (clk_prepare_enable(daudio_pll3clk)) { pr_err("enable daudio_pll2clk failed; \n"); } /*daudio module clk*/ daudio_moduleclk = clk_get(NULL, "cpuri2s1"); if ((!daudio_moduleclk)||(IS_ERR(daudio_moduleclk))) { pr_err("try to get daudio_moduleclk failed\n"); } if (clk_set_parent(daudio_moduleclk, daudio_pll3clk)) { pr_err("try to set parent of daudio_moduleclk to daudio_pll2ck failed! line = %d\n",__LINE__); } if (clk_set_rate(daudio_pll3clk, 24576000)) { pr_err("set daudio_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__); } if (clk_prepare_enable(daudio_moduleclk)) { pr_err("open daudio_moduleclk failed! line = %d\n", __LINE__); } #else #ifdef CONFIG_ARCH_SUN8IW7 daudio_pll = clk_get(NULL, "pll_audio"); if ((!daudio_pll)||(IS_ERR(daudio_pll))) { pr_err("try to get daudio_pll failed\n"); } if (clk_prepare_enable(daudio_pll)) { pr_err("enable daudio_pll2clk failed; \n"); } /*daudio module clk*/ daudio_moduleclk = clk_get(NULL, "i2s0"); if ((!daudio_moduleclk)||(IS_ERR(daudio_moduleclk))) { pr_err("try to get daudio_moduleclk failed\n"); } if (clk_set_parent(daudio_moduleclk, daudio_pll)) { pr_err("try to set parent of daudio_moduleclk to daudio_pll2ck failed! line = %d\n",__LINE__); } if (clk_set_rate(daudio_moduleclk, 24576000)) { pr_err("set daudio_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__); } if (clk_prepare_enable(daudio_moduleclk)) { pr_err("open daudio_moduleclk failed! line = %d\n", __LINE__); } #else daudio_pllx8 = clk_get(NULL, "pll_audiox8"); if ((!daudio_pllx8)||(IS_ERR(daudio_pllx8))) { pr_err("try to get daudio_pllx8 failed\n"); } if (clk_prepare_enable(daudio_pllx8)) { pr_err("enable daudio_pll2clk failed; \n"); } /*daudio pll2clk*/ daudio_pll2clk = clk_get(NULL, "pll2"); if ((!daudio_pll2clk)||(IS_ERR(daudio_pll2clk))) { pr_err("try to get daudio_pll2clk failed\n"); } if (clk_prepare_enable(daudio_pll2clk)) { pr_err("enable daudio_pll2clk failed; \n"); } #ifdef CONFIG_ARCH_SUN8IW8 /*daudio module clk*/ daudio_moduleclk = clk_get(NULL, "i2s0"); #else //pr_debug("%s,line:%d,0xbc:%x\n",__func__,__LINE__,sunxi_smc_readl(0xf1c200bc)); daudio_moduleclk = clk_get(NULL, "tdm"); #endif if ((!daudio_moduleclk)||(IS_ERR(daudio_moduleclk))) { pr_err("try to get daudio_moduleclk failed\n"); } if (clk_set_parent(daudio_moduleclk, daudio_pll2clk)) { pr_err("try to set parent of daudio_moduleclk to daudio_pll2ck failed! line = %d\n",__LINE__); } #if defined(CONFIG_ARCH_SUN8IW6) || defined(CONFIG_ARCH_SUN8IW8) //#ifdef CONFIG_ARCH_SUN8IW6 if (clk_set_rate(daudio_moduleclk, 24576000)) { pr_err("set daudio_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__); } #else if (clk_set_rate(daudio_moduleclk, 24576000/8)) { pr_err("set daudio_moduleclk clock freq to 24576000 failed! line = %d\n", __LINE__); } #endif if (clk_prepare_enable(daudio_moduleclk)) { pr_err("open daudio_moduleclk failed! line = %d\n", __LINE__); } //pr_debug("%s,line:%d,bc:%x\n",__func__,__LINE__,sunxi_smc_readl(0xf1c200bc)); #endif #endif reg_val = sunxi_smc_readl(sunxi_daudio.regs + SUNXI_DAUDIOCTL); reg_val |= SUNXI_DAUDIOCTL_GEN; sunxi_smc_writel(reg_val, sunxi_daudio.regs + SUNXI_DAUDIOCTL); type = script_get_item(TDM_NAME, "mclk_fs", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] mclk_fs type err!\n"); } mclk_fs = val.val; type = script_get_item(TDM_NAME, "sample_resolution", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] sample_resolution type err!\n"); } sample_resolution = val.val; type = script_get_item(TDM_NAME, "slot_width_select", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] slot_width_select type err!\n"); } slot_width_select = val.val; type = script_get_item(TDM_NAME, "pcm_lrck_period", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] pcm_lrck_period type err!\n"); } pcm_lrck_period = val.val; type = script_get_item(TDM_NAME, "pcm_lrckr_period", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] pcm_lrckr_period type err!\n"); } pcm_lrckr_period = val.val; type = script_get_item(TDM_NAME, "msb_lsb_first", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] msb_lsb_first type err!\n"); } msb_lsb_first = val.val; type = script_get_item(TDM_NAME, "sign_extend", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] sign_extend type err!\n"); } sign_extend = val.val; type = script_get_item(TDM_NAME, "slot_index", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] slot_index type err!\n"); } slot_index = val.val; type = script_get_item(TDM_NAME, "frame_width", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] frame_width type err!\n"); } frame_width = val.val; type = script_get_item(TDM_NAME, "tx_data_mode", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] tx_data_mode type err!\n"); } tx_data_mode = val.val; type = script_get_item(TDM_NAME, "rx_data_mode", &val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { pr_err("[DAUDIO] rx_data_mode type err!\n"); } rx_data_mode = val.val; ret = snd_soc_register_dais(&pdev->dev,sunxi_daudio_dai, ARRAY_SIZE(sunxi_daudio_dai)); if (ret) { dev_err(&pdev->dev, "Failed to register DAI\n"); } return 0; }
static int axp_pinctrl_parse_pin_cfg(struct platform_device *pdev) { int mainkey_count; int mainkey_idx; /* get main key count */ mainkey_count = script_get_main_key_count(); pr_debug("mainkey total count : %d\n", mainkey_count); for (mainkey_idx = 0; mainkey_idx < mainkey_count; mainkey_idx++) { char *mainkey_name; script_item_u *pin_list; int pin_count; int pin_index; int map_index; struct pinctrl_map *maps; /* get main key name by index */ mainkey_name = script_get_main_key_name(mainkey_idx); if (!mainkey_name) { /* get mainkey name failed */ pr_debug("get mainkey [%s] name failed\n", mainkey_name); continue; } /* get main-key(device) pin configuration */ pin_count = script_get_pio_list(mainkey_name, &pin_list); pr_debug("mainkey name : %s, pin count : %d\n", mainkey_name, pin_count); if (pin_count == 0) { /* the mainkey have no pin configuration */ continue; } /* allocate pinctrl_map table, * max map table size = pin count * 2 : * mux map and config map. */ maps = kzalloc(sizeof(*maps) * (pin_count * 2), GFP_KERNEL); if (!maps) { pr_err("allocate memory for sunxi pinctrl map table failed\n"); return -ENOMEM; } map_index = 0; for (pin_index = 0; pin_index < pin_count; pin_index++) { /* convert struct sunxi_pin_cfg to struct pinctrl_map */ map_index += axp_pin_cfg_to_pin_map(pdev, &(pin_list[pin_index].gpio), &(maps[map_index]), mainkey_name); } if (map_index) { /* register maps to pinctrl */ pr_debug("map mainkey [%s] to pinctrl, map number [%d]\n", mainkey_name, map_index); pinctrl_register_mappings(maps, map_index); } /* free pinctrl_map table directly, * pinctrl subsytem will dup this map table */ kfree(maps); } return 0; }
static int sunxi_arisc_pin_cfg(struct platform_device *pdev) { script_item_u script_val; script_item_value_type_e type; script_item_u *pin_list; int pin_count = 0; int pin_index = 0; struct gpio_config *pin_cfg; char pin_name[SUNXI_PIN_NAME_MAX_LEN]; unsigned long config; ARISC_INF("device [%s] pin resource request enter\n", dev_name(&pdev->dev)); /* * request arisc resources: * p2wi/rsb gpio... */ /* get pin sys_config info */ #if defined CONFIG_ARCH_SUN8IW1P1 pin_count = script_get_pio_list ("s_p2twi0", &pin_list); #elif (defined CONFIG_ARCH_SUN8IW3P1) || (defined CONFIG_ARCH_SUN8IW5P1) || (defined CONFIG_ARCH_SUN8IW6P1) pin_count = script_get_pio_list ("s_rsb0", &pin_list); #elif defined CONFIG_ARCH_SUN9IW1P1 pin_count = script_get_pio_list ("s_rsb0", &pin_list); #else #error "please select a platform\n" #endif if (pin_count == 0) { /* "s_p2twi0" or "s_rsb0" have no pin configuration */ ARISC_WRN("arisc s_p2twi0/s_rsb0 have no pin configuration\n"); return -EINVAL; } /* request pin individually */ for (pin_index = 0; pin_index < pin_count; pin_index++) { pin_cfg = &(pin_list[pin_index].gpio); /* valid pin of sunxi-pinctrl, config pin attributes individually.*/ sunxi_gpio_to_name(pin_cfg->gpio, pin_name); config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC, pin_cfg->mul_sel); pin_config_set(SUNXI_PINCTRL, pin_name, config); if (pin_cfg->pull != GPIO_PULL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_PUD, pin_cfg->pull); pin_config_set (SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->drv_level != GPIO_DRVLVL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DRV, pin_cfg->drv_level); pin_config_set (SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->data != GPIO_DATA_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT, pin_cfg->data); pin_config_set (SUNXI_PINCTRL, pin_name, config); } } /* * request arisc resources: * uart gpio... */ type = script_get_item("s_uart0", "s_uart_used", &script_val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { ARISC_WRN("sys_config.fex have no arisc s_uart0 config!"); script_val.val = 0; } if (script_val.val) { pin_count = script_get_pio_list ("s_uart0", &pin_list); if (pin_count == 0) { /* "s_uart0" have no pin configuration */ ARISC_WRN("arisc s_uart0 have no pin configuration\n"); return -EINVAL; } /* request pin individually */ for (pin_index = 0; pin_index < pin_count; pin_index++) { pin_cfg = &(pin_list[pin_index].gpio); /* valid pin of sunxi-pinctrl, config pin attributes individually.*/ sunxi_gpio_to_name(pin_cfg->gpio, pin_name); config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC, pin_cfg->mul_sel); pin_config_set(SUNXI_PINCTRL, pin_name, config); if (pin_cfg->pull != GPIO_PULL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_PUD, pin_cfg->pull); pin_config_set (SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->drv_level != GPIO_DRVLVL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DRV, pin_cfg->drv_level); pin_config_set (SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->data != GPIO_DATA_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT, pin_cfg->data); pin_config_set (SUNXI_PINCTRL, pin_name, config); } } } ARISC_INF("arisc uart debug config [%s] [%s] : %d\n", "s_uart0", "s_uart_used", script_val.val); /* * request arisc resources: * jtag gpio... */ type = script_get_item("s_jtag0", "s_jtag_used", &script_val); if (SCIRPT_ITEM_VALUE_TYPE_INT != type) { ARISC_WRN("sys_config.fex have no arisc s_jtag0 config!"); script_val.val = 0; } if (script_val.val) { pin_count = script_get_pio_list ("s_jtag0", &pin_list); if (pin_count == 0) { /* "s_jtag0" have no pin configuration */ ARISC_WRN("arisc s_jtag0 have no pin configuration\n"); return -EINVAL; } /* request pin individually */ for (pin_index = 0; pin_index < pin_count; pin_index++) { pin_cfg = &(pin_list[pin_index].gpio); /* valid pin of sunxi-pinctrl, config pin attributes individually.*/ sunxi_gpio_to_name(pin_cfg->gpio, pin_name); config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_FUNC, pin_cfg->mul_sel); pin_config_set(SUNXI_PINCTRL, pin_name, config); if (pin_cfg->pull != GPIO_PULL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_PUD, pin_cfg->pull); pin_config_set (SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->drv_level != GPIO_DRVLVL_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DRV, pin_cfg->drv_level); pin_config_set (SUNXI_PINCTRL, pin_name, config); } if (pin_cfg->data != GPIO_DATA_DEFAULT) { config = SUNXI_PINCFG_PACK(SUNXI_PINCFG_TYPE_DAT, pin_cfg->data); pin_config_set (SUNXI_PINCTRL, pin_name, config); } } } ARISC_INF("arisc jtag debug config [%s] [%s] : %d\n", "s_jtag0", "s_jtag_used", script_val.val); ARISC_INF("device [%s] pin resource request ok\n", dev_name(&pdev->dev)); return 0; }
static int sw_serial_get_resource(struct sw_serial_port *sport) { char uart_para[16]; int cnt, i = 0, ret; script_item_u *list = NULL; /* get register base */ sport->mmres = platform_get_resource(sport->pdev, IORESOURCE_MEM, 0); if (!sport->mmres) { ret = -ENODEV; UART_ERR("%s: uart%d no IORESOURCE_MEM\n", __func__, sport->port_no); goto err_out; } /* get clock */ sport->bus_clk_name = apb_clock_name[sport->port_no]; sport->bus_clk = clk_get(NULL, sport->bus_clk_name); if (IS_ERR(sport->bus_clk)) { ret = PTR_ERR(sport->bus_clk); UART_ERR("%s: uart%d get bus clock failed\n", __func__, sport->port_no); goto iounmap; } sport->mod_clk_name = mod_clock_name[sport->port_no]; sport->mod_clk = clk_get(NULL, sport->mod_clk_name); if (IS_ERR(sport->mod_clk)) { ret = PTR_ERR(sport->mod_clk); UART_ERR("%s: uart%d get mod clock failed\n", __func__, sport->port_no); goto iounmap; } sport->sclk = clk_get_rate(sport->mod_clk); /* get irq */ sport->irq = platform_get_irq(sport->pdev, 0); if (sport->irq == 0) { ret = -EINVAL; UART_ERR("%s: uart%d no IORESOURCE_irq\n", __func__, sport->port_no); goto iounmap; } clk_enable(sport->bus_clk); clk_enable(sport->mod_clk); clk_reset(sport->mod_clk, AW_CCU_CLK_NRESET); sprintf(uart_para, "uart_para%d", sport->port_no); cnt = script_get_pio_list(uart_para, &list); if (!cnt) { ret = -EINVAL; UART_ERR("%s: uart%d get pio list from sys_config.fex failed\n", __func__, sport->port_no); goto free_pclk; } for (i = 0; i < cnt; i++) if (gpio_request(list[i].gpio.gpio, NULL)) { ret = -EINVAL; UART_ERR("%s: uart%d request gpio%d failed\n", __func__, sport->port_no, list[i].gpio.gpio); goto free_pclk; } if (sw_gpio_setall_range(&list[0].gpio, cnt)) { UART_ERR("%s: uart%d gpio set all range error\n", __func__, sport->port_no); goto free_pclk; } return 0; free_pclk: clk_put(sport->mod_clk); clk_put(sport->bus_clk); iounmap: err_out: while (i--) gpio_free(list[i].gpio.gpio); return ret; }
static int sunxi_devices_pin_request(struct platform_device *pdev) { int mainkey_count; int mainkey_idx; struct pinctrl *pinctrl; /* get main key count */ mainkey_count = script_get_main_key_count(); pr_warn("mainkey total count : %d\n", mainkey_count); for (mainkey_idx = 0; mainkey_idx < mainkey_count; mainkey_idx++) { char *mainkey_name; script_item_u *pin_list; int pin_count; char *device_name; script_item_value_type_e type; script_item_u item; script_item_u used; /* get main key name by index */ mainkey_name = script_get_main_key_name(mainkey_idx); if (!mainkey_name) { /* get mainkey name failed */ pr_warn("get mainkey [%s] name failed\n", mainkey_name); continue; } /* get main-key(device) pin configuration */ pin_count = script_get_pio_list(mainkey_name, &pin_list); pr_warn("mainkey name : %s, pin count : %d\n", mainkey_name, pin_count); if (pin_count == 0) { /* mainley have no pin configuration */ continue; } /* try to get device name */ type = script_get_item(mainkey_name, "used", &used); if ((type != SCIRPT_ITEM_VALUE_TYPE_INT) || (used.val == 0)) { /* this device not used */ continue; } /* try to get device name */ type = script_get_item(mainkey_name, "device_name", &item); if ((type == SCIRPT_ITEM_VALUE_TYPE_STR) && (item.str)) { /* the mainkey have valid device-name, * use the config device_name */ device_name = item.str; } else { /* have no device_name config, * default use mainkey name as device name */ device_name = mainkey_name; } /* set device name */ dev_set_name(&(pdev->dev), device_name); /* request device pinctrl, set as default state */ pinctrl = devm_pinctrl_get_select_default(&pdev->dev); if (IS_ERR_OR_NULL(pinctrl)) { pr_warn("request pinctrl handle for device [%s] failed\n", dev_name(&pdev->dev)); return -EINVAL; } pr_warn("device [%s] pinctrl request succeeded\n", device_name); devices_pinctrl[mainkey_idx] = pinctrl; } return 0; }
static int sunxi_devices_pin_check(struct platform_device *pdev) { int mainkey_count; int mainkey_idx; /* get main key count */ mainkey_count = script_get_main_key_count(); pr_warn("mainkey total count : %d\n", mainkey_count); for (mainkey_idx = 0; mainkey_idx < mainkey_count; mainkey_idx++) { char *mainkey_name; script_item_u *pin_list; int pin_count; int pin_index; char *device_name; script_item_value_type_e type; script_item_u item; int fail_cnt; script_item_u used; /* get main key name by index */ mainkey_name = script_get_main_key_name(mainkey_idx); if (!mainkey_name) { /* get mainkey name failed */ pr_warn("get mainkey [%s] name failed\n", mainkey_name); continue; } /* get main-key(device) pin configuration */ pin_count = script_get_pio_list(mainkey_name, &pin_list); pr_warn("mainkey name : %s, pin count : %d\n", mainkey_name, pin_count); if (pin_count == 0) { /* mainley have no pin configuration */ continue; } /* try to get device name */ type = script_get_item(mainkey_name, "used", &used); if ((type != SCIRPT_ITEM_VALUE_TYPE_INT) || (used.val == 0)) { /* this device not used */ continue; } /* try to get device name */ type = script_get_item(mainkey_name, "device_name", &item); if ((type == SCIRPT_ITEM_VALUE_TYPE_STR) && (item.str)) { /* the mainkey have valid device-name, * use the config device_name. */ device_name = item.str; } else { /* have no device_name config, * default use mainkey name as device name */ device_name = mainkey_name; } fail_cnt = 0; for (pin_index = 0; pin_index < pin_count; pin_index++) { fail_cnt += sunxi_pin_cfg_check(&(pin_list[pin_index].gpio)); } if (fail_cnt) { pr_warn("device [%s] pin check fail cnt %d\n", device_name, fail_cnt); } else { pr_warn("device [%s] pin check succeeded\n", device_name); } } return 0; }