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