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