static int32_t si_8348_mhl_tx_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int ret;
printk("%s, client=0x%08x\n", __func__, (unsigned int)client);
client->timing = 100;
i2c_bus_adapter = to_i2c_adapter(client->dev.parent);
/*
* On some boards the configuration switches
* are connected via an I2C controlled GPIO expander.
* At this point in the initialization, we're not
* ready to to I2C yet, so don't try to read any config
* switches here. Instead, wait until gpio_expander_init().
*/
// ret = mhl_tx_init(&drv_info, client);
mClient = client;
printk("%s, mhl_tx_init ret %d\n", __func__, ret);
if (ret){
}
return ret;
}
static int __devinit da9052_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter;
// printk("\n\tEntered da9052_i2c_is_probe.............\n");
da9052_i2c = kzalloc(sizeof(struct da9052), GFP_KERNEL);
if (!da9052_i2c)
return -ENOMEM;
/* Get the bus driver handler */
adapter = to_i2c_adapter(client->dev.parent);
/* Check i2c bus driver supports byte data transfer */
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
dev_info(&client->dev,\
"Error in %s:i2c_check_functionality\n", __func__);
return -ENODEV;;
}
/* Store handle to i2c client */
da9052_i2c->i2c_client = client;
da9052_i2c->irq = client->irq;
da9052_i2c->dev = &client->dev;
/* Initialize i2c data structure here*/
da9052_i2c->adapter = adapter;
/* host i2c driver looks only first 7 bits for the slave address */
da9052_i2c->slave_addr = DA9052_I2C_ADDR >> 1;
/* Store the i2c client data */
i2c_set_clientdata(client, da9052_i2c);
/* Validate I2C connectivity */
if ( I2C_CONNECTED == da9052_i2c_is_connected()) {
/* Enable Repeated Write Mode permanently */
struct da9052_ssc_msg ctrl_msg = {
DA9052_CONTROLB_REG, DA9052_CONTROLB_WRITEMODE};
if (da9052_i2c_write(da9052_i2c, &ctrl_msg) < 0) {
dev_info(&da9052_i2c->i2c_client->dev,
"%s: repeated mode not set!!\n", __func__);
return -ENODEV;
}
/* I2C is connected */
da9052_i2c->connecting_device = I2C;
if( 0!= da9052_ssc_init(da9052_i2c) )
return -ENODEV;
}
else {
return -ENODEV;
}
//printk("Exiting da9052_i2c_probe.....\n");
return 0;
}
static int lumpy_add_devices()
{
struct i2c_adapter *adapter;
struct device *dev = NULL;
int bus;
/* find the SMBus adapter */
dev = bus_find_device(&i2c_bus_type, NULL, "SMBus I801 adapter",
__find_i2c_adap);
if (!dev) {
pr_err("%s: no SMBus adapter found on system.\n", __func__);
return -ENXIO;
}
adapter = to_i2c_adapter(dev);
bus = adapter->nr;
/* add cyapa */
lumpy_tp = add_smbus_device(adapter, "trackpad", &cyapa_device);
if (!lumpy_tp)
pr_err("%s failed to register device %d-%02x\n",
__func__, bus, LUMPY_TOUCHPAD_I2C_ADDR);
/* add isl light sensor */
lumpy_als = add_smbus_device(adapter, "lightsensor", &als_device);
if (!lumpy_als)
pr_err("%s failed to register device %d-%02x\n",
__func__, bus, LUMPY_ALS_I2C_ADDR);
i2c_put_adapter(adapter);
return 0;
}
static int fm3130_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
struct fm3130 *fm3130 = dev_get_drvdata(dev);
int tmp;
struct rtc_time *tm = &alrm->time;
/* read the RTC alarm registers all at once */
tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
&fm3130->msg[2], 2);
if (tmp != 2) {
dev_err(dev, "%s error %d\n", "read", tmp);
return -EIO;
}
dev_dbg(dev, "alarm read %02x %02x %02x %02x %02x\n",
fm3130->regs[FM3130_ALARM_SECONDS],
fm3130->regs[FM3130_ALARM_MINUTES],
fm3130->regs[FM3130_ALARM_HOURS],
fm3130->regs[FM3130_ALARM_DATE],
fm3130->regs[FM3130_ALARM_MONTHS]);
tm->tm_sec = bcd2bin(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
tm->tm_min = bcd2bin(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
tm->tm_hour = bcd2bin(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
tm->tm_mday = bcd2bin(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
tm->tm_mon = bcd2bin(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
if (tm->tm_mon > 0)
tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
dev_dbg(dev, "%s secs=%d, mins=%d, "
"hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
"read alarm", tm->tm_sec, tm->tm_min,
tm->tm_hour, tm->tm_mday,
tm->tm_mon, tm->tm_year, tm->tm_wday);
return 0;
}
static int __devinit smsc_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct smsc_data *data;
struct usb4604_platform_data *pdata = client->dev.platform_data;
int err = 0;
if(pdata->usb4604_platform_hw_init)
pdata->usb4604_platform_hw_init();
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
data = kzalloc(sizeof(struct smsc_data), GFP_KERNEL);
if (!data)
return -ENOMEM;
psmsc_data = data;
data->client = client;
i2c_set_clientdata(client, data);
mutex_init(&data->lock);
//CONFIG_MACH_RK3188_S115A use usb3503,usb3503 dont need to write register.
//usb4604 need to write register 0xAA.
smsc_start(client);
dev_info(&client->dev, "driver version %s enabled\n", DRIVER_VERSION);
return 0;
exit_kfree:
kfree(data);
return err;
}
static int __devinit smb328a_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct smb328a_platform_data *pdata = client->dev.platform_data;
int ret;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
printk("+++++++++++++++ %s +++++++++++++++\n", __func__);
smb328a_i2c_client = client;
pdata->start_charging = smb328a_start_charging;
pdata->stop_charging = smb328a_stop_charging;
pdata->get_vbus_status = smb328a_get_vbus_status;
INIT_WORK(&chg_work, _smb328a_chg_work);
setup_timer(&chg_work_timer, _smb328a_chg_work_timer_func, (unsigned long)pdata);
chg_wqueue = create_freezeable_workqueue("smb328a_wqueue");
ret = request_threaded_irq(client->irq, NULL, _smb328a_isr,
IRQF_TRIGGER_RISING,
"smb328a-isr", pdata);
_smb328a_print_register();
return 0;
}
static int smb136_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct smb136_chg_data *chg;
int ret = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
pr_info("%s : SMB136 Charger Driver Loading\n", __func__);
chg = kzalloc(sizeof(struct smb136_chg_data), GFP_KERNEL);
if (!chg)
return -ENOMEM;
chg->client = client;
chg->pdata = client->dev.platform_data;
chg->chgdev = chg->pdata->chgdev;
i2c_set_clientdata(client, chg);
smb136_chg = chg; // set local
printk("Smb136 charger attach success!!!\n");
// Check whether battery already full charged or not.
if(smb136_get_charging_status()==CHARGING_STATUS_FULL)
chg->chgdev->set_charging_status(CHARGING_STATUS_FULL);
if (!chg->pdata) {
pr_err("%s : No platform data supplied\n", __func__);
ret = -EINVAL;
goto err_pdata;
}
chg->chgdev->charging_control = smb136_charging;
chg->chgdev->get_connection_status = NULL;
chg->chgdev->get_charging_status = smb136_get_charging_status;
if(chg->pdata && chg->pdata->charger_dev_register)
chg->pdata->charger_dev_register(chg->chgdev);
charger_i2c_init = 1;
ret = smb136_irq_init(chg);
if (ret)
goto err_pdata;
if (device_create_file(&client->dev, &dev_attr_command) < 0)
printk("Failed to create device file(%s)!\n", dev_attr_command.attr.name);
smb136_test_read();
return 0;
err_pdata:
kfree(chg);
return ret;
}
/*
* i2c_driver function
*/
static int aksensor_probe(struct i2c_client *client,
const struct i2c_device_id *did)
{
struct aksensor_priv *priv;
struct soc_camera_link *icl = soc_camera_i2c_to_link(client);
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int i, ret;
SENDBG("entry %s\n", __func__);
if (!icl || !icl->priv) {
dev_err(&client->dev, "AKSENSOR: missing platform data!\n");
return -EINVAL;
}
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
dev_err(&adapter->dev,
"I2C-Adapter doesn't support "
"I2C_FUNC_SMBUS_BYTE_DATA\n");
return -EIO;
}
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (!priv) {
return -ENOMEM;
}
priv->info = icl->priv;
v4l2_i2c_subdev_init(&priv->subdev, client, &aksensor_subdev_ops);
ret = aksensor_video_probe(client);
if (ret) {
kfree(priv);
return ret;
}
v4l2_ctrl_handler_init(&priv->hdl, cur_sensor_info->nr_ctrls);
for (i = 0; i < cur_sensor_info->nr_ctrls; i++)
v4l2_ctrl_new_custom(&priv->hdl, &cur_sensor_info->ctrls[i], NULL);
priv->subdev.ctrl_handler = &priv->hdl;
if (priv->hdl.error) {
int err = priv->hdl.error;
v4l2_ctrl_handler_free(&priv->hdl);
kfree(priv);
return err;
}
// init sensor resolution, default VGA
for (i = 0; i < cur_sensor_info->num_resolution; i++)
if (!strcmp(cur_sensor_info->resolution[i].name, "VGA")) {
priv->win.width = cur_sensor_info->resolution[i].width;
priv->win.height = cur_sensor_info->resolution[i].height;
}
sensor_dbg("%s: priv->win.width=%d priv->win.height=%d\n",
__func__, priv->win.width, priv->win.height);
return ret;
}
static int fm3130_get_time(struct device *dev, struct rtc_time *t)
{
struct fm3130 *fm3130 = dev_get_drvdata(dev);
int tmp;
if (!fm3130->data_valid) {
/* We have invalid data in RTC, probably due
to battery faults or other problems. Return EIO
for now, it will allow us to set data later insted
of error during probing which disables device */
return -EIO;
}
fm3130_rtc_mode(dev, FM3130_MODE_READ);
/* read the RTC date and time registers all at once */
tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
fm3130->msg, 2);
if (tmp != 2) {
dev_err(dev, "%s error %d\n", "read", tmp);
return -EIO;
}
fm3130_rtc_mode(dev, FM3130_MODE_NORMAL);
dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x"
"%02x %02x %02x %02x %02x %02x %02x\n",
"read",
fm3130->regs[0], fm3130->regs[1],
fm3130->regs[2], fm3130->regs[3],
fm3130->regs[4], fm3130->regs[5],
fm3130->regs[6], fm3130->regs[7],
fm3130->regs[8], fm3130->regs[9],
fm3130->regs[0xa], fm3130->regs[0xb],
fm3130->regs[0xc], fm3130->regs[0xd],
fm3130->regs[0xe]);
t->tm_sec = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
t->tm_min = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
tmp = fm3130->regs[FM3130_RTC_HOURS] & 0x3f;
t->tm_hour = bcd2bin(tmp);
t->tm_wday = bcd2bin(fm3130->regs[FM3130_RTC_DAY] & 0x07) - 1;
t->tm_mday = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
tmp = fm3130->regs[FM3130_RTC_MONTHS] & 0x1f;
t->tm_mon = bcd2bin(tmp) - 1;
/* assume 20YY not 19YY, and ignore CF bit */
t->tm_year = bcd2bin(fm3130->regs[FM3130_RTC_YEARS]) + 100;
dev_dbg(dev, "%s secs=%d, mins=%d, "
"hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
"read", t->tm_sec, t->tm_min,
t->tm_hour, t->tm_mday,
t->tm_mon, t->tm_year, t->tm_wday);
/* initial clock setting can be undefined */
return rtc_valid_tm(t);
}
static int fm3130_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
struct fm3130 *fm3130 = dev_get_drvdata(dev);
int tmp;
struct rtc_time *tm = &alrm->time;
if (!fm3130->alarm_valid) {
/*
*/
return -EIO;
}
/* */
tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
&fm3130->msg[2], 2);
if (tmp != 2) {
dev_err(dev, "%s error %d\n", "read", tmp);
return -EIO;
}
dev_dbg(dev, "alarm read %02x %02x %02x %02x %02x\n",
fm3130->regs[FM3130_ALARM_SECONDS],
fm3130->regs[FM3130_ALARM_MINUTES],
fm3130->regs[FM3130_ALARM_HOURS],
fm3130->regs[FM3130_ALARM_DATE],
fm3130->regs[FM3130_ALARM_MONTHS]);
tm->tm_sec = bcd2bin(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
tm->tm_min = bcd2bin(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
tm->tm_hour = bcd2bin(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
tm->tm_mday = bcd2bin(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
tm->tm_mon = bcd2bin(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
if (tm->tm_mon > 0)
tm->tm_mon -= 1; /* */
dev_dbg(dev, "%s secs=%d, mins=%d, "
"hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
"read alarm", tm->tm_sec, tm->tm_min,
tm->tm_hour, tm->tm_mday,
tm->tm_mon, tm->tm_year, tm->tm_wday);
/* */
fm3130->regs[FM3130_RTC_CONTROL] =
i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
if ((fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AEN) &&
(~fm3130->regs[FM3130_RTC_CONTROL] &
FM3130_RTC_CONTROL_BIT_CAL)) {
alrm->enabled = 1;
}
return 0;
}
static int fm3130_get_time(struct device *dev, struct rtc_time *t)
{
struct fm3130 *fm3130 = dev_get_drvdata(dev);
int tmp;
if (!fm3130->data_valid) {
/*
*/
return -EIO;
}
fm3130_rtc_mode(dev, FM3130_MODE_READ);
/* */
tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
fm3130->msg, 2);
if (tmp != 2) {
dev_err(dev, "%s error %d\n", "read", tmp);
return -EIO;
}
fm3130_rtc_mode(dev, FM3130_MODE_NORMAL);
dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x"
"%02x %02x %02x %02x %02x %02x %02x\n",
"read",
fm3130->regs[0], fm3130->regs[1],
fm3130->regs[2], fm3130->regs[3],
fm3130->regs[4], fm3130->regs[5],
fm3130->regs[6], fm3130->regs[7],
fm3130->regs[8], fm3130->regs[9],
fm3130->regs[0xa], fm3130->regs[0xb],
fm3130->regs[0xc], fm3130->regs[0xd],
fm3130->regs[0xe]);
t->tm_sec = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
t->tm_min = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
tmp = fm3130->regs[FM3130_RTC_HOURS] & 0x3f;
t->tm_hour = bcd2bin(tmp);
t->tm_wday = bcd2bin(fm3130->regs[FM3130_RTC_DAY] & 0x07) - 1;
t->tm_mday = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
tmp = fm3130->regs[FM3130_RTC_MONTHS] & 0x1f;
t->tm_mon = bcd2bin(tmp) - 1;
/* */
t->tm_year = bcd2bin(fm3130->regs[FM3130_RTC_YEARS]) + 100;
dev_dbg(dev, "%s secs=%d, mins=%d, "
"hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
"read", t->tm_sec, t->tm_min,
t->tm_hour, t->tm_mday,
t->tm_mon, t->tm_year, t->tm_wday);
/* */
return rtc_valid_tm(t);
}
static int tsl2550_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct tsl2550_data *data;
int *opmode, err = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WRITE_BYTE
| I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
err = -EIO;
goto exit;
}
data = kzalloc(sizeof(struct tsl2550_data), GFP_KERNEL);
if (!data) {
err = -ENOMEM;
goto exit;
}
data->client = client;
i2c_set_clientdata(client, data);
/* Check platform data */
opmode = client->dev.platform_data;
if (opmode) {
if (*opmode < 0 || *opmode > 1) {
dev_err(&client->dev, "invalid operating_mode (%d)\n",
*opmode);
err = -EINVAL;
goto exit_kfree;
}
data->operating_mode = *opmode;
} else
data->operating_mode = 0; /* default mode is standard */
dev_info(&client->dev, "%s operating mode\n",
data->operating_mode ? "extended" : "standard");
mutex_init(&data->update_lock);
/* Initialize the TSL2550 chip */
err = tsl2550_init_client(client);
if (err)
goto exit_kfree;
/* Register sysfs hooks */
err = sysfs_create_group(&client->dev.kobj, &tsl2550_attr_group);
if (err)
goto exit_kfree;
dev_info(&client->dev, "support ver. %s enabled\n", DRIVER_VERSION);
return 0;
exit_kfree:
kfree(data);
exit:
return err;
}
static int __find_i2c_adap(struct device *dev, void *data)
{
const char *name = data;
struct i2c_adapter *adapter;
if (strncmp(dev_name(dev), "i2c-", 4))
return 0;
adapter = to_i2c_adapter(dev);
return !strncmp(adapter->name, name, strlen(name));
}
static int fm3130_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
struct fm3130 *fm3130 = dev_get_drvdata(dev);
int tmp;
struct rtc_time *tm = &alrm->time;
if (!fm3130->alarm_valid) {
/*
* We have invalid alarm in RTC, probably due to battery faults
* or other problems. Return EIO for now, it will allow us to
* set alarm value later instead of error during probing which
* disables device
*/
return -EIO;
}
/* read the RTC alarm registers all at once */
tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
&fm3130->msg[2], 2);
if (tmp != 2) {
dev_err(dev, "%s error %d\n", "read", tmp);
return -EIO;
}
dev_dbg(dev, "alarm read %02x %02x %02x %02x %02x\n",
fm3130->regs[FM3130_ALARM_SECONDS],
fm3130->regs[FM3130_ALARM_MINUTES],
fm3130->regs[FM3130_ALARM_HOURS],
fm3130->regs[FM3130_ALARM_DATE],
fm3130->regs[FM3130_ALARM_MONTHS]);
tm->tm_sec = bcd2bin(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
tm->tm_min = bcd2bin(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
tm->tm_hour = bcd2bin(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
tm->tm_mday = bcd2bin(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
tm->tm_mon = bcd2bin(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
if (tm->tm_mon > 0)
tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
dev_dbg(dev, "%s secs=%d, mins=%d, "
"hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
"read alarm", tm->tm_sec, tm->tm_min,
tm->tm_hour, tm->tm_mday,
tm->tm_mon, tm->tm_year, tm->tm_wday);
/* check if alarm enabled */
fm3130->regs[FM3130_RTC_CONTROL] =
i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
if ((fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AEN) &&
(~fm3130->regs[FM3130_RTC_CONTROL] &
FM3130_RTC_CONTROL_BIT_CAL)) {
alrm->enabled = 1;
}
return 0;
}
static __devinit int es8323_i2c_probe(struct i2c_client *i2c,
const struct i2c_device_id *id)
{
struct es8323_priv *es8323;
int ret = -1;
struct i2c_adapter *adapter = to_i2c_adapter(i2c->dev.parent);
char reg;
char tmp;
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
dev_warn(&adapter->dev,
"I2C-Adapter doesn't support I2C_FUNC_I2C\n");
return -EIO;
}
es8323 = kzalloc(sizeof(struct es8323_priv), GFP_KERNEL);
if (es8323 == NULL)
return -ENOMEM;
i2c_set_clientdata(i2c, es8323);
es8323->control_type = SND_SOC_I2C;
reg = ES8323_DACCONTROL18;
ret = i2c_master_reg8_recv(i2c, reg, &tmp, 1 ,200 * 1000);
//ret =i2c_master_reg8_recv(client, 0x00, buf, 2, 200*1000);//i2c_write_bytes(client, &test_data, 1); //Test I2C connection.
if (ret < 0){
printk("es8323 probe error\n");
kfree(es8323);
return ret;
}
printk("es8323 probe i2c recv ok\n");
ret = snd_soc_register_codec(&i2c->dev,
&soc_codec_dev_es8323, &es8323_dai, 1);
if (ret < 0) {
kfree(es8323);
return ret;
}
es8323_class = class_create(THIS_MODULE, "es8323");
if (IS_ERR(es8323_class))
{
printk("Create class audio_es8323.\n");
return -ENOMEM;
}
es8323_dev = device_create(es8323_class, NULL, MKDEV(0, 1), NULL, "dev");
ret = device_create_file(es8323_dev, &dev_attr_es8323);
if (ret < 0)
printk("failed to add dev_attr_es8323 file\n");
#ifdef CONFIG_MACH_RK_FAC
es8323_hdmi_ctrl=1;
#endif
return ret;
}
static int __init __find_i2c_adap(struct device *dev, void *data)
{
const char *name = data;
static const char *prefix = "i2c-";
struct i2c_adapter *adapter;
if (strncmp(dev_name(dev), prefix, strlen(prefix)) != 0)
return 0;
adapter = to_i2c_adapter(dev);
return (strncmp(adapter->name, name, strlen(name)) == 0);
}
static int __devinit fsa9480_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct fsa9480_usbsw *usbsw;
int ret = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
usbsw = kzalloc(sizeof(struct fsa9480_usbsw), GFP_KERNEL);
if (!usbsw) {
dev_err(&client->dev, "failed to allocate driver data\n");
return -ENOMEM;
}
usbsw->client = client;
usbsw->pdata = client->dev.platform_data;
chip = usbsw;
i2c_set_clientdata(client, usbsw);
ret = fsa9480_irq_init(usbsw);
if (ret)
goto fail1;
ret = sysfs_create_group(&client->dev.kobj, &fsa9480_group);
if (ret) {
dev_err(&client->dev,
"failed to create fsa9480 attribute group\n");
goto fail2;
}
/* ADC Detect Time: 500ms */
fsa9480_write_reg(client, FSA9480_REG_TIMING1, 0x6);
if (chip->pdata->reset_cb)
chip->pdata->reset_cb();
/* device detection */
fsa9480_detect_dev(usbsw, INT_ATTACH);
pm_runtime_set_active(&client->dev);
return 0;
fail2:
if (client->irq)
free_irq(client->irq, usbsw);
fail1:
i2c_set_clientdata(client, NULL);
kfree(usbsw);
return ret;
}
static int asus_led_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct led_platform_data *pdata;
struct led_info_priv *priv;
struct i2c_adapter *adapter;
int i, ret = 0;
LED_INFO("%s +++\n", __func__);
/* check if the project support TCA6507 */
if (Read_PROJ_ID()==PROJ_ID_ZS550ML_SEC) {
LED_INFO("this project doesn't support tca6507, skip probe function.\n");
return 0;
}
adapter = to_i2c_adapter(client->dev.parent);
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
return -EIO;
pdata = client->dev.platform_data;
if (pdata && pdata->num_leds) {
priv = kzalloc(sizeof_led_info_priv(pdata->num_leds),
GFP_KERNEL);
if (!priv)
return -ENOMEM;
priv->num_leds = pdata->num_leds;
for (i = 0; i < priv->num_leds; i++) {
priv->leds[i].cdev.name = pdata->leds[i].name;
priv->leds[i].cdev.brightness_set = asus_led_set_brightness;
priv->leds[i].cdev.brightness = LED_OFF;
priv->leds[i].cdev.max_brightness = 255;
ret = led_classdev_register(&client->dev, &priv->leds[i].cdev);
if (ret < 0)
LED_ERR("led_classdev_register led[%d] fail\n", i);
#ifdef CONTROL_LED
disable_led_flag = 0;
ret = device_create_file(priv->leds[i].cdev.dev, &dev_attr_disable);
if (ret)
LED_ERR("device_create_file disable in led[%d] fail\n", i);
#endif
red_led_flag = 0;
green_led_flag = 0;
red_blink_flag = 0;
green_blink_flag = 0;
ret = device_create_file(priv->leds[i].cdev.dev, &dev_attr_blink);
if (ret)
LED_ERR("device_create_file blink in led[%d] fail\n", i);
}
}
led_client = client;
LED_INFO("%s ---\n", __func__);
return 0;
}
static int __devinit fsa9480_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct fsa9480_usbsw *usbsw;
int ret = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -EIO;
usbsw = kzalloc(sizeof(struct fsa9480_usbsw), GFP_KERNEL);
if (!usbsw) {
dev_err(&client->dev, "failed to allocate driver data\n");
return -ENOMEM;
}
usbsw->client = client;
usbsw->pdata = client->dev.platform_data;
if (!usbsw->pdata)
goto fail1;
i2c_set_clientdata(client, usbsw);
if (usbsw->pdata->cfg_gpio)
usbsw->pdata->cfg_gpio();
fsa9480_reg_init(usbsw);
ret = fsa9480_irq_init(usbsw);
if (ret)
goto fail1;
ret = sysfs_create_group(&client->dev.kobj, &fsa9480_group);
if (ret) {
dev_err(&client->dev,
"failed to create fsa9480 attribute group\n");
goto fail2;
}
if (usbsw->pdata->reset_cb)
usbsw->pdata->reset_cb();
/* device detection */
fsa9480_detect_dev(usbsw);
return 0;
fail2:
if (client->irq)
free_irq(client->irq, usbsw);
fail1:
i2c_set_clientdata(client, NULL);
kfree(usbsw);
return ret;
}
static int rx8010_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct rx8010_data *rx8010;
int err = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
| I2C_FUNC_SMBUS_I2C_BLOCK)) {
dev_err(&adapter->dev, "doesn't support required functionality\n");
return -EIO;
}
rx8010 = devm_kzalloc(&client->dev, sizeof(struct rx8010_data),
GFP_KERNEL);
if (!rx8010)
return -ENOMEM;
rx8010->client = client;
i2c_set_clientdata(client, rx8010);
err = rx8010_init_client(client);
if (err)
return err;
if (client->irq > 0) {
dev_info(&client->dev, "IRQ %d supplied\n", client->irq);
err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
rx8010_irq_1_handler,
IRQF_TRIGGER_LOW | IRQF_ONESHOT,
"rx8010", client);
if (err) {
dev_err(&client->dev, "unable to request IRQ\n");
client->irq = 0;
} else {
rx8010_rtc_ops.read_alarm = rx8010_read_alarm;
rx8010_rtc_ops.set_alarm = rx8010_set_alarm;
rx8010_rtc_ops.alarm_irq_enable = rx8010_alarm_irq_enable;
}
}
rx8010->rtc = devm_rtc_device_register(&client->dev, client->name,
&rx8010_rtc_ops, THIS_MODULE);
if (IS_ERR(rx8010->rtc)) {
dev_err(&client->dev, "unable to register the class device\n");
return PTR_ERR(rx8010->rtc);
}
rx8010->rtc->max_user_freq = 1;
return err;
}
static int smb347_i2c_probe
(struct i2c_client *client, const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct smb347_chg_data *chg;
int ret = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
pr_info("%s : smb347 Charger Driver Loading\n", __func__);
chg = kzalloc(sizeof(struct smb347_chg_data), GFP_KERNEL);
if (!chg)
return -ENOMEM;
chg->callbacks = kzalloc(sizeof(struct smb_charger_callbacks),
GFP_KERNEL);
if (!chg->callbacks) {
kfree(chg);
return -ENOMEM;
}
chg->client = client;
chg->pdata = client->dev.platform_data;
i2c_set_clientdata(client, chg);
smb347_chg = chg;
if (!chg->pdata) {
pr_err("%s : No platform data supplied\n", __func__);
ret = -EINVAL;
goto err_pdata;
}
pr_info("register callback functions!\n");
chg->callbacks->set_charging_state = smb347_set_charging_state;
chg->callbacks->get_charging_state = smb347_get_charging_state;
chg->callbacks->set_charging_current = smb347_set_charging_current;
chg->callbacks->get_charging_current = smb347_get_charging_current;
chg->callbacks->get_charger_is_full = smb347_get_charger_is_full;
if (chg->pdata && chg->pdata->register_callbacks)
chg->pdata->register_callbacks(chg->callbacks);
pr_info("smb347 charger initialized.\n");
return 0;
err_pdata:
kfree(chg->callbacks);
kfree(chg);
return ret;
}
static int __devinit smb347_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
int ret, irq_num, i;
uint8_t val, buf[15];
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
charger = kzalloc(sizeof(*charger), GFP_KERNEL);
if (!charger)
return -ENOMEM;
charger->client = client;
charger->dev = &client->dev;
i2c_set_clientdata(client, charger);
/* Restore default setting: APSD Enable & 5/1/HC mode Pin control */
smb347_default_setback();
ret = sysfs_create_group(&client->dev.kobj, &smb347_group);
if (ret) {
dev_err(&client->dev, "smb347_probe: unable to create the sysfs\n");
}
mutex_init(&charger->cable_lock);
smb347_wq = create_singlethread_workqueue("smb347_wq");
INIT_DELAYED_WORK_DEFERRABLE(&charger->inok_isr_work, inok_isr_work_function);
//INIT_DELAYED_WORK(&charger->regs_dump_work, regs_dump_work_func);
ret = smb347_inok_irq(charger);
if (ret) {
dev_err(&client->dev, "%s(): Failed in requesting ACOK# pin isr\n",
__func__);
goto error;
}
//queue_delayed_work(smb347_wq, &charger->regs_dump_work, 30*HZ);
cable_type_detect();
ret = register_otg_callback( (callback_t)smb347_otg_status, charger);
if (ret < 0)
goto error;
return 0;
error:
kfree(charger);
return ret;
}
static int i2cdev_detach_adapter(struct device *dev, void *dummy) {
struct i2c_adapter *adap;
//struct i2c_dev *i2c_dev;
if (dev->type != &i2c_adapter_type)
return 0;
adap = to_i2c_adapter(dev);
printk(KERN_INFO "DETACH I2C");
return 0;
}
static int mt9v022_probe(struct i2c_client *client,
const struct i2c_device_id *did)
{
struct mt9v022 *mt9v022;
struct soc_camera_device *icd;
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct soc_camera_link *icl = client->dev.platform_data;
int ret;
if (!icl) {
dev_err(&client->dev, "MT9V022 driver needs platform data\n");
return -EINVAL;
}
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) {
dev_warn(&adapter->dev,
"I2C-Adapter doesn't support I2C_FUNC_SMBUS_WORD\n");
return -EIO;
}
mt9v022 = kzalloc(sizeof(struct mt9v022), GFP_KERNEL);
if (!mt9v022)
return -ENOMEM;
mt9v022->chip_control = MT9V022_CHIP_CONTROL_DEFAULT;
mt9v022->client = client;
i2c_set_clientdata(client, mt9v022);
icd = &mt9v022->icd;
icd->ops = &mt9v022_ops;
icd->control = &client->dev;
icd->x_min = 1;
icd->y_min = 4;
icd->x_current = 1;
icd->y_current = 4;
icd->width_min = 48;
icd->width_max = 752;
icd->height_min = 32;
icd->height_max = 480;
icd->y_skip_top = 1;
icd->iface = icl->bus_id;
ret = soc_camera_device_register(icd);
if (ret)
goto eisdr;
return 0;
eisdr:
kfree(mt9v022);
return ret;
}
static int i2cdev_attach_adapter(struct device *dev, void *dummy) {
struct i2c_adapter *adap;
//struct i2c_dev *i2c_dev;
//int res;
if (dev->type != &i2c_adapter_type)
return 0;
adap = to_i2c_adapter(dev);
printk(KERN_INFO "ATTACH I2C %s", adap->name);
return 0;
}
/*
******************************************************************************
* - Device operation such as;
* probe, init/exit, remove
******************************************************************************
*/
static int __devinit lm356x_probe(struct i2c_client *client,
const struct i2c_device_id *id, struct lm356x_drv_data **data)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct lm356x_platform_data *pdata = client->dev.platform_data;
int result;
*data = kzalloc(sizeof(struct lm356x_drv_data), GFP_KERNEL);
if (*data == NULL) {
dev_err(&client->dev,
"%s: no memory for device\n", __func__);
return -ENOMEM;
}
dev_set_drvdata(&client->dev, *data);
/* Make sure we have i2c functionality on the bus */
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
dev_err(&client->dev,
"%s: Not support i2c functionality\n",
__func__);
result = -EIO;
goto err_setup;
}
if (!pdata) {
dev_err(&client->dev,
"%s: platform data required.\n", __func__);
result = -EINVAL;
goto err_setup;
}
(*data)->client = client;
result = pdata->hw_enable();
if (result) {
dev_err(&client->dev,
"%s: Failed to HW Enable.\n", __func__);
goto err_setup;
}
mutex_init(&(*data)->lock);
return 0;
err_setup:
kfree(*data);
dev_err(&client->dev,
"%s: failed with code %d.\n", __func__, result);
return result;
}
static int nfc_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
FUNC_START();
my_pr_debug( "%s clinet 0x%p id %s", __func__, client, id->name);
adapter = to_i2c_adapter( client->dev.parent);
my_pr_debug( "%s master tx 0x%p id %s", __func__, client->adapter->algo->master_xfer, id->name);
my_pr_debug( "%s master tx 0x%p id %s", __func__, adapter->algo->master_xfer, id->name);
nfc_client = client;
my_pr_err( "%s nfc_client->ext_flag: %d", __func__, nfc_client->ext_flag);
FUNC_END();
return 0;
}
static int smb347_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
struct smb347_chg_data *chg;
int ret = 0;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
return -EIO;
dev_info(&client->dev, "%s : smb347 Charger Driver Loading\n",
__func__);
chg = kzalloc(sizeof(struct smb347_chg_data), GFP_KERNEL);
if (!chg)
return -ENOMEM;
chg->client = client;
if (!chg->client) {
dev_err(&client->dev, "%s : No client\n", __func__);
ret = -EINVAL;
goto err_client;
} else {
chg->dev = &client->dev;
}
chg->pdata = client->dev.platform_data;
if (!chg->pdata) {
dev_err(&client->dev, "%s : No platform data supplied\n",
__func__);
ret = -EINVAL;
goto err_pdata;
}
i2c_set_clientdata(client, chg);
chg->callbacks.set_charging_state = smb347_set_charging_state;
chg->callbacks.get_status_reg = smb347_read_status;
if (chg->pdata->register_callbacks)
chg->pdata->register_callbacks(&chg->callbacks);
pr_info("smb347 charger initialized.\n");
return 0;
err_pdata:
err_client:
kfree(chg);
return ret;
}
static int __init find_i2c_adapter_num(enum i2c_adapter_type type)
{
struct device *dev = NULL;
struct i2c_adapter *adapter;
const char *name = i2c_adapter_names[type];
/* find the adapter by name */
dev = bus_find_device(&i2c_bus_type, NULL, (void *)name,
__find_i2c_adap);
if (!dev) {
pr_err("%s: i2c adapter %s not found on system.\n", __func__,
name);
return -ENODEV;
}
adapter = to_i2c_adapter(dev);
return adapter->nr;
}
/**
* Reboot chip
*
* Caution : IRQ must be disabled before mms_reboot and enabled after mms_reboot.
*/
void mms_reboot(struct mms_ts_info *info)
{
struct i2c_adapter *adapter = to_i2c_adapter(info->client->dev.parent);
dev_dbg(&info->client->dev, "%s [START]\n", __func__);
i2c_lock_adapter(adapter);
mms_power_control(info, 0);
mms_power_control(info, 1);
i2c_unlock_adapter(adapter);
msleep(30);
dev_info(&info->client->dev, "%s [DONE]\n", __func__);
}
