static int __devinit sec_fuelgauge_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct sec_fuelgauge_info *fuelgauge;
int ret = 0;
union power_supply_propval raw_soc_val;
dev_dbg(&client->dev,
"%s: SEC Fuelgauge Driver Loading\n", __func__);
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
fuelgauge = kzalloc(sizeof(*fuelgauge), GFP_KERNEL);
if (!fuelgauge)
return -ENOMEM;
mutex_init(&fuelgauge->fg_lock);
fuelgauge->client = client;
fuelgauge->pdata = client->dev.platform_data;
i2c_set_clientdata(client, fuelgauge);
fuelgauge->psy_fg.name = "sec-fuelgauge";
fuelgauge->psy_fg.type = POWER_SUPPLY_TYPE_UNKNOWN;
fuelgauge->psy_fg.get_property = sec_fg_get_property;
fuelgauge->psy_fg.set_property = sec_fg_set_property;
fuelgauge->psy_fg.properties = sec_fuelgauge_props;
fuelgauge->psy_fg.num_properties =
ARRAY_SIZE(sec_fuelgauge_props);
fuelgauge->capacity_max = fuelgauge->pdata->capacity_max;
#if 0
raw_soc_val.intval = SEC_FUELGAUGE_CAPACITY_TYPE_RAW;
sec_hal_fg_get_property(fuelgauge->client,
POWER_SUPPLY_PROP_CAPACITY, &raw_soc_val);
raw_soc_val.intval /= 10;
if(raw_soc_val.intval > fuelgauge->pdata->capacity_max)
sec_fg_calculate_dynamic_scale(fuelgauge);
#endif
if (!fuelgauge->pdata->fg_gpio_init()) {
dev_err(&client->dev,
"%s: Failed to Initialize GPIO\n", __func__);
goto err_free;
}
if (!sec_hal_fg_init(fuelgauge->client)) {
dev_err(&client->dev,
"%s: Failed to Initialize Fuelgauge\n", __func__);
goto err_free;
}
ret = power_supply_register(&client->dev, &fuelgauge->psy_fg);
if (ret) {
dev_err(&client->dev,
"%s: Failed to Register psy_fg\n", __func__);
goto err_free;
}
if (fuelgauge->pdata->fg_irq) {
INIT_DELAYED_WORK_DEFERRABLE(
&fuelgauge->isr_work, sec_fg_isr_work);
ret = request_threaded_irq(fuelgauge->pdata->fg_irq,
NULL, sec_fg_irq_thread,
fuelgauge->pdata->fg_irq_attr,
"fuelgauge-irq", fuelgauge);
if (ret) {
dev_err(&client->dev,
"%s: Failed to Reqeust IRQ\n", __func__);
goto err_supply_unreg;
}
ret = enable_irq_wake(gpio_to_irq(fuelgauge->pdata->fg_irq));
if (ret < 0)
dev_err(&client->dev,
"%s: Failed to Enable Wakeup Source(%d)\n",
__func__, ret);
}
fuelgauge->is_fuel_alerted = false;
if (fuelgauge->pdata->fuel_alert_soc >= 0) {
if (sec_hal_fg_fuelalert_init(fuelgauge->client,
fuelgauge->pdata->fuel_alert_soc))
wake_lock_init(&fuelgauge->fuel_alert_wake_lock,
WAKE_LOCK_SUSPEND, "fuel_alerted");
else {
dev_err(&client->dev,
"%s: Failed to Initialize Fuel-alert\n",
__func__);
goto err_irq;
}
}
fuelgauge->initial_update_of_soc = true;
ret = sec_fg_create_attrs(fuelgauge->psy_fg.dev);
if (ret) {
dev_err(&client->dev,
"%s : Failed to create_attrs\n", __func__);
goto err_irq;
}
dev_dbg(&client->dev,
"%s: SEC Fuelgauge Driver Loaded\n", __func__);
return 0;
err_irq:
if (fuelgauge->pdata->fg_irq)
free_irq(fuelgauge->pdata->fg_irq, fuelgauge);
wake_lock_destroy(&fuelgauge->fuel_alert_wake_lock);
err_supply_unreg:
power_supply_unregister(&fuelgauge->psy_fg);
err_free:
mutex_destroy(&fuelgauge->fg_lock);
kfree(fuelgauge);
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;
struct i2c_client *i2c = iodev->i2c;
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->set_charge_timeout = false;
chg->cable_status = CABLE_TYPE_NONE;
mutex_init(&chg->mutex);
platform_set_drvdata(pdev, chg);
ret = max8998_update_reg(i2c, MAX8998_REG_CHGR1, /* disable */
(0x3 << MAX8998_SHIFT_RSTR), MAX8998_MASK_RSTR);
if (ret < 0)
goto err_kfree;
ret = max8998_update_reg(i2c, MAX8998_REG_CHGR2, /* 6 Hr */
(0x2 << MAX8998_SHIFT_FT), MAX8998_MASK_FT);
if (ret < 0)
goto err_kfree;
ret = max8998_update_reg(i2c, MAX8998_REG_CHGR2, /* 4.2V */
(0x0 << MAX8998_SHIFT_BATTSL), MAX8998_MASK_BATTSL);
if (ret < 0)
goto err_kfree;
ret = max8998_update_reg(i2c, 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(i2c, MAX8998_REG_IRQM1,
~(MAX8998_MASK_DCINR | MAX8998_MASK_DCINF));
if (ret < 0)
goto err_kfree;
ret = max8998_write_reg(i2c, MAX8998_REG_IRQM2, 0xFF);
if (ret < 0)
goto err_kfree;
ret = max8998_write_reg(i2c, MAX8998_REG_IRQM3, ~0x4);
if (ret < 0)
goto err_kfree;
ret = max8998_write_reg(i2c, 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_freezable_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->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("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->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 __devinit tl2796_probe(struct spi_device *spi)
{
struct s5p_lcd *lcd;
int ret;
lcd = kzalloc(sizeof(struct s5p_lcd), GFP_KERNEL);
if (!lcd) {
pr_err("failed to allocate for lcd\n");
ret = -ENOMEM;
goto err_alloc;
}
mutex_init(&lcd->lock);
spi->bits_per_word = 9;
if (spi_setup(spi)) {
pr_err("failed to setup spi\n");
ret = -EINVAL;
goto err_setup;
}
lcd->g_spi = spi;
lcd->dev = &spi->dev;
lcd->bl = 255;
if (!spi->dev.platform_data) {
dev_err(lcd->dev, "failed to get platform data\n");
ret = -EINVAL;
goto err_setup;
}
lcd->data = (struct s5p_panel_data *)spi->dev.platform_data;
if (!lcd->data->gamma_table || !lcd->data->seq_display_set ||
!lcd->data->seq_etc_set || !lcd->data->standby_on ||
!lcd->data->standby_off) {
dev_err(lcd->dev, "Invalid platform data\n");
ret = -EINVAL;
goto err_setup;
}
lcd->gamma_adj_points =
lcd->data->gamma_adj_points ?: &default_gamma_adj_points;
lcd->bl_dev = backlight_device_register("s5p_bl",
&spi->dev, lcd, &s5p_bl_ops, NULL);
if (!lcd->bl_dev) {
dev_err(lcd->dev, "failed to register backlight\n");
ret = -EINVAL;
goto err_setup;
}
lcd->bl_dev->props.max_brightness = 255;
spi_set_drvdata(spi, lcd);
tl2796_ldi_enable(lcd);
#ifdef CONFIG_HAS_EARLYSUSPEND
lcd->early_suspend.suspend = tl2796_early_suspend;
lcd->early_suspend.resume = tl2796_late_resume;
lcd->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1;
register_early_suspend(&lcd->early_suspend);
#endif
pr_info("tl2796_probe successfully proved\n");
return 0;
err_setup:
mutex_destroy(&lcd->lock);
kfree(lcd);
err_alloc:
return ret;
}
static __devinit int adv7180_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct adv7180_state *state;
struct v4l2_subdev *sd;
struct soc_camera_device *icd = client->dev.platform_data;
int ret;
#ifndef CONFIG_ARCH_RK29
/* Check if the adapter supports the needed features */
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
#endif
v4l_info(client, "chip found @ 0x%02x (%s)\n",
client->addr << 1, client->adapter->name);
state = kzalloc(sizeof(struct adv7180_state), GFP_KERNEL);
if (state == NULL) {
ret = -ENOMEM;
goto err;
}
state->irq = client->irq;
INIT_WORK(&state->work, adv7180_work);
mutex_init(&state->mutex);
state->autodetect = true;
sd = &state->sd;
v4l2_i2c_subdev_init(sd, client, &adv7180_ops);
state->icd = icd;
icd->ops = &adv7180_sensor_ops;
icd->user_width = adv7180_pic_sizes[0].width;
icd->user_height = adv7180_pic_sizes[0].height;
icd->colorspace = adv7180_colour_fmts[0].colorspace;
adv7180_pwr_ctl(icd, 1);
ret = 0;
ret = i2c_smbus_read_byte_data(client, ADV7180_IDENT_REG);
if (ret != ADV7180_ID_7180)
goto err_unreg_subdev;
/* register for interrupts */
if (state->irq > 0) {
ret = request_irq(state->irq, adv7180_irq, 0, DRIVER_NAME,
state);
if (ret)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
ADV7180_ADI_CTRL_IRQ_SPACE);
if (ret < 0)
goto err_unreg_subdev;
/* config the Interrupt pin to be active low */
ret = i2c_smbus_write_byte_data(client, ADV7180_ICONF1_ADI,
ADV7180_ICONF1_ACTIVE_LOW | ADV7180_ICONF1_PSYNC_ONLY);
if (ret < 0)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR1_ADI, 0);
if (ret < 0)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR2_ADI, 0);
if (ret < 0)
goto err_unreg_subdev;
/* enable AD change interrupts interrupts */
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR3_ADI,
ADV7180_IRQ3_AD_CHANGE);
if (ret < 0)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_IMR4_ADI, 0);
if (ret < 0)
goto err_unreg_subdev;
ret = i2c_smbus_write_byte_data(client, ADV7180_ADI_CTRL_REG,
0);
if (ret < 0)
goto err_unreg_subdev;
}
adv7180_pwr_ctl(icd, 0);
v4l_info(client, "chip probe success @ 0x%02x (%s)\n",
client->addr << 1, client->adapter->name);
return 0;
err_unreg_subdev:
adv7180_pwr_ctl(icd, 0);
mutex_destroy(&state->mutex);
v4l2_device_unregister_subdev(sd);
kfree(state);
err:
printk(KERN_ERR DRIVER_NAME ": Failed to probe: %d\n", ret);
return ret;
}
static int __devinit fsa9485_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct fsa9485_usbsw *usbsw;
int ret = 0;
struct input_dev *input;
struct device *switch_dev;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
input = input_allocate_device();
usbsw = kzalloc(sizeof(struct fsa9485_usbsw), GFP_KERNEL);
if (!usbsw || !input) {
dev_err(&client->dev, "failed to allocate driver data\n");
kfree(usbsw);
return -ENOMEM;
}
usbsw->input = input;
input->name = client->name;
input->phys = "deskdock-key/input0";
input->dev.parent = &client->dev;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0001;
/* Enable auto repeat feature of Linux input subsystem */
__set_bit(EV_REP, input->evbit);
input_set_capability(input, EV_KEY, KEY_VOLUMEUP);
input_set_capability(input, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(input, EV_KEY, KEY_PLAYPAUSE);
input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG);
input_set_capability(input, EV_KEY, KEY_NEXTSONG);
ret = input_register_device(input);
if (ret) {
dev_err(&client->dev,
"input_register_device %s: err %d\n", __func__, ret);
}
usbsw->client = client;
usbsw->pdata = client->dev.platform_data;
if (!usbsw->pdata)
goto fail1;
i2c_set_clientdata(client, usbsw);
mutex_init(&usbsw->mutex);
local_usbsw = usbsw;
if (usbsw->pdata->cfg_gpio)
usbsw->pdata->cfg_gpio();
fsa9485_reg_init(usbsw);
ret = sysfs_create_group(&client->dev.kobj, &fsa9485_group);
if (ret) {
dev_err(&client->dev,
"failed to create fsa9485 attribute group\n");
goto fail2;
}
/* make sysfs node /sys/class/sec/switch/usb_state */
switch_dev = device_create(sec_class, NULL, 0, NULL, "switch");
if (IS_ERR(switch_dev)) {
pr_err("[FSA9485] Failed to create device (switch_dev)!\n");
ret = PTR_ERR(switch_dev);
goto fail2;
}
ret = device_create_file(switch_dev, &dev_attr_usb_state);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (usb_state)!\n");
goto err_create_file_state;
}
ret = device_create_file(switch_dev, &dev_attr_adc);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (adc)!\n");
goto err_create_file_adc;
}
ret = device_create_file(switch_dev, &dev_attr_reset_switch);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (reset_switch)!\n");
goto err_create_file_reset_switch;
}
dev_set_drvdata(switch_dev, usbsw);
/* fsa9485 dock init*/
if (usbsw->pdata->dock_init)
usbsw->pdata->dock_init();
/* fsa9485 reset */
if (usbsw->pdata->reset_cb)
usbsw->pdata->reset_cb();
/* set fsa9485 init flag. */
if (usbsw->pdata->set_init_flag)
usbsw->pdata->set_init_flag();
/* initial cable detection */
INIT_DELAYED_WORK(&usbsw->init_work, fsa9485_init_detect);
schedule_delayed_work(&usbsw->init_work, msecs_to_jiffies(2700));
return 0;
err_create_file_reset_switch:
device_remove_file(switch_dev, &dev_attr_reset_switch);
err_create_file_adc:
device_remove_file(switch_dev, &dev_attr_adc);
err_create_file_state:
device_remove_file(switch_dev, &dev_attr_usb_state);
fail2:
if (client->irq)
free_irq(client->irq, usbsw);
fail1:
mutex_destroy(&usbsw->mutex);
i2c_set_clientdata(client, NULL);
kfree(usbsw);
return ret;
}
// Destroy bridge state
int bs_destroy(struct bs_t *bs) {
mutex_destroy(bs);
free(bs);
return 1;
}
static int lge_hsd_probe(struct platform_device *pdev)
{
#ifdef AT_TEST_GPKD
int err;
#endif
int ret = 0;
struct fsa8008_platform_data *pdata = pdev->dev.platform_data;
struct hsd_info *hi;
HSD_DBG("lge_hsd_probe");
hi = kzalloc(sizeof(struct hsd_info), GFP_KERNEL);
if (NULL == hi) {
HSD_ERR("Failed to allloate headset per device info\n");
return -ENOMEM;
}
hi->key_code = pdata->key_code;
platform_set_drvdata(pdev, hi);
atomic_set(&hi->btn_state, 0);
atomic_set(&hi->is_3_pole_or_not, 1);
hi->gpio_detect = pdata->gpio_detect;
hi->gpio_mic_en = pdata->gpio_mic_en;
hi->gpio_jpole = pdata->gpio_jpole;
hi->gpio_key = pdata->gpio_key;
hi->set_headset_mic_bias = pdata->set_headset_mic_bias;
hi->latency_for_detection = pdata->latency_for_detection;
// hi->latency_for_key = 0;
hi->latency_for_key = 200 /* milli */ * HZ / 1000; /* convert milli to jiffies */
mutex_init(&hi->mutex_lock);
INIT_DELAYED_WORK(&hi->work, detect_work);
INIT_DELAYED_WORK(&hi->work_for_key_pressed, button_pressed);
INIT_DELAYED_WORK(&hi->work_for_key_released, button_released);
/* initialize gpio_detect */
ret = gpio_request(hi->gpio_detect, "gpio_detect");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_detect) gpio_request\n", hi->gpio_detect);
goto error_01;
}
ret = gpio_direction_input(hi->gpio_detect);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_detect) gpio_direction_input\n", hi->gpio_detect);
goto error_02;
}
/* initialize gpio_jpole */
ret = gpio_request(hi->gpio_jpole, "gpio_jpole");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_jpole) gpio_request\n", hi->gpio_jpole);
goto error_02;
}
ret = gpio_direction_input(hi->gpio_jpole);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_jpole) gpio_direction_input\n", hi->gpio_jpole);
goto error_03;
}
/* initialize gpio_key */
ret = gpio_request(hi->gpio_key, "gpio_key");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_key) gpio_request\n", hi->gpio_key);
goto error_03;
}
ret = gpio_direction_input(hi->gpio_key);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_key) gpio_direction_input\n", hi->gpio_key);
goto error_04;
}
/* initialize gpio_mic_en */
ret = gpio_request(hi->gpio_mic_en, "gpio_mic_en");
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_mic_en) gpio_request\n", hi->gpio_mic_en);
goto error_04;
}
ret = gpio_direction_output(hi->gpio_mic_en, 0);
if (ret < 0) {
HSD_ERR("Failed to configure gpio%d (gpio_mic_en) gpio_direction_output\n", hi->gpio_mic_en);
goto error_05;
}
/* initialize irq of gpio_jpole */
hi->irq_detect = gpio_to_irq(hi->gpio_detect);
HSD_DBG("hi->irq_detect = %d\n", hi->irq_detect);
if (hi->irq_detect < 0) {
HSD_ERR("Failed to get interrupt number\n");
ret = hi->irq_detect;
goto error_05;
}
ret = request_threaded_irq(hi->irq_detect, NULL, gpio_irq_handler,
IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, pdev->name, hi);
if (ret) {
HSD_ERR("failed to request button irq");
goto error_05;
}
ret = set_irq_wake(hi->irq_detect, 1);
if (ret < 0) {
HSD_ERR("Failed to set irq_detect interrupt wake\n");
goto error_06;
}
/* initialize irq of gpio_key */
hi->irq_key = gpio_to_irq(hi->gpio_key);
HSD_DBG("hi->irq_key = %d\n", hi->irq_key);
if (hi->irq_key < 0) {
HSD_ERR("Failed to get interrupt number\n");
ret = hi->irq_key;
goto error_06;
}
ret = request_threaded_irq(hi->irq_key, NULL, button_irq_handler,
IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, pdev->name, hi);
if (ret) {
HSD_ERR("failed to request button irq");
goto error_06;
}
disable_irq(hi->irq_key);
ret = set_irq_wake(hi->irq_key, 1);
if (ret < 0) {
HSD_ERR("Failed to set irq_key interrupt wake\n");
goto error_07;
}
/* initialize switch device */
hi->sdev.name = pdata->switch_name;
hi->sdev.print_state = lge_hsd_print_state;
hi->sdev.print_name = lge_hsd_print_name;
ret = switch_dev_register(&hi->sdev);
if (ret < 0) {
HSD_ERR("Failed to register switch device\n");
goto error_07;
}
/* initialize input device */
hi->input = input_allocate_device();
if (!hi->input) {
HSD_ERR("Failed to allocate input device\n");
ret = -ENOMEM;
goto error_08;
}
hi->input->name = pdata->keypad_name;
hi->input->id.vendor = 0x0001;
hi->input->id.product = 1;
hi->input->id.version = 1;
// input_set_capability(hi->input, EV_SW, SW_HEADPHONE_INSERT);
set_bit(EV_SYN, hi->input->evbit);
set_bit(EV_KEY, hi->input->evbit);
set_bit(hi->key_code, hi->input->keybit);
ret = input_register_device(hi->input);
if (ret) {
HSD_ERR("Failed to register input device\n");
goto error_09;
}
if (!gpio_get_value_cansleep(hi->gpio_detect))
#ifdef CONFIG_FSA8008_USE_LOCAL_WORK_QUEUE
queue_delayed_work(local_fsa8008_workqueue, &(hi->work), 0); /* to detect in initialization with eacjack insertion */
#else
schedule_delayed_work(&(hi->work), 0); /* to detect in initialization with eacjack insertion */
#endif
#ifdef AT_TEST_GPKD
err = device_create_file(&pdev->dev, &dev_attr_hookkeylog);
#endif
return ret;
error_09 :
input_free_device(hi->input);
error_08 :
switch_dev_unregister(&hi->sdev);
error_07 :
free_irq(hi->irq_key, 0);
error_06 :
free_irq(hi->irq_detect, 0);
error_05 :
gpio_free(hi->gpio_mic_en);
error_04 :
gpio_free(hi->gpio_key);
error_03 :
gpio_free(hi->gpio_jpole);
error_02 :
gpio_free(hi->gpio_detect);
error_01 :
mutex_destroy(&hi->mutex_lock);
kfree(hi);
return ret;
}
static int pn547_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
int rc = 0;
struct clk *nfc_clk = NULL;
struct pn547_i2c_platform_data *platform_data;
struct pn547_dev *pn547_dev;
printk("### %s begin! \n",__func__);
dev_info(&client->dev, "%s ++\n", __func__);
platform_data = kzalloc(sizeof(struct pn547_i2c_platform_data),
GFP_KERNEL);
if (platform_data == NULL) {
dev_err(&client->dev, "failed to allocate memory\n");
ret = -ENOMEM;
goto err_platform_data;
}
printk("### %s 11 begin! \n",__func__);
ret = pn547_parse_dt(&client->dev, platform_data);
if (ret < 0) {
dev_err(&client->dev, "failed to parse device tree: %d\n", ret);
goto err_parse_dt;
}
printk("pn547 dev kobj_name=%s,init_name=%s,id=%d\n",client->dev.kobj.name,client->dev.init_name, client->dev.id);
nfc_clk = clk_get(&client->dev, "nfc_pn547clk");
if (nfc_clk == NULL) {
dev_err(&client->dev, "failed to get clk: %d\n", ret);
goto err_parse_dt;
}
rc = clk_set_rate(nfc_clk,19200000);
if(rc){
dev_err(&client->dev, "Clock set rate failed: %d\n",rc);
}
ret = clk_prepare_enable(nfc_clk);
if (ret) {
dev_err(&client->dev, "failed to enable clk: %d\n", ret);
goto err_parse_dt;
}
ret = pn547_gpio_request(&client->dev, platform_data);
if (ret) {
dev_err(&client->dev, "failed to request gpio\n");
goto err_gpio_request;
}
dev_dbg(&client->dev, "%s:\n", __func__);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev, "%s: i2c check failed\n", __func__);
ret = -ENODEV;
goto err_i2c;
}
printk("### %s 22 begin! \n",__func__);
pn547_dev = kzalloc(sizeof(*pn547_dev), GFP_KERNEL);
if (pn547_dev == NULL) {
dev_err(&client->dev,
"failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
client->irq = gpio_to_irq(platform_data->irq_gpio);
pn547_dev->irq_gpio = platform_data->irq_gpio;
pn547_dev->ven_gpio = platform_data->ven_gpio;
pn547_dev->firm_gpio = platform_data->fwdl_en_gpio;
pn547_dev->clk_req_gpio = platform_data->clk_req_gpio;
pn547_dev->client = client;
pn547_dev->dev = &client->dev;
pn547_dev->do_reading = 0;
/* Initialise mutex and work queue */
init_waitqueue_head(&pn547_dev->read_wq);
mutex_init(&pn547_dev->read_mutex);
spin_lock_init(&pn547_dev->irq_enabled_lock);
wake_lock_init(&pn547_dev->wl,WAKE_LOCK_SUSPEND,"nfc_locker");
pn547_dev->pn547_device.minor = MISC_DYNAMIC_MINOR;
pn547_dev->pn547_device.name = "pn544";
pn547_dev->pn547_device.fops = &pn547_dev_fops;
printk("### %s 33 begin! \n",__func__);
ret = misc_register(&pn547_dev->pn547_device);
if (ret) {
dev_err(&client->dev, "%s: misc_register err %d\n",
__func__, ret);
goto err_misc_register;
}
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
dev_info(&client->dev, "%s : requesting IRQ %d\n",
__func__, client->irq);
pn547_dev->irq_enabled = true;
ret = request_irq(client->irq, pn547_dev_irq_handler,
IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND | IRQF_ONESHOT,
client->name, pn547_dev);
if (ret) {
dev_err(&client->dev, "request_irq failed\n");
goto err_request_irq_failed;
}
pn547_disable_irq(pn547_dev);
i2c_set_clientdata(client, pn547_dev);
return 0;
err_request_irq_failed:
misc_deregister(&pn547_dev->pn547_device);
err_misc_register:
mutex_destroy(&pn547_dev->read_mutex);
kfree(pn547_dev);
err_exit:
err_i2c:
pn547_gpio_release(platform_data);
err_gpio_request:
err_parse_dt:
kfree(platform_data);
err_platform_data:
dev_err(&client->dev, "%s: err %d\n", __func__, ret);
return ret;
}
static void __exit itefrontend_exit(void)
{
pr_dbg("unregister ite9133 demod driver\n");
mutex_destroy(&ite_lock);
aml_unregister_fe_drv(AM_DEV_DTV_DEMOD, &ite9133_dtv_demod_drv);
}
/**
* Worker for rtSemMutexSolRequest that handles the case where we go to sleep.
*
* @returns VINF_SUCCESS, VERR_INTERRUPTED, or VERR_SEM_DESTROYED.
* Returns without owning the mutex.
* @param pThis The mutex instance.
* @param cMillies The timeout, must be > 0 or RT_INDEFINITE_WAIT.
* @param fInterruptible The wait type.
*
* @remarks This needs to be called with the mutex object held!
*/
static int rtSemMutexSolRequestSleep(PRTSEMMUTEXINTERNAL pThis, RTMSINTERVAL cMillies,
bool fInterruptible)
{
int rc = VERR_GENERAL_FAILURE;
Assert(cMillies > 0);
/*
* Now we wait (sleep; although might spin and then sleep) & reference the mutex.
*/
ASMAtomicIncU32(&pThis->cWaiters);
ASMAtomicIncU32(&pThis->cRefs);
if (cMillies != RT_INDEFINITE_WAIT)
{
clock_t cTicks = drv_usectohz((clock_t)(cMillies * 1000L));
clock_t cTimeout = ddi_get_lbolt();
cTimeout += cTicks;
if (fInterruptible)
rc = cv_timedwait_sig(&pThis->Cnd, &pThis->Mtx, cTimeout);
else
rc = cv_timedwait(&pThis->Cnd, &pThis->Mtx, cTimeout);
}
else
{
if (fInterruptible)
rc = cv_wait_sig(&pThis->Cnd, &pThis->Mtx);
else
{
cv_wait(&pThis->Cnd, &pThis->Mtx);
rc = 1;
}
}
ASMAtomicDecU32(&pThis->cWaiters);
if (rc > 0)
{
if (pThis->u32Magic == RTSEMMUTEX_MAGIC)
{
if (pThis->hOwnerThread == NIL_RTNATIVETHREAD)
{
/*
* Woken up by a release from another thread.
*/
Assert(pThis->cRecursions == 0);
pThis->cRecursions = 1;
pThis->hOwnerThread = RTThreadNativeSelf();
rc = VINF_SUCCESS;
}
else
{
/*
* Interrupted by some signal.
*/
rc = VERR_INTERRUPTED;
}
}
else
{
/*
* Awakened due to the destruction-in-progress broadcast.
* We will cleanup if we're the last waiter.
*/
rc = VERR_SEM_DESTROYED;
}
}
else if (rc == -1)
{
/*
* Timed out.
*/
rc = VERR_TIMEOUT;
}
else
{
/*
* Condition may not have been met, returned due to pending signal.
*/
rc = VERR_INTERRUPTED;
}
if (!ASMAtomicDecU32(&pThis->cRefs))
{
Assert(RT_FAILURE_NP(rc));
mutex_exit(&pThis->Mtx);
cv_destroy(&pThis->Cnd);
mutex_destroy(&pThis->Mtx);
RTMemFree(pThis);
return rc;
}
return rc;
}
static int __devinit fsa9485_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct fsa9485_usbsw *usbsw;
int ret = 0;
struct input_dev *input;
struct device *switch_dev;
struct fsa9485_platform_data *pdata;
dev_info(&client->dev, "%s\n", __func__);
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct fsa9485_platform_data), GFP_KERNEL);
if (!pdata) {
dev_err(&client->dev, "Failed to allocate memory\n");
return -ENOMEM;
}
pdata = &fsa9485_pdata;
fsa9485_parse_dt(&client->dev, pdata);
client->irq = gpio_to_irq(pdata->gpio_int);
} else
pdata = client->dev.platform_data;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
input = input_allocate_device();
if (!input) {
dev_err(&client->dev, "failed to allocate input device data\n");
return -ENOMEM;
}
usbsw = kzalloc(sizeof(struct fsa9485_usbsw), GFP_KERNEL);
if (!usbsw) {
dev_err(&client->dev, "failed to allocate driver data\n");
input_free_device(input);
return -ENOMEM;
}
usbsw->input = input;
input->name = client->name;
input->phys = "deskdock-key/input0";
input->dev.parent = &client->dev;
input->id.bustype = BUS_HOST;
input->id.vendor = 0x0001;
input->id.product = 0x0001;
input->id.version = 0x0001;
/* Enable auto repeat feature of Linux input subsystem */
__set_bit(EV_REP, input->evbit);
input_set_capability(input, EV_KEY, KEY_VOLUMEUP);
input_set_capability(input, EV_KEY, KEY_VOLUMEDOWN);
input_set_capability(input, EV_KEY, KEY_PLAYPAUSE);
input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG);
input_set_capability(input, EV_KEY, KEY_NEXTSONG);
ret = input_register_device(input);
if (ret) {
dev_err(&client->dev,
"input_register_device %s: err %d\n", __func__, ret);
input_free_device(input);
kfree(usbsw);
return ret;
}
usbsw->client = client;
usbsw->pdata = pdata;
if (!usbsw->pdata)
goto fail1;
#if !defined(CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK)
usbsw->is_factory_start = false;
#endif /* !CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK */
i2c_set_clientdata(client, usbsw);
mutex_init(&usbsw->mutex);
local_usbsw = usbsw;
if (usbsw->pdata->cfg_gpio)
usbsw->pdata->cfg_gpio();
fsa9485_reg_init(usbsw);
uart_connecting = 0;
ret = sysfs_create_group(&client->dev.kobj, &fsa9485_group);
if (ret) {
dev_err(&client->dev,
"failed to create fsa9485 attribute group\n");
goto fail2;
}
/* make sysfs node /sys/class/sec/switch/usb_state */
switch_dev = device_create(sec_class, NULL, 0, NULL, "switch");
if (IS_ERR(switch_dev)) {
pr_err("[FSA9485] Failed to create device (switch_dev)!\n");
ret = PTR_ERR(switch_dev);
goto fail2;
}
ret = device_create_file(switch_dev, &dev_attr_usb_state);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (usb_state)!\n");
goto err_create_file_state;
}
ret = device_create_file(switch_dev, &dev_attr_adc);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (adc)!\n");
goto err_create_file_adc;
}
ret = device_create_file(switch_dev, &dev_attr_reset_switch);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (reset_switch)!\n");
goto err_create_file_reset_switch;
}
#if !defined(CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK)
ret = device_create_file(switch_dev, &dev_attr_apo_factory);
if (ret < 0) {
pr_err("[FSA9485] Failed to create file (apo_factory)!\n");
goto err_create_file_apo_factory;
}
#endif
dev_set_drvdata(switch_dev, usbsw);
/* fsa9485 dock init*/
if (usbsw->pdata->dock_init)
usbsw->pdata->dock_init();
/* fsa9485 reset */
if (usbsw->pdata->reset_cb)
usbsw->pdata->reset_cb();
/* set fsa9485 init flag. */
if (usbsw->pdata->set_init_flag)
usbsw->pdata->set_init_flag();
local_usbsw->dock_ready = 0;
local_usbsw->mhl_ready = 0;
/* initial cable detection */
INIT_DELAYED_WORK(&usbsw->init_work, fsa9485_init_detect);
schedule_delayed_work(&usbsw->init_work, msecs_to_jiffies(2700));
INIT_DELAYED_WORK(&usbsw->audio_work, fsa9485_delayed_audio);
schedule_delayed_work(&usbsw->audio_work, msecs_to_jiffies(20000));
#if defined(CONFIG_VIDEO_MHL_V1) || defined(CONFIG_VIDEO_MHL_V2)
INIT_WORK(&usbsw->mhl_work, fsa9485_mhl_detect);
#endif
return 0;
#if !defined(CONFIG_MUIC_FSA9485_SUPPORT_CAR_DOCK)
err_create_file_apo_factory:
device_remove_file(switch_dev, &dev_attr_apo_factory);
#endif
err_create_file_reset_switch:
device_remove_file(switch_dev, &dev_attr_reset_switch);
err_create_file_adc:
device_remove_file(switch_dev, &dev_attr_adc);
err_create_file_state:
device_remove_file(switch_dev, &dev_attr_usb_state);
fail2:
if (client->irq)
free_irq(client->irq, usbsw);
fail1:
input_unregister_device(input);
mutex_destroy(&usbsw->mutex);
i2c_set_clientdata(client, NULL);
input_free_device(input);
kfree(usbsw);
return ret;
}
static int wacom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct wacom_g5_platform_data *pdata;
struct wacom_i2c *wac_i2c;
struct input_dev *input;
int ret = 0;
int error;
int fw_ver;
/*Check I2C functionality */
ret = i2c_check_functionality(client->adapter, I2C_FUNC_I2C);
if (!ret) {
printk(KERN_ERR "%s: No I2C functionality found\n", __func__);
ret = -ENODEV;
goto err_i2c_fail;
}
/*Obtain kernel memory space for wacom i2c */
if (client->dev.of_node) {
pdata = devm_kzalloc(&client->dev,
sizeof(struct wacom_g5_platform_data), GFP_KERNEL);
if (!pdata) {
dev_err(&client->dev,
"%s: Failed to allocate memory\n",
__func__);
return -ENOMEM;
}
error = wacom_parse_dt(&client->dev, pdata);
if (error)
return error;
} else {
pdata = client->dev.platform_data;
if (pdata == NULL) {
dev_err(&client->dev, "%s: no pdata\n", __func__);
ret = -ENODEV;
goto err_i2c_fail;
}
}
wacom_connect_platform_data(pdata);
wacom_request_gpio(pdata);
wac_i2c = kzalloc(sizeof(struct wacom_i2c), GFP_KERNEL);
if (NULL == wac_i2c) {
dev_err(&client->dev,
"%s: failed to allocate wac_i2c.\n",
__func__);
ret = -ENOMEM;
goto err_i2c_fail;
}
wac_i2c->client_boot = i2c_new_dummy(client->adapter,
WACOM_I2C_BOOT);
if (!wac_i2c->client_boot) {
dev_err(&client->dev, "Fail to register sub client[0x%x]\n",
WACOM_I2C_BOOT);
}
input = input_allocate_device();
if (NULL == input) {
dev_err(&client->dev,
"%s: failed to allocate input device.\n",
__func__);
ret = -ENOMEM;
goto err_freemem;
}
wacom_i2c_set_input_values(client, wac_i2c, input);
wac_i2c->wac_feature = &wacom_feature_EMR;
wac_i2c->wac_pdata = pdata;
wac_i2c->input_dev = input;
wac_i2c->client = client;
client->irq = gpio_to_irq(pdata->gpio_int);
printk(KERN_ERR "%s: wacom : gpio_to_irq : %d\n",
__func__, client->irq);
wac_i2c->irq = client->irq;
/*Set client data */
i2c_set_clientdata(client, wac_i2c);
i2c_set_clientdata(wac_i2c->client_boot, wac_i2c);
#ifdef WACOM_PDCT_WORK_AROUND
wac_i2c->irq_pdct = gpio_to_irq(pdata->gpio_pen_pdct);
wac_i2c->pen_pdct = PDCT_NOSIGNAL;
#endif
#ifdef WACOM_PEN_DETECT
wac_i2c->gpio_pen_insert = pdata->gpio_pen_insert;
wac_i2c->irq_pen_insert = gpio_to_irq(wac_i2c->gpio_pen_insert);
#endif
#ifdef WACOM_IMPORT_FW_ALGO
wac_i2c->use_offset_table = true;
wac_i2c->use_aveTransition = false;
#endif
#ifdef USE_WACOM_CALLBACK
/*Register callbacks */
wac_i2c->callbacks.check_prox = wacom_check_emr_prox;
if (wac_i2c->wac_pdata->register_cb)
wac_i2c->wac_pdata->register_cb(&wac_i2c->callbacks);
#endif
#ifdef CONFIG_SEC_VIENNA_PROJECT
if (system_rev >= WACOM_BOOT_REVISION) {
wac_i2c->wac_pdata->ic_mpu_ver = MPU_W9007;
wac_i2c->boot_ver = 0x92;
}
#endif
#ifdef CONFIG_SEC_LT03_PROJECT
wac_i2c->boot_ver = 0x92;
#endif
if (wac_i2c->wac_pdata->ic_mpu_ver > 0) {
wac_i2c->ic_mpu_ver = wac_i2c->wac_pdata->ic_mpu_ver;
wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, false);
wac_i2c->wac_pdata->wacom_start(wac_i2c);
msleep(200);
} else {
wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, true);
/*Reset */
wac_i2c->wac_pdata->wacom_start(wac_i2c);
msleep(200);
ret = wacom_check_mpu_version(wac_i2c);
if (ret == -ETIMEDOUT)
#if defined(CONFIG_SEC_H_PROJECT) || defined(CONFIG_SEC_FRESCO_PROJECT)
goto err_wacom_i2c_send_timeout;
#else
pr_err("[E-PEN] wacom_i2c_send failed.\n");
#endif
wac_i2c->ic_mpu_ver = wacom_check_flash_mode(wac_i2c, BOOT_MPU);
dev_info(&wac_i2c->client->dev,
"%s: mpu version: %x\n", __func__, ret);
if (wac_i2c->ic_mpu_ver == MPU_W9001)
wac_i2c->client_boot = i2c_new_dummy(client->adapter,
WACOM_I2C_9001_BOOT);
else if (wac_i2c->ic_mpu_ver == MPU_W9007) {
ret = wacom_enter_bootloader(wac_i2c);
if (ret < 0) {
dev_info(&wac_i2c->client->dev,
"%s: failed to get BootLoader version, %d\n", __func__, ret);
goto err_wacom_i2c_bootloader_ver;
} else {
dev_info(&wac_i2c->client->dev,
"%s: BootLoader version: %x\n", __func__, ret);
}
}
wac_i2c->wac_pdata->compulsory_flash_mode(wac_i2c, false);
wac_i2c->wac_pdata->reset_platform_hw(wac_i2c);
wac_i2c->power_enable = true;
}
/* Firmware Feature */
wacom_i2c_init_firm_data();
pr_err("%s: wacon ic turn on\n", __func__);
fw_ver = wacom_i2c_query(wac_i2c);
wacom_init_abs_params(wac_i2c);
input_set_drvdata(input, wac_i2c);
/*Initializing for semaphor */
mutex_init(&wac_i2c->lock);
#if defined(CONFIG_SEC_LT03_PROJECT) || defined(CONFIG_SEC_VIENNA_PROJECT)
mutex_init(&wac_i2c->irq_lock);
#endif
#ifdef WACOM_BOOSTER
wacom_init_dvfs(wac_i2c);
#endif
INIT_DELAYED_WORK(&wac_i2c->resume_work, wacom_i2c_resume_work);
#ifdef USE_WACOM_BLOCK_KEYEVENT
INIT_DELAYED_WORK(&wac_i2c->touch_pressed_work, wacom_i2c_touch_pressed_work);
wac_i2c->key_delay_time = 100;
#endif
#ifdef USE_WACOM_LCD_WORKAROUND
wac_i2c->wait_done = true;
wac_i2c->delay_time = 5;
INIT_DELAYED_WORK(&wac_i2c->read_vsync_work, wacom_i2c_read_vsync_work);
wac_i2c->boot_done = false;
INIT_DELAYED_WORK(&wac_i2c->boot_done_work, wacom_i2c_boot_done_work);
#endif
#ifdef WACOM_PEN_DETECT
INIT_DELAYED_WORK(&wac_i2c->pen_insert_dwork, pen_insert_work);
#endif
#ifdef WACOM_RESETPIN_DELAY
INIT_DELAYED_WORK(&wac_i2c->work_wacom_reset, wacom_reset);
#endif
/*Before registering input device, data in each input_dev must be set */
ret = input_register_device(input);
if (ret) {
pr_err("[E-PEN] failed to register input device.\n");
goto err_input_allocate_device;
}
#ifdef CONFIG_HAS_EARLYSUSPEND
wac_i2c->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
wac_i2c->early_suspend.suspend = wacom_i2c_early_suspend;
wac_i2c->early_suspend.resume = wacom_i2c_late_resume;
register_early_suspend(&wac_i2c->early_suspend);
#endif
wac_i2c->dev = device_create(sec_class, NULL, 0, NULL, "sec_epen");
if (IS_ERR(wac_i2c->dev)) {
dev_err(&wac_i2c->client->dev,
"%s: Failed to create device(wac_i2c->dev)!\n",
__func__);
goto err_sysfs_create_group;
}
dev_set_drvdata(wac_i2c->dev, wac_i2c);
ret = sysfs_create_group(&wac_i2c->dev->kobj, &epen_attr_group);
if (ret) {
dev_err(&wac_i2c->client->dev,
"%s: failed to create sysfs group\n",
__func__);
goto err_sysfs_create_group;
}
ret = wacom_firmware_update(wac_i2c);
if (ret) {
dev_err(&wac_i2c->client->dev,
"%s: firmware update failed.\n",
__func__);
if (fw_ver > 0 && wac_i2c->ic_mpu_ver < 0)
dev_err(&wac_i2c->client->dev,
"%s: read query but not enter boot mode[%x,%x]\n",
__func__, fw_ver, wac_i2c->ic_mpu_ver);
else
goto err_fw_update;
}
/*Request IRQ */
if (pdata->irq_flags) {
ret =
request_threaded_irq(wac_i2c->irq, NULL, wacom_interrupt,
IRQF_DISABLED | pdata->irq_flags |
IRQF_ONESHOT, wac_i2c->name, wac_i2c);
if (ret < 0) {
dev_err(&wac_i2c->client->dev,
"%s: failed to request irq(%d) - %d\n",
__func__, wac_i2c->irq, ret);
goto err_fw_update;
}
#if defined(WACOM_PDCT_WORK_AROUND)
ret = request_threaded_irq(wac_i2c->irq_pdct, NULL,
wacom_interrupt_pdct,
IRQF_DISABLED | IRQF_TRIGGER_RISING |
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
wac_i2c->name, wac_i2c);
if (ret < 0) {
dev_err(&wac_i2c->client->dev,
"%s: failed to request irq(%d) - %d\n",
__func__, wac_i2c->irq_pdct, ret);
goto err_request_irq_pdct;
}
#endif
#ifdef WACOM_PEN_DETECT
ret = request_threaded_irq(
wac_i2c->irq_pen_insert, NULL,
wacom_pen_detect,
IRQF_DISABLED | IRQF_TRIGGER_RISING |
IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
"pen_insert", wac_i2c);
if (ret < 0) {
dev_err(&wac_i2c->client->dev,
"%s: failed to request irq(%d) - %d\n",
__func__, wac_i2c->irq_pen_insert, ret);
goto err_request_irq_pen_inster;
}
enable_irq_wake(wac_i2c->irq_pen_insert);
/* update the current status */
schedule_delayed_work(&wac_i2c->pen_insert_dwork, HZ / 2);
#endif
}
#ifdef USE_WACOM_LCD_WORKAROUND
schedule_delayed_work(&wac_i2c->boot_done_work,
msecs_to_jiffies(20 * 1000));
#endif
#ifdef WACOM_RESETPIN_DELAY
schedule_delayed_work(&wac_i2c->work_wacom_reset, msecs_to_jiffies(5000));
#endif
return 0;
err_request_irq_pen_inster:
#ifdef WACOM_PDCT_WORK_AROUND
free_irq(wac_i2c->irq_pdct, wac_i2c);
err_request_irq_pdct:
#endif
free_irq(wac_i2c->irq, wac_i2c);
err_fw_update:
sysfs_remove_group(&wac_i2c->dev->kobj, &epen_attr_group);
err_sysfs_create_group:
wac_i2c->init_fail = true;
input_unregister_device(input);
err_input_allocate_device:
cancel_delayed_work_sync(&wac_i2c->resume_work);
cancel_delayed_work_sync(&wac_i2c->touch_pressed_work);
#ifdef USE_WACOM_LCD_WORKAROUND
cancel_delayed_work_sync(&wac_i2c->read_vsync_work);
cancel_delayed_work_sync(&wac_i2c->boot_done_work);
#endif
cancel_delayed_work_sync(&wac_i2c->pen_insert_dwork);
#ifdef WACOM_RESETPIN_DELAY
cancel_delayed_work_sync(&wac_i2c->work_wacom_reset);
#endif
#ifdef WACOM_BOOSTER
cancel_delayed_work_sync(&wac_i2c->work_dvfs_off);
cancel_delayed_work_sync(&wac_i2c->work_dvfs_chg);
mutex_destroy(&wac_i2c->dvfs_lock);
#endif
wac_i2c->wac_pdata->wacom_stop(wac_i2c);
mutex_destroy(&wac_i2c->lock);
err_wacom_i2c_bootloader_ver:
#if defined(CONFIG_SEC_H_PROJECT) || defined(CONFIG_SEC_FRESCO_PROJECT)
err_wacom_i2c_send_timeout:
#endif
input_free_device(input);
err_freemem:
kfree(wac_i2c);
err_i2c_fail:
return ret;
}
static int pn544_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret;
struct pn544_i2c_platform_data *platform_data;
struct pn544_dev *pn544_dev;
platform_data = client->dev.platform_data;
if (platform_data == NULL)
{
printk("%s : nfc probe fail\n", __func__);
return -ENODEV;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
{
printk("%s : need I2C_FUNC_I2C\n", __func__);
return -ENODEV;
}
//IRQ
ret = gpio_request(platform_data->irq_gpio, "nfc_int");
if (ret)
{
printk("gpio_nfc_int request error\n");
return -ENODEV;
}
//VEN
ret = gpio_request(platform_data->ven_gpio, "nfc_ven");
if (ret)
{
printk("gpio_nfc_ven request error\n");
return -ENODEV;
}
//PVDD
ret = gpio_request(PN544_PW_EN, "nfc_pvdd");
if (ret)
{
printk("gpio_nfc_ven request error\n");
return -ENODEV;
}
//FIRM
ret = gpio_request(platform_data->firm_gpio, "nfc_firm");
if (ret)
{
printk("gpio_nfc_firm request error\n");
return -ENODEV;
}
pn544_dev = kzalloc(sizeof(*pn544_dev), GFP_KERNEL);
if (pn544_dev == NULL)
{
dev_err(&client->dev,
"failed to allocate memory for module data\n");
ret = -ENOMEM;
goto err_exit;
}
gpio_set_value(PN544_PW_EN, 1);
pn544_dev->irq_gpio = platform_data->irq_gpio;
pn544_dev->ven_gpio = platform_data->ven_gpio;
pn544_dev->firm_gpio = platform_data->firm_gpio;
pn544_dev->client = client;
/* init mutex and queues */
init_waitqueue_head(&pn544_dev->read_wq);
mutex_init(&pn544_dev->read_mutex);
spin_lock_init(&pn544_dev->irq_enabled_lock);
pn544_dev->pn544_device.minor = MISC_DYNAMIC_MINOR;
pn544_dev->pn544_device.name = "pn544";
pn544_dev->pn544_device.fops = &pn544_dev_fops;
ret = misc_register(&pn544_dev->pn544_device);
if (ret)
{
printk("%s : misc_register failed\n", __FILE__);
goto err_misc_register;
}
/* request irq. the irq is set whenever the chip has data available
* for reading. it is cleared when all data has been read.
*/
pr_info("%s : requesting IRQ %d\n", __func__, client->irq);
pn544_dev->irq_enabled = true;
// ts->irq = gpio_to_irq(ts->platform_data->irq_gpio);
ret = request_irq(client->irq, pn544_dev_irq_handler, IRQF_TRIGGER_HIGH, client->name, pn544_dev);
if (ret)
{
dev_err(&client->dev, "request_irq failed\n");
goto err_request_irq_failed;
}
printk("pn544_probe -> request_irq,%d\n", ret);
pn544_disable_irq(pn544_dev);
i2c_set_clientdata(client, pn544_dev);
return 0;
err_request_irq_failed:
misc_deregister(&pn544_dev->pn544_device);
err_misc_register:
mutex_destroy(&pn544_dev->read_mutex);
kfree(pn544_dev);
err_exit:
gpio_free(pn544_dev->irq_gpio);
gpio_free(pn544_dev->ven_gpio);
gpio_free(pn544_dev->firm_gpio);
return ret;
}
static int __devinit bq2419x_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct bq2419x_chip *bq2419x;
struct bq2419x_platform_data *pdata;
int ret = 0;
pdata = client->dev.platform_data;
if (!pdata) {
dev_err(&client->dev, "No Platform data");
return -EINVAL;
}
bq2419x = devm_kzalloc(&client->dev, sizeof(*bq2419x), GFP_KERNEL);
if (!bq2419x) {
dev_err(&client->dev, "Memory allocation failed\n");
return -ENOMEM;
}
bq2419x->regmap = devm_regmap_init_i2c(client, &bq2419x_regmap_config);
if (IS_ERR(bq2419x->regmap)) {
ret = PTR_ERR(bq2419x->regmap);
dev_err(&client->dev, "regmap init failed with err %d\n", ret);
return ret;
}
bq2419x->dev = &client->dev;
bq2419x->use_usb = pdata->bcharger_pdata->use_usb;
bq2419x->use_mains = pdata->bcharger_pdata->use_mains;
bq2419x->update_status = pdata->bcharger_pdata->update_status;
bq2419x->rtc_alarm_time = pdata->bcharger_pdata->rtc_alarm_time;
bq2419x->wdt_time_sec = pdata->bcharger_pdata->wdt_timeout;
bq2419x->chg_restart_time = pdata->bcharger_pdata->chg_restart_time;
bq2419x->wdt_refresh_timeout = 25;
i2c_set_clientdata(client, bq2419x);
bq2419x->irq = client->irq;
bq2419x->rtc = alarmtimer_get_rtcdev();
mutex_init(&bq2419x->mutex);
mutex_init(&bq2419x->otg_mutex);
bq2419x->suspended = 0;
bq2419x->chg_restart_timeout = 0;
bq2419x->is_otg_connected = 0;
ret = bq2419x_show_chip_version(bq2419x);
if (ret < 0) {
dev_err(&client->dev, "version read failed %d\n", ret);
return ret;
}
ret = bq2419x_charger_init(bq2419x);
if (ret < 0) {
dev_err(bq2419x->dev, "Charger init failed: %d\n", ret);
return ret;
}
ret = bq2419x_init_charger_regulator(bq2419x, pdata);
if (ret < 0) {
dev_err(&client->dev,
"Charger regualtor init failed %d\n", ret);
return ret;
}
ret = bq2419x_psy_init(bq2419x);
if (ret < 0) {
dev_err(&client->dev,
"Charger power supply init failed %d\n", ret);
goto scrub_chg_reg;
}
ret = bq2419x_init_vbus_regulator(bq2419x, pdata);
if (ret < 0) {
dev_err(&client->dev,
"VBUS regualtor init failed %d\n", ret);
goto scrub_psy;
}
init_kthread_worker(&bq2419x->bq_kworker);
bq2419x->bq_kworker_task = kthread_run(kthread_worker_fn,
&bq2419x->bq_kworker,
dev_name(bq2419x->dev));
if (IS_ERR(bq2419x->bq_kworker_task)) {
ret = PTR_ERR(bq2419x->bq_kworker_task);
dev_err(&client->dev, "Kworker task creation failed %d\n", ret);
goto scrub_vbus_reg;
}
init_kthread_work(&bq2419x->bq_wdt_work, bq2419x_work_thread);
sched_setscheduler(bq2419x->bq_kworker_task,
SCHED_FIFO, &bq2419x_param);
queue_kthread_work(&bq2419x->bq_kworker, &bq2419x->bq_wdt_work);
ret = bq2419x_watchdog_init(bq2419x, bq2419x->wdt_time_sec, "PROBE");
if (ret < 0) {
dev_err(bq2419x->dev, "BQWDT init failed %d\n", ret);
return ret;
}
INIT_DELAYED_WORK(&bq2419x->otg_reset_work,
bq2419x_otg_reset_work_handler);
ret = bq2419x_fault_clear_sts(bq2419x);
if (ret < 0) {
dev_err(bq2419x->dev, "fault clear status failed %d\n", ret);
return ret;
}
ret = request_threaded_irq(bq2419x->irq, NULL,
bq2419x_irq, IRQF_TRIGGER_FALLING,
dev_name(bq2419x->dev), bq2419x);
if (ret < 0) {
dev_err(bq2419x->dev, "request IRQ %d fail, err = %d\n",
bq2419x->irq, ret);
goto scrub_kthread;
}
/* enable charging */
ret = bq2419x_charger_enable(bq2419x);
if (ret < 0)
goto scrub_irq;
return 0;
scrub_irq:
free_irq(bq2419x->irq, bq2419x);
scrub_kthread:
bq2419x->stop_thread = true;
flush_kthread_worker(&bq2419x->bq_kworker);
kthread_stop(bq2419x->bq_kworker_task);
scrub_vbus_reg:
regulator_unregister(bq2419x->vbus_rdev);
scrub_psy:
if (bq2419x->use_usb)
power_supply_unregister(&bq2419x->usb);
if (bq2419x->use_mains)
power_supply_unregister(&bq2419x->ac);
scrub_chg_reg:
regulator_unregister(bq2419x->chg_rdev);
mutex_destroy(&bq2419x->mutex);
mutex_destroy(&bq2419x->otg_mutex);
return ret;
}
static int __devinit tl2796_probe(struct spi_device *spi)
{
struct s5p_lcd *lcd;
int ret;
lcd = kzalloc(sizeof(*lcd), GFP_KERNEL);
if (!lcd) {
pr_err("failed to allocate for lcd\n");
ret = -ENOMEM;
goto err_alloc;
}
mutex_init(&lcd->lock);
spi->bits_per_word = 8;
if (spi_setup(spi)) {
pr_err("failed to setup spi\n");
ret = -EINVAL;
goto err_setup;
}
lcd->g_spi = spi;
lcd->dev = &spi->dev;
lcd->bl = 255;
if (!spi->dev.platform_data) {
dev_err(lcd->dev, "failed to get platform data\n");
ret = -EINVAL;
goto err_setup;
}
// lcd->data = (struct s5p_panel_data *)spi->dev.platform_data;
//determinate of LCD type
lcd->lcd_type = get_lcdtype();
ret = gpio_request(GPIO_LCD_BL_PWM, "lcd_bl_pwm");
if (ret < 0) {
dev_err(lcd->dev, "unable to request gpio for backlight\n");
return ret;
}
s3c_gpio_cfgpin(GPIO_LCD_BL_PWM, (0x2 << 0));
lcd->backlight_pwm_dev = pwm_request(0, "backlight-pwm");
if (IS_ERR(lcd->backlight_pwm_dev)) {
dev_err(lcd->dev, "unable to request PWM for backlight\n");
} else
dev_err(lcd->dev, "got pwm for backlight\n");
pwm_config(lcd->backlight_pwm_dev, (bl_freq_count*70)/100, bl_freq_count);
pwm_enable(lcd->backlight_pwm_dev);
lcd->bl_dev = backlight_device_register("s5p_bl",
&spi->dev, lcd, &s5p_bl_ops, NULL);
if (!lcd->bl_dev) {
dev_err(lcd->dev, "failed to register backlight\n");
ret = -EINVAL;
goto err_setup;
}
lcd->bl_dev->props.max_brightness = 255;
lcd->lcd_dev = lcd_device_register("s5p_lcd", &spi->dev, lcd, &s5p_lcd_ops);
if (!lcd->lcd_dev)
{
dev_err(lcd->dev, "failed to register lcd\n");
ret = -EINVAL;
goto err_setup_lcd;
}
// Class and device file creation
printk(KERN_ERR "ldi_class create\n");
lcd->ldi_class = class_create(THIS_MODULE, "ldi_class");
if (IS_ERR(lcd->ldi_class))
pr_err("Failed to create class(ldi_class)!\n");
lcd->ldi_dev = device_create(lcd->ldi_class, &spi->dev, 0, lcd, "ldi_dev");
if (IS_ERR(lcd->ldi_dev))
pr_err("Failed to create device(ldi_dev)!\n");
if (!lcd->ldi_dev) {
dev_err(lcd->dev, "failed to register device(ldi_dev)\n");
ret = -EINVAL;
goto err_setup_ldi;
}
if (device_create_file(lcd->ldi_dev, &dev_attr_update_brightness_cmd) < 0)
pr_err("Failed to create device file(%s)!\n", dev_attr_update_brightness_cmd.attr.name);
spi_set_drvdata(spi, lcd);
tl2796_ldi_enable(lcd);
#ifdef CONFIG_FB_S3C_MDNIE
init_mdnie_class(); //set mDNIe UI mode, Outdoormode
#endif
#ifdef CONFIG_HAS_EARLYSUSPEND
lcd->early_suspend.suspend = tl2796_early_suspend;
lcd->early_suspend.resume = tl2796_late_resume;
lcd->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB - 1;
register_early_suspend(&lcd->early_suspend);
#endif
gprintk("tl2796_probe successfully probed\n", __func__);
return 0;
err_setup_ldi:
lcd_device_unregister(lcd->lcd_dev);
err_setup_lcd:
backlight_device_unregister(lcd->bl_dev);
err_setup:
mutex_destroy(&lcd->lock);
kfree(lcd);
err_alloc:
return ret;
}
static int ssp_probe(struct spi_device *spi)
{
int iRet = 0;
struct ssp_data *data;
pr_info("\n#####################################################\n");
data = kzalloc(sizeof(*data), GFP_KERNEL);
if (data == NULL) {
pr_err("[SSP]: %s - failed to allocate memory for data\n",
__func__);
iRet = -ENOMEM;
goto exit;
}
iRet = initialize_platformdata(data, spi->dev.platform_data);
if (iRet < 0) {
pr_err("[SSP]: %s - failed initialize pdata\n", __func__);
iRet = -ENOMEM;
goto err_init_pdata;
}
mutex_init(&data->comm_mutex);
mutex_init(&data->wakeup_mutex);
mutex_init(&data->reset_mutex);
mutex_init(&data->enable_mutex);
spi->mode = SPI_MODE_1;
if (spi_setup(spi)) {
pr_err("failed to setup spi for ssp_spi\n");
goto err_setup;
}
data->spi = spi;
spi_set_drvdata(spi, data);
initialize_variable(data);
INIT_DELAYED_WORK(&data->work_firmware, work_function_firmware_update);
/* check boot loader binary */
data->fw_dl_state = check_fwbl(data);
if (data->fw_dl_state == FW_DL_STATE_NONE) {
iRet = startup_mcu(data);
if (iRet == ERROR) {
data->uResetCnt++;
toggle_mcu_reset(data);
msleep(SSP_SW_RESET_TIME);
iRet = startup_mcu(data);
}
if (iRet != SUCCESS) {
pr_err("[SSP]: %s - startup_mcu failed\n", __func__);
goto err_read_reg;
}
}
wake_lock_init(&data->ssp_wake_lock,
WAKE_LOCK_SUSPEND, "ssp_wake_lock");
iRet = initialize_debug_timer(data);
if (iRet < 0) {
pr_err("[SSP]: %s - could not create workqueue\n", __func__);
goto err_create_workqueue;
}
iRet = initialize_irq(data);
if (iRet < 0) {
pr_err("[SSP]: %s - could not create irq\n", __func__);
goto err_setup_irq;
}
iRet = initialize_sensors(data);
if (iRet < 0) {
pr_err("[SSP]: %s - could not initialize sensor\n", __func__);
goto err_init_sensor;
}
/* init sensorhub device */
iRet = ssp_sensorhub_initialize(data);
if (iRet < 0) {
pr_err("%s: ssp_sensorhub_initialize err(%d)", __func__, iRet);
ssp_sensorhub_remove(data);
}
ssp_enable(data, true);
data->bProbeIsDone = true;
pr_info("[SSP]: %s - probe success!\n", __func__);
enable_debug_timer(data);
if (data->fw_dl_state == FW_DL_STATE_NEED_TO_SCHEDULE) {
pr_info("[SSP]: Firmware update is scheduled\n");
schedule_delayed_work(&data->work_firmware,
msecs_to_jiffies(1000));
data->fw_dl_state = FW_DL_STATE_SCHEDULED;
} else if (data->fw_dl_state == FW_DL_STATE_FAIL) {
data->bSspShutdown = true;
}
iRet = 0;
if (data->check_lpmode() == true) {
ssp_charging_motion(data, 1);
data->bLpModeEnabled = true;
pr_info("[SSP]: LPM Charging...\n");
} else {
data->bLpModeEnabled = false;
pr_info("[SSP]: Normal Booting OK\n");
}
goto exit;
err_init_sensor:
free_irq(data->iIrq, data);
gpio_free(data->spi->irq);
err_setup_irq:
destroy_workqueue(data->debug_wq);
err_create_workqueue:
err_input_register_device:
wake_lock_destroy(&data->ssp_wake_lock);
err_read_reg:
err_reset_null:
err_setup:
mutex_destroy(&data->enable_mutex);
mutex_destroy(&data->reset_mutex);
mutex_destroy(&data->wakeup_mutex);
mutex_destroy(&data->comm_mutex);
err_init_pdata:
kfree(data);
pr_err("[SSP]: %s - probe failed!\n", __func__);
exit:
pr_info("#####################################################\n\n");
return iRet;
}
static int __devinit csid_probe(struct platform_device *pdev)
{
struct csid_device *new_csid_dev;
uint32_t csi_vdd_voltage = 0;
int rc = 0;
new_csid_dev = kzalloc(sizeof(struct csid_device), GFP_KERNEL);
if (!new_csid_dev) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
v4l2_subdev_init(&new_csid_dev->msm_sd.sd, &msm_csid_subdev_ops);
v4l2_set_subdevdata(&new_csid_dev->msm_sd.sd, new_csid_dev);
platform_set_drvdata(pdev, &new_csid_dev->msm_sd.sd);
mutex_init(&new_csid_dev->mutex);
if (pdev->dev.of_node) {
rc = of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
if (rc < 0) {
pr_err("%s:%d failed to read cell-index\n", __func__,
__LINE__);
goto csid_no_resource;
}
CDBG("%s device id %d\n", __func__, pdev->id);
rc = of_property_read_u32((&pdev->dev)->of_node,
"qcom,csi-vdd-voltage", &csi_vdd_voltage);
if (rc < 0) {
pr_err("%s:%d failed to read qcom,csi-vdd-voltage\n",
__func__, __LINE__);
goto csid_no_resource;
}
CDBG("%s:%d reading mipi_csi_vdd is %d\n", __func__, __LINE__,
csi_vdd_voltage);
csid_vreg_info[0].min_voltage = csi_vdd_voltage;
csid_vreg_info[0].max_voltage = csi_vdd_voltage;
}
new_csid_dev->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csid");
if (!new_csid_dev->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "csid");
if (!new_csid_dev->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->io = request_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem), pdev->name);
if (!new_csid_dev->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
new_csid_dev->pdev = pdev;
new_csid_dev->msm_sd.sd.internal_ops = &msm_csid_internal_ops;
new_csid_dev->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(new_csid_dev->msm_sd.sd.name,
ARRAY_SIZE(new_csid_dev->msm_sd.sd.name), "msm_csid");
media_entity_init(&new_csid_dev->msm_sd.sd.entity, 0, NULL, 0);
new_csid_dev->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
new_csid_dev->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_CSID;
new_csid_dev->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x5;
msm_sd_register(&new_csid_dev->msm_sd);
rc = request_irq(new_csid_dev->irq->start, msm_csid_irq,
IRQF_TRIGGER_RISING, "csid", new_csid_dev);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s: irq request fail\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
disable_irq(new_csid_dev->irq->start);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s Error registering irq ", __func__);
goto csid_no_resource;
}
new_csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
csid_no_resource:
mutex_destroy(&new_csid_dev->mutex);
kfree(new_csid_dev);
return 0;
}
static int ufs_fill_super(struct super_block *sb, void *data, int silent)
{
struct ufs_sb_info * sbi;
struct ufs_sb_private_info * uspi;
struct ufs_super_block_first * usb1;
struct ufs_super_block_second * usb2;
struct ufs_super_block_third * usb3;
struct ufs_buffer_head * ubh;
struct inode *inode;
unsigned block_size, super_block_size;
unsigned flags;
unsigned super_block_offset;
unsigned maxsymlen;
int ret = -EINVAL;
uspi = NULL;
ubh = NULL;
flags = 0;
UFSD("ENTER\n");
#ifndef CONFIG_UFS_FS_WRITE
if (!(sb->s_flags & MS_RDONLY)) {
printk("ufs was compiled with read-only support, "
"can't be mounted as read-write\n");
return -EROFS;
}
#endif
sbi = kzalloc(sizeof(struct ufs_sb_info), GFP_KERNEL);
if (!sbi)
goto failed_nomem;
sb->s_fs_info = sbi;
sbi->sb = sb;
UFSD("flag %u\n", (int)(sb->s_flags & MS_RDONLY));
mutex_init(&sbi->mutex);
spin_lock_init(&sbi->work_lock);
INIT_DELAYED_WORK(&sbi->sync_work, delayed_sync_fs);
/*
* Set default mount options
* Parse mount options
*/
sbi->s_mount_opt = 0;
ufs_set_opt (sbi->s_mount_opt, ONERROR_LOCK);
if (!ufs_parse_options ((char *) data, &sbi->s_mount_opt)) {
printk("wrong mount options\n");
goto failed;
}
if (!(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE)) {
if (!silent)
printk("You didn't specify the type of your ufs filesystem\n\n"
"mount -t ufs -o ufstype="
"sun|sunx86|44bsd|ufs2|5xbsd|old|hp|nextstep|nextstep-cd|openstep ...\n\n"
">>>WARNING<<< Wrong ufstype may corrupt your filesystem, "
"default is ufstype=old\n");
ufs_set_opt (sbi->s_mount_opt, UFSTYPE_OLD);
}
uspi = kzalloc(sizeof(struct ufs_sb_private_info), GFP_KERNEL);
sbi->s_uspi = uspi;
if (!uspi)
goto failed;
uspi->s_dirblksize = UFS_SECTOR_SIZE;
super_block_offset=UFS_SBLOCK;
/* Keep 2Gig file limit. Some UFS variants need to override
this but as I don't know which I'll let those in the know loosen
the rules */
switch (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) {
case UFS_MOUNT_UFSTYPE_44BSD:
UFSD("ufstype=44bsd\n");
uspi->s_fsize = block_size = 512;
uspi->s_fmask = ~(512 - 1);
uspi->s_fshift = 9;
uspi->s_sbsize = super_block_size = 1536;
uspi->s_sbbase = 0;
flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
break;
case UFS_MOUNT_UFSTYPE_UFS2:
UFSD("ufstype=ufs2\n");
super_block_offset=SBLOCK_UFS2;
uspi->s_fsize = block_size = 512;
uspi->s_fmask = ~(512 - 1);
uspi->s_fshift = 9;
uspi->s_sbsize = super_block_size = 1536;
uspi->s_sbbase = 0;
flags |= UFS_TYPE_UFS2 | UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
break;
case UFS_MOUNT_UFSTYPE_SUN:
UFSD("ufstype=sun\n");
uspi->s_fsize = block_size = 1024;
uspi->s_fmask = ~(1024 - 1);
uspi->s_fshift = 10;
uspi->s_sbsize = super_block_size = 2048;
uspi->s_sbbase = 0;
uspi->s_maxsymlinklen = 0; /* Not supported on disk */
flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUN | UFS_CG_SUN;
break;
case UFS_MOUNT_UFSTYPE_SUNOS:
UFSD(("ufstype=sunos\n"))
uspi->s_fsize = block_size = 1024;
uspi->s_fmask = ~(1024 - 1);
uspi->s_fshift = 10;
uspi->s_sbsize = 2048;
super_block_size = 2048;
uspi->s_sbbase = 0;
uspi->s_maxsymlinklen = 0; /* Not supported on disk */
flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_SUNOS | UFS_CG_SUN;
break;
case UFS_MOUNT_UFSTYPE_SUNx86:
UFSD("ufstype=sunx86\n");
uspi->s_fsize = block_size = 1024;
uspi->s_fmask = ~(1024 - 1);
uspi->s_fshift = 10;
uspi->s_sbsize = super_block_size = 2048;
uspi->s_sbbase = 0;
uspi->s_maxsymlinklen = 0; /* Not supported on disk */
flags |= UFS_DE_OLD | UFS_UID_EFT | UFS_ST_SUNx86 | UFS_CG_SUN;
break;
case UFS_MOUNT_UFSTYPE_OLD:
UFSD("ufstype=old\n");
uspi->s_fsize = block_size = 1024;
uspi->s_fmask = ~(1024 - 1);
uspi->s_fshift = 10;
uspi->s_sbsize = super_block_size = 2048;
uspi->s_sbbase = 0;
flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
if (!(sb->s_flags & MS_RDONLY)) {
if (!silent)
printk(KERN_INFO "ufstype=old is supported read-only\n");
sb->s_flags |= MS_RDONLY;
}
break;
case UFS_MOUNT_UFSTYPE_NEXTSTEP:
UFSD("ufstype=nextstep\n");
uspi->s_fsize = block_size = 1024;
uspi->s_fmask = ~(1024 - 1);
uspi->s_fshift = 10;
uspi->s_sbsize = super_block_size = 2048;
uspi->s_sbbase = 0;
uspi->s_dirblksize = 1024;
flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
if (!(sb->s_flags & MS_RDONLY)) {
if (!silent)
printk(KERN_INFO "ufstype=nextstep is supported read-only\n");
sb->s_flags |= MS_RDONLY;
}
break;
case UFS_MOUNT_UFSTYPE_NEXTSTEP_CD:
UFSD("ufstype=nextstep-cd\n");
uspi->s_fsize = block_size = 2048;
uspi->s_fmask = ~(2048 - 1);
uspi->s_fshift = 11;
uspi->s_sbsize = super_block_size = 2048;
uspi->s_sbbase = 0;
uspi->s_dirblksize = 1024;
flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
if (!(sb->s_flags & MS_RDONLY)) {
if (!silent)
printk(KERN_INFO "ufstype=nextstep-cd is supported read-only\n");
sb->s_flags |= MS_RDONLY;
}
break;
case UFS_MOUNT_UFSTYPE_OPENSTEP:
UFSD("ufstype=openstep\n");
uspi->s_fsize = block_size = 1024;
uspi->s_fmask = ~(1024 - 1);
uspi->s_fshift = 10;
uspi->s_sbsize = super_block_size = 2048;
uspi->s_sbbase = 0;
uspi->s_dirblksize = 1024;
flags |= UFS_DE_44BSD | UFS_UID_44BSD | UFS_ST_44BSD | UFS_CG_44BSD;
if (!(sb->s_flags & MS_RDONLY)) {
if (!silent)
printk(KERN_INFO "ufstype=openstep is supported read-only\n");
sb->s_flags |= MS_RDONLY;
}
break;
case UFS_MOUNT_UFSTYPE_HP:
UFSD("ufstype=hp\n");
uspi->s_fsize = block_size = 1024;
uspi->s_fmask = ~(1024 - 1);
uspi->s_fshift = 10;
uspi->s_sbsize = super_block_size = 2048;
uspi->s_sbbase = 0;
flags |= UFS_DE_OLD | UFS_UID_OLD | UFS_ST_OLD | UFS_CG_OLD;
if (!(sb->s_flags & MS_RDONLY)) {
if (!silent)
printk(KERN_INFO "ufstype=hp is supported read-only\n");
sb->s_flags |= MS_RDONLY;
}
break;
default:
if (!silent)
printk("unknown ufstype\n");
goto failed;
}
again:
if (!sb_set_blocksize(sb, block_size)) {
printk(KERN_ERR "UFS: failed to set blocksize\n");
goto failed;
}
/*
* read ufs super block from device
*/
ubh = ubh_bread_uspi(uspi, sb, uspi->s_sbbase + super_block_offset/block_size, super_block_size);
if (!ubh)
goto failed;
usb1 = ubh_get_usb_first(uspi);
usb2 = ubh_get_usb_second(uspi);
usb3 = ubh_get_usb_third(uspi);
/* Sort out mod used on SunOS 4.1.3 for fs_state */
uspi->s_postblformat = fs32_to_cpu(sb, usb3->fs_postblformat);
if (((flags & UFS_ST_MASK) == UFS_ST_SUNOS) &&
(uspi->s_postblformat != UFS_42POSTBLFMT)) {
flags &= ~UFS_ST_MASK;
flags |= UFS_ST_SUN;
}
/*
* Check ufs magic number
*/
sbi->s_bytesex = BYTESEX_LE;
switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
case UFS_MAGIC:
case UFS_MAGIC_BW:
case UFS2_MAGIC:
case UFS_MAGIC_LFN:
case UFS_MAGIC_FEA:
case UFS_MAGIC_4GB:
goto magic_found;
}
sbi->s_bytesex = BYTESEX_BE;
switch ((uspi->fs_magic = fs32_to_cpu(sb, usb3->fs_magic))) {
case UFS_MAGIC:
case UFS_MAGIC_BW:
case UFS2_MAGIC:
case UFS_MAGIC_LFN:
case UFS_MAGIC_FEA:
case UFS_MAGIC_4GB:
goto magic_found;
}
if ((((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP)
|| ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_NEXTSTEP_CD)
|| ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_OPENSTEP))
&& uspi->s_sbbase < 256) {
ubh_brelse_uspi(uspi);
ubh = NULL;
uspi->s_sbbase += 8;
goto again;
}
if (!silent)
printk("ufs_read_super: bad magic number\n");
goto failed;
magic_found:
/*
* Check block and fragment sizes
*/
uspi->s_bsize = fs32_to_cpu(sb, usb1->fs_bsize);
uspi->s_fsize = fs32_to_cpu(sb, usb1->fs_fsize);
uspi->s_sbsize = fs32_to_cpu(sb, usb1->fs_sbsize);
uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
if (!is_power_of_2(uspi->s_fsize)) {
printk(KERN_ERR "ufs_read_super: fragment size %u is not a power of 2\n",
uspi->s_fsize);
goto failed;
}
if (uspi->s_fsize < 512) {
printk(KERN_ERR "ufs_read_super: fragment size %u is too small\n",
uspi->s_fsize);
goto failed;
}
if (uspi->s_fsize > 4096) {
printk(KERN_ERR "ufs_read_super: fragment size %u is too large\n",
uspi->s_fsize);
goto failed;
}
if (!is_power_of_2(uspi->s_bsize)) {
printk(KERN_ERR "ufs_read_super: block size %u is not a power of 2\n",
uspi->s_bsize);
goto failed;
}
if (uspi->s_bsize < 4096) {
printk(KERN_ERR "ufs_read_super: block size %u is too small\n",
uspi->s_bsize);
goto failed;
}
if (uspi->s_bsize / uspi->s_fsize > 8) {
printk(KERN_ERR "ufs_read_super: too many fragments per block (%u)\n",
uspi->s_bsize / uspi->s_fsize);
goto failed;
}
if (uspi->s_fsize != block_size || uspi->s_sbsize != super_block_size) {
ubh_brelse_uspi(uspi);
ubh = NULL;
block_size = uspi->s_fsize;
super_block_size = uspi->s_sbsize;
UFSD("another value of block_size or super_block_size %u, %u\n", block_size, super_block_size);
goto again;
}
sbi->s_flags = flags;/*after that line some functions use s_flags*/
ufs_print_super_stuff(sb, usb1, usb2, usb3);
/*
* Check, if file system was correctly unmounted.
* If not, make it read only.
*/
if (((flags & UFS_ST_MASK) == UFS_ST_44BSD) ||
((flags & UFS_ST_MASK) == UFS_ST_OLD) ||
(((flags & UFS_ST_MASK) == UFS_ST_SUN ||
(flags & UFS_ST_MASK) == UFS_ST_SUNOS ||
(flags & UFS_ST_MASK) == UFS_ST_SUNx86) &&
(ufs_get_fs_state(sb, usb1, usb3) == (UFS_FSOK - fs32_to_cpu(sb, usb1->fs_time))))) {
switch(usb1->fs_clean) {
case UFS_FSCLEAN:
UFSD("fs is clean\n");
break;
case UFS_FSSTABLE:
UFSD("fs is stable\n");
break;
case UFS_FSLOG:
UFSD("fs is logging fs\n");
break;
case UFS_FSOSF1:
UFSD("fs is DEC OSF/1\n");
break;
case UFS_FSACTIVE:
printk("ufs_read_super: fs is active\n");
sb->s_flags |= MS_RDONLY;
break;
case UFS_FSBAD:
printk("ufs_read_super: fs is bad\n");
sb->s_flags |= MS_RDONLY;
break;
default:
printk("ufs_read_super: can't grok fs_clean 0x%x\n", usb1->fs_clean);
sb->s_flags |= MS_RDONLY;
break;
}
} else {
printk("ufs_read_super: fs needs fsck\n");
sb->s_flags |= MS_RDONLY;
}
/*
* Read ufs_super_block into internal data structures
*/
sb->s_op = &ufs_super_ops;
sb->s_export_op = &ufs_export_ops;
sb->s_magic = fs32_to_cpu(sb, usb3->fs_magic);
uspi->s_sblkno = fs32_to_cpu(sb, usb1->fs_sblkno);
uspi->s_cblkno = fs32_to_cpu(sb, usb1->fs_cblkno);
uspi->s_iblkno = fs32_to_cpu(sb, usb1->fs_iblkno);
uspi->s_dblkno = fs32_to_cpu(sb, usb1->fs_dblkno);
uspi->s_cgoffset = fs32_to_cpu(sb, usb1->fs_cgoffset);
uspi->s_cgmask = fs32_to_cpu(sb, usb1->fs_cgmask);
if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2) {
uspi->s_u2_size = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_size);
uspi->s_u2_dsize = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_dsize);
} else {
uspi->s_size = fs32_to_cpu(sb, usb1->fs_size);
uspi->s_dsize = fs32_to_cpu(sb, usb1->fs_dsize);
}
uspi->s_ncg = fs32_to_cpu(sb, usb1->fs_ncg);
/* s_bsize already set */
/* s_fsize already set */
uspi->s_fpb = fs32_to_cpu(sb, usb1->fs_frag);
uspi->s_minfree = fs32_to_cpu(sb, usb1->fs_minfree);
uspi->s_bmask = fs32_to_cpu(sb, usb1->fs_bmask);
uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
uspi->s_bshift = fs32_to_cpu(sb, usb1->fs_bshift);
uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
UFSD("uspi->s_bshift = %d,uspi->s_fshift = %d", uspi->s_bshift,
uspi->s_fshift);
uspi->s_fpbshift = fs32_to_cpu(sb, usb1->fs_fragshift);
uspi->s_fsbtodb = fs32_to_cpu(sb, usb1->fs_fsbtodb);
/* s_sbsize already set */
uspi->s_csmask = fs32_to_cpu(sb, usb1->fs_csmask);
uspi->s_csshift = fs32_to_cpu(sb, usb1->fs_csshift);
uspi->s_nindir = fs32_to_cpu(sb, usb1->fs_nindir);
uspi->s_inopb = fs32_to_cpu(sb, usb1->fs_inopb);
uspi->s_nspf = fs32_to_cpu(sb, usb1->fs_nspf);
uspi->s_npsect = ufs_get_fs_npsect(sb, usb1, usb3);
uspi->s_interleave = fs32_to_cpu(sb, usb1->fs_interleave);
uspi->s_trackskew = fs32_to_cpu(sb, usb1->fs_trackskew);
if (uspi->fs_magic == UFS2_MAGIC)
uspi->s_csaddr = fs64_to_cpu(sb, usb3->fs_un1.fs_u2.fs_csaddr);
else
uspi->s_csaddr = fs32_to_cpu(sb, usb1->fs_csaddr);
uspi->s_cssize = fs32_to_cpu(sb, usb1->fs_cssize);
uspi->s_cgsize = fs32_to_cpu(sb, usb1->fs_cgsize);
uspi->s_ntrak = fs32_to_cpu(sb, usb1->fs_ntrak);
uspi->s_nsect = fs32_to_cpu(sb, usb1->fs_nsect);
uspi->s_spc = fs32_to_cpu(sb, usb1->fs_spc);
uspi->s_ipg = fs32_to_cpu(sb, usb1->fs_ipg);
uspi->s_fpg = fs32_to_cpu(sb, usb1->fs_fpg);
uspi->s_cpc = fs32_to_cpu(sb, usb2->fs_un.fs_u1.fs_cpc);
uspi->s_contigsumsize = fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_contigsumsize);
uspi->s_qbmask = ufs_get_fs_qbmask(sb, usb3);
uspi->s_qfmask = ufs_get_fs_qfmask(sb, usb3);
uspi->s_nrpos = fs32_to_cpu(sb, usb3->fs_nrpos);
uspi->s_postbloff = fs32_to_cpu(sb, usb3->fs_postbloff);
uspi->s_rotbloff = fs32_to_cpu(sb, usb3->fs_rotbloff);
/*
* Compute another frequently used values
*/
uspi->s_fpbmask = uspi->s_fpb - 1;
if ((flags & UFS_TYPE_MASK) == UFS_TYPE_UFS2)
uspi->s_apbshift = uspi->s_bshift - 3;
else
uspi->s_apbshift = uspi->s_bshift - 2;
uspi->s_2apbshift = uspi->s_apbshift * 2;
uspi->s_3apbshift = uspi->s_apbshift * 3;
uspi->s_apb = 1 << uspi->s_apbshift;
uspi->s_2apb = 1 << uspi->s_2apbshift;
uspi->s_3apb = 1 << uspi->s_3apbshift;
uspi->s_apbmask = uspi->s_apb - 1;
uspi->s_nspfshift = uspi->s_fshift - UFS_SECTOR_BITS;
uspi->s_nspb = uspi->s_nspf << uspi->s_fpbshift;
uspi->s_inopf = uspi->s_inopb >> uspi->s_fpbshift;
uspi->s_bpf = uspi->s_fsize << 3;
uspi->s_bpfshift = uspi->s_fshift + 3;
uspi->s_bpfmask = uspi->s_bpf - 1;
if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_44BSD ||
(sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_UFS2)
uspi->s_maxsymlinklen =
fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
if (uspi->fs_magic == UFS2_MAGIC)
maxsymlen = 2 * 4 * (UFS_NDADDR + UFS_NINDIR);
else
maxsymlen = 4 * (UFS_NDADDR + UFS_NINDIR);
if (uspi->s_maxsymlinklen > maxsymlen) {
ufs_warning(sb, __func__, "ufs_read_super: excessive maximum "
"fast symlink size (%u)\n", uspi->s_maxsymlinklen);
uspi->s_maxsymlinklen = maxsymlen;
}
sb->s_max_links = UFS_LINK_MAX;
inode = ufs_iget(sb, UFS_ROOTINO);
if (IS_ERR(inode)) {
ret = PTR_ERR(inode);
goto failed;
}
sb->s_root = d_make_root(inode);
if (!sb->s_root) {
ret = -ENOMEM;
goto failed;
}
ufs_setup_cstotal(sb);
/*
* Read cylinder group structures
*/
if (!(sb->s_flags & MS_RDONLY))
if (!ufs_read_cylinder_structures(sb))
goto failed;
UFSD("EXIT\n");
return 0;
failed:
mutex_destroy(&sbi->mutex);
if (ubh)
ubh_brelse_uspi (uspi);
kfree (uspi);
kfree(sbi);
sb->s_fs_info = NULL;
UFSD("EXIT (FAILED)\n");
return ret;
failed_nomem:
UFSD("EXIT (NOMEM)\n");
return -ENOMEM;
}
static int
ipc_bridge_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
struct ipc_bridge *dev;
struct usb_device *udev = interface_to_usbdev(intf);
struct usb_host_interface *intf_desc;
struct usb_endpoint_descriptor *ep;
u16 wMaxPacketSize;
int ret;
intf_desc = intf->cur_altsetting;
if (intf_desc->desc.bNumEndpoints != 1 || !usb_endpoint_is_int_in(
&intf_desc->endpoint[0].desc)) {
dev_err(&intf->dev, "driver expects only 1 int ep\n");
return -ENODEV;
}
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
if (!dev) {
dev_err(&intf->dev, "fail to allocate dev\n");
return -ENOMEM;
}
__ipc_bridge_dev = dev;
dev->inturb = usb_alloc_urb(0, GFP_KERNEL);
if (!dev->inturb) {
dev_err(&intf->dev, "fail to allocate int urb\n");
ret = -ENOMEM;
goto free_dev;
}
ep = &intf->cur_altsetting->endpoint[0].desc;
wMaxPacketSize = le16_to_cpu(ep->wMaxPacketSize);
dev->intbuf = kmalloc(wMaxPacketSize, GFP_KERNEL);
if (!dev->intbuf) {
dev_err(&intf->dev, "%s: error allocating int buffer\n",
__func__);
ret = -ENOMEM;
goto free_inturb;
}
usb_fill_int_urb(dev->inturb, udev,
usb_rcvintpipe(udev, ep->bEndpointAddress),
dev->intbuf, wMaxPacketSize,
ipc_bridge_int_cb, dev, ep->bInterval);
dev->in_ctlreq = kmalloc(sizeof(*dev->in_ctlreq), GFP_KERNEL);
if (!dev->in_ctlreq) {
dev_err(&intf->dev, "error allocating IN control req\n");
ret = -ENOMEM;
goto free_intbuf;
}
dev->in_ctlreq->bRequestType =
(USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
dev->in_ctlreq->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
dev->in_ctlreq->wValue = 0;
dev->in_ctlreq->wIndex = intf->cur_altsetting->desc.bInterfaceNumber;
dev->in_ctlreq->wLength = cpu_to_le16(IPC_BRIDGE_MAX_READ_SZ);
dev->readurb = usb_alloc_urb(0, GFP_KERNEL);
if (!dev->readurb) {
dev_err(&intf->dev, "fail to allocate read urb\n");
ret = -ENOMEM;
goto free_in_ctlreq;
}
dev->readbuf = kmalloc(IPC_BRIDGE_MAX_READ_SZ, GFP_KERNEL);
if (!dev->readbuf) {
dev_err(&intf->dev, "fail to allocate read buffer\n");
ret = -ENOMEM;
goto free_readurb;
}
dev->out_ctlreq = kmalloc(sizeof(*dev->out_ctlreq), GFP_KERNEL);
if (!dev->out_ctlreq) {
dev_err(&intf->dev, "error allocating OUT control req\n");
ret = -ENOMEM;
goto free_readbuf;
}
dev->out_ctlreq->bRequestType =
(USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE);
dev->out_ctlreq->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
dev->out_ctlreq->wValue = 0;
dev->out_ctlreq->wIndex = intf->cur_altsetting->desc.bInterfaceNumber;
dev->writeurb = usb_alloc_urb(0, GFP_KERNEL);
if (!dev->writeurb) {
dev_err(&intf->dev, "fail to allocate write urb\n");
ret = -ENOMEM;
goto free_out_ctlreq;
}
dev->udev = usb_get_dev(interface_to_usbdev(intf));
dev->intf = intf;
spin_lock_init(&dev->lock);
init_completion(&dev->write_done);
init_waitqueue_head(&dev->read_wait_q);
INIT_LIST_HEAD(&dev->rx_list);
mutex_init(&dev->open_mutex);
mutex_init(&dev->read_mutex);
mutex_init(&dev->write_mutex);
usb_set_intfdata(intf, dev);
usb_enable_autosuspend(udev);
dev->pdev = platform_device_alloc("ipc_bridge", -1);
if (!dev->pdev) {
dev_err(&intf->dev, "fail to allocate pdev\n");
ret = -ENOMEM;
goto destroy_mutex;
}
ret = platform_device_add_data(dev->pdev, &ipc_bridge_pdata,
sizeof(struct ipc_bridge_platform_data));
if (ret) {
dev_err(&intf->dev, "fail to add pdata\n");
goto put_pdev;
}
ret = platform_device_add(dev->pdev);
if (ret) {
dev_err(&intf->dev, "fail to add pdev\n");
goto put_pdev;
}
ret = ipc_bridge_submit_inturb(dev, GFP_KERNEL);
if (ret) {
dev_err(&intf->dev, "fail to start reading\n");
goto del_pdev;
}
ipc_bridge_debugfs_init();
return 0;
del_pdev:
platform_device_del(dev->pdev);
put_pdev:
platform_device_put(dev->pdev);
destroy_mutex:
usb_disable_autosuspend(udev);
mutex_destroy(&dev->write_mutex);
mutex_destroy(&dev->read_mutex);
mutex_destroy(&dev->open_mutex);
usb_put_dev(dev->udev);
usb_free_urb(dev->writeurb);
free_out_ctlreq:
kfree(dev->out_ctlreq);
free_readbuf:
kfree(dev->readbuf);
free_readurb:
usb_free_urb(dev->readurb);
free_in_ctlreq:
kfree(dev->in_ctlreq);
free_intbuf:
kfree(dev->intbuf);
free_inturb:
usb_free_urb(dev->inturb);
free_dev:
kfree(dev);
__ipc_bridge_dev = NULL;
return ret;
}
/*
* Destroy address map
*
* damapp: address map
*
* Returns: DAM_SUCCESS
* DAM_EINVAL Invalid argument(s)
* DAM_FAILURE General failure
*/
void
damap_destroy(damap_t *damapp)
{
int i;
dam_t *mapp = (dam_t *)damapp;
ASSERT(mapp);
DTRACE_PROBE2(damap__destroy,
char *, mapp->dam_name, damap_t *, mapp);
mutex_enter(&mapp->dam_lock);
/*
* prevent new reports from being added to the map
*/
mapp->dam_flags |= DAM_DESTROYPEND;
if (mapp->dam_high) {
mutex_exit(&mapp->dam_lock);
/*
* wait for outstanding reports to stabilize and cancel
* the timer for this map
*/
(void) damap_sync(damapp, 0);
mutex_enter(&mapp->dam_lock);
dam_sched_timeout(NULL, mapp, 0);
/*
* map is at full stop
* release the contents of the map, invoking the
* detactivation protocol as addresses are released
*/
mutex_exit(&mapp->dam_lock);
for (i = 1; i < mapp->dam_high; i++) {
if (ddi_get_soft_state(mapp->dam_da, i) == NULL)
continue;
ASSERT(DAM_IN_REPORT(mapp, i) == 0);
if (DAM_IS_STABLE(mapp, i)) {
dam_addr_deactivate(mapp, i);
} else {
ddi_strid_free(mapp->dam_addr_hash, i);
ddi_soft_state_free(mapp->dam_da, i);
}
}
ddi_strid_fini(&mapp->dam_addr_hash);
ddi_soft_state_fini(&mapp->dam_da);
kstat_delete(mapp->dam_kstatsp);
} else
mutex_exit(&mapp->dam_lock);
bitset_fini(&mapp->dam_active_set);
bitset_fini(&mapp->dam_stable_set);
bitset_fini(&mapp->dam_report_set);
mutex_destroy(&mapp->dam_lock);
cv_destroy(&mapp->dam_sync_cv);
if (mapp->dam_name)
kmem_free(mapp->dam_name, strlen(mapp->dam_name) + 1);
kmem_free(mapp, sizeof (*mapp));
}
int
ldap_pvt_thread_mutex_destroy( ldap_pvt_thread_mutex_t *mutex )
{
return( mutex_destroy( mutex ) );
}
/* Initialize control handlers */
static int ov13858_init_controls(struct ov13858 *ov13858)
{
struct i2c_client *client = v4l2_get_subdevdata(&ov13858->sd);
struct v4l2_ctrl_handler *ctrl_hdlr;
s64 exposure_max;
s64 vblank_def;
s64 vblank_min;
s64 hblank;
s64 pixel_rate_min;
s64 pixel_rate_max;
const struct ov13858_mode *mode;
int ret;
ctrl_hdlr = &ov13858->ctrl_handler;
ret = v4l2_ctrl_handler_init(ctrl_hdlr, 8);
if (ret)
return ret;
mutex_init(&ov13858->mutex);
ctrl_hdlr->lock = &ov13858->mutex;
ov13858->link_freq = v4l2_ctrl_new_int_menu(ctrl_hdlr,
&ov13858_ctrl_ops,
V4L2_CID_LINK_FREQ,
OV13858_NUM_OF_LINK_FREQS - 1,
0,
link_freq_menu_items);
if (ov13858->link_freq)
ov13858->link_freq->flags |= V4L2_CTRL_FLAG_READ_ONLY;
pixel_rate_max = link_freq_to_pixel_rate(link_freq_menu_items[0]);
pixel_rate_min = link_freq_to_pixel_rate(link_freq_menu_items[1]);
/* By default, PIXEL_RATE is read only */
ov13858->pixel_rate = v4l2_ctrl_new_std(ctrl_hdlr, &ov13858_ctrl_ops,
V4L2_CID_PIXEL_RATE,
pixel_rate_min, pixel_rate_max,
1, pixel_rate_max);
mode = ov13858->cur_mode;
vblank_def = mode->vts_def - mode->height;
vblank_min = mode->vts_min - mode->height;
ov13858->vblank = v4l2_ctrl_new_std(
ctrl_hdlr, &ov13858_ctrl_ops, V4L2_CID_VBLANK,
vblank_min, OV13858_VTS_MAX - mode->height, 1,
vblank_def);
hblank = link_freq_configs[mode->link_freq_index].pixels_per_line -
mode->width;
ov13858->hblank = v4l2_ctrl_new_std(
ctrl_hdlr, &ov13858_ctrl_ops, V4L2_CID_HBLANK,
hblank, hblank, 1, hblank);
if (ov13858->hblank)
ov13858->hblank->flags |= V4L2_CTRL_FLAG_READ_ONLY;
exposure_max = mode->vts_def - 8;
ov13858->exposure = v4l2_ctrl_new_std(
ctrl_hdlr, &ov13858_ctrl_ops,
V4L2_CID_EXPOSURE, OV13858_EXPOSURE_MIN,
exposure_max, OV13858_EXPOSURE_STEP,
OV13858_EXPOSURE_DEFAULT);
v4l2_ctrl_new_std(ctrl_hdlr, &ov13858_ctrl_ops, V4L2_CID_ANALOGUE_GAIN,
OV13858_ANA_GAIN_MIN, OV13858_ANA_GAIN_MAX,
OV13858_ANA_GAIN_STEP, OV13858_ANA_GAIN_DEFAULT);
/* Digital gain */
v4l2_ctrl_new_std(ctrl_hdlr, &ov13858_ctrl_ops, V4L2_CID_DIGITAL_GAIN,
OV13858_DGTL_GAIN_MIN, OV13858_DGTL_GAIN_MAX,
OV13858_DGTL_GAIN_STEP, OV13858_DGTL_GAIN_DEFAULT);
v4l2_ctrl_new_std_menu_items(ctrl_hdlr, &ov13858_ctrl_ops,
V4L2_CID_TEST_PATTERN,
ARRAY_SIZE(ov13858_test_pattern_menu) - 1,
0, 0, ov13858_test_pattern_menu);
if (ctrl_hdlr->error) {
ret = ctrl_hdlr->error;
dev_err(&client->dev, "%s control init failed (%d)\n",
__func__, ret);
goto error;
}
ov13858->sd.ctrl_handler = ctrl_hdlr;
return 0;
error:
v4l2_ctrl_handler_free(ctrl_hdlr);
mutex_destroy(&ov13858->mutex);
return ret;
}
static struct i2c_driver apds9130_driver;
static int __devinit apds9130_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct apds9130_data *data;
int err = 0;
printk(KERN_INFO "%s %d\n ",__func__,__LINE__);
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE)) {
err = -EIO;
printk("apds9130 probe failed due to I2C_FUNC_SMBUS_BYTE. Ret = %d\n",err);
goto exit;
}
data = kzalloc(sizeof(struct apds9130_data), GFP_KERNEL);
if (!data) {
err = -ENOMEM;
printk("apds9130 probe failed due to no memory %d\n",err);
goto exit;
}
data->client = client;
apds9130_i2c_client = client;
i2c_set_clientdata(client, data);
wake_lock_init(&data->ps_wlock, WAKE_LOCK_SUSPEND, "proxi_wakelock");
data->enable = 0; /* default mode is standard */
data->ps_threshold = APDS9130_PS_DETECTION_THRESHOLD;
data->ps_hysteresis_threshold = APDS9130_PS_HSYTERESIS_THRESHOLD;
data->ps_detection = 0; /* default to no detection */
data->enable_ps_sensor = 0; // default to 0
#if defined(APDS9130_PROXIMITY_CAL)
data->cross_talk=PS_DEFAULT_CROSS_TALK;
#endif
mutex_init(&data->update_lock);
/* Initialize the APDS-9130 chip */
err = apds9130_init_client(client);
if (err < 0){
printk("apds9130 probe failed due to init client Ret = %d\n",err);
goto exit_kfree;
}
INIT_DELAYED_WORK(&data->dwork, apds9130_work_handler);
if (request_irq(client->irq, apds9130_interrupt, IRQF_DISABLED|IRQ_TYPE_EDGE_FALLING,
APDS9130_DRV_NAME, (void *)client)) {
printk(KERN_INFO"%s Could not allocate APDS9130_INT %d !\n", __func__,client->irq);
goto exit_kfree;
}
enable_irq_wake(client->irq);
printk(KERN_INFO"%s interrupt is hooked\n", __func__);
data->input_dev_ps = input_allocate_device();
if (!data->input_dev_ps) {
err = -ENOMEM;
printk(KERN_INFO"Failed to allocate input device ps\n");
goto exit_free_irq;
}
set_bit(EV_ABS, data->input_dev_ps->evbit);
input_set_abs_params(data->input_dev_ps, ABS_DISTANCE, 0, 1, 0, 0);
data->input_dev_ps->name = "proximity";
err = input_register_device(data->input_dev_ps);
if (err) {
err = -ENOMEM;
printk(KERN_INFO"Unable to register input device ps: %s\n",
data->input_dev_ps->name);
goto exit_free_dev_ps;
}
data->sw_mode = PROX_STAT_OPERATING;
/* Register sysfs hooks */
err = sysfs_create_group(&client->dev.kobj, &apds9130_attr_group);
if (err)
goto exit_unregister_dev_ps;
printk(KERN_INFO"%s support ver. %s enabled\n", __func__, DRIVER_VERSION);
return 0;
//
exit_unregister_dev_ps:
input_unregister_device(data->input_dev_ps);
exit_free_dev_ps:
input_free_device(data->input_dev_ps);
exit_free_irq:
free_irq(client->irq, client);
exit_kfree:
//
wake_lock_destroy(&data->ps_wlock);
mutex_destroy(&data->update_lock);
//
kfree(data);
exit:
static void ov13858_free_controls(struct ov13858 *ov13858)
{
v4l2_ctrl_handler_free(ov13858->sd.ctrl_handler);
mutex_destroy(&ov13858->mutex);
}
int akm8963_probe(struct i2c_client *client,
const struct i2c_device_id *devid)
{
struct akm8963_data *akm;
int err;
pr_info("%s is called.\n", __func__);
if (client->dev.platform_data == NULL && client->irq == 0) {
dev_err(&client->dev, "platform data & irq are NULL.\n");
err = -ENODEV;
goto exit_platform_data_null;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
dev_err(&client->dev, "I2C check failed, exiting.\n");
err = -ENODEV;
goto exit_check_functionality_failed;
}
akm = kzalloc(sizeof(struct akm8963_data), GFP_KERNEL);
if (!akm) {
dev_err(&client->dev,
"failed to allocate memory for module data\n");
err = -ENOMEM;
goto exit_alloc_data_failed;
}
akm->pdata = client->dev.platform_data;
mutex_init(&akm->lock);
init_completion(&akm->data_ready);
i2c_set_clientdata(client, akm);
akm->this_client = client;
err = akm8963_ecs_set_mode_power_down(akm);
if (err < 0) {
pr_err("%s: akm8963_ecs_set_mode_power_down fail(err=%d)\n",
__func__, err);
goto exit_set_mode_power_down_failed;
}
err = akm8963_setup_irq(akm);
if (err) {
pr_err("%s: could not setup irq\n", __func__);
goto exit_setup_irq;
}
akm->akmd_device.minor = MISC_DYNAMIC_MINOR;
akm->akmd_device.name = "akm8963";
akm->akmd_device.fops = &akmd_fops;
err = misc_register(&akm->akmd_device);
if (err) {
pr_err("%s, misc_register failed.\n", __func__);
goto exit_akmd_device_register_failed;
}
init_waitqueue_head(&akm->state_wq);
/* put into fuse access mode to read asa data */
err = i2c_smbus_write_byte_data(client, AK8963_REG_CNTL1,
AK8963_CNTL1_FUSE_ACCESS);
if (err) {
pr_err("%s: unable to enter fuse rom mode\n", __func__);
goto exit_i2c_failed;
}
err = i2c_smbus_read_i2c_block_data(client, AK8963_FUSE_ASAX,
sizeof(akm->asa), akm->asa);
if (err != sizeof(akm->asa)) {
pr_err("%s: unable to load factory sensitivity adjust values\n",
__func__);
goto exit_i2c_failed;
} else
pr_info("%s: asa_x = %d, asa_y = %d, asa_z = %d\n", __func__,
akm->asa[0], akm->asa[1], akm->asa[2]);
err = i2c_smbus_write_byte_data(client, AK8963_REG_CNTL1,
AK8963_CNTL1_POWER_DOWN);
if (err) {
dev_err(&client->dev, "Error in setting power down mode\n");
goto exit_i2c_failed;
}
akm->dev = sensors_classdev_register("magnetic_sensor");
if (IS_ERR(akm->dev)) {
pr_err("Failed to create device!");
goto exit_class_create_failed;
}
if (device_create_file(akm->dev, &dev_attr_raw_data) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_raw_data.attr.name);
goto exit_device_create_raw_data;
}
if (device_create_file(akm->dev, &dev_attr_vendor) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_name.attr.name);
goto exit_device_create_vendor;
}
if (device_create_file(akm->dev, &dev_attr_name) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_raw_data.attr.name);
goto exit_device_create_name;
}
#ifdef FACTORY_TEST
if (device_create_file(akm->dev, &dev_attr_adc) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_adc.attr.name);
goto exit_device_create_file1;
}
if (device_create_file(akm->dev, &dev_attr_status) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_status.attr.name);
goto exit_device_create_file2;
}
if (device_create_file(akm->dev, &dev_attr_asa) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_asa.attr.name);
goto exit_device_create_file3;
}
if (device_create_file(akm->dev, &dev_attr_selftest) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_selftest.attr.name);
goto exit_device_create_file4;
}
if (device_create_file(akm->dev,
&dev_attr_chk_registers) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_chk_registers.attr.name);
goto exit_device_create_file5;
}
if (device_create_file(akm->dev, &dev_attr_dac) < 0) {
pr_err("Failed to create device file(%s)!\n",
dev_attr_dac.attr.name);
goto exit_device_create_file6;
}
#endif
dev_set_drvdata(akm->dev, akm);
pr_info("%s is successful.\n", __func__);
return 0;
#ifdef FACTORY_TEST
exit_device_create_file6:
device_remove_file(akm->dev, &dev_attr_chk_registers);
exit_device_create_file5:
device_remove_file(akm->dev, &dev_attr_selftest);
exit_device_create_file4:
device_remove_file(akm->dev, &dev_attr_asa);
exit_device_create_file3:
device_remove_file(akm->dev, &dev_attr_status);
exit_device_create_file2:
device_remove_file(akm->dev, &dev_attr_adc);
exit_device_create_file1:
device_remove_file(akm->dev, &dev_attr_name);
#endif
exit_device_create_name:
device_remove_file(akm->dev, &dev_attr_vendor);
exit_device_create_vendor:
device_remove_file(akm->dev, &dev_attr_raw_data);
exit_device_create_raw_data:
sensors_classdev_unregister(akm->dev);
exit_class_create_failed:
exit_i2c_failed:
misc_deregister(&akm->akmd_device);
exit_akmd_device_register_failed:
free_irq(akm->irq, akm);
gpio_free(akm->pdata->gpio_data_ready_int);
exit_setup_irq:
exit_set_mode_power_down_failed:
mutex_destroy(&akm->lock);
kfree(akm);
exit_alloc_data_failed:
exit_check_functionality_failed:
exit_platform_data_null:
return err;
}
static int bq51221_charger_probe(
struct i2c_client *client,
const struct i2c_device_id *id)
{
struct device_node *of_node = client->dev.of_node;
struct bq51221_charger_data *charger;
bq51221_charger_platform_data_t *pdata = client->dev.platform_data;
int ret = 0;
dev_info(&client->dev,
"%s: bq51221 Charger Driver Loading\n", __func__);
if (of_node) {
pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata) {
dev_err(&client->dev, "Failed to allocate memory\n");
return -ENOMEM;
}
ret = bq51221_chg_parse_dt(&client->dev, pdata);
if (ret < 0)
goto err_parse_dt;
} else {
pdata = client->dev.platform_data;
}
charger = kzalloc(sizeof(*charger), GFP_KERNEL);
if (charger == NULL) {
dev_err(&client->dev, "Memory is not enough.\n");
ret = -ENOMEM;
goto err_wpc_nomem;
}
charger->dev = &client->dev;
ret = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA |
I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_I2C_BLOCK);
if (!ret) {
ret = i2c_get_functionality(client->adapter);
dev_err(charger->dev, "I2C functionality is not supported.\n");
ret = -ENOSYS;
goto err_i2cfunc_not_support;
}
charger->client = client;
charger->pdata = pdata;
pr_info("%s: %s\n", __func__, charger->pdata->wireless_charger_name );
/* if board-init had already assigned irq_base (>=0) ,
no need to allocate it;
assign -1 to let this driver allocate resource by itself*/
#if 0 /* this part is for bq51221s */
if (pdata->irq_base < 0)
pdata->irq_base = irq_alloc_descs(-1, 0, BQ51221_EVENT_IRQ, 0);
if (pdata->irq_base < 0) {
pr_err("%s: irq_alloc_descs Fail! ret(%d)\n",
__func__, pdata->irq_base);
ret = -EINVAL;
goto irq_base_err;
} else {
charger->irq_base = pdata->irq_base;
pr_info("%s: irq_base = %d\n",
__func__, charger->irq_base);
#if (LINUX_VERSION_CODE>=KERNEL_VERSION(3,4,0))
irq_domain_add_legacy(of_node, BQ51221_EVENT_IRQ, charger->irq_base, 0,
&irq_domain_simple_ops, NULL);
#endif /*(LINUX_VERSION_CODE>=KERNEL_VERSION(3,4,0))*/
}
#endif
i2c_set_clientdata(client, charger);
charger->psy_chg.name = pdata->wireless_charger_name;
charger->psy_chg.type = POWER_SUPPLY_TYPE_UNKNOWN;
charger->psy_chg.get_property = bq51221_chg_get_property;
charger->psy_chg.set_property = bq51221_chg_set_property;
charger->psy_chg.properties = sec_charger_props;
charger->psy_chg.num_properties = ARRAY_SIZE(sec_charger_props);
mutex_init(&charger->io_lock);
#if 0 /* this part is for bq51221s */
if (charger->chg_irq) {
INIT_DELAYED_WORK(
&charger->isr_work, bq51221_chg_isr_work);
ret = request_threaded_irq(charger->chg_irq,
NULL, bq51221_chg_irq_thread,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"charger-irq", charger);
if (ret) {
dev_err(&client->dev,
"%s: Failed to Reqeust IRQ\n", __func__);
goto err_supply_unreg;
}
ret = enable_irq_wake(charger->chg_irq);
if (ret < 0)
dev_err(&client->dev,
"%s: Failed to Enable Wakeup Source(%d)\n",
__func__, ret);
}
#endif
charger->pdata->cs100_status = 0;
charger->pdata->pad_mode = BQ51221_PAD_MODE_NONE;
charger->pdata->siop_level = 100;
charger->pdata->default_voreg = false;
ret = power_supply_register(&client->dev, &charger->psy_chg);
if (ret) {
dev_err(&client->dev,
"%s: Failed to Register psy_chg\n", __func__);
goto err_supply_unreg;
}
charger->wqueue = create_workqueue("bq51221_workqueue");
if (!charger->wqueue) {
pr_err("%s: Fail to Create Workqueue\n", __func__);
goto err_pdata_free;
}
wake_lock_init(&(charger->wpc_wake_lock), WAKE_LOCK_SUSPEND,
"wpc_wakelock");
INIT_DELAYED_WORK(&charger->wpc_work, bq51221_detect_work);
dev_info(&client->dev,
"%s: bq51221 Charger Driver Loaded\n", __func__);
return 0;
err_pdata_free:
power_supply_unregister(&charger->psy_chg);
err_supply_unreg:
mutex_destroy(&charger->io_lock);
err_i2cfunc_not_support:
kfree(charger);
err_wpc_nomem:
err_parse_dt:
kfree(pdata);
return ret;
}
static int gp2a_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct gp2a_data *gp2a;
struct gp2ap020_pdata *pdata = client->dev.platform_data;
u8 value = 0;
int err = 0;
pr_info("%s : probe start!\n", __func__);
if (!pdata) {
pr_err("%s: missing pdata!\n", __func__);
err = -EINVAL;
goto done;
}
/*
if (!pdata->power_on) {
pr_err("%s: incomplete pdata!\n", __func__);
err = -EINVAL;
goto done;
}
*/
/* allocate driver_data */
gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL);
if (!gp2a) {
pr_err("kzalloc error\n");
err = -ENOMEM;
goto done;
}
gp2a->pdata = pdata;
gp2a->client = client;
gp2a->proximity_enabled = 0;
gp2a->light_enabled = 0;
gp2a->light_delay = SENSOR_DEFAULT_DELAY;
i2c_set_clientdata(client, gp2a);
if (pdata->power_on)
pdata->power_on(true);
if (pdata->version) { /* GP2AP030 */
gp2a_reg[1][1] = 0x1A;
if (pdata->thresh[0])
gp2a_reg[3][1] = pdata->thresh[0];
else
gp2a_reg[3][1] = 0x08;
if (pdata->thresh[1])
gp2a_reg[5][1] = pdata->thresh[1];
else
gp2a_reg[5][1] = 0x0A;
}
INIT_DELAYED_WORK(&gp2a->light_work, gp2a_work_func_light);
INIT_WORK(&gp2a->proximity_work, gp2a_work_func_prox);
err = proximity_input_init(gp2a);
if (err < 0)
goto error_setup_reg_prox;
err = light_input_init(gp2a);
if (err < 0)
goto error_setup_reg_light;
err = sysfs_create_group(&gp2a->proximity_input_dev->dev.kobj,
&proximity_attribute_group);
if (err < 0)
goto err_sysfs_create_group_proximity;
err = sysfs_create_group(&gp2a->light_input_dev->dev.kobj,
&lightsensor_attribute_group);
if (err)
goto err_sysfs_create_group_light;
mutex_init(&gp2a->light_mutex);
mutex_init(&gp2a->data_mutex);
/* wake lock init */
wake_lock_init(&gp2a->prx_wake_lock, WAKE_LOCK_SUSPEND,
"prx_wake_lock");
/* GP2A Regs INIT SETTINGS and Check I2C communication */
/* shutdown mode op[3]=0 */
value = 0x00;
err = gp2a_i2c_write(gp2a, (u8) (COMMAND1), &value);
if (err < 0) {
pr_err("%s failed : threre is no such device.\n", __func__);
goto err_no_device;
}
/* Setup irq */
err = gp2a_setup_irq(gp2a);
if (err) {
pr_err("%s: could not setup irq\n", __func__);
goto err_setup_irq;
}
err = sensors_register(gp2a->light_sensor_device,
gp2a, additional_light_attrs, "light_sensor");
if (err) {
pr_err("%s: cound not register sensor device\n", __func__);
goto err_sysfs_create_factory_light;
}
err = sensors_register(gp2a->proximity_sensor_device,
gp2a, additional_proximity_attrs, "proximity_sensor");
if (err) {
pr_err("%s: cound not register sensor device\n", __func__);
goto err_sysfs_create_factory_proximity;
}
#ifdef CONFIG_SENSOR_USE_SYMLINK
err = sensors_initialize_symlink(gp2a->proximity_input_dev);
if (err) {
pr_err("%s: cound not make proximity sensor symlink(%d).\n",
__func__, err);
goto err_sensors_initialize_symlink_proximity;
}
err = sensors_initialize_symlink(gp2a->light_input_dev);
if (err) {
pr_err("%s: cound not make light sensor symlink(%d).\n",
__func__, err);
goto err_sensors_initialize_symlink_light;
}
#endif
input_report_abs(gp2a->proximity_input_dev, ABS_DISTANCE, 1);
pr_info("%s : probe success!\n", __func__);
return 0;
#ifdef CONFIG_SENSOR_USE_SYMLINK
err_sensors_initialize_symlink_light:
sensors_delete_symlink(gp2a->proximity_input_dev);
err_sensors_initialize_symlink_proximity:
#endif
err_sysfs_create_factory_proximity:
err_sysfs_create_factory_light:
free_irq(gp2a->irq, gp2a);
gpio_free(gp2a->pdata->p_out);
err_setup_irq:
err_no_device:
wake_lock_destroy(&gp2a->prx_wake_lock);
mutex_destroy(&gp2a->light_mutex);
mutex_destroy(&gp2a->data_mutex);
sysfs_remove_group(&gp2a->light_input_dev->dev.kobj,
&lightsensor_attribute_group);
err_sysfs_create_group_light:
sysfs_remove_group(&gp2a->proximity_input_dev->dev.kobj,
&proximity_attribute_group);
err_sysfs_create_group_proximity:
input_unregister_device(gp2a->light_input_dev);
error_setup_reg_light:
input_unregister_device(gp2a->proximity_input_dev);
error_setup_reg_prox:
if (pdata->power_on)
pdata->power_on(false);
kfree(gp2a);
done:
return err;
}
static int __devinit mc33880_probe(struct spi_device *spi)
{
struct mc33880 *mc;
struct mc33880_platform_data *pdata;
int ret;
pdata = spi->dev.platform_data;
if (!pdata || !pdata->base) {
dev_dbg(&spi->dev, "incorrect or missing platform data\n");
return -EINVAL;
}
/*
* bits_per_word cannot be configured in platform data
*/
spi->bits_per_word = 8;
ret = spi_setup(spi);
if (ret < 0)
return ret;
mc = kzalloc(sizeof(struct mc33880), GFP_KERNEL);
if (!mc)
return -ENOMEM;
mutex_init(&mc->lock);
dev_set_drvdata(&spi->dev, mc);
mc->spi = spi;
mc->chip.label = DRIVER_NAME,
mc->chip.set = mc33880_set;
mc->chip.base = pdata->base;
mc->chip.ngpio = PIN_NUMBER;
mc->chip.can_sleep = 1;
mc->chip.dev = &spi->dev;
mc->chip.owner = THIS_MODULE;
mc->port_config = 0x00;
/* write twice, because during initialisation the first setting
* is just for testing SPI communication, and the second is the
* "real" configuration
*/
ret = mc33880_write_config(mc);
mc->port_config = 0x00;
if (!ret)
ret = mc33880_write_config(mc);
if (ret) {
printk(KERN_ERR "Failed writing to " DRIVER_NAME ": %d\n", ret);
goto exit_destroy;
}
ret = gpiochip_add(&mc->chip);
if (ret)
goto exit_destroy;
return ret;
exit_destroy:
dev_set_drvdata(&spi->dev, NULL);
mutex_destroy(&mc->lock);
kfree(mc);
return ret;
}
static int
chfs_unmount(struct mount *mp, int mntflags)
{
int flags = 0, i = 0;
struct ufsmount *ump;
struct chfs_mount *chmp;
if (mntflags & MNT_FORCE)
flags |= FORCECLOSE;
dbg("[START]\n");
ump = VFSTOUFS(mp);
chmp = ump->um_chfs;
/* Stop GC. */
chfs_gc_thread_stop(chmp);
/* Flush everyt buffer. */
(void)vflush(mp, NULLVP, flags);
if (chmp->chm_wbuf_len) {
mutex_enter(&chmp->chm_lock_mountfields);
chfs_flush_pending_wbuf(chmp);
mutex_exit(&chmp->chm_lock_mountfields);
}
/* Free node references. */
for (i = 0; i < chmp->chm_ebh->peb_nr; i++) {
chfs_free_node_refs(&chmp->chm_blocks[i]);
}
/* Destroy vnode cache hashtable. */
chfs_vnocache_hash_destroy(chmp->chm_vnocache_hash);
/* Close eraseblock handler. */
ebh_close(chmp->chm_ebh);
/* Destroy mutexes. */
rw_destroy(&chmp->chm_lock_wbuf);
mutex_destroy(&chmp->chm_lock_vnocache);
mutex_destroy(&chmp->chm_lock_sizes);
mutex_destroy(&chmp->chm_lock_mountfields);
/* Unmount UFS. */
if (ump->um_devvp->v_type != VBAD) {
spec_node_setmountedfs(ump->um_devvp, NULL);
}
vn_lock(ump->um_devvp, LK_EXCLUSIVE | LK_RETRY);
(void)VOP_CLOSE(ump->um_devvp, FREAD|FWRITE, NOCRED);
vput(ump->um_devvp);
mutex_destroy(&ump->um_lock);
/* Everything done. */
kmem_free(ump, sizeof(struct ufsmount));
mp->mnt_data = NULL;
mp->mnt_flag &= ~MNT_LOCAL;
dbg("[END]\n");
return (0);
}
static int gp2a_opt_probe(struct platform_device *pdev)
{
struct gp2a_data *gp2a;
struct gp2a_platform_data *pdata = pdev->dev.platform_data;
u8 value = 0;
int err = 0;
printk(KERN_INFO"[GP2A] %s : probe start!\n", __func__);
if (!pdata) {
pr_err("%s: missing pdata!\n", __func__);
return err;
}
/*PROXY_EN*/
if (gpio_request(pdata ->power_gpio, "PROXY_EN")) {
printk(KERN_ERR "Request GPIO_%d failed!\n", pdata ->power_gpio);
}
if (pdata->gp2a_led_on)
pdata->gp2a_led_on(1);
#ifndef CONFIG_MACH_CRATER_CHN_CTC
if (pdata->gp2a_get_threshold) {
gp2a_update_threshold(pdata->gp2a_get_threshold(), false);
}
#endif
/* allocate driver_data */
gp2a = kzalloc(sizeof(struct gp2a_data), GFP_KERNEL);
if (!gp2a) {
pr_err("kzalloc error\n");
return -ENOMEM;
}
gp2a->proximity_enabled = 0;
gp2a->pdata = pdata;
gp2a->light_enabled = 0;
gp2a->light_delay = SENSOR_DEFAULT_DELAY;
gp2a->testmode = 0;
gp2a->light_level_state = 0;
if (pdata->power_on) {
pdata->power_on(1);
msleep(5);
}
INIT_DELAYED_WORK(&gp2a->light_work, gp2a_work_func_light);
INIT_WORK(&gp2a->proximity_work, gp2a_work_func_prox);
/*misc device registration*/
err = misc_register(&gp2a_opt_misc_device);
if( err < 0 )
goto error_setup_reg_misc;
err = proximity_input_init(gp2a);
if (err < 0)
goto error_setup_reg_prox;
err = light_input_init(gp2a);
if (err < 0)
goto error_setup_reg_light;
err = sysfs_create_group(&gp2a->proximity_input_dev->dev.kobj,
&proximity_attribute_group);
if (err < 0)
goto err_sysfs_create_group_proximity;
err = sysfs_create_group(&gp2a->light_input_dev->dev.kobj,
&lightsensor_attribute_group);
if (err)
goto err_sysfs_create_group_light;
mutex_init(&gp2a->light_mutex);
mutex_init(&gp2a->data_mutex);
/* set platdata */
platform_set_drvdata(pdev, gp2a);
/* wake lock init */
wake_lock_init(&gp2a->prx_wake_lock, WAKE_LOCK_SUSPEND,
"prx_wake_lock");
/* init i2c */
err = opt_i2c_init();
if(err < 0)
{
pr_err("opt_probe failed : i2c_client is NULL\n");
goto err_no_device;
}
else
printk(KERN_INFO "[GP2A] opt_i2c_client : (0x%p)\n",opt_i2c_client);
/* GP2A Regs INIT SETTINGS and Check I2C communication */
value = 0x00;
err = opt_i2c_write((u8) (COMMAND1), &value); /* shutdown mode op[3]=0 */
if (err < 0) {
pr_err("%s failed : threre is no such device.\n", __func__);
goto err_no_device;
}
/* Setup irq */
err = gp2a_setup_irq(gp2a);
if (err) {
pr_err("%s: could not setup irq\n", __func__);
goto err_setup_irq;
}
/* set sysfs for proximity sensor */
gp2a->proximity_dev = device_create(sensors_class,
NULL, 0, NULL, "proximity_sensor");
if (IS_ERR(gp2a->proximity_dev)) {
pr_err("%s: could not create proximity_dev\n", __func__);
goto err_proximity_device_create;
}
gp2a->light_dev = device_create(sensors_class,
NULL, 0, NULL, "light_sensor");
if (IS_ERR(gp2a->light_dev)) {
pr_err("%s: could not create light_dev\n", __func__);
goto err_light_device_create;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_state) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_state.attr.name);
goto err_proximity_device_create_file1;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_prox_avg) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_avg.attr.name);
goto err_proximity_device_create_file2;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_proximity_enable) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_proximity_enable.attr.name);
goto err_proximity_device_create_file3;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_vendor) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_vendor.attr.name);
goto err_proximity_device_create_file4;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_name) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_name.attr.name);
goto err_proximity_device_create_file5;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_prox_cal) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_cal.attr.name);
goto err_proximity_device_create_file6;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_prox_offset_pass) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_offset_pass.attr.name);
goto err_proximity_device_create_file7;
}
if (device_create_file(gp2a->proximity_dev,
&dev_attr_prox_thresh) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_prox_thresh.attr.name);
goto err_proximity_device_create_file8;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_lux) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_lux.attr.name);
goto err_light_device_create_file1;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_light_enable) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_light_enable.attr.name);
goto err_light_device_create_file2;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_vendor) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_vendor.attr.name);
goto err_light_device_create_file3;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_name) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_name.attr.name);
goto err_light_device_create_file4;
}
if (device_create_file(gp2a->light_dev,
&dev_attr_raw_data) < 0) {
pr_err("%s: could not create device file(%s)!\n", __func__,
dev_attr_raw_data.attr.name);
goto err_light_device_create_file5;
}
dev_set_drvdata(gp2a->proximity_dev, gp2a);
dev_set_drvdata(gp2a->light_dev, gp2a);
device_init_wakeup(&pdev->dev, 1);
if (pdata->gp2a_led_on) {
pdata->gp2a_led_on(0);
printk(KERN_INFO "[GP2A] gpio_get_value of GPIO(%d) is %d\n",pdata ->power_gpio,
gpio_get_value(pdata ->power_gpio));
}
/* set initial proximity value as 1 */
input_report_abs(gp2a->proximity_input_dev, ABS_DISTANCE, 1);
input_sync(gp2a->proximity_input_dev);
gp2a_opt_data = gp2a;
printk(KERN_INFO"[GP2A] %s : probe success!\n", __func__);
return 0;
err_light_device_create_file5:
device_remove_file(gp2a->light_dev, &dev_attr_name);
err_light_device_create_file4:
device_remove_file(gp2a->light_dev, &dev_attr_vendor);
err_light_device_create_file3:
device_remove_file(gp2a->light_dev, &dev_attr_light_enable);
err_light_device_create_file2:
device_remove_file(gp2a->light_dev, &dev_attr_lux);
err_light_device_create_file1:
device_remove_file(gp2a->proximity_dev, &dev_attr_prox_thresh);
err_proximity_device_create_file8:
device_remove_file(gp2a->proximity_dev, &dev_attr_prox_offset_pass);
err_proximity_device_create_file7:
device_remove_file(gp2a->proximity_dev, &dev_attr_prox_cal);
err_proximity_device_create_file6:
device_remove_file(gp2a->proximity_dev, &dev_attr_name);
err_proximity_device_create_file5:
device_remove_file(gp2a->proximity_dev, &dev_attr_vendor);
err_proximity_device_create_file4:
device_remove_file(gp2a->proximity_dev, &dev_attr_proximity_enable);
err_proximity_device_create_file3:
device_remove_file(gp2a->proximity_dev, &dev_attr_prox_avg);
err_proximity_device_create_file2:
device_remove_file(gp2a->proximity_dev, &dev_attr_state);
err_proximity_device_create_file1:
err_light_device_create:
device_destroy(sensors_class, 0);
err_proximity_device_create:
gpio_free(pdata->p_out);
err_setup_irq:
err_no_device:
wake_lock_destroy(&gp2a->prx_wake_lock);
mutex_destroy(&gp2a->light_mutex);
mutex_destroy(&gp2a->data_mutex);
sysfs_remove_group(&gp2a->light_input_dev->dev.kobj,
&lightsensor_attribute_group);
err_sysfs_create_group_light:
sysfs_remove_group(&gp2a->proximity_input_dev->dev.kobj,
&proximity_attribute_group);
err_sysfs_create_group_proximity:
input_unregister_device(gp2a->light_input_dev);
error_setup_reg_light:
input_unregister_device(gp2a->proximity_input_dev);
error_setup_reg_prox:
misc_deregister(&gp2a_opt_misc_device);
error_setup_reg_misc:
if (pdata->power_on)
pdata->power_on(0);
kfree(gp2a);
return err;
}
