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
