Lines Matching refs:data
145 "Set to non-zero to disable SMBus block data transactions.");
159 /* Driver data */
194 * Client-specific data
228 /* block6 has a lot of data we don't need */
497 static int LM93_AUTO_BOOST_HYST_FROM_REGS(struct lm93_data *data, int nr,
504 reg = data->boost_hyst[0] & 0x0f;
507 reg = data->boost_hyst[0] >> 4 & 0x0f;
510 reg = data->boost_hyst[1] & 0x0f;
514 reg = data->boost_hyst[1] >> 4 & 0x0f;
518 return LM93_TEMP_FROM_REG(data->boost[nr]) -
522 static u8 LM93_AUTO_BOOST_HYST_TO_REG(struct lm93_data *data, long hyst,
526 (LM93_TEMP_FROM_REG(data->boost[nr]) - hyst), mode);
530 reg = (data->boost_hyst[0] & 0xf0) | (reg & 0x0f);
533 reg = (reg << 4 & 0xf0) | (data->boost_hyst[0] & 0x0f);
536 reg = (data->boost_hyst[1] & 0xf0) | (reg & 0x0f);
540 reg = (reg << 4 & 0xf0) | (data->boost_hyst[1] & 0x0f);
809 "lm93: read byte data failed, address 0x%02x.\n",
830 "lm93: write byte data failed, 0x%02x at address 0x%02x.\n",
847 "lm93: read word data failed, address 0x%02x.\n",
868 "lm93: write word data failed, 0x%04x at address 0x%02x.\n",
877 * read block data into values, retry if not expected length
893 "lm93: block read data failed, command 0x%02x.\n",
909 struct lm93_data *data = dev_get_drvdata(dev);
910 struct i2c_client *client = data->client;
913 mutex_lock(&data->update_lock);
915 if (time_after(jiffies, data->last_updated + interval) ||
916 !data->valid) {
918 data->update(data, client);
919 data->last_updated = jiffies;
920 data->valid = 1;
923 mutex_unlock(&data->update_lock);
924 return data;
927 /* update routine for data that has no corresponding SMBus block command */
928 static void lm93_update_client_common(struct lm93_data *data,
936 data->temp_lim[i].min =
938 data->temp_lim[i].max =
943 data->config = lm93_read_byte(client, LM93_REG_CONFIG);
947 data->vid[i] = lm93_read_byte(client, LM93_REG_VID(i));
951 data->prochot_max[i] = lm93_read_byte(client,
956 data->vccp_limits[i] = lm93_read_byte(client,
960 data->gpi = lm93_read_byte(client, LM93_REG_GPI);
963 data->prochot_override = lm93_read_byte(client,
967 data->prochot_interval = lm93_read_byte(client,
972 data->boost[i] = lm93_read_byte(client, LM93_REG_BOOST(i));
975 data->boost_hyst[0] = lm93_read_byte(client, LM93_REG_BOOST_HYST_12);
976 data->boost_hyst[1] = lm93_read_byte(client, LM93_REG_BOOST_HYST_34);
979 data->auto_pwm_min_hyst[0] =
981 data->auto_pwm_min_hyst[1] =
985 data->pwm_ramp_ctl = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
988 data->sfc1 = lm93_read_byte(client, LM93_REG_SFC1);
989 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
990 data->sf_tach_to_pwm = lm93_read_byte(client,
994 for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++)
998 /* update routine which uses SMBus block data commands */
999 static void lm93_update_client_full(struct lm93_data *data,
1002 dev_dbg(&client->dev, "starting device update (block data enabled)\n");
1005 lm93_read_block(client, 3, (u8 *)(data->block3));
1006 lm93_read_block(client, 7, (u8 *)(data->block7));
1009 lm93_read_block(client, 2, (u8 *)(data->block2));
1012 lm93_read_block(client, 4, (u8 *)(data->block4));
1015 lm93_read_block(client, 5, (u8 *)(data->block5));
1016 lm93_read_block(client, 8, (u8 *)(data->block8));
1019 lm93_read_block(client, 9, (u8 *)(data->block9));
1022 lm93_read_block(client, 1, (u8 *)(&data->block1));
1025 lm93_read_block(client, 10, (u8 *)(&data->block10));
1027 lm93_update_client_common(data, client);
1030 /* update routine which uses SMBus byte/word data commands only */
1031 static void lm93_update_client_min(struct lm93_data *data,
1037 dev_dbg(&client->dev, "starting device update (block data disabled)\n");
1041 data->block3[i] =
1043 data->block7[i].min =
1045 data->block7[i].max =
1051 data->block2[i] =
1057 data->block4[i].cur =
1059 data->block4[i].avg =
1065 data->block5[i] =
1067 data->block8[i] =
1074 data->block9[i][j] =
1080 for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++) {
1087 data->block10.base[i] =
1093 data->block10.offset[i] =
1097 lm93_update_client_common(data, client);
1106 struct lm93_data *data = lm93_update_device(dev);
1107 return sprintf(buf, "%d\n", LM93_IN_FROM_REG(nr, data->block3[nr]));
1131 struct lm93_data *data = lm93_update_device(dev);
1136 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1137 rc = LM93_IN_MIN_FROM_REG(data->vccp_limits[vccp], vid);
1139 rc = LM93_IN_FROM_REG(nr, data->block7[nr].min);
1148 struct lm93_data *data = dev_get_drvdata(dev);
1149 struct i2c_client *client = data->client;
1159 mutex_lock(&data->update_lock);
1161 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1162 data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0xf0) |
1165 data->vccp_limits[vccp]);
1167 data->block7[nr].min = LM93_IN_TO_REG(nr, val);
1169 data->block7[nr].min);
1171 mutex_unlock(&data->update_lock);
1196 struct lm93_data *data = lm93_update_device(dev);
1201 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1202 rc = LM93_IN_MAX_FROM_REG(data->vccp_limits[vccp], vid);
1204 rc = LM93_IN_FROM_REG(nr, data->block7[nr].max);
1213 struct lm93_data *data = dev_get_drvdata(dev);
1214 struct i2c_client *client = data->client;
1224 mutex_lock(&data->update_lock);
1226 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1227 data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0x0f) |
1230 data->vccp_limits[vccp]);
1232 data->block7[nr].max = LM93_IN_TO_REG(nr, val);
1234 data->block7[nr].max);
1236 mutex_unlock(&data->update_lock);
1261 struct lm93_data *data = lm93_update_device(dev);
1262 return sprintf(buf, "%d\n", LM93_TEMP_FROM_REG(data->block2[nr]));
1273 struct lm93_data *data = lm93_update_device(dev);
1274 return sprintf(buf, "%d\n", LM93_TEMP_FROM_REG(data->temp_lim[nr].min));
1282 struct lm93_data *data = dev_get_drvdata(dev);
1283 struct i2c_client *client = data->client;
1291 mutex_lock(&data->update_lock);
1292 data->temp_lim[nr].min = LM93_TEMP_TO_REG(val);
1293 lm93_write_byte(client, LM93_REG_TEMP_MIN(nr), data->temp_lim[nr].min);
1294 mutex_unlock(&data->update_lock);
1306 struct lm93_data *data = lm93_update_device(dev);
1307 return sprintf(buf, "%d\n", LM93_TEMP_FROM_REG(data->temp_lim[nr].max));
1315 struct lm93_data *data = dev_get_drvdata(dev);
1316 struct i2c_client *client = data->client;
1324 mutex_lock(&data->update_lock);
1325 data->temp_lim[nr].max = LM93_TEMP_TO_REG(val);
1326 lm93_write_byte(client, LM93_REG_TEMP_MAX(nr), data->temp_lim[nr].max);
1327 mutex_unlock(&data->update_lock);
1339 struct lm93_data *data = lm93_update_device(dev);
1340 return sprintf(buf, "%d\n", LM93_TEMP_FROM_REG(data->block10.base[nr]));
1348 struct lm93_data *data = dev_get_drvdata(dev);
1349 struct i2c_client *client = data->client;
1357 mutex_lock(&data->update_lock);
1358 data->block10.base[nr] = LM93_TEMP_TO_REG(val);
1359 lm93_write_byte(client, LM93_REG_TEMP_BASE(nr), data->block10.base[nr]);
1360 mutex_unlock(&data->update_lock);
1372 struct lm93_data *data = lm93_update_device(dev);
1373 return sprintf(buf, "%d\n", LM93_TEMP_FROM_REG(data->boost[nr]));
1381 struct lm93_data *data = dev_get_drvdata(dev);
1382 struct i2c_client *client = data->client;
1390 mutex_lock(&data->update_lock);
1391 data->boost[nr] = LM93_TEMP_TO_REG(val);
1392 lm93_write_byte(client, LM93_REG_BOOST(nr), data->boost[nr]);
1393 mutex_unlock(&data->update_lock);
1406 struct lm93_data *data = lm93_update_device(dev);
1407 int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1409 LM93_AUTO_BOOST_HYST_FROM_REGS(data, nr, mode));
1417 struct lm93_data *data = dev_get_drvdata(dev);
1418 struct i2c_client *client = data->client;
1426 mutex_lock(&data->update_lock);
1428 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1429 data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
1430 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1431 data->boost_hyst[nr/2] = LM93_AUTO_BOOST_HYST_TO_REG(data, val, nr, 1);
1433 data->boost_hyst[nr/2]);
1434 mutex_unlock(&data->update_lock);
1448 struct lm93_data *data = lm93_update_device(dev);
1449 int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1451 LM93_TEMP_AUTO_OFFSET_FROM_REG(data->block10.offset[ofs],
1462 struct lm93_data *data = dev_get_drvdata(dev);
1463 struct i2c_client *client = data->client;
1471 mutex_lock(&data->update_lock);
1473 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1474 data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
1475 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1476 data->block10.offset[ofs] = LM93_TEMP_AUTO_OFFSET_TO_REG(
1477 data->block10.offset[ofs], val, nr, 1);
1479 data->block10.offset[ofs]);
1480 mutex_unlock(&data->update_lock);
1527 struct lm93_data *data = lm93_update_device(dev);
1528 reg = data->auto_pwm_min_hyst[nr/2] >> 4 & 0x0f;
1529 ctl4 = data->block9[nr][LM93_PWM_CTL4];
1539 struct lm93_data *data = dev_get_drvdata(dev);
1540 struct i2c_client *client = data->client;
1549 mutex_lock(&data->update_lock);
1556 data->auto_pwm_min_hyst[nr/2] = reg;
1558 mutex_unlock(&data->update_lock);
1571 struct lm93_data *data = lm93_update_device(dev);
1572 int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1574 data->auto_pwm_min_hyst[nr / 2], mode));
1582 struct lm93_data *data = dev_get_drvdata(dev);
1583 struct i2c_client *client = data->client;
1592 mutex_lock(&data->update_lock);
1594 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1595 data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
1596 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1597 reg = data->auto_pwm_min_hyst[nr/2];
1599 data->auto_pwm_min_hyst[nr/2] = reg;
1601 mutex_unlock(&data->update_lock);
1614 struct lm93_data *data = lm93_update_device(dev);
1616 return sprintf(buf, "%d\n", LM93_FAN_FROM_REG(data->block5[nr]));
1628 struct lm93_data *data = lm93_update_device(dev);
1630 return sprintf(buf, "%d\n", LM93_FAN_FROM_REG(data->block8[nr]));
1638 struct lm93_data *data = dev_get_drvdata(dev);
1639 struct i2c_client *client = data->client;
1647 mutex_lock(&data->update_lock);
1648 data->block8[nr] = LM93_FAN_TO_REG(val);
1649 lm93_write_word(client, LM93_REG_FAN_MIN(nr), data->block8[nr]);
1650 mutex_unlock(&data->update_lock);
1662 * data->sf_tach_to_pwm: (tach to pwm mapping bits)
1667 * data->sfc2: (enable bits)
1677 struct lm93_data *data = lm93_update_device(dev);
1682 mapping = (data->sf_tach_to_pwm >> (nr * 2)) & 0x03;
1685 if (mapping && ((data->sfc2 >> nr) & 0x01))
1691 * helper function - must grab data->update_lock before calling
1695 struct lm93_data *data, int fan, long value)
1698 data->sf_tach_to_pwm = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM);
1699 data->sf_tach_to_pwm &= ~(0x3 << fan * 2);
1700 data->sf_tach_to_pwm |= value << fan * 2;
1701 lm93_write_byte(client, LM93_REG_SF_TACH_TO_PWM, data->sf_tach_to_pwm);
1704 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1706 data->sfc2 |= 1 << fan;
1708 data->sfc2 &= ~(1 << fan);
1709 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1717 struct lm93_data *data = dev_get_drvdata(dev);
1718 struct i2c_client *client = data->client;
1726 mutex_lock(&data->update_lock);
1736 lm93_write_fan_smart_tach(client, data, nr, val);
1738 mutex_unlock(&data->update_lock);
1751 struct lm93_data *data = lm93_update_device(dev);
1755 ctl2 = data->block9[nr][LM93_PWM_CTL2];
1756 ctl4 = data->block9[nr][LM93_PWM_CTL4];
1758 rc = data->pwm_override[nr];
1769 struct lm93_data *data = dev_get_drvdata(dev);
1770 struct i2c_client *client = data->client;
1779 mutex_lock(&data->update_lock);
1785 data->pwm_override[nr] = LM93_PWM_FROM_REG(ctl2 >> 4,
1789 mutex_unlock(&data->update_lock);
1800 struct lm93_data *data = lm93_update_device(dev);
1804 ctl2 = data->block9[nr][LM93_PWM_CTL2];
1817 struct lm93_data *data = dev_get_drvdata(dev);
1818 struct i2c_client *client = data->client;
1827 mutex_lock(&data->update_lock);
1841 mutex_unlock(&data->update_lock);
1846 mutex_unlock(&data->update_lock);
1857 struct lm93_data *data = lm93_update_device(dev);
1860 ctl4 = data->block9[nr][LM93_PWM_CTL4];
1865 * helper function - must grab data->update_lock before calling
1870 struct lm93_data *data, int pwm)
1883 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1884 data->sfc2 &= ~mask;
1885 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1893 struct lm93_data *data = dev_get_drvdata(dev);
1894 struct i2c_client *client = data->client;
1903 mutex_lock(&data->update_lock);
1906 data->block9[nr][LM93_PWM_CTL4] = ctl4;
1909 lm93_disable_fan_smart_tach(client, data, nr);
1911 mutex_unlock(&data->update_lock);
1923 struct lm93_data *data = lm93_update_device(dev);
1924 return sprintf(buf, "%d\n", data->block9[nr][LM93_PWM_CTL1]);
1932 struct lm93_data *data = dev_get_drvdata(dev);
1933 struct i2c_client *client = data->client;
1941 mutex_lock(&data->update_lock);
1942 data->block9[nr][LM93_PWM_CTL1] = clamp_val(val, 0, 255);
1944 data->block9[nr][LM93_PWM_CTL1]);
1945 mutex_unlock(&data->update_lock);
1957 struct lm93_data *data = lm93_update_device(dev);
1960 ctl3 = data->block9[nr][LM93_PWM_CTL3];
1961 ctl4 = data->block9[nr][LM93_PWM_CTL4];
1972 struct lm93_data *data = dev_get_drvdata(dev);
1973 struct i2c_client *client = data->client;
1982 mutex_lock(&data->update_lock);
1988 data->block9[nr][LM93_PWM_CTL3] = ctl3;
1990 mutex_unlock(&data->update_lock);
2002 struct lm93_data *data = lm93_update_device(dev);
2004 data->block9[nr][LM93_PWM_CTL3]));
2012 struct lm93_data *data = dev_get_drvdata(dev);
2013 struct i2c_client *client = data->client;
2022 mutex_lock(&data->update_lock);
2025 data->block9[nr][LM93_PWM_CTL3] = ctl3;
2027 mutex_unlock(&data->update_lock);
2037 struct lm93_data *data = lm93_update_device(dev);
2039 LM93_RAMP_FROM_REG(data->pwm_ramp_ctl >> 4 & 0x0f));
2046 struct lm93_data *data = dev_get_drvdata(dev);
2047 struct i2c_client *client = data->client;
2056 mutex_lock(&data->update_lock);
2060 mutex_unlock(&data->update_lock);
2069 struct lm93_data *data = lm93_update_device(dev);
2071 LM93_RAMP_FROM_REG(data->pwm_ramp_ctl & 0x0f));
2078 struct lm93_data *data = dev_get_drvdata(dev);
2079 struct i2c_client *client = data->client;
2088 mutex_lock(&data->update_lock);
2092 mutex_unlock(&data->update_lock);
2102 struct lm93_data *data = lm93_update_device(dev);
2103 return sprintf(buf, "%d\n", LM93_VID_FROM_REG(data->vid[nr]));
2113 struct lm93_data *data = lm93_update_device(dev);
2114 return sprintf(buf, "%d\n", data->block4[nr].cur);
2124 struct lm93_data *data = lm93_update_device(dev);
2125 return sprintf(buf, "%d\n", data->block4[nr].avg);
2135 struct lm93_data *data = lm93_update_device(dev);
2136 return sprintf(buf, "%d\n", data->prochot_max[nr]);
2144 struct lm93_data *data = dev_get_drvdata(dev);
2145 struct i2c_client *client = data->client;
2153 mutex_lock(&data->update_lock);
2154 data->prochot_max[nr] = LM93_PROCHOT_TO_REG(val);
2156 data->prochot_max[nr]);
2157 mutex_unlock(&data->update_lock);
2170 struct lm93_data *data = lm93_update_device(dev);
2172 (data->prochot_override & prochot_override_mask[nr]) ? 1 : 0);
2180 struct lm93_data *data = dev_get_drvdata(dev);
2181 struct i2c_client *client = data->client;
2189 mutex_lock(&data->update_lock);
2191 data->prochot_override |= prochot_override_mask[nr];
2193 data->prochot_override &= (~prochot_override_mask[nr]);
2195 data->prochot_override);
2196 mutex_unlock(&data->update_lock);
2207 struct lm93_data *data = lm93_update_device(dev);
2210 tmp = (data->prochot_interval & 0xf0) >> 4;
2212 tmp = data->prochot_interval & 0x0f;
2221 struct lm93_data *data = dev_get_drvdata(dev);
2222 struct i2c_client *client = data->client;
2231 mutex_lock(&data->update_lock);
2237 data->prochot_interval = tmp;
2239 mutex_unlock(&data->update_lock);
2250 struct lm93_data *data = lm93_update_device(dev);
2251 return sprintf(buf, "%d\n", data->prochot_override & 0x0f);
2258 struct lm93_data *data = dev_get_drvdata(dev);
2259 struct i2c_client *client = data->client;
2267 mutex_lock(&data->update_lock);
2268 data->prochot_override = (data->prochot_override & 0xf0) |
2271 data->prochot_override);
2272 mutex_unlock(&data->update_lock);
2281 struct lm93_data *data = lm93_update_device(dev);
2282 return sprintf(buf, "%d\n", (data->config & 0x10) ? 1 : 0);
2289 struct lm93_data *data = dev_get_drvdata(dev);
2290 struct i2c_client *client = data->client;
2298 mutex_lock(&data->update_lock);
2300 data->config |= 0x10;
2302 data->config &= ~0x10;
2303 lm93_write_byte(client, LM93_REG_CONFIG, data->config);
2304 mutex_unlock(&data->update_lock);
2314 struct lm93_data *data = lm93_update_device(dev);
2316 data->block1.host_status_1 & (1 << (nr + 4)) ? 1 : 0);
2325 struct lm93_data *data = lm93_update_device(dev);
2326 return sprintf(buf, "%d\n", LM93_GPI_FROM_REG(data->gpi));
2334 struct lm93_data *data = lm93_update_device(dev);
2335 return sprintf(buf, "%d\n", LM93_ALARMS_FROM_REG(data->block1));
2589 struct lm93_data *data;
2598 dev_dbg(dev, "using SMBus block data transactions\n");
2601 dev_dbg(dev, "disabled SMBus block data transactions\n");
2604 dev_dbg(dev, "detect failed, smbus byte and/or word data not supported!\n");
2608 data = devm_kzalloc(dev, sizeof(struct lm93_data), GFP_KERNEL);
2609 if (!data)
2613 data->client = client;
2614 data->update = update;
2615 mutex_init(&data->update_lock);
2621 data,