Annotation of sys/arch/macppc/dev/smu.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: smu.c,v 1.19 2007/05/20 23:38:52 thib Exp $ */
2:
3: /*
4: * Copyright (c) 2005 Mark Kettenis
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <sys/param.h>
20: #include <sys/systm.h>
21: #include <sys/device.h>
22: #include <sys/kernel.h>
23: #include <sys/rwlock.h>
24: #include <sys/proc.h>
25: #include <sys/sensors.h>
26:
27: #include <machine/autoconf.h>
28: #include <machine/cpu.h>
29:
30: #include <dev/clock_subr.h>
31: #include <dev/i2c/i2cvar.h>
32: #include <dev/ofw/openfirm.h>
33:
34: #include <arch/macppc/dev/maci2cvar.h>
35:
36: int smu_match(struct device *, void *, void *);
37: void smu_attach(struct device *, struct device *, void *);
38:
39: #define SMU_MAXFANS 3
40:
41: struct smu_fan {
42: u_int8_t reg;
43: u_int16_t min_rpm;
44: u_int16_t max_rpm;
45: u_int16_t unmanaged_rpm;
46: struct ksensor sensor;
47: };
48:
49: #define SMU_MAXSENSORS 3
50:
51: struct smu_sensor {
52: u_int8_t reg;
53: struct ksensor sensor;
54: };
55:
56: struct smu_softc {
57: struct device sc_dev;
58:
59: /* SMU command buffer. */
60: bus_dma_tag_t sc_dmat;
61: bus_dmamap_t sc_cmdmap;
62: bus_dma_segment_t sc_cmdseg[1];
63: caddr_t sc_cmd;
64: struct rwlock sc_lock;
65:
66: /* Doorbell and mailbox. */
67: struct ppc_bus_space sc_mem_bus_space;
68: bus_space_tag_t sc_memt;
69: bus_space_handle_t sc_gpioh;
70: bus_space_handle_t sc_buffh;
71:
72: struct smu_fan sc_fans[SMU_MAXFANS];
73: int sc_num_fans;
74:
75: struct smu_sensor sc_sensors[SMU_MAXSENSORS];
76: int sc_num_sensors;
77:
78: struct ksensordev sc_sensordev;
79:
80: u_int16_t sc_cpu_diode_scale;
81: int16_t sc_cpu_diode_offset;
82: u_int16_t sc_cpu_volt_scale;
83: int16_t sc_cpu_volt_offset;
84: u_int16_t sc_cpu_curr_scale;
85: int16_t sc_cpu_curr_offset;
86:
87: struct i2c_controller sc_i2c_tag;
88: };
89:
90: struct cfattach smu_ca = {
91: sizeof(struct smu_softc), smu_match, smu_attach
92: };
93:
94: struct cfdriver smu_cd = {
95: NULL, "smu", DV_DULL,
96: };
97:
98: /* SMU command */
99: struct smu_cmd {
100: u_int8_t cmd;
101: u_int8_t len;
102: u_int8_t data[254];
103: };
104: #define SMU_CMDSZ sizeof(struct smu_cmd)
105:
106: /* RTC */
107: #define SMU_RTC 0x8e
108: #define SMU_RTC_SET_DATETIME 0x80
109: #define SMU_RTC_GET_DATETIME 0x81
110:
111: /* ADC */
112: #define SMU_ADC 0xd8
113:
114: /* Fan control */
115: #define SMU_FAN 0x4a
116:
117: /* Data partitions */
118: #define SMU_PARTITION 0x3e
119: #define SMU_PARTITION_LATEST 0x01
120: #define SMU_PARTITION_BASE 0x02
121: #define SMU_PARTITION_UPDATE 0x03
122:
123: /* I2C */
124: #define SMU_I2C 0x9a
125: #define SMU_I2C_SIMPLE 0x00
126: #define SMU_I2C_NORMAL 0x01
127: #define SMU_I2C_COMBINED 0x02
128:
129: /* Power Management */
130: #define SMU_POWER 0xaa
131:
132: /* Miscellaneous */
133: #define SMU_MISC 0xee
134: #define SMU_MISC_GET_DATA 0x02
135:
136: int smu_intr(void *);
137:
138: int smu_do_cmd(struct smu_softc *, int);
139: int smu_time_read(time_t *);
140: int smu_time_write(time_t);
141: int smu_get_datablock(struct smu_softc *sc, u_int8_t, u_int8_t *, size_t);
142: int smu_fan_set_rpm(struct smu_softc *, struct smu_fan *, u_int16_t);
143: int smu_fan_refresh(struct smu_softc *, struct smu_fan *);
144: int smu_sensor_refresh(struct smu_softc *, struct smu_sensor *);
145: void smu_refresh_sensors(void *);
146:
147: int smu_i2c_acquire_bus(void *, int);
148: void smu_i2c_release_bus(void *, int);
149: int smu_i2c_exec(void *, i2c_op_t, i2c_addr_t,
150: const void *, size_t, void *buf, size_t, int);
151:
152: void smu_slew_voltage(u_int);
153:
154: #define GPIO_DDR 0x04 /* Data direction */
155: #define GPIO_DDR_OUTPUT 0x04 /* Output */
156: #define GPIO_DDR_INPUT 0x00 /* Input */
157:
158: #define GPIO_LEVEL 0x02 /* Pin level (RO) */
159:
160: #define GPIO_DATA 0x01 /* Data */
161:
162: int
163: smu_match(struct device *parent, void *cf, void *aux)
164: {
165: struct confargs *ca = aux;
166:
167: if (strcmp(ca->ca_name, "smu") == 0)
168: return (1);
169: return (0);
170: }
171:
172: /* XXX */
173: extern struct powerpc_bus_dma_tag pci_bus_dma_tag;
174:
175: void
176: smu_attach(struct device *parent, struct device *self, void *aux)
177: {
178: struct smu_softc *sc = (struct smu_softc *)self;
179: struct confargs *ca = aux;
180: struct i2cbus_attach_args iba;
181: struct smu_fan *fan;
182: struct smu_sensor *sensor;
183: int nseg, node;
184: char type[32], loc[32];
185: u_int32_t reg, intr, gpio, val;
186: u_int8_t data[12];
187:
188: /* XXX */
189: sc->sc_mem_bus_space.bus_base = 0x80000000;
190: sc->sc_mem_bus_space.bus_size = 0;
191: sc->sc_mem_bus_space.bus_io = 0;
192: sc->sc_memt = &sc->sc_mem_bus_space;
193:
194: /* Map smu-doorbell gpio. */
195: if (OF_getprop(ca->ca_node, "platform-doorbell-ack",
196: &node, sizeof node) <= 0 ||
197: OF_getprop(node, "reg", ®, sizeof reg) <= 0 ||
198: OF_getprop(node, "interrupts", &intr, sizeof intr) <= 0 ||
199: OF_getprop(OF_parent(node), "reg", &gpio, sizeof gpio) <= 0) {
200: printf(": cannot find smu-doorbell gpio\n");
201: return;
202: }
203: if (bus_space_map(sc->sc_memt, gpio + reg, 1, 0, &sc->sc_gpioh)) {
204: printf(": cannot map smu-doorbell gpio\n");
205: return;
206: }
207:
208: /* XXX Should get this from OF. */
209: if (bus_space_map(sc->sc_memt, 0x860c, 4, 0, &sc->sc_buffh)) {
210: printf(": cannot map smu-doorbell buffer\n");
211: return;
212: }
213:
214: /* XXX */
215: sc->sc_dmat = &pci_bus_dma_tag;
216:
217: /* Allocate and map SMU command buffer. */
218: if (bus_dmamem_alloc(sc->sc_dmat, SMU_CMDSZ, 0, 0,
219: sc->sc_cmdseg, 1, &nseg, BUS_DMA_NOWAIT)) {
220: printf(": cannot allocate cmd buffer\n");
221: return;
222: }
223: if (bus_dmamem_map(sc->sc_dmat, sc->sc_cmdseg, nseg,
224: SMU_CMDSZ, &sc->sc_cmd, BUS_DMA_NOWAIT)) {
225: printf(": cannot map cmd buffer\n");
226: bus_dmamem_free(sc->sc_dmat, sc->sc_cmdseg, 1);
227: return;
228: }
229: if (bus_dmamap_create(sc->sc_dmat, SMU_CMDSZ, 1, SMU_CMDSZ, 0,
230: BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW, &sc->sc_cmdmap)) {
231: printf(": cannot create cmd dmamap\n");
232: bus_dmamem_unmap(sc->sc_dmat, sc->sc_cmd, SMU_CMDSZ);
233: bus_dmamem_free(sc->sc_dmat, sc->sc_cmdseg, 1);
234: return;
235: }
236: if (bus_dmamap_load(sc->sc_dmat, sc->sc_cmdmap, sc->sc_cmd,
237: SMU_CMDSZ, NULL, BUS_DMA_NOWAIT)) {
238: printf(": cannot load cmd dmamap\n");
239: bus_dmamap_destroy(sc->sc_dmat, sc->sc_cmdmap);
240: bus_dmamem_unmap(sc->sc_dmat, sc->sc_cmd, SMU_CMDSZ);
241: bus_dmamem_free(sc->sc_dmat, sc->sc_cmdseg, nseg);
242: return;
243: }
244:
245: rw_init(&sc->sc_lock, sc->sc_dev.dv_xname);
246:
247: /* Establish smu-doorbell interrupt. */
248: mac_intr_establish(parent, intr, IST_EDGE, IPL_BIO,
249: smu_intr, sc, sc->sc_dev.dv_xname);
250:
251: /* Initialize global variables that control RTC functionality. */
252: time_read = smu_time_read;
253: time_write = smu_time_write;
254:
255: /* Fans */
256: node = OF_getnodebyname(ca->ca_node, "rpm-fans");
257: if (node == 0)
258: node = OF_getnodebyname(ca->ca_node, "fans");
259: for (node = OF_child(node); node; node = OF_peer(node)) {
260: if (OF_getprop(node, "reg", ®, sizeof reg) <= 0 ||
261: OF_getprop(node, "device_type", type, sizeof type) <= 0)
262: continue;
263:
264: if (strcmp(type, "fan-rpm-control") != 0) {
265: printf(": unsupported fan type: %s\n", type);
266: return;
267: }
268:
269: if (sc->sc_num_fans >= SMU_MAXFANS) {
270: printf(": too many fans\n");
271: return;
272: }
273:
274: fan = &sc->sc_fans[sc->sc_num_fans++];
275: fan->sensor.type = SENSOR_FANRPM;
276: fan->sensor.flags = SENSOR_FINVALID;
277: fan->reg = reg;
278:
279: if (OF_getprop(node, "min-value", &val, sizeof val) <= 0)
280: val = 0;
281: fan->min_rpm = val;
282: if (OF_getprop(node, "max-value", &val, sizeof val) <= 0)
283: val = 0xffff;
284: fan->max_rpm = val;
285: if (OF_getprop(node, "unmanage-value", &val, sizeof val) <= 0)
286: val = fan->max_rpm;
287: fan->unmanaged_rpm = val;
288:
289: if (OF_getprop(node, "location", loc, sizeof loc) <= 0)
290: strlcpy(loc, "Unknown", sizeof loc);
291: strlcpy(fan->sensor.desc, loc, sizeof sensor->sensor.desc);
292:
293: /* Start running fans at their "unmanaged" speed. */
294: smu_fan_set_rpm(sc, fan, fan->unmanaged_rpm);
295:
296: sensor_attach(&sc->sc_sensordev, &fan->sensor);
297: }
298:
299: /*
300: * Bail out if we didn't find any fans. If we don't set the
301: * fans to a safe speed, but tickle the SMU periodically by
302: * reading sensors, the fans will never spin up and the
303: * machine might overheat.
304: */
305: if (sc->sc_num_fans == 0) {
306: printf(": no fans\n");
307: return;
308: }
309:
310: /* Sensors */
311: node = OF_getnodebyname(ca->ca_node, "sensors");
312: for (node = OF_child(node); node; node = OF_peer(node)) {
313: if (OF_getprop(node, "reg", &val, sizeof val) <= 0 ||
314: OF_getprop(node, "device_type", type, sizeof type) <= 0)
315: continue;
316:
317: sensor = &sc->sc_sensors[sc->sc_num_sensors++];
318: sensor->sensor.flags = SENSOR_FINVALID;
319: sensor->reg = val;
320:
321: if (strcmp(type, "current-sensor") == 0) {
322: sensor->sensor.type = SENSOR_AMPS;
323: } else if (strcmp(type, "temp-sensor") == 0) {
324: sensor->sensor.type = SENSOR_TEMP;
325: } else if (strcmp(type, "voltage-sensor") == 0) {
326: sensor->sensor.type = SENSOR_VOLTS_DC;
327: } else {
328: sensor->sensor.type = SENSOR_INTEGER;
329: }
330:
331: if (OF_getprop(node, "location", loc, sizeof loc) <= 0)
332: strlcpy(loc, "Unknown", sizeof loc);
333: strlcpy(sensor->sensor.desc, loc, sizeof sensor->sensor.desc);
334:
335: sensor_attach(&sc->sc_sensordev, &sensor->sensor);
336: }
337:
338: /* Register sensor device with sysctl */
339: strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
340: sizeof(sc->sc_sensordev.xname));
341: sensordev_install(&sc->sc_sensordev);
342:
343: /* CPU temperature diode calibration */
344: smu_get_datablock(sc, 0x18, data, sizeof data);
345: sc->sc_cpu_diode_scale = (data[4] << 8) + data[5];
346: sc->sc_cpu_diode_offset = (data[6] << 8) + data[7];
347:
348: /* CPU power (voltage and current) calibration */
349: smu_get_datablock(sc, 0x21, data, sizeof data);
350: sc->sc_cpu_volt_scale = (data[4] << 8) + data[5];
351: sc->sc_cpu_volt_offset = (data[6] << 8) + data[7];
352: sc->sc_cpu_curr_scale = (data[8] << 8) + data[9];
353: sc->sc_cpu_curr_offset = (data[10] << 8) + data[11];
354:
355: sensor_task_register(sc, smu_refresh_sensors, 5);
356: printf("\n");
357:
358: ppc64_slew_voltage = smu_slew_voltage;
359:
360: sc->sc_i2c_tag.ic_cookie = sc;
361: sc->sc_i2c_tag.ic_acquire_bus = smu_i2c_acquire_bus;
362: sc->sc_i2c_tag.ic_release_bus = smu_i2c_release_bus;
363: sc->sc_i2c_tag.ic_exec = smu_i2c_exec;
364:
365: node = OF_getnodebyname(ca->ca_node, "smu-i2c-control");
366: node = OF_child(node);
367:
368: bzero(&iba, sizeof iba);
369: iba.iba_name = "iic";
370: iba.iba_tag = &sc->sc_i2c_tag;
371: iba.iba_bus_scan = maciic_scan;
372: iba.iba_bus_scan_arg = &node;
373: config_found(&sc->sc_dev, &iba, NULL);
374: }
375:
376: int
377: smu_intr(void *arg)
378: {
379: wakeup(arg);
380: return 1;
381: }
382:
383: int
384: smu_do_cmd(struct smu_softc *sc, int timo)
385: {
386: struct smu_cmd *cmd = (struct smu_cmd *)sc->sc_cmd;
387: u_int8_t gpio, ack = ~cmd->cmd;
388: int error;
389:
390: /* Write to mailbox. */
391: bus_space_write_4(sc->sc_memt, sc->sc_buffh, 0,
392: sc->sc_cmdmap->dm_segs->ds_addr);
393:
394: /* Flush to RAM. */
395: asm __volatile__ ("dcbst 0,%0; sync" :: "r"(sc->sc_cmd): "memory");
396:
397: /* Ring doorbell. */
398: bus_space_write_1(sc->sc_memt, sc->sc_gpioh, 0, GPIO_DDR_OUTPUT);
399:
400: do {
401: error = tsleep(sc, PWAIT, "smu", (timo * hz) / 1000);
402: if (error)
403: return (error);
404: gpio = bus_space_read_1(sc->sc_memt, sc->sc_gpioh, 0);
405: } while (!(gpio & (GPIO_DATA)));
406:
407: /* CPU might have brought back the cache line. */
408: asm __volatile__ ("dcbf 0,%0; sync" :: "r"(sc->sc_cmd) : "memory");
409:
410: if (cmd->cmd != ack)
411: return (EIO);
412: return (0);
413: }
414:
415: int
416: smu_time_read(time_t *secs)
417: {
418: struct smu_softc *sc = smu_cd.cd_devs[0];
419: struct smu_cmd *cmd = (struct smu_cmd *)sc->sc_cmd;
420: struct clock_ymdhms dt;
421: int error;
422:
423: rw_enter_write(&sc->sc_lock);
424:
425: cmd->cmd = SMU_RTC;
426: cmd->len = 1;
427: cmd->data[0] = SMU_RTC_GET_DATETIME;
428: error = smu_do_cmd(sc, 800);
429: if (error) {
430: rw_exit_write(&sc->sc_lock);
431:
432: *secs = 0;
433: return (error);
434: }
435:
436: dt.dt_year = 2000 + FROMBCD(cmd->data[6]);
437: dt.dt_mon = FROMBCD(cmd->data[5]);
438: dt.dt_day = FROMBCD(cmd->data[4]);
439: dt.dt_hour = FROMBCD(cmd->data[2]);
440: dt.dt_min = FROMBCD(cmd->data[1]);
441: dt.dt_sec = FROMBCD(cmd->data[0]);
442:
443: rw_exit_write(&sc->sc_lock);
444:
445: *secs = clock_ymdhms_to_secs(&dt);
446: return (0);
447: }
448:
449: int
450: smu_time_write(time_t secs)
451: {
452: struct smu_softc *sc = smu_cd.cd_devs[0];
453: struct smu_cmd *cmd = (struct smu_cmd *)sc->sc_cmd;
454: struct clock_ymdhms dt;
455: int error;
456:
457: clock_secs_to_ymdhms(secs, &dt);
458:
459: rw_enter_write(&sc->sc_lock);
460:
461: cmd->cmd = SMU_RTC;
462: cmd->len = 8;
463: cmd->data[0] = SMU_RTC_SET_DATETIME;
464: cmd->data[1] = TOBCD(dt.dt_sec);
465: cmd->data[2] = TOBCD(dt.dt_min);
466: cmd->data[3] = TOBCD(dt.dt_hour);
467: cmd->data[4] = TOBCD(dt.dt_wday);
468: cmd->data[5] = TOBCD(dt.dt_day);
469: cmd->data[6] = TOBCD(dt.dt_mon);
470: cmd->data[7] = TOBCD(dt.dt_year - 2000);
471: error = smu_do_cmd(sc, 800);
472:
473: rw_exit_write(&sc->sc_lock);
474:
475: return (error);
476: }
477:
478:
479: int
480: smu_get_datablock(struct smu_softc *sc, u_int8_t id, u_int8_t *buf, size_t len)
481: {
482: struct smu_cmd *cmd = (struct smu_cmd *)sc->sc_cmd;
483: u_int8_t addr[4];
484: int error;
485:
486: cmd->cmd = SMU_PARTITION;
487: cmd->len = 2;
488: cmd->data[0] = SMU_PARTITION_LATEST;
489: cmd->data[1] = id;
490: error = smu_do_cmd(sc, 800);
491: if (error)
492: return (error);
493:
494: addr[0] = 0x00;
495: addr[1] = 0x00;
496: addr[2] = cmd->data[0];
497: addr[3] = cmd->data[1];
498:
499: cmd->cmd = SMU_MISC;
500: cmd->len = 7;
501: cmd->data[0] = SMU_MISC_GET_DATA;
502: cmd->data[1] = sizeof(u_int32_t);
503: cmd->data[2] = addr[0];
504: cmd->data[3] = addr[1];
505: cmd->data[4] = addr[2];
506: cmd->data[5] = addr[3];
507: cmd->data[6] = len;
508: error = smu_do_cmd(sc, 800);
509: if (error)
510: return (error);
511:
512: memcpy(buf, cmd->data, len);
513: return (0);
514: }
515:
516: int
517: smu_fan_set_rpm(struct smu_softc *sc, struct smu_fan *fan, u_int16_t rpm)
518: {
519: struct smu_cmd *cmd = (struct smu_cmd *)sc->sc_cmd;
520:
521: /*
522: * On the PowerMac8,2 this command expects the requested fan
523: * speed at a different location in the command block than on
524: * the PowerMac8,1. We simply store the value at both
525: * locations.
526: */
527: cmd->cmd = SMU_FAN;
528: cmd->len = 14;
529: cmd->data[0] = 0x00; /* fan-rpm-control */
530: cmd->data[1] = 0x01 << fan->reg;
531: cmd->data[2] = cmd->data[2 + fan->reg * 2] = (rpm >> 8) & 0xff;
532: cmd->data[3] = cmd->data[3 + fan->reg * 2] = (rpm & 0xff);
533: return smu_do_cmd(sc, 800);
534: }
535:
536: int
537: smu_fan_refresh(struct smu_softc *sc, struct smu_fan *fan)
538: {
539: struct smu_cmd *cmd = (struct smu_cmd *)sc->sc_cmd;
540: int error;
541:
542: cmd->cmd = SMU_FAN;
543: cmd->len = 2;
544: cmd->data[0] = 0x01; /* fan-rpm-control */
545: cmd->data[1] = 0x01 << fan->reg;
546: error = smu_do_cmd(sc, 800);
547: if (error) {
548: fan->sensor.flags = SENSOR_FINVALID;
549: return (error);
550: }
551: fan->sensor.value = (cmd->data[1] << 8) + cmd->data[2];
552: fan->sensor.flags = 0;
553: return (0);
554: }
555:
556: int
557: smu_sensor_refresh(struct smu_softc *sc, struct smu_sensor *sensor)
558: {
559: struct smu_cmd *cmd = (struct smu_cmd *)sc->sc_cmd;
560: int64_t value;
561: int error;
562:
563: cmd->cmd = SMU_ADC;
564: cmd->len = 1;
565: cmd->data[0] = sensor->reg;
566: error = smu_do_cmd(sc, 800);
567: if (error) {
568: sensor->sensor.flags = SENSOR_FINVALID;
569: return (error);
570: }
571: value = (cmd->data[0] << 8) + cmd->data[1];
572: switch (sensor->sensor.type) {
573: case SENSOR_TEMP:
574: value *= sc->sc_cpu_diode_scale;
575: value >>= 3;
576: value += ((int64_t)sc->sc_cpu_diode_offset) << 9;
577: value <<= 1;
578:
579: /* Convert from 16.16 fixed point degC into muK. */
580: value *= 15625;
581: value /= 1024;
582: value += 273150000;
583: break;
584:
585: case SENSOR_VOLTS_DC:
586: value *= sc->sc_cpu_volt_scale;
587: value += sc->sc_cpu_volt_offset;
588: value <<= 4;
589:
590: /* Convert from 16.16 fixed point V into muV. */
591: value *= 15625;
592: value /= 1024;
593: break;
594:
595: case SENSOR_AMPS:
596: value *= sc->sc_cpu_curr_scale;
597: value += sc->sc_cpu_curr_offset;
598: value <<= 4;
599:
600: /* Convert from 16.16 fixed point A into muA. */
601: value *= 15625;
602: value /= 1024;
603: break;
604:
605: default:
606: break;
607: }
608: sensor->sensor.value = value;
609: sensor->sensor.flags = 0;
610: return (0);
611: }
612:
613: void
614: smu_refresh_sensors(void *arg)
615: {
616: struct smu_softc *sc = arg;
617: int i;
618:
619: rw_enter_write(&sc->sc_lock);
620: for (i = 0; i < sc->sc_num_sensors; i++)
621: smu_sensor_refresh(sc, &sc->sc_sensors[i]);
622: for (i = 0; i < sc->sc_num_fans; i++)
623: smu_fan_refresh(sc, &sc->sc_fans[i]);
624: rw_exit_write(&sc->sc_lock);
625: }
626:
627: int
628: smu_i2c_acquire_bus(void *cookie, int flags)
629: {
630: struct smu_softc *sc = cookie;
631:
632: if (flags & I2C_F_POLL)
633: return (0);
634:
635: return (rw_enter(&sc->sc_lock, RW_WRITE));
636: }
637:
638: void
639: smu_i2c_release_bus(void *cookie, int flags)
640: {
641: struct smu_softc *sc = cookie;
642:
643: if (flags & I2C_F_POLL)
644: return;
645:
646: rw_exit(&sc->sc_lock);
647: }
648:
649: int
650: smu_i2c_exec(void *cookie, i2c_op_t op, i2c_addr_t addr,
651: const void *cmdbuf, size_t cmdlen, void *buf, size_t len, int flags)
652: {
653: struct smu_softc *sc = cookie;
654: struct smu_cmd *cmd = (struct smu_cmd *)sc->sc_cmd;
655: u_int8_t smu_op = SMU_I2C_NORMAL;
656: int error, retries = 10;
657:
658: if (!I2C_OP_STOP_P(op) || cmdlen > 3 || len > 5)
659: return (EINVAL);
660:
661: if(cmdlen == 0)
662: smu_op = SMU_I2C_SIMPLE;
663: else if (I2C_OP_READ_P(op))
664: smu_op = SMU_I2C_COMBINED;
665:
666: cmd->cmd = SMU_I2C;
667: cmd->len = 9 + len;
668: cmd->data[0] = 0xb;
669: cmd->data[1] = smu_op;
670: cmd->data[2] = addr << 1;
671: cmd->data[3] = cmdlen;
672: memcpy (&cmd->data[4], cmdbuf, cmdlen);
673: cmd->data[7] = addr << 1 | I2C_OP_READ_P(op);
674: cmd->data[8] = len;
675: memcpy(&cmd->data[9], buf, len);
676:
677: error = smu_do_cmd(sc, 250);
678: if (error)
679: return error;
680:
681: while (retries--) {
682: cmd->cmd = SMU_I2C;
683: cmd->len = 1;
684: cmd->data[0] = 0;
685: memset(&cmd->data[1], 0xff, len);
686:
687: error = smu_do_cmd(sc, 250);
688: if (error)
689: return error;
690:
691: if ((cmd->data[0] & 0x80) == 0)
692: break;
693: if (cmd->data[0] == 0xfd)
694: break;
695:
696: DELAY(15 * 1000);
697: }
698:
699: if (cmd->data[0] & 0x80)
700: return (EIO);
701:
702: if (I2C_OP_READ_P(op))
703: memcpy(buf, &cmd->data[1], len);
704: return (0);
705: }
706:
707: void
708: smu_slew_voltage(u_int freq_scale)
709: {
710: struct smu_softc *sc = smu_cd.cd_devs[0];
711: struct smu_cmd *cmd = (struct smu_cmd *)sc->sc_cmd;
712:
713: cmd->cmd = SMU_POWER;
714: cmd->len = 8;
715: memcpy(cmd->data, "VSLEW", 5);
716: cmd->data[5] = 0xff;
717: cmd->data[6] = 1;
718: cmd->data[7] = freq_scale;
719:
720: smu_do_cmd(sc, 250);
721: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to smu.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / macppc / dev