/* $NetBSD: spdmem_i2c.c,v 1.26 2022/03/30 00:06:50 pgoyette Exp $ */

/*
* Copyright (c) 2007 Nicolas Joly
* Copyright (c) 2007 Paul Goyette
* Copyright (c) 2007 Tobias Nygren
* Copyright (c) 2015 Michael van Elst
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
*    derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

/*
* Serial Presence Detect (SPD) memory identification
*
* JEDEC standard No. 21-C
* JEDEC document 4_01_06R24
* - Definitions of the EE1004-v 4 Kbit Serial Presence Detect EEPROM [...]
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: spdmem_i2c.c,v 1.26 2022/03/30 00:06:50 pgoyette Exp $");

#include <sys/param.h>
#include <sys/device.h>
#include <sys/endian.h>
#include <sys/module.h>
#include <sys/sysctl.h>
#include <machine/bswap.h>

#include <dev/i2c/i2cvar.h>
#include <dev/ic/spdmemreg.h>
#include <dev/ic/spdmemvar.h>

/* Constants for matching i2c bus address */
#define SPDMEM_I2C_ADDRMASK 0xfff8
#define SPDMEM_I2C_ADDR     0x50
#define SPDCTL_I2C_ADDR     0x30

/* set write protection */
#define SPDCTL_SWP0         (SPDCTL_I2C_ADDR + 1)
#define SPDCTL_SWP1         (SPDCTL_I2C_ADDR + 4)
#define SPDCTL_SWP2         (SPDCTL_I2C_ADDR + 5)
#define SPDCTL_SWP3         (SPDCTL_I2C_ADDR + 0)

/* clear write protections */
#define SPDCTL_CWP          (SPDCTL_I2C_ADDR + 3)

/* read protection status */
#define SPDCTL_RPS0         (SPDCTL_I2C_ADDR + 1)
#define SPDCTL_RPS1         (SPDCTL_I2C_ADDR + 4)
#define SPDCTL_RPS2         (SPDCTL_I2C_ADDR + 5)
#define SPDCTL_RPS3         (SPDCTL_I2C_ADDR + 0)

/* select page address */
#define SPDCTL_SPA0         (SPDCTL_I2C_ADDR + 6)
#define SPDCTL_SPA1         (SPDCTL_I2C_ADDR + 7)

/* read page address */
#define SPDCTL_RPA          (SPDCTL_I2C_ADDR + 6)

struct spdmem_i2c_softc {
       struct spdmem_softc sc_base;
       i2c_tag_t sc_tag;
       i2c_addr_t sc_addr; /* EEPROM */
       i2c_addr_t sc_page0;
       i2c_addr_t sc_page1;
};

static int  spdmem_reset_page(struct spdmem_i2c_softc *);
static int  spdmem_i2c_match(device_t, cfdata_t, void *);
static void spdmem_i2c_attach(device_t, device_t, void *);
static int  spdmem_i2c_detach(device_t, int);

CFATTACH_DECL_NEW(spdmem_iic, sizeof(struct spdmem_i2c_softc),
   spdmem_i2c_match, spdmem_i2c_attach, spdmem_i2c_detach, NULL);

static int spdmem_i2c_read(struct spdmem_softc *, uint16_t, uint8_t *);

static int
spdmem_reset_page(struct spdmem_i2c_softc *sc)
{
       uint8_t reg, byte0, byte2;
       static uint8_t dummy = 0;
       int rv;

       reg = 0;

       rv = iic_acquire_bus(sc->sc_tag, 0);
       if (rv)
               return rv;

       /*
        * Try to read byte 0 and 2. If it failed, it's not spdmem or a device
        * doesn't exist at the address.
        */
       rv = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, &reg, 1,
           &byte0, 1, 0);
       if (rv != 0)
               goto error;

       reg = 2;
       rv = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, &reg, 1,
           &byte2, 1, 0);
       if (rv != 0)
               goto error;

       /*
        * Quirk for BIOSes that leave page 1 of a 4kbit EEPROM selected.
        *
        * byte0 is the length, byte2 is the memory type. Both of them should
        * not be zero. If zero, the current page might be 1 (DDR4 and newer).
        * If page 1 is selected, offset 0 can be 0 (Module Characteristics
        * (Energy backup is not available)) and also offset 2 can be 0
        * (Megabytes, and a part of Capacity digits).
        *
        * Note: The encoding of byte0 is vary in memory type, so we check
        * just with zero to be simple.
        *
        * Try to see if we are not at page 0. If it's not, select page 0.
        */
       if ((byte0 == 0) || (byte2 == 0)) {
               /*
                * Note that SDCTL_RPA is the same as sc->sc_page0(SPDCTL_SPA0)
                * Write is SPA0, read is RPA.
                *
                * This call returns 0 on page 0 and returns -1 on page 1.
                * I don't know whether our icc_exec()'s API is good or not.
                */
               rv = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_page0,
                   &reg, 1, &dummy, 1, 0);
               if (rv != 0) {
                       /*
                        * The possibilities are:
                        * a) page 1 is selected.
                        * b) The device doesn't support page select and
                        *    it's not a SPD ROM.
                        * Is there no way to distinguish them now?
                        */
                       rv = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
                           sc->sc_page0, &reg, 1, &dummy, 1, 0);
                       if (rv == 0) {
                               aprint_debug("Page 1 was selected. Page 0 is "
                                   "selected now.\n");
                       } else {
                               aprint_debug("Failed to select page 0. This "
                                   "device isn't SPD ROM\n");
                       }
               } else {
                       /* This device isn't SPD ROM */
                       rv = -1;
               }
       }
error:
       iic_release_bus(sc->sc_tag, 0);

       return rv;
}

static const struct device_compatible_entry compat_data[] = {
       { .compat = "atmel,spd" },
       { .compat = "i2c-at34c02" },
       DEVICE_COMPAT_EOL
};

static int
spdmem_i2c_match(device_t parent, cfdata_t match, void *aux)
{
       struct i2c_attach_args *ia = aux;
       struct spdmem_i2c_softc sc;
       int match_result;

       if (iic_use_direct_match(ia, match, compat_data, &match_result))
               return match_result;

       /*
        * XXXJRT
        * Should do this with "compatible" strings.  There are also
        * other problems with this "match" routine.  Specifically, if
        * we are doing direct-config, we know the device is already
        * there aren't do need to probe.  I'll leave the logic for
        * now and let someone who knows better clean it later.
        */

       if (ia->ia_name) {
               /* add other names as we find more firmware variations */
               if (strcmp(ia->ia_name, "dimm-spd") &&
                   strcmp(ia->ia_name, "dimm"))
                       return 0;
       }

       /* only do this lame test when not using direct config */
       if (ia->ia_name == NULL) {
               if ((ia->ia_addr & SPDMEM_I2C_ADDRMASK) != SPDMEM_I2C_ADDR)
                       return 0;
       }

       sc.sc_tag = ia->ia_tag;
       sc.sc_addr = ia->ia_addr;
       sc.sc_page0 = SPDCTL_SPA0;
       sc.sc_page1 = SPDCTL_SPA1;
       sc.sc_base.sc_read = spdmem_i2c_read;

       /* Check the bank and reset to the page 0 */
       if (spdmem_reset_page(&sc) != 0)
               return 0;

       if (spdmem_common_probe(&sc.sc_base)) {
               return ia->ia_name ? I2C_MATCH_DIRECT_SPECIFIC
                                  : I2C_MATCH_ADDRESS_AND_PROBE;
       }
       return 0;
}

static void
spdmem_i2c_attach(device_t parent, device_t self, void *aux)
{
       struct spdmem_i2c_softc *sc = device_private(self);
       struct i2c_attach_args *ia = aux;

       sc->sc_tag = ia->ia_tag;
       sc->sc_addr = ia->ia_addr;
       sc->sc_page0 = SPDCTL_SPA0;
       sc->sc_page1 = SPDCTL_SPA1;
       sc->sc_base.sc_read = spdmem_i2c_read;

       if (!pmf_device_register(self, NULL, NULL))
               aprint_error_dev(self, "couldn't establish power handler\n");

       spdmem_common_attach(&sc->sc_base, self);
}

static int
spdmem_i2c_detach(device_t self, int flags)
{
       struct spdmem_i2c_softc *sc = device_private(self);

       pmf_device_deregister(self);

       return spdmem_common_detach(&sc->sc_base, self);
}

static int
spdmem_i2c_read(struct spdmem_softc *softc, uint16_t addr, uint8_t *val)
{
       uint8_t reg;
       struct spdmem_i2c_softc *sc = (struct spdmem_i2c_softc *)softc;
       static uint8_t dummy = 0;
       int rv;

       reg = addr & 0xff;

       rv = iic_acquire_bus(sc->sc_tag, 0);
       if (rv)
               return rv;

       if (addr & 0x100) {
               rv = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_page1,
                   &dummy, 1, &dummy, 1, 0);
               rv |= iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr,
                   &reg, 1, val, 1, 0);
               rv |= iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
                   sc->sc_page0, &dummy, 1, &dummy, 1, 0);
       } else {
               rv = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr,
                   &reg, 1, val, 1, 0);
       }

       iic_release_bus(sc->sc_tag, 0);

       return rv;
}

MODULE(MODULE_CLASS_DRIVER, spdmem, "iic");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
spdmem_modcmd(modcmd_t cmd, void *opaque)
{
       int error = 0;
#ifdef _MODULE
       static struct sysctllog *spdmem_sysctl_clog;
#endif

       switch (cmd) {
       case MODULE_CMD_INIT:
#ifdef _MODULE
               error = config_init_component(cfdriver_ioconf_spdmem,
                   cfattach_ioconf_spdmem, cfdata_ioconf_spdmem);
#endif
               return error;
       case MODULE_CMD_FINI:
#ifdef _MODULE
               error = config_fini_component(cfdriver_ioconf_spdmem,
                   cfattach_ioconf_spdmem, cfdata_ioconf_spdmem);
               sysctl_teardown(&spdmem_sysctl_clog);
#endif
               return error;
       default:
               return ENOTTY;
       }
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.