Lines Matching refs:data
232 * Driver data (common to all clients)
260 * Client data (each client gets its own)
303 /* Somewhat ugly :( global data pointer list with all fschmd devices, so that
304 we can find our device data as when using misc_register there is no other
305 method to get to ones device data from the open fop. */
307 /* Note this lock not only protect list access, but also data.kref access */
310 /* Release our data struct when we're detached from the i2c client *and* all
314 struct fschmd_data *data = container_of(ref, struct fschmd_data, kref);
315 kfree(data);
327 struct fschmd_data *data = fschmd_update_device(dev);
329 if (data->kind == fscher || data->kind >= fschrc)
330 return sprintf(buf, "%d\n", (data->volt[index] * dmi_vref *
333 return sprintf(buf, "%d\n", (data->volt[index] *
344 struct fschmd_data *data = fschmd_update_device(dev);
346 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[index]));
353 struct fschmd_data *data = fschmd_update_device(dev);
355 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[index]));
362 struct fschmd_data *data = dev_get_drvdata(dev);
367 mutex_lock(&data->update_lock);
369 FSCHMD_REG_TEMP_LIMIT[data->kind][index], v);
370 data->temp_max[index] = v;
371 mutex_unlock(&data->update_lock);
380 struct fschmd_data *data = fschmd_update_device(dev);
383 if (data->temp_status[index] & FSCHMD_TEMP_WORKING)
393 struct fschmd_data *data = fschmd_update_device(dev);
395 if ((data->temp_status[index] & FSCHMD_TEMP_ALARM_MASK) ==
409 struct fschmd_data *data = fschmd_update_device(dev);
411 return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[index]));
418 struct fschmd_data *data = fschmd_update_device(dev);
421 return sprintf(buf, "%d\n", 1 << (data->fan_ripple[index] & 3));
429 struct fschmd_data *data = dev_get_drvdata(dev);
443 mutex_lock(&data->update_lock);
446 FSCHMD_REG_FAN_RIPPLE[data->kind][index]);
453 FSCHMD_REG_FAN_RIPPLE[data->kind][index], reg);
455 data->fan_ripple[index] = reg;
457 mutex_unlock(&data->update_lock);
466 struct fschmd_data *data = fschmd_update_device(dev);
468 if (data->fan_status[index] & FSCHMD_FAN_ALARM)
478 struct fschmd_data *data = fschmd_update_device(dev);
480 if (data->fan_status[index] & FSCHMD_FAN_NOT_PRESENT)
491 struct fschmd_data *data = fschmd_update_device(dev);
492 int val = data->fan_min[index];
495 if (val || data->kind == fscsyl)
505 struct fschmd_data *data = dev_get_drvdata(dev);
509 if (v || data->kind == fscsyl) {
514 mutex_lock(&data->update_lock);
517 FSCHMD_REG_FAN_MIN[data->kind][index], v);
518 data->fan_min[index] = v;
520 mutex_unlock(&data->update_lock);
531 struct fschmd_data *data = fschmd_update_device(dev);
533 if (data->global_control & FSCHMD_CONTROL_ALERT_LED)
543 struct fschmd_data *data = dev_get_drvdata(dev);
546 mutex_lock(&data->update_lock);
557 data->global_control = reg;
559 mutex_unlock(&data->update_lock);
672 static int watchdog_set_timeout(struct fschmd_data *data, int timeout)
675 int kind = data->kind + 1; /* 0-x array index -> 1-x module param */
686 mutex_lock(&data->watchdog_lock);
687 if (!data->client) {
693 data->watchdog_control &= ~FSCHMD_WDOG_CONTROL_RESOLUTION;
695 data->watchdog_control |= FSCHMD_WDOG_CONTROL_RESOLUTION;
697 data->watchdog_preset = DIV_ROUND_UP(timeout, resolution);
700 i2c_smbus_write_byte_data(data->client,
701 FSCHMD_REG_WDOG_PRESET[data->kind], data->watchdog_preset);
703 i2c_smbus_write_byte_data(data->client,
704 FSCHMD_REG_WDOG_CONTROL[data->kind],
705 data->watchdog_control & ~FSCHMD_WDOG_CONTROL_TRIGGER);
707 ret = data->watchdog_preset * resolution;
710 mutex_unlock(&data->watchdog_lock);
714 static int watchdog_get_timeout(struct fschmd_data *data)
718 mutex_lock(&data->watchdog_lock);
719 if (data->watchdog_control & FSCHMD_WDOG_CONTROL_RESOLUTION)
720 timeout = data->watchdog_preset * 60;
722 timeout = data->watchdog_preset * 2;
723 mutex_unlock(&data->watchdog_lock);
728 static int watchdog_trigger(struct fschmd_data *data)
732 mutex_lock(&data->watchdog_lock);
733 if (!data->client) {
738 data->watchdog_control |= FSCHMD_WDOG_CONTROL_TRIGGER;
739 i2c_smbus_write_byte_data(data->client,
740 FSCHMD_REG_WDOG_CONTROL[data->kind],
741 data->watchdog_control);
743 mutex_unlock(&data->watchdog_lock);
747 static int watchdog_stop(struct fschmd_data *data)
751 mutex_lock(&data->watchdog_lock);
752 if (!data->client) {
757 data->watchdog_control &= ~FSCHMD_WDOG_CONTROL_STARTED;
760 i2c_smbus_write_byte_data(data->client,
761 FSCHMD_REG_WDOG_CONTROL[data->kind],
762 data->watchdog_control | FSCHMD_WDOG_CONTROL_STOP);
764 mutex_unlock(&data->watchdog_lock);
770 struct fschmd_data *pos, *data = NULL;
781 data = pos;
785 /* Note we can never not have found data, so we don't check for this */
786 watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
788 kref_get(&data->kref);
795 watchdog_trigger(data);
796 filp->private_data = data;
803 struct fschmd_data *data = filp->private_data;
805 if (data->watchdog_expect_close) {
806 watchdog_stop(data);
807 data->watchdog_expect_close = 0;
809 watchdog_trigger(data);
810 dev_crit(&data->client->dev,
814 clear_bit(0, &data->watchdog_is_open);
817 kref_put(&data->kref, fschmd_release_resources);
827 struct fschmd_data *data = filp->private_data;
834 data->watchdog_expect_close = 0;
841 data->watchdog_expect_close = 1;
844 ret = watchdog_trigger(data);
859 struct fschmd_data *data = filp->private_data;
864 ident.firmware_version = data->revision;
876 if (data->watchdog_state & FSCHMD_WDOG_STATE_CARDRESET)
883 ret = watchdog_trigger(data);
887 i = watchdog_get_timeout(data);
896 ret = watchdog_set_timeout(data, i);
908 ret = watchdog_stop(data);
910 ret = watchdog_trigger(data);
1048 struct fschmd_data *data;
1055 data = kzalloc(sizeof(struct fschmd_data), GFP_KERNEL);
1056 if (!data)
1059 i2c_set_clientdata(client, data);
1060 mutex_init(&data->update_lock);
1061 mutex_init(&data->watchdog_lock);
1062 INIT_LIST_HEAD(&data->list);
1063 kref_init(&data->kref);
1064 /* Store client pointer in our data struct for watchdog usage
1065 (where the client is found through a data ptr instead of the
1067 data->client = client;
1068 data->kind = kind;
1073 data->temp_max[0] = 70 + 128;
1074 data->temp_max[1] = 50 + 128;
1075 data->temp_max[2] = 50 + 128;
1090 data->revision = i2c_smbus_read_byte_data(client, FSCHMD_REG_REVISION);
1091 data->global_control = i2c_smbus_read_byte_data(client,
1093 data->watchdog_control = i2c_smbus_read_byte_data(client,
1094 FSCHMD_REG_WDOG_CONTROL[data->kind]);
1095 data->watchdog_state = i2c_smbus_read_byte_data(client,
1096 FSCHMD_REG_WDOG_STATE[data->kind]);
1097 data->watchdog_preset = i2c_smbus_read_byte_data(client,
1098 FSCHMD_REG_WDOG_PRESET[data->kind]);
1104 for (i = 0; i < FSCHMD_NO_VOLT_SENSORS[data->kind]; i++) {
1111 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++) {
1119 data->temp_status[i / 4] =
1122 [data->kind][i / 4]);
1123 if (data->temp_status[i / 4] & FSCHMD_TEMP_DISABLED)
1133 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++) {
1142 data->fan_status[i / 5] =
1145 [data->kind][i / 5]);
1146 if (data->fan_status[i / 5] & FSCHMD_FAN_DISABLED)
1156 data->hwmon_dev = hwmon_device_register(&client->dev);
1157 if (IS_ERR(data->hwmon_dev)) {
1158 err = PTR_ERR(data->hwmon_dev);
1159 data->hwmon_dev = NULL;
1165 our data to the watchdog_data_list (and set the default timeout) */
1169 snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1171 data->watchdog_miscdev.name = data->watchdog_name;
1172 data->watchdog_miscdev.fops = &watchdog_fops;
1173 data->watchdog_miscdev.minor = watchdog_minors[i];
1174 err = misc_register(&data->watchdog_miscdev);
1178 data->watchdog_miscdev.minor = 0;
1184 list_add(&data->list, &watchdog_data_list);
1185 watchdog_set_timeout(data, 60);
1192 data->watchdog_miscdev.minor = 0;
1199 names[data->kind], (int) data->revision);
1204 fschmd_remove(client); /* will also free data for us */
1210 struct fschmd_data *data = i2c_get_clientdata(client);
1214 if (data->watchdog_miscdev.minor) {
1215 misc_deregister(&data->watchdog_miscdev);
1216 if (data->watchdog_is_open) {
1220 watchdog_stop(data);
1223 list_del(&data->list);
1226 mutex_lock(&data->watchdog_lock);
1227 data->client = NULL;
1228 mutex_unlock(&data->watchdog_lock);
1233 if (data->hwmon_dev)
1234 hwmon_device_unregister(data->hwmon_dev);
1237 for (i = 0; i < (FSCHMD_NO_VOLT_SENSORS[data->kind]); i++)
1239 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++)
1242 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++)
1247 kref_put(&data->kref, fschmd_release_resources);
1256 struct fschmd_data *data = i2c_get_clientdata(client);
1259 mutex_lock(&data->update_lock);
1261 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
1263 for (i = 0; i < FSCHMD_NO_TEMP_SENSORS[data->kind]; i++) {
1264 data->temp_act[i] = i2c_smbus_read_byte_data(client,
1265 FSCHMD_REG_TEMP_ACT[data->kind][i]);
1266 data->temp_status[i] = i2c_smbus_read_byte_data(client,
1267 FSCHMD_REG_TEMP_STATE[data->kind][i]);
1270 if (FSCHMD_REG_TEMP_LIMIT[data->kind][i])
1271 data->temp_max[i] = i2c_smbus_read_byte_data(
1273 FSCHMD_REG_TEMP_LIMIT[data->kind][i]);
1277 if ((data->temp_status[i] & FSCHMD_TEMP_ALARM_MASK) ==
1279 data->temp_act[i] < data->temp_max[i])
1281 FSCHMD_REG_TEMP_STATE[data->kind][i],
1282 data->temp_status[i]);
1285 for (i = 0; i < FSCHMD_NO_FAN_SENSORS[data->kind]; i++) {
1286 data->fan_act[i] = i2c_smbus_read_byte_data(client,
1287 FSCHMD_REG_FAN_ACT[data->kind][i]);
1288 data->fan_status[i] = i2c_smbus_read_byte_data(client,
1289 FSCHMD_REG_FAN_STATE[data->kind][i]);
1290 data->fan_ripple[i] = i2c_smbus_read_byte_data(client,
1291 FSCHMD_REG_FAN_RIPPLE[data->kind][i]);
1294 if (FSCHMD_REG_FAN_MIN[data->kind][i])
1295 data->fan_min[i] = i2c_smbus_read_byte_data(
1297 FSCHMD_REG_FAN_MIN[data->kind][i]);
1300 if ((data->fan_status[i] & FSCHMD_FAN_ALARM) &&
1301 data->fan_act[i])
1303 FSCHMD_REG_FAN_STATE[data->kind][i],
1304 data->fan_status[i]);
1307 for (i = 0; i < FSCHMD_NO_VOLT_SENSORS[data->kind]; i++)
1308 data->volt[i] = i2c_smbus_read_byte_data(client,
1309 FSCHMD_REG_VOLT[data->kind][i]);
1311 data->last_updated = jiffies;
1312 data->valid = 1;
1315 mutex_unlock(&data->update_lock);
1317 return data;