/**
* All the device spefic initializations happen here.
*/
static NvS32 __init ami304_probe(struct platform_device *pdev)
{
struct i2c_client *new_client = ami304_i2c_client;
struct tegra_compass_device_data *compass = NULL;
struct input_dev *input_dev = NULL;
struct device *dev = &pdev->dev;
NvS32 err;
#if DEBUG_AMI304
printk("[%s:%d] Compass Sensor \n", __FUNCTION__, __LINE__);
#endif
compass = kzalloc(sizeof(*compass), GFP_KERNEL);
if (compass == NULL) {
err = -ENOMEM;
pr_err("ami304_probe: Failed to memory\n");
goto allocate_dev_fail;
}
compass_dev = compass;
input_dev = input_allocate_device();
if (input_dev == NULL) {
err = -ENOMEM;
pr_err("tegra_com_ami304_probe: Failed to allocate input device\n");
goto allocate_dev_fail;
}
compass_dev->input_dev = input_dev;
err = open_def_odm_compass();
if (!err) {
pr_err("open_def_odm_comp: Failed \n");
goto exit_alloc_data_failed;
}
msleep(1);
// mdelay(50); //to waiting time(50ms) from PowerOFF to Stand-by
//On soft reset
AMI304_Reset_Init();
AMI304_Init(AMI304_FORCE_MODE); // default is Force State
#if DEBUG_AMI304
printk("[%s:%d] Compass Sensor: AMI304 registered driver! \n", __FUNCTION__, __LINE__);
#endif
err = misc_register(&ami304_device);
if (err) {
printk(KERN_ERR
"ami304_device register failed\n");
goto exit_misc_device_register_failed;
}
#if 1
platform_set_drvdata(pdev, compass);
set_bit(EV_ABS, compass_dev->input_dev->evbit);
/* yaw */
input_set_abs_params(compass_dev->input_dev, ABS_RX, 0, 360, 0, 0);
/* pitch */
input_set_abs_params(compass_dev->input_dev, ABS_RY, -180, 180, 0, 0);
/* roll */
input_set_abs_params(compass_dev->input_dev, ABS_RZ, -90, 90, 0, 0);
/* status of magnetic sensor */
input_set_abs_params(compass_dev->input_dev, ABS_RUDDER, 0, 5, 0, 0);
/* x-axis acceleration */
input_set_abs_params(compass_dev->input_dev, ABS_X, -2000, 2000, 0, 0);
/* y-axis acceleration */
input_set_abs_params(compass_dev->input_dev, ABS_Y, -2000, 2000, 0, 0);
/* z-axis acceleration */
input_set_abs_params(compass_dev->input_dev, ABS_Z, -2000, 2000, 0, 0);
/* x-axis of raw magnetic vector */
//input_set_abs_params(compass_dev->input_dev, ABS_HAT0X, -3000, 3000, 0, 0);
/* y-axis of raw magnetic vector */
//input_set_abs_params(compass_dev->input_dev, ABS_HAT0Y, -3000, 3000, 0, 0);
/* z-axis of raw magnetic vector */
//input_set_abs_params(compass_dev->input_dev, ABS_BRAKE, -3000, 3000, 0, 0);
/* status of acceleration sensor */
input_set_abs_params(compass_dev->input_dev, ABS_WHEEL, 0, 5, 0, 0);
#if DEBUG_AMI304
printk("[%s:%d] Compass Sensor \n", __FUNCTION__, __LINE__);
#endif
compass_dev->input_dev->name = "Acompass";
err = input_register_device(input_dev);
if (err) {
pr_err("tegra_compass_probe: Unable to register %s\
input device\n", input_dev->name);
goto exit_input_register_device_failed;
}
err = sysfs_create_group(&dev->kobj, &ami304_attribute_group);
#else
platform_set_drvdata(pdev, compass);
input_dev->name = "accelerometer_tegra";
err = input_register_device(input_dev);
if (err) {
pr_err("tegra_compass_probe: Unable to register %s\
input device\n", input_dev->name);
goto input_register_device_failed;
}
err = add_sysfs_entry();
err = sysfs_create_group(&compass_dev->input_dev, &ami304_attribute_group);
if (err)
printk("goto err1;\n");
#endif
err = misc_register(&ami304daemon_device);
if (err) {
printk(KERN_ERR
"ami304daemon_device register failed\n");
goto exit_misc_device_register_failed;
}
err = misc_register(&ami304hal_device);
if (err) {
printk(KERN_ERR
"ami304hal_device register failed\n");
goto exit_misc_device_register_failed;
}
#ifdef CONFIG_HAS_EARLYSUSPEND // wkkim : temporary early suspend apply
early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
early_suspend.suspend = compass_early_suspend;
early_suspend.resume = compass_late_resume;
register_early_suspend(&early_suspend);
#endif
return 0;
exit_input_register_device_failed:
input_free_device(compass_dev->input_dev);
exit_misc_device_register_failed:
//exit_kfree:
kfree(compass_dev);
allocate_dev_fail:
exit_input_dev_alloc_failed:
exit_alloc_data_failed:
close_odm_compass();
input_free_device(input_dev);
kfree(compass);
compass = 0;
err = -ENOMEM;
exit:
return err;
}
/**
* All the device spefic initializations happen here.
*/
static NvS32 __init tegra_acc_probe(struct platform_device *pdev)
{
struct tegra_acc_device_data *accelerometer = NULL;
struct input_dev *input_dev = NULL;
NvS32 err;
NvBool ret;
accelerometer = kzalloc(sizeof(*accelerometer), GFP_KERNEL);
if (accelerometer == NULL) {
err = -ENOMEM;
pr_err("tegra_acc_probe: Failed to memory\n");
goto allocate_dev_fail;
}
accel_dev = accelerometer;
input_dev = input_allocate_device();
if (input_dev == NULL) {
err = -ENOMEM;
pr_err("tegra_acc_probe: Failed to allocate input device\n");
goto allocate_dev_fail;
}
g_input_dev = input_dev;
ret = open_def_odm_accl();
if (!ret) {
pr_err("open_def_odm_accl failed\n");
goto allocate_dev_fail;
}
//start the Int thread.
accelerometer->task = kthread_create(tegra_acc_thread,
accelerometer, "tegra_acc_thread");
if (accelerometer->task == NULL) {
err = -1;
goto thread_create_failed;
}
wake_up_process(accelerometer->task);
accelerometer->input_dev = input_dev;
set_bit(EV_SYN, accelerometer->input_dev->evbit);
set_bit(EV_KEY, accelerometer->input_dev->evbit);
set_bit(EV_ABS, accelerometer->input_dev->evbit);
input_set_abs_params(accelerometer->input_dev, ABS_X,
accelerometer->min_data.x,
accelerometer->max_data.x, 0, 0);
input_set_abs_params(accelerometer->input_dev, ABS_Y,
accelerometer->min_data.y,
accelerometer->max_data.y, 0, 0);
input_set_abs_params(accelerometer->input_dev, ABS_Z,
accelerometer->min_data.z,
accelerometer->max_data.z, 0, 0);
platform_set_drvdata(pdev, accelerometer);
input_dev->name = "accelerometer_tegra";
err = input_register_device(input_dev);
if (err) {
pr_err("tegra_acc_probe: Unable to register %s\
input device\n", input_dev->name);
goto input_register_device_failed;
}
err = add_sysfs_entry();
if (err) {
pr_err("tegra_acc_probe: add_sysfs_entry failed\n");
goto sysfs_failed;
}
printk(KERN_INFO DRIVER_NAME "successfully registered\n");
return err;
sysfs_failed:
input_unregister_device(input_dev);
input_register_device_failed:
accelerometer->bThreadAlive = 0;
thread_create_failed:
//KillThreadHere!
allocate_dev_fail:
close_odm_accl();
input_free_device(input_dev);
kfree(accelerometer);
accelerometer = 0;
err = -ENOMEM;
return err;
}
static int pwm_fan_probe(struct platform_device *pdev)
{
int i;
struct fan_dev_data *fan_data = NULL;
int *rpm_data;
int *rru_data;
int *rrd_data;
int *lookup_data;
int *pwm_data;
int err = 0;
int of_err = 0;
struct device_node *node = NULL;
struct device_node *data_node = NULL;
u32 value;
int pwm_fan_gpio;
int gpio_free_flag = 0;
if (!pdev)
return -EINVAL;
node = pdev->dev.of_node;
if (!node) {
pr_err("FAN: dev of_node NULL\n");
return -EINVAL;
}
data_node = of_parse_phandle(node, "shared_data", 0);
if (!data_node) {
pr_err("PWM shared data node NULL, parse phandle failed\n");
return -EINVAL;
}
fan_data = devm_kzalloc(&pdev->dev,
sizeof(struct fan_dev_data), GFP_KERNEL);
if (!fan_data)
return -ENOMEM;
fan_data->dev = &pdev->dev;
fan_data->fan_reg = regulator_get(fan_data->dev, "vdd-fan");
if (IS_ERR_OR_NULL(fan_data->fan_reg)) {
pr_err("FAN: coudln't get the regulator\n");
devm_kfree(&pdev->dev, (void *)fan_data);
return -ENODEV;
}
of_err |= of_property_read_string(node, "name", &fan_data->name);
pr_info("FAN dev name: %s\n", fan_data->name);
of_err |= of_property_read_u32(data_node, "pwm_gpio", &value);
pwm_fan_gpio = (int)value;
err = gpio_request(pwm_fan_gpio, "pwm-fan");
if (err < 0) {
pr_err("FAN:gpio request failed\n");
err = -EINVAL;
goto gpio_request_fail;
} else {
pr_info("FAN:gpio request success.\n");
}
of_err |= of_property_read_u32(data_node, "active_steps", &value);
fan_data->active_steps = (int)value;
of_err |= of_property_read_u32(data_node, "pwm_period", &value);
fan_data->pwm_period = (int)value;
of_err |= of_property_read_u32(data_node, "pwm_id", &value);
fan_data->pwm_id = (int)value;
of_err |= of_property_read_u32(data_node, "step_time", &value);
fan_data->step_time = (int)value;
of_err |= of_property_read_u32(data_node, "active_pwm_max", &value);
fan_data->fan_pwm_max = (int)value;
of_err |= of_property_read_u32(data_node, "state_cap", &value);
fan_data->fan_state_cap = (int)value;
fan_data->pwm_gpio = pwm_fan_gpio;
if (of_err) {
err = -ENXIO;
goto rpm_alloc_fail;
}
if (of_property_read_u32(data_node, "tach_gpio", &value)) {
fan_data->tach_gpio = -1;
pr_info("FAN: can't find tach_gpio\n");
} else
fan_data->tach_gpio = (int)value;
/* rpm array */
rpm_data = devm_kzalloc(&pdev->dev,
sizeof(int) * (fan_data->active_steps), GFP_KERNEL);
if (!rpm_data) {
err = -ENOMEM;
goto rpm_alloc_fail;
}
of_err |= of_property_read_u32_array(data_node, "active_rpm", rpm_data,
(size_t) fan_data->active_steps);
fan_data->fan_rpm = rpm_data;
/* rru array */
rru_data = devm_kzalloc(&pdev->dev,
sizeof(int) * (fan_data->active_steps), GFP_KERNEL);
if (!rru_data) {
err = -ENOMEM;
goto rru_alloc_fail;
}
of_err |= of_property_read_u32_array(data_node, "active_rru", rru_data,
(size_t) fan_data->active_steps);
fan_data->fan_rru = rru_data;
/* rrd array */
rrd_data = devm_kzalloc(&pdev->dev,
sizeof(int) * (fan_data->active_steps), GFP_KERNEL);
if (!rrd_data) {
err = -ENOMEM;
goto rrd_alloc_fail;
}
of_err |= of_property_read_u32_array(data_node, "active_rrd", rrd_data,
(size_t) fan_data->active_steps);
fan_data->fan_rrd = rrd_data;
/* state_cap_lookup array */
lookup_data = devm_kzalloc(&pdev->dev,
sizeof(int) * (fan_data->active_steps), GFP_KERNEL);
if (!lookup_data) {
err = -ENOMEM;
goto lookup_alloc_fail;
}
of_err |= of_property_read_u32_array(data_node, "state_cap_lookup",
lookup_data, (size_t) fan_data->active_steps);
fan_data->fan_state_cap_lookup = lookup_data;
/* pwm array */
pwm_data = devm_kzalloc(&pdev->dev,
sizeof(int) * (fan_data->active_steps), GFP_KERNEL);
if (!pwm_data) {
err = -ENOMEM;
goto pwm_alloc_fail;
}
of_err |= of_property_read_u32_array(node, "active_pwm", pwm_data,
(size_t) fan_data->active_steps);
fan_data->fan_pwm = pwm_data;
if (of_err) {
err = -ENXIO;
goto workqueue_alloc_fail;
}
mutex_init(&fan_data->fan_state_lock);
fan_data->workqueue = alloc_workqueue(dev_name(&pdev->dev),
WQ_HIGHPRI | WQ_UNBOUND, 1);
if (!fan_data->workqueue) {
err = -ENOMEM;
goto workqueue_alloc_fail;
}
INIT_DELAYED_WORK(&(fan_data->fan_ramp_work), fan_ramping_work_func);
fan_data->fan_cap_pwm = fan_data->fan_pwm[fan_data->fan_state_cap];
fan_data->precision_multiplier =
fan_data->pwm_period / fan_data->fan_pwm_max;
dev_info(&pdev->dev, "cap state:%d, cap pwm:%d\n",
fan_data->fan_state_cap, fan_data->fan_cap_pwm);
fan_data->cdev =
thermal_cooling_device_register("pwm-fan",
fan_data, &pwm_fan_cooling_ops);
if (IS_ERR_OR_NULL(fan_data->cdev)) {
dev_err(&pdev->dev, "Failed to register cooling device\n");
err = -EINVAL;
goto cdev_register_fail;
}
fan_data->pwm_dev = pwm_request(fan_data->pwm_id, dev_name(&pdev->dev));
if (IS_ERR_OR_NULL(fan_data->pwm_dev)) {
dev_err(&pdev->dev, "unable to request PWM for fan\n");
err = -ENODEV;
goto pwm_req_fail;
} else {
dev_info(&pdev->dev, "got pwm for fan\n");
}
fan_data->tach_enabled = 0;
gpio_free(fan_data->pwm_gpio);
gpio_free_flag = 1;
if (fan_data->tach_gpio != -1) {
/* init fan tach */
fan_data->tach_irq = gpio_to_irq(fan_data->tach_gpio);
err = gpio_request(fan_data->tach_gpio, "pwm-fan-tach");
if (err < 0) {
dev_err(&pdev->dev, "fan tach gpio request failed\n");
goto tach_gpio_request_fail;
}
gpio_free_flag = 0;
err = gpio_direction_input(fan_data->tach_gpio);
if (err < 0) {
dev_err(&pdev->dev, "fan tach set gpio direction input failed\n");
goto tach_request_irq_fail;
}
err = gpio_sysfs_set_active_low(fan_data->tach_gpio, 1);
if (err < 0) {
dev_err(&pdev->dev, "fan tach set gpio active low failed\n");
goto tach_request_irq_fail;
}
err = request_irq(fan_data->tach_irq, fan_tach_isr,
IRQF_TRIGGER_RISING,
"pwm-fan-tach", NULL);
if (err < 0) {
dev_err(&pdev->dev, "fan request irq failed\n");
goto tach_request_irq_fail;
}
dev_info(&pdev->dev, "fan tach request irq: %d. success\n",
fan_data->tach_irq);
disable_irq_nosync(fan_data->tach_irq);
}
of_err |= of_property_read_u32(data_node, "tach_period", &value);
if (of_err < 0)
dev_err(&pdev->dev, "parsing tach_period error: %d\n", of_err);
else {
fan_data->tach_period = (int) value;
dev_info(&pdev->dev, "tach period: %d\n", fan_data->tach_period);
/* init tach work related */
fan_data->tach_workqueue = alloc_workqueue(fan_data->name,
WQ_HIGHPRI | WQ_UNBOUND, 1);
if (!fan_data->tach_workqueue) {
err = -ENOMEM;
goto tach_workqueue_alloc_fail;
}
INIT_DELAYED_WORK(&(fan_data->fan_tach_work),
fan_tach_work_func);
queue_delayed_work(fan_data->tach_workqueue,
&(fan_data->fan_tach_work),
msecs_to_jiffies(fan_data->tach_period));
}
/* init rpm related values */
spin_lock_init(&irq_lock);
irq_count = 0;
fan_data->rpm_measured = 0;
/*turn temp control on*/
fan_data->fan_temp_control_flag = 1;
set_pwm_duty_cycle(fan_data->fan_pwm[0], fan_data);
platform_set_drvdata(pdev, fan_data);
if (add_sysfs_entry(&pdev->dev) < 0) {
dev_err(&pdev->dev, "FAN:Can't create syfs node");
err = -ENOMEM;
goto sysfs_fail;
}
if (pwm_fan_debug_init(fan_data) < 0) {
dev_err(&pdev->dev, "FAN:Can't create debug fs nodes");
/*Just continue without debug fs*/
}
/* print out initialized info */
for (i = 0; i < fan_data->active_steps; i++) {
dev_info(&pdev->dev,
"index %d: pwm=%d, rpm=%d, rru=%d, rrd=%d, state:%d\n",
i,
fan_data->fan_pwm[i],
fan_data->fan_rpm[i],
fan_data->fan_rru[i],
fan_data->fan_rrd[i],
fan_data->fan_state_cap_lookup[i]);
}
return err;
sysfs_fail:
destroy_workqueue(fan_data->tach_workqueue);
tach_workqueue_alloc_fail:
free_irq(fan_data->tach_irq, NULL);
tach_request_irq_fail:
tach_gpio_request_fail:
pwm_free(fan_data->pwm_dev);
pwm_req_fail:
thermal_cooling_device_unregister(fan_data->cdev);
cdev_register_fail:
destroy_workqueue(fan_data->workqueue);
workqueue_alloc_fail:
devm_kfree(&pdev->dev, (void *)pwm_data);
pwm_alloc_fail:
devm_kfree(&pdev->dev, (void *)lookup_data);
lookup_alloc_fail:
devm_kfree(&pdev->dev, (void *)rrd_data);
rrd_alloc_fail:
devm_kfree(&pdev->dev, (void *)rru_data);
rru_alloc_fail:
devm_kfree(&pdev->dev, (void *)rpm_data);
rpm_alloc_fail:
if (!gpio_free_flag)
gpio_free(fan_data->pwm_gpio);
gpio_request_fail:
devm_kfree(&pdev->dev, (void *)fan_data);
if (err == -ENXIO)
pr_err("FAN: of_property_read failed\n");
else if (err == -ENOMEM)
pr_err("FAN: memery allocation failed\n");
return err;
}
static int pwm_fan_probe(struct platform_device *pdev)
{
int i;
struct pwm_fan_platform_data *data;
struct fan_dev_data *fan_data;
int *rpm_data;
int err = 0;
data = dev_get_platdata(&pdev->dev);
if (!data) {
dev_err(&pdev->dev, "platform data is null\n");
return -EINVAL;
}
fan_data = devm_kzalloc(&pdev->dev,
sizeof(struct fan_dev_data), GFP_KERNEL);
if (!fan_data)
return -ENOMEM;
rpm_data = devm_kzalloc(&pdev->dev,
5 * sizeof(int) * data->active_steps, GFP_KERNEL);
if (!rpm_data)
return -ENOMEM;
fan_data->fan_rpm = rpm_data;
fan_data->fan_pwm = rpm_data + data->active_steps;
fan_data->fan_rru = fan_data->fan_pwm + data->active_steps;
fan_data->fan_rrd = fan_data->fan_rru + data->active_steps;
fan_data->fan_state_cap_lookup = fan_data->fan_rrd + data->active_steps;
mutex_init(&fan_data->fan_state_lock);
fan_data->workqueue = alloc_workqueue(dev_name(&pdev->dev),
WQ_HIGHPRI | WQ_UNBOUND, 1);
if (!fan_data->workqueue)
return -ENOMEM;
INIT_DELAYED_WORK(&(fan_data->fan_ramp_work), fan_ramping_work_func);
fan_data->step_time = data->step_time;
fan_data->active_steps = data->active_steps;
fan_data->pwm_period = data->pwm_period;
fan_data->fan_pwm_max = data->active_pwm_max;
fan_data->dev = &pdev->dev;
fan_data->fan_state_cap = data->state_cap;
fan_data->pwm_gpio = data->pwm_gpio;
fan_data->pwm_id = data->pwm_id;
for (i = 0; i < fan_data->active_steps; i++) {
fan_data->fan_rpm[i] = data->active_rpm[i];
fan_data->fan_pwm[i] = data->active_pwm[i];
fan_data->fan_rru[i] = data->active_rru[i];
fan_data->fan_rrd[i] = data->active_rrd[i];
fan_data->fan_state_cap_lookup[i] = data->state_cap_lookup[i];
dev_info(&pdev->dev,
"rpm=%d, pwm=%d, rru=%d, rrd=%d state:%d\n",
fan_data->fan_rpm[i],
fan_data->fan_pwm[i],
fan_data->fan_rru[i],
fan_data->fan_rrd[i],
fan_data->fan_state_cap_lookup[i]);
}
fan_data->fan_cap_pwm = data->active_pwm[data->state_cap];
fan_data->precision_multiplier =
data->pwm_period / data->active_pwm_max;
dev_info(&pdev->dev, "cap state:%d, cap pwm:%d\n",
fan_data->fan_state_cap, fan_data->fan_cap_pwm);
fan_data->cdev =
thermal_cooling_device_register((char *)dev_name(&pdev->dev),
fan_data, &pwm_fan_cooling_ops);
if (IS_ERR_OR_NULL(fan_data->cdev)) {
dev_err(&pdev->dev, "Failed to register cooling device\n");
return -EINVAL;
}
gpio_free(fan_data->pwm_gpio);
fan_data->pwm_dev = pwm_request(data->pwm_id, dev_name(&pdev->dev));
if (IS_ERR_OR_NULL(fan_data->pwm_dev)) {
dev_err(&pdev->dev, "unable to request PWM for fan\n");
err = -ENODEV;
goto pwm_req_fail;
} else {
dev_info(&pdev->dev, "got pwm for fan\n");
}
fan_data->tach_gpio = data->tach_gpio;
fan_data->tach_enabled = 0;
if (fan_data->tach_gpio != -1) {
/* init fan tach */
fan_data->tach_irq = gpio_to_irq(fan_data->tach_gpio);
err = gpio_request(fan_data->tach_gpio, "pwm-fan-tach");
if (err < 0) {
dev_err(&pdev->dev, "fan tach gpio request failed\n");
goto tach_gpio_request_fail;
}
err = gpio_direction_input(fan_data->tach_gpio);
if (err < 0) {
dev_err(&pdev->dev, "fan tach set gpio direction input failed\n");
goto tach_request_irq_fail;
}
err = gpio_sysfs_set_active_low(fan_data->tach_gpio, 1);
if (err < 0) {
dev_err(&pdev->dev, "fan tach set gpio active low failed\n");
goto tach_request_irq_fail;
}
err = request_irq(fan_data->tach_irq, fan_tach_isr,
IRQF_TRIGGER_FALLING , "pwm-fan-tach", NULL);
if (err < 0)
goto tach_request_irq_fail;
disable_irq_nosync(fan_data->tach_irq);
}
platform_set_drvdata(pdev, fan_data);
/*turn temp control on*/
fan_data->fan_temp_control_flag = 1;
set_pwm_duty_cycle(fan_data->fan_pwm[0], fan_data);
if (add_sysfs_entry(&pdev->dev) < 0) {
dev_err(&pdev->dev, "FAN:Can't create syfs node");
err = -ENOMEM;
goto sysfs_fail;
}
if (pwm_fan_debug_init(fan_data) < 0) {
dev_err(&pdev->dev, "FAN:Can't create debug fs nodes");
/*Just continue without debug fs*/
}
return err;
sysfs_fail:
pwm_free(fan_data->pwm_dev);
free_irq(fan_data->tach_irq, NULL);
tach_request_irq_fail:
gpio_free(fan_data->tach_gpio);
tach_gpio_request_fail:
pwm_req_fail:
thermal_cooling_device_unregister(fan_data->cdev);
return err;
}
