Lines Matching refs:data
224 * Driver data (common to all clients)
252 * Client data (each client gets its own)
298 * Somewhat ugly :( global data pointer list with all fschmd devices, so that
299 * we can find our device data as when using misc_register there is no other
300 * method to get to ones device data from the open fop.
303 /* Note this lock not only protect list access, but also data.kref access */
307 * Release our data struct when we're detached from the i2c client *and* all
312 struct fschmd_data *data = container_of(ref, struct fschmd_data, kref);
313 kfree(data);
325 struct fschmd_data *data = fschmd_update_device(dev);
327 if (data->kind == fscher || data->kind >= fschrc)
328 return sprintf(buf, "%d\n", (data->volt[index] * dmi_vref *
331 return sprintf(buf, "%d\n", (data->volt[index] *
342 struct fschmd_data *data = fschmd_update_device(dev);
344 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_act[index]));
351 struct fschmd_data *data = fschmd_update_device(dev);
353 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[index]));
361 struct fschmd_data *data = dev_get_drvdata(dev);
371 mutex_lock(&data->update_lock);
373 FSCHMD_REG_TEMP_LIMIT[data->kind][index], v);
374 data->temp_max[index] = v;
375 mutex_unlock(&data->update_lock);
384 struct fschmd_data *data = fschmd_update_device(dev);
387 if (data->temp_status[index] & FSCHMD_TEMP_WORKING)
397 struct fschmd_data *data = fschmd_update_device(dev);
399 if ((data->temp_status[index] & FSCHMD_TEMP_ALARM_MASK) ==
413 struct fschmd_data *data = fschmd_update_device(dev);
415 return sprintf(buf, "%u\n", RPM_FROM_REG(data->fan_act[index]));
422 struct fschmd_data *data = fschmd_update_device(dev);
425 return sprintf(buf, "%d\n", 1 << (data->fan_ripple[index] & 3));
434 struct fschmd_data *data = dev_get_drvdata(dev);
460 mutex_lock(&data->update_lock);
463 FSCHMD_REG_FAN_RIPPLE[data->kind][index]);
470 FSCHMD_REG_FAN_RIPPLE[data->kind][index], reg);
472 data->fan_ripple[index] = reg;
474 mutex_unlock(&data->update_lock);
483 struct fschmd_data *data = fschmd_update_device(dev);
485 if (data->fan_status[index] & FSCHMD_FAN_ALARM)
495 struct fschmd_data *data = fschmd_update_device(dev);
497 if (data->fan_status[index] & FSCHMD_FAN_NOT_PRESENT)
509 struct fschmd_data *data = fschmd_update_device(dev);
510 int val = data->fan_min[index];
513 if (val || data->kind == fscsyl)
524 struct fschmd_data *data = dev_get_drvdata(dev);
533 if (v || data->kind == fscsyl) {
538 mutex_lock(&data->update_lock);
541 FSCHMD_REG_FAN_MIN[data->kind][index], v);
542 data->fan_min[index] = v;
544 mutex_unlock(&data->update_lock);
557 struct fschmd_data *data = fschmd_update_device(dev);
559 if (data->global_control & FSCHMD_CONTROL_ALERT_LED)
569 struct fschmd_data *data = dev_get_drvdata(dev);
577 mutex_lock(&data->update_lock);
588 data->global_control = reg;
590 mutex_unlock(&data->update_lock);
696 static int watchdog_set_timeout(struct fschmd_data *data, int timeout)
699 int kind = data->kind + 1; /* 0-x array index -> 1-x module param */
710 mutex_lock(&data->watchdog_lock);
711 if (!data->client) {
717 data->watchdog_control &= ~FSCHMD_WDOG_CONTROL_RESOLUTION;
719 data->watchdog_control |= FSCHMD_WDOG_CONTROL_RESOLUTION;
721 data->watchdog_preset = DIV_ROUND_UP(timeout, resolution);
724 i2c_smbus_write_byte_data(data->client,
725 FSCHMD_REG_WDOG_PRESET[data->kind], data->watchdog_preset);
727 i2c_smbus_write_byte_data(data->client,
728 FSCHMD_REG_WDOG_CONTROL[data->kind],
729 data->watchdog_control & ~FSCHMD_WDOG_CONTROL_TRIGGER);
731 ret = data->watchdog_preset * resolution;
734 mutex_unlock(&data->watchdog_lock);
738 static int watchdog_get_timeout(struct fschmd_data *data)
742 mutex_lock(&data->watchdog_lock);
743 if (data->watchdog_control & FSCHMD_WDOG_CONTROL_RESOLUTION)
744 timeout = data->watchdog_preset * 60;
746 timeout = data->watchdog_preset * 2;
747 mutex_unlock(&data->watchdog_lock);
752 static int watchdog_trigger(struct fschmd_data *data)
756 mutex_lock(&data->watchdog_lock);
757 if (!data->client) {
762 data->watchdog_control |= FSCHMD_WDOG_CONTROL_TRIGGER;
763 i2c_smbus_write_byte_data(data->client,
764 FSCHMD_REG_WDOG_CONTROL[data->kind],
765 data->watchdog_control);
767 mutex_unlock(&data->watchdog_lock);
771 static int watchdog_stop(struct fschmd_data *data)
775 mutex_lock(&data->watchdog_lock);
776 if (!data->client) {
781 data->watchdog_control &= ~FSCHMD_WDOG_CONTROL_STARTED;
786 i2c_smbus_write_byte_data(data->client,
787 FSCHMD_REG_WDOG_CONTROL[data->kind],
788 data->watchdog_control | FSCHMD_WDOG_CONTROL_STOP);
790 mutex_unlock(&data->watchdog_lock);
796 struct fschmd_data *pos, *data = NULL;
809 data = pos;
813 /* Note we can never not have found data, so we don't check for this */
814 watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
816 kref_get(&data->kref);
823 watchdog_trigger(data);
824 filp->private_data = data;
831 struct fschmd_data *data = filp->private_data;
833 if (data->watchdog_expect_close) {
834 watchdog_stop(data);
835 data->watchdog_expect_close = 0;
837 watchdog_trigger(data);
838 dev_crit(&data->client->dev,
842 clear_bit(0, &data->watchdog_is_open);
845 kref_put(&data->kref, fschmd_release_resources);
855 struct fschmd_data *data = filp->private_data;
862 data->watchdog_expect_close = 0;
869 data->watchdog_expect_close = 1;
872 ret = watchdog_trigger(data);
888 struct fschmd_data *data = filp->private_data;
892 ident.firmware_version = data->revision;
904 if (data->watchdog_state & FSCHMD_WDOG_STATE_CARDRESET)
911 ret = watchdog_trigger(data);
915 i = watchdog_get_timeout(data);
924 ret = watchdog_set_timeout(data, i);
936 ret = watchdog_stop(data);
938 ret = watchdog_trigger(data);
1085 struct fschmd_data *data;
1092 data = kzalloc(sizeof(struct fschmd_data), GFP_KERNEL);
1093 if (!data)
1096 i2c_set_clientdata(client, data);
1097 mutex_init(&data->update_lock);
1098 mutex_init(&data->watchdog_lock);
1099 INIT_LIST_HEAD(&data->list);
1100 kref_init(&data->kref);
1102 * Store client pointer in our data struct for watchdog usage
1103 * (where the client is found through a data ptr instead of the
1106 data->client = client;
1107 data->kind = kind;
1114 data->temp_max[0] = 70 + 128;
1115 data->temp_max[1] = 50 + 128;
1116 data->temp_max[2] = 50 + 128;
1131 data->revision = i2c_smbus_read_byte_data(client, FSCHMD_REG_REVISION);
1132 data->global_control = i2c_smbus_read_byte_data(client,
1134 data->watchdog_control = i2c_smbus_read_byte_data(client,
1135 FSCHMD_REG_WDOG_CONTROL[data->kind]);
1136 data->watchdog_state = i2c_smbus_read_byte_data(client,
1137 FSCHMD_REG_WDOG_STATE[data->kind]);
1138 data->watchdog_preset = i2c_smbus_read_byte_data(client,
1139 FSCHMD_REG_WDOG_PRESET[data->kind]);
1145 for (i = 0; i < FSCHMD_NO_VOLT_SENSORS[data->kind]; i++) {
1152 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++) {
1160 data->temp_status[i / 4] =
1163 [data->kind][i / 4]);
1164 if (data->temp_status[i / 4] & FSCHMD_TEMP_DISABLED)
1174 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++) {
1183 data->fan_status[i / 5] =
1186 [data->kind][i / 5]);
1187 if (data->fan_status[i / 5] & FSCHMD_FAN_DISABLED)
1197 data->hwmon_dev = hwmon_device_register(&client->dev);
1198 if (IS_ERR(data->hwmon_dev)) {
1199 err = PTR_ERR(data->hwmon_dev);
1200 data->hwmon_dev = NULL;
1207 * our data to the watchdog_data_list (and set the default timeout)
1212 snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1214 data->watchdog_miscdev.name = data->watchdog_name;
1215 data->watchdog_miscdev.fops = &watchdog_fops;
1216 data->watchdog_miscdev.minor = watchdog_minors[i];
1217 err = misc_register(&data->watchdog_miscdev);
1221 data->watchdog_miscdev.minor = 0;
1227 list_add(&data->list, &watchdog_data_list);
1228 watchdog_set_timeout(data, 60);
1235 data->watchdog_miscdev.minor = 0;
1242 names[data->kind], (int) data->revision);
1247 fschmd_remove(client); /* will also free data for us */
1253 struct fschmd_data *data = i2c_get_clientdata(client);
1257 if (data->watchdog_miscdev.minor) {
1258 misc_deregister(&data->watchdog_miscdev);
1259 if (data->watchdog_is_open) {
1263 watchdog_stop(data);
1266 list_del(&data->list);
1269 mutex_lock(&data->watchdog_lock);
1270 data->client = NULL;
1271 mutex_unlock(&data->watchdog_lock);
1278 if (data->hwmon_dev)
1279 hwmon_device_unregister(data->hwmon_dev);
1282 for (i = 0; i < (FSCHMD_NO_VOLT_SENSORS[data->kind]); i++)
1284 for (i = 0; i < (FSCHMD_NO_TEMP_SENSORS[data->kind] * 4); i++)
1287 for (i = 0; i < (FSCHMD_NO_FAN_SENSORS[data->kind] * 5); i++)
1292 kref_put(&data->kref, fschmd_release_resources);
1299 struct fschmd_data *data = i2c_get_clientdata(client);
1302 mutex_lock(&data->update_lock);
1304 if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
1306 for (i = 0; i < FSCHMD_NO_TEMP_SENSORS[data->kind]; i++) {
1307 data->temp_act[i] = i2c_smbus_read_byte_data(client,
1308 FSCHMD_REG_TEMP_ACT[data->kind][i]);
1309 data->temp_status[i] = i2c_smbus_read_byte_data(client,
1310 FSCHMD_REG_TEMP_STATE[data->kind][i]);
1313 if (FSCHMD_REG_TEMP_LIMIT[data->kind][i])
1314 data->temp_max[i] = i2c_smbus_read_byte_data(
1316 FSCHMD_REG_TEMP_LIMIT[data->kind][i]);
1322 if ((data->temp_status[i] & FSCHMD_TEMP_ALARM_MASK) ==
1324 data->temp_act[i] < data->temp_max[i])
1326 FSCHMD_REG_TEMP_STATE[data->kind][i],
1327 data->temp_status[i]);
1330 for (i = 0; i < FSCHMD_NO_FAN_SENSORS[data->kind]; i++) {
1331 data->fan_act[i] = i2c_smbus_read_byte_data(client,
1332 FSCHMD_REG_FAN_ACT[data->kind][i]);
1333 data->fan_status[i] = i2c_smbus_read_byte_data(client,
1334 FSCHMD_REG_FAN_STATE[data->kind][i]);
1335 data->fan_ripple[i] = i2c_smbus_read_byte_data(client,
1336 FSCHMD_REG_FAN_RIPPLE[data->kind][i]);
1339 if (FSCHMD_REG_FAN_MIN[data->kind][i])
1340 data->fan_min[i] = i2c_smbus_read_byte_data(
1342 FSCHMD_REG_FAN_MIN[data->kind][i]);
1345 if ((data->fan_status[i] & FSCHMD_FAN_ALARM) &&
1346 data->fan_act[i])
1348 FSCHMD_REG_FAN_STATE[data->kind][i],
1349 data->fan_status[i]);
1352 for (i = 0; i < FSCHMD_NO_VOLT_SENSORS[data->kind]; i++)
1353 data->volt[i] = i2c_smbus_read_byte_data(client,
1354 FSCHMD_REG_VOLT[data->kind][i]);
1356 data->last_updated = jiffies;
1357 data->valid = true;
1360 mutex_unlock(&data->update_lock);
1362 return data;