static int pwm_fan_resume(struct platform_device *pdev) { struct fan_dev_data *fan_data = platform_get_drvdata(pdev); int err; /*Sanity check, want to make sure fan is off when the driver resumes*/ mutex_lock(&fan_data->fan_state_lock); gpio_free(fan_data->pwm_gpio); 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, " %s: unable to request PWM for fan\n", __func__); mutex_unlock(&fan_data->fan_state_lock); return -ENODEV; } else { dev_info(&pdev->dev, " %s, got pwm for fan\n", __func__); } set_pwm_duty_cycle(0, fan_data); /*Start thermal control*/ fan_data->fan_temp_control_flag = 1; mutex_unlock(&fan_data->fan_state_lock); return 0; }
static int pwm_fan_suspend(struct platform_device *pdev, pm_message_t state) { struct fan_dev_data *fan_data = platform_get_drvdata(pdev); int err; mutex_lock(&fan_data->fan_state_lock); cancel_delayed_work(&fan_data->fan_ramp_work); /*Turn the fan off*/ fan_data->fan_cur_pwm = 0; fan_data->next_target_pwm = 0; set_pwm_duty_cycle(0, fan_data); pwm_disable(fan_data->pwm_dev); pwm_free(fan_data->pwm_dev); err = gpio_request(fan_data->pwm_gpio, "pwm-fan"); if (err < 0) { dev_err(&pdev->dev, "%s:gpio request failed %d\n", __func__, fan_data->pwm_gpio); } gpio_direction_output(fan_data->pwm_gpio, 1); /*Stop thermal control*/ fan_data->fan_temp_control_flag = 0; mutex_unlock(&fan_data->fan_state_lock); return 0; }
/** @fn main() @brief just to test PWM module including drive, speed. @return none */ void main() { //PCA0MD = 0x00; UART0_PORT_Init(); PWM_PORT_Init(); OSCILLATOR_Init(); PCA0_Init(); EA = 1; set_pwm_duty_cycle(50); }
static void fan_ramping_work_func(struct work_struct *work) { int rru, rrd; int cur_pwm, next_pwm; struct delayed_work *dwork = container_of(work, struct delayed_work, work); struct fan_dev_data *fan_data = container_of(dwork, struct fan_dev_data, fan_ramp_work); if (!fan_data) { dev_err(fan_data->dev, "Fan data is null\n"); return; } mutex_lock(&fan_data->fan_state_lock); cur_pwm = fan_data->fan_cur_pwm; rru = fan_get_rru(cur_pwm, fan_data); rrd = fan_get_rrd(cur_pwm, fan_data); next_pwm = cur_pwm; if (fan_data->next_target_pwm > fan_data->fan_cur_pwm) { fan_data->fan_cur_pwm = fan_data->fan_cur_pwm + rru; next_pwm = min( get_next_higher_pwm(cur_pwm, fan_data), fan_data->fan_cur_pwm); next_pwm = min(fan_data->next_target_pwm, next_pwm); next_pwm = min(fan_data->fan_cap_pwm, next_pwm); } else if (fan_data->next_target_pwm < fan_data->fan_cur_pwm) { fan_data->fan_cur_pwm = fan_data->fan_cur_pwm - rrd; next_pwm = max(get_next_lower_pwm(cur_pwm, fan_data), fan_data->fan_cur_pwm); next_pwm = max(next_pwm, fan_data->next_target_pwm); next_pwm = max(0, next_pwm); } set_pwm_duty_cycle(next_pwm, fan_data); fan_data->fan_cur_pwm = next_pwm; if (fan_data->next_target_pwm != next_pwm) queue_delayed_work(fan_data->workqueue, &(fan_data->fan_ramp_work), msecs_to_jiffies(fan_data->step_time)); mutex_unlock(&fan_data->fan_state_lock); }
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 void fan_ramping_work_func(struct work_struct *work) { int rru, rrd, err; int cur_pwm, next_pwm; struct delayed_work *dwork = container_of(work, struct delayed_work, work); struct fan_dev_data *fan_data = container_of(dwork, struct fan_dev_data, fan_ramp_work); if (!fan_data) { dev_err(fan_data->dev, "Fan data is null\n"); return; } mutex_lock(&fan_data->fan_state_lock); cur_pwm = fan_data->fan_cur_pwm; rru = fan_get_rru(cur_pwm, fan_data); rrd = fan_get_rrd(cur_pwm, fan_data); next_pwm = cur_pwm; if (fan_data->next_target_pwm > fan_data->fan_cur_pwm) { fan_data->fan_cur_pwm = fan_data->fan_cur_pwm + rru; next_pwm = min( get_next_higher_pwm(cur_pwm, fan_data), fan_data->fan_cur_pwm); next_pwm = min(fan_data->next_target_pwm, next_pwm); next_pwm = min(fan_data->fan_cap_pwm, next_pwm); } else if (fan_data->next_target_pwm < fan_data->fan_cur_pwm) { fan_data->fan_cur_pwm = fan_data->fan_cur_pwm - rrd; next_pwm = max(get_next_lower_pwm(cur_pwm, fan_data), fan_data->fan_cur_pwm); next_pwm = max(next_pwm, fan_data->next_target_pwm); next_pwm = max(0, next_pwm); } if ((next_pwm != 0) && !(fan_data->is_fan_reg_enabled)) { err = regulator_enable(fan_data->fan_reg); if (err < 0) dev_err(fan_data->dev, " Coudn't enable vdd-fan\n"); else { dev_info(fan_data->dev, " Enabled vdd-fan\n"); fan_data->is_fan_reg_enabled = true; } } if ((next_pwm == 0) && (fan_data->is_fan_reg_enabled)) { err = regulator_disable(fan_data->fan_reg); if (err < 0) dev_err(fan_data->dev, " Couldn't disable vdd-fan\n"); else { dev_info(fan_data->dev, " Disabled vdd-fan\n"); fan_data->is_fan_reg_enabled = false; } } set_pwm_duty_cycle(next_pwm, fan_data); fan_data->fan_cur_pwm = next_pwm; if (fan_data->next_target_pwm != next_pwm) queue_delayed_work(fan_data->workqueue, &(fan_data->fan_ramp_work), msecs_to_jiffies(fan_data->step_time)); mutex_unlock(&fan_data->fan_state_lock); }
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; }