iomdiic.c revision 1.1
1 /* $NetBSD: iomdiic.c,v 1.1 2003/10/06 16:11:19 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 2003 Wasabi Systems, Inc. 5 * All rights reserved. 6 * 7 * Written by Jason R. Thorpe for Wasabi Systems, Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed for the NetBSD Project by 20 * Wasabi Systems, Inc. 21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse 22 * or promote products derived from this software without specific prior 23 * written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 #include <sys/param.h> 39 #include <sys/device.h> 40 #include <sys/kernel.h> 41 #include <sys/systm.h> 42 #include <sys/lock.h> 43 44 #include <machine/bus.h> 45 #include <machine/cpu.h> 46 47 #include <arm/iomd/iomdreg.h> 48 #include <arm/iomd/iomdvar.h> 49 50 #include <dev/i2c/i2cvar.h> 51 #include <dev/i2c/i2c_bitbang.h> 52 53 #include <arm/iomd/iomdiicvar.h> 54 55 struct iomdiic_softc { 56 struct device sc_dev; 57 bus_space_tag_t sc_st; 58 bus_space_handle_t sc_sh; 59 60 struct i2c_controller sc_i2c; 61 struct lock sc_buslock; 62 63 /* 64 * The SDA pin is open-drain, so we make it an input by 65 * writing a 1 to it. 66 */ 67 uint8_t sc_iomd_iocr; 68 }; 69 70 static int iomdiic_acquire_bus(void *, int); 71 static void iomdiic_release_bus(void *, int); 72 73 static int iomdiic_send_start(void *, int); 74 static int iomdiic_send_stop(void *, int); 75 static int iomdiic_initiate_xfer(void *, i2c_addr_t, int); 76 static int iomdiic_read_byte(void *, uint8_t *, int); 77 static int iomdiic_write_byte(void *, uint8_t, int); 78 79 #define IOMDIIC_READ *(__volatile uint8_t *)(IOMD_ADDRESS(IOMD_IOCR)) 80 #define IOMDIIC_WRITE(x) *(__volatile uint8_t *)(IOMD_ADDRESS(IOMD_IOCR)) = (x) 81 82 #define IOMD_IOCR_SDA 0x01 83 #define IOMD_IOCR_SCL 0x02 84 85 static void 86 iomdiic_bb_set_bits(void *cookie, uint32_t bits) 87 { 88 struct iomdiic_softc *sc = cookie; 89 90 IOMDIIC_WRITE((IOMDIIC_READ & ~(IOMD_IOCR_SDA|IOMD_IOCR_SCL)) | 91 sc->sc_iomd_iocr | bits); 92 } 93 94 static void 95 iomdiic_bb_set_dir(void *cookie, uint32_t bits) 96 { 97 struct iomdiic_softc *sc = cookie; 98 99 sc->sc_iomd_iocr = bits; 100 } 101 102 static uint32_t 103 iomdiic_bb_read_bits(void *cookie) 104 { 105 106 return (IOMDIIC_READ); 107 } 108 109 static const struct i2c_bitbang_ops iomdiic_bbops = { 110 iomdiic_bb_set_bits, 111 iomdiic_bb_set_dir, 112 iomdiic_bb_read_bits, 113 { 114 IOMD_IOCR_SDA, /* SDA */ 115 IOMD_IOCR_SCL, /* SCL */ 116 0, /* SDA is output */ 117 IOMD_IOCR_SDA, /* SDA is input */ 118 } 119 }; 120 121 static int 122 iomdiic_match(struct device *parent, struct cfdata *cf, void *aux) 123 { 124 125 return (1); 126 } 127 128 static void 129 iomdiic_attach(struct device *parent, struct device *self, void *aux) 130 { 131 struct iomdiic_softc *sc = (void *) self; 132 struct i2cbus_attach_args iba; 133 134 printf("\n"); 135 136 lockinit(&sc->sc_buslock, PRIBIO|PCATCH, "iomdiiclk", 0, 0); 137 138 sc->sc_i2c.ic_cookie = sc; 139 sc->sc_i2c.ic_acquire_bus = iomdiic_acquire_bus; 140 sc->sc_i2c.ic_release_bus = iomdiic_release_bus; 141 sc->sc_i2c.ic_send_start = iomdiic_send_start; 142 sc->sc_i2c.ic_send_stop = iomdiic_send_stop; 143 sc->sc_i2c.ic_initiate_xfer = iomdiic_initiate_xfer; 144 sc->sc_i2c.ic_read_byte = iomdiic_read_byte; 145 sc->sc_i2c.ic_write_byte = iomdiic_write_byte; 146 147 iba.iba_name = "iic"; 148 iba.iba_tag = &sc->sc_i2c; 149 (void) config_found(&sc->sc_dev, &iba, iicbus_print); 150 } 151 152 CFATTACH_DECL(iomdiic, sizeof(struct iomdiic_softc), 153 iomdiic_match, iomdiic_attach, NULL, NULL); 154 155 i2c_tag_t 156 iomdiic_bootstrap_cookie(void) 157 { 158 static struct iomdiic_softc sc; 159 160 /* XXX Yuck. */ 161 strcpy(sc.sc_dev.dv_xname, "iomdiicboot"); 162 163 sc.sc_i2c.ic_cookie = ≻ 164 sc.sc_i2c.ic_acquire_bus = iomdiic_acquire_bus; 165 sc.sc_i2c.ic_release_bus = iomdiic_release_bus; 166 sc.sc_i2c.ic_send_start = iomdiic_send_start; 167 sc.sc_i2c.ic_send_stop = iomdiic_send_stop; 168 sc.sc_i2c.ic_initiate_xfer = iomdiic_initiate_xfer; 169 sc.sc_i2c.ic_read_byte = iomdiic_read_byte; 170 sc.sc_i2c.ic_write_byte = iomdiic_write_byte; 171 172 return ((void *) &sc.sc_i2c); 173 } 174 175 static int 176 iomdiic_acquire_bus(void *cookie, int flags) 177 { 178 struct iomdiic_softc *sc = cookie; 179 180 /* XXX What should we do for the polling case? */ 181 if (flags & I2C_F_POLL) 182 return (0); 183 184 return (lockmgr(&sc->sc_buslock, LK_EXCLUSIVE, NULL)); 185 } 186 187 static void 188 iomdiic_release_bus(void *cookie, int flags) 189 { 190 struct iomdiic_softc *sc = cookie; 191 192 /* XXX See above. */ 193 if (flags & I2C_F_POLL) 194 return; 195 196 (void) lockmgr(&sc->sc_buslock, LK_RELEASE, NULL); 197 } 198 199 static int 200 iomdiic_send_start(void *cookie, int flags) 201 { 202 203 return (i2c_bitbang_send_start(cookie, flags, &iomdiic_bbops)); 204 } 205 206 static int 207 iomdiic_send_stop(void *cookie, int flags) 208 { 209 210 return (i2c_bitbang_send_stop(cookie, flags, &iomdiic_bbops)); 211 } 212 213 static int 214 iomdiic_initiate_xfer(void *cookie, i2c_addr_t addr, int flags) 215 { 216 217 return (i2c_bitbang_initiate_xfer(cookie, addr, flags, &iomdiic_bbops)); 218 } 219 220 static int 221 iomdiic_read_byte(void *cookie, uint8_t *bytep, int flags) 222 { 223 224 return (i2c_bitbang_read_byte(cookie, bytep, flags, &iomdiic_bbops)); 225 } 226 227 static int 228 iomdiic_write_byte(void *cookie, uint8_t byte, int flags) 229 { 230 231 return (i2c_bitbang_write_byte(cookie, byte, flags, &iomdiic_bbops)); 232 } 233
Indexes created Mon Sep 29 21:09:56 GMT 2025