Lines Matching refs:data
263 * Somewhat ugly :( global data pointer list with all devices, so that
264 * we can find our device data as when using misc_register. There is no
265 * other method to get to one's device data from the open file-op and
270 /* Note this lock not only protect list access, but also data.kref access */
274 * Release our data struct when we're detached from the i2c client *and* all
279 struct w83793_data *data = container_of(ref, struct w83793_data, kref);
280 kfree(data);
314 struct w83793_data *data = dev_get_drvdata(dev);
315 return sprintf(buf, "%d\n", data->vrm);
321 struct w83793_data *data = w83793_update_device(dev);
326 return sprintf(buf, "%d\n", vid_from_reg(data->vid[index], data->vrm));
333 struct w83793_data *data = dev_get_drvdata(dev);
344 data->vrm = val;
353 struct w83793_data *data = w83793_update_device(dev);
362 val = (data->alarms[index] >> (bit)) & 1;
364 val = (data->beeps[index] >> (bit)) & 1;
375 struct w83793_data *data = i2c_get_clientdata(client);
391 mutex_lock(&data->update_lock);
392 data->beeps[index] = w83793_read_value(client, W83793_REG_BEEP(index));
393 data->beeps[index] &= ~beep_bit;
394 data->beeps[index] |= val << shift;
395 w83793_write_value(client, W83793_REG_BEEP(index), data->beeps[index]);
396 mutex_unlock(&data->update_lock);
404 struct w83793_data *data = w83793_update_device(dev);
405 return sprintf(buf, "%u\n", (data->beep_enable >> 1) & 0x01);
413 struct w83793_data *data = i2c_get_clientdata(client);
424 mutex_lock(&data->update_lock);
425 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP)
427 data->beep_enable |= val << 1;
428 w83793_write_value(client, W83793_REG_OVT_BEEP, data->beep_enable);
429 mutex_unlock(&data->update_lock);
441 struct w83793_data *data = i2c_get_clientdata(client);
452 mutex_lock(&data->update_lock);
455 data->valid = false; /* Force cache refresh */
456 mutex_unlock(&data->update_lock);
469 struct w83793_data *data = w83793_update_device(dev);
473 val = data->fan[index] & 0x0fff;
475 val = data->fan_min[index] & 0x0fff;
488 struct w83793_data *data = i2c_get_clientdata(client);
497 mutex_lock(&data->update_lock);
498 data->fan_min[index] = val;
502 mutex_unlock(&data->update_lock);
512 struct w83793_data *data = w83793_update_device(dev);
518 val = TIME_FROM_REG(data->pwm_stop_time[index]);
520 val = (data->pwm[index][nr] & 0x3f) << 2;
530 struct w83793_data *data = i2c_get_clientdata(client);
542 mutex_lock(&data->update_lock);
545 data->pwm_stop_time[index] = val;
550 data->pwm[index][nr] =
552 data->pwm[index][nr] |= val;
554 data->pwm[index][nr]);
557 mutex_unlock(&data->update_lock);
568 struct w83793_data *data = w83793_update_device(dev);
569 long temp = TEMP_FROM_REG(data->temp[index][nr]);
572 int low = ((data->temp_low_bits >> (index * 2)) & 0x03) * 250;
587 struct w83793_data *data = i2c_get_clientdata(client);
595 mutex_lock(&data->update_lock);
596 data->temp[index][nr] = TEMP_TO_REG(tmp, -128, 127);
598 data->temp[index][nr]);
599 mutex_unlock(&data->update_lock);
623 struct w83793_data *data = w83793_update_device(dev);
632 tmp = (data->temp_mode[index] >> shift) & mask;
648 struct w83793_data *data = i2c_get_clientdata(client);
673 mutex_lock(&data->update_lock);
674 data->temp_mode[index] =
676 data->temp_mode[index] &= ~(mask << shift);
677 data->temp_mode[index] |= val << shift;
679 data->temp_mode[index]);
680 mutex_unlock(&data->update_lock);
695 struct w83793_data *data = w83793_update_device(dev);
699 val = (data->pwm_default & 0x3f) << 2;
701 val = TIME_FROM_REG(data->pwm_uptime);
703 val = TIME_FROM_REG(data->pwm_downtime);
705 val = TEMP_FROM_REG(data->temp_critical & 0x7f);
718 struct w83793_data *data = i2c_get_clientdata(client);
726 mutex_lock(&data->update_lock);
728 data->pwm_default =
730 data->pwm_default |= clamp_val(val, 0, 0xff) >> 2;
732 data->pwm_default);
734 data->pwm_uptime = TIME_TO_REG(val);
735 data->pwm_uptime += data->pwm_uptime == 0 ? 1 : 0;
737 data->pwm_uptime);
739 data->pwm_downtime = TIME_TO_REG(val);
740 data->pwm_downtime += data->pwm_downtime == 0 ? 1 : 0;
742 data->pwm_downtime);
744 data->temp_critical =
746 data->temp_critical |= TEMP_TO_REG(val, 0, 0x7f);
748 data->temp_critical);
751 mutex_unlock(&data->update_lock);
793 struct w83793_data *data = w83793_update_device(dev);
797 val = data->temp_fan_map[index];
800 val = ((data->pwm_enable >> index) & 0x01) + 2;
802 val = TEMP_FROM_REG(data->temp_cruise[index] & 0x7f);
804 val = data->tolerance[index >> 1] >> ((index & 0x01) ? 4 : 0);
819 struct w83793_data *data = i2c_get_clientdata(client);
827 mutex_lock(&data->update_lock);
831 data->temp_fan_map[index] = val;
834 data->pwm_enable =
837 data->pwm_enable |= 1 << index;
839 data->pwm_enable &= ~(1 << index);
841 data->pwm_enable);
843 mutex_unlock(&data->update_lock);
847 data->temp_cruise[index] =
849 data->temp_cruise[index] &= 0x80;
850 data->temp_cruise[index] |= TEMP_TO_REG(val, 0, 0x7f);
853 data->temp_cruise[index]);
857 data->tolerance[i] =
860 data->tolerance[i] &= ~(0x0f << shift);
861 data->tolerance[i] |= TEMP_TO_REG(val, 0, 0x0f) << shift;
863 data->tolerance[i]);
866 mutex_unlock(&data->update_lock);
877 struct w83793_data *data = w83793_update_device(dev);
879 return sprintf(buf, "%d\n", (data->sf2_pwm[index][nr] & 0x3f) << 2);
887 struct w83793_data *data = i2c_get_clientdata(client);
900 mutex_lock(&data->update_lock);
901 data->sf2_pwm[index][nr] =
903 data->sf2_pwm[index][nr] |= val;
905 data->sf2_pwm[index][nr]);
906 mutex_unlock(&data->update_lock);
917 struct w83793_data *data = w83793_update_device(dev);
920 TEMP_FROM_REG(data->sf2_temp[index][nr] & 0x7f));
928 struct w83793_data *data = i2c_get_clientdata(client);
941 mutex_lock(&data->update_lock);
942 data->sf2_temp[index][nr] =
944 data->sf2_temp[index][nr] |= val;
946 data->sf2_temp[index][nr]);
947 mutex_unlock(&data->update_lock);
959 struct w83793_data *data = w83793_update_device(dev);
960 u16 val = data->in[index][nr];
964 val += (data->in_low_bits[nr] >> (index * 2)) & 0x3;
980 struct w83793_data *data = i2c_get_clientdata(client);
989 mutex_lock(&data->update_lock);
997 data->in_low_bits[nr] =
999 data->in_low_bits[nr] &= ~(0x03 << (2 * index));
1000 data->in_low_bits[nr] |= (val & 0x03) << (2 * index);
1002 data->in_low_bits[nr]);
1005 data->in[index][nr] = val;
1007 data->in[index][nr]);
1008 mutex_unlock(&data->update_lock);
1188 static int watchdog_set_timeout(struct w83793_data *data, int timeout)
1198 mutex_lock(&data->watchdog_lock);
1199 if (!data->client) {
1204 data->watchdog_timeout = mtimeout;
1207 w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1208 data->watchdog_timeout);
1213 mutex_unlock(&data->watchdog_lock);
1217 static int watchdog_get_timeout(struct w83793_data *data)
1221 mutex_lock(&data->watchdog_lock);
1222 timeout = data->watchdog_timeout * 60;
1223 mutex_unlock(&data->watchdog_lock);
1228 static int watchdog_trigger(struct w83793_data *data)
1232 mutex_lock(&data->watchdog_lock);
1233 if (!data->client) {
1239 w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1240 data->watchdog_timeout);
1243 mutex_unlock(&data->watchdog_lock);
1247 static int watchdog_enable(struct w83793_data *data)
1251 mutex_lock(&data->watchdog_lock);
1252 if (!data->client) {
1258 w83793_write_value(data->client, W83793_REG_WDT_TIMEOUT,
1259 data->watchdog_timeout);
1262 w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0x55);
1265 mutex_unlock(&data->watchdog_lock);
1269 static int watchdog_disable(struct w83793_data *data)
1273 mutex_lock(&data->watchdog_lock);
1274 if (!data->client) {
1280 w83793_write_value(data->client, W83793_REG_WDT_LOCK, 0xAA);
1283 mutex_unlock(&data->watchdog_lock);
1289 struct w83793_data *pos, *data = NULL;
1302 data = pos;
1308 watchdog_is_open = test_and_set_bit(0, &data->watchdog_is_open);
1311 * Increase data reference counter (if not already done).
1312 * Note we can never not have found data, so we don't check for this
1315 kref_get(&data->kref);
1324 watchdog_enable(data);
1326 /* Store pointer to data into filp's private data */
1327 filp->private_data = data;
1334 struct w83793_data *data = filp->private_data;
1336 if (data->watchdog_expect_close) {
1337 watchdog_disable(data);
1338 data->watchdog_expect_close = 0;
1340 watchdog_trigger(data);
1341 dev_crit(&data->client->dev,
1345 clear_bit(0, &data->watchdog_is_open);
1347 /* Decrease data reference counter */
1349 kref_put(&data->kref, w83793_release_resources);
1359 struct w83793_data *data = filp->private_data;
1366 data->watchdog_expect_close = 0;
1373 data->watchdog_expect_close = 1;
1376 ret = watchdog_trigger(data);
1394 struct w83793_data *data = filp->private_data;
1405 val = data->watchdog_caused_reboot ? WDIOF_CARDRESET : 0;
1414 ret = watchdog_trigger(data);
1418 val = watchdog_get_timeout(data);
1427 ret = watchdog_set_timeout(data, val);
1439 ret = watchdog_disable(data);
1441 ret = watchdog_enable(data);
1469 struct w83793_data *data = NULL;
1475 list_for_each_entry(data, &watchdog_data_list, list) {
1476 if (data->watchdog_miscdev.minor)
1477 watchdog_disable(data);
1500 struct w83793_data *data = i2c_get_clientdata(client);
1505 if (data->watchdog_miscdev.minor) {
1506 misc_deregister(&data->watchdog_miscdev);
1508 if (data->watchdog_is_open) {
1512 watchdog_disable(data);
1516 list_del(&data->list);
1520 mutex_lock(&data->watchdog_lock);
1521 data->client = NULL;
1522 mutex_unlock(&data->watchdog_lock);
1531 hwmon_device_unregister(data->hwmon_dev);
1553 /* Decrease data reference counter */
1555 kref_put(&data->kref, w83793_release_resources);
1648 struct w83793_data *data;
1654 data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL);
1655 if (!data) {
1660 i2c_set_clientdata(client, data);
1661 data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1662 mutex_init(&data->update_lock);
1663 mutex_init(&data->watchdog_lock);
1664 INIT_LIST_HEAD(&data->list);
1665 kref_init(&data->kref);
1668 * Store client pointer in our data struct for watchdog usage
1669 * (where the client is found through a data ptr instead of the
1672 data->client = client;
1685 data->has_fan = 0x1f;
1686 data->has_pwm = 0x07;
1692 data->has_vid |= 0x2; /* has VIDB */
1694 data->has_pwm |= 0x18; /* pwm 4,5 */
1696 data->has_fan |= 0x20;
1697 data->has_pwm |= 0x20;
1700 data->has_fan |= 0x40;
1701 data->has_pwm |= 0x40;
1704 data->has_fan |= 0x80;
1705 data->has_pwm |= 0x80;
1711 data->has_vid |= 0x1; /* has VIDA */
1714 data->has_fan |= 0x100;
1716 data->has_fan |= 0x200;
1720 data->has_fan |= 0x400;
1722 data->has_fan |= 0x800;
1726 data->has_fan |= 0x80;
1727 data->has_pwm |= 0x80;
1732 data->has_fan |= 0x100;
1735 data->has_fan |= 0x200;
1738 data->has_fan |= 0x400;
1741 data->has_fan |= 0x800;
1747 data->has_temp |= 0x01;
1749 data->has_temp |= 0x02;
1751 data->has_temp |= 0x04;
1753 data->has_temp |= 0x08;
1757 data->has_temp |= 0x10;
1759 data->has_temp |= 0x20;
1770 if (!(data->has_vid & (1 << i)))
1776 if (data->has_vid) {
1777 data->vrm = vid_which_vrm();
1792 if (!(data->has_temp & (1 << i)))
1805 if (!(data->has_fan & (1 << i)))
1818 if (!(data->has_pwm & (1 << i)))
1829 data->hwmon_dev = hwmon_device_register(dev);
1830 if (IS_ERR(data->hwmon_dev)) {
1831 err = PTR_ERR(data->hwmon_dev);
1854 data->watchdog_timeout = timeout;
1857 data->watchdog_caused_reboot =
1858 w83793_read_value(data->client, W83793_REG_WDT_STATUS) & 0x01;
1861 watchdog_disable(data);
1866 * our data to the watchdog_data_list (and set the default timeout)
1871 snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1873 data->watchdog_miscdev.name = data->watchdog_name;
1874 data->watchdog_miscdev.fops = &watchdog_fops;
1875 data->watchdog_miscdev.minor = watchdog_minors[i];
1877 err = misc_register(&data->watchdog_miscdev);
1881 data->watchdog_miscdev.minor = 0;
1887 list_add(&data->list, &watchdog_data_list);
1895 data->watchdog_miscdev.minor = 0;
1908 hwmon_device_unregister(data->hwmon_dev);
1931 kfree(data);
1939 struct w83793_data *data = i2c_get_clientdata(client);
1946 if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1947 || !data->valid))
1951 for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1952 data->in[j][i] =
1955 data->in_low_bits[i] =
1959 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1961 if (!(data->has_fan & (1 << i)))
1963 data->fan_min[i] =
1965 data->fan_min[i] |=
1969 for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1970 if (!(data->has_temp & (1 << i)))
1972 data->temp_fan_map[i] =
1975 data->temp[i][j] =
1978 data->temp_cruise[i] =
1981 data->sf2_pwm[i][j] =
1983 data->sf2_temp[i][j] =
1989 for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1990 data->temp_mode[i] =
1993 for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1994 data->tolerance[i] =
1998 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
1999 if (!(data->has_pwm & (1 << i)))
2001 data->pwm[i][PWM_NONSTOP] =
2003 data->pwm[i][PWM_START] =
2005 data->pwm_stop_time[i] =
2009 data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
2010 data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
2011 data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
2012 data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
2013 data->temp_critical =
2015 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
2017 for (i = 0; i < ARRAY_SIZE(data->beeps); i++)
2018 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
2020 data->last_nonvolatile = jiffies;
2026 struct w83793_data *data = i2c_get_clientdata(client);
2029 mutex_lock(&data->update_lock);
2031 if (!(time_after(jiffies, data->last_updated + HZ * 2)
2032 || !data->valid))
2036 for (i = 0; i < ARRAY_SIZE(data->in); i++)
2037 data->in[i][IN_READ] =
2040 data->in_low_bits[IN_READ] =
2043 for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
2044 if (!(data->has_fan & (1 << i)))
2046 data->fan[i] =
2048 data->fan[i] |=
2052 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
2053 if (!(data->has_temp & (1 << i)))
2055 data->temp[i][TEMP_READ] =
2059 data->temp_low_bits =
2062 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
2063 if (data->has_pwm & (1 << i))
2064 data->pwm[i][PWM_DUTY] =
2069 for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
2070 data->alarms[i] =
2072 if (data->has_vid & 0x01)
2073 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
2074 if (data->has_vid & 0x02)
2075 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
2077 data->last_updated = jiffies;
2078 data->valid = true;
2081 mutex_unlock(&data->update_lock);
2082 return data;
2087 * Must be called with data->update_lock held, except during initialization
2091 struct w83793_data *data = i2c_get_clientdata(client);
2095 new_bank |= data->bank & 0xfc;
2096 if (data->bank != new_bank) {
2099 data->bank = new_bank;
2104 new_bank, data->bank, reg);
2114 /* Must be called with data->update_lock held, except during initialization */
2117 struct w83793_data *data = i2c_get_clientdata(client);
2121 new_bank |= data->bank & 0xfc;
2122 if (data->bank != new_bank) {
2129 new_bank, data->bank, reg);
2132 data->bank = new_bank;