xref: /freebsd/sys/dev/glxiic/glxiic.c (revision 676ea8e1778d671703c8901ea82ad4092b00b24a)
1149d1c89SHenrik Brix Andersen /*-
2718cf2ccSPedro F. Giffuni  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3718cf2ccSPedro F. Giffuni  *
4149d1c89SHenrik Brix Andersen  * Copyright (c) 2011 Henrik Brix Andersen <brix@FreeBSD.org>
5149d1c89SHenrik Brix Andersen  * All rights reserved.
6149d1c89SHenrik Brix Andersen  *
7149d1c89SHenrik Brix Andersen  * Redistribution and use in source and binary forms, with or without
8149d1c89SHenrik Brix Andersen  * modification, are permitted provided that the following conditions
9149d1c89SHenrik Brix Andersen  * are met:
10149d1c89SHenrik Brix Andersen  * 1. Redistributions of source code must retain the above copyright
11149d1c89SHenrik Brix Andersen  *    notice, this list of conditions and the following disclaimer.
12149d1c89SHenrik Brix Andersen  * 2. Redistributions in binary form must reproduce the above copyright
13149d1c89SHenrik Brix Andersen  *    notice, this list of conditions and the following disclaimer in the
14149d1c89SHenrik Brix Andersen  *    documentation and/or other materials provided with the distribution.
15149d1c89SHenrik Brix Andersen  *
16149d1c89SHenrik Brix Andersen  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17149d1c89SHenrik Brix Andersen  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18149d1c89SHenrik Brix Andersen  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19149d1c89SHenrik Brix Andersen  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20149d1c89SHenrik Brix Andersen  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21149d1c89SHenrik Brix Andersen  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22149d1c89SHenrik Brix Andersen  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23149d1c89SHenrik Brix Andersen  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24149d1c89SHenrik Brix Andersen  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25149d1c89SHenrik Brix Andersen  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26149d1c89SHenrik Brix Andersen  */
27149d1c89SHenrik Brix Andersen 
28149d1c89SHenrik Brix Andersen #include <sys/cdefs.h>
29149d1c89SHenrik Brix Andersen __FBSDID("$FreeBSD$");
30149d1c89SHenrik Brix Andersen /*
31149d1c89SHenrik Brix Andersen  * AMD Geode LX CS5536 System Management Bus controller.
32149d1c89SHenrik Brix Andersen  *
33149d1c89SHenrik Brix Andersen  * Although AMD refers to this device as an SMBus controller, it
34149d1c89SHenrik Brix Andersen  * really is an I2C controller (It lacks SMBus ALERT# and Alert
35149d1c89SHenrik Brix Andersen  * Response support).
36149d1c89SHenrik Brix Andersen  *
37149d1c89SHenrik Brix Andersen  * The driver is implemented as an interrupt-driven state machine,
38149d1c89SHenrik Brix Andersen  * supporting both master and slave mode.
39149d1c89SHenrik Brix Andersen  */
40149d1c89SHenrik Brix Andersen #include <sys/param.h>
41149d1c89SHenrik Brix Andersen #include <sys/systm.h>
42149d1c89SHenrik Brix Andersen #include <sys/bus.h>
43149d1c89SHenrik Brix Andersen #include <sys/kernel.h>
44149d1c89SHenrik Brix Andersen #include <sys/module.h>
45149d1c89SHenrik Brix Andersen #include <sys/lock.h>
46149d1c89SHenrik Brix Andersen #include <sys/mutex.h>
47149d1c89SHenrik Brix Andersen #include <sys/sysctl.h>
48149d1c89SHenrik Brix Andersen #ifdef GLXIIC_DEBUG
49149d1c89SHenrik Brix Andersen #include <sys/syslog.h>
50149d1c89SHenrik Brix Andersen #endif
51149d1c89SHenrik Brix Andersen 
52149d1c89SHenrik Brix Andersen #include <dev/pci/pcireg.h>
53149d1c89SHenrik Brix Andersen #include <dev/pci/pcivar.h>
54149d1c89SHenrik Brix Andersen 
55149d1c89SHenrik Brix Andersen #include <machine/bus.h>
56149d1c89SHenrik Brix Andersen #include <sys/rman.h>
57149d1c89SHenrik Brix Andersen #include <machine/resource.h>
58149d1c89SHenrik Brix Andersen 
59149d1c89SHenrik Brix Andersen #include <dev/iicbus/iiconf.h>
60149d1c89SHenrik Brix Andersen #include <dev/iicbus/iicbus.h>
61149d1c89SHenrik Brix Andersen 
62149d1c89SHenrik Brix Andersen #include "iicbus_if.h"
63149d1c89SHenrik Brix Andersen 
64149d1c89SHenrik Brix Andersen /* CS5536 PCI-ISA ID. */
65149d1c89SHenrik Brix Andersen #define	GLXIIC_CS5536_DEV_ID		0x20901022
66149d1c89SHenrik Brix Andersen 
67149d1c89SHenrik Brix Andersen /* MSRs. */
68149d1c89SHenrik Brix Andersen #define	GLXIIC_MSR_PIC_YSEL_HIGH	0x51400021
69149d1c89SHenrik Brix Andersen 
70149d1c89SHenrik Brix Andersen /* Bus speeds. */
71149d1c89SHenrik Brix Andersen #define	GLXIIC_SLOW	0x0258	/*  10 kHz. */
72149d1c89SHenrik Brix Andersen #define	GLXIIC_FAST	0x0078	/*  50 kHz. */
73149d1c89SHenrik Brix Andersen #define	GLXIIC_FASTEST	0x003c	/* 100 kHz. */
74149d1c89SHenrik Brix Andersen 
75149d1c89SHenrik Brix Andersen /* Default bus activity timeout in milliseconds. */
76149d1c89SHenrik Brix Andersen #define GLXIIC_DEFAULT_TIMEOUT	35
77149d1c89SHenrik Brix Andersen 
78149d1c89SHenrik Brix Andersen /* GPIO register offsets. */
79149d1c89SHenrik Brix Andersen #define	GLXIIC_GPIOL_OUT_AUX1_SEL	0x10
80149d1c89SHenrik Brix Andersen #define	GLXIIC_GPIOL_IN_AUX1_SEL	0x34
81149d1c89SHenrik Brix Andersen 
82149d1c89SHenrik Brix Andersen /* GPIO 14 (SMB_CLK) and 15 (SMB_DATA) bitmasks. */
83149d1c89SHenrik Brix Andersen #define	GLXIIC_GPIO_14_15_ENABLE	0x0000c000
84149d1c89SHenrik Brix Andersen #define	GLXIIC_GPIO_14_15_DISABLE	0xc0000000
85149d1c89SHenrik Brix Andersen 
86149d1c89SHenrik Brix Andersen /* SMB register offsets. */
87149d1c89SHenrik Brix Andersen #define	GLXIIC_SMB_SDA				0x00
88149d1c89SHenrik Brix Andersen #define	GLXIIC_SMB_STS				0x01
89149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_STS_SLVSTP_BIT	(1 << 7)
90149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_STS_SDAST_BIT	(1 << 6)
91149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_STS_BER_BIT		(1 << 5)
92149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_STS_NEGACK_BIT	(1 << 4)
93149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_STS_STASTR_BIT	(1 << 3)
94149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_STS_NMATCH_BIT	(1 << 2)
95149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_STS_MASTER_BIT	(1 << 1)
96149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_STS_XMIT_BIT		(1 << 0)
97149d1c89SHenrik Brix Andersen #define	GLXIIC_SMB_CTRL_STS			0x02
98149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL_STS_TGSCL_BIT	(1 << 5)
99149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL_STS_TSDA_BIT	(1 << 4)
100149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL_STS_GCMTCH_BIT	(1 << 3)
101149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL_STS_MATCH_BIT	(1 << 2)
102149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL_STS_BB_BIT	(1 << 1)
103149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL_STS_BUSY_BIT	(1 << 0)
104149d1c89SHenrik Brix Andersen #define	GLXIIC_SMB_CTRL1			0x03
105149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL1_STASTRE_BIT	(1 << 7)
106149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL1_NMINTE_BIT	(1 << 6)
107149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL1_GCMEN_BIT	(1 << 5)
108149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL1_ACK_BIT	(1 << 4)
109149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL1_INTEN_BIT	(1 << 2)
110149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL1_STOP_BIT	(1 << 1)
111149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL1_START_BIT	(1 << 0)
112149d1c89SHenrik Brix Andersen #define	GLXIIC_SMB_ADDR				0x04
113149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_ADDR_SAEN_BIT	(1 << 7)
114149d1c89SHenrik Brix Andersen #define	GLXIIC_SMB_CTRL2			0x05
115149d1c89SHenrik Brix Andersen #define		GLXIIC_SMB_CTRL2_EN_BIT		(1 << 0)
116149d1c89SHenrik Brix Andersen #define	GLXIIC_SMB_CTRL3			0x06
117149d1c89SHenrik Brix Andersen 
118149d1c89SHenrik Brix Andersen typedef enum {
119149d1c89SHenrik Brix Andersen 	GLXIIC_STATE_IDLE,
120149d1c89SHenrik Brix Andersen 	GLXIIC_STATE_SLAVE_TX,
121149d1c89SHenrik Brix Andersen 	GLXIIC_STATE_SLAVE_RX,
122149d1c89SHenrik Brix Andersen 	GLXIIC_STATE_MASTER_ADDR,
123149d1c89SHenrik Brix Andersen 	GLXIIC_STATE_MASTER_TX,
124149d1c89SHenrik Brix Andersen 	GLXIIC_STATE_MASTER_RX,
125149d1c89SHenrik Brix Andersen 	GLXIIC_STATE_MASTER_STOP,
126149d1c89SHenrik Brix Andersen 	GLXIIC_STATE_MAX,
127149d1c89SHenrik Brix Andersen } glxiic_state_t;
128149d1c89SHenrik Brix Andersen 
129149d1c89SHenrik Brix Andersen struct glxiic_softc {
130149d1c89SHenrik Brix Andersen 	device_t	 dev;		/* Myself. */
131149d1c89SHenrik Brix Andersen 	device_t	 iicbus;	/* IIC bus. */
132149d1c89SHenrik Brix Andersen 	struct mtx	 mtx;		/* Lock. */
133149d1c89SHenrik Brix Andersen 	glxiic_state_t	 state;		/* Driver state. */
134149d1c89SHenrik Brix Andersen 	struct callout	 callout;	/* Driver state timeout callout. */
135149d1c89SHenrik Brix Andersen 	int		 timeout;	/* Driver state timeout (ms). */
136149d1c89SHenrik Brix Andersen 
137149d1c89SHenrik Brix Andersen 	int		 smb_rid;	/* SMB controller resource ID. */
138149d1c89SHenrik Brix Andersen 	struct resource *smb_res;	/* SMB controller resource. */
139149d1c89SHenrik Brix Andersen 	int		 gpio_rid;	/* GPIO resource ID. */
140149d1c89SHenrik Brix Andersen 	struct resource *gpio_res;	/* GPIO resource. */
141149d1c89SHenrik Brix Andersen 
142149d1c89SHenrik Brix Andersen 	int		 irq_rid;	/* IRQ resource ID. */
143149d1c89SHenrik Brix Andersen 	struct resource *irq_res;	/* IRQ resource. */
144149d1c89SHenrik Brix Andersen 	void		*irq_handler;	/* IRQ handler cookie. */
145149d1c89SHenrik Brix Andersen 	int		 old_irq;	/* IRQ mapped by board firmware. */
146149d1c89SHenrik Brix Andersen 
147149d1c89SHenrik Brix Andersen 	struct iic_msg	*msg;		/* Current master mode message. */
148149d1c89SHenrik Brix Andersen 	uint32_t	 nmsgs;		/* Number of messages remaining. */
149149d1c89SHenrik Brix Andersen 	uint8_t		*data;		/* Current master mode data byte. */
150149d1c89SHenrik Brix Andersen 	uint16_t	 ndata;		/* Number of data bytes remaining. */
151149d1c89SHenrik Brix Andersen 	int		 error;		/* Last master mode error. */
152149d1c89SHenrik Brix Andersen 
153149d1c89SHenrik Brix Andersen 	uint8_t		 addr;		/* Own address. */
154149d1c89SHenrik Brix Andersen 	uint16_t	 sclfrq;	/* Bus frequency. */
155149d1c89SHenrik Brix Andersen };
156149d1c89SHenrik Brix Andersen 
157149d1c89SHenrik Brix Andersen #ifdef GLXIIC_DEBUG
158da25396aSHenrik Brix Andersen #define GLXIIC_DEBUG_LOG(fmt, args...)	\
159da25396aSHenrik Brix Andersen 	log(LOG_DEBUG, "%s: " fmt "\n" , __func__ , ## args)
160149d1c89SHenrik Brix Andersen #else
161da25396aSHenrik Brix Andersen #define GLXIIC_DEBUG_LOG(fmt, args...)
162149d1c89SHenrik Brix Andersen #endif
163149d1c89SHenrik Brix Andersen 
164149d1c89SHenrik Brix Andersen #define	GLXIIC_SCLFRQ(n)		((n << 1))
165149d1c89SHenrik Brix Andersen #define	GLXIIC_SMBADDR(n)		((n >> 1))
166149d1c89SHenrik Brix Andersen #define	GLXIIC_SMB_IRQ_TO_MAP(n)	((n << 16))
167149d1c89SHenrik Brix Andersen #define	GLXIIC_MAP_TO_SMB_IRQ(n)	((n >> 16) & 0xf)
168149d1c89SHenrik Brix Andersen 
169149d1c89SHenrik Brix Andersen #define	GLXIIC_LOCK(_sc)		mtx_lock(&_sc->mtx)
170149d1c89SHenrik Brix Andersen #define	GLXIIC_UNLOCK(_sc)		mtx_unlock(&_sc->mtx)
171149d1c89SHenrik Brix Andersen #define	GLXIIC_LOCK_INIT(_sc)		\
172149d1c89SHenrik Brix Andersen 	mtx_init(&_sc->mtx, device_get_nameunit(_sc->dev), "glxiic", MTX_DEF)
173149d1c89SHenrik Brix Andersen #define	GLXIIC_SLEEP(_sc)		\
174149d1c89SHenrik Brix Andersen 	mtx_sleep(_sc, &_sc->mtx, IICPRI, "glxiic", 0)
175149d1c89SHenrik Brix Andersen #define	GLXIIC_WAKEUP(_sc)		wakeup(_sc);
176149d1c89SHenrik Brix Andersen #define	GLXIIC_LOCK_DESTROY(_sc)	mtx_destroy(&_sc->mtx);
177149d1c89SHenrik Brix Andersen #define	GLXIIC_ASSERT_LOCKED(_sc)	mtx_assert(&_sc->mtx, MA_OWNED);
178149d1c89SHenrik Brix Andersen 
179149d1c89SHenrik Brix Andersen typedef	int (glxiic_state_callback_t)(struct glxiic_softc *sc,
180149d1c89SHenrik Brix Andersen     uint8_t status);
181149d1c89SHenrik Brix Andersen 
182149d1c89SHenrik Brix Andersen static glxiic_state_callback_t	glxiic_state_idle_callback;
183149d1c89SHenrik Brix Andersen static glxiic_state_callback_t	glxiic_state_slave_tx_callback;
184149d1c89SHenrik Brix Andersen static glxiic_state_callback_t	glxiic_state_slave_rx_callback;
185149d1c89SHenrik Brix Andersen static glxiic_state_callback_t	glxiic_state_master_addr_callback;
186149d1c89SHenrik Brix Andersen static glxiic_state_callback_t	glxiic_state_master_tx_callback;
187149d1c89SHenrik Brix Andersen static glxiic_state_callback_t	glxiic_state_master_rx_callback;
188149d1c89SHenrik Brix Andersen static glxiic_state_callback_t	glxiic_state_master_stop_callback;
189149d1c89SHenrik Brix Andersen 
190149d1c89SHenrik Brix Andersen struct glxiic_state_table_entry {
191149d1c89SHenrik Brix Andersen 	glxiic_state_callback_t *callback;
192149d1c89SHenrik Brix Andersen 	boolean_t master;
193149d1c89SHenrik Brix Andersen };
194149d1c89SHenrik Brix Andersen typedef struct glxiic_state_table_entry glxiic_state_table_entry_t;
195149d1c89SHenrik Brix Andersen 
196149d1c89SHenrik Brix Andersen static glxiic_state_table_entry_t glxiic_state_table[GLXIIC_STATE_MAX] = {
197149d1c89SHenrik Brix Andersen 	[GLXIIC_STATE_IDLE] = {
198149d1c89SHenrik Brix Andersen 		.callback = &glxiic_state_idle_callback,
199149d1c89SHenrik Brix Andersen 		.master = FALSE,
200149d1c89SHenrik Brix Andersen 	},
201149d1c89SHenrik Brix Andersen 
202149d1c89SHenrik Brix Andersen 	[GLXIIC_STATE_SLAVE_TX] = {
203149d1c89SHenrik Brix Andersen 		.callback = &glxiic_state_slave_tx_callback,
204149d1c89SHenrik Brix Andersen 		.master = FALSE,
205149d1c89SHenrik Brix Andersen 	},
206149d1c89SHenrik Brix Andersen 
207149d1c89SHenrik Brix Andersen 	[GLXIIC_STATE_SLAVE_RX] = {
208149d1c89SHenrik Brix Andersen 		.callback = &glxiic_state_slave_rx_callback,
209149d1c89SHenrik Brix Andersen 		.master = FALSE,
210149d1c89SHenrik Brix Andersen 	},
211149d1c89SHenrik Brix Andersen 
212149d1c89SHenrik Brix Andersen 	[GLXIIC_STATE_MASTER_ADDR] = {
213149d1c89SHenrik Brix Andersen 		.callback = &glxiic_state_master_addr_callback,
214149d1c89SHenrik Brix Andersen 		.master = TRUE,
215149d1c89SHenrik Brix Andersen 	},
216149d1c89SHenrik Brix Andersen 
217149d1c89SHenrik Brix Andersen 	[GLXIIC_STATE_MASTER_TX] = {
218149d1c89SHenrik Brix Andersen 		.callback = &glxiic_state_master_tx_callback,
219149d1c89SHenrik Brix Andersen 		.master = TRUE,
220149d1c89SHenrik Brix Andersen 	},
221149d1c89SHenrik Brix Andersen 
222149d1c89SHenrik Brix Andersen 	[GLXIIC_STATE_MASTER_RX] = {
223149d1c89SHenrik Brix Andersen 		.callback = &glxiic_state_master_rx_callback,
224149d1c89SHenrik Brix Andersen 		.master = TRUE,
225149d1c89SHenrik Brix Andersen 	},
226149d1c89SHenrik Brix Andersen 
227149d1c89SHenrik Brix Andersen 	[GLXIIC_STATE_MASTER_STOP] = {
228149d1c89SHenrik Brix Andersen 		.callback = &glxiic_state_master_stop_callback,
229149d1c89SHenrik Brix Andersen 		.master = TRUE,
230149d1c89SHenrik Brix Andersen 	},
231149d1c89SHenrik Brix Andersen };
232149d1c89SHenrik Brix Andersen 
233149d1c89SHenrik Brix Andersen static void	glxiic_identify(driver_t *driver, device_t parent);
234149d1c89SHenrik Brix Andersen static int	glxiic_probe(device_t dev);
235149d1c89SHenrik Brix Andersen static int	glxiic_attach(device_t dev);
236149d1c89SHenrik Brix Andersen static int	glxiic_detach(device_t dev);
237149d1c89SHenrik Brix Andersen 
238149d1c89SHenrik Brix Andersen static uint8_t	glxiic_read_status_locked(struct glxiic_softc *sc);
239149d1c89SHenrik Brix Andersen static void	glxiic_stop_locked(struct glxiic_softc *sc);
240149d1c89SHenrik Brix Andersen static void	glxiic_timeout(void *arg);
241149d1c89SHenrik Brix Andersen static void	glxiic_start_timeout_locked(struct glxiic_softc *sc);
242149d1c89SHenrik Brix Andersen static void	glxiic_set_state_locked(struct glxiic_softc *sc,
243149d1c89SHenrik Brix Andersen     glxiic_state_t state);
244149d1c89SHenrik Brix Andersen static int	glxiic_handle_slave_match_locked(struct glxiic_softc *sc,
245149d1c89SHenrik Brix Andersen     uint8_t status);
246149d1c89SHenrik Brix Andersen static void	glxiic_intr(void *arg);
247149d1c89SHenrik Brix Andersen 
248149d1c89SHenrik Brix Andersen static int	glxiic_reset(device_t dev, u_char speed, u_char addr,
249149d1c89SHenrik Brix Andersen     u_char *oldaddr);
250149d1c89SHenrik Brix Andersen static int	glxiic_transfer(device_t dev, struct iic_msg *msgs,
251149d1c89SHenrik Brix Andersen     uint32_t nmsgs);
252149d1c89SHenrik Brix Andersen 
253149d1c89SHenrik Brix Andersen static void	glxiic_smb_map_interrupt(int irq);
254149d1c89SHenrik Brix Andersen static void 	glxiic_gpio_enable(struct glxiic_softc *sc);
255149d1c89SHenrik Brix Andersen static void 	glxiic_gpio_disable(struct glxiic_softc *sc);
256149d1c89SHenrik Brix Andersen static void	glxiic_smb_enable(struct glxiic_softc *sc, uint8_t speed,
257149d1c89SHenrik Brix Andersen     uint8_t addr);
258149d1c89SHenrik Brix Andersen static void	glxiic_smb_disable(struct glxiic_softc *sc);
259149d1c89SHenrik Brix Andersen 
260149d1c89SHenrik Brix Andersen static device_method_t glxiic_methods[] = {
261149d1c89SHenrik Brix Andersen 	DEVMETHOD(device_identify,	glxiic_identify),
262149d1c89SHenrik Brix Andersen 	DEVMETHOD(device_probe,		glxiic_probe),
263149d1c89SHenrik Brix Andersen 	DEVMETHOD(device_attach,	glxiic_attach),
264149d1c89SHenrik Brix Andersen 	DEVMETHOD(device_detach,	glxiic_detach),
265149d1c89SHenrik Brix Andersen 
266149d1c89SHenrik Brix Andersen 	DEVMETHOD(iicbus_reset,		glxiic_reset),
267149d1c89SHenrik Brix Andersen 	DEVMETHOD(iicbus_transfer,	glxiic_transfer),
268149d1c89SHenrik Brix Andersen 	DEVMETHOD(iicbus_callback,	iicbus_null_callback),
269149d1c89SHenrik Brix Andersen 
270149d1c89SHenrik Brix Andersen 	{ 0, 0 }
271149d1c89SHenrik Brix Andersen };
272149d1c89SHenrik Brix Andersen 
273149d1c89SHenrik Brix Andersen static driver_t glxiic_driver = {
274149d1c89SHenrik Brix Andersen 	"glxiic",
275149d1c89SHenrik Brix Andersen 	glxiic_methods,
276149d1c89SHenrik Brix Andersen 	sizeof(struct glxiic_softc),
277149d1c89SHenrik Brix Andersen };
278149d1c89SHenrik Brix Andersen 
279149d1c89SHenrik Brix Andersen static devclass_t glxiic_devclass;
280149d1c89SHenrik Brix Andersen 
281149d1c89SHenrik Brix Andersen DRIVER_MODULE(glxiic, isab, glxiic_driver, glxiic_devclass, 0, 0);
282*676ea8e1SJohn Baldwin DRIVER_MODULE(iicbus, glxiic, iicbus_driver, 0, 0);
283149d1c89SHenrik Brix Andersen MODULE_DEPEND(glxiic, iicbus, 1, 1, 1);
284149d1c89SHenrik Brix Andersen 
285149d1c89SHenrik Brix Andersen static void
286149d1c89SHenrik Brix Andersen glxiic_identify(driver_t *driver, device_t parent)
287149d1c89SHenrik Brix Andersen {
288149d1c89SHenrik Brix Andersen 
289149d1c89SHenrik Brix Andersen 	/* Prevent child from being added more than once. */
290149d1c89SHenrik Brix Andersen 	if (device_find_child(parent, driver->name, -1) != NULL)
291149d1c89SHenrik Brix Andersen 		return;
292149d1c89SHenrik Brix Andersen 
293149d1c89SHenrik Brix Andersen 	if (pci_get_devid(parent) == GLXIIC_CS5536_DEV_ID) {
294149d1c89SHenrik Brix Andersen 		if (device_add_child(parent, driver->name, -1) == NULL)
295149d1c89SHenrik Brix Andersen 			device_printf(parent, "Could not add glxiic child\n");
296149d1c89SHenrik Brix Andersen 	}
297149d1c89SHenrik Brix Andersen }
298149d1c89SHenrik Brix Andersen 
299149d1c89SHenrik Brix Andersen static int
300149d1c89SHenrik Brix Andersen glxiic_probe(device_t dev)
301149d1c89SHenrik Brix Andersen {
302149d1c89SHenrik Brix Andersen 
303a8de37b0SEitan Adler 	if (resource_disabled("glxiic", device_get_unit(dev)))
304a8de37b0SEitan Adler 		return (ENXIO);
305a8de37b0SEitan Adler 
306149d1c89SHenrik Brix Andersen 	device_set_desc(dev, "AMD Geode CS5536 SMBus controller");
307149d1c89SHenrik Brix Andersen 
308149d1c89SHenrik Brix Andersen 	return (BUS_PROBE_DEFAULT);
309149d1c89SHenrik Brix Andersen }
310149d1c89SHenrik Brix Andersen 
311149d1c89SHenrik Brix Andersen static int
312149d1c89SHenrik Brix Andersen glxiic_attach(device_t dev)
313149d1c89SHenrik Brix Andersen {
314149d1c89SHenrik Brix Andersen 	struct glxiic_softc *sc;
315149d1c89SHenrik Brix Andersen 	struct sysctl_ctx_list *ctx;
316149d1c89SHenrik Brix Andersen 	struct sysctl_oid *tree;
317149d1c89SHenrik Brix Andersen 	int error, irq, unit;
318149d1c89SHenrik Brix Andersen 	uint32_t irq_map;
319149d1c89SHenrik Brix Andersen 
320149d1c89SHenrik Brix Andersen 	sc = device_get_softc(dev);
321149d1c89SHenrik Brix Andersen 	sc->dev = dev;
322149d1c89SHenrik Brix Andersen 	sc->state = GLXIIC_STATE_IDLE;
323149d1c89SHenrik Brix Andersen 	error = 0;
324149d1c89SHenrik Brix Andersen 
325149d1c89SHenrik Brix Andersen 	GLXIIC_LOCK_INIT(sc);
326149d1c89SHenrik Brix Andersen 	callout_init_mtx(&sc->callout, &sc->mtx, 0);
327149d1c89SHenrik Brix Andersen 
328149d1c89SHenrik Brix Andersen 	sc->smb_rid = PCIR_BAR(0);
329149d1c89SHenrik Brix Andersen 	sc->smb_res = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &sc->smb_rid,
330149d1c89SHenrik Brix Andersen 	    RF_ACTIVE);
331149d1c89SHenrik Brix Andersen 	if (sc->smb_res == NULL) {
332149d1c89SHenrik Brix Andersen 		device_printf(dev, "Could not allocate SMBus I/O port\n");
333149d1c89SHenrik Brix Andersen 		error = ENXIO;
334149d1c89SHenrik Brix Andersen 		goto out;
335149d1c89SHenrik Brix Andersen 	}
336149d1c89SHenrik Brix Andersen 
337149d1c89SHenrik Brix Andersen 	sc->gpio_rid = PCIR_BAR(1);
338149d1c89SHenrik Brix Andersen 	sc->gpio_res = bus_alloc_resource_any(dev, SYS_RES_IOPORT,
339149d1c89SHenrik Brix Andersen 	    &sc->gpio_rid, RF_SHAREABLE | RF_ACTIVE);
340149d1c89SHenrik Brix Andersen 	if (sc->gpio_res == NULL) {
341149d1c89SHenrik Brix Andersen 		device_printf(dev, "Could not allocate GPIO I/O port\n");
342149d1c89SHenrik Brix Andersen 		error = ENXIO;
343149d1c89SHenrik Brix Andersen 		goto out;
344149d1c89SHenrik Brix Andersen 	}
345149d1c89SHenrik Brix Andersen 
346149d1c89SHenrik Brix Andersen 	/* Ensure the controller is not enabled by firmware. */
347149d1c89SHenrik Brix Andersen 	glxiic_smb_disable(sc);
348149d1c89SHenrik Brix Andersen 
349149d1c89SHenrik Brix Andersen 	/* Read the existing IRQ map. */
350149d1c89SHenrik Brix Andersen 	irq_map = rdmsr(GLXIIC_MSR_PIC_YSEL_HIGH);
351149d1c89SHenrik Brix Andersen 	sc->old_irq = GLXIIC_MAP_TO_SMB_IRQ(irq_map);
352149d1c89SHenrik Brix Andersen 
353149d1c89SHenrik Brix Andersen 	unit = device_get_unit(dev);
354149d1c89SHenrik Brix Andersen 	if (resource_int_value("glxiic", unit, "irq", &irq) == 0) {
355149d1c89SHenrik Brix Andersen 		if (irq < 1 || irq > 15) {
356149d1c89SHenrik Brix Andersen 			device_printf(dev, "Bad value %d for glxiic.%d.irq\n",
357149d1c89SHenrik Brix Andersen 			    irq, unit);
358149d1c89SHenrik Brix Andersen 			error = ENXIO;
359149d1c89SHenrik Brix Andersen 			goto out;
360149d1c89SHenrik Brix Andersen 		}
361149d1c89SHenrik Brix Andersen 
362149d1c89SHenrik Brix Andersen 		if (bootverbose)
363149d1c89SHenrik Brix Andersen 			device_printf(dev, "Using irq %d set by hint\n", irq);
364149d1c89SHenrik Brix Andersen 	} else if (sc->old_irq != 0) {
365149d1c89SHenrik Brix Andersen 		if (bootverbose)
366149d1c89SHenrik Brix Andersen 			device_printf(dev, "Using irq %d set by firmware\n",
367149d1c89SHenrik Brix Andersen 			    irq);
368149d1c89SHenrik Brix Andersen 		irq = sc->old_irq;
369149d1c89SHenrik Brix Andersen 	} else {
370149d1c89SHenrik Brix Andersen 		device_printf(dev, "No irq mapped by firmware");
371149d1c89SHenrik Brix Andersen 		printf(" and no glxiic.%d.irq hint provided\n", unit);
372149d1c89SHenrik Brix Andersen 		error = ENXIO;
373149d1c89SHenrik Brix Andersen 		goto out;
374149d1c89SHenrik Brix Andersen 	}
375149d1c89SHenrik Brix Andersen 
376149d1c89SHenrik Brix Andersen 	/* Map the SMBus interrupt to the requested legacy IRQ. */
377149d1c89SHenrik Brix Andersen 	glxiic_smb_map_interrupt(irq);
378149d1c89SHenrik Brix Andersen 
379149d1c89SHenrik Brix Andersen 	sc->irq_rid = 0;
380149d1c89SHenrik Brix Andersen 	sc->irq_res = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->irq_rid,
381149d1c89SHenrik Brix Andersen 	    irq, irq, 1, RF_SHAREABLE | RF_ACTIVE);
382149d1c89SHenrik Brix Andersen 	if (sc->irq_res == NULL) {
383149d1c89SHenrik Brix Andersen 		device_printf(dev, "Could not allocate IRQ %d\n", irq);
384149d1c89SHenrik Brix Andersen 		error = ENXIO;
385149d1c89SHenrik Brix Andersen 		goto out;
386149d1c89SHenrik Brix Andersen 	}
387149d1c89SHenrik Brix Andersen 
388149d1c89SHenrik Brix Andersen 	error = bus_setup_intr(dev, sc->irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
389149d1c89SHenrik Brix Andersen 	    NULL, glxiic_intr, sc, &(sc->irq_handler));
390149d1c89SHenrik Brix Andersen 	if (error != 0) {
391149d1c89SHenrik Brix Andersen 		device_printf(dev, "Could not setup IRQ handler\n");
392149d1c89SHenrik Brix Andersen 		error = ENXIO;
393149d1c89SHenrik Brix Andersen 		goto out;
394149d1c89SHenrik Brix Andersen 	}
395149d1c89SHenrik Brix Andersen 
396149d1c89SHenrik Brix Andersen 	if ((sc->iicbus = device_add_child(dev, "iicbus", -1)) == NULL) {
397149d1c89SHenrik Brix Andersen 		device_printf(dev, "Could not allocate iicbus instance\n");
398149d1c89SHenrik Brix Andersen 		error = ENXIO;
399149d1c89SHenrik Brix Andersen 		goto out;
400149d1c89SHenrik Brix Andersen 	}
401149d1c89SHenrik Brix Andersen 
402149d1c89SHenrik Brix Andersen 	ctx = device_get_sysctl_ctx(dev);
403149d1c89SHenrik Brix Andersen 	tree = device_get_sysctl_tree(dev);
404149d1c89SHenrik Brix Andersen 
405149d1c89SHenrik Brix Andersen 	sc->timeout = GLXIIC_DEFAULT_TIMEOUT;
406149d1c89SHenrik Brix Andersen 	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
407af3b2549SHans Petter Selasky 	    "timeout", CTLFLAG_RWTUN, &sc->timeout, 0,
408149d1c89SHenrik Brix Andersen 	    "activity timeout in ms");
409149d1c89SHenrik Brix Andersen 
410149d1c89SHenrik Brix Andersen 	glxiic_gpio_enable(sc);
411149d1c89SHenrik Brix Andersen 	glxiic_smb_enable(sc, IIC_FASTEST, 0);
412149d1c89SHenrik Brix Andersen 
4131e4042d4SIan Lepore 	/* Probe and attach the iicbus when interrupts are available. */
414b832a7e5SWarner Losh 	error = bus_delayed_attach_children(dev);
4151e4042d4SIan Lepore 
416149d1c89SHenrik Brix Andersen out:
417149d1c89SHenrik Brix Andersen 	if (error != 0) {
418149d1c89SHenrik Brix Andersen 		callout_drain(&sc->callout);
419149d1c89SHenrik Brix Andersen 
420149d1c89SHenrik Brix Andersen 		if (sc->iicbus != NULL)
421149d1c89SHenrik Brix Andersen 			device_delete_child(dev, sc->iicbus);
422149d1c89SHenrik Brix Andersen 		if (sc->smb_res != NULL) {
423149d1c89SHenrik Brix Andersen 			glxiic_smb_disable(sc);
424149d1c89SHenrik Brix Andersen 			bus_release_resource(dev, SYS_RES_IOPORT, sc->smb_rid,
425149d1c89SHenrik Brix Andersen 			    sc->smb_res);
426149d1c89SHenrik Brix Andersen 		}
427149d1c89SHenrik Brix Andersen 		if (sc->gpio_res != NULL) {
428149d1c89SHenrik Brix Andersen 			glxiic_gpio_disable(sc);
429149d1c89SHenrik Brix Andersen 			bus_release_resource(dev, SYS_RES_IOPORT, sc->gpio_rid,
430149d1c89SHenrik Brix Andersen 			    sc->gpio_res);
431149d1c89SHenrik Brix Andersen 		}
432149d1c89SHenrik Brix Andersen 		if (sc->irq_handler != NULL)
433149d1c89SHenrik Brix Andersen 			bus_teardown_intr(dev, sc->irq_res, sc->irq_handler);
434149d1c89SHenrik Brix Andersen 		if (sc->irq_res != NULL)
435149d1c89SHenrik Brix Andersen 			bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid,
436149d1c89SHenrik Brix Andersen 			    sc->irq_res);
437149d1c89SHenrik Brix Andersen 
438149d1c89SHenrik Brix Andersen 		/* Restore the old SMBus interrupt mapping. */
439149d1c89SHenrik Brix Andersen 		glxiic_smb_map_interrupt(sc->old_irq);
440149d1c89SHenrik Brix Andersen 
441149d1c89SHenrik Brix Andersen 		GLXIIC_LOCK_DESTROY(sc);
442149d1c89SHenrik Brix Andersen 	}
443149d1c89SHenrik Brix Andersen 
444149d1c89SHenrik Brix Andersen 	return (error);
445149d1c89SHenrik Brix Andersen }
446149d1c89SHenrik Brix Andersen 
447149d1c89SHenrik Brix Andersen static int
448149d1c89SHenrik Brix Andersen glxiic_detach(device_t dev)
449149d1c89SHenrik Brix Andersen {
450149d1c89SHenrik Brix Andersen 	struct glxiic_softc *sc;
451149d1c89SHenrik Brix Andersen 	int error;
452149d1c89SHenrik Brix Andersen 
453149d1c89SHenrik Brix Andersen 	sc = device_get_softc(dev);
454149d1c89SHenrik Brix Andersen 
455149d1c89SHenrik Brix Andersen 	error = bus_generic_detach(dev);
456149d1c89SHenrik Brix Andersen 	if (error != 0)
457149d1c89SHenrik Brix Andersen 		goto out;
458149d1c89SHenrik Brix Andersen 	if (sc->iicbus != NULL)
459149d1c89SHenrik Brix Andersen 		error = device_delete_child(dev, sc->iicbus);
460149d1c89SHenrik Brix Andersen 
461149d1c89SHenrik Brix Andersen out:
462149d1c89SHenrik Brix Andersen 	callout_drain(&sc->callout);
463149d1c89SHenrik Brix Andersen 
464149d1c89SHenrik Brix Andersen 	if (sc->smb_res != NULL) {
465149d1c89SHenrik Brix Andersen 		glxiic_smb_disable(sc);
466149d1c89SHenrik Brix Andersen 		bus_release_resource(dev, SYS_RES_IOPORT, sc->smb_rid,
467149d1c89SHenrik Brix Andersen 		    sc->smb_res);
468149d1c89SHenrik Brix Andersen 	}
469149d1c89SHenrik Brix Andersen 	if (sc->gpio_res != NULL) {
470149d1c89SHenrik Brix Andersen 		glxiic_gpio_disable(sc);
471149d1c89SHenrik Brix Andersen 		bus_release_resource(dev, SYS_RES_IOPORT, sc->gpio_rid,
472149d1c89SHenrik Brix Andersen 		    sc->gpio_res);
473149d1c89SHenrik Brix Andersen 	}
474149d1c89SHenrik Brix Andersen 	if (sc->irq_handler != NULL)
475149d1c89SHenrik Brix Andersen 		bus_teardown_intr(dev, sc->irq_res, sc->irq_handler);
476149d1c89SHenrik Brix Andersen 	if (sc->irq_res != NULL)
477149d1c89SHenrik Brix Andersen 		bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid,
478149d1c89SHenrik Brix Andersen 		    sc->irq_res);
479149d1c89SHenrik Brix Andersen 
480149d1c89SHenrik Brix Andersen 	/* Restore the old SMBus interrupt mapping. */
481149d1c89SHenrik Brix Andersen 	glxiic_smb_map_interrupt(sc->old_irq);
482149d1c89SHenrik Brix Andersen 
483149d1c89SHenrik Brix Andersen 	GLXIIC_LOCK_DESTROY(sc);
484149d1c89SHenrik Brix Andersen 
485149d1c89SHenrik Brix Andersen 	return (error);
486149d1c89SHenrik Brix Andersen }
487149d1c89SHenrik Brix Andersen 
488149d1c89SHenrik Brix Andersen static uint8_t
489149d1c89SHenrik Brix Andersen glxiic_read_status_locked(struct glxiic_softc *sc)
490149d1c89SHenrik Brix Andersen {
491149d1c89SHenrik Brix Andersen 	uint8_t status;
492149d1c89SHenrik Brix Andersen 
493149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
494149d1c89SHenrik Brix Andersen 
495149d1c89SHenrik Brix Andersen 	status = bus_read_1(sc->smb_res, GLXIIC_SMB_STS);
496149d1c89SHenrik Brix Andersen 
497149d1c89SHenrik Brix Andersen 	/* Clear all status flags except SDAST and STASTR after reading. */
498149d1c89SHenrik Brix Andersen 	bus_write_1(sc->smb_res, GLXIIC_SMB_STS, (GLXIIC_SMB_STS_SLVSTP_BIT |
499149d1c89SHenrik Brix Andersen 		GLXIIC_SMB_STS_BER_BIT | GLXIIC_SMB_STS_NEGACK_BIT |
500149d1c89SHenrik Brix Andersen 		GLXIIC_SMB_STS_NMATCH_BIT));
501149d1c89SHenrik Brix Andersen 
502149d1c89SHenrik Brix Andersen 	return (status);
503149d1c89SHenrik Brix Andersen }
504149d1c89SHenrik Brix Andersen 
505149d1c89SHenrik Brix Andersen static void
506149d1c89SHenrik Brix Andersen glxiic_stop_locked(struct glxiic_softc *sc)
507149d1c89SHenrik Brix Andersen {
508149d1c89SHenrik Brix Andersen 	uint8_t status, ctrl1;
509149d1c89SHenrik Brix Andersen 
510149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
511149d1c89SHenrik Brix Andersen 
512149d1c89SHenrik Brix Andersen 	status = glxiic_read_status_locked(sc);
513149d1c89SHenrik Brix Andersen 
514149d1c89SHenrik Brix Andersen 	ctrl1 = bus_read_1(sc->smb_res, GLXIIC_SMB_CTRL1);
515149d1c89SHenrik Brix Andersen 	bus_write_1(sc->smb_res, GLXIIC_SMB_CTRL1,
516149d1c89SHenrik Brix Andersen 	    ctrl1 | GLXIIC_SMB_CTRL1_STOP_BIT);
517149d1c89SHenrik Brix Andersen 
518149d1c89SHenrik Brix Andersen 	/*
519149d1c89SHenrik Brix Andersen 	 * Perform a dummy read of SDA in master receive mode to clear
520149d1c89SHenrik Brix Andersen 	 * SDAST if set.
521149d1c89SHenrik Brix Andersen 	 */
522149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_XMIT_BIT) == 0 &&
523149d1c89SHenrik Brix Andersen 	    (status & GLXIIC_SMB_STS_SDAST_BIT) != 0)
524149d1c89SHenrik Brix Andersen 	 	bus_read_1(sc->smb_res, GLXIIC_SMB_SDA);
525149d1c89SHenrik Brix Andersen 
526149d1c89SHenrik Brix Andersen 	/* Check stall after start bit and clear if needed */
527149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_STASTR_BIT) != 0) {
528149d1c89SHenrik Brix Andersen 		bus_write_1(sc->smb_res, GLXIIC_SMB_STS,
529149d1c89SHenrik Brix Andersen 		    GLXIIC_SMB_STS_STASTR_BIT);
530149d1c89SHenrik Brix Andersen 	}
531149d1c89SHenrik Brix Andersen }
532149d1c89SHenrik Brix Andersen 
533149d1c89SHenrik Brix Andersen static void
534149d1c89SHenrik Brix Andersen glxiic_timeout(void *arg)
535149d1c89SHenrik Brix Andersen {
536149d1c89SHenrik Brix Andersen 	struct glxiic_softc *sc;
537149d1c89SHenrik Brix Andersen 	uint8_t error;
538149d1c89SHenrik Brix Andersen 
539149d1c89SHenrik Brix Andersen 	sc = (struct glxiic_softc *)arg;
540149d1c89SHenrik Brix Andersen 
541da25396aSHenrik Brix Andersen 	GLXIIC_DEBUG_LOG("timeout in state %d", sc->state);
542149d1c89SHenrik Brix Andersen 
543149d1c89SHenrik Brix Andersen 	if (glxiic_state_table[sc->state].master) {
544149d1c89SHenrik Brix Andersen 		sc->error = IIC_ETIMEOUT;
545149d1c89SHenrik Brix Andersen 		GLXIIC_WAKEUP(sc);
546149d1c89SHenrik Brix Andersen 	} else {
547149d1c89SHenrik Brix Andersen 		error = IIC_ETIMEOUT;
548149d1c89SHenrik Brix Andersen 		iicbus_intr(sc->iicbus, INTR_ERROR, &error);
549149d1c89SHenrik Brix Andersen 	}
550149d1c89SHenrik Brix Andersen 
551149d1c89SHenrik Brix Andersen 	glxiic_smb_disable(sc);
552149d1c89SHenrik Brix Andersen 	glxiic_smb_enable(sc, IIC_UNKNOWN, sc->addr);
553149d1c89SHenrik Brix Andersen 	glxiic_set_state_locked(sc, GLXIIC_STATE_IDLE);
554149d1c89SHenrik Brix Andersen }
555149d1c89SHenrik Brix Andersen 
556149d1c89SHenrik Brix Andersen static void
557149d1c89SHenrik Brix Andersen glxiic_start_timeout_locked(struct glxiic_softc *sc)
558149d1c89SHenrik Brix Andersen {
559149d1c89SHenrik Brix Andersen 
560149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
561149d1c89SHenrik Brix Andersen 
56285c9dd9dSSteven Hartland 	callout_reset_sbt(&sc->callout, SBT_1MS * sc->timeout, 0,
56385c9dd9dSSteven Hartland 	    glxiic_timeout, sc, 0);
564149d1c89SHenrik Brix Andersen }
565149d1c89SHenrik Brix Andersen 
566149d1c89SHenrik Brix Andersen static void
567149d1c89SHenrik Brix Andersen glxiic_set_state_locked(struct glxiic_softc *sc, glxiic_state_t state)
568149d1c89SHenrik Brix Andersen {
569149d1c89SHenrik Brix Andersen 
570149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
571149d1c89SHenrik Brix Andersen 
572149d1c89SHenrik Brix Andersen 	if (state == GLXIIC_STATE_IDLE)
573149d1c89SHenrik Brix Andersen 		callout_stop(&sc->callout);
574149d1c89SHenrik Brix Andersen 	else if (sc->timeout > 0)
575149d1c89SHenrik Brix Andersen 		glxiic_start_timeout_locked(sc);
576149d1c89SHenrik Brix Andersen 
577149d1c89SHenrik Brix Andersen 	sc->state = state;
578149d1c89SHenrik Brix Andersen }
579149d1c89SHenrik Brix Andersen 
580149d1c89SHenrik Brix Andersen static int
581149d1c89SHenrik Brix Andersen glxiic_handle_slave_match_locked(struct glxiic_softc *sc, uint8_t status)
582149d1c89SHenrik Brix Andersen {
583149d1c89SHenrik Brix Andersen 	uint8_t ctrl_sts, addr;
584149d1c89SHenrik Brix Andersen 
585149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
586149d1c89SHenrik Brix Andersen 
587149d1c89SHenrik Brix Andersen 	ctrl_sts = bus_read_1(sc->smb_res, GLXIIC_SMB_CTRL_STS);
588149d1c89SHenrik Brix Andersen 
589149d1c89SHenrik Brix Andersen 	if ((ctrl_sts & GLXIIC_SMB_CTRL_STS_MATCH_BIT) != 0) {
590149d1c89SHenrik Brix Andersen 		if ((status & GLXIIC_SMB_STS_XMIT_BIT) != 0) {
591149d1c89SHenrik Brix Andersen 			addr = sc->addr | LSB;
592149d1c89SHenrik Brix Andersen 			glxiic_set_state_locked(sc,
593149d1c89SHenrik Brix Andersen 			    GLXIIC_STATE_SLAVE_TX);
594149d1c89SHenrik Brix Andersen 		} else {
595149d1c89SHenrik Brix Andersen 			addr = sc->addr & ~LSB;
596149d1c89SHenrik Brix Andersen 			glxiic_set_state_locked(sc,
597149d1c89SHenrik Brix Andersen 			    GLXIIC_STATE_SLAVE_RX);
598149d1c89SHenrik Brix Andersen 		}
599149d1c89SHenrik Brix Andersen 		iicbus_intr(sc->iicbus, INTR_START, &addr);
600149d1c89SHenrik Brix Andersen 	} else if ((ctrl_sts & GLXIIC_SMB_CTRL_STS_GCMTCH_BIT) != 0) {
601149d1c89SHenrik Brix Andersen 		addr = 0;
602149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_SLAVE_RX);
603149d1c89SHenrik Brix Andersen 		iicbus_intr(sc->iicbus, INTR_GENERAL, &addr);
604149d1c89SHenrik Brix Andersen 	} else {
605da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("unknown slave match");
606149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
607149d1c89SHenrik Brix Andersen 	}
608149d1c89SHenrik Brix Andersen 
609149d1c89SHenrik Brix Andersen 	return (IIC_NOERR);
610149d1c89SHenrik Brix Andersen }
611149d1c89SHenrik Brix Andersen 
612149d1c89SHenrik Brix Andersen static int
613149d1c89SHenrik Brix Andersen glxiic_state_idle_callback(struct glxiic_softc *sc, uint8_t status)
614149d1c89SHenrik Brix Andersen {
615149d1c89SHenrik Brix Andersen 
616149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
617149d1c89SHenrik Brix Andersen 
618149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_BER_BIT) != 0) {
619da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("bus error in idle");
620149d1c89SHenrik Brix Andersen 		return (IIC_EBUSERR);
621149d1c89SHenrik Brix Andersen 	}
622149d1c89SHenrik Brix Andersen 
623149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_NMATCH_BIT) != 0) {
624149d1c89SHenrik Brix Andersen 		return (glxiic_handle_slave_match_locked(sc, status));
625149d1c89SHenrik Brix Andersen 	}
626149d1c89SHenrik Brix Andersen 
627149d1c89SHenrik Brix Andersen 	return (IIC_NOERR);
628149d1c89SHenrik Brix Andersen }
629149d1c89SHenrik Brix Andersen 
630149d1c89SHenrik Brix Andersen static int
631149d1c89SHenrik Brix Andersen glxiic_state_slave_tx_callback(struct glxiic_softc *sc, uint8_t status)
632149d1c89SHenrik Brix Andersen {
633149d1c89SHenrik Brix Andersen 	uint8_t data;
634149d1c89SHenrik Brix Andersen 
635149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
636149d1c89SHenrik Brix Andersen 
637149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_BER_BIT) != 0) {
638da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("bus error in slave tx");
639149d1c89SHenrik Brix Andersen 		return (IIC_EBUSERR);
640149d1c89SHenrik Brix Andersen 	}
641149d1c89SHenrik Brix Andersen 
642149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_SLVSTP_BIT) != 0) {
643149d1c89SHenrik Brix Andersen 		iicbus_intr(sc->iicbus, INTR_STOP, NULL);
644149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_IDLE);
645149d1c89SHenrik Brix Andersen 		return (IIC_NOERR);
646149d1c89SHenrik Brix Andersen 	}
647149d1c89SHenrik Brix Andersen 
648149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_NEGACK_BIT) != 0) {
649149d1c89SHenrik Brix Andersen 		iicbus_intr(sc->iicbus, INTR_NOACK, NULL);
650149d1c89SHenrik Brix Andersen 		return (IIC_NOERR);
651149d1c89SHenrik Brix Andersen 	}
652149d1c89SHenrik Brix Andersen 
653149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_NMATCH_BIT) != 0) {
654149d1c89SHenrik Brix Andersen 		/* Handle repeated start in slave mode. */
655149d1c89SHenrik Brix Andersen 		return (glxiic_handle_slave_match_locked(sc, status));
656149d1c89SHenrik Brix Andersen 	}
657149d1c89SHenrik Brix Andersen 
658149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_SDAST_BIT) == 0) {
659da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("not awaiting data in slave tx");
660149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
661149d1c89SHenrik Brix Andersen 	}
662149d1c89SHenrik Brix Andersen 
663149d1c89SHenrik Brix Andersen 	iicbus_intr(sc->iicbus, INTR_TRANSMIT, &data);
664149d1c89SHenrik Brix Andersen 	bus_write_1(sc->smb_res, GLXIIC_SMB_SDA, data);
665149d1c89SHenrik Brix Andersen 
666149d1c89SHenrik Brix Andersen 	glxiic_start_timeout_locked(sc);
667149d1c89SHenrik Brix Andersen 
668149d1c89SHenrik Brix Andersen 	return (IIC_NOERR);
669149d1c89SHenrik Brix Andersen }
670149d1c89SHenrik Brix Andersen 
671149d1c89SHenrik Brix Andersen static int
672149d1c89SHenrik Brix Andersen glxiic_state_slave_rx_callback(struct glxiic_softc *sc, uint8_t status)
673149d1c89SHenrik Brix Andersen {
674149d1c89SHenrik Brix Andersen 	uint8_t data;
675149d1c89SHenrik Brix Andersen 
676149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
677149d1c89SHenrik Brix Andersen 
678149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_BER_BIT) != 0) {
679da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("bus error in slave rx");
680149d1c89SHenrik Brix Andersen 		return (IIC_EBUSERR);
681149d1c89SHenrik Brix Andersen 	}
682149d1c89SHenrik Brix Andersen 
683149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_SLVSTP_BIT) != 0) {
684149d1c89SHenrik Brix Andersen 		iicbus_intr(sc->iicbus, INTR_STOP, NULL);
685149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_IDLE);
686149d1c89SHenrik Brix Andersen 		return (IIC_NOERR);
687149d1c89SHenrik Brix Andersen 	}
688149d1c89SHenrik Brix Andersen 
689149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_NMATCH_BIT) != 0) {
690149d1c89SHenrik Brix Andersen 		/* Handle repeated start in slave mode. */
691149d1c89SHenrik Brix Andersen 		return (glxiic_handle_slave_match_locked(sc, status));
692149d1c89SHenrik Brix Andersen 	}
693149d1c89SHenrik Brix Andersen 
694149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_SDAST_BIT) == 0) {
695da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("no pending data in slave rx");
696149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
697149d1c89SHenrik Brix Andersen 	}
698149d1c89SHenrik Brix Andersen 
699149d1c89SHenrik Brix Andersen 	data = bus_read_1(sc->smb_res, GLXIIC_SMB_SDA);
700149d1c89SHenrik Brix Andersen 	iicbus_intr(sc->iicbus, INTR_RECEIVE, &data);
701149d1c89SHenrik Brix Andersen 
702149d1c89SHenrik Brix Andersen 	glxiic_start_timeout_locked(sc);
703149d1c89SHenrik Brix Andersen 
704149d1c89SHenrik Brix Andersen 	return (IIC_NOERR);
705149d1c89SHenrik Brix Andersen }
706149d1c89SHenrik Brix Andersen 
707149d1c89SHenrik Brix Andersen static int
708149d1c89SHenrik Brix Andersen glxiic_state_master_addr_callback(struct glxiic_softc *sc, uint8_t status)
709149d1c89SHenrik Brix Andersen {
710149d1c89SHenrik Brix Andersen 	uint8_t slave;
71155e79db6SDaichi GOTO 	uint8_t ctrl1;
712149d1c89SHenrik Brix Andersen 
713149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
714149d1c89SHenrik Brix Andersen 
715149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_BER_BIT) != 0) {
716da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("bus error after master start");
717149d1c89SHenrik Brix Andersen 		return (IIC_EBUSERR);
718149d1c89SHenrik Brix Andersen 	}
719149d1c89SHenrik Brix Andersen 
720149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_MASTER_BIT) == 0) {
721da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("not bus master after master start");
722149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
723149d1c89SHenrik Brix Andersen 	}
724149d1c89SHenrik Brix Andersen 
725149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_SDAST_BIT) == 0) {
726da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("not awaiting address in master addr");
727149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
728149d1c89SHenrik Brix Andersen 	}
729149d1c89SHenrik Brix Andersen 
730149d1c89SHenrik Brix Andersen 	if ((sc->msg->flags & IIC_M_RD) != 0) {
731149d1c89SHenrik Brix Andersen 		slave = sc->msg->slave | LSB;
732149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_MASTER_RX);
733149d1c89SHenrik Brix Andersen 	} else {
734149d1c89SHenrik Brix Andersen 		slave = sc->msg->slave & ~LSB;
735149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_MASTER_TX);
736149d1c89SHenrik Brix Andersen 	}
737149d1c89SHenrik Brix Andersen 
738149d1c89SHenrik Brix Andersen 	sc->data = sc->msg->buf;
739149d1c89SHenrik Brix Andersen 	sc->ndata = sc->msg->len;
740149d1c89SHenrik Brix Andersen 
741149d1c89SHenrik Brix Andersen 	/* Handle address-only transfer. */
742149d1c89SHenrik Brix Andersen 	if (sc->ndata == 0)
743149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_MASTER_STOP);
744149d1c89SHenrik Brix Andersen 
745149d1c89SHenrik Brix Andersen 	bus_write_1(sc->smb_res, GLXIIC_SMB_SDA, slave);
746149d1c89SHenrik Brix Andersen 
74755e79db6SDaichi GOTO 	if ((sc->msg->flags & IIC_M_RD) != 0 && sc->ndata == 1) {
74855e79db6SDaichi GOTO 		/* Last byte from slave, set NACK. */
74955e79db6SDaichi GOTO 		ctrl1 = bus_read_1(sc->smb_res, GLXIIC_SMB_CTRL1);
75055e79db6SDaichi GOTO 		bus_write_1(sc->smb_res, GLXIIC_SMB_CTRL1,
75155e79db6SDaichi GOTO 		    ctrl1 | GLXIIC_SMB_CTRL1_ACK_BIT);
75255e79db6SDaichi GOTO 	}
75355e79db6SDaichi GOTO 
754149d1c89SHenrik Brix Andersen 	return (IIC_NOERR);
755149d1c89SHenrik Brix Andersen }
756149d1c89SHenrik Brix Andersen 
757149d1c89SHenrik Brix Andersen static int
758149d1c89SHenrik Brix Andersen glxiic_state_master_tx_callback(struct glxiic_softc *sc, uint8_t status)
759149d1c89SHenrik Brix Andersen {
760149d1c89SHenrik Brix Andersen 
761149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
762149d1c89SHenrik Brix Andersen 
763149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_BER_BIT) != 0) {
764da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("bus error in master tx");
765149d1c89SHenrik Brix Andersen 		return (IIC_EBUSERR);
766149d1c89SHenrik Brix Andersen 	}
767149d1c89SHenrik Brix Andersen 
768149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_MASTER_BIT) == 0) {
769da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("not bus master in master tx");
770149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
771149d1c89SHenrik Brix Andersen 	}
772149d1c89SHenrik Brix Andersen 
773149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_NEGACK_BIT) != 0) {
774da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("slave nack in master tx");
775149d1c89SHenrik Brix Andersen 		return (IIC_ENOACK);
776149d1c89SHenrik Brix Andersen 	}
777149d1c89SHenrik Brix Andersen 
778149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_STASTR_BIT) != 0) {
779149d1c89SHenrik Brix Andersen 		bus_write_1(sc->smb_res, GLXIIC_SMB_STS,
780149d1c89SHenrik Brix Andersen 		    GLXIIC_SMB_STS_STASTR_BIT);
781149d1c89SHenrik Brix Andersen 	}
782149d1c89SHenrik Brix Andersen 
783149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_SDAST_BIT) == 0) {
784da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("not awaiting data in master tx");
785149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
786149d1c89SHenrik Brix Andersen 	}
787149d1c89SHenrik Brix Andersen 
788149d1c89SHenrik Brix Andersen 	bus_write_1(sc->smb_res, GLXIIC_SMB_SDA, *sc->data++);
789149d1c89SHenrik Brix Andersen 	if (--sc->ndata == 0)
790149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_MASTER_STOP);
791149d1c89SHenrik Brix Andersen 	else
792149d1c89SHenrik Brix Andersen 		glxiic_start_timeout_locked(sc);
793149d1c89SHenrik Brix Andersen 
794149d1c89SHenrik Brix Andersen 	return (IIC_NOERR);
795149d1c89SHenrik Brix Andersen }
796149d1c89SHenrik Brix Andersen 
797149d1c89SHenrik Brix Andersen static int
798149d1c89SHenrik Brix Andersen glxiic_state_master_rx_callback(struct glxiic_softc *sc, uint8_t status)
799149d1c89SHenrik Brix Andersen {
800149d1c89SHenrik Brix Andersen 	uint8_t ctrl1;
801149d1c89SHenrik Brix Andersen 
802149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
803149d1c89SHenrik Brix Andersen 
804149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_BER_BIT) != 0) {
805da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("bus error in master rx");
806149d1c89SHenrik Brix Andersen 		return (IIC_EBUSERR);
807149d1c89SHenrik Brix Andersen 	}
808149d1c89SHenrik Brix Andersen 
809149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_MASTER_BIT) == 0) {
810da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("not bus master in master rx");
811149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
812149d1c89SHenrik Brix Andersen 	}
813149d1c89SHenrik Brix Andersen 
814149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_NEGACK_BIT) != 0) {
815da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("slave nack in rx");
816149d1c89SHenrik Brix Andersen 		return (IIC_ENOACK);
817149d1c89SHenrik Brix Andersen 	}
818149d1c89SHenrik Brix Andersen 
819149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_STASTR_BIT) != 0) {
820149d1c89SHenrik Brix Andersen 		/* Bus is stalled, clear and wait for data. */
821149d1c89SHenrik Brix Andersen 		bus_write_1(sc->smb_res, GLXIIC_SMB_STS,
822149d1c89SHenrik Brix Andersen 		    GLXIIC_SMB_STS_STASTR_BIT);
823149d1c89SHenrik Brix Andersen 		return (IIC_NOERR);
824149d1c89SHenrik Brix Andersen 	}
825149d1c89SHenrik Brix Andersen 
826149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_SDAST_BIT) == 0) {
827da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("no pending data in master rx");
828149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
829149d1c89SHenrik Brix Andersen 	}
830149d1c89SHenrik Brix Andersen 
831149d1c89SHenrik Brix Andersen 	*sc->data++ = bus_read_1(sc->smb_res, GLXIIC_SMB_SDA);
832149d1c89SHenrik Brix Andersen 	if (--sc->ndata == 0) {
833149d1c89SHenrik Brix Andersen 		/* Proceed with stop on reading last byte. */
834149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_MASTER_STOP);
835149d1c89SHenrik Brix Andersen 		return (glxiic_state_table[sc->state].callback(sc, status));
836149d1c89SHenrik Brix Andersen 	}
837149d1c89SHenrik Brix Andersen 
83855e79db6SDaichi GOTO 	if (sc->ndata == 1) {
83955e79db6SDaichi GOTO 		/* Last byte from slave, set NACK. */
84055e79db6SDaichi GOTO 		ctrl1 = bus_read_1(sc->smb_res, GLXIIC_SMB_CTRL1);
84155e79db6SDaichi GOTO 		bus_write_1(sc->smb_res, GLXIIC_SMB_CTRL1,
84255e79db6SDaichi GOTO 		    ctrl1 | GLXIIC_SMB_CTRL1_ACK_BIT);
84355e79db6SDaichi GOTO 	}
84455e79db6SDaichi GOTO 
845149d1c89SHenrik Brix Andersen 	glxiic_start_timeout_locked(sc);
846149d1c89SHenrik Brix Andersen 
847149d1c89SHenrik Brix Andersen 	return (IIC_NOERR);
848149d1c89SHenrik Brix Andersen }
849149d1c89SHenrik Brix Andersen 
850149d1c89SHenrik Brix Andersen static int
851149d1c89SHenrik Brix Andersen glxiic_state_master_stop_callback(struct glxiic_softc *sc, uint8_t status)
852149d1c89SHenrik Brix Andersen {
853149d1c89SHenrik Brix Andersen 	uint8_t ctrl1;
854149d1c89SHenrik Brix Andersen 
855149d1c89SHenrik Brix Andersen 	GLXIIC_ASSERT_LOCKED(sc);
856149d1c89SHenrik Brix Andersen 
857149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_BER_BIT) != 0) {
858da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("bus error in master stop");
859149d1c89SHenrik Brix Andersen 		return (IIC_EBUSERR);
860149d1c89SHenrik Brix Andersen 	}
861149d1c89SHenrik Brix Andersen 
862149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_MASTER_BIT) == 0) {
863da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("not bus master in master stop");
864149d1c89SHenrik Brix Andersen 		return (IIC_ESTATUS);
865149d1c89SHenrik Brix Andersen 	}
866149d1c89SHenrik Brix Andersen 
867149d1c89SHenrik Brix Andersen 	if ((status & GLXIIC_SMB_STS_NEGACK_BIT) != 0) {
868da25396aSHenrik Brix Andersen 		GLXIIC_DEBUG_LOG("slave nack in master stop");
869149d1c89SHenrik Brix Andersen 		return (IIC_ENOACK);
870149d1c89SHenrik Brix Andersen 	}
871149d1c89SHenrik Brix Andersen 
872149d1c89SHenrik Brix Andersen 	if (--sc->nmsgs > 0) {
873149d1c89SHenrik Brix Andersen 		/* Start transfer of next message. */
874149d1c89SHenrik Brix Andersen 		if ((sc->msg->flags & IIC_M_NOSTOP) == 0) {
875149d1c89SHenrik Brix Andersen 			glxiic_stop_locked(sc);
876149d1c89SHenrik Brix Andersen 		}
877149d1c89SHenrik Brix Andersen 
878149d1c89SHenrik Brix Andersen 		ctrl1 = bus_read_1(sc->smb_res, GLXIIC_SMB_CTRL1);
879149d1c89SHenrik Brix Andersen 		bus_write_1(sc->smb_res, GLXIIC_SMB_CTRL1,
880149d1c89SHenrik Brix Andersen 		    ctrl1 | GLXIIC_SMB_CTRL1_START_BIT);
881149d1c89SHenrik Brix Andersen 
882149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_MASTER_ADDR);
883149d1c89SHenrik Brix Andersen 		sc->msg++;
884149d1c89SHenrik Brix Andersen 	} else {
885149d1c89SHenrik Brix Andersen 		/* Last message. */
886149d1c89SHenrik Brix Andersen 		glxiic_stop_locked(sc);
887149d1c89SHenrik Brix Andersen 		glxiic_set_state_locked(sc, GLXIIC_STATE_IDLE);
888149d1c89SHenrik Brix Andersen 		sc->error = IIC_NOERR;
889149d1c89SHenrik Brix Andersen 		GLXIIC_WAKEUP(sc);
890149d1c89SHenrik Brix Andersen 	}
891149d1c89SHenrik Brix Andersen 
892149d1c89SHenrik Brix Andersen 	return (IIC_NOERR);
893149d1c89SHenrik Brix Andersen }
894149d1c89SHenrik Brix Andersen 
895149d1c89SHenrik Brix Andersen static void
896149d1c89SHenrik Brix Andersen glxiic_intr(void *arg)
897149d1c89SHenrik Brix Andersen {
898149d1c89SHenrik Brix Andersen 	struct glxiic_softc *sc;
899149d1c89SHenrik Brix Andersen 	int error;
900149d1c89SHenrik Brix Andersen 	uint8_t status, data;
901149d1c89SHenrik Brix Andersen 
902149d1c89SHenrik Brix Andersen 	sc = (struct glxiic_softc *)arg;
903149d1c89SHenrik Brix Andersen 
904149d1c89SHenrik Brix Andersen 	GLXIIC_LOCK(sc);
905149d1c89SHenrik Brix Andersen 
906149d1c89SHenrik Brix Andersen 	status = glxiic_read_status_locked(sc);
907149d1c89SHenrik Brix Andersen 
908149d1c89SHenrik Brix Andersen 	/* Check if this interrupt originated from the SMBus. */
909149d1c89SHenrik Brix Andersen 	if ((status &
910149d1c89SHenrik Brix Andersen 		~(GLXIIC_SMB_STS_MASTER_BIT | GLXIIC_SMB_STS_XMIT_BIT)) != 0) {
911149d1c89SHenrik Brix Andersen 
912149d1c89SHenrik Brix Andersen 		error = glxiic_state_table[sc->state].callback(sc, status);
913149d1c89SHenrik Brix Andersen 
914149d1c89SHenrik Brix Andersen 		if (error != IIC_NOERR) {
915149d1c89SHenrik Brix Andersen 			if (glxiic_state_table[sc->state].master) {
916149d1c89SHenrik Brix Andersen 				glxiic_stop_locked(sc);
917149d1c89SHenrik Brix Andersen 				glxiic_set_state_locked(sc, GLXIIC_STATE_IDLE);
918149d1c89SHenrik Brix Andersen 				sc->error = error;
919149d1c89SHenrik Brix Andersen 				GLXIIC_WAKEUP(sc);
920149d1c89SHenrik Brix Andersen 			} else {
921149d1c89SHenrik Brix Andersen 				data = error & 0xff;
922149d1c89SHenrik Brix Andersen 				iicbus_intr(sc->iicbus, INTR_ERROR, &data);
923149d1c89SHenrik Brix Andersen 				glxiic_set_state_locked(sc, GLXIIC_STATE_IDLE);
924149d1c89SHenrik Brix Andersen 			}
925149d1c89SHenrik Brix Andersen 		}
926149d1c89SHenrik Brix Andersen 	}
927149d1c89SHenrik Brix Andersen 
928149d1c89SHenrik Brix Andersen 	GLXIIC_UNLOCK(sc);
929149d1c89SHenrik Brix Andersen }
930149d1c89SHenrik Brix Andersen 
931149d1c89SHenrik Brix Andersen static int
932149d1c89SHenrik Brix Andersen glxiic_reset(device_t dev, u_char speed, u_char addr, u_char *oldaddr)
933149d1c89SHenrik Brix Andersen {
934149d1c89SHenrik Brix Andersen 	struct glxiic_softc *sc;
935149d1c89SHenrik Brix Andersen 
936149d1c89SHenrik Brix Andersen 	sc = device_get_softc(dev);
937149d1c89SHenrik Brix Andersen 
938149d1c89SHenrik Brix Andersen 	GLXIIC_LOCK(sc);
939149d1c89SHenrik Brix Andersen 
940149d1c89SHenrik Brix Andersen 	if (oldaddr != NULL)
941149d1c89SHenrik Brix Andersen 		*oldaddr = sc->addr;
942149d1c89SHenrik Brix Andersen 	sc->addr = addr;
943149d1c89SHenrik Brix Andersen 
944149d1c89SHenrik Brix Andersen 	/* A disable/enable cycle resets the controller. */
945149d1c89SHenrik Brix Andersen 	glxiic_smb_disable(sc);
946149d1c89SHenrik Brix Andersen 	glxiic_smb_enable(sc, speed, addr);
947149d1c89SHenrik Brix Andersen 
948149d1c89SHenrik Brix Andersen 	if (glxiic_state_table[sc->state].master) {
949149d1c89SHenrik Brix Andersen 		sc->error = IIC_ESTATUS;
950149d1c89SHenrik Brix Andersen 		GLXIIC_WAKEUP(sc);
951149d1c89SHenrik Brix Andersen 	}
952149d1c89SHenrik Brix Andersen 	glxiic_set_state_locked(sc, GLXIIC_STATE_IDLE);
953149d1c89SHenrik Brix Andersen 
954149d1c89SHenrik Brix Andersen 	GLXIIC_UNLOCK(sc);
955149d1c89SHenrik Brix Andersen 
956149d1c89SHenrik Brix Andersen 	return (IIC_NOERR);
957149d1c89SHenrik Brix Andersen }
958149d1c89SHenrik Brix Andersen 
959149d1c89SHenrik Brix Andersen static int
960149d1c89SHenrik Brix Andersen glxiic_transfer(device_t dev, struct iic_msg *msgs, uint32_t nmsgs)
961149d1c89SHenrik Brix Andersen {
962149d1c89SHenrik Brix Andersen 	struct glxiic_softc *sc;
963149d1c89SHenrik Brix Andersen 	int error;
964149d1c89SHenrik Brix Andersen 	uint8_t ctrl1;
965149d1c89SHenrik Brix Andersen 
966149d1c89SHenrik Brix Andersen 	sc = device_get_softc(dev);
967149d1c89SHenrik Brix Andersen 
968149d1c89SHenrik Brix Andersen 	GLXIIC_LOCK(sc);
969149d1c89SHenrik Brix Andersen 
970149d1c89SHenrik Brix Andersen 	if (sc->state != GLXIIC_STATE_IDLE) {
971149d1c89SHenrik Brix Andersen 		error = IIC_EBUSBSY;
972149d1c89SHenrik Brix Andersen 		goto out;
973149d1c89SHenrik Brix Andersen 	}
974149d1c89SHenrik Brix Andersen 
975149d1c89SHenrik Brix Andersen 	sc->msg = msgs;
976149d1c89SHenrik Brix Andersen 	sc->nmsgs = nmsgs;
977149d1c89SHenrik Brix Andersen 	glxiic_set_state_locked(sc, GLXIIC_STATE_MASTER_ADDR);
978149d1c89SHenrik Brix Andersen 
979149d1c89SHenrik Brix Andersen 	/* Set start bit and let glxiic_intr() handle the transfer. */
980149d1c89SHenrik Brix Andersen 	ctrl1 = bus_read_1(sc->smb_res, GLXIIC_SMB_CTRL1);
981149d1c89SHenrik Brix Andersen 	bus_write_1(sc->smb_res, GLXIIC_SMB_CTRL1,
982149d1c89SHenrik Brix Andersen 	    ctrl1 | GLXIIC_SMB_CTRL1_START_BIT);
983149d1c89SHenrik Brix Andersen 
984149d1c89SHenrik Brix Andersen 	GLXIIC_SLEEP(sc);
985149d1c89SHenrik Brix Andersen 	error = sc->error;
986149d1c89SHenrik Brix Andersen out:
987149d1c89SHenrik Brix Andersen 	GLXIIC_UNLOCK(sc);
988149d1c89SHenrik Brix Andersen 
989149d1c89SHenrik Brix Andersen 	return (error);
990149d1c89SHenrik Brix Andersen }
991149d1c89SHenrik Brix Andersen 
992149d1c89SHenrik Brix Andersen static void
993149d1c89SHenrik Brix Andersen glxiic_smb_map_interrupt(int irq)
994149d1c89SHenrik Brix Andersen {
995149d1c89SHenrik Brix Andersen 	uint32_t irq_map;
996149d1c89SHenrik Brix Andersen 	int old_irq;
997149d1c89SHenrik Brix Andersen 
998149d1c89SHenrik Brix Andersen 	/* Protect the read-modify-write operation. */
999149d1c89SHenrik Brix Andersen 	critical_enter();
1000149d1c89SHenrik Brix Andersen 
1001149d1c89SHenrik Brix Andersen 	irq_map = rdmsr(GLXIIC_MSR_PIC_YSEL_HIGH);
1002149d1c89SHenrik Brix Andersen 	old_irq = GLXIIC_MAP_TO_SMB_IRQ(irq_map);
1003149d1c89SHenrik Brix Andersen 
1004149d1c89SHenrik Brix Andersen 	if (irq != old_irq) {
1005149d1c89SHenrik Brix Andersen 		irq_map &= ~GLXIIC_SMB_IRQ_TO_MAP(old_irq);
1006149d1c89SHenrik Brix Andersen 		irq_map |= GLXIIC_SMB_IRQ_TO_MAP(irq);
1007149d1c89SHenrik Brix Andersen 		wrmsr(GLXIIC_MSR_PIC_YSEL_HIGH, irq_map);
1008149d1c89SHenrik Brix Andersen 	}
1009149d1c89SHenrik Brix Andersen 
1010149d1c89SHenrik Brix Andersen 	critical_exit();
1011149d1c89SHenrik Brix Andersen }
1012149d1c89SHenrik Brix Andersen 
1013149d1c89SHenrik Brix Andersen static void
1014149d1c89SHenrik Brix Andersen glxiic_gpio_enable(struct glxiic_softc *sc)
1015149d1c89SHenrik Brix Andersen {
1016149d1c89SHenrik Brix Andersen 
1017149d1c89SHenrik Brix Andersen 	bus_write_4(sc->gpio_res, GLXIIC_GPIOL_IN_AUX1_SEL,
1018149d1c89SHenrik Brix Andersen 	    GLXIIC_GPIO_14_15_ENABLE);
1019149d1c89SHenrik Brix Andersen 	bus_write_4(sc->gpio_res, GLXIIC_GPIOL_OUT_AUX1_SEL,
1020149d1c89SHenrik Brix Andersen 	    GLXIIC_GPIO_14_15_ENABLE);
1021149d1c89SHenrik Brix Andersen }
1022149d1c89SHenrik Brix Andersen 
1023149d1c89SHenrik Brix Andersen static void
1024149d1c89SHenrik Brix Andersen glxiic_gpio_disable(struct glxiic_softc *sc)
1025149d1c89SHenrik Brix Andersen {
1026149d1c89SHenrik Brix Andersen 
1027149d1c89SHenrik Brix Andersen 	bus_write_4(sc->gpio_res, GLXIIC_GPIOL_OUT_AUX1_SEL,
1028149d1c89SHenrik Brix Andersen 	    GLXIIC_GPIO_14_15_DISABLE);
1029149d1c89SHenrik Brix Andersen 	bus_write_4(sc->gpio_res, GLXIIC_GPIOL_IN_AUX1_SEL,
1030149d1c89SHenrik Brix Andersen 	    GLXIIC_GPIO_14_15_DISABLE);
1031149d1c89SHenrik Brix Andersen }
1032149d1c89SHenrik Brix Andersen 
1033149d1c89SHenrik Brix Andersen static void
1034149d1c89SHenrik Brix Andersen glxiic_smb_enable(struct glxiic_softc *sc, uint8_t speed, uint8_t addr)
1035149d1c89SHenrik Brix Andersen {
1036149d1c89SHenrik Brix Andersen 	uint8_t ctrl1;
1037149d1c89SHenrik Brix Andersen 
1038149d1c89SHenrik Brix Andersen 	ctrl1 = 0;
1039149d1c89SHenrik Brix Andersen 
1040149d1c89SHenrik Brix Andersen 	switch (speed) {
1041149d1c89SHenrik Brix Andersen 	case IIC_SLOW:
1042149d1c89SHenrik Brix Andersen 		sc->sclfrq = GLXIIC_SLOW;
1043149d1c89SHenrik Brix Andersen 		break;
1044149d1c89SHenrik Brix Andersen 	case IIC_FAST:
1045149d1c89SHenrik Brix Andersen 		sc->sclfrq = GLXIIC_FAST;
1046149d1c89SHenrik Brix Andersen 		break;
1047149d1c89SHenrik Brix Andersen 	case IIC_FASTEST:
1048149d1c89SHenrik Brix Andersen 		sc->sclfrq = GLXIIC_FASTEST;
1049149d1c89SHenrik Brix Andersen 		break;
1050149d1c89SHenrik Brix Andersen 	case IIC_UNKNOWN:
1051149d1c89SHenrik Brix Andersen 	default:
1052149d1c89SHenrik Brix Andersen 		/* Reuse last frequency. */
1053149d1c89SHenrik Brix Andersen 		break;
1054149d1c89SHenrik Brix Andersen 	}
1055149d1c89SHenrik Brix Andersen 
1056149d1c89SHenrik Brix Andersen 	/* Set bus speed and enable controller. */
1057149d1c89SHenrik Brix Andersen 	bus_write_2(sc->smb_res, GLXIIC_SMB_CTRL2,
1058149d1c89SHenrik Brix Andersen 	    GLXIIC_SCLFRQ(sc->sclfrq) | GLXIIC_SMB_CTRL2_EN_BIT);
1059149d1c89SHenrik Brix Andersen 
1060149d1c89SHenrik Brix Andersen 	if (addr != 0) {
1061149d1c89SHenrik Brix Andersen 		/* Enable new match and global call match interrupts. */
1062149d1c89SHenrik Brix Andersen 		ctrl1 |= GLXIIC_SMB_CTRL1_NMINTE_BIT |
1063149d1c89SHenrik Brix Andersen 			GLXIIC_SMB_CTRL1_GCMEN_BIT;
1064149d1c89SHenrik Brix Andersen 		bus_write_1(sc->smb_res, GLXIIC_SMB_ADDR,
1065149d1c89SHenrik Brix Andersen 		    GLXIIC_SMB_ADDR_SAEN_BIT | GLXIIC_SMBADDR(addr));
1066149d1c89SHenrik Brix Andersen 	} else {
1067149d1c89SHenrik Brix Andersen 		bus_write_1(sc->smb_res, GLXIIC_SMB_ADDR, 0);
1068149d1c89SHenrik Brix Andersen 	}
1069149d1c89SHenrik Brix Andersen 
1070149d1c89SHenrik Brix Andersen 	/* Enable stall after start and interrupt. */
1071149d1c89SHenrik Brix Andersen 	bus_write_1(sc->smb_res, GLXIIC_SMB_CTRL1,
1072149d1c89SHenrik Brix Andersen 	    ctrl1 | GLXIIC_SMB_CTRL1_STASTRE_BIT | GLXIIC_SMB_CTRL1_INTEN_BIT);
1073149d1c89SHenrik Brix Andersen }
1074149d1c89SHenrik Brix Andersen 
1075149d1c89SHenrik Brix Andersen static void
1076149d1c89SHenrik Brix Andersen glxiic_smb_disable(struct glxiic_softc *sc)
1077149d1c89SHenrik Brix Andersen {
1078149d1c89SHenrik Brix Andersen 	uint16_t sclfrq;
1079149d1c89SHenrik Brix Andersen 
1080149d1c89SHenrik Brix Andersen 	sclfrq = bus_read_2(sc->smb_res, GLXIIC_SMB_CTRL2);
1081149d1c89SHenrik Brix Andersen 	bus_write_2(sc->smb_res, GLXIIC_SMB_CTRL2,
1082149d1c89SHenrik Brix Andersen 	    sclfrq & ~GLXIIC_SMB_CTRL2_EN_BIT);
1083149d1c89SHenrik Brix Andersen }
1084