windfarm_pm91.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Windfarm PowerMac thermal control. SMU based 1 CPU desktop control loops
  4. *
  5. * (c) Copyright 2005 Benjamin Herrenschmidt, IBM Corp.
  6. * <benh@kernel.crashing.org>
  7. *
  8. * The algorithm used is the PID control algorithm, used the same
  9. * way the published Darwin code does, using the same values that
  10. * are present in the Darwin 8.2 snapshot property lists (note however
  11. * that none of the code has been re-used, it's a complete re-implementation
  12. *
  13. * The various control loops found in Darwin config file are:
  14. *
  15. * PowerMac9,1
  16. * ===========
  17. *
  18. * Has 3 control loops: CPU fans is similar to PowerMac8,1 (though it doesn't
  19. * try to play with other control loops fans). Drive bay is rather basic PID
  20. * with one sensor and one fan. Slots area is a bit different as the Darwin
  21. * driver is supposed to be capable of working in a special "AGP" mode which
  22. * involves the presence of an AGP sensor and an AGP fan (possibly on the
  23. * AGP card itself). I can't deal with that special mode as I don't have
  24. * access to those additional sensor/fans for now (though ultimately, it would
  25. * be possible to add sensor objects for them) so I'm only implementing the
  26. * basic PCI slot control loop
  27. */
  28. #include <linux/types.h>
  29. #include <linux/errno.h>
  30. #include <linux/kernel.h>
  31. #include <linux/delay.h>
  32. #include <linux/slab.h>
  33. #include <linux/init.h>
  34. #include <linux/spinlock.h>
  35. #include <linux/wait.h>
  36. #include <linux/kmod.h>
  37. #include <linux/device.h>
  38. #include <linux/platform_device.h>
  39. #include <asm/prom.h>
  40. #include <asm/machdep.h>
  41. #include <asm/io.h>
  42. #include <asm/sections.h>
  43. #include <asm/smu.h>
  44. #include "windfarm.h"
  45. #include "windfarm_pid.h"
  46. #define VERSION "0.4"
  47. #undef DEBUG
  48. #ifdef DEBUG
  49. #define DBG(args...) printk(args)
  50. #else
  51. #define DBG(args...) do { } while(0)
  52. #endif
  53. /* define this to force CPU overtemp to 74 degree, useful for testing
  54. * the overtemp code
  55. */
  56. #undef HACKED_OVERTEMP
  57. /* Controls & sensors */
  58. static struct wf_sensor *sensor_cpu_power;
  59. static struct wf_sensor *sensor_cpu_temp;
  60. static struct wf_sensor *sensor_hd_temp;
  61. static struct wf_sensor *sensor_slots_power;
  62. static struct wf_control *fan_cpu_main;
  63. static struct wf_control *fan_cpu_second;
  64. static struct wf_control *fan_cpu_third;
  65. static struct wf_control *fan_hd;
  66. static struct wf_control *fan_slots;
  67. static struct wf_control *cpufreq_clamp;
  68. /* Set to kick the control loop into life */
  69. static int wf_smu_all_controls_ok, wf_smu_all_sensors_ok;
  70. static bool wf_smu_started;
  71. static bool wf_smu_overtemp;
  72. /* Failure handling.. could be nicer */
  73. #define FAILURE_FAN 0x01
  74. #define FAILURE_SENSOR 0x02
  75. #define FAILURE_OVERTEMP 0x04
  76. static unsigned int wf_smu_failure_state;
  77. static int wf_smu_readjust, wf_smu_skipping;
  78. /*
  79. * ****** CPU Fans Control Loop ******
  80. *
  81. */
  82. #define WF_SMU_CPU_FANS_INTERVAL 1
  83. #define WF_SMU_CPU_FANS_MAX_HISTORY 16
  84. /* State data used by the cpu fans control loop
  85. */
  86. struct wf_smu_cpu_fans_state {
  87. int ticks;
  88. s32 cpu_setpoint;
  89. struct wf_cpu_pid_state pid;
  90. };
  91. static struct wf_smu_cpu_fans_state *wf_smu_cpu_fans;
  92. /*
  93. * ****** Drive Fan Control Loop ******
  94. *
  95. */
  96. struct wf_smu_drive_fans_state {
  97. int ticks;
  98. s32 setpoint;
  99. struct wf_pid_state pid;
  100. };
  101. static struct wf_smu_drive_fans_state *wf_smu_drive_fans;
  102. /*
  103. * ****** Slots Fan Control Loop ******
  104. *
  105. */
  106. struct wf_smu_slots_fans_state {
  107. int ticks;
  108. s32 setpoint;
  109. struct wf_pid_state pid;
  110. };
  111. static struct wf_smu_slots_fans_state *wf_smu_slots_fans;
  112. /*
  113. * ***** Implementation *****
  114. *
  115. */
  116. static void wf_smu_create_cpu_fans(void)
  117. {
  118. struct wf_cpu_pid_param pid_param;
  119. const struct smu_sdbp_header *hdr;
  120. struct smu_sdbp_cpupiddata *piddata;
  121. struct smu_sdbp_fvt *fvt;
  122. s32 tmax, tdelta, maxpow, powadj;
  123. /* First, locate the PID params in SMU SBD */
  124. hdr = smu_get_sdb_partition(SMU_SDB_CPUPIDDATA_ID, NULL);
  125. if (hdr == 0) {
  126. printk(KERN_WARNING "windfarm: CPU PID fan config not found "
  127. "max fan speed\n");
  128. goto fail;
  129. }
  130. piddata = (struct smu_sdbp_cpupiddata *)&hdr[1];
  131. /* Get the FVT params for operating point 0 (the only supported one
  132. * for now) in order to get tmax
  133. */
  134. hdr = smu_get_sdb_partition(SMU_SDB_FVT_ID, NULL);
  135. if (hdr) {
  136. fvt = (struct smu_sdbp_fvt *)&hdr[1];
  137. tmax = ((s32)fvt->maxtemp) << 16;
  138. } else
  139. tmax = 0x5e0000; /* 94 degree default */
  140. /* Alloc & initialize state */
  141. wf_smu_cpu_fans = kmalloc(sizeof(struct wf_smu_cpu_fans_state),
  142. GFP_KERNEL);
  143. if (wf_smu_cpu_fans == NULL)
  144. goto fail;
  145. wf_smu_cpu_fans->ticks = 1;
  146. /* Fill PID params */
  147. pid_param.interval = WF_SMU_CPU_FANS_INTERVAL;
  148. pid_param.history_len = piddata->history_len;
  149. if (pid_param.history_len > WF_CPU_PID_MAX_HISTORY) {
  150. printk(KERN_WARNING "windfarm: History size overflow on "
  151. "CPU control loop (%d)\n", piddata->history_len);
  152. pid_param.history_len = WF_CPU_PID_MAX_HISTORY;
  153. }
  154. pid_param.gd = piddata->gd;
  155. pid_param.gp = piddata->gp;
  156. pid_param.gr = piddata->gr / pid_param.history_len;
  157. tdelta = ((s32)piddata->target_temp_delta) << 16;
  158. maxpow = ((s32)piddata->max_power) << 16;
  159. powadj = ((s32)piddata->power_adj) << 16;
  160. pid_param.tmax = tmax;
  161. pid_param.ttarget = tmax - tdelta;
  162. pid_param.pmaxadj = maxpow - powadj;
  163. pid_param.min = wf_control_get_min(fan_cpu_main);
  164. pid_param.max = wf_control_get_max(fan_cpu_main);
  165. wf_cpu_pid_init(&wf_smu_cpu_fans->pid, &pid_param);
  166. DBG("wf: CPU Fan control initialized.\n");
  167. DBG(" ttarget=%d.%03d, tmax=%d.%03d, min=%d RPM, max=%d RPM\n",
  168. FIX32TOPRINT(pid_param.ttarget), FIX32TOPRINT(pid_param.tmax),
  169. pid_param.min, pid_param.max);
  170. return;
  171. fail:
  172. printk(KERN_WARNING "windfarm: CPU fan config not found\n"
  173. "for this machine model, max fan speed\n");
  174. if (cpufreq_clamp)
  175. wf_control_set_max(cpufreq_clamp);
  176. if (fan_cpu_main)
  177. wf_control_set_max(fan_cpu_main);
  178. }
  179. static void wf_smu_cpu_fans_tick(struct wf_smu_cpu_fans_state *st)
  180. {
  181. s32 new_setpoint, temp, power;
  182. int rc;
  183. if (--st->ticks != 0) {
  184. if (wf_smu_readjust)
  185. goto readjust;
  186. return;
  187. }
  188. st->ticks = WF_SMU_CPU_FANS_INTERVAL;
  189. rc = wf_sensor_get(sensor_cpu_temp, &temp);
  190. if (rc) {
  191. printk(KERN_WARNING "windfarm: CPU temp sensor error %d\n",
  192. rc);
  193. wf_smu_failure_state |= FAILURE_SENSOR;
  194. return;
  195. }
  196. rc = wf_sensor_get(sensor_cpu_power, &power);
  197. if (rc) {
  198. printk(KERN_WARNING "windfarm: CPU power sensor error %d\n",
  199. rc);
  200. wf_smu_failure_state |= FAILURE_SENSOR;
  201. return;
  202. }
  203. DBG("wf_smu: CPU Fans tick ! CPU temp: %d.%03d, power: %d.%03d\n",
  204. FIX32TOPRINT(temp), FIX32TOPRINT(power));
  205. #ifdef HACKED_OVERTEMP
  206. if (temp > 0x4a0000)
  207. wf_smu_failure_state |= FAILURE_OVERTEMP;
  208. #else
  209. if (temp > st->pid.param.tmax)
  210. wf_smu_failure_state |= FAILURE_OVERTEMP;
  211. #endif
  212. new_setpoint = wf_cpu_pid_run(&st->pid, power, temp);
  213. DBG("wf_smu: new_setpoint: %d RPM\n", (int)new_setpoint);
  214. if (st->cpu_setpoint == new_setpoint)
  215. return;
  216. st->cpu_setpoint = new_setpoint;
  217. readjust:
  218. if (fan_cpu_main && wf_smu_failure_state == 0) {
  219. rc = wf_control_set(fan_cpu_main, st->cpu_setpoint);
  220. if (rc) {
  221. printk(KERN_WARNING "windfarm: CPU main fan"
  222. " error %d\n", rc);
  223. wf_smu_failure_state |= FAILURE_FAN;
  224. }
  225. }
  226. if (fan_cpu_second && wf_smu_failure_state == 0) {
  227. rc = wf_control_set(fan_cpu_second, st->cpu_setpoint);
  228. if (rc) {
  229. printk(KERN_WARNING "windfarm: CPU second fan"
  230. " error %d\n", rc);
  231. wf_smu_failure_state |= FAILURE_FAN;
  232. }
  233. }
  234. if (fan_cpu_third && wf_smu_failure_state == 0) {
  235. rc = wf_control_set(fan_cpu_third, st->cpu_setpoint);
  236. if (rc) {
  237. printk(KERN_WARNING "windfarm: CPU third fan"
  238. " error %d\n", rc);
  239. wf_smu_failure_state |= FAILURE_FAN;
  240. }
  241. }
  242. }
  243. static void wf_smu_create_drive_fans(void)
  244. {
  245. struct wf_pid_param param = {
  246. .interval = 5,
  247. .history_len = 2,
  248. .gd = 0x01e00000,
  249. .gp = 0x00500000,
  250. .gr = 0x00000000,
  251. .itarget = 0x00200000,
  252. };
  253. /* Alloc & initialize state */
  254. wf_smu_drive_fans = kmalloc(sizeof(struct wf_smu_drive_fans_state),
  255. GFP_KERNEL);
  256. if (wf_smu_drive_fans == NULL) {
  257. printk(KERN_WARNING "windfarm: Memory allocation error"
  258. " max fan speed\n");
  259. goto fail;
  260. }
  261. wf_smu_drive_fans->ticks = 1;
  262. /* Fill PID params */
  263. param.additive = (fan_hd->type == WF_CONTROL_RPM_FAN);
  264. param.min = wf_control_get_min(fan_hd);
  265. param.max = wf_control_get_max(fan_hd);
  266. wf_pid_init(&wf_smu_drive_fans->pid, &param);
  267. DBG("wf: Drive Fan control initialized.\n");
  268. DBG(" itarged=%d.%03d, min=%d RPM, max=%d RPM\n",
  269. FIX32TOPRINT(param.itarget), param.min, param.max);
  270. return;
  271. fail:
  272. if (fan_hd)
  273. wf_control_set_max(fan_hd);
  274. }
  275. static void wf_smu_drive_fans_tick(struct wf_smu_drive_fans_state *st)
  276. {
  277. s32 new_setpoint, temp;
  278. int rc;
  279. if (--st->ticks != 0) {
  280. if (wf_smu_readjust)
  281. goto readjust;
  282. return;
  283. }
  284. st->ticks = st->pid.param.interval;
  285. rc = wf_sensor_get(sensor_hd_temp, &temp);
  286. if (rc) {
  287. printk(KERN_WARNING "windfarm: HD temp sensor error %d\n",
  288. rc);
  289. wf_smu_failure_state |= FAILURE_SENSOR;
  290. return;
  291. }
  292. DBG("wf_smu: Drive Fans tick ! HD temp: %d.%03d\n",
  293. FIX32TOPRINT(temp));
  294. if (temp > (st->pid.param.itarget + 0x50000))
  295. wf_smu_failure_state |= FAILURE_OVERTEMP;
  296. new_setpoint = wf_pid_run(&st->pid, temp);
  297. DBG("wf_smu: new_setpoint: %d\n", (int)new_setpoint);
  298. if (st->setpoint == new_setpoint)
  299. return;
  300. st->setpoint = new_setpoint;
  301. readjust:
  302. if (fan_hd && wf_smu_failure_state == 0) {
  303. rc = wf_control_set(fan_hd, st->setpoint);
  304. if (rc) {
  305. printk(KERN_WARNING "windfarm: HD fan error %d\n",
  306. rc);
  307. wf_smu_failure_state |= FAILURE_FAN;
  308. }
  309. }
  310. }
  311. static void wf_smu_create_slots_fans(void)
  312. {
  313. struct wf_pid_param param = {
  314. .interval = 1,
  315. .history_len = 8,
  316. .gd = 0x00000000,
  317. .gp = 0x00000000,
  318. .gr = 0x00020000,
  319. .itarget = 0x00000000
  320. };
  321. /* Alloc & initialize state */
  322. wf_smu_slots_fans = kmalloc(sizeof(struct wf_smu_slots_fans_state),
  323. GFP_KERNEL);
  324. if (wf_smu_slots_fans == NULL) {
  325. printk(KERN_WARNING "windfarm: Memory allocation error"
  326. " max fan speed\n");
  327. goto fail;
  328. }
  329. wf_smu_slots_fans->ticks = 1;
  330. /* Fill PID params */
  331. param.additive = (fan_slots->type == WF_CONTROL_RPM_FAN);
  332. param.min = wf_control_get_min(fan_slots);
  333. param.max = wf_control_get_max(fan_slots);
  334. wf_pid_init(&wf_smu_slots_fans->pid, &param);
  335. DBG("wf: Slots Fan control initialized.\n");
  336. DBG(" itarged=%d.%03d, min=%d RPM, max=%d RPM\n",
  337. FIX32TOPRINT(param.itarget), param.min, param.max);
  338. return;
  339. fail:
  340. if (fan_slots)
  341. wf_control_set_max(fan_slots);
  342. }
  343. static void wf_smu_slots_fans_tick(struct wf_smu_slots_fans_state *st)
  344. {
  345. s32 new_setpoint, power;
  346. int rc;
  347. if (--st->ticks != 0) {
  348. if (wf_smu_readjust)
  349. goto readjust;
  350. return;
  351. }
  352. st->ticks = st->pid.param.interval;
  353. rc = wf_sensor_get(sensor_slots_power, &power);
  354. if (rc) {
  355. printk(KERN_WARNING "windfarm: Slots power sensor error %d\n",
  356. rc);
  357. wf_smu_failure_state |= FAILURE_SENSOR;
  358. return;
  359. }
  360. DBG("wf_smu: Slots Fans tick ! Slots power: %d.%03d\n",
  361. FIX32TOPRINT(power));
  362. #if 0 /* Check what makes a good overtemp condition */
  363. if (power > (st->pid.param.itarget + 0x50000))
  364. wf_smu_failure_state |= FAILURE_OVERTEMP;
  365. #endif
  366. new_setpoint = wf_pid_run(&st->pid, power);
  367. DBG("wf_smu: new_setpoint: %d\n", (int)new_setpoint);
  368. if (st->setpoint == new_setpoint)
  369. return;
  370. st->setpoint = new_setpoint;
  371. readjust:
  372. if (fan_slots && wf_smu_failure_state == 0) {
  373. rc = wf_control_set(fan_slots, st->setpoint);
  374. if (rc) {
  375. printk(KERN_WARNING "windfarm: Slots fan error %d\n",
  376. rc);
  377. wf_smu_failure_state |= FAILURE_FAN;
  378. }
  379. }
  380. }
  381. /*
  382. * ****** Setup / Init / Misc ... ******
  383. *
  384. */
  385. static void wf_smu_tick(void)
  386. {
  387. unsigned int last_failure = wf_smu_failure_state;
  388. unsigned int new_failure;
  389. if (!wf_smu_started) {
  390. DBG("wf: creating control loops !\n");
  391. wf_smu_create_drive_fans();
  392. wf_smu_create_slots_fans();
  393. wf_smu_create_cpu_fans();
  394. wf_smu_started = true;
  395. }
  396. /* Skipping ticks */
  397. if (wf_smu_skipping && --wf_smu_skipping)
  398. return;
  399. wf_smu_failure_state = 0;
  400. if (wf_smu_drive_fans)
  401. wf_smu_drive_fans_tick(wf_smu_drive_fans);
  402. if (wf_smu_slots_fans)
  403. wf_smu_slots_fans_tick(wf_smu_slots_fans);
  404. if (wf_smu_cpu_fans)
  405. wf_smu_cpu_fans_tick(wf_smu_cpu_fans);
  406. wf_smu_readjust = 0;
  407. new_failure = wf_smu_failure_state & ~last_failure;
  408. /* If entering failure mode, clamp cpufreq and ramp all
  409. * fans to full speed.
  410. */
  411. if (wf_smu_failure_state && !last_failure) {
  412. if (cpufreq_clamp)
  413. wf_control_set_max(cpufreq_clamp);
  414. if (fan_cpu_main)
  415. wf_control_set_max(fan_cpu_main);
  416. if (fan_cpu_second)
  417. wf_control_set_max(fan_cpu_second);
  418. if (fan_cpu_third)
  419. wf_control_set_max(fan_cpu_third);
  420. if (fan_hd)
  421. wf_control_set_max(fan_hd);
  422. if (fan_slots)
  423. wf_control_set_max(fan_slots);
  424. }
  425. /* If leaving failure mode, unclamp cpufreq and readjust
  426. * all fans on next iteration
  427. */
  428. if (!wf_smu_failure_state && last_failure) {
  429. if (cpufreq_clamp)
  430. wf_control_set_min(cpufreq_clamp);
  431. wf_smu_readjust = 1;
  432. }
  433. /* Overtemp condition detected, notify and start skipping a couple
  434. * ticks to let the temperature go down
  435. */
  436. if (new_failure & FAILURE_OVERTEMP) {
  437. wf_set_overtemp();
  438. wf_smu_skipping = 2;
  439. wf_smu_overtemp = true;
  440. }
  441. /* We only clear the overtemp condition if overtemp is cleared
  442. * _and_ no other failure is present. Since a sensor error will
  443. * clear the overtemp condition (can't measure temperature) at
  444. * the control loop levels, but we don't want to keep it clear
  445. * here in this case
  446. */
  447. if (!wf_smu_failure_state && wf_smu_overtemp) {
  448. wf_clear_overtemp();
  449. wf_smu_overtemp = false;
  450. }
  451. }
  452. static void wf_smu_new_control(struct wf_control *ct)
  453. {
  454. if (wf_smu_all_controls_ok)
  455. return;
  456. if (fan_cpu_main == NULL && !strcmp(ct->name, "cpu-rear-fan-0")) {
  457. if (wf_get_control(ct) == 0)
  458. fan_cpu_main = ct;
  459. }
  460. if (fan_cpu_second == NULL && !strcmp(ct->name, "cpu-rear-fan-1")) {
  461. if (wf_get_control(ct) == 0)
  462. fan_cpu_second = ct;
  463. }
  464. if (fan_cpu_third == NULL && !strcmp(ct->name, "cpu-front-fan-0")) {
  465. if (wf_get_control(ct) == 0)
  466. fan_cpu_third = ct;
  467. }
  468. if (cpufreq_clamp == NULL && !strcmp(ct->name, "cpufreq-clamp")) {
  469. if (wf_get_control(ct) == 0)
  470. cpufreq_clamp = ct;
  471. }
  472. if (fan_hd == NULL && !strcmp(ct->name, "drive-bay-fan")) {
  473. if (wf_get_control(ct) == 0)
  474. fan_hd = ct;
  475. }
  476. if (fan_slots == NULL && !strcmp(ct->name, "slots-fan")) {
  477. if (wf_get_control(ct) == 0)
  478. fan_slots = ct;
  479. }
  480. if (fan_cpu_main && (fan_cpu_second || fan_cpu_third) && fan_hd &&
  481. fan_slots && cpufreq_clamp)
  482. wf_smu_all_controls_ok = 1;
  483. }
  484. static void wf_smu_new_sensor(struct wf_sensor *sr)
  485. {
  486. if (wf_smu_all_sensors_ok)
  487. return;
  488. if (sensor_cpu_power == NULL && !strcmp(sr->name, "cpu-power")) {
  489. if (wf_get_sensor(sr) == 0)
  490. sensor_cpu_power = sr;
  491. }
  492. if (sensor_cpu_temp == NULL && !strcmp(sr->name, "cpu-temp")) {
  493. if (wf_get_sensor(sr) == 0)
  494. sensor_cpu_temp = sr;
  495. }
  496. if (sensor_hd_temp == NULL && !strcmp(sr->name, "hd-temp")) {
  497. if (wf_get_sensor(sr) == 0)
  498. sensor_hd_temp = sr;
  499. }
  500. if (sensor_slots_power == NULL && !strcmp(sr->name, "slots-power")) {
  501. if (wf_get_sensor(sr) == 0)
  502. sensor_slots_power = sr;
  503. }
  504. if (sensor_cpu_power && sensor_cpu_temp &&
  505. sensor_hd_temp && sensor_slots_power)
  506. wf_smu_all_sensors_ok = 1;
  507. }
  508. static int wf_smu_notify(struct notifier_block *self,
  509. unsigned long event, void *data)
  510. {
  511. switch(event) {
  512. case WF_EVENT_NEW_CONTROL:
  513. DBG("wf: new control %s detected\n",
  514. ((struct wf_control *)data)->name);
  515. wf_smu_new_control(data);
  516. wf_smu_readjust = 1;
  517. break;
  518. case WF_EVENT_NEW_SENSOR:
  519. DBG("wf: new sensor %s detected\n",
  520. ((struct wf_sensor *)data)->name);
  521. wf_smu_new_sensor(data);
  522. break;
  523. case WF_EVENT_TICK:
  524. if (wf_smu_all_controls_ok && wf_smu_all_sensors_ok)
  525. wf_smu_tick();
  526. }
  527. return 0;
  528. }
  529. static struct notifier_block wf_smu_events = {
  530. .notifier_call = wf_smu_notify,
  531. };
  532. static int wf_init_pm(void)
  533. {
  534. printk(KERN_INFO "windfarm: Initializing for Desktop G5 model\n");
  535. return 0;
  536. }
  537. static int wf_smu_probe(struct platform_device *ddev)
  538. {
  539. wf_register_client(&wf_smu_events);
  540. return 0;
  541. }
  542. static int wf_smu_remove(struct platform_device *ddev)
  543. {
  544. wf_unregister_client(&wf_smu_events);
  545. /* XXX We don't have yet a guarantee that our callback isn't
  546. * in progress when returning from wf_unregister_client, so
  547. * we add an arbitrary delay. I'll have to fix that in the core
  548. */
  549. msleep(1000);
  550. /* Release all sensors */
  551. /* One more crappy race: I don't think we have any guarantee here
  552. * that the attribute callback won't race with the sensor beeing
  553. * disposed of, and I'm not 100% certain what best way to deal
  554. * with that except by adding locks all over... I'll do that
  555. * eventually but heh, who ever rmmod this module anyway ?
  556. */
  557. if (sensor_cpu_power)
  558. wf_put_sensor(sensor_cpu_power);
  559. if (sensor_cpu_temp)
  560. wf_put_sensor(sensor_cpu_temp);
  561. if (sensor_hd_temp)
  562. wf_put_sensor(sensor_hd_temp);
  563. if (sensor_slots_power)
  564. wf_put_sensor(sensor_slots_power);
  565. /* Release all controls */
  566. if (fan_cpu_main)
  567. wf_put_control(fan_cpu_main);
  568. if (fan_cpu_second)
  569. wf_put_control(fan_cpu_second);
  570. if (fan_cpu_third)
  571. wf_put_control(fan_cpu_third);
  572. if (fan_hd)
  573. wf_put_control(fan_hd);
  574. if (fan_slots)
  575. wf_put_control(fan_slots);
  576. if (cpufreq_clamp)
  577. wf_put_control(cpufreq_clamp);
  578. /* Destroy control loops state structures */
  579. kfree(wf_smu_slots_fans);
  580. kfree(wf_smu_drive_fans);
  581. kfree(wf_smu_cpu_fans);
  582. return 0;
  583. }
  584. static struct platform_driver wf_smu_driver = {
  585. .probe = wf_smu_probe,
  586. .remove = wf_smu_remove,
  587. .driver = {
  588. .name = "windfarm",
  589. },
  590. };
  591. static int __init wf_smu_init(void)
  592. {
  593. int rc = -ENODEV;
  594. if (of_machine_is_compatible("PowerMac9,1"))
  595. rc = wf_init_pm();
  596. if (rc == 0) {
  597. #ifdef MODULE
  598. request_module("windfarm_smu_controls");
  599. request_module("windfarm_smu_sensors");
  600. request_module("windfarm_lm75_sensor");
  601. request_module("windfarm_cpufreq_clamp");
  602. #endif /* MODULE */
  603. platform_driver_register(&wf_smu_driver);
  604. }
  605. return rc;
  606. }
  607. static void __exit wf_smu_exit(void)
  608. {
  609. platform_driver_unregister(&wf_smu_driver);
  610. }
  611. module_init(wf_smu_init);
  612. module_exit(wf_smu_exit);
  613. MODULE_AUTHOR("Benjamin Herrenschmidt <benh@kernel.crashing.org>");
  614. MODULE_DESCRIPTION("Thermal control logic for PowerMac9,1");
  615. MODULE_LICENSE("GPL");
  616. MODULE_ALIAS("platform:windfarm");