 @@ -18,27 +18,27 @@
  * ``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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: adm1026.c,v 1.7 2019/12/23 02:25:28 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: adm1026.c,v 1.8 2020/06/26 10:06:57 martin Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/sysctl.h>
 #include <dev/sysmon/sysmonvar.h>
 #include <dev/i2c/i2cvar.h>
 #include <dev/i2c/adm1026reg.h>
 /* Voltage/analog sensors descriptions and registers */
 @@ -88,89 +88,94 @@ struct adm1026_softc {
 	i2c_tag_t sc_tag;
 	int sc_address;
 	bool sc_multi_read;
 	uint8_t sc_rev, sc_cfg[2];
 	int sc_nfans, sc_ntemps;	/* Map sysmon numbers to sensors */
 	int sc_fandiv[ADM1026_MAX_FANS], sc_temp_off[ADM1026_MAX_TEMPS];
 	struct sysmon_envsys *sc_sme;
 	envsys_data_t sc_sensor[ADM1026_MAX_FANS + ADM1026_MAX_TEMPS +
 	    ADM1026_MAX_VOLTS];
 };
 static int adm1026_match(device_t, cfdata_t, void *);
-static int adm1026_ident(struct adm1026_softc *, int);
+static int adm1026_ident(i2c_tag_t, i2c_addr_t, int, uint8_t*);
 static void adm1026_attach(device_t, device_t, void *);
 static int adm1026_detach(device_t, int);
 bool adm1026_pmf_suspend(device_t, const pmf_qual_t *);
 bool adm1026_pmf_resume(device_t, const pmf_qual_t *);
 static void adm1026_setup_fans(struct adm1026_softc *sc, int div2_val);
 static void adm1026_setup_temps(struct adm1026_softc *sc);
 static void adm1026_setup_volts(struct adm1026_softc *sc);
 void adm1026_refresh(struct sysmon_envsys *sme, envsys_data_t *edata);
 static void adm1026_read_fan(struct adm1026_softc *sc, envsys_data_t *edata);
 static void adm1026_read_temp(struct adm1026_softc *sc, envsys_data_t *edata);
 static void adm1026_read_volt(struct adm1026_softc *sc, envsys_data_t *edata);
-static int adm1026_read_reg(struct adm1026_softc *sc,
+static int adm1026_read_reg_int(i2c_tag_t, i2c_addr_t,
-    uint8_t reg, uint8_t *val);
+    uint8_t reg, bool multi_read, uint8_t *val);
 static int adm1026_write_reg(struct adm1026_softc *sc,
     uint8_t reg, uint8_t val);
 static inline int
 adm1026_read_reg(struct adm1026_softc *sc, uint8_t reg, uint8_t *val)
+{
 	return adm1026_read_reg_int(sc->sc_tag, sc->sc_address, reg,
 	    sc->sc_multi_read, val);
+}
 CFATTACH_DECL_NEW(adm1026hm, sizeof(struct adm1026_softc),
 	adm1026_match, adm1026_attach, adm1026_detach, NULL);
 static const struct device_compatible_entry compat_data[] = {
 	{ "i2c-adm1026",		0 },
 	{ NULL,				0 }
 };
 static int
 adm1026_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct i2c_attach_args *ia = aux;
 	struct adm1026_softc sc;	/* For chip ident */
 	int match_result;
 	uint8_t rev;
 	sc.sc_tag = ia->ia_tag;
 	sc.sc_address = ia->ia_addr;
 	if (iic_use_direct_match(ia, cf, compat_data, &match_result))
 		return match_result;
-	if (ia->ia_addr == ADM1026_ADDR1 && adm1026_ident(&sc, 1))
+	if (ia->ia_addr == ADM1026_ADDR1
 	    && adm1026_ident(ia->ia_tag, ia->ia_addr, 1, &rev))
 		return I2C_MATCH_ADDRESS_AND_PROBE;
 	return 0;
+}
 static int
-adm1026_ident(struct adm1026_softc *sc, int probe_only)
+adm1026_ident(i2c_tag_t tag, i2c_addr_t addr, int probe_only, uint8_t *rev)
+{
 	uint8_t val;
 	int err;
 	/* Manufacturer ID and revision/stepping */
-	err = adm1026_read_reg(sc, ADM1026_ID, &val);
+	err = adm1026_read_reg_int(tag, addr, ADM1026_ID, false, &val);
 	if (err || val != ADM1026_MANF_ID) {
 		if (!probe_only)
 			aprint_verbose("adm1026_ident: "
 			    "manufacturer ID invalid or missing\n");
 		return 0;
+	}
-	err = adm1026_read_reg(sc, ADM1026_REV, &sc->sc_rev);
+	err = adm1026_read_reg_int(tag, addr, ADM1026_REV, false, rev);
-	if (err || ADM1026_REVISION(sc->sc_rev) != ADM1026_MANF_REV) {
+	if (err || ADM1026_REVISION(*rev) != ADM1026_MANF_REV) {
 		if (!probe_only)
 			aprint_verbose("adm1026_ident: "
 			    "manufacturer revision invalid or missing\n");
 		return 0;
+	}
 	return 1;
+}
 static void
 adm1026_attach(device_t parent, device_t self, void *aux)
+{
 	struct adm1026_softc *sc = device_private(self);
 	struct i2c_attach_args *ia = aux;
 @@ -179,27 +184,27 @@ adm1026_attach(device_t parent, device_t
 	int err, div2_val;
 	sc->sc_tag = ia->ia_tag;
 	sc->sc_address = ia->ia_addr;
 	sc->sc_dev = self;
 	sc->sc_multi_read = false;
 	prop_dictionary_get_bool(props, "multi_read", &sc->sc_multi_read);
 	if (prop_dictionary_get_uint8(props, "fan_div2", &fan_div2) != 0)
 		div2_val = fan_div2;
 	else
 		div2_val = -1;
-	(void) adm1026_ident(sc, 0);
+	(void) adm1026_ident(sc->sc_tag, sc->sc_address, 0, &sc->sc_rev);
 	aprint_normal(": ADM1026 hardware monitor: rev. 0x%x, step. 0x%x\n",
 	    ADM1026_REVISION(sc->sc_rev), ADM1026_STEPPING(sc->sc_rev));
 	/*
 	 * Start monitoring if not already monitoring.
 	 * Wait 1.8s for the fan readings to stabilise.
 	 */
 	if ((err = adm1026_read_reg(sc, ADM1026_CONF1, &val)) != 0) {
 		aprint_error_dev(sc->sc_dev, ": unable to read conf1\n");
 		return;
+	}
 	if (!(val & ADM1026_CONF1_MONITOR)) {
 		aprint_normal_dev(sc->sc_dev,
 @@ -472,71 +477,72 @@ adm1026_read_volt(struct adm1026_softc *
 	err = adm1026_read_reg(sc, adm1026_volts_table[volt].reg, &val);
 	if (err) {
 		edata->state = ENVSYS_SINVALID;
 		return;
+	}
 	/* Vbatt is not valid for < 1.5V */
 	if (volt == 0 && val < 0x60)
 		edata->state = ENVSYS_SINVALID;
 	edata->value_cur = (int) val * adm1026_volts_table[volt].incr;
 	edata->state = ENVSYS_SVALID;
+}
 static int
-adm1026_read_reg(struct adm1026_softc *sc, uint8_t reg, uint8_t *val)
+adm1026_read_reg_int(i2c_tag_t tag, i2c_addr_t addr, uint8_t reg,
     bool multi_read, uint8_t *val)
+{
 #define ADM1026_READ_RETRIES	5
 	int i, j, err = 0;
 	uint8_t creg, cval, tmp[ADM1026_READ_RETRIES + 1];
-	if ((err = iic_acquire_bus(sc->sc_tag, 0)) != 0)
+	if ((err = iic_acquire_bus(tag, 0)) != 0)
 		return err;
 	/* Standard ADM1026 */
-	if (sc->sc_multi_read == false) {
+	if (multi_read == false) {
-		err = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
+		err = iic_exec(tag, I2C_OP_READ_WITH_STOP,
-		    sc->sc_address, &reg, 1, val, 1, 0);
+		    addr, &reg, 1, val, 1, 0);
 	/*
 	 * The ADM1026 found in some Sun machines sometimes reads bogus values.
 	 * We'll read at least twice and check that we get (nearly) the same
 	 * value.  If not, we'll read another register and then re-read the
 	 * first.
 	 */
 	} else {
 		if (reg == ADM1026_CONF1)
 			creg = ADM1026_CONF2;
 		else
 			creg = ADM1026_CONF1;
-		if ((err = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
+		if ((err = iic_exec(tag, I2C_OP_READ_WITH_STOP,
-		    sc->sc_address, &reg, 1, &tmp[0], 1, 0)) != 0) {
+		    addr, &reg, 1, &tmp[0], 1, 0)) != 0) {
-			iic_release_bus(sc->sc_tag, 0);
+			iic_release_bus(tag, 0);
 			return err;
+		}
 		for (i = 1; i <= ADM1026_READ_RETRIES; i++) {
-			if ((err = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
+			if ((err = iic_exec(tag, I2C_OP_READ_WITH_STOP,
-			    sc->sc_address, &reg, 1, &tmp[i], 1, 0)) != 0)
+			    addr, &reg, 1, &tmp[i], 1, 0)) != 0)
 				break;
 			for (j = 0; j < i; j++)
 				if (abs(tmp[j] - tmp[i]) < 3) {
 					*val = tmp[i];
-					iic_release_bus(sc->sc_tag, 0);
+					iic_release_bus(tag, 0);
 					return 0;
+				}
-			if ((err = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
+			if ((err = iic_exec(tag, I2C_OP_READ_WITH_STOP,
-			    sc->sc_address, &creg, 1, &cval, 1, 0)) != 0)
+			    addr, &creg, 1, &cval, 1, 0)) != 0)
 				break;
 			err = -1;	/* Return error if we don't match. */
+		}
+	}
-	iic_release_bus(sc->sc_tag, 0);
+	iic_release_bus(tag, 0);
 	return err;
+}
 static int
 adm1026_write_reg(struct adm1026_softc *sc, uint8_t reg, uint8_t val)
+{
 	int err = 0;
 	if ((err = iic_acquire_bus(sc->sc_tag, 0)) != 0)
 		return err;
 	err = iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP, sc->sc_address,
 	    &reg, 1, &val, 1, 0);
 	iic_release_bus(sc->sc_tag, 0);