/*
* I2C
*/
static int pcf8574x_0x20_setup(struct i2c_client *client, int gpio,
unsigned int ngpio, void *context)
{
int status;
status = gpio_request(gpio + PCF_GPIO_ETH_DETECT, "eth_det");
if (status < 0) {
pr_err("error: can't request GPIO%d\n",
gpio + PCF_GPIO_ETH_DETECT);
return status;
}
status = gpio_direction_input(gpio + PCF_GPIO_ETH_DETECT);
if (status < 0) {
pr_err("error: can't setup GPIO%d as input\n",
gpio + PCF_GPIO_ETH_DETECT);
return status;
}
status = gpio_export(gpio + PCF_GPIO_ETH_DETECT, false);
if (status < 0) {
pr_err("error: can't export GPIO%d\n",
gpio + PCF_GPIO_ETH_DETECT);
return status;
}
status = gpio_sysfs_set_active_low(gpio + PCF_GPIO_ETH_DETECT, 1);
if (status < 0) {
pr_err("error: gpio_sysfs_set active_low(GPIO%d, 1)\n",
gpio + PCF_GPIO_ETH_DETECT);
return status;
}
return 0;
}
int board_gpio_export_one(const struct board_gpio_export_data *d)
{
int s;
s = gpio_request(d->gpio, d->name);
if (s)
goto err;
if (d->flags & BOARD_GPIO_EXPORT_FLAG_OUTPUT) {
int value = d->flags & BOARD_GPIO_EXPORT_FLAG_INIT_ACTIVE;
if (d->flags & BOARD_GPIO_EXPORT_FLAG_INVERTED)
value = !value;
s = gpio_direction_output(d->gpio, value);
} else {
s = gpio_direction_input(d->gpio);
}
if (s)
goto err_free;
s = gpio_sysfs_set_active_low(d->gpio,
d->flags & BOARD_GPIO_EXPORT_FLAG_INVERTED);
if (s)
goto err_free;
s = gpio_export(d->gpio, 0);
if (s)
goto err_free;
return 0;
err_free:
gpio_free(d->gpio);
err:
printk(KERN_ERR "gpio %d (%s) export failed (%d)\n",
d->gpio, d->name, s);
return s;
}
static int adam_backlight_init(struct device *dev)
{
int ret;
ret = gpio_request(ADAM_BL_ENB, "backlight_enb");
if (ret < 0)
return ret;
ret = gpio_direction_output(ADAM_BL_ENB, 1);
if (ret < 0)
gpio_free(ADAM_BL_ENB);
// PQI on/off at /sys/bus/gpio/gpio27
ret = gpio_export(ADAM_BL_ENB, 0);
if(ret < 0)
gpio_free(ADAM_BL_ENB);
gpio_sysfs_set_active_low(ADAM_BL_ENB, 1);
return ret;
};
static int gpio_vreg_request_gpio(struct gpio_vreg *vreg)
{
int rc = 0;
/* */
if (!vreg->gpio_requested) {
rc = gpio_request(vreg->gpio, vreg->gpio_label);
if (rc < 0) {
pr_err("failed to request gpio %u (%s), rc=%d\n",
vreg->gpio, vreg->gpio_label, rc);
return rc;
} else {
vreg->gpio_requested = true;
}
rc = gpio_sysfs_set_active_low(vreg->gpio, vreg->active_low);
if (rc < 0)
pr_err("active_low=%d failed for gpio %u, rc=%d\n",
vreg->active_low, vreg->gpio, rc);
}
return rc;
}
static int __devinit chromeos_arm_probe(struct platform_device *pdev)
{
int gpio, err, active_low;
enum of_gpio_flags flags;
struct device_node *np = pdev->dev.of_node;
if (!np) {
err = -ENODEV;
goto err;
}
gpio = of_get_named_gpio_flags(np, "write-protect-gpio", 0, &flags);
if (!gpio_is_valid(gpio)) {
dev_err(&pdev->dev, "invalid write-protect gpio descriptor\n");
err = -EINVAL;
goto err;
}
active_low = !!(flags & OF_GPIO_ACTIVE_LOW);
err = gpio_request_one(gpio, GPIOF_DIR_IN, "firmware-write-protect");
if (err)
goto err;
err = gpio_sysfs_set_active_low(gpio, active_low);
if (err)
goto err;
gpio_export(gpio, 0);
gpio_export_link(&pdev->dev, "write-protect", gpio);
dev_info(&pdev->dev, "chromeos system detected\n");
err = 0;
err:
of_node_put(np);
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;
}
