1 /* $NetBSD: spdmem_i2c.c,v 1.26 2022/03/30 00:06:50 pgoyette Exp $ */ 2 3 /* 4 * Copyright (c) 2007 Nicolas Joly 5 * Copyright (c) 2007 Paul Goyette 6 * Copyright (c) 2007 Tobias Nygren 7 * Copyright (c) 2015 Michael van Elst 8 * All rights reserved. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 23 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 24 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 31 * POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 /* 35 * Serial Presence Detect (SPD) memory identification 36 * 37 * JEDEC standard No. 21-C 38 * JEDEC document 4_01_06R24 39 * - Definitions of the EE1004-v 4 Kbit Serial Presence Detect EEPROM [...] 40 */ 41 42 #include <sys/cdefs.h> 43 __KERNEL_RCSID(0, "$NetBSD: spdmem_i2c.c,v 1.26 2022/03/30 00:06:50 pgoyette Exp $"); 44 45 #include <sys/param.h> 46 #include <sys/device.h> 47 #include <sys/endian.h> 48 #include <sys/module.h> 49 #include <sys/sysctl.h> 50 #include <machine/bswap.h> 51 52 #include <dev/i2c/i2cvar.h> 53 #include <dev/ic/spdmemreg.h> 54 #include <dev/ic/spdmemvar.h> 55 56 /* Constants for matching i2c bus address */ 57 #define SPDMEM_I2C_ADDRMASK 0xfff8 58 #define SPDMEM_I2C_ADDR 0x50 59 #define SPDCTL_I2C_ADDR 0x30 60 61 /* set write protection */ 62 #define SPDCTL_SWP0 (SPDCTL_I2C_ADDR + 1) 63 #define SPDCTL_SWP1 (SPDCTL_I2C_ADDR + 4) 64 #define SPDCTL_SWP2 (SPDCTL_I2C_ADDR + 5) 65 #define SPDCTL_SWP3 (SPDCTL_I2C_ADDR + 0) 66 67 /* clear write protections */ 68 #define SPDCTL_CWP (SPDCTL_I2C_ADDR + 3) 69 70 /* read protection status */ 71 #define SPDCTL_RPS0 (SPDCTL_I2C_ADDR + 1) 72 #define SPDCTL_RPS1 (SPDCTL_I2C_ADDR + 4) 73 #define SPDCTL_RPS2 (SPDCTL_I2C_ADDR + 5) 74 #define SPDCTL_RPS3 (SPDCTL_I2C_ADDR + 0) 75 76 /* select page address */ 77 #define SPDCTL_SPA0 (SPDCTL_I2C_ADDR + 6) 78 #define SPDCTL_SPA1 (SPDCTL_I2C_ADDR + 7) 79 80 /* read page address */ 81 #define SPDCTL_RPA (SPDCTL_I2C_ADDR + 6) 82 83 struct spdmem_i2c_softc { 84 struct spdmem_softc sc_base; 85 i2c_tag_t sc_tag; 86 i2c_addr_t sc_addr; /* EEPROM */ 87 i2c_addr_t sc_page0; 88 i2c_addr_t sc_page1; 89 }; 90 91 static int spdmem_reset_page(struct spdmem_i2c_softc *); 92 static int spdmem_i2c_match(device_t, cfdata_t, void *); 93 static void spdmem_i2c_attach(device_t, device_t, void *); 94 static int spdmem_i2c_detach(device_t, int); 95 96 CFATTACH_DECL_NEW(spdmem_iic, sizeof(struct spdmem_i2c_softc), 97 spdmem_i2c_match, spdmem_i2c_attach, spdmem_i2c_detach, NULL); 98 99 static int spdmem_i2c_read(struct spdmem_softc *, uint16_t, uint8_t *); 100 101 static int 102 spdmem_reset_page(struct spdmem_i2c_softc *sc) 103 { 104 uint8_t reg, byte0, byte2; 105 static uint8_t dummy = 0; 106 int rv; 107 108 reg = 0; 109 110 rv = iic_acquire_bus(sc->sc_tag, 0); 111 if (rv) 112 return rv; 113 114 /* 115 * Try to read byte 0 and 2. If it failed, it's not spdmem or a device 116 * doesn't exist at the address. 117 */ 118 rv = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, ®, 1, 119 &byte0, 1, 0); 120 if (rv != 0) 121 goto error; 122 123 reg = 2; 124 rv = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, ®, 1, 125 &byte2, 1, 0); 126 if (rv != 0) 127 goto error; 128 129 /* 130 * Quirk for BIOSes that leave page 1 of a 4kbit EEPROM selected. 131 * 132 * byte0 is the length, byte2 is the memory type. Both of them should 133 * not be zero. If zero, the current page might be 1 (DDR4 and newer). 134 * If page 1 is selected, offset 0 can be 0 (Module Characteristics 135 * (Energy backup is not available)) and also offset 2 can be 0 136 * (Megabytes, and a part of Capacity digits). 137 * 138 * Note: The encoding of byte0 is vary in memory type, so we check 139 * just with zero to be simple. 140 * 141 * Try to see if we are not at page 0. If it's not, select page 0. 142 */ 143 if ((byte0 == 0) || (byte2 == 0)) { 144 /* 145 * Note that SDCTL_RPA is the same as sc->sc_page0(SPDCTL_SPA0) 146 * Write is SPA0, read is RPA. 147 * 148 * This call returns 0 on page 0 and returns -1 on page 1. 149 * I don't know whether our icc_exec()'s API is good or not. 150 */ 151 rv = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_page0, 152 ®, 1, &dummy, 1, 0); 153 if (rv != 0) { 154 /* 155 * The possibilities are: 156 * a) page 1 is selected. 157 * b) The device doesn't support page select and 158 * it's not a SPD ROM. 159 * Is there no way to distinguish them now? 160 */ 161 rv = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 162 sc->sc_page0, ®, 1, &dummy, 1, 0); 163 if (rv == 0) { 164 aprint_debug("Page 1 was selected. Page 0 is " 165 "selected now.\n"); 166 } else { 167 aprint_debug("Failed to select page 0. This " 168 "device isn't SPD ROM\n"); 169 } 170 } else { 171 /* This device isn't SPD ROM */ 172 rv = -1; 173 } 174 } 175 error: 176 iic_release_bus(sc->sc_tag, 0); 177 178 return rv; 179 } 180 181 static const struct device_compatible_entry compat_data[] = { 182 { .compat = "atmel,spd" }, 183 { .compat = "i2c-at34c02" }, 184 DEVICE_COMPAT_EOL 185 }; 186 187 static int 188 spdmem_i2c_match(device_t parent, cfdata_t match, void *aux) 189 { 190 struct i2c_attach_args *ia = aux; 191 struct spdmem_i2c_softc sc; 192 int match_result; 193 194 if (iic_use_direct_match(ia, match, compat_data, &match_result)) 195 return match_result; 196 197 /* 198 * XXXJRT 199 * Should do this with "compatible" strings. There are also 200 * other problems with this "match" routine. Specifically, if 201 * we are doing direct-config, we know the device is already 202 * there aren't do need to probe. I'll leave the logic for 203 * now and let someone who knows better clean it later. 204 */ 205 206 if (ia->ia_name) { 207 /* add other names as we find more firmware variations */ 208 if (strcmp(ia->ia_name, "dimm-spd") && 209 strcmp(ia->ia_name, "dimm")) 210 return 0; 211 } 212 213 /* only do this lame test when not using direct config */ 214 if (ia->ia_name == NULL) { 215 if ((ia->ia_addr & SPDMEM_I2C_ADDRMASK) != SPDMEM_I2C_ADDR) 216 return 0; 217 } 218 219 sc.sc_tag = ia->ia_tag; 220 sc.sc_addr = ia->ia_addr; 221 sc.sc_page0 = SPDCTL_SPA0; 222 sc.sc_page1 = SPDCTL_SPA1; 223 sc.sc_base.sc_read = spdmem_i2c_read; 224 225 /* Check the bank and reset to the page 0 */ 226 if (spdmem_reset_page(&sc) != 0) 227 return 0; 228 229 if (spdmem_common_probe(&sc.sc_base)) { 230 return ia->ia_name ? I2C_MATCH_DIRECT_SPECIFIC 231 : I2C_MATCH_ADDRESS_AND_PROBE; 232 } 233 return 0; 234 } 235 236 static void 237 spdmem_i2c_attach(device_t parent, device_t self, void *aux) 238 { 239 struct spdmem_i2c_softc *sc = device_private(self); 240 struct i2c_attach_args *ia = aux; 241 242 sc->sc_tag = ia->ia_tag; 243 sc->sc_addr = ia->ia_addr; 244 sc->sc_page0 = SPDCTL_SPA0; 245 sc->sc_page1 = SPDCTL_SPA1; 246 sc->sc_base.sc_read = spdmem_i2c_read; 247 248 if (!pmf_device_register(self, NULL, NULL)) 249 aprint_error_dev(self, "couldn't establish power handler\n"); 250 251 spdmem_common_attach(&sc->sc_base, self); 252 } 253 254 static int 255 spdmem_i2c_detach(device_t self, int flags) 256 { 257 struct spdmem_i2c_softc *sc = device_private(self); 258 259 pmf_device_deregister(self); 260 261 return spdmem_common_detach(&sc->sc_base, self); 262 } 263 264 static int 265 spdmem_i2c_read(struct spdmem_softc *softc, uint16_t addr, uint8_t *val) 266 { 267 uint8_t reg; 268 struct spdmem_i2c_softc *sc = (struct spdmem_i2c_softc *)softc; 269 static uint8_t dummy = 0; 270 int rv; 271 272 reg = addr & 0xff; 273 274 rv = iic_acquire_bus(sc->sc_tag, 0); 275 if (rv) 276 return rv; 277 278 if (addr & 0x100) { 279 rv = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_page1, 280 &dummy, 1, &dummy, 1, 0); 281 rv |= iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, 282 ®, 1, val, 1, 0); 283 rv |= iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, 284 sc->sc_page0, &dummy, 1, &dummy, 1, 0); 285 } else { 286 rv = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, 287 ®, 1, val, 1, 0); 288 } 289 290 iic_release_bus(sc->sc_tag, 0); 291 292 return rv; 293 } 294 295 MODULE(MODULE_CLASS_DRIVER, spdmem, "iic"); 296 297 #ifdef _MODULE 298 #include "ioconf.c" 299 #endif 300 301 static int 302 spdmem_modcmd(modcmd_t cmd, void *opaque) 303 { 304 int error = 0; 305 #ifdef _MODULE 306 static struct sysctllog *spdmem_sysctl_clog; 307 #endif 308 309 switch (cmd) { 310 case MODULE_CMD_INIT: 311 #ifdef _MODULE 312 error = config_init_component(cfdriver_ioconf_spdmem, 313 cfattach_ioconf_spdmem, cfdata_ioconf_spdmem); 314 #endif 315 return error; 316 case MODULE_CMD_FINI: 317 #ifdef _MODULE 318 error = config_fini_component(cfdriver_ioconf_spdmem, 319 cfattach_ioconf_spdmem, cfdata_ioconf_spdmem); 320 sysctl_teardown(&spdmem_sysctl_clog); 321 #endif 322 return error; 323 default: 324 return ENOTTY; 325 } 326 } 327
Indexes created Sun Oct 25 00:26:45 UTC 2026