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 = 0; /* 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);
1650 struct w83793_data *data;
1656 data = kzalloc(sizeof(struct w83793_data), GFP_KERNEL);
1657 if (!data) {
1662 i2c_set_clientdata(client, data);
1663 data->bank = i2c_smbus_read_byte_data(client, W83793_REG_BANKSEL);
1664 mutex_init(&data->update_lock);
1665 mutex_init(&data->watchdog_lock);
1666 INIT_LIST_HEAD(&data->list);
1667 kref_init(&data->kref);
1670 * Store client pointer in our data struct for watchdog usage
1671 * (where the client is found through a data ptr instead of the
1674 data->client = client;
1687 data->has_fan = 0x1f;
1688 data->has_pwm = 0x07;
1694 data->has_vid |= 0x2; /* has VIDB */
1696 data->has_pwm |= 0x18; /* pwm 4,5 */
1698 data->has_fan |= 0x20;
1699 data->has_pwm |= 0x20;
1702 data->has_fan |= 0x40;
1703 data->has_pwm |= 0x40;
1706 data->has_fan |= 0x80;
1707 data->has_pwm |= 0x80;
1713 data->has_vid |= 0x1; /* has VIDA */
1716 data->has_fan |= 0x100;
1718 data->has_fan |= 0x200;
1722 data->has_fan |= 0x400;
1724 data->has_fan |= 0x800;
1728 data->has_fan |= 0x80;
1729 data->has_pwm |= 0x80;
1734 data->has_fan |= 0x100;
1737 data->has_fan |= 0x200;
1740 data->has_fan |= 0x400;
1743 data->has_fan |= 0x800;
1749 data->has_temp |= 0x01;
1751 data->has_temp |= 0x02;
1753 data->has_temp |= 0x04;
1755 data->has_temp |= 0x08;
1759 data->has_temp |= 0x10;
1761 data->has_temp |= 0x20;
1772 if (!(data->has_vid & (1 << i)))
1778 if (data->has_vid) {
1779 data->vrm = vid_which_vrm();
1794 if (!(data->has_temp & (1 << i)))
1807 if (!(data->has_fan & (1 << i)))
1820 if (!(data->has_pwm & (1 << i)))
1831 data->hwmon_dev = hwmon_device_register(dev);
1832 if (IS_ERR(data->hwmon_dev)) {
1833 err = PTR_ERR(data->hwmon_dev);
1856 data->watchdog_timeout = timeout;
1859 data->watchdog_caused_reboot =
1860 w83793_read_value(data->client, W83793_REG_WDT_STATUS) & 0x01;
1863 watchdog_disable(data);
1868 * our data to the watchdog_data_list (and set the default timeout)
1873 snprintf(data->watchdog_name, sizeof(data->watchdog_name),
1875 data->watchdog_miscdev.name = data->watchdog_name;
1876 data->watchdog_miscdev.fops = &watchdog_fops;
1877 data->watchdog_miscdev.minor = watchdog_minors[i];
1879 err = misc_register(&data->watchdog_miscdev);
1883 data->watchdog_miscdev.minor = 0;
1889 list_add(&data->list, &watchdog_data_list);
1897 data->watchdog_miscdev.minor = 0;
1910 hwmon_device_unregister(data->hwmon_dev);
1933 kfree(data);
1941 struct w83793_data *data = i2c_get_clientdata(client);
1948 if (!(time_after(jiffies, data->last_nonvolatile + HZ * 300)
1949 || !data->valid))
1953 for (j = 0; j < ARRAY_SIZE(data->in); j++) {
1954 data->in[j][i] =
1957 data->in_low_bits[i] =
1961 for (i = 0; i < ARRAY_SIZE(data->fan_min); i++) {
1963 if (!(data->has_fan & (1 << i)))
1965 data->fan_min[i] =
1967 data->fan_min[i] |=
1971 for (i = 0; i < ARRAY_SIZE(data->temp_fan_map); i++) {
1972 if (!(data->has_temp & (1 << i)))
1974 data->temp_fan_map[i] =
1977 data->temp[i][j] =
1980 data->temp_cruise[i] =
1983 data->sf2_pwm[i][j] =
1985 data->sf2_temp[i][j] =
1991 for (i = 0; i < ARRAY_SIZE(data->temp_mode); i++)
1992 data->temp_mode[i] =
1995 for (i = 0; i < ARRAY_SIZE(data->tolerance); i++) {
1996 data->tolerance[i] =
2000 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
2001 if (!(data->has_pwm & (1 << i)))
2003 data->pwm[i][PWM_NONSTOP] =
2005 data->pwm[i][PWM_START] =
2007 data->pwm_stop_time[i] =
2011 data->pwm_default = w83793_read_value(client, W83793_REG_PWM_DEFAULT);
2012 data->pwm_enable = w83793_read_value(client, W83793_REG_PWM_ENABLE);
2013 data->pwm_uptime = w83793_read_value(client, W83793_REG_PWM_UPTIME);
2014 data->pwm_downtime = w83793_read_value(client, W83793_REG_PWM_DOWNTIME);
2015 data->temp_critical =
2017 data->beep_enable = w83793_read_value(client, W83793_REG_OVT_BEEP);
2019 for (i = 0; i < ARRAY_SIZE(data->beeps); i++)
2020 data->beeps[i] = w83793_read_value(client, W83793_REG_BEEP(i));
2022 data->last_nonvolatile = jiffies;
2028 struct w83793_data *data = i2c_get_clientdata(client);
2031 mutex_lock(&data->update_lock);
2033 if (!(time_after(jiffies, data->last_updated + HZ * 2)
2034 || !data->valid))
2038 for (i = 0; i < ARRAY_SIZE(data->in); i++)
2039 data->in[i][IN_READ] =
2042 data->in_low_bits[IN_READ] =
2045 for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
2046 if (!(data->has_fan & (1 << i)))
2048 data->fan[i] =
2050 data->fan[i] |=
2054 for (i = 0; i < ARRAY_SIZE(data->temp); i++) {
2055 if (!(data->has_temp & (1 << i)))
2057 data->temp[i][TEMP_READ] =
2061 data->temp_low_bits =
2064 for (i = 0; i < ARRAY_SIZE(data->pwm); i++) {
2065 if (data->has_pwm & (1 << i))
2066 data->pwm[i][PWM_DUTY] =
2071 for (i = 0; i < ARRAY_SIZE(data->alarms); i++)
2072 data->alarms[i] =
2074 if (data->has_vid & 0x01)
2075 data->vid[0] = w83793_read_value(client, W83793_REG_VID_INA);
2076 if (data->has_vid & 0x02)
2077 data->vid[1] = w83793_read_value(client, W83793_REG_VID_INB);
2079 data->last_updated = jiffies;
2080 data->valid = 1;
2083 mutex_unlock(&data->update_lock);
2084 return data;
2089 * Must be called with data->update_lock held, except during initialization
2093 struct w83793_data *data = i2c_get_clientdata(client);
2097 new_bank |= data->bank & 0xfc;
2098 if (data->bank != new_bank) {
2101 data->bank = new_bank;
2106 new_bank, data->bank, reg);
2116 /* Must be called with data->update_lock held, except during initialization */
2119 struct w83793_data *data = i2c_get_clientdata(client);
2123 new_bank |= data->bank & 0xfc;
2124 if (data->bank != new_bank) {
2131 new_bank, data->bank, reg);
2134 data->bank = new_bank;