Lines Matching refs:data
288 static u8 f71882fg_read8(struct f71882fg_data *data, u8 reg)
292 outb(reg, data->addr + ADDR_REG_OFFSET);
293 val = inb(data->addr + DATA_REG_OFFSET);
298 static u16 f71882fg_read16(struct f71882fg_data *data, u8 reg)
302 val = f71882fg_read8(data, reg) << 8;
303 val |= f71882fg_read8(data, reg + 1);
318 static void f71882fg_write8(struct f71882fg_data *data, u8 reg, u8 val)
320 outb(reg, data->addr + ADDR_REG_OFFSET);
321 outb(val, data->addr + DATA_REG_OFFSET);
324 static void f71882fg_write16(struct f71882fg_data *data, u8 reg, u16 val)
326 f71882fg_write8(data, reg, val >> 8);
327 f71882fg_write8(data, reg + 1, val & 0xff);
330 static u16 f71882fg_read_temp(struct f71882fg_data *data, int nr)
332 if (data->type == f71858fg)
333 return f71882fg_read16(data, F71882FG_REG_TEMP(nr));
335 return f71882fg_read8(data, F71882FG_REG_TEMP(nr));
340 struct f71882fg_data *data = dev_get_drvdata(dev);
341 int nr_fans = f71882fg_nr_fans[data->type];
342 int nr_temps = f71882fg_nr_temps[data->type];
345 mutex_lock(&data->update_lock);
348 if (time_after(jiffies, data->last_limits + 60 * HZ) ||
349 !data->valid) {
350 if (f71882fg_has_in1_alarm[data->type]) {
351 if (data->type == f81866a) {
352 data->in1_max =
353 f71882fg_read8(data,
355 data->in_beep =
356 f71882fg_read8(data,
359 data->in1_max =
360 f71882fg_read8(data,
362 data->in_beep =
363 f71882fg_read8(data,
369 for (nr = data->temp_start; nr < nr_temps + data->temp_start;
371 data->temp_ovt[nr] = f71882fg_read8(data,
373 data->temp_high[nr] = f71882fg_read8(data,
377 if (data->type != f8000) {
378 data->temp_hyst[0] = f71882fg_read8(data,
380 data->temp_hyst[1] = f71882fg_read8(data,
384 if ((data->type != f71858fg) && (data->type != f8000)) {
385 reg = f71882fg_read8(data, F71882FG_REG_TEMP_TYPE);
386 data->temp_type[1] = (reg & 0x02) ? 2 : 4;
387 data->temp_type[2] = (reg & 0x04) ? 2 : 4;
388 data->temp_type[3] = (reg & 0x08) ? 2 : 4;
391 if (f71882fg_fan_has_beep[data->type])
392 data->fan_beep = f71882fg_read8(data,
395 if (f71882fg_temp_has_beep[data->type])
396 data->temp_beep = f71882fg_read8(data,
399 data->pwm_enable = f71882fg_read8(data,
401 data->pwm_auto_point_hyst[0] =
402 f71882fg_read8(data, F71882FG_REG_FAN_HYST(0));
403 data->pwm_auto_point_hyst[1] =
404 f71882fg_read8(data, F71882FG_REG_FAN_HYST(1));
407 data->pwm_auto_point_mapping[nr] =
408 f71882fg_read8(data,
411 switch (data->type) {
414 data->pwm_auto_point_pwm[nr][point] =
415 f71882fg_read8(data,
420 data->pwm_auto_point_temp[nr][point] =
421 f71882fg_read8(data,
428 data->pwm_auto_point_pwm[nr][0] =
429 f71882fg_read8(data,
433 data->pwm_auto_point_pwm[nr][1] =
434 f71882fg_read8(data,
437 data->pwm_auto_point_pwm[nr][4] =
438 f71882fg_read8(data,
441 data->pwm_auto_point_temp[nr][0] =
442 f71882fg_read8(data,
445 data->pwm_auto_point_temp[nr][3] =
446 f71882fg_read8(data,
452 data->last_limits = jiffies;
456 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {
457 data->temp_status = f71882fg_read8(data,
459 data->temp_diode_open = f71882fg_read8(data,
461 for (nr = data->temp_start; nr < nr_temps + data->temp_start;
463 data->temp[nr] = f71882fg_read_temp(data, nr);
465 data->fan_status = f71882fg_read8(data,
468 data->fan[nr] = f71882fg_read16(data,
470 data->fan_target[nr] =
471 f71882fg_read16(data, F71882FG_REG_FAN_TARGET(nr));
472 data->fan_full_speed[nr] =
473 f71882fg_read16(data,
475 data->pwm[nr] =
476 f71882fg_read8(data, F71882FG_REG_PWM(nr));
479 if (data->type == f71808a) {
480 data->fan[2] = f71882fg_read16(data,
482 data->pwm[2] = f71882fg_read8(data,
485 if (data->type == f8000)
486 data->fan[3] = f71882fg_read16(data,
489 if (f71882fg_has_in1_alarm[data->type]) {
490 if (data->type == f81866a)
491 data->in_status = f71882fg_read8(data,
495 data->in_status = f71882fg_read8(data,
500 if (f71882fg_has_in[data->type][nr])
501 data->in[nr] = f71882fg_read8(data,
504 data->last_updated = jiffies;
505 data->valid = true;
508 mutex_unlock(&data->update_lock);
510 return data;
516 struct f71882fg_data *data = dev_get_drvdata(dev);
517 return sprintf(buf, "%s\n", f71882fg_names[data->type]);
525 struct f71882fg_data *data = f71882fg_update_device(dev);
529 if (data->type == f71858fg) {
531 if (data->temp_config & 1) {
532 sign = data->temp[nr] & 0x0001;
533 temp = (data->temp[nr] >> 5) & 0x7ff;
535 sign = data->temp[nr] & 0x8000;
536 temp = (data->temp[nr] >> 5) & 0x3ff;
542 temp = ((s8)data->temp[nr]) * 1000;
551 struct f71882fg_data *data = f71882fg_update_device(dev);
554 return sprintf(buf, "%d\n", data->temp_high[nr] * 1000);
560 struct f71882fg_data *data = dev_get_drvdata(dev);
571 mutex_lock(&data->update_lock);
572 f71882fg_write8(data, F71882FG_REG_TEMP_HIGH(nr), val);
573 data->temp_high[nr] = val;
574 mutex_unlock(&data->update_lock);
582 struct f71882fg_data *data = f71882fg_update_device(dev);
586 mutex_lock(&data->update_lock);
588 temp_max_hyst = data->temp_hyst[nr / 2] >> 4;
590 temp_max_hyst = data->temp_hyst[nr / 2] & 0x0f;
591 temp_max_hyst = (data->temp_high[nr] - temp_max_hyst) * 1000;
592 mutex_unlock(&data->update_lock);
600 struct f71882fg_data *data = dev_get_drvdata(dev);
612 mutex_lock(&data->update_lock);
615 data->temp_high[nr] = f71882fg_read8(data, F71882FG_REG_TEMP_HIGH(nr));
616 val = clamp_val(val, data->temp_high[nr] - 15, data->temp_high[nr]);
617 val = data->temp_high[nr] - val;
620 reg = f71882fg_read8(data, F71882FG_REG_TEMP_HYST(nr / 2));
625 f71882fg_write8(data, F71882FG_REG_TEMP_HYST(nr / 2), reg);
626 data->temp_hyst[nr / 2] = reg;
628 mutex_unlock(&data->update_lock);
635 struct f71882fg_data *data = f71882fg_update_device(dev);
638 if (data->temp_status & (1 << nr))
647 struct f71882fg_data *data = f71882fg_update_device(dev);
650 return sprintf(buf, "%d\n", data->temp_ovt[nr] * 1000);
656 struct f71882fg_data *data = dev_get_drvdata(dev);
667 mutex_lock(&data->update_lock);
668 f71882fg_write8(data, F71882FG_REG_TEMP_OVT(nr), val);
669 data->temp_ovt[nr] = val;
670 mutex_unlock(&data->update_lock);
678 struct f71882fg_data *data = f71882fg_update_device(dev);
682 mutex_lock(&data->update_lock);
684 temp_crit_hyst = data->temp_hyst[nr / 2] >> 4;
686 temp_crit_hyst = data->temp_hyst[nr / 2] & 0x0f;
687 temp_crit_hyst = (data->temp_ovt[nr] - temp_crit_hyst) * 1000;
688 mutex_unlock(&data->update_lock);
696 struct f71882fg_data *data = f71882fg_update_device(dev);
699 if (data->temp_diode_open & (1 << nr))
751 struct f71882fg_data *data = f71882fg_update_device(dev);
754 return sprintf(buf, "%d\n", data->temp_type[nr]);
812 struct f71882fg_data *data = f71882fg_update_device(dev);
815 if (data->temp_beep & (1 << nr))
824 struct f71882fg_data *data = dev_get_drvdata(dev);
832 mutex_lock(&data->update_lock);
833 data->temp_beep = f71882fg_read8(data, F71882FG_REG_TEMP_BEEP);
835 data->temp_beep |= 1 << nr;
837 data->temp_beep &= ~(1 << nr);
839 f71882fg_write8(data, F71882FG_REG_TEMP_BEEP, data->temp_beep);
840 mutex_unlock(&data->update_lock);
913 struct f71882fg_data *data = f71882fg_update_device(dev);
916 return sprintf(buf, "%d\n", data->in[nr] * 8);
937 struct f71882fg_data *data = f71882fg_update_device(dev);
939 return sprintf(buf, "%d\n", data->in1_max * 8);
945 struct f71882fg_data *data = dev_get_drvdata(dev);
956 mutex_lock(&data->update_lock);
957 if (data->type == f81866a)
958 f71882fg_write8(data, F81866_REG_IN1_HIGH, val);
960 f71882fg_write8(data, F71882FG_REG_IN1_HIGH, val);
961 data->in1_max = val;
962 mutex_unlock(&data->update_lock);
970 struct f71882fg_data *data = f71882fg_update_device(dev);
973 if (data->in_beep & (1 << nr))
982 struct f71882fg_data *data = dev_get_drvdata(dev);
990 mutex_lock(&data->update_lock);
991 if (data->type == f81866a)
992 data->in_beep = f71882fg_read8(data, F81866_REG_IN_BEEP);
994 data->in_beep = f71882fg_read8(data, F71882FG_REG_IN_BEEP);
997 data->in_beep |= 1 << nr;
999 data->in_beep &= ~(1 << nr);
1001 if (data->type == f81866a)
1002 f71882fg_write8(data, F81866_REG_IN_BEEP, data->in_beep);
1004 f71882fg_write8(data, F71882FG_REG_IN_BEEP, data->in_beep);
1005 mutex_unlock(&data->update_lock);
1013 struct f71882fg_data *data = f71882fg_update_device(dev);
1016 if (data->in_status & (1 << nr))
1034 struct f71882fg_data *data = f71882fg_update_device(dev);
1036 int speed = fan_from_reg(data->fan[nr]);
1047 struct f71882fg_data *data = f71882fg_update_device(dev);
1049 int speed = fan_from_reg(data->fan_full_speed[nr]);
1057 struct f71882fg_data *data = dev_get_drvdata(dev);
1068 mutex_lock(&data->update_lock);
1069 f71882fg_write16(data, F71882FG_REG_FAN_FULL_SPEED(nr), val);
1070 data->fan_full_speed[nr] = val;
1071 mutex_unlock(&data->update_lock);
1079 struct f71882fg_data *data = f71882fg_update_device(dev);
1082 if (data->fan_status & (1 << nr))
1091 struct f71882fg_data *data = f71882fg_update_device(dev);
1093 mutex_lock(&data->update_lock);
1094 if (data->pwm_enable & (1 << (2 * nr)))
1096 val = data->pwm[nr];
1099 if (fan_from_reg(data->fan_full_speed[nr]))
1100 val = 255 * fan_from_reg(data->fan_target[nr])
1101 / fan_from_reg(data->fan_full_speed[nr]);
1105 mutex_unlock(&data->update_lock);
1113 struct f71882fg_data *data = dev_get_drvdata(dev);
1123 mutex_lock(&data->update_lock);
1124 data->pwm_enable = f71882fg_read8(data, F71882FG_REG_PWM_ENABLE);
1125 if ((data->type == f8000 && ((data->pwm_enable >> 2 * nr) & 3) != 2) ||
1126 (data->type != f8000 && !((data->pwm_enable >> 2 * nr) & 2))) {
1130 if (data->pwm_enable & (1 << (2 * nr))) {
1132 f71882fg_write8(data, F71882FG_REG_PWM(nr), val);
1133 data->pwm[nr] = val;
1137 full_speed = f71882fg_read16(data,
1140 f71882fg_write16(data, F71882FG_REG_FAN_TARGET(nr), target);
1141 data->fan_target[nr] = target;
1142 data->fan_full_speed[nr] = full_speed;
1145 mutex_unlock(&data->update_lock);
1154 struct f71882fg_data *data = f71882fg_update_device(dev);
1157 switch ((data->pwm_enable >> 2 * nr) & 3) {
1166 if (data->type == f8000)
1179 struct f71882fg_data *data = dev_get_drvdata(dev);
1188 if (data->type == f8000 && nr == 2 && val != 2)
1191 mutex_lock(&data->update_lock);
1192 data->pwm_enable = f71882fg_read8(data, F71882FG_REG_PWM_ENABLE);
1194 if (data->type == f8000 && ((data->pwm_enable >> 2 * nr) & 1)) {
1197 data->pwm_enable &= ~(2 << (2 * nr));
1200 data->pwm_enable |= 2 << (2 * nr);
1210 if (data->type == f71858fg &&
1211 ((data->pwm_enable >> (2 * nr)) & 1)) {
1215 data->pwm_enable |= 2 << (2 * nr);
1218 data->pwm_enable &= ~(2 << (2 * nr));
1225 f71882fg_write8(data, F71882FG_REG_PWM_ENABLE, data->pwm_enable);
1227 mutex_unlock(&data->update_lock);
1236 struct f71882fg_data *data = f71882fg_update_device(dev);
1239 result = (data->pwm_auto_point_mapping[nr] >> 4) & 1;
1248 struct f71882fg_data *data = dev_get_drvdata(dev);
1256 mutex_lock(&data->update_lock);
1257 data->pwm_auto_point_mapping[nr] =
1258 f71882fg_read8(data, F71882FG_REG_POINT_MAPPING(nr));
1260 val = data->pwm_auto_point_mapping[nr] | (1 << 4);
1262 val = data->pwm_auto_point_mapping[nr] & (~(1 << 4));
1263 f71882fg_write8(data, F71882FG_REG_POINT_MAPPING(nr), val);
1264 data->pwm_auto_point_mapping[nr] = val;
1265 mutex_unlock(&data->update_lock);
1320 struct f71882fg_data *data = f71882fg_update_device(dev);
1323 val = data->pwm[nr];
1331 struct f71882fg_data *data = dev_get_drvdata(dev);
1341 mutex_lock(&data->update_lock);
1342 f71882fg_write8(data, F71882FG_REG_PWM(nr), val);
1343 data->pwm[nr] = val;
1344 mutex_unlock(&data->update_lock);
1360 struct f71882fg_data *data = f71882fg_update_device(dev);
1363 if (data->fan_beep & (1 << nr))
1372 struct f71882fg_data *data = dev_get_drvdata(dev);
1380 mutex_lock(&data->update_lock);
1381 data->fan_beep = f71882fg_read8(data, F71882FG_REG_FAN_BEEP);
1383 data->fan_beep |= 1 << nr;
1385 data->fan_beep &= ~(1 << nr);
1387 f71882fg_write8(data, F71882FG_REG_FAN_BEEP, data->fan_beep);
1388 mutex_unlock(&data->update_lock);
1410 struct f71882fg_data *data = f71882fg_update_device(dev);
1413 result = 1 << ((data->pwm_auto_point_mapping[nr] & 3) -
1414 data->temp_start);
1423 struct f71882fg_data *data = dev_get_drvdata(dev);
1444 val += data->temp_start;
1445 mutex_lock(&data->update_lock);
1446 data->pwm_auto_point_mapping[nr] =
1447 f71882fg_read8(data, F71882FG_REG_POINT_MAPPING(nr));
1448 val = (data->pwm_auto_point_mapping[nr] & 0xfc) | val;
1449 f71882fg_write8(data, F71882FG_REG_POINT_MAPPING(nr), val);
1450 data->pwm_auto_point_mapping[nr] = val;
1451 mutex_unlock(&data->update_lock);
1461 struct f71882fg_data *data = f71882fg_update_device(dev);
1465 mutex_lock(&data->update_lock);
1466 if (data->pwm_enable & (1 << (2 * pwm))) {
1468 result = data->pwm_auto_point_pwm[pwm][point];
1471 result = 32 * 255 / (32 + data->pwm_auto_point_pwm[pwm][point]);
1473 mutex_unlock(&data->update_lock);
1482 struct f71882fg_data *data = dev_get_drvdata(dev);
1493 mutex_lock(&data->update_lock);
1494 data->pwm_enable = f71882fg_read8(data, F71882FG_REG_PWM_ENABLE);
1495 if (data->pwm_enable & (1 << (2 * pwm))) {
1504 f71882fg_write8(data, F71882FG_REG_POINT_PWM(pwm, point), val);
1505 data->pwm_auto_point_pwm[pwm][point] = val;
1506 mutex_unlock(&data->update_lock);
1516 struct f71882fg_data *data = f71882fg_update_device(dev);
1520 result = data->pwm_auto_point_temp[pwm][point];
1528 struct f71882fg_data *data = dev_get_drvdata(dev);
1539 if (data->auto_point_temp_signed)
1544 mutex_lock(&data->update_lock);
1545 f71882fg_write8(data, F71882FG_REG_POINT_TEMP(pwm, point), val);
1546 data->pwm_auto_point_temp[pwm][point] = val;
1547 mutex_unlock(&data->update_lock);
1557 struct f71882fg_data *data = f71882fg_update_device(dev);
1561 mutex_lock(&data->update_lock);
1563 result = data->pwm_auto_point_hyst[nr / 2] >> 4;
1565 result = data->pwm_auto_point_hyst[nr / 2] & 0x0f;
1566 result = 1000 * (data->pwm_auto_point_temp[nr][point] - result);
1567 mutex_unlock(&data->update_lock);
1576 struct f71882fg_data *data = dev_get_drvdata(dev);
1588 mutex_lock(&data->update_lock);
1589 data->pwm_auto_point_temp[nr][point] =
1590 f71882fg_read8(data, F71882FG_REG_POINT_TEMP(nr, point));
1591 val = clamp_val(val, data->pwm_auto_point_temp[nr][point] - 15,
1592 data->pwm_auto_point_temp[nr][point]);
1593 val = data->pwm_auto_point_temp[nr][point] - val;
1595 reg = f71882fg_read8(data, F71882FG_REG_FAN_HYST(nr / 2));
1601 f71882fg_write8(data, F71882FG_REG_FAN_HYST(nr / 2), reg);
1602 data->pwm_auto_point_hyst[nr / 2] = reg;
1603 mutex_unlock(&data->update_lock);
2131 struct f71882fg_data *data = platform_get_drvdata(pdev);
2136 switch (data->type) {
2138 if (((data->pwm_enable >> (idx * 2)) & 3) == 3)
2142 if (((data->pwm_enable >> (idx * 2)) & 1) != 1)
2147 err = data->pwm_enable & 0x20;
2156 (data->pwm_enable >> (idx * 2)) & 3, idx + 1);
2165 if (f71882fg_fan_has_beep[data->type]) {
2174 (data->pwm_enable & (1 << (2 * idx))) ? "duty-cycle" : "RPM");
2177 switch (data->type) {
2185 data->pwm_auto_point_mapping[idx] =
2186 f71882fg_read8(data, F71882FG_REG_POINT_MAPPING(idx));
2187 if ((data->pwm_auto_point_mapping[idx] & 0x80) ||
2188 (data->pwm_auto_point_mapping[idx] & 3) == 0) {
2191 "data, disabling pwm auto_point "
2200 switch (data->type) {
2228 struct f71882fg_data *data = platform_get_drvdata(pdev);
2229 int nr_fans = f71882fg_nr_fans[data->type];
2230 int nr_temps = f71882fg_nr_temps[data->type];
2232 u8 start_reg = f71882fg_read8(data, F71882FG_REG_START);
2234 if (data->hwmon_dev)
2235 hwmon_device_unregister(data->hwmon_dev);
2240 switch (data->type) {
2242 if (data->temp_config & 0x10)
2266 if (f71882fg_temp_has_beep[data->type]) {
2267 if (data->type == f81866a)
2280 if (f71882fg_has_in[data->type][i]) {
2285 if (f71882fg_has_in1_alarm[data->type]) {
2296 if (f71882fg_fan_has_beep[data->type]) {
2301 switch (data->type) {
2341 struct f71882fg_data *data;
2349 data = devm_kzalloc(&pdev->dev, sizeof(struct f71882fg_data),
2351 if (!data)
2354 data->addr = platform_get_resource(pdev, IORESOURCE_IO, 0)->start;
2355 data->type = sio_data->type;
2356 data->temp_start =
2357 (data->type == f71858fg || data->type == f8000 ||
2358 data->type == f81866a) ? 0 : 1;
2359 mutex_init(&data->update_lock);
2360 platform_set_drvdata(pdev, data);
2362 start_reg = f71882fg_read8(data, F71882FG_REG_START);
2378 switch (data->type) {
2380 data->temp_config =
2381 f71882fg_read8(data, F71882FG_REG_TEMP_CONFIG);
2382 if (data->temp_config & 0x10)
2413 if (f71882fg_temp_has_beep[data->type]) {
2414 if (data->type == f81866a) {
2431 if (f71882fg_has_in[data->type][i]) {
2438 if (f71882fg_has_in1_alarm[data->type]) {
2448 switch (data->type) {
2454 data->auto_point_temp_signed = 1;
2459 reg = f71882fg_read8(data, F71882FG_REG_FAN_FAULT_T);
2461 data->auto_point_temp_signed = 1;
2464 f71882fg_write8(data, F71882FG_REG_FAN_FAULT_T, reg);
2470 data->pwm_enable =
2471 f71882fg_read8(data, F71882FG_REG_PWM_ENABLE);
2480 switch (data->type) {
2498 data->hwmon_dev = hwmon_device_register(&pdev->dev);
2499 if (IS_ERR(data->hwmon_dev)) {
2500 err = PTR_ERR(data->hwmon_dev);
2501 data->hwmon_dev = NULL;
2509 return err; /* f71882fg_remove() also frees our data */
2639 pr_err("Platform data allocation failed\n");