Lines Matching refs:data
233 * We cache the results and return the saved data if the driver
236 * Also, there is significant configuration data for this chip
237 * So, we keep the config data up to date in the cache
247 * at client->data. The adm1026_data structure is dynamically
321 struct adm1026_data *data = dev_get_drvdata(dev);
322 struct i2c_client *client = data->client;
326 mutex_lock(&data->update_lock);
327 if (!data->valid
329 data->last_reading + ADM1026_DATA_INTERVAL)) {
333 data->in[i] =
338 data->fan[i] =
347 data->temp[i] =
351 data->pwm1.pwm = adm1026_read_value(client,
353 data->analog_out = adm1026_read_value(client,
365 data->alarms = alarms;
373 data->gpio = gpio;
375 data->last_reading = jiffies;
378 if (!data->valid ||
379 time_after(jiffies, data->last_config + ADM1026_CONFIG_INTERVAL)) {
383 data->in_min[i] = adm1026_read_value(client,
385 data->in_max[i] = adm1026_read_value(client,
393 data->fan_min[i] = adm1026_read_value(client,
395 data->fan_div[i] = DIV_FROM_REG(value & 0x03);
404 data->temp_min[i] = adm1026_read_value(client,
406 data->temp_max[i] = adm1026_read_value(client,
408 data->temp_tmin[i] = adm1026_read_value(client,
410 data->temp_crit[i] = adm1026_read_value(client,
412 data->temp_offset[i] = adm1026_read_value(client,
425 data->alarm_mask = alarms;
432 data->gpio_mask = gpio;
435 data->config1 = adm1026_read_value(client,
437 if (data->config1 & CFG1_PWM_AFC) {
438 data->pwm1.enable = 2;
439 data->pwm1.auto_pwm_min =
440 PWM_MIN_FROM_REG(data->pwm1.pwm);
443 data->config2 = adm1026_read_value(client,
445 data->config3 = adm1026_read_value(client,
447 data->gpio_config[16] = (data->config3 >> 6) & 0x03;
455 data->gpio_config[i] = value & 0x03;
459 data->last_config = jiffies;
462 data->valid = true;
463 mutex_unlock(&data->update_lock);
464 return data;
472 struct adm1026_data *data = adm1026_update_device(dev);
473 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in[nr]));
480 struct adm1026_data *data = adm1026_update_device(dev);
481 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_min[nr]));
488 struct adm1026_data *data = dev_get_drvdata(dev);
489 struct i2c_client *client = data->client;
497 mutex_lock(&data->update_lock);
498 data->in_min[nr] = INS_TO_REG(nr, val);
499 adm1026_write_value(client, ADM1026_REG_IN_MIN[nr], data->in_min[nr]);
500 mutex_unlock(&data->update_lock);
508 struct adm1026_data *data = adm1026_update_device(dev);
509 return sprintf(buf, "%d\n", INS_FROM_REG(nr, data->in_max[nr]));
516 struct adm1026_data *data = dev_get_drvdata(dev);
517 struct i2c_client *client = data->client;
525 mutex_lock(&data->update_lock);
526 data->in_max[nr] = INS_TO_REG(nr, val);
527 adm1026_write_value(client, ADM1026_REG_IN_MAX[nr], data->in_max[nr]);
528 mutex_unlock(&data->update_lock);
584 struct adm1026_data *data = adm1026_update_device(dev);
585 return sprintf(buf, "%d\n", INS_FROM_REG(16, data->in[16]) -
591 struct adm1026_data *data = adm1026_update_device(dev);
592 return sprintf(buf, "%d\n", INS_FROM_REG(16, data->in_min[16])
599 struct adm1026_data *data = dev_get_drvdata(dev);
600 struct i2c_client *client = data->client;
608 mutex_lock(&data->update_lock);
609 data->in_min[16] = INS_TO_REG(16,
613 adm1026_write_value(client, ADM1026_REG_IN_MIN[16], data->in_min[16]);
614 mutex_unlock(&data->update_lock);
620 struct adm1026_data *data = adm1026_update_device(dev);
621 return sprintf(buf, "%d\n", INS_FROM_REG(16, data->in_max[16])
628 struct adm1026_data *data = dev_get_drvdata(dev);
629 struct i2c_client *client = data->client;
637 mutex_lock(&data->update_lock);
638 data->in_max[16] = INS_TO_REG(16,
642 adm1026_write_value(client, ADM1026_REG_IN_MAX[16], data->in_max[16]);
643 mutex_unlock(&data->update_lock);
658 struct adm1026_data *data = adm1026_update_device(dev);
659 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
660 data->fan_div[nr]));
667 struct adm1026_data *data = adm1026_update_device(dev);
668 return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
669 data->fan_div[nr]));
677 struct adm1026_data *data = dev_get_drvdata(dev);
678 struct i2c_client *client = data->client;
686 mutex_lock(&data->update_lock);
687 data->fan_min[nr] = FAN_TO_REG(val, data->fan_div[nr]);
689 data->fan_min[nr]);
690 mutex_unlock(&data->update_lock);
714 struct adm1026_data *data = dev_get_drvdata(dev);
715 struct i2c_client *client = data->client;
717 int new_div = data->fan_div[fan];
720 if (data->fan_min[fan] == 0 || data->fan_min[fan] == 0xff)
723 new_min = data->fan_min[fan] * old_div / new_div;
725 data->fan_min[fan] = new_min;
735 struct adm1026_data *data = adm1026_update_device(dev);
736 return sprintf(buf, "%d\n", data->fan_div[nr]);
744 struct adm1026_data *data = dev_get_drvdata(dev);
745 struct i2c_client *client = data->client;
756 mutex_lock(&data->update_lock);
757 orig_div = data->fan_div[nr];
758 data->fan_div[nr] = DIV_FROM_REG(new_div);
762 (DIV_TO_REG(data->fan_div[0]) << 0) |
763 (DIV_TO_REG(data->fan_div[1]) << 2) |
764 (DIV_TO_REG(data->fan_div[2]) << 4) |
765 (DIV_TO_REG(data->fan_div[3]) << 6));
768 (DIV_TO_REG(data->fan_div[4]) << 0) |
769 (DIV_TO_REG(data->fan_div[5]) << 2) |
770 (DIV_TO_REG(data->fan_div[6]) << 4) |
771 (DIV_TO_REG(data->fan_div[7]) << 6));
774 if (data->fan_div[nr] != orig_div)
777 mutex_unlock(&data->update_lock);
796 struct adm1026_data *data = adm1026_update_device(dev);
797 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp[nr]));
804 struct adm1026_data *data = adm1026_update_device(dev);
805 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_min[nr]));
813 struct adm1026_data *data = dev_get_drvdata(dev);
814 struct i2c_client *client = data->client;
822 mutex_lock(&data->update_lock);
823 data->temp_min[nr] = TEMP_TO_REG(val);
825 data->temp_min[nr]);
826 mutex_unlock(&data->update_lock);
834 struct adm1026_data *data = adm1026_update_device(dev);
835 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_max[nr]));
843 struct adm1026_data *data = dev_get_drvdata(dev);
844 struct i2c_client *client = data->client;
852 mutex_lock(&data->update_lock);
853 data->temp_max[nr] = TEMP_TO_REG(val);
855 data->temp_max[nr]);
856 mutex_unlock(&data->update_lock);
875 struct adm1026_data *data = adm1026_update_device(dev);
876 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_offset[nr]));
884 struct adm1026_data *data = dev_get_drvdata(dev);
885 struct i2c_client *client = data->client;
893 mutex_lock(&data->update_lock);
894 data->temp_offset[nr] = TEMP_TO_REG(val);
896 data->temp_offset[nr]);
897 mutex_unlock(&data->update_lock);
911 struct adm1026_data *data = adm1026_update_device(dev);
913 ADM1026_FAN_ACTIVATION_TEMP_HYST + data->temp_tmin[nr]));
921 struct adm1026_data *data = adm1026_update_device(dev);
922 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_tmin[nr] +
931 struct adm1026_data *data = adm1026_update_device(dev);
932 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_tmin[nr]));
940 struct adm1026_data *data = dev_get_drvdata(dev);
941 struct i2c_client *client = data->client;
949 mutex_lock(&data->update_lock);
950 data->temp_tmin[nr] = TEMP_TO_REG(val);
952 data->temp_tmin[nr]);
953 mutex_unlock(&data->update_lock);
973 struct adm1026_data *data = adm1026_update_device(dev);
974 return sprintf(buf, "%d\n", (data->config1 & CFG1_THERM_HOT) >> 4);
979 struct adm1026_data *data = dev_get_drvdata(dev);
980 struct i2c_client *client = data->client;
991 mutex_lock(&data->update_lock);
992 data->config1 = (data->config1 & ~CFG1_THERM_HOT) | (val << 4);
993 adm1026_write_value(client, ADM1026_REG_CONFIG1, data->config1);
994 mutex_unlock(&data->update_lock);
1011 struct adm1026_data *data = adm1026_update_device(dev);
1012 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->temp_crit[nr]));
1020 struct adm1026_data *data = dev_get_drvdata(dev);
1021 struct i2c_client *client = data->client;
1029 mutex_lock(&data->update_lock);
1030 data->temp_crit[nr] = TEMP_TO_REG(val);
1032 data->temp_crit[nr]);
1033 mutex_unlock(&data->update_lock);
1044 struct adm1026_data *data = adm1026_update_device(dev);
1045 return sprintf(buf, "%d\n", DAC_FROM_REG(data->analog_out));
1051 struct adm1026_data *data = dev_get_drvdata(dev);
1052 struct i2c_client *client = data->client;
1060 mutex_lock(&data->update_lock);
1061 data->analog_out = DAC_TO_REG(val);
1062 adm1026_write_value(client, ADM1026_REG_DAC, data->analog_out);
1063 mutex_unlock(&data->update_lock);
1072 struct adm1026_data *data = adm1026_update_device(dev);
1073 int vid = (data->gpio >> 11) & 0x1f;
1076 return sprintf(buf, "%d\n", vid_from_reg(vid, data->vrm));
1084 struct adm1026_data *data = dev_get_drvdata(dev);
1085 return sprintf(buf, "%d\n", data->vrm);
1091 struct adm1026_data *data = dev_get_drvdata(dev);
1102 data->vrm = val;
1111 struct adm1026_data *data = adm1026_update_device(dev);
1112 return sprintf(buf, "%ld\n", data->alarms);
1120 struct adm1026_data *data = adm1026_update_device(dev);
1122 return sprintf(buf, "%ld\n", (data->alarms >> bitnr) & 1);
1157 struct adm1026_data *data = adm1026_update_device(dev);
1158 return sprintf(buf, "%ld\n", data->alarm_mask);
1164 struct adm1026_data *data = dev_get_drvdata(dev);
1165 struct i2c_client *client = data->client;
1174 mutex_lock(&data->update_lock);
1175 data->alarm_mask = val & 0x7fffffff;
1176 mask = data->alarm_mask
1177 | (data->gpio_mask & 0x10000 ? 0x80000000 : 0);
1189 mutex_unlock(&data->update_lock);
1198 struct adm1026_data *data = adm1026_update_device(dev);
1199 return sprintf(buf, "%ld\n", data->gpio);
1204 struct adm1026_data *data = dev_get_drvdata(dev);
1205 struct i2c_client *client = data->client;
1214 mutex_lock(&data->update_lock);
1215 data->gpio = val & 0x1ffff;
1216 gpio = data->gpio;
1220 gpio = ((gpio >> 1) & 0x80) | (data->alarms >> 24 & 0x7f);
1222 mutex_unlock(&data->update_lock);
1232 struct adm1026_data *data = adm1026_update_device(dev);
1233 return sprintf(buf, "%ld\n", data->gpio_mask);
1239 struct adm1026_data *data = dev_get_drvdata(dev);
1240 struct i2c_client *client = data->client;
1249 mutex_lock(&data->update_lock);
1250 data->gpio_mask = val & 0x1ffff;
1251 mask = data->gpio_mask;
1255 mask = ((mask >> 1) & 0x80) | (data->alarm_mask >> 24 & 0x7f);
1257 mutex_unlock(&data->update_lock);
1266 struct adm1026_data *data = adm1026_update_device(dev);
1267 return sprintf(buf, "%d\n", PWM_FROM_REG(data->pwm1.pwm));
1273 struct adm1026_data *data = dev_get_drvdata(dev);
1274 struct i2c_client *client = data->client;
1276 if (data->pwm1.enable == 1) {
1284 mutex_lock(&data->update_lock);
1285 data->pwm1.pwm = PWM_TO_REG(val);
1286 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
1287 mutex_unlock(&data->update_lock);
1296 struct adm1026_data *data = adm1026_update_device(dev);
1297 return sprintf(buf, "%d\n", data->pwm1.auto_pwm_min);
1304 struct adm1026_data *data = dev_get_drvdata(dev);
1305 struct i2c_client *client = data->client;
1313 mutex_lock(&data->update_lock);
1314 data->pwm1.auto_pwm_min = clamp_val(val, 0, 255);
1315 if (data->pwm1.enable == 2) { /* apply immediately */
1316 data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |
1317 PWM_MIN_TO_REG(data->pwm1.auto_pwm_min));
1318 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
1320 mutex_unlock(&data->update_lock);
1334 struct adm1026_data *data = adm1026_update_device(dev);
1335 return sprintf(buf, "%d\n", data->pwm1.enable);
1342 struct adm1026_data *data = dev_get_drvdata(dev);
1343 struct i2c_client *client = data->client;
1355 mutex_lock(&data->update_lock);
1356 old_enable = data->pwm1.enable;
1357 data->pwm1.enable = val;
1358 data->config1 = (data->config1 & ~CFG1_PWM_AFC)
1360 adm1026_write_value(client, ADM1026_REG_CONFIG1, data->config1);
1362 data->pwm1.pwm = PWM_TO_REG((data->pwm1.pwm & 0x0f) |
1363 PWM_MIN_TO_REG(data->pwm1.auto_pwm_min));
1364 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
1367 data->pwm1.pwm = 255;
1368 adm1026_write_value(client, ADM1026_REG_PWM, data->pwm1.pwm);
1370 mutex_unlock(&data->update_lock);
1620 struct adm1026_data *data = i2c_get_clientdata(client);
1625 if (data->config2 & (1 << i)) {
1627 data->gpio_config[i] & 0x02 ? "" : "!",
1628 data->gpio_config[i] & 0x01 ? "OUT" : "IN",
1636 data->gpio_config[i] & 0x02 ? "" : "!",
1637 data->gpio_config[i] & 0x01 ? "OUT" : "IN",
1640 if (data->config3 & CFG3_GPIO16_ENABLE) {
1642 data->gpio_config[16] & 0x02 ? "" : "!",
1643 data->gpio_config[16] & 0x01 ? "OUT" : "IN");
1652 struct adm1026_data *data = i2c_get_clientdata(client);
1666 data->gpio_config[gpio_output[i]] |= 0x01;
1669 data->config2 |= 1 << gpio_output[i];
1675 data->gpio_config[gpio_input[i]] &= ~0x01;
1678 data->config2 |= 1 << gpio_input[i];
1684 data->gpio_config[gpio_inverted[i]] &= ~0x02;
1690 data->gpio_config[gpio_normal[i]] |= 0x02;
1696 data->config2 &= ~(1 << gpio_fan[i]);
1700 adm1026_write_value(client, ADM1026_REG_CONFIG2, data->config2);
1701 data->config3 = (data->config3 & 0x3f)
1702 | ((data->gpio_config[16] & 0x03) << 6);
1703 adm1026_write_value(client, ADM1026_REG_CONFIG3, data->config3);
1706 value |= data->gpio_config[i] & 0x03;
1722 struct adm1026_data *data = i2c_get_clientdata(client);
1726 data->config1 = adm1026_read_value(client, ADM1026_REG_CONFIG1);
1727 data->config2 = adm1026_read_value(client, ADM1026_REG_CONFIG2);
1728 data->config3 = adm1026_read_value(client, ADM1026_REG_CONFIG3);
1732 data->config1);
1733 if ((data->config1 & CFG1_MONITOR) == 0) {
1737 if (data->config1 & CFG1_INT_ENABLE) {
1741 if (data->config1 & CFG1_AIN8_9) {
1748 if (data->config1 & CFG1_THERM_HOT) {
1753 if (data->config3 & CFG3_GPIO16_ENABLE) {
1760 if (data->config3 & CFG3_VREF_250)
1771 data->gpio_config[i] = value & 0x03;
1774 data->gpio_config[16] = (data->config3 >> 6) & 0x03;
1801 data->pwm1.auto_pwm_min = 255;
1807 data->config1 = value;
1814 data->fan_div[i] = DIV_FROM_REG(value & 0x03);
1823 struct adm1026_data *data;
1825 data = devm_kzalloc(dev, sizeof(struct adm1026_data), GFP_KERNEL);
1826 if (!data)
1829 i2c_set_clientdata(client, data);
1830 data->client = client;
1831 mutex_init(&data->update_lock);
1834 data->vrm = vid_which_vrm();
1840 data->groups[0] = &adm1026_group;
1841 if (data->config1 & CFG1_AIN8_9)
1842 data->groups[1] = &adm1026_group_in8_9;
1844 data->groups[1] = &adm1026_group_temp3;
1847 data, data->groups);