int main (void) { int result = 0; // UART init UartStdOutInit(); // Test banner message and revision number puts("Cortex Microcontroller System Design Kit - GPIO Driver Test - revision $Revision: 242484 $\n"); if (gpio0_id_check()!=0) { puts ("GPIO 0 not present. Test skipped."); UartEndSimulation(); return 0;} if (gpio1_id_check()!=0) { puts ("GPIO 1 not present. Test skipped."); UartEndSimulation(); return 0;} result |= GPIO_OPEN(); result |= GPIO_AltFuncEN(); result |= GPIO_IRQ(); result |= GPIO_Mask_OP(); if(result == 0) { puts("** TEST PASSED **\n"); } else { printf("** TEST FAILED **, Error code: (0x%x)\n", result); } UartEndSimulation(); return result; }
INT32 wmt_plat_bgf_eint_ctrl ( ENUM_PIN_STATE state ) { #if CFG_WMT_PS_SUPPORT switch(state) { case PIN_STA_INIT: /*set to gpio input low, pull down eanble*/ aml_gpio_input_mtk(MTK_BGF_INT); WMT_DBG_FUNC("WMT-PLAT:BGFInt init(in pd) \n"); break; case PIN_STA_MUX: /*set to EINT mode,interrupt input, pull up enable*/ gpio_set_status(MTK_BGF_INT,gpio_status_in); aml_clr_reg32_mask(P_PAD_PULL_UP_REG4,0x1<<10);//pull up resister gpio_irq_set(MTK_BGF_INT,GPIO_IRQ(mtk_bgf_irq_no,GPIO_IRQ_LOW)); WMT_DBG_FUNC("WMT-PLAT:BGFInt mux (eint) \n"); break; case PIN_STA_IN_L: case PIN_STA_DEINIT: /*first: disable bgf inq wake up host function*/ do { int iret; iret = disable_irq_wake(mtk_bgf_irq_no); if(iret){ WMT_WARN_FUNC("disable_irq_wake(bgf:%d) fail(%d)\n",mtk_bgf_irq_no,iret); iret = 0; } else{ WMT_INFO_FUNC("disable_irq_wake(bgf:%d)--,ret(%d)\n",mtk_bgf_irq_no,iret); } } while (0); /*second: set to gpio input low, pull down eanble*/ //aml_set_reg32_mask(P_PAD_PULL_UP_REG4,0x1<<10); aml_gpio_input_mtk(MTK_BGF_INT); WMT_DBG_FUNC("WMT-PLAT:BGFInt deinit(in pd) \n"); break; default: WMT_WARN_FUNC("WMT-PLAT:Warnning, invalid state(%d) on BGF EINT\n", state); break; } #endif return 0; }
val = readw(VA(PADCONF_GPMC_NOE)); val |= 0x0E00; writew(VA(PADCONF_GPMC_NOE), val); val = readw(VA(PADCONF_GPMC_NADV_ALE)); val |= 0x0E00; writew(VA(PADCONF_GPMC_NADV_ALE), val); return 0; } static struct platform_device lan9220_device = { .dev = { .mem = 0x28000000, .irq = GPIO_IRQ(19), }, .name = "SMSC LAN9220", .init = lan9220_device_init, }; #endif // fixme: __INITDATA__ static struct platform_device *evm3530_devices[] = { #ifdef CONFIG_LAN9220 &lan9220_device, #endif }; static int __INIT__ evm3530_init(struct board_desc *board, const struct board_id *id) {
static int __devinit bq24157_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret = 0; struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct bq24157_platform_data *pdata = client->dev.platform_data; printk("%s name : %s\n", __func__, client->name); /*First check the functionality supported by the host*/ if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { printk("%s functionality check failed 1 \n", __func__); return -EIO; } if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { printk("%s functionality check failed 2 \n", __func__); return -EIO; } if(bq24157_client == NULL) { bq24157_client = client; } else { printk("%s bq24157_client is not NULL. bq24157_client->name : %s\n", __func__, bq24157_client->name); ret = -ENXIO; goto err_bq24157_client_is_not_NULL; } #if defined(CONFIG_SPA) spa_external_event = spa_get_external_event_handler(); #endif ret = bq24157_read_chip_info(); if(ret) { printk("%s fail to read chip info\n", __func__); goto err_read_chip_info; } ret = bq24157_init_data(); if(ret) { printk("%s fail to init data\n", __func__); goto err_init_data; } if(pdata->cd == 0) { printk("%s please assign cd pin GPIO\n", __func__); ret = -1; goto err_gpio_request_cd; } ret = gpio_request(pdata->cd, "bq24157_CD"); if(ret) { dev_err(&client->dev,"bq24157: Unable to get gpio %d\n", pdata->cd); goto err_gpio_request_cd; } bq24157_chg_en = pdata->cd; #if defined(CONFIG_SPA) ret = spa_chg_register_enable_charge(bq24157_enable_charge); if(ret) { printk("%s fail to register enable_charge function\n", __func__); goto err_register_enable_charge; } ret = spa_chg_register_disable_charge(bq24157_disable_charge); if(ret) { printk("%s fail to register disable_charge function\n", __func__); goto err_register_disable_charge; } spa_external_event = spa_get_external_event_handler(); #endif INIT_DELAYED_WORK(&pdata->stat_irq_work, bq24157_stat_irq_work); wake_lock_init(&pdata->stat_irq_wakelock, WAKE_LOCK_SUSPEND, "bq24157_stat_irq"); if(client->irq){ printk("%s irq : %d\n", __func__, client->irq); /* check init status */ if((gpio_get_value(GPIO_IRQ(bq24157_client->irq))? 1 : 0) == 1) { wake_lock(&pdata->stat_irq_wakelock); schedule_delayed_work(&pdata->stat_irq_work, 0); } ret = gpio_request(GPIO_IRQ(client->irq), "bq24157_stat"); if(ret) { printk("%s gpio_request failed\n", __func__); goto err_gpio_request_bq24157_stat; } gpio_direction_input(GPIO_IRQ(client->irq)); ret = request_irq(client->irq, bq24157_stat_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "bq24157_stat", pdata); if(ret) { printk("%s request_irq failed\n", __func__); goto err_request_irq_bq24157_stat; } } return 0; err_request_irq_bq24157_stat: gpio_free(client->irq); err_gpio_request_bq24157_stat: #if defined(CONFIG_SPA) spa_chg_unregister_disable_charge(bq24157_disable_charge); err_register_disable_charge: spa_chg_unregister_enable_charge(bq24157_enable_charge); err_register_enable_charge: #endif err_gpio_request_cd: err_init_data: err_read_chip_info: #if defined(CONFIG_SPA) spa_external_event = NULL; #endif bq24157_client = NULL; err_bq24157_client_is_not_NULL: return ret; }
static void bq24157_stat_irq_work(struct work_struct *work) { struct bq24157_platform_data *pdata = container_of(work, struct bq24157_platform_data, stat_irq_work.work); unsigned char data = 0; int ret = 0; int stat = gpio_get_value(GPIO_IRQ(bq24157_client->irq))? 1 : 0; printk("%s \n", __func__); if((bq24157_is_ovp==1) && (stat == 0)) { bq24157_is_ovp = 0; #if defined(CONFIG_SPA) if(spa_external_event) { spa_external_event(SPA_CATEGORY_BATTERY, SPA_BATTERY_EVENT_OVP_CHARGE_RESTART); } #endif goto ovp_restart; } ret = bq24157_i2c_read(1, BQ24157_STATUS_CONTROL, &data); if(ret < 0) { printk("%s bq24157_i2c_read failed %d\n", __func__, ret); goto err_read_status_control; } printk("%s 0x%x stat : %d\n", __func__, data, stat); switch(data & STAT) { case STAT_READY: break; case STAT_INPROGRESS: break; case STAT_CHARGE_DONE: #if defined(CONFIG_SPA) if(spa_external_event) { spa_external_event(SPA_CATEGORY_BATTERY, SPA_BATTERY_EVENT_CHARGE_FULL); } #endif break; case STAT_FAULT: switch(data & FAULT) { case FAULT_NORMAL: break; case FAULT_VBUS_OVP: #if defined(CONFIG_SPA) if(spa_external_event) { spa_external_event(SPA_CATEGORY_BATTERY, SPA_BATTERY_EVENT_OVP_CHARGE_STOP); } #endif break; case FAULT_SLEEP_MODE: break; case FAULT_BAD_ADAPTOR: break; case FAULT_OUTPUT_OVP: break; case FAULT_THEMAL_SHUTDOWN: break; case FAULT_TIMER_FAULT: break; case FAULT_NO_BATTERY: break; default: break; } break; default: break; } ovp_restart: err_read_status_control: wake_unlock(&pdata->stat_irq_wakelock); }
val = 0x8 << 8 | 0x1 << 6 | 0x8; writel(VA(GPMC_CONFIG7(1)), val); return 0; } // fixme: __initdata static struct resource smsc91x_res[] = { [0] = { .start = 0x28000000, .size = 4, .flag = IORESOURCE_MEM, }, [1] = { .start = GPIO_IRQ(19), .size = 1, .flag = IORESOURCE_IRQ, }, }; static struct platform_device smsc91x_device = { .dev = { .resources = smsc91x_res, .res_num = ARRAY_ELEM_NUM(smsc91x_res), }, .name = "SMSC SMSC91X", .init = smsc91x_device_init, }; #endif