static int __init mmc_init(void)
{
int ret;
workqueue = create_freezeable_workqueue("kmmcd");
if (!workqueue)
return -ENOMEM;
ret = mmc_register_bus();
if (ret)
goto destroy_workqueue;
ret = mmc_register_host_class();
if (ret)
goto unregister_bus;
ret = sdio_register_bus();
if (ret)
goto unregister_host_class;
return 0;
unregister_host_class:
mmc_unregister_host_class();
unregister_bus:
mmc_unregister_bus();
destroy_workqueue:
destroy_workqueue(workqueue);
return ret;
}
//end
static int __init mmc_init(void)
{
int ret;
wake_lock_init(&mmc_delayed_work_wake_lock, WAKE_LOCK_SUSPEND, "mmc_delayed_work");
workqueue = create_freezeable_workqueue("kmmcd");
if (!workqueue)
return -ENOMEM;
ret = mmc_register_bus();
if (ret)
goto destroy_workqueue;
ret = mmc_register_host_class();
if (ret)
goto unregister_bus;
ret = sdio_register_bus();
if (ret)
goto unregister_host_class;
return 0;
unregister_host_class:
mmc_unregister_host_class();
unregister_bus:
mmc_unregister_bus();
destroy_workqueue:
destroy_workqueue(workqueue);
return ret;
}
static int __devinit smb328a_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct smb328a_platform_data *pdata = client->dev.platform_data;
int ret;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
printk("+++++++++++++++ %s +++++++++++++++\n", __func__);
smb328a_i2c_client = client;
pdata->start_charging = smb328a_start_charging;
pdata->stop_charging = smb328a_stop_charging;
pdata->get_vbus_status = smb328a_get_vbus_status;
INIT_WORK(&chg_work, _smb328a_chg_work);
setup_timer(&chg_work_timer, _smb328a_chg_work_timer_func, (unsigned long)pdata);
chg_wqueue = create_freezeable_workqueue("smb328a_wqueue");
ret = request_threaded_irq(client->irq, NULL, _smb328a_isr,
IRQF_TRIGGER_RISING,
"smb328a-isr", pdata);
_smb328a_print_register();
return 0;
}
static int ksuspend_usb_init(void)
{
ksuspend_usb_wq = create_freezeable_workqueue("ksuspend_usbd");
if (!ksuspend_usb_wq)
return -ENOMEM;
return 0;
}
static int bu92747_irda_startup(struct uart_port *port)
{
struct bu92747_port *s = container_of(port,
struct bu92747_port,
port);
char b[32];
struct rev_frame_length *f = &(s->rev_frames);
BU92747_IRDA_DBG("line %d, enter %s \n", __LINE__, __FUNCTION__);
dev_dbg(s->dev, "%s\n", __func__);
s->baud = 9600;
s->rx_enabled = 1;
spin_lock(&s->data_lock);
frame_length_buf_clear(f);
s->cur_frame_length = 0;
spin_unlock(&s->data_lock);
if (s->suspending)
return 0;
s->tx_empty = 1;
s->force_end_work = 0;
sprintf(b, "bu92747_irda-%d", s->minor);
s->workqueue = create_freezeable_workqueue(b);
if (!s->workqueue) {
dev_warn(s->dev, "cannot create workqueue\n");
return -EBUSY;
}
INIT_WORK(&s->work, bu92747_irda_work);
//atomic_set(&(s->data_ready), 0);
if (request_irq(s->irq, bu92747_irda_irq,
IRQ_TYPE_LEVEL_LOW, "bu92747_irda", s) < 0) {
dev_warn(s->dev, "cannot allocate irq %d\n", s->irq);
s->irq = 0;
destroy_workqueue(s->workqueue);
s->workqueue = NULL;
return -EBUSY;
}
disable_irq(s->irq);
if (s->pdata->irda_pwr_ctl)
s->pdata->irda_pwr_ctl(1);
irda_hw_startup();
irda_hw_set_moderx();
enable_irq(s->irq);
return 0;
}
static int ksuspend_usb_init(void)
{
/* This workqueue is supposed to be both freezable and
* singlethreaded. Its job doesn't justify running on more
* than one CPU.
*/
ksuspend_usb_wq = create_freezeable_workqueue("ksuspend_usbd");
if (!ksuspend_usb_wq)
return -ENOMEM;
return 0;
}
static int sc16is7x2_startup(struct uart_port *port)
{
struct sc16is7x2_channel *chan = to_sc16is7x2_channel(port);
struct sc16is7x2_chip *ts = chan->chip;
unsigned ch = (&ts->channel[1] == chan) ? 1 : 0;
unsigned long flags;
dev_dbg(&ts->spi->dev, "\n%s (%d)\n", __func__, port->line);
/* Clear the interrupt registers. */
sc16is7x2_write(ts, UART_IER, ch, 0);
sc16is7x2_read_status(ts, ch);
/* Initialize work queue */
chan->workqueue = create_freezeable_workqueue("sc16is7x2");
if (!chan->workqueue) {
dev_err(&ts->spi->dev, "Workqueue creation failed\n");
return -EBUSY;
}
INIT_WORK(&chan->work, sc16is7x2_handle_channel);
/* Setup IRQ. Actually we have a low active IRQ, but we want
* one shot behaviour */
if (request_irq(ts->spi->irq, sc16is7x2_irq,
IRQF_TRIGGER_FALLING | IRQF_SHARED,
"sc16is7x2", chan)) {
dev_err(&ts->spi->dev, "IRQ request failed\n");
destroy_workqueue(chan->workqueue);
chan->workqueue = NULL;
return -EBUSY;
}
spin_lock_irqsave(&chan->uart.lock, flags);
chan->lcr = UART_LCR_WLEN8;
chan->mcr = 0;
chan->fcr = 0;
chan->ier = UART_IER_RLSI | UART_IER_RDI | UART_IER_THRI;
spin_unlock_irqrestore(&chan->uart.lock, flags);
sc16is7x2_write(ts, UART_FCR, ch, UART_FCR_ENABLE_FIFO |
UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
sc16is7x2_write(ts, UART_FCR, ch, chan->fcr);
/* Now, initialize the UART */
sc16is7x2_write(ts, UART_LCR, ch, chan->lcr);
sc16is7x2_write(ts, UART_MCR, ch, chan->mcr);
sc16is7x2_write(ts, UART_IER, ch, chan->ier);
return 0;
}
static int __init mmc_init(void)
{
int ret;
wake_lock_init(&mmc_delayed_work_wake_lock, WAKE_LOCK_SUSPEND, "mmc_delayed_work");
/* FIH, BillHJChang, 2009/11/20 { */
/* [FXX_CR], issue of card detect fail in suspend mode */
#ifdef CONFIG_FIH_FXX
wake_lock_init(&sdcard_idle_wake_lock, WAKE_LOCK_IDLE, "sd_suspend_work");
#endif
/* } FIH, BillHJChang, 2009/11/20 */
/* FIH, SimonSSChang, 2010/08/25 { */
/* avoid WIFI firmware reload fail when to do kernel resume */
#ifdef CONFIG_FIH_FXX
workqueue = create_singlethread_workqueue("kmmcd");
#else
workqueue = create_freezeable_workqueue("kmmcd");
#endif
/* } FIH, SimonSSChang, 2010/08/25 */
if (!workqueue)
return -ENOMEM;
ret = mmc_register_bus();
if (ret)
goto destroy_workqueue;
ret = mmc_register_host_class();
if (ret)
goto unregister_bus;
ret = sdio_register_bus();
if (ret)
goto unregister_host_class;
return 0;
unregister_host_class:
mmc_unregister_host_class();
unregister_bus:
mmc_unregister_bus();
destroy_workqueue:
destroy_workqueue(workqueue);
return ret;
}
static int __devinit fan5403_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct fan5403_platform_data *pdata = client->dev.platform_data;
int ret;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
pr_info("+++++++++++++++ %s +++++++++++++++\n", __func__);
fan5403_i2c_client = client;
/* Init Rx functions from host */
pdata->start_charging = fan5403_start_charging;
pdata->stop_charging = fan5403_stop_charging;
pdata->get_vbus_status = fan5403_get_vbus_status;
pdata->set_host_status = fan5403_set_host_status;
pdata->get_monitor_bits = fan5403_get_monitor_bits;
INIT_WORK(&chg_work, _fan5403_chg_work);
setup_timer(&chg_work_timer, _fan5403_chg_work_timer_func, (unsigned long)pdata);
chg_wqueue = create_freezeable_workqueue("fan5403_wqueue");
if (HWREV == 0x1) { /* REV0.5 */
ret = request_threaded_irq(client->irq, NULL, _fan5403_handle_stat,
(IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING),
"fan5403-stat", pdata);
}
_fan5403_customize_register_settings();
_fan5403_print_register();
return 0;
}
static int __init pm_start_workqueue(void)
{
pm_wq = create_freezeable_workqueue("pm");
return pm_wq ? 0 : -ENOMEM;
}
static int __devinit omapl_pru_can_probe(struct platform_device *pdev)
{
struct net_device *ndev = NULL;
struct omapl_pru_can_priv *priv = NULL;
struct ti_pru_can_platform_data *pdata;
struct resource *res_mem, *trx_irq;
pru_can_firmware_structure fw_pru;
u32 err, retries = 0;
pdata = pdev->dev.platform_data;
if (!pdata) {
dev_err(&pdev->dev, "no platform data provided for pru!\n");
return -ENODEV;
}
res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res_mem) {
dev_err(&pdev->dev, "unable to get pru memory resources!\n");
err = -ENODEV;
goto probe_exit;
}
trx_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!trx_irq) {
dev_err(&pdev->dev, "unable to get pru interrupt resources!\n");
err = -ENODEV;
goto probe_exit;
}
if (!request_mem_region(res_mem->start, resource_size(res_mem),
dev_name(&pdev->dev))) {
dev_err(&pdev->dev, "pru memory region already claimed!\n");
err = -EBUSY;
goto probe_exit;
}
ndev = alloc_candev(sizeof(struct omapl_pru_can_priv), MB_MAX + 1);
if (!ndev) {
dev_err(&pdev->dev, "alloc_candev failed\n");
err = -ENOMEM;
goto probe_exit_free_region;
}
priv = netdev_priv(ndev);
priv->pru_arm_iomap.pru_io_addr =
ioremap(res_mem->start, resource_size(res_mem));
if (!priv->pru_arm_iomap.pru_io_addr) {
dev_err(&pdev->dev, "ioremap failed\n");
err = -ENOMEM;
goto probe_exit_free_region;
}
priv->pru_arm_iomap.psc0_io_addr = IO_ADDRESS(DA8XX_PSC0_BASE);
if (!priv->pru_arm_iomap.psc0_io_addr) {
dev_err(&pdev->dev, "ioremap failed\n");
err = -ENOMEM;
goto probe_exit_iounmap;
}
priv->pru_arm_iomap.psc1_io_addr = IO_ADDRESS(DA8XX_PSC1_BASE);
if (!priv->pru_arm_iomap.psc1_io_addr) {
dev_err(&pdev->dev, "ioremap failed\n");
err = -ENOMEM;
goto probe_exit_iounmap;
}
priv->pru_arm_iomap.syscfg_io_addr = IO_ADDRESS(DA8XX_SYSCFG0_BASE);
if (!priv->pru_arm_iomap.syscfg_io_addr) {
dev_err(&pdev->dev, "ioremap failed\n");
err = -ENOMEM;
goto probe_exit_iounmap;
}
priv->ndev = ndev;
priv->trx_irq = trx_irq->start;
priv->can.bittiming_const = NULL;
priv->can.do_set_bittiming = omapl_pru_can_set_bittiming;
priv->can.do_set_mode = omapl_pru_can_set_mode;
priv->can.do_get_state = omapl_pru_can_get_state;
priv->can_tx_hndl.u8prunumber = CAN_TX_PRU_1;
priv->can_rx_hndl.u8prunumber = CAN_RX_PRU_0;
ndev->flags |= (IFF_ECHO | IFF_NOARP); /* we support local echo, no arp */
platform_set_drvdata(pdev, ndev);
SET_NETDEV_DEV(ndev, &pdev->dev);
ndev->netdev_ops = &omapl_pru_can_netdev_ops;
priv->clk = clk_get(&pdev->dev, "pru_ck");
if (IS_ERR(priv->clk)) {
dev_err(&pdev->dev, "no clock available\n");
err = PTR_ERR(priv->clk);
priv->clk = NULL;
goto probe_exit_candev;
}
priv->can.clock.freq = clk_get_rate(priv->clk);
priv->clk_timer = clk_get(&pdev->dev, "pll1_sysclk2");
if (IS_ERR(priv->clk_timer)) {
dev_err(&pdev->dev, "no timer clock available\n");
err = PTR_ERR(priv->clk_timer);
priv->clk_timer = NULL;
goto probe_exit_candev;
}
priv->timer_freq = clk_get_rate(priv->clk_timer);
err = register_candev(ndev);
if (err) {
dev_err(&pdev->dev, "register_candev() failed\n");
err = -ENODEV;
goto probe_exit_clk;
}
err = request_firmware(&priv->fw_tx, "PRU_CAN_Emulation_Tx.bin",
&pdev->dev);
if (err) {
dev_err(&pdev->dev, "can't load firmware\n");
err = -ENODEV;
goto probe_exit_clk;
}
dev_info(&pdev->dev, "fw_tx size %d. downloading...\n",
priv->fw_tx->size);
err = request_firmware(&priv->fw_rx, "PRU_CAN_Emulation_Rx.bin",
&pdev->dev);
if (err) {
dev_err(&pdev->dev, "can't load firmware\n");
err = -ENODEV;
goto probe_release_fw;
}
dev_info(&pdev->dev, "fw_rx size %d. downloading...\n",
priv->fw_rx->size);
fw_pru.ptr_pru1 = kmalloc(priv->fw_tx->size, GFP_KERNEL);
memcpy((void *)fw_pru.ptr_pru1, (const void *)priv->fw_tx->data,
priv->fw_tx->size);
fw_pru.u32_pru1_code_size = priv->fw_tx->size;
fw_pru.ptr_pru0 = kmalloc(priv->fw_rx->size, GFP_KERNEL);
memcpy((void *)fw_pru.ptr_pru0, (const void *)priv->fw_rx->data,
priv->fw_rx->size);
fw_pru.u32_pru0_code_size = priv->fw_rx->size;
/* init the pru */
pru_can_emulation_init(&priv->pru_arm_iomap, priv->can.clock.freq);
while ((pru_can_check_init_status()) && (retries++ < MAX_INIT_RETRIES))
udelay(retries);
if (MAX_INIT_RETRIES <= retries) {
dev_err(&pdev->dev, "failed to initialize the pru\n");
err = -ENODEV;
goto probe_release_fw_1;
}
pru_can_enable();
/* download firmware into pru */
err = pru_can_download_firmware(&fw_pru, 0);
if (err) {
dev_err(&pdev->dev, "firmware download error\n");
err = -ENODEV;
goto probe_release_fw_1;
}
err = pru_can_download_firmware(&fw_pru, 1);
if (err) {
dev_err(&pdev->dev, "firmware download error\n");
err = -ENODEV;
goto probe_release_fw_1;
}
if (pru_can_calculatetiming (DFLT_PRU_FREQ, DFLT_PRU_BITRATE) != 0) {
return -EINVAL;
}
pru_can_run(0);
pru_can_run(1);
kfree((const void *)fw_pru.ptr_pru0);
kfree((const void *)fw_pru.ptr_pru1);
/*Create The Work Queue */
if ((priv->pru_can_wQ =
create_freezeable_workqueue("omapl_pru_wQ")) == NULL)
dev_err(&pdev->dev, "failed to create work queue\n");
INIT_WORK(&priv->rx_work, omapl_pru_can_rx_wQ);
dev_info(&pdev->dev,
"%s device registered"
"(®_base=0x%p, trx_irq = %d, clk = %d)\n",
DRV_NAME, priv->pru_arm_iomap.pru_io_addr, priv->trx_irq,
priv->can.clock.freq);
return 0;
probe_release_fw_1:
kfree((const void *)fw_pru.ptr_pru0);
kfree((const void *)fw_pru.ptr_pru1);
release_firmware(priv->fw_rx);
probe_release_fw:
release_firmware(priv->fw_tx);
probe_exit_clk:
clk_put(priv->clk);
probe_exit_candev:
if (NULL != ndev)
free_candev(ndev);
probe_exit_iounmap:
iounmap(priv->pru_arm_iomap.pru_io_addr);
probe_exit_free_region:
release_mem_region(res_mem->start, resource_size(res_mem));
probe_exit:
return err;
}
static int __devinit max17040_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct input_dev *input_data = NULL;
int ret;
#if 0
int aflag=0;
#endif
sleep_dbg("[MAX17040] max17040_probe [IN]\n");
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
max17040_data.client = client;
i2c_set_clientdata(client, &max17040_data);
//sys file system are registered
max17040_data.battery.name = "batterys";
max17040_data.battery.type = POWER_SUPPLY_TYPE_BATTERY;
max17040_data.battery.get_property = max17040_get_property;
max17040_data.battery.properties = max17040_battery_props;
max17040_data.battery.external_power_changed = max17040_bat_external_power_changed;
max17040_data.battery.num_properties = ARRAY_SIZE(max17040_battery_props);
ret = power_supply_register(&client->dev, &max17040_data.battery);
if (ret) {
sleep_dbg("[MAX17040] failed: power supply register [ERROR]\n");
i2c_set_clientdata(client, NULL);
return ret;
}
//The code used in the test mode [TEST MODE]
ret = sysfs_create_group(&client->dev.kobj, &max17040_attr_group);
if (ret) {
sleep_dbg("[MAX17040] failed: sysfs_create_group [ERROR]\n");
}
//mutex is init
mutex_init(&max17040_data.data_mutex);
mutex_init(&max17040_data.i2c_mutex);
mutex_init(&max17040_data.quick_mutex);
//rcomp is set
max17040_set_rcomp();
//Version of reading
max17040_get_version();
//read vell and soc
max17040_quick_get_vcell();
max17040_quick_get_soc();
#if 0
//check quick start
aflag=max17040_check_restart(max17040_data.quick_data.quick_vcell,max17040_data.quick_data.quick_soc);
if(aflag)
{
max17040_restart();
msleep(300); //quick start update time
}
#endif
//The code used in the test mode [TEST MODE]
atomic_set(&max17040_data.set_test, 0);
input_data = input_allocate_device();
if (!input_data) {
sleep_dbg("MAX17040: Unable to input_allocate_device \n");
return -1;
}
set_bit(EV_REL,input_data->evbit);
input_set_capability(input_data, EV_REL, REL_RX);
input_set_capability(input_data, EV_REL, REL_RY); /* wake */
input_set_capability(input_data, EV_REL, REL_RZ); /* wake */
input_data->name="max17040";
ret =input_register_device(input_data);
if (ret) {
sleep_dbg("MAX17040: Unable to register input_data device\n");
return -1;
}
input_set_drvdata(input_data, &max17040_data);
max17040_data.max17040_input_data=input_data;
//initialize workqueue and alarm setting
wake_lock_init(&max17040_data.work_wake_lock, WAKE_LOCK_SUSPEND,
"max17040-battery");
#ifdef MAX17040_ALARM_RTC_ENABLE
max17040_data.last_poll=alarm_get_elapsed_realtime();
INIT_WORK(&max17040_data.monitor_work, max17040_work);
max17040_data.monitor_wqueue = create_freezeable_workqueue("max17040");
/* init to something sane */
if (!max17040_data.monitor_wqueue) {
sleep_dbg("fail_workqueue Error [PROBE FUNCTION]");
return -1;
}
alarm_init(&max17040_data.alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
max_battery_alarm_callback);
//prevent suspend
max17040_prevent_suspend();
#ifdef CONFIG_HAS_EARLYSUSPEND
max17040_data.early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN;
max17040_data.early_suspend.suspend = max17040_batt_early_suspend;
max17040_data.early_suspend.resume = max17040_batt_late_resume;
dbg("set max17040 EARLY_SUSPEND\n");
register_early_suspend(&max17040_data.early_suspend);
#endif //CONFIG_HAS_EARLYSUSPEND
queue_work(max17040_data.monitor_wqueue, &max17040_data.monitor_work);
#else
INIT_DELAYED_WORK_DEFERRABLE(&max17040_data.work, max17040_work);
schedule_delayed_work(&max17040_data.work, 0);
#endif //MAX17040_ALARM_RTC_ENABLE
sleep_dbg("[MAX17040] max17040_probe [OUT]\n");
return 0;
}
static __devinit int max8998_charger_probe(struct platform_device *pdev)
{
struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent);
struct max8998_platform_data *pdata = dev_get_platdata(iodev->dev);
struct chg_data *chg;
struct i2c_client *i2c = iodev->i2c;
int ret = 0;
bat_info("%s : MAX8998 Charger Driver Loading\n", __func__);
chg = kzalloc(sizeof(*chg), GFP_KERNEL);
if (!chg)
return -ENOMEM;
chg->iodev = iodev;
chg->pdata = pdata->charger;
if (!chg->pdata || !chg->pdata->adc_table) {
pr_err("%s : No platform data & adc_table supplied\n", __func__);
ret = -EINVAL;
goto err_bat_table;
}
chg->psy_bat.name = "battery";
chg->psy_bat.type = POWER_SUPPLY_TYPE_BATTERY;
chg->psy_bat.properties = max8998_battery_props;
chg->psy_bat.num_properties = ARRAY_SIZE(max8998_battery_props);
chg->psy_bat.get_property = s3c_bat_get_property;
chg->psy_usb.name = "usb";
chg->psy_usb.type = POWER_SUPPLY_TYPE_USB;
chg->psy_usb.supplied_to = supply_list;
chg->psy_usb.num_supplicants = ARRAY_SIZE(supply_list);
chg->psy_usb.properties = s3c_power_properties;
chg->psy_usb.num_properties = ARRAY_SIZE(s3c_power_properties);
chg->psy_usb.get_property = s3c_usb_get_property;
chg->psy_ac.name = "ac";
chg->psy_ac.type = POWER_SUPPLY_TYPE_MAINS;
chg->psy_ac.supplied_to = supply_list;
chg->psy_ac.num_supplicants = ARRAY_SIZE(supply_list);
chg->psy_ac.properties = s3c_power_properties;
chg->psy_ac.num_properties = ARRAY_SIZE(s3c_power_properties);
chg->psy_ac.get_property = s3c_ac_get_property;
chg->present = 1;
chg->bat_info.batt_health = POWER_SUPPLY_HEALTH_GOOD;
chg->bat_info.batt_is_full = false;
chg->set_batt_full = false;
chg->set_charge_timeout = false;
chg->cable_status = CABLE_TYPE_NONE;
chg->esafe = MAX8998_USB_VBUS_AP_ON;
mutex_init(&chg->mutex);
platform_set_drvdata(pdev, chg);
ret = max8998_write_reg(i2c, MAX8998_REG_IRQM1,
~(MAX8998_IRQ_DCINR_MASK | MAX8998_IRQ_DCINF_MASK));
if (ret < 0)
goto err_kfree;
ret = max8998_write_reg(i2c, MAX8998_REG_IRQM2, 0xFF);
if (ret < 0)
goto err_kfree;
#ifdef TOPOFF_CURRENT_CHECK
ret = max8998_write_reg(i2c, MAX8998_REG_IRQM3, 0xFF);
#else
ret = max8998_write_reg(i2c, MAX8998_REG_IRQM3, ~MAX8998_IRQ_TOPOFFR_MASK);
#endif
if (ret < 0)
goto err_kfree;
ret = max8998_write_reg(i2c, MAX8998_REG_IRQM4,
~(MAX8998_IRQ_LOBAT2_MASK | MAX8998_IRQ_LOBAT1_MASK));
if (ret < 0)
goto err_kfree;
ret = max8998_update_reg(i2c, MAX8998_REG_ONOFF3,
(1 << MAX8998_SHIFT_ENBATTMON), MAX8998_MASK_ENBATTMON);
if (ret < 0)
goto err_kfree;
ret = max8998_update_reg(i2c, MAX8998_REG_LBCNFG1, 0x7, 0x37); //3.57V
if (ret < 0)
goto err_kfree;
ret = max8998_update_reg(i2c, MAX8998_REG_LBCNFG2, 0x5, 0x37); //3.4V
if (ret < 0)
goto err_kfree;
max8998_lowbat_config(chg, 0);
wake_lock_init(&chg->vbus_wake_lock, WAKE_LOCK_SUSPEND, "vbus_present");
wake_lock_init(&chg->work_wake_lock, WAKE_LOCK_SUSPEND, "max8998-charger");
wake_lock_init(&chg->lowbat_wake_lock, WAKE_LOCK_SUSPEND, "max8998-lowbat");
INIT_WORK(&chg->bat_work, s3c_bat_work);
setup_timer(&chg->bat_work_timer, s3c_bat_work_timer_func, (unsigned long)chg);
chg->monitor_wqueue = create_freezeable_workqueue(dev_name(&pdev->dev));
if (!chg->monitor_wqueue) {
pr_err("%s : Failed to create freezeable workqueue\n", __func__);
ret = -ENOMEM;
goto err_wake_lock;
}
check_lpm_charging_mode(chg);
/* init power supplier framework */
ret = power_supply_register(&pdev->dev, &chg->psy_bat);
if (ret) {
pr_err("%s : Failed to register power supply psy_bat\n", __func__);
goto err_wqueue;
}
ret = power_supply_register(&pdev->dev, &chg->psy_usb);
if (ret) {
pr_err("%s : Failed to register power supply psy_usb\n", __func__);
goto err_supply_unreg_bat;
}
ret = power_supply_register(&pdev->dev, &chg->psy_ac);
if (ret) {
pr_err("%s : Failed to register power supply psy_ac\n", __func__);
goto err_supply_unreg_usb;
}
ret = request_threaded_irq(iodev->i2c->irq, NULL, max8998_int_work_func,
IRQF_TRIGGER_FALLING, "max8998-charger", chg);
if (ret) {
pr_err("%s : Failed to request pmic irq\n", __func__);
goto err_supply_unreg_ac;
}
ret = enable_irq_wake(iodev->i2c->irq);
if (ret) {
pr_err("%s : Failed to enable pmic irq wake\n", __func__);
goto err_irq;
}
ret = s3c_bat_create_attrs(chg->psy_bat.dev);
if (ret) {
pr_err("%s : Failed to create_attrs\n", __func__);
goto err_irq;
}
chg->callbacks.set_cable = max8998_set_cable;
chg->callbacks.set_esafe = max8998_set_esafe;
chg->callbacks.get_vdcin = max8998_get_vdcin;
if (chg->pdata->register_callbacks)
chg->pdata->register_callbacks(&chg->callbacks);
wake_lock(&chg->work_wake_lock);
queue_work(chg->monitor_wqueue, &chg->bat_work);
return 0;
err_irq:
free_irq(iodev->i2c->irq, NULL);
err_supply_unreg_ac:
power_supply_unregister(&chg->psy_ac);
err_supply_unreg_usb:
power_supply_unregister(&chg->psy_usb);
err_supply_unreg_bat:
power_supply_unregister(&chg->psy_bat);
err_wqueue:
destroy_workqueue(chg->monitor_wqueue);
cancel_work_sync(&chg->bat_work);
err_wake_lock:
wake_lock_destroy(&chg->work_wake_lock);
wake_lock_destroy(&chg->vbus_wake_lock);
wake_lock_destroy(&chg->lowbat_wake_lock);
err_kfree:
mutex_destroy(&chg->mutex);
err_bat_table:
kfree(chg);
return ret;
}
static __devinit int max8998_charger_probe(struct platform_device *pdev)
{
struct max8998_dev *iodev = dev_get_drvdata(pdev->dev.parent);
struct max8998_platform_data *pdata = dev_get_platdata(iodev->dev);
struct chg_data *chg;
int ret = 0;
pr_info("%s : MAX8998 Charger Driver Loading\n", __func__);
chg = kzalloc(sizeof(*chg), GFP_KERNEL);
if (!chg)
return -ENOMEM;
chg->iodev = iodev;
chg->pdata = pdata->charger;
if (!chg->pdata || !chg->pdata->adc_table) {
pr_err("%s : No platform data & adc_table supplied\n", __func__);
ret = -EINVAL;
goto err_bat_table;
}
chg->psy_bat.name = "battery",
chg->psy_bat.type = POWER_SUPPLY_TYPE_BATTERY,
chg->psy_bat.properties = max8998_battery_props,
chg->psy_bat.num_properties = ARRAY_SIZE(max8998_battery_props),
chg->psy_bat.get_property = s3c_bat_get_property,
chg->psy_usb.name = "usb",
chg->psy_usb.type = POWER_SUPPLY_TYPE_USB,
chg->psy_usb.supplied_to = supply_list,
chg->psy_usb.num_supplicants = ARRAY_SIZE(supply_list),
chg->psy_usb.properties = s3c_power_properties,
chg->psy_usb.num_properties = ARRAY_SIZE(s3c_power_properties),
chg->psy_usb.get_property = s3c_usb_get_property,
chg->psy_ac.name = "ac",
chg->psy_ac.type = POWER_SUPPLY_TYPE_MAINS,
chg->psy_ac.supplied_to = supply_list,
chg->psy_ac.num_supplicants = ARRAY_SIZE(supply_list),
chg->psy_ac.properties = s3c_power_properties,
chg->psy_ac.num_properties = ARRAY_SIZE(s3c_power_properties),
chg->psy_ac.get_property = s3c_ac_get_property,
chg->present = 1;
chg->polling_interval = POLLING_INTERVAL;
chg->bat_info.batt_health = POWER_SUPPLY_HEALTH_GOOD;
chg->bat_info.batt_is_full = false;
chg->bat_info.batt_max_soc = 0;
chg->set_charge_timeout = false;
chg->cable_status = CABLE_TYPE_NONE;
mutex_init(&chg->mutex);
platform_set_drvdata(pdev, chg);
ret = max8998_update_reg(iodev, MAX8998_REG_CHGR1, /* disable */
(0x3 << MAX8998_SHIFT_RSTR), MAX8998_MASK_RSTR);
if (ret < 0)
goto err_kfree;
ret = max8998_update_reg(iodev, MAX8998_REG_CHGR2, /* 6 Hr */
(0x2 << MAX8998_SHIFT_FT), MAX8998_MASK_FT);
if (ret < 0)
goto err_kfree;
ret = max8998_update_reg(iodev, MAX8998_REG_CHGR2, /* 4.2V */
(0x0 << MAX8998_SHIFT_BATTSL), MAX8998_MASK_BATTSL);
if (ret < 0)
goto err_kfree;
ret = max8998_update_reg(iodev, MAX8998_REG_CHGR2, /* 105c */
(0x0 << MAX8998_SHIFT_TMP), MAX8998_MASK_TMP);
if (ret < 0)
goto err_kfree;
pr_info("%s : pmic interrupt registered\n", __func__);
ret = max8998_write_reg(iodev, MAX8998_REG_IRQM1,
~(MAX8998_MASK_DCINR | MAX8998_MASK_DCINF));
if (ret < 0)
goto err_kfree;
ret = max8998_write_reg(iodev, MAX8998_REG_IRQM2, 0xFF);
if (ret < 0)
goto err_kfree;
ret = max8998_write_reg(iodev, MAX8998_REG_IRQM3, ~0x4);
if (ret < 0)
goto err_kfree;
ret = max8998_write_reg(iodev, MAX8998_REG_IRQM4, 0xFF);
if (ret < 0)
goto err_kfree;
wake_lock_init(&chg->vbus_wake_lock, WAKE_LOCK_SUSPEND,
"vbus_present");
wake_lock_init(&chg->work_wake_lock, WAKE_LOCK_SUSPEND,
"max8998-charger");
INIT_WORK(&chg->bat_work, s3c_bat_work);
chg->monitor_wqueue =
create_freezeable_workqueue(dev_name(&pdev->dev));
if (!chg->monitor_wqueue) {
pr_err("Failed to create freezeable workqueue\n");
ret = -ENOMEM;
goto err_wake_lock;
}
chg->last_poll = alarm_get_elapsed_realtime();
alarm_init(&chg->alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
s3c_battery_alarm);
check_lpm_charging_mode(chg);
/* init power supplier framework */
ret = power_supply_register(&pdev->dev, &chg->psy_bat);
if (ret) {
pr_err("Failed to register power supply psy_bat\n");
goto err_wqueue;
}
ret = power_supply_register(&pdev->dev, &chg->psy_usb);
if (ret) {
pr_err("Failed to register power supply psy_usb\n");
goto err_supply_unreg_bat;
}
ret = power_supply_register(&pdev->dev, &chg->psy_ac);
if (ret) {
pr_err("Failed to register power supply psy_ac\n");
goto err_supply_unreg_usb;
}
ret = request_threaded_irq(iodev->i2c_client->irq, NULL,
max8998_int_work_func,
IRQF_TRIGGER_FALLING, "max8998-charger", chg);
if (ret) {
pr_err("%s : Failed to request pmic irq\n", __func__);
goto err_supply_unreg_ac;
}
ret = enable_irq_wake(iodev->i2c_client->irq);
if (ret) {
pr_err("Failed to enable pmic irq wake\n");
goto err_irq;
}
ret = s3c_bat_create_attrs(chg->psy_bat.dev);
if (ret) {
pr_err("%s : Failed to create_attrs\n", __func__);
goto err_irq;
}
chg->callbacks.set_cable = max8998_set_cable;
if (chg->pdata->register_callbacks)
chg->pdata->register_callbacks(&chg->callbacks);
wake_lock(&chg->work_wake_lock);
queue_work(chg->monitor_wqueue, &chg->bat_work);
return 0;
err_irq:
free_irq(iodev->i2c_client->irq, NULL);
err_supply_unreg_ac:
power_supply_unregister(&chg->psy_ac);
err_supply_unreg_usb:
power_supply_unregister(&chg->psy_usb);
err_supply_unreg_bat:
power_supply_unregister(&chg->psy_bat);
err_wqueue:
destroy_workqueue(chg->monitor_wqueue);
cancel_work_sync(&chg->bat_work);
alarm_cancel(&chg->alarm);
err_wake_lock:
wake_lock_destroy(&chg->work_wake_lock);
wake_lock_destroy(&chg->vbus_wake_lock);
err_kfree:
mutex_destroy(&chg->mutex);
err_bat_table:
kfree(chg);
return ret;
}
static int capella_cm3602_setup(struct capella_cm3602_data *ip)
{
int rc = -EIO;
struct capella_cm3602_platform_data *pdata = ip->pdata;
//int irq = gpio_to_irq(pdata->p_out);
char b[20];
D("%s\n", __func__);
rc = gpio_request(pdata->pwd_out_pin, "cm3602 out");
if (rc) {
pr_err("%s: request gpio %d failed \n", __func__, pdata->pwd_out_pin);
return rc;
}
rc = gpio_request(pdata->ps_shutdown_pin, "shut down pin");
if (rc) {
gpio_free(pdata->pwd_out_pin);
pr_err("%s: request gpio %d failed \n", __func__, pdata->ps_shutdown_pin);
return rc;
}
/*
gpio_direction_output(pdata->pwd_out_pin, SPI_GPIO_OUT);
gpio_set_value(pdata->pwd_out_pin, SPI_GPIO_LOW); //CM3605_PWD output
gpio_direction_output(pdata->ps_shutdown_pin, SPI_GPIO_OUT);
gpio_set_value(pdata->ps_shutdown_pin, SPI_GPIO_LOW); //CM3605_PS_SHUTDOWN
*/
rc = gpio_request(pdata->irq_pin, "cm3602 irq");
if (rc) {
gpio_free(pdata->pwd_out_pin);
gpio_free(pdata->ps_shutdown_pin);
pr_err("%s: request gpio %d failed \n", __func__, pdata->irq_pin);
return rc;
}
//rc = gpio_direction_input(pdata->irq_pin);
rc = request_irq(gpio_to_irq(pdata->irq_pin),capella_cm3602_irq_handler,SPI_GPIO_EDGE_FALLING,NULL, ip);
if (rc < 0) {
pr_err("%s: request_irq failed for gpio %d (%d)\n",
__func__,
pdata->p_out, rc);
goto fail_free_p_out;
}
sprintf(b,"cm3602_workqueue");
ip->cm3602_workqueue = create_freezeable_workqueue(b);
if(!ip->cm3602_workqueue)
{
printk("cannot create cm3602 workqueue\n");
return -EBUSY;
}
INIT_WORK(&ip->cm3602_work, cm3602_work_handler);
setup_timer(&ip->cm3602_timer,cm3602_timer,(unsigned long)ip);
ip->cm3602_timer.expires = jiffies + HZ;
add_timer(&ip->cm3602_timer);
//chenli:psensor off by default
ip->pdata->power(0);
/*
rc = set_irq_wake(irq, 1);
if (rc < 0) {
pr_err("%s: failed to set irq %d as a wake interrupt\n",
__func__, irq);
goto fail_free_irq;
}
*/
goto done;
/*
fail_free_irq:
free_irq(irq, 0);*/
fail_free_p_out:
gpio_free(pdata->irq_pin);
done:
return rc;
}
/**
* \fn wlanDrvIf_Create
* \brief Create the driver instance
*
* Allocate driver object.
* Initialize driver OS resources (IRQ, workqueue, events socket)
* Setup driver network interface.
* Create and link all driver modules.
*
* \note
* \param void
* \return 0 - OK, else - failure
* \sa wlanDrvIf_Destroy
*/
static int wlanDrvIf_Create (void)
{
TWlanDrvIfObj *drv; /* Dm: Failure is not cleaned properly !!! */
int rc;
/* Allocate driver's structure */
drv = kmalloc (sizeof(TWlanDrvIfObj), GFP_KERNEL);
if (!drv)
{
return -ENOMEM;
}
#ifdef TI_DBG
tb_init(TB_OPTION_NONE);
#endif
pDrvStaticHandle = drv; /* save for module destroy */
#ifdef TI_MEM_ALLOC_TRACE
os_printf ("MTT:%s:%d ::kmalloc(%lu, %x) : %lu\n", __FUNCTION__, __LINE__, sizeof(TWlanDrvIfObj), GFP_KERNEL, sizeof(TWlanDrvIfObj));
#endif
memset (drv, 0, sizeof(TWlanDrvIfObj));
/* Dm: drv->irq = TNETW_IRQ; */
drv->tCommon.eDriverState = DRV_STATE_IDLE;
drv->tiwlan_wq = create_freezeable_workqueue(DRIVERWQ_NAME);
if (!drv->tiwlan_wq) {
ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to create workQ!\n");
rc = -EINVAL;
goto drv_create_end_1;
}
drv->wl_packet = 0;
drv->wl_count = 0;
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_init(&drv->wl_wifi, WAKE_LOCK_SUSPEND, "wifi_wake");
wake_lock_init(&drv->wl_rxwake, WAKE_LOCK_SUSPEND, "wifi_rx_wake");
#endif
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask, (void *)drv);
#else
INIT_WORK(&drv->tWork, wlanDrvIf_DriverTask);
#endif
spin_lock_init (&drv->lock);
/* Setup driver network interface. */
rc = wlanDrvIf_SetupNetif (drv);
if (rc) {
goto drv_create_end_2;
}
/* Create the events socket interface */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,23)
drv->wl_sock = netlink_kernel_create( NETLINK_USERSOCK, 0, NULL, THIS_MODULE );
#else
drv->wl_sock = netlink_kernel_create(&init_net, NETLINK_USERSOCK, 0, NULL, NULL, THIS_MODULE );
#endif
if (drv->wl_sock == NULL) {
ti_dprintf (TIWLAN_LOG_ERROR, "netlink_kernel_create() failed !\n");
rc = -EINVAL;
goto drv_create_end_3;
}
/* Create all driver modules and link their handles */
rc = drvMain_Create (drv,
&drv->tCommon.hDrvMain,
&drv->tCommon.hCmdHndlr,
&drv->tCommon.hContext,
&drv->tCommon.hTxDataQ,
&drv->tCommon.hTxMgmtQ,
&drv->tCommon.hTxCtrl,
&drv->tCommon.hTWD,
&drv->tCommon.hEvHandler,
&drv->tCommon.hCmdDispatch,
&drv->tCommon.hReport);
if (rc != TI_OK) {
ti_dprintf (TIWLAN_LOG_ERROR, "%s: Failed to dvrMain_Create!\n", __func__);
rc = -EINVAL;
goto drv_create_end_4;
}
/*
* Initialize interrupts (or polling mode for debug):
*/
#ifdef PRIODIC_INTERRUPT
/* Debug mode: Polling (the timer is started by HwInit process) */
drv->hPollTimer = os_timerCreate ((TI_HANDLE)drv, wlanDrvIf_PollIrqHandler, (TI_HANDLE)drv);
#else
/* Normal mode: Interrupts (the default mode) */
rc = hPlatform_initInterrupt (drv, (void*)wlanDrvIf_HandleInterrupt);
#if 1 //wait to debug
if (rc) {
ti_dprintf (TIWLAN_LOG_ERROR, "wlanDrvIf_Create(): Failed to register interrupt handler!\n");
goto drv_create_end_5;
}
#endif
#endif /* PRIODIC_INTERRUPT */
return 0;
#if 1 //wait to debug
drv_create_end_5:
/* Destroy all driver modules */
if (drv->tCommon.hDrvMain) {
drvMain_Destroy (drv->tCommon.hDrvMain);
}
#endif
drv_create_end_4:
if (drv->wl_sock) {
sock_release (drv->wl_sock->sk_socket);
}
drv_create_end_3:
/* Release the driver network interface */
if (drv->netdev) {
unregister_netdev (drv->netdev);
free_netdev (drv->netdev);
}
drv_create_end_2:
#ifdef CONFIG_HAS_WAKELOCK
wake_lock_destroy(&drv->wl_wifi);
wake_lock_destroy(&drv->wl_rxwake);
#endif
if (drv->tiwlan_wq)
destroy_workqueue(drv->tiwlan_wq);
drv_create_end_1:
kfree(drv);
printk("%s: Fail\n", __func__);
return rc;
}
static __devinit int sec_battery_probe(struct platform_device *pdev)
{
struct sec_battery_platform_data *pdata = pdev->dev.platform_data;
struct chg_data *chg;
int ret = 0;
pr_info("%s : Samsung Battery Driver Loading\n", __func__);
chg = kzalloc(sizeof(*chg), GFP_KERNEL);
if (!chg)
return -ENOMEM;
chg->pdata = pdata;
if (!chg->pdata || !chg->pdata->adc_table) {
pr_err("%s : No platform data & adc_table supplied\n", __func__);
ret = -EINVAL;
goto err_bat_table;
}
chg->psy_bat.name = "battery",
chg->psy_bat.type = POWER_SUPPLY_TYPE_BATTERY,
chg->psy_bat.properties = sec_battery_props,
chg->psy_bat.num_properties = ARRAY_SIZE(sec_battery_props),
chg->psy_bat.get_property = sec_bat_get_property,
chg->psy_usb.name = "usb",
chg->psy_usb.type = POWER_SUPPLY_TYPE_USB,
chg->psy_usb.supplied_to = supply_list,
chg->psy_usb.num_supplicants = ARRAY_SIZE(supply_list),
chg->psy_usb.properties = sec_power_properties,
chg->psy_usb.num_properties = ARRAY_SIZE(sec_power_properties),
chg->psy_usb.get_property = sec_usb_get_property,
chg->psy_ac.name = "ac",
chg->psy_ac.type = POWER_SUPPLY_TYPE_MAINS,
chg->psy_ac.supplied_to = supply_list,
chg->psy_ac.num_supplicants = ARRAY_SIZE(supply_list),
chg->psy_ac.properties = sec_power_properties,
chg->psy_ac.num_properties = ARRAY_SIZE(sec_power_properties),
chg->psy_ac.get_property = sec_ac_get_property,
chg->present = 1;
chg->polling_interval = POLLING_INTERVAL;
chg->bat_info.batt_health = POWER_SUPPLY_HEALTH_GOOD;
chg->bat_info.batt_is_full = false;
chg->set_charge_timeout = false;
chg->bat_info.batt_improper_ta = false;
chg->is_recharging = false;
#ifdef CONFIG_BATTERY_MAX17042
// Get battery type from fuelgauge driver.
if(chg->pdata && chg->pdata->fuelgauge_cb)
chg->battery_type = (battery_type_t)chg->pdata->fuelgauge_cb(
REQ_TEST_MODE_INTERFACE, TEST_MODE_BATTERY_TYPE_CHECK, 0);
// Check UV charging case.
if(chg->pdata && chg->pdata->pmic_charger &&
chg->pdata->pmic_charger->get_connection_status) {
if(chg->pdata->pmic_charger->get_connection_status() &&
check_UV_charging_case(chg))
chg->low_batt_boot_flag = true;
}
else
chg->low_batt_boot_flag = false;
// init delayed work
INIT_DELAYED_WORK(&chg->full_chg_work, full_comp_work_handler);
// Init low batt check threshold values.
if(chg->battery_type == SDI_BATTERY_TYPE)
chg->check_start_vol = 3550; // Under 3.55V
else if(chg->battery_type == ATL_BATTERY_TYPE)
chg->check_start_vol = 3450; // Under 3.45V
#endif
chg->cable_status = CABLE_TYPE_NONE;
chg->charging_status = CHARGING_STATUS_NONE;
mutex_init(&chg->mutex);
platform_set_drvdata(pdev, chg);
wake_lock_init(&chg->vbus_wake_lock, WAKE_LOCK_SUSPEND,
"vbus_present");
wake_lock_init(&chg->work_wake_lock, WAKE_LOCK_SUSPEND,
"sec_battery_work");
INIT_WORK(&chg->bat_work, sec_bat_work);
chg->monitor_wqueue =
create_freezeable_workqueue(dev_name(&pdev->dev));
if (!chg->monitor_wqueue) {
pr_err("Failed to create freezeable workqueue\n");
ret = -ENOMEM;
goto err_wake_lock;
}
chg->last_poll = alarm_get_elapsed_realtime();
alarm_init(&chg->alarm, ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
sec_battery_alarm);
/* init power supplier framework */
ret = power_supply_register(&pdev->dev, &chg->psy_bat);
if (ret) {
pr_err("Failed to register power supply psy_bat\n");
goto err_wqueue;
}
ret = power_supply_register(&pdev->dev, &chg->psy_usb);
if (ret) {
pr_err("Failed to register power supply psy_usb\n");
goto err_supply_unreg_bat;
}
ret = power_supply_register(&pdev->dev, &chg->psy_ac);
if (ret) {
pr_err("Failed to register power supply psy_ac\n");
goto err_supply_unreg_usb;
}
sec_bat_create_attrs(chg->psy_bat.dev);
chg->callbacks.set_cable = sec_bat_set_cable;
chg->callbacks.set_status = sec_bat_set_status;
chg->callbacks.force_update = sec_bat_force_update;
if (chg->pdata->register_callbacks)
chg->pdata->register_callbacks(&chg->callbacks);
wake_lock(&chg->work_wake_lock);
queue_work(chg->monitor_wqueue, &chg->bat_work);
p1_lpm_mode_check(chg);
return 0;
err_supply_unreg_ac:
power_supply_unregister(&chg->psy_ac);
err_supply_unreg_usb:
power_supply_unregister(&chg->psy_usb);
err_supply_unreg_bat:
power_supply_unregister(&chg->psy_bat);
err_wqueue:
destroy_workqueue(chg->monitor_wqueue);
cancel_work_sync(&chg->bat_work);
alarm_cancel(&chg->alarm);
err_wake_lock:
wake_lock_destroy(&chg->work_wake_lock);
wake_lock_destroy(&chg->vbus_wake_lock);
mutex_destroy(&chg->mutex);
err_bat_table:
kfree(chg);
return ret;
}