Merge from vendor branch OPENSSL:
[dragonfly.git] / sys / dev / powermng / ichsmb / ichsmb.c
1
2 /*
3  * ichsmb.c
4  *
5  * Copyright (c) 2000 Whistle Communications, Inc.
6  * All rights reserved.
7  * 
8  * Subject to the following obligations and disclaimer of warranty, use and
9  * redistribution of this software, in source or object code forms, with or
10  * without modifications are expressly permitted by Whistle Communications;
11  * provided, however, that:
12  * 1. Any and all reproductions of the source or object code must include the
13  *    copyright notice above and the following disclaimer of warranties; and
14  * 2. No rights are granted, in any manner or form, to use Whistle
15  *    Communications, Inc. trademarks, including the mark "WHISTLE
16  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
17  *    such appears in the above copyright notice or in the software.
18  * 
19  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
20  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
21  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
22  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
24  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
25  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
26  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
27  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
28  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
29  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
30  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
31  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
35  * OF SUCH DAMAGE.
36  *
37  * Author: Archie Cobbs <archie@freebsd.org>
38  *
39  * $FreeBSD: src/sys/dev/ichsmb/ichsmb.c,v 1.1.2.1 2000/10/09 00:52:43 archie Exp $
40  * $DragonFly: src/sys/dev/powermng/ichsmb/ichsmb.c,v 1.4 2003/08/07 21:17:07 dillon Exp $
41  */
42
43 /*
44  * Support for the SMBus controller logical device which is part of the
45  * Intel 81801AA (ICH) and 81801AB (ICH0) I/O controller hub chips.
46  */
47
48 #include <sys/param.h>
49 #include <sys/systm.h>
50 #include <sys/kernel.h>
51 #include <sys/errno.h>
52 #include <sys/syslog.h>
53 #include <sys/bus.h>
54
55 #include <machine/bus.h>
56 #include <sys/rman.h>
57 #include <machine/resource.h>
58
59 #include <bus/smbus/smbconf.h>
60
61 #include "ichsmb_var.h"
62 #include "ichsmb_reg.h"
63
64 /*
65  * Enable debugging by defining ICHSMB_DEBUG to a non-zero value.
66  */
67 #define ICHSMB_DEBUG    0
68 #if ICHSMB_DEBUG != 0 && defined(__GNUC__)
69 #define DBG(fmt, args...)       \
70         do { log(LOG_DEBUG, "%s: " fmt, __FUNCTION__ , ## args); } while (0)
71 #else
72 #define DBG(fmt, args...)       do { } while (0)
73 #endif
74
75 /*
76  * Our child device driver name
77  */
78 #define DRIVER_SMBUS    "smbus"
79
80 /*
81  * Internal functions
82  */
83 static int ichsmb_wait(sc_p sc);
84
85 /********************************************************************
86                 BUS-INDEPENDENT BUS METHODS
87 ********************************************************************/
88
89 /*
90  * Handle probe-time duties that are independent of the bus
91  * our device lives on.
92  */
93 int
94 ichsmb_probe(device_t dev)
95 {
96         device_t smb;
97
98         /* Add child: an instance of the "smbus" device */
99         if ((smb = device_add_child(dev, DRIVER_SMBUS, -1)) == NULL) {
100                 log(LOG_ERR, "%s: no \"%s\" child found\n",
101                     device_get_nameunit(dev), DRIVER_SMBUS);
102                 return (ENXIO);
103         }
104         return (0);
105 }
106
107 /*
108  * Handle attach-time duties that are independent of the bus
109  * our device lives on.
110  */
111 int
112 ichsmb_attach(device_t dev)
113 {
114         const sc_p sc = device_get_softc(dev);
115         int error;
116
117         /* Clear interrupt conditions */
118         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_STA, 0xff);
119
120         /* Add "smbus" child */
121         if ((error = bus_generic_attach(dev)) != 0) {
122                 log(LOG_ERR, "%s: failed to attach child: %d\n",
123                     device_get_nameunit(dev), error);
124                 error = ENXIO;
125         }
126
127         /* Done */
128         return (error);
129 }
130
131 /********************************************************************
132                         SMBUS METHODS
133 ********************************************************************/
134
135 int 
136 ichsmb_callback(device_t dev, int index, caddr_t data)
137 {
138         int smb_error = 0;
139
140         DBG("index=%d how=%d\n", index, data ? *(int *)data : -1);
141         switch (index) {
142         case SMB_REQUEST_BUS:
143                 break;
144         case SMB_RELEASE_BUS:
145                 break;
146         default:
147                 smb_error = SMB_EABORT; /* XXX */
148                 break;
149         }
150         DBG("smb_error=%d\n", smb_error);
151         return (smb_error);
152 }
153
154 int
155 ichsmb_quick(device_t dev, u_char slave, int how)
156 {
157         const sc_p sc = device_get_softc(dev);
158         int smb_error;
159         int s;
160
161         DBG("slave=0x%02x how=%d\n", slave, how);
162         KASSERT(sc->ich_cmd == -1,
163             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
164         switch (how) {
165         case SMB_QREAD:
166         case SMB_QWRITE:
167                 s = splhigh();
168                 sc->ich_cmd = ICH_HST_CNT_SMB_CMD_QUICK;
169                 bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
170                     (slave << 1) | (how == SMB_QREAD ?
171                         ICH_XMIT_SLVA_READ : ICH_XMIT_SLVA_WRITE));
172                 bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
173                     ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
174                 smb_error = ichsmb_wait(sc);
175                 splx(s);
176                 break;
177         default:
178                 smb_error = SMB_ENOTSUPP;
179         }
180         DBG("smb_error=%d\n", smb_error);
181         return (smb_error);
182 }
183
184 int
185 ichsmb_sendb(device_t dev, u_char slave, char byte)
186 {
187         const sc_p sc = device_get_softc(dev);
188         int smb_error;
189         int s;
190
191         DBG("slave=0x%02x byte=0x%02x\n", slave, (u_char)byte);
192         KASSERT(sc->ich_cmd == -1,
193             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
194         s = splhigh();
195         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE;
196         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
197             (slave << 1) | ICH_XMIT_SLVA_WRITE);
198         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CMD, byte);
199         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
200             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
201         smb_error = ichsmb_wait(sc);
202         splx(s);
203         DBG("smb_error=%d\n", smb_error);
204         return (smb_error);
205 }
206
207 int
208 ichsmb_recvb(device_t dev, u_char slave, char *byte)
209 {
210         const sc_p sc = device_get_softc(dev);
211         int smb_error;
212         int s;
213
214         DBG("slave=0x%02x\n", slave);
215         KASSERT(sc->ich_cmd == -1,
216             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
217         s = splhigh();
218         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE;
219         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
220             (slave << 1) | ICH_XMIT_SLVA_READ);
221         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
222             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
223         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR)
224                 *byte = bus_space_read_1(sc->io_bst, sc->io_bsh, ICH_D0);
225         splx(s);
226         DBG("smb_error=%d byte=0x%02x\n", smb_error, (u_char)*byte);
227         return (smb_error);
228 }
229
230 int
231 ichsmb_writeb(device_t dev, u_char slave, char cmd, char byte)
232 {
233         const sc_p sc = device_get_softc(dev);
234         int smb_error;
235         int s;
236
237         DBG("slave=0x%02x cmd=0x%02x byte=0x%02x\n",
238             slave, (u_char)cmd, (u_char)byte);
239         KASSERT(sc->ich_cmd == -1,
240             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
241         s = splhigh();
242         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE_DATA;
243         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
244             (slave << 1) | ICH_XMIT_SLVA_WRITE);
245         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CMD, cmd);
246         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_D0, byte);
247         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
248             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
249         smb_error = ichsmb_wait(sc);
250         splx(s);
251         DBG("smb_error=%d\n", smb_error);
252         return (smb_error);
253 }
254
255 int
256 ichsmb_writew(device_t dev, u_char slave, char cmd, short word)
257 {
258         const sc_p sc = device_get_softc(dev);
259         int smb_error;
260         int s;
261
262         DBG("slave=0x%02x cmd=0x%02x word=0x%04x\n",
263             slave, (u_char)cmd, (u_int16_t)word);
264         KASSERT(sc->ich_cmd == -1,
265             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
266         s = splhigh();
267         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_WORD_DATA;
268         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
269             (slave << 1) | ICH_XMIT_SLVA_WRITE);
270         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CMD, cmd);
271         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_D0, word & 0xff);
272         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_D1, word >> 8);
273         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
274             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
275         smb_error = ichsmb_wait(sc);
276         splx(s);
277         DBG("smb_error=%d\n", smb_error);
278         return (smb_error);
279 }
280
281 int
282 ichsmb_readb(device_t dev, u_char slave, char cmd, char *byte)
283 {
284         const sc_p sc = device_get_softc(dev);
285         int smb_error;
286         int s;
287
288         DBG("slave=0x%02x cmd=0x%02x\n", slave, (u_char)cmd);
289         KASSERT(sc->ich_cmd == -1,
290             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
291         s = splhigh();
292         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BYTE_DATA;
293         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
294             (slave << 1) | ICH_XMIT_SLVA_READ);
295         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CMD, cmd);
296         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
297             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
298         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR)
299                 *byte = bus_space_read_1(sc->io_bst, sc->io_bsh, ICH_D0);
300         splx(s);
301         DBG("smb_error=%d byte=0x%02x\n", smb_error, (u_char)*byte);
302         return (smb_error);
303 }
304
305 int
306 ichsmb_readw(device_t dev, u_char slave, char cmd, short *word)
307 {
308         const sc_p sc = device_get_softc(dev);
309         int smb_error;
310         int s;
311
312         DBG("slave=0x%02x cmd=0x%02x\n", slave, (u_char)cmd);
313         KASSERT(sc->ich_cmd == -1,
314             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
315         s = splhigh();
316         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_WORD_DATA;
317         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
318             (slave << 1) | ICH_XMIT_SLVA_READ);
319         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CMD, cmd);
320         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
321             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
322         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR) {
323                 *word = (bus_space_read_1(sc->io_bst,
324                         sc->io_bsh, ICH_D0) & 0xff)
325                   | (bus_space_read_1(sc->io_bst,
326                         sc->io_bsh, ICH_D1) << 8);
327         }
328         splx(s);
329         DBG("smb_error=%d word=0x%04x\n", smb_error, (u_int16_t)*word);
330         return (smb_error);
331 }
332
333 int
334 ichsmb_pcall(device_t dev, u_char slave, char cmd, short sdata, short *rdata)
335 {
336         const sc_p sc = device_get_softc(dev);
337         int smb_error;
338         int s;
339
340         DBG("slave=0x%02x cmd=0x%02x sdata=0x%04x\n",
341             slave, (u_char)cmd, (u_int16_t)sdata);
342         KASSERT(sc->ich_cmd == -1,
343             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
344         s = splhigh();
345         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_PROC_CALL;
346         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
347             (slave << 1) | ICH_XMIT_SLVA_WRITE);
348         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CMD, cmd);
349         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_D0, sdata & 0xff);
350         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_D1, sdata >> 8);
351         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
352             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
353         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR) {
354                 *rdata = (bus_space_read_1(sc->io_bst,
355                         sc->io_bsh, ICH_D0) & 0xff)
356                   | (bus_space_read_1(sc->io_bst,
357                         sc->io_bsh, ICH_D1) << 8);
358         }
359         splx(s);
360         DBG("smb_error=%d rdata=0x%04x\n", smb_error, (u_int16_t)*rdata);
361         return (smb_error);
362 }
363
364 int
365 ichsmb_bwrite(device_t dev, u_char slave, char cmd, u_char count, char *buf)
366 {
367         const sc_p sc = device_get_softc(dev);
368         int smb_error;
369         int s;
370
371         DBG("slave=0x%02x cmd=0x%02x count=%d\n", slave, (u_char)cmd, count);
372 #if ICHSMB_DEBUG
373 #define DISP(ch)        (((ch) < 0x20 || (ch) >= 0x7e) ? '.' : (ch))
374         {
375             u_char *p;
376
377             for (p = (u_char *)buf; p - (u_char *)buf < 32; p += 8) {
378                 DBG("%02x: %02x %02x %02x %02x %02x %02x %02x %02x"
379                     "  %c%c%c%c%c%c%c%c", (p - (u_char *)buf),
380                     p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
381                     DISP(p[0]), DISP(p[1]), DISP(p[2]), DISP(p[3]), 
382                     DISP(p[4]), DISP(p[5]), DISP(p[6]), DISP(p[7]));
383             }
384         }
385 #undef DISP
386 #endif
387         KASSERT(sc->ich_cmd == -1,
388             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
389         if (count < 1 || count > 32)
390                 return (EINVAL);
391         bcopy(buf, sc->block_data, count);
392         sc->block_count = count;
393         sc->block_index = 1;
394         sc->block_write = 1;
395
396         s = splhigh();
397         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BLOCK;
398         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
399             (slave << 1) | ICH_XMIT_SLVA_WRITE);
400         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CMD, cmd);
401         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_D0, count);
402         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_BLOCK_DB, buf[0]);
403         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
404             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
405         smb_error = ichsmb_wait(sc);
406         splx(s);
407         DBG("smb_error=%d\n", smb_error);
408         return (smb_error);
409 }
410
411 int
412 ichsmb_bread(device_t dev, u_char slave, char cmd, u_char count, char *buf)
413 {
414         const sc_p sc = device_get_softc(dev);
415         int smb_error;
416         int s;
417
418         DBG("slave=0x%02x cmd=0x%02x count=%d\n", slave, (u_char)cmd, count);
419         KASSERT(sc->ich_cmd == -1,
420             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
421         if (count < 1 || count > 32)
422                 return (EINVAL);
423         bzero(sc->block_data, sizeof(sc->block_data));
424         sc->block_count = count;
425         sc->block_index = 0;
426         sc->block_write = 0;
427
428         s = splhigh();
429         sc->ich_cmd = ICH_HST_CNT_SMB_CMD_BLOCK;
430         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_XMIT_SLVA,
431             (slave << 1) | ICH_XMIT_SLVA_READ);
432         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CMD, cmd);
433         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_D0, count); /* XXX? */
434         bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_CNT,
435             ICH_HST_CNT_START | ICH_HST_CNT_INTREN | sc->ich_cmd);
436         if ((smb_error = ichsmb_wait(sc)) == SMB_ENOERR)
437                 bcopy(sc->block_data, buf, sc->block_count);
438         splx(s);
439         DBG("smb_error=%d\n", smb_error);
440 #if ICHSMB_DEBUG
441 #define DISP(ch)        (((ch) < 0x20 || (ch) >= 0x7e) ? '.' : (ch))
442         {
443             u_char *p;
444
445             for (p = (u_char *)buf; p - (u_char *)buf < 32; p += 8) {
446                 DBG("%02x: %02x %02x %02x %02x %02x %02x %02x %02x"
447                     "  %c%c%c%c%c%c%c%c", (p - (u_char *)buf),
448                     p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7],
449                     DISP(p[0]), DISP(p[1]), DISP(p[2]), DISP(p[3]), 
450                     DISP(p[4]), DISP(p[5]), DISP(p[6]), DISP(p[7]));
451             }
452         }
453 #undef DISP
454 #endif
455         return (smb_error);
456 }
457
458 /********************************************************************
459                         OTHER FUNCTIONS
460 ********************************************************************/
461
462 /*
463  * This table describes what interrupts we should ever expect to
464  * see after each ICH command, not including the SMBALERT interrupt.
465  */
466 static const u_int8_t ichsmb_state_irqs[] = {
467         /* quick */
468         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
469         /* byte */
470         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
471         /* byte data */
472         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
473         /* word data */
474         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
475         /* process call */
476         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR),
477         /* block */
478         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR
479             | ICH_HST_STA_BYTE_DONE_STS),
480         /* i2c read (not used) */
481         (ICH_HST_STA_BUS_ERR | ICH_HST_STA_DEV_ERR | ICH_HST_STA_INTR
482             | ICH_HST_STA_BYTE_DONE_STS)
483 };
484
485 /*
486  * Interrupt handler. This handler is bus-independent. Note that our
487  * interrupt may be shared, so we must handle "false" interrupts.
488  */
489 void
490 ichsmb_device_intr(void *cookie)
491 {
492         const sc_p sc = cookie;
493         const device_t dev = sc->dev;
494         const int maxloops = 16;
495         u_int8_t status;
496         u_int8_t ok_bits;
497         int cmd_index;
498         int count;
499         int s;
500
501         s = splhigh();
502         for (count = 0; count < maxloops; count++) {
503
504                 /* Get and reset status bits */
505                 status = bus_space_read_1(sc->io_bst, sc->io_bsh, ICH_HST_STA);
506 #if ICHSMB_DEBUG
507                 if ((status & ~(ICH_HST_STA_INUSE_STS | ICH_HST_STA_HOST_BUSY))
508                     || count > 0) {
509                         DBG("%d stat=0x%02x\n", count, status);
510                 }
511 #endif
512                 status &= ~(ICH_HST_STA_INUSE_STS | ICH_HST_STA_HOST_BUSY);
513                 if (status == 0)
514                         break;
515
516                 /* Check for unexpected interrupt */
517                 ok_bits = ICH_HST_STA_SMBALERT_STS;
518                 cmd_index = sc->ich_cmd >> 2;
519                 if (sc->ich_cmd != -1) {
520                         KASSERT(cmd_index < sizeof(ichsmb_state_irqs),
521                             ("%s: ich_cmd=%d", device_get_nameunit(dev),
522                             sc->ich_cmd));
523                         ok_bits |= ichsmb_state_irqs[cmd_index];
524                 }
525                 if ((status & ~ok_bits) != 0) {
526                         log(LOG_ERR, "%s: irq 0x%02x during %d\n",
527                             device_get_nameunit(dev), status, cmd_index);
528                         bus_space_write_1(sc->io_bst, sc->io_bsh,
529                             ICH_HST_STA, (status & ~ok_bits));
530                         continue;
531                 }
532
533                 /* Handle SMBALERT interrupt */
534                 if (status & ICH_HST_STA_SMBALERT_STS) {
535                         static int smbalert_count = 16;
536                         if (smbalert_count > 0) {
537                                 log(LOG_WARNING, "%s: SMBALERT# rec'd\n",
538                                     device_get_nameunit(dev));
539                                 if (--smbalert_count == 0) {
540                                         log(LOG_WARNING,
541                                             "%s: not logging anymore\n",
542                                             device_get_nameunit(dev));
543                                 }
544                         }
545                 }
546
547                 /* Check for bus error */
548                 if (status & ICH_HST_STA_BUS_ERR) {
549                         sc->smb_error = SMB_ECOLLI;     /* XXX SMB_EBUSERR? */
550                         goto finished;
551                 }
552
553                 /* Check for device error */
554                 if (status & ICH_HST_STA_DEV_ERR) {
555                         sc->smb_error = SMB_ENOACK;     /* or SMB_ETIMEOUT? */
556                         goto finished;
557                 }
558
559                 /* Check for byte completion in block transfer */
560                 if (status & ICH_HST_STA_BYTE_DONE_STS) {
561                         if (sc->block_write) {
562                                 if (sc->block_index < sc->block_count) {
563
564                                         /* Write next byte */
565                                         bus_space_write_1(sc->io_bst,
566                                             sc->io_bsh, ICH_BLOCK_DB,
567                                             sc->block_data[sc->block_index++]);
568                                 }
569                         } else {
570
571                                 /* First interrupt, get the count also */
572                                 if (sc->block_index == 0) {
573                                         sc->block_count = bus_space_read_1(
574                                             sc->io_bst, sc->io_bsh, ICH_D0);
575                                 }
576
577                                 /* Get next byte, if any */
578                                 if (sc->block_index < sc->block_count) {
579
580                                         /* Read next byte */
581                                         sc->block_data[sc->block_index++] =
582                                             bus_space_read_1(sc->io_bst,
583                                               sc->io_bsh, ICH_BLOCK_DB);
584
585                                         /* Set "LAST_BYTE" bit before reading
586                                            the last byte of block data */
587                                         if (sc->block_index
588                                             >= sc->block_count - 1) {
589                                                 bus_space_write_1(sc->io_bst,
590                                                     sc->io_bsh, ICH_HST_CNT,
591                                                     ICH_HST_CNT_LAST_BYTE
592                                                         | ICH_HST_CNT_INTREN
593                                                         | sc->ich_cmd);
594                                         }
595                                 }
596                         }
597                 }
598
599                 /* Check command completion */
600                 if (status & ICH_HST_STA_INTR) {
601                         sc->smb_error = SMB_ENOERR;
602 finished:
603                         sc->ich_cmd = -1;
604                         bus_space_write_1(sc->io_bst, sc->io_bsh,
605                             ICH_HST_STA, status);
606                         wakeup(sc);
607                         break;
608                 }
609
610                 /* Clear status bits and try again */
611                 bus_space_write_1(sc->io_bst, sc->io_bsh, ICH_HST_STA, status);
612         }
613         splx(s);
614
615         /* Too many loops? */
616         if (count == maxloops) {
617                 log(LOG_ERR, "%s: interrupt loop, status=0x%02x\n",
618                     device_get_nameunit(dev),
619                     bus_space_read_1(sc->io_bst, sc->io_bsh, ICH_HST_STA));
620         }
621 }
622
623 /*
624  * Wait for command completion. Assumes splhigh().
625  * Returns an SMB_* error code.
626  */
627 static int
628 ichsmb_wait(sc_p sc)
629 {
630         const device_t dev = sc->dev;
631         int error, smb_error;
632
633         KASSERT(sc->ich_cmd != -1,
634             ("%s: ich_cmd=%d\n", __FUNCTION__ , sc->ich_cmd));
635 sleep:
636         error = tsleep(sc, PCATCH, "ichsmb", hz / 4);
637         DBG("tsleep -> %d\n", error);
638         switch (error) {
639         case ERESTART:
640                 if (sc->ich_cmd != -1)
641                         goto sleep;
642                 /* FALLTHROUGH */
643         case 0:
644                 smb_error = sc->smb_error;
645                 break;
646         case EWOULDBLOCK:
647                 log(LOG_ERR, "%s: device timeout, status=0x%02x\n",
648                     device_get_nameunit(dev),
649                     bus_space_read_1(sc->io_bst, sc->io_bsh, ICH_HST_STA));
650                 sc->ich_cmd = -1;
651                 smb_error = SMB_ETIMEOUT;
652                 break;
653         default:
654                 smb_error = SMB_EABORT;
655                 break;
656         }
657         return (smb_error);
658 }
659
660 /*
661  * Release resources associated with device.
662  */
663 void
664 ichsmb_release_resources(sc_p sc)
665 {
666         const device_t dev = sc->dev;
667
668         if (sc->irq_handle != NULL) {
669                 bus_teardown_intr(dev, sc->irq_res, sc->irq_handle);
670                 sc->irq_handle = NULL;
671         }
672         if (sc->irq_res != NULL) {
673                 bus_release_resource(dev,
674                     SYS_RES_IRQ, sc->irq_rid, sc->irq_res);
675                 sc->irq_res = NULL;
676         }
677         if (sc->io_res != NULL) {
678                 bus_release_resource(dev,
679                     SYS_RES_IOPORT, sc->io_rid, sc->io_res);
680                 sc->io_res = NULL;
681         }
682 }
683