1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Windfarm PowerMac thermal control. FCU fan control 4 * 5 * Copyright 2012 Benjamin Herrenschmidt, IBM Corp. 6 */ 7 #undef DEBUG 8 9 #include <linux/types.h> 10 #include <linux/errno.h> 11 #include <linux/kernel.h> 12 #include <linux/delay.h> 13 #include <linux/slab.h> 14 #include <linux/init.h> 15 #include <linux/wait.h> 16 #include <linux/i2c.h> 17 18 #include <asm/machdep.h> 19 #include <asm/io.h> 20 #include <asm/sections.h> 21 22 #include "windfarm.h" 23 #include "windfarm_mpu.h" 24 25 #define VERSION "1.0" 26 27 #ifdef DEBUG 28 #define DBG(args...) printk(args) 29 #else 30 #define DBG(args...) do { } while(0) 31 #endif 32 33 /* 34 * This option is "weird" :) Basically, if you define this to 1 35 * the control loop for the RPMs fans (not PWMs) will apply the 36 * correction factor obtained from the PID to the actual RPM 37 * speed read from the FCU. 38 * 39 * If you define the below constant to 0, then it will be 40 * applied to the setpoint RPM speed, that is basically the 41 * speed we proviously "asked" for. 42 * 43 * I'm using 0 for now which is what therm_pm72 used to do and 44 * what Darwin -apparently- does based on observed behaviour. 45 */ 46 #define RPM_PID_USE_ACTUAL_SPEED 0 47 48 /* Default min/max for pumps */ 49 #define CPU_PUMP_OUTPUT_MAX 3200 50 #define CPU_PUMP_OUTPUT_MIN 1250 51 52 #define FCU_FAN_RPM 0 53 #define FCU_FAN_PWM 1 54 55 struct wf_fcu_priv { 56 struct kref ref; 57 struct i2c_client *i2c; 58 struct mutex lock; 59 struct list_head fan_list; 60 int rpm_shift; 61 }; 62 63 struct wf_fcu_fan { 64 struct list_head link; 65 int id; 66 s32 min, max, target; 67 struct wf_fcu_priv *fcu_priv; 68 struct wf_control ctrl; 69 }; 70 71 static void wf_fcu_release(struct kref *ref) 72 { 73 struct wf_fcu_priv *pv = container_of(ref, struct wf_fcu_priv, ref); 74 75 kfree(pv); 76 } 77 78 static void wf_fcu_fan_release(struct wf_control *ct) 79 { 80 struct wf_fcu_fan *fan = ct->priv; 81 82 kref_put(&fan->fcu_priv->ref, wf_fcu_release); 83 kfree(fan); 84 } 85 86 static int wf_fcu_read_reg(struct wf_fcu_priv *pv, int reg, 87 unsigned char *buf, int nb) 88 { 89 int tries, nr, nw; 90 91 mutex_lock(&pv->lock); 92 93 buf[0] = reg; 94 tries = 0; 95 for (;;) { 96 nw = i2c_master_send(pv->i2c, buf, 1); 97 if (nw > 0 || (nw < 0 && nw != -EIO) || tries >= 100) 98 break; 99 msleep(10); 100 ++tries; 101 } 102 if (nw <= 0) { 103 pr_err("Failure writing address to FCU: %d", nw); 104 nr = nw; 105 goto bail; 106 } 107 tries = 0; 108 for (;;) { 109 nr = i2c_master_recv(pv->i2c, buf, nb); 110 if (nr > 0 || (nr < 0 && nr != -ENODEV) || tries >= 100) 111 break; 112 msleep(10); 113 ++tries; 114 } 115 if (nr <= 0) 116 pr_err("wf_fcu: Failure reading data from FCU: %d", nw); 117 bail: 118 mutex_unlock(&pv->lock); 119 return nr; 120 } 121 122 static int wf_fcu_write_reg(struct wf_fcu_priv *pv, int reg, 123 const unsigned char *ptr, int nb) 124 { 125 int tries, nw; 126 unsigned char buf[16]; 127 128 buf[0] = reg; 129 memcpy(buf+1, ptr, nb); 130 ++nb; 131 tries = 0; 132 for (;;) { 133 nw = i2c_master_send(pv->i2c, buf, nb); 134 if (nw > 0 || (nw < 0 && nw != -EIO) || tries >= 100) 135 break; 136 msleep(10); 137 ++tries; 138 } 139 if (nw < 0) 140 pr_err("wf_fcu: Failure writing to FCU: %d", nw); 141 return nw; 142 } 143 144 static int wf_fcu_fan_set_rpm(struct wf_control *ct, s32 value) 145 { 146 struct wf_fcu_fan *fan = ct->priv; 147 struct wf_fcu_priv *pv = fan->fcu_priv; 148 int rc, shift = pv->rpm_shift; 149 unsigned char buf[2]; 150 151 if (value < fan->min) 152 value = fan->min; 153 if (value > fan->max) 154 value = fan->max; 155 156 fan->target = value; 157 158 buf[0] = value >> (8 - shift); 159 buf[1] = value << shift; 160 rc = wf_fcu_write_reg(pv, 0x10 + (fan->id * 2), buf, 2); 161 if (rc < 0) 162 return -EIO; 163 return 0; 164 } 165 166 static int wf_fcu_fan_get_rpm(struct wf_control *ct, s32 *value) 167 { 168 struct wf_fcu_fan *fan = ct->priv; 169 struct wf_fcu_priv *pv = fan->fcu_priv; 170 int rc, reg_base, shift = pv->rpm_shift; 171 unsigned char failure; 172 unsigned char active; 173 unsigned char buf[2]; 174 175 rc = wf_fcu_read_reg(pv, 0xb, &failure, 1); 176 if (rc != 1) 177 return -EIO; 178 if ((failure & (1 << fan->id)) != 0) 179 return -EFAULT; 180 rc = wf_fcu_read_reg(pv, 0xd, &active, 1); 181 if (rc != 1) 182 return -EIO; 183 if ((active & (1 << fan->id)) == 0) 184 return -ENXIO; 185 186 /* Programmed value or real current speed */ 187 #if RPM_PID_USE_ACTUAL_SPEED 188 reg_base = 0x11; 189 #else 190 reg_base = 0x10; 191 #endif 192 rc = wf_fcu_read_reg(pv, reg_base + (fan->id * 2), buf, 2); 193 if (rc != 2) 194 return -EIO; 195 196 *value = (buf[0] << (8 - shift)) | buf[1] >> shift; 197 198 return 0; 199 } 200 201 static int wf_fcu_fan_set_pwm(struct wf_control *ct, s32 value) 202 { 203 struct wf_fcu_fan *fan = ct->priv; 204 struct wf_fcu_priv *pv = fan->fcu_priv; 205 unsigned char buf[2]; 206 int rc; 207 208 if (value < fan->min) 209 value = fan->min; 210 if (value > fan->max) 211 value = fan->max; 212 213 fan->target = value; 214 215 value = (value * 2559) / 1000; 216 buf[0] = value; 217 rc = wf_fcu_write_reg(pv, 0x30 + (fan->id * 2), buf, 1); 218 if (rc < 0) 219 return -EIO; 220 return 0; 221 } 222 223 static int wf_fcu_fan_get_pwm(struct wf_control *ct, s32 *value) 224 { 225 struct wf_fcu_fan *fan = ct->priv; 226 struct wf_fcu_priv *pv = fan->fcu_priv; 227 unsigned char failure; 228 unsigned char active; 229 unsigned char buf[2]; 230 int rc; 231 232 rc = wf_fcu_read_reg(pv, 0x2b, &failure, 1); 233 if (rc != 1) 234 return -EIO; 235 if ((failure & (1 << fan->id)) != 0) 236 return -EFAULT; 237 rc = wf_fcu_read_reg(pv, 0x2d, &active, 1); 238 if (rc != 1) 239 return -EIO; 240 if ((active & (1 << fan->id)) == 0) 241 return -ENXIO; 242 243 rc = wf_fcu_read_reg(pv, 0x30 + (fan->id * 2), buf, 1); 244 if (rc != 1) 245 return -EIO; 246 247 *value = (((s32)buf[0]) * 1000) / 2559; 248 249 return 0; 250 } 251 252 static s32 wf_fcu_fan_min(struct wf_control *ct) 253 { 254 struct wf_fcu_fan *fan = ct->priv; 255 256 return fan->min; 257 } 258 259 static s32 wf_fcu_fan_max(struct wf_control *ct) 260 { 261 struct wf_fcu_fan *fan = ct->priv; 262 263 return fan->max; 264 } 265 266 static const struct wf_control_ops wf_fcu_fan_rpm_ops = { 267 .set_value = wf_fcu_fan_set_rpm, 268 .get_value = wf_fcu_fan_get_rpm, 269 .get_min = wf_fcu_fan_min, 270 .get_max = wf_fcu_fan_max, 271 .release = wf_fcu_fan_release, 272 .owner = THIS_MODULE, 273 }; 274 275 static const struct wf_control_ops wf_fcu_fan_pwm_ops = { 276 .set_value = wf_fcu_fan_set_pwm, 277 .get_value = wf_fcu_fan_get_pwm, 278 .get_min = wf_fcu_fan_min, 279 .get_max = wf_fcu_fan_max, 280 .release = wf_fcu_fan_release, 281 .owner = THIS_MODULE, 282 }; 283 284 static void wf_fcu_get_pump_minmax(struct wf_fcu_fan *fan) 285 { 286 const struct mpu_data *mpu = wf_get_mpu(0); 287 u16 pump_min = 0, pump_max = 0xffff; 288 u16 tmp[4]; 289 290 /* Try to fetch pumps min/max infos from eeprom */ 291 if (mpu) { 292 memcpy(&tmp, mpu->processor_part_num, 8); 293 if (tmp[0] != 0xffff && tmp[1] != 0xffff) { 294 pump_min = max(pump_min, tmp[0]); 295 pump_max = min(pump_max, tmp[1]); 296 } 297 if (tmp[2] != 0xffff && tmp[3] != 0xffff) { 298 pump_min = max(pump_min, tmp[2]); 299 pump_max = min(pump_max, tmp[3]); 300 } 301 } 302 303 /* Double check the values, this _IS_ needed as the EEPROM on 304 * some dual 2.5Ghz G5s seem, at least, to have both min & max 305 * same to the same value ... (grrrr) 306 */ 307 if (pump_min == pump_max || pump_min == 0 || pump_max == 0xffff) { 308 pump_min = CPU_PUMP_OUTPUT_MIN; 309 pump_max = CPU_PUMP_OUTPUT_MAX; 310 } 311 312 fan->min = pump_min; 313 fan->max = pump_max; 314 315 DBG("wf_fcu: pump min/max for %s set to: [%d..%d] RPM\n", 316 fan->ctrl.name, pump_min, pump_max); 317 } 318 319 static void wf_fcu_get_rpmfan_minmax(struct wf_fcu_fan *fan) 320 { 321 struct wf_fcu_priv *pv = fan->fcu_priv; 322 const struct mpu_data *mpu0 = wf_get_mpu(0); 323 const struct mpu_data *mpu1 = wf_get_mpu(1); 324 325 /* Default */ 326 fan->min = 2400 >> pv->rpm_shift; 327 fan->max = 56000 >> pv->rpm_shift; 328 329 /* CPU fans have min/max in MPU */ 330 if (mpu0 && !strcmp(fan->ctrl.name, "cpu-front-fan-0")) { 331 fan->min = max(fan->min, (s32)mpu0->rminn_intake_fan); 332 fan->max = min(fan->max, (s32)mpu0->rmaxn_intake_fan); 333 goto bail; 334 } 335 if (mpu1 && !strcmp(fan->ctrl.name, "cpu-front-fan-1")) { 336 fan->min = max(fan->min, (s32)mpu1->rminn_intake_fan); 337 fan->max = min(fan->max, (s32)mpu1->rmaxn_intake_fan); 338 goto bail; 339 } 340 if (mpu0 && !strcmp(fan->ctrl.name, "cpu-rear-fan-0")) { 341 fan->min = max(fan->min, (s32)mpu0->rminn_exhaust_fan); 342 fan->max = min(fan->max, (s32)mpu0->rmaxn_exhaust_fan); 343 goto bail; 344 } 345 if (mpu1 && !strcmp(fan->ctrl.name, "cpu-rear-fan-1")) { 346 fan->min = max(fan->min, (s32)mpu1->rminn_exhaust_fan); 347 fan->max = min(fan->max, (s32)mpu1->rmaxn_exhaust_fan); 348 goto bail; 349 } 350 /* Rackmac variants, we just use mpu0 intake */ 351 if (!strncmp(fan->ctrl.name, "cpu-fan", 7)) { 352 fan->min = max(fan->min, (s32)mpu0->rminn_intake_fan); 353 fan->max = min(fan->max, (s32)mpu0->rmaxn_intake_fan); 354 goto bail; 355 } 356 bail: 357 DBG("wf_fcu: fan min/max for %s set to: [%d..%d] RPM\n", 358 fan->ctrl.name, fan->min, fan->max); 359 } 360 361 static void wf_fcu_add_fan(struct wf_fcu_priv *pv, const char *name, 362 int type, int id) 363 { 364 struct wf_fcu_fan *fan; 365 366 fan = kzalloc(sizeof(*fan), GFP_KERNEL); 367 if (!fan) 368 return; 369 fan->fcu_priv = pv; 370 fan->id = id; 371 fan->ctrl.name = name; 372 fan->ctrl.priv = fan; 373 374 /* min/max is oddball but the code comes from 375 * therm_pm72 which seems to work so ... 376 */ 377 if (type == FCU_FAN_RPM) { 378 if (!strncmp(name, "cpu-pump", strlen("cpu-pump"))) 379 wf_fcu_get_pump_minmax(fan); 380 else 381 wf_fcu_get_rpmfan_minmax(fan); 382 fan->ctrl.type = WF_CONTROL_RPM_FAN; 383 fan->ctrl.ops = &wf_fcu_fan_rpm_ops; 384 } else { 385 fan->min = 10; 386 fan->max = 100; 387 fan->ctrl.type = WF_CONTROL_PWM_FAN; 388 fan->ctrl.ops = &wf_fcu_fan_pwm_ops; 389 } 390 391 if (wf_register_control(&fan->ctrl)) { 392 pr_err("wf_fcu: Failed to register fan %s\n", name); 393 kfree(fan); 394 return; 395 } 396 list_add(&fan->link, &pv->fan_list); 397 kref_get(&pv->ref); 398 } 399 400 static void wf_fcu_lookup_fans(struct wf_fcu_priv *pv) 401 { 402 /* Translation of device-tree location properties to 403 * windfarm fan names 404 */ 405 static const struct { 406 const char *dt_name; /* Device-tree name */ 407 const char *ct_name; /* Control name */ 408 } loc_trans[] = { 409 { "BACKSIDE", "backside-fan", }, 410 { "SYS CTRLR FAN", "backside-fan", }, 411 { "DRIVE BAY", "drive-bay-fan", }, 412 { "SLOT", "slots-fan", }, 413 { "PCI FAN", "slots-fan", }, 414 { "CPU A INTAKE", "cpu-front-fan-0", }, 415 { "CPU A EXHAUST", "cpu-rear-fan-0", }, 416 { "CPU B INTAKE", "cpu-front-fan-1", }, 417 { "CPU B EXHAUST", "cpu-rear-fan-1", }, 418 { "CPU A PUMP", "cpu-pump-0", }, 419 { "CPU B PUMP", "cpu-pump-1", }, 420 { "CPU A 1", "cpu-fan-a-0", }, 421 { "CPU A 2", "cpu-fan-b-0", }, 422 { "CPU A 3", "cpu-fan-c-0", }, 423 { "CPU B 1", "cpu-fan-a-1", }, 424 { "CPU B 2", "cpu-fan-b-1", }, 425 { "CPU B 3", "cpu-fan-c-1", }, 426 }; 427 struct device_node *np, *fcu = pv->i2c->dev.of_node; 428 int i; 429 430 DBG("Looking up FCU controls in device-tree...\n"); 431 432 for_each_child_of_node(fcu, np) { 433 int id, type = -1; 434 const char *loc; 435 const char *name; 436 const u32 *reg; 437 438 DBG(" control: %pOFn, type: %s\n", np, of_node_get_device_type(np)); 439 440 /* Detect control type */ 441 if (of_node_is_type(np, "fan-rpm-control") || 442 of_node_is_type(np, "fan-rpm")) 443 type = FCU_FAN_RPM; 444 if (of_node_is_type(np, "fan-pwm-control") || 445 of_node_is_type(np, "fan-pwm")) 446 type = FCU_FAN_PWM; 447 /* Only care about fans for now */ 448 if (type == -1) 449 continue; 450 451 /* Lookup for a matching location */ 452 loc = of_get_property(np, "location", NULL); 453 reg = of_get_property(np, "reg", NULL); 454 if (loc == NULL || reg == NULL) 455 continue; 456 DBG(" matching location: %s, reg: 0x%08x\n", loc, *reg); 457 458 for (i = 0; i < ARRAY_SIZE(loc_trans); i++) { 459 if (strncmp(loc, loc_trans[i].dt_name, 460 strlen(loc_trans[i].dt_name))) 461 continue; 462 name = loc_trans[i].ct_name; 463 464 DBG(" location match, name: %s\n", name); 465 466 if (type == FCU_FAN_RPM) 467 id = ((*reg) - 0x10) / 2; 468 else 469 id = ((*reg) - 0x30) / 2; 470 if (id > 7) { 471 pr_warn("wf_fcu: Can't parse fan ID in device-tree for %pOF\n", np); 472 break; 473 } 474 wf_fcu_add_fan(pv, name, type, id); 475 break; 476 } 477 } 478 } 479 480 static void wf_fcu_default_fans(struct wf_fcu_priv *pv) 481 { 482 /* We only support the default fans for PowerMac7,2 */ 483 if (!of_machine_is_compatible("PowerMac7,2")) 484 return; 485 486 wf_fcu_add_fan(pv, "backside-fan", FCU_FAN_PWM, 1); 487 wf_fcu_add_fan(pv, "drive-bay-fan", FCU_FAN_RPM, 2); 488 wf_fcu_add_fan(pv, "slots-fan", FCU_FAN_PWM, 2); 489 wf_fcu_add_fan(pv, "cpu-front-fan-0", FCU_FAN_RPM, 3); 490 wf_fcu_add_fan(pv, "cpu-rear-fan-0", FCU_FAN_RPM, 4); 491 wf_fcu_add_fan(pv, "cpu-front-fan-1", FCU_FAN_RPM, 5); 492 wf_fcu_add_fan(pv, "cpu-rear-fan-1", FCU_FAN_RPM, 6); 493 } 494 495 static int wf_fcu_init_chip(struct wf_fcu_priv *pv) 496 { 497 unsigned char buf = 0xff; 498 int rc; 499 500 rc = wf_fcu_write_reg(pv, 0xe, &buf, 1); 501 if (rc < 0) 502 return -EIO; 503 rc = wf_fcu_write_reg(pv, 0x2e, &buf, 1); 504 if (rc < 0) 505 return -EIO; 506 rc = wf_fcu_read_reg(pv, 0, &buf, 1); 507 if (rc < 0) 508 return -EIO; 509 pv->rpm_shift = (buf == 1) ? 2 : 3; 510 511 pr_debug("wf_fcu: FCU Initialized, RPM fan shift is %d\n", 512 pv->rpm_shift); 513 514 return 0; 515 } 516 517 static int wf_fcu_probe(struct i2c_client *client) 518 { 519 struct wf_fcu_priv *pv; 520 521 pv = kzalloc(sizeof(*pv), GFP_KERNEL); 522 if (!pv) 523 return -ENOMEM; 524 525 kref_init(&pv->ref); 526 mutex_init(&pv->lock); 527 INIT_LIST_HEAD(&pv->fan_list); 528 pv->i2c = client; 529 530 /* 531 * First we must start the FCU which will query the 532 * shift value to apply to RPMs 533 */ 534 if (wf_fcu_init_chip(pv)) { 535 pr_err("wf_fcu: Initialization failed !\n"); 536 kfree(pv); 537 return -ENXIO; 538 } 539 540 /* First lookup fans in the device-tree */ 541 wf_fcu_lookup_fans(pv); 542 543 /* 544 * Older machines don't have the device-tree entries 545 * we are looking for, just hard code the list 546 */ 547 if (list_empty(&pv->fan_list)) 548 wf_fcu_default_fans(pv); 549 550 /* Still no fans ? FAIL */ 551 if (list_empty(&pv->fan_list)) { 552 pr_err("wf_fcu: Failed to find fans for your machine\n"); 553 kfree(pv); 554 return -ENODEV; 555 } 556 557 dev_set_drvdata(&client->dev, pv); 558 559 return 0; 560 } 561 562 static void wf_fcu_remove(struct i2c_client *client) 563 { 564 struct wf_fcu_priv *pv = dev_get_drvdata(&client->dev); 565 struct wf_fcu_fan *fan; 566 567 while (!list_empty(&pv->fan_list)) { 568 fan = list_first_entry(&pv->fan_list, struct wf_fcu_fan, link); 569 list_del(&fan->link); 570 wf_unregister_control(&fan->ctrl); 571 } 572 kref_put(&pv->ref, wf_fcu_release); 573 } 574 575 static const struct i2c_device_id wf_fcu_id[] = { 576 { "MAC,fcu", 0 }, 577 { } 578 }; 579 MODULE_DEVICE_TABLE(i2c, wf_fcu_id); 580 581 static const struct of_device_id wf_fcu_of_id[] = { 582 { .compatible = "fcu", }, 583 { } 584 }; 585 MODULE_DEVICE_TABLE(of, wf_fcu_of_id); 586 587 static struct i2c_driver wf_fcu_driver = { 588 .driver = { 589 .name = "wf_fcu", 590 .of_match_table = wf_fcu_of_id, 591 }, 592 .probe_new = wf_fcu_probe, 593 .remove = wf_fcu_remove, 594 .id_table = wf_fcu_id, 595 }; 596 597 module_i2c_driver(wf_fcu_driver); 598 599 MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>"); 600 MODULE_DESCRIPTION("FCU control objects for PowerMacs thermal control"); 601 MODULE_LICENSE("GPL"); 602 603