static int __devinit melfas_ts_init(void)
{
#ifdef CONFIG_BATTERY_SEC
if (is_lpcharging_state()) {
pr_info("%s : LPM Charging Mode! return 0\n", __func__);
return 0;
}
#endif
return i2c_add_driver(&melfas_ts_driver);
}
static int __init lightsensor_init(void)
{
#ifdef CONFIG_BATTERY_SEC
if (is_lpcharging_state()) {
pr_info("%s : LPM Charging Mode! return 0\n", __func__);
return 0;
}
#endif
sensor_pdev = platform_device_register_simple(SENSOR_NAME, 0, NULL, 0);
if (IS_ERR(sensor_pdev)) {
return -1;
}
return platform_driver_register(&lightsensor_driver);
}
static int __init gp2a_opt_init(void)
{
int ret;
#ifdef CONFIG_BATTERY_SEC
if (is_lpcharging_state()) {
pr_info("%s : LPM Charging Mode! return 0\n", __func__);
return 0;
}
#endif
ret = platform_driver_register(&gp2a_opt_driver);
return ret;
}
static int __init wacom_i2c_init(void)
{
int ret = 0;
#ifdef CONFIG_BATTERY_SEC
if (is_lpcharging_state()) {
pr_info("%s : LPM Charging Mode! return ENODEV!\n", __func__);
return 0;
}
#endif
#if defined(WACOM_SLEEP_WITH_PEN_SLP)
printk(KERN_ERR "[E-PEN]: %s: Sleep type-PEN_SLP pin\n", __func__);
#elif defined(WACOM_SLEEP_WITH_PEN_LDO_EN)
printk(KERN_ERR "[E-PEN]: %s: Sleep type-PEN_LDO_EN pin\n", __func__);
#endif
ret = i2c_add_driver(&wacom_i2c_driver);
if (ret)
printk(KERN_ERR "[E-PEN]: fail to i2c_add_driver\n");
return ret;
}
int akm8975_probe(struct i2c_client *client,
const struct i2c_device_id *devid)
{
struct akm8975_data *akm;
int err;
struct akm8975_platform_data *pdata = client->dev.platform_data;
printk("ak8975 probe start!\n");
if (pdata == NULL) {
dev_err(&client->dev, "platform data is NULL. exiting.\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 akm8975_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 = pdata;
if(pdata->power_on)
akm->power_on = pdata->power_on;
if(pdata->power_off)
akm->power_off = pdata->power_off;
#if defined (CONFIG_KOR_MODEL_SHV_E110S) || defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L) || defined(CONFIG_EUR_MODEL_GT_I9210) \
|| defined(CONFIG_USA_MODEL_SGH_I577)
#if defined(CONFIG_KOR_MODEL_SHV_E160S) || defined(CONFIG_KOR_MODEL_SHV_E160K) || defined(CONFIG_KOR_MODEL_SHV_E160L)
if (get_hw_rev() >= 0x04 ) {
#elif defined(CONFIG_USA_MODEL_SGH_I577)
if (get_hw_rev() >= 0x06 ) {
#else
if (get_hw_rev() >= 0x08 ) {
#endif
/* For Magnetic sensor POR condition */
if(pdata->power_on_mag)
pdata->power_on_mag();
msleep(1);
if(pdata->power_off_mag)
pdata->power_off_mag();
msleep(10);
/* For Magnetic sensor POR condition */
}
#endif
#if defined (CONFIG_USA_MODEL_SGH_I717)
if (get_hw_rev() >= 0x5) {
/* For Magnetic sensor POR condition */
if(pdata->power_on_mag)
pdata->power_on_mag();
msleep(1);
if(pdata->power_off_mag)
pdata->power_off_mag();
msleep(10);
/* For Magnetic sensor POR condition */
}
#endif
if(akm->power_on)
akm->power_on();
mutex_init(&akm->lock);
init_completion(&akm->data_ready);
i2c_set_clientdata(client, akm);
akm->this_client = client;
err = akm8975_ecs_set_mode_power_down(akm);
if (err < 0)
goto exit_set_mode_power_down_failed;
err = akm8975_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 = "akm8975";
akm->akmd_device.fops = &akmd_fops;
err = misc_register(&akm->akmd_device);
if (err)
goto exit_akmd_device_register_failed;
#if defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_CAN_MODEL_SGH_I577R) || defined(CONFIG_CAN_MODEL_SGH_I757M)
/* creating class/device for test */
akm->akm8975_class = class_create(THIS_MODULE, "magnetometer");
if(IS_ERR(akm->akm8975_class)) {
pr_err("%s: class create failed(magnetometer)\n", __func__);
err = PTR_ERR(akm->akm8975_class);
goto exit_class_create_failed;
}
akm->akm8975_dev = device_create(akm->akm8975_class, NULL, 0, "%s", "magnetometer");
if(IS_ERR(akm->akm8975_dev)) {
pr_err("%s: device create failed(magnetometer)\n", __func__);
err = PTR_ERR(akm->akm8975_dev);
goto exit_device_create_failed;
}
err = device_create_file(akm->akm8975_dev, &dev_attr_raw_data);
if (err < 0) {
pr_err("%s: failed to create device file(%s)\n", __func__, dev_attr_raw_data.attr.name);
goto exit_device_create_file_failed;
}
dev_set_drvdata(akm->akm8975_dev, akm);
#endif
init_waitqueue_head(&akm->state_wq);
printk("ak8975 probe success!\n");
return 0;
#if defined(CONFIG_USA_MODEL_SGH_I577) || defined(CONFIG_USA_MODEL_SGH_I757) || defined(CONFIG_CAN_MODEL_SGH_I577R) || defined(CONFIG_CAN_MODEL_SGH_I757M)
exit_device_create_file_failed:
device_destroy(akm->akm8975_class, 0);
exit_device_create_failed:
class_destroy(akm->akm8975_class);
exit_class_create_failed:
misc_deregister(&akm->akmd_device);
#endif
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:
if(akm->power_off)
akm->power_off();
mutex_destroy(&akm->lock);
kfree(akm);
exit_alloc_data_failed:
exit_check_functionality_failed:
exit_platform_data_null:
return err;
}
static int __devexit akm8975_remove(struct i2c_client *client)
{
struct akm8975_data *akm = i2c_get_clientdata(client);
misc_deregister(&akm->akmd_device);
free_irq(akm->irq, akm);
// gpio_free(akm->pdata->gpio_data_ready_int);
mutex_destroy(&akm->lock);
kfree(akm);
return 0;
}
static const struct i2c_device_id akm8975_id[] = {
{AKM8975_I2C_NAME, 0 },
{ }
};
static struct i2c_driver akm8975_driver = {
.probe = akm8975_probe,
.remove = akm8975_remove,
.id_table = akm8975_id,
.driver = {
.pm = &akm8975_pm_ops,
.name = AKM8975_I2C_NAME,
},
};
#ifdef CONFIG_BATTERY_SEC
extern unsigned int is_lpcharging_state(void);
#endif
static int __init akm8975_init(void)
{
#ifdef CONFIG_BATTERY_SEC
if (is_lpcharging_state()) {
pr_info("%s : LPM Charging Mode! return 0\n", __func__);
return 0;
}
#endif
return i2c_add_driver(&akm8975_driver);
}
static void __exit akm8975_exit(void)
{
i2c_del_driver(&akm8975_driver);
}
module_init(akm8975_init);
module_exit(akm8975_exit);
MODULE_DESCRIPTION("AKM8975 compass driver");
MODULE_LICENSE("GPL");
int load_565rle_image(char *filename, bool bf_supported)
{
int fd, err = 0;
unsigned count, max;
unsigned short *data, *bits, *ptr;
struct fb_info *info;
#if 0
struct module *owner;
#endif
info = registered_fb[0];
if (!info) {
printk(KERN_WARNING "%s: Can not access framebuffer\n",
__func__);
return -ENODEV;
}
#if 0
owner = info->fbops->owner;
if (!try_module_get(owner))
return NULL;
if (info->fbops->fb_open && info->fbops->fb_open(info, 0)) {
module_put(owner);
return NULL;
}
#endif
fd = sys_open(filename, O_RDONLY, 0);
if (fd < 0) {
printk(KERN_WARNING "%s: Can not open %s\n",
__func__, filename);
return -ENOENT;
}
printk("%s: open OK! %s\n",__func__, filename);
count = (unsigned)sys_lseek(fd, (off_t)0, 2);
if (count == 0) {
sys_close(fd);
err = -EIO;
goto err_logo_close_file;
}
printk("%s: count %d\n",__func__, count);
sys_lseek(fd, (off_t)0, 0);
data = kmalloc(count, GFP_KERNEL);
if (!data) {
printk(KERN_WARNING "%s: Can not alloc data\n", __func__);
err = -ENOMEM;
goto err_logo_close_file;
}
if ((unsigned)sys_read(fd, (char *)data, count) != count) {
err = -EIO;
goto err_logo_free_data;
}
max = fb_width(info) * fb_height(info);
ptr = data;
bits = (unsigned short *)(info->screen_base);
printk("%s: max %d, n %d 0x%x\n",__func__, max, ptr[0], (unsigned int)bits);
while (count > 3) {
unsigned n = ptr[0];
if (n > max)
break;
memset16_rgb8888(bits, ptr[1], n << 1);
bits += n*2; // for rgb8888
max -= n;
ptr += 2;
count -= 4;
}
#if !defined (CONFIG_USA_OPERATOR_ATT) && !defined (CONFIG_JPN_MODEL_SC_03D) && !defined (CONFIG_CAN_OPERATOR_RWC)
if (!is_lpcharging_state() && !sec_debug_is_recovery_mode())
s3cfb_start_progress(info);
#endif
err_logo_free_data:
kfree(data);
err_logo_close_file:
sys_close(fd);
return err;
}
