Lines Matching refs:drvdata
173 struct drvdata {
198 * in drvdata must be updated, and only then new output reports can be
221 static void handle_fan_config_report(struct drvdata *drvdata, void *data, int size)
232 spin_lock(&drvdata->wq.lock);
235 drvdata->fan_type[i] = report->fan_type[i];
237 drvdata->fan_config_received = true;
238 wake_up_all_locked(&drvdata->wq);
239 spin_unlock(&drvdata->wq.lock);
242 static void handle_fan_status_report(struct drvdata *drvdata, void *data, int size)
250 spin_lock(&drvdata->wq.lock);
258 if (!drvdata->fan_config_received) {
259 spin_unlock(&drvdata->wq.lock);
264 if (drvdata->fan_type[i] == report->fan_type[i])
274 hid_warn_once(drvdata->hid,
276 i, drvdata->fan_type[i], report->fan_type[i]);
277 drvdata->fan_type[i] = report->fan_type[i];
283 drvdata->fan_rpm[i] =
285 drvdata->fan_duty_percent[i] =
289 drvdata->pwm_status_received = true;
290 wake_up_all_locked(&drvdata->wq);
295 drvdata->fan_in[i] =
297 drvdata->fan_curr[i] =
301 drvdata->voltage_status_received = true;
302 wake_up_all_locked(&drvdata->wq);
306 spin_unlock(&drvdata->wq.lock);
341 struct drvdata *drvdata = dev_get_drvdata(dev);
347 *val = drvdata->update_interval;
355 spin_lock_irq(&drvdata->wq.lock);
369 res = wait_event_interruptible_locked_irq(drvdata->wq,
370 drvdata->fan_config_received);
374 *val = drvdata->fan_type[channel] != FAN_TYPE_NONE;
378 res = wait_event_interruptible_locked_irq(drvdata->wq,
379 drvdata->fan_config_received);
383 *val = drvdata->fan_type[channel] == FAN_TYPE_PWM;
387 res = wait_event_interruptible_locked_irq(drvdata->wq,
388 drvdata->pwm_status_received);
392 *val = scale_pwm_value(drvdata->fan_duty_percent[channel],
405 res = wait_event_interruptible_locked_irq(drvdata->wq,
406 drvdata->pwm_status_received);
410 *val = drvdata->fan_rpm[channel];
416 res = wait_event_interruptible_locked_irq(drvdata->wq,
417 drvdata->voltage_status_received);
421 *val = drvdata->fan_in[channel];
427 res = wait_event_interruptible_locked_irq(drvdata->wq,
428 drvdata->voltage_status_received);
432 *val = drvdata->fan_curr[channel];
441 spin_unlock_irq(&drvdata->wq.lock);
445 static int send_output_report(struct drvdata *drvdata, const void *data,
450 if (data_size > sizeof(drvdata->output_buffer))
453 memcpy(drvdata->output_buffer, data, data_size);
455 if (data_size < sizeof(drvdata->output_buffer))
456 memset(drvdata->output_buffer + data_size, 0,
457 sizeof(drvdata->output_buffer) - data_size);
459 ret = hid_hw_output_report(drvdata->hid, drvdata->output_buffer,
460 sizeof(drvdata->output_buffer));
464 static int set_pwm(struct drvdata *drvdata, int channel, long val)
475 ret = mutex_lock_interruptible(&drvdata->mutex);
480 ret = send_output_report(drvdata, &report, sizeof(report));
495 spin_lock_bh(&drvdata->wq.lock);
496 drvdata->fan_duty_percent[channel] = duty_percent;
497 spin_unlock_bh(&drvdata->wq.lock);
500 mutex_unlock(&drvdata->mutex);
509 static int set_pwm_enable(struct drvdata *drvdata, int channel, long val)
514 spin_lock_irq(&drvdata->wq.lock);
516 res = wait_event_interruptible_locked_irq(drvdata->wq,
517 drvdata->fan_config_received);
519 spin_unlock_irq(&drvdata->wq.lock);
523 expected_val = drvdata->fan_type[channel] != FAN_TYPE_NONE;
525 spin_unlock_irq(&drvdata->wq.lock);
560 static int set_update_interval(struct drvdata *drvdata, long val)
575 ret = send_output_report(drvdata, report, sizeof(report));
579 drvdata->update_interval = control_byte_to_update_interval(control);
583 static int init_device(struct drvdata *drvdata, long update_interval)
591 ret = send_output_report(drvdata, detect_fans_report,
596 return set_update_interval(drvdata, update_interval);
603 struct drvdata *drvdata = dev_get_drvdata(dev);
610 return set_pwm_enable(drvdata, channel, val);
613 return set_pwm(drvdata, channel, val);
622 ret = mutex_lock_interruptible(&drvdata->mutex);
626 ret = set_update_interval(drvdata, val);
628 mutex_unlock(&drvdata->mutex);
691 struct drvdata *drvdata = hid_get_drvdata(hdev);
696 handle_fan_config_report(drvdata, data, size);
700 handle_fan_status_report(drvdata, data, size);
709 struct drvdata *drvdata = hid_get_drvdata(hdev);
715 spin_lock_bh(&drvdata->wq.lock);
716 drvdata->fan_config_received = false;
717 drvdata->pwm_status_received = false;
718 drvdata->voltage_status_received = false;
719 spin_unlock_bh(&drvdata->wq.lock);
721 return init_device(drvdata, drvdata->update_interval);
732 struct drvdata *drvdata;
735 drvdata = devm_kzalloc(&hdev->dev, sizeof(struct drvdata), GFP_KERNEL);
736 if (!drvdata)
739 drvdata->hid = hdev;
740 hid_set_drvdata(hdev, drvdata);
742 init_waitqueue_head(&drvdata->wq);
744 mutex_init(&drvdata->mutex);
745 ret = devm_add_action_or_reset(&hdev->dev, mutex_fini, &drvdata->mutex);
763 init_device(drvdata, UPDATE_INTERVAL_DEFAULT_MS);
765 drvdata->hwmon =
766 hwmon_device_register_with_info(&hdev->dev, "nzxtsmart2", drvdata,
768 if (IS_ERR(drvdata->hwmon)) {
769 ret = PTR_ERR(drvdata->hwmon);
785 struct drvdata *drvdata = hid_get_drvdata(hdev);
787 hwmon_device_unregister(drvdata->hwmon);