2 * Copyright (c) 2000 Matthew C. Forman
4 * Based (heavily) on alpm.c which is:
6 * Copyright (c) 1998, 1999 Nicolas Souchu
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * $FreeBSD: src/sys/pci/amdpm.c,v 1.1.2.1 2001/10/10 12:10:26 murray Exp $
31 * $DragonFly: src/sys/dev/powermng/i386/amdpm/amdpm.c,v 1.4 2003/08/07 21:17:07 dillon Exp $
36 * Power management function/SMBus function support for the AMD 756 chip.
39 #include <sys/param.h>
40 #include <sys/kernel.h>
41 #include <sys/systm.h>
42 #include <sys/module.h>
46 #include <machine/bus_pio.h>
47 #include <machine/bus_memio.h>
48 #include <machine/bus.h>
49 #include <machine/clock.h>
50 #include <machine/resource.h>
53 #include <bus/pci/pcivar.h>
54 #include <bus/pci/pcireg.h>
56 #include <bus/iicbus/iiconf.h>
57 #include <bus/smbus/smbconf.h>
60 #define AMDPM_DEBUG(x) if (amdpm_debug) (x)
63 static int amdpm_debug = 1;
65 static int amdpm_debug = 0;
68 #define AMDPM_VENDORID_AMD 0x1022
69 #define AMDPM_DEVICEID_AMD756PM 0x740b
71 /* PCI Configuration space registers */
72 #define AMDPCI_PMBASE 0x58
74 #define AMDPCI_GEN_CONFIG_PM 0x41
75 #define AMDPCI_PMIOEN (1<<7)
77 #define AMDPCI_SCIINT_CONFIG_PM 0x42
78 #define AMDPCI_SCISEL_IRQ11 11
80 #define AMDPCI_REVID 0x08
84 * Base address programmed via AMDPCI_PMBASE.
86 #define AMDSMB_GLOBAL_STATUS 0xE0
87 #define AMDSMB_GS_TO_STS (1<<5)
88 #define AMDSMB_GS_HCYC_STS (1<<4)
89 #define AMDSMB_GS_HST_STS (1<<3)
90 #define AMDSMB_GS_PRERR_STS (1<<2)
91 #define AMDSMB_GS_COL_STS (1<<1)
92 #define AMDSMB_GS_ABRT_STS (1<<0)
93 #define AMDSMB_GS_CLEAR_STS (AMDSMB_GS_TO_STS|AMDSMB_GS_HCYC_STS|AMDSMB_GS_PRERR_STS|AMDSMB_GS_COL_STS|AMDSMB_GS_ABRT_STS)
95 #define AMDSMB_GLOBAL_ENABLE 0xE2
96 #define AMDSMB_GE_ABORT (1<<5)
97 #define AMDSMB_GE_HCYC_EN (1<<4)
98 #define AMDSMB_GE_HOST_STC (1<<3)
99 #define AMDSMB_GE_CYC_QUICK 0
100 #define AMDSMB_GE_CYC_BYTE 1
101 #define AMDSMB_GE_CYC_BDATA 2
102 #define AMDSMB_GE_CYC_WDATA 3
103 #define AMDSMB_GE_CYC_PROCCALL 4
104 #define AMDSMB_GE_CYC_BLOCK 5
106 #define AMDSMB_HSTADDR 0xE4
107 #define AMDSMB_HSTDATA 0xE6
108 #define AMDSMB_HSTCMD 0xE8
109 #define AMDSMB_HSTDFIFO 0xE9
110 #define AMDSMB_HSLVDATA 0xEA
111 #define AMDSMB_HSLVDA 0xEC
112 #define AMDSMB_HSLVDDR 0xEE
113 #define AMDSMB_SNPADDR 0xEF
118 struct resource *res;
119 bus_space_tag_t smbst;
120 bus_space_handle_t smbsh;
123 struct amdsmb_softc {
126 struct amdpm_softc *amdpm;
129 #define AMDPM_SMBINB(amdsmb,register) \
130 (bus_space_read_1(amdsmb->amdpm->smbst, amdsmb->amdpm->smbsh, register))
131 #define AMDPM_SMBOUTB(amdsmb,register,value) \
132 (bus_space_write_1(amdsmb->amdpm->smbst, amdsmb->amdpm->smbsh, register, value))
133 #define AMDPM_SMBINW(amdsmb,register) \
134 (bus_space_read_2(amdsmb->amdpm->smbst, amdsmb->amdpm->smbsh, register))
135 #define AMDPM_SMBOUTW(amdsmb,register,value) \
136 (bus_space_write_2(amdsmb->amdpm->smbst, amdsmb->amdpm->smbsh, register, value))
138 static int amdsmb_probe(device_t);
139 static int amdsmb_attach(device_t);
140 static int amdsmb_smb_callback(device_t, int, caddr_t *);
141 static int amdsmb_smb_quick(device_t dev, u_char slave, int how);
142 static int amdsmb_smb_sendb(device_t dev, u_char slave, char byte);
143 static int amdsmb_smb_recvb(device_t dev, u_char slave, char *byte);
144 static int amdsmb_smb_writeb(device_t dev, u_char slave, char cmd, char byte);
145 static int amdsmb_smb_readb(device_t dev, u_char slave, char cmd, char *byte);
146 static int amdsmb_smb_writew(device_t dev, u_char slave, char cmd, short word);
147 static int amdsmb_smb_readw(device_t dev, u_char slave, char cmd, short *word);
148 static int amdsmb_smb_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf);
149 static int amdsmb_smb_bread(device_t dev, u_char slave, char cmd, u_char count, char *byte);
151 static int amdpm_probe(device_t);
152 static int amdpm_attach(device_t);
156 amdpm_probe(device_t dev)
160 if ((pci_get_vendor(dev) == AMDPM_VENDORID_AMD) &&
161 (pci_get_device(dev) == AMDPM_DEVICEID_AMD756PM)) {
162 device_set_desc(dev, "AMD 756 Power Management Controller");
165 * We have to do this, since the BIOS won't give us the
166 * resource info (not mine, anyway).
168 base = pci_read_config(dev, AMDPCI_PMBASE, 4);
170 bus_set_resource(dev, SYS_RES_IOPORT, AMDPCI_PMBASE, base, 256);
177 amdpm_attach(device_t dev)
179 struct amdpm_softc *amdpm_sc = device_get_softc(dev);
181 int unit = device_get_unit(dev);
182 device_t smbinterface;
184 /* Enable I/O block access */
185 val_b = pci_read_config(dev, AMDPCI_GEN_CONFIG_PM, 1);
186 pci_write_config(dev, AMDPCI_GEN_CONFIG_PM, val_b | AMDPCI_PMIOEN, 1);
188 /* Allocate I/O space */
189 amdpm_sc->rid = AMDPCI_PMBASE;
190 amdpm_sc->res = bus_alloc_resource(dev, SYS_RES_IOPORT, &amdpm_sc->rid, 0, ~0, 1, RF_ACTIVE);
192 if (amdpm_sc->res == NULL) {
193 device_printf(dev, "could not map i/o space\n");
197 amdpm_sc->smbst = rman_get_bustag(amdpm_sc->res);
198 amdpm_sc->smbsh = rman_get_bushandle(amdpm_sc->res);
200 smbinterface = device_add_child(dev, "amdsmb", unit);
202 device_printf(dev, "could not add SMBus device\n");
204 device_probe_and_attach(smbinterface);
210 amdsmb_probe(device_t dev)
212 struct amdsmb_softc *amdsmb_sc = (struct amdsmb_softc *)device_get_softc(dev);
214 /* Allocate a new smbus device */
215 amdsmb_sc->smbus = smbus_alloc_bus(dev);
216 if (!amdsmb_sc->smbus)
219 device_set_desc(dev, "AMD 756 SMBus interface");
220 device_printf(dev, "AMD 756 SMBus interface\n");
226 amdsmb_attach(device_t dev)
228 struct amdsmb_softc *amdsmb_sc = (struct amdsmb_softc *)device_get_softc(dev);
230 amdsmb_sc->amdpm = device_get_softc(device_get_parent(dev));
232 /* Probe and attach the smbus */
233 device_probe_and_attach(amdsmb_sc->smbus);
239 amdsmb_smb_callback(device_t dev, int index, caddr_t *data)
244 case SMB_REQUEST_BUS:
245 case SMB_RELEASE_BUS:
255 amdsmb_clear(struct amdsmb_softc *sc)
257 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_STATUS, AMDSMB_GS_CLEAR_STS);
265 amdsmb_abort(struct amdsmb_softc *sc)
269 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
270 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, l | AMDSMB_GE_ABORT);
277 amdsmb_idle(struct amdsmb_softc *sc)
281 sts = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_STATUS);
283 AMDPM_DEBUG(printf("amdpm: busy? STS=0x%x\n", sts));
285 return (~(sts & AMDSMB_GS_HST_STS));
289 * Poll the SMBus controller
292 amdsmb_wait(struct amdsmb_softc *sc)
298 /* Wait for command to complete (SMBus controller is idle) */
301 sts = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_STATUS);
302 if (!(sts & AMDSMB_GS_HST_STS))
306 AMDPM_DEBUG(printf("amdpm: STS=0x%x (count=%d)\n", sts, count));
311 error |= SMB_ETIMEOUT;
313 if (sts & AMDSMB_GS_ABRT_STS)
316 if (sts & AMDSMB_GS_COL_STS)
319 if (sts & AMDSMB_GS_PRERR_STS)
320 error |= SMB_EBUSERR;
322 if (error != SMB_ENOERR)
329 amdsmb_smb_quick(device_t dev, u_char slave, int how)
331 struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
336 if (!amdsmb_idle(sc))
341 AMDPM_DEBUG(printf("amdpm: QWRITE to 0x%x", slave));
342 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave & ~LSB);
345 AMDPM_DEBUG(printf("amdpm: QREAD to 0x%x", slave));
346 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave | LSB);
349 panic("%s: unknown QUICK command (%x)!", __FUNCTION__, how);
351 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
352 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, (l & 0xfff8) | AMDSMB_GE_CYC_QUICK | AMDSMB_GE_HOST_STC);
354 error = amdsmb_wait(sc);
356 AMDPM_DEBUG(printf(", error=0x%x\n", error));
362 amdsmb_smb_sendb(device_t dev, u_char slave, char byte)
364 struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
369 if (!amdsmb_idle(sc))
372 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave & ~LSB);
373 AMDPM_SMBOUTW(sc, AMDSMB_HSTDATA, byte);
374 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
375 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, (l & 0xfff8) | AMDSMB_GE_CYC_BYTE | AMDSMB_GE_HOST_STC);
377 error = amdsmb_wait(sc);
379 AMDPM_DEBUG(printf("amdpm: SENDB to 0x%x, byte=0x%x, error=0x%x\n", slave, byte, error));
385 amdsmb_smb_recvb(device_t dev, u_char slave, char *byte)
387 struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
392 if (!amdsmb_idle(sc))
395 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave | LSB);
396 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
397 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, (l & 0xfff8) | AMDSMB_GE_CYC_BYTE | AMDSMB_GE_HOST_STC);
399 if ((error = amdsmb_wait(sc)) == SMB_ENOERR)
400 *byte = AMDPM_SMBINW(sc, AMDSMB_HSTDATA);
402 AMDPM_DEBUG(printf("amdpm: RECVB from 0x%x, byte=0x%x, error=0x%x\n", slave, *byte, error));
408 amdsmb_smb_writeb(device_t dev, u_char slave, char cmd, char byte)
410 struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
415 if (!amdsmb_idle(sc))
418 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave & ~LSB);
419 AMDPM_SMBOUTW(sc, AMDSMB_HSTDATA, byte);
420 AMDPM_SMBOUTB(sc, AMDSMB_HSTCMD, cmd);
421 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
422 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, (l & 0xfff8) | AMDSMB_GE_CYC_BDATA | AMDSMB_GE_HOST_STC);
424 error = amdsmb_wait(sc);
426 AMDPM_DEBUG(printf("amdpm: WRITEB to 0x%x, cmd=0x%x, byte=0x%x, error=0x%x\n", slave, cmd, byte, error));
432 amdsmb_smb_readb(device_t dev, u_char slave, char cmd, char *byte)
434 struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
439 if (!amdsmb_idle(sc))
442 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave | LSB);
443 AMDPM_SMBOUTB(sc, AMDSMB_HSTCMD, cmd);
444 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
445 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, (l & 0xfff8) | AMDSMB_GE_CYC_BDATA | AMDSMB_GE_HOST_STC);
447 if ((error = amdsmb_wait(sc)) == SMB_ENOERR)
448 *byte = AMDPM_SMBINW(sc, AMDSMB_HSTDATA);
450 AMDPM_DEBUG(printf("amdpm: READB from 0x%x, cmd=0x%x, byte=0x%x, error=0x%x\n", slave, cmd, *byte, error));
456 amdsmb_smb_writew(device_t dev, u_char slave, char cmd, short word)
458 struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
463 if (!amdsmb_idle(sc))
466 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave & ~LSB);
467 AMDPM_SMBOUTW(sc, AMDSMB_HSTDATA, word);
468 AMDPM_SMBOUTB(sc, AMDSMB_HSTCMD, cmd);
469 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
470 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, (l & 0xfff8) | AMDSMB_GE_CYC_WDATA | AMDSMB_GE_HOST_STC);
472 error = amdsmb_wait(sc);
474 AMDPM_DEBUG(printf("amdpm: WRITEW to 0x%x, cmd=0x%x, word=0x%x, error=0x%x\n", slave, cmd, word, error));
480 amdsmb_smb_readw(device_t dev, u_char slave, char cmd, short *word)
482 struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
487 if (!amdsmb_idle(sc))
490 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave | LSB);
491 AMDPM_SMBOUTB(sc, AMDSMB_HSTCMD, cmd);
492 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
493 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, (l & 0xfff8) | AMDSMB_GE_CYC_WDATA | AMDSMB_GE_HOST_STC);
495 if ((error = amdsmb_wait(sc)) == SMB_ENOERR)
496 *word = AMDPM_SMBINW(sc, AMDSMB_HSTDATA);
498 AMDPM_DEBUG(printf("amdpm: READW from 0x%x, cmd=0x%x, word=0x%x, error=0x%x\n", slave, cmd, *word, error));
504 amdsmb_smb_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf)
506 struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
507 u_char remain, len, i;
508 int error = SMB_ENOERR;
517 len = min(remain, 32);
519 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave & ~LSB);
522 * Do we have to reset the internal 32-byte buffer?
523 * Can't see how to do this from the data sheet.
526 AMDPM_SMBOUTW(sc, AMDSMB_HSTDATA, len);
528 /* Fill the 32-byte internal buffer */
529 for (i=0; i<len; i++) {
530 AMDPM_SMBOUTB(sc, AMDSMB_HSTDFIFO, buf[count-remain+i]);
533 AMDPM_SMBOUTB(sc, AMDSMB_HSTCMD, cmd);
534 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
535 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, (l & 0xfff8) | AMDSMB_GE_CYC_BLOCK | AMDSMB_GE_HOST_STC);
537 if ((error = amdsmb_wait(sc)) != SMB_ENOERR)
544 AMDPM_DEBUG(printf("amdpm: WRITEBLK to 0x%x, count=0x%x, cmd=0x%x, error=0x%x", slave, count, cmd, error));
550 amdsmb_smb_bread(device_t dev, u_char slave, char cmd, u_char count, char *buf)
552 struct amdsmb_softc *sc = (struct amdsmb_softc *)device_get_softc(dev);
553 u_char remain, len, i;
554 int error = SMB_ENOERR;
558 if (!amdsmb_idle(sc))
563 AMDPM_SMBOUTW(sc, AMDSMB_HSTADDR, slave | LSB);
565 AMDPM_SMBOUTB(sc, AMDSMB_HSTCMD, cmd);
567 l = AMDPM_SMBINW(sc, AMDSMB_GLOBAL_ENABLE);
568 AMDPM_SMBOUTW(sc, AMDSMB_GLOBAL_ENABLE, (l & 0xfff8) | AMDSMB_GE_CYC_BLOCK | AMDSMB_GE_HOST_STC);
570 if ((error = amdsmb_wait(sc)) != SMB_ENOERR)
573 len = AMDPM_SMBINW(sc, AMDSMB_HSTDATA);
575 /* Read the 32-byte internal buffer */
576 for (i=0; i<len; i++) {
577 buf[count-remain+i] = AMDPM_SMBINB(sc, AMDSMB_HSTDFIFO);
584 AMDPM_DEBUG(printf("amdpm: READBLK to 0x%x, count=0x%x, cmd=0x%x, error=0x%x", slave, count, cmd, error));
589 static devclass_t amdpm_devclass;
591 static device_method_t amdpm_methods[] = {
592 /* Device interface */
593 DEVMETHOD(device_probe, amdpm_probe),
594 DEVMETHOD(device_attach, amdpm_attach),
599 static driver_t amdpm_driver = {
602 sizeof(struct amdpm_softc),
605 static devclass_t amdsmb_devclass;
607 static device_method_t amdsmb_methods[] = {
608 /* Device interface */
609 DEVMETHOD(device_probe, amdsmb_probe),
610 DEVMETHOD(device_attach, amdsmb_attach),
613 DEVMETHOD(bus_print_child, bus_generic_print_child),
615 /* SMBus interface */
616 DEVMETHOD(smbus_callback, amdsmb_smb_callback),
617 DEVMETHOD(smbus_quick, amdsmb_smb_quick),
618 DEVMETHOD(smbus_sendb, amdsmb_smb_sendb),
619 DEVMETHOD(smbus_recvb, amdsmb_smb_recvb),
620 DEVMETHOD(smbus_writeb, amdsmb_smb_writeb),
621 DEVMETHOD(smbus_readb, amdsmb_smb_readb),
622 DEVMETHOD(smbus_writew, amdsmb_smb_writew),
623 DEVMETHOD(smbus_readw, amdsmb_smb_readw),
624 DEVMETHOD(smbus_bwrite, amdsmb_smb_bwrite),
625 DEVMETHOD(smbus_bread, amdsmb_smb_bread),
630 static driver_t amdsmb_driver = {
633 sizeof(struct amdsmb_softc),
636 DRIVER_MODULE(amdpm, pci, amdpm_driver, amdpm_devclass, 0, 0);
637 DRIVER_MODULE(amdsmb, amdpm, amdsmb_driver, amdsmb_devclass, 0, 0);