]> git.karo-electronics.de Git - linux-beck.git/commitdiff
i2c: Bus drivers return -Errno not -1
authorDavid Brownell <david-b@pacbell.net>
Mon, 14 Jul 2008 20:38:25 +0000 (22:38 +0200)
committerJean Delvare <khali@mahadeva.delvare>
Mon, 14 Jul 2008 20:38:25 +0000 (22:38 +0200)
Tighten error paths used by various i2c adapters (mostly x86) so
they return real fault/errno codes instead of a "-1" (which is
most often interpreted as "-EPERM").  Build tested, with eyeball
review.

One minor initial goal is to have adapters consistently return
the code "-ENXIO" when addressing a device doesn't get an ACK
response, at least in the probe paths where they are already
good at stifling related logspam.

Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Jean Delvare <khali@linux-fr.org>
15 files changed:
drivers/i2c/algos/i2c-algo-bit.c
drivers/i2c/busses/i2c-ali1535.c
drivers/i2c/busses/i2c-ali1563.c
drivers/i2c/busses/i2c-ali15x3.c
drivers/i2c/busses/i2c-amd756-s4882.c
drivers/i2c/busses/i2c-amd756.c
drivers/i2c/busses/i2c-amd8111.c
drivers/i2c/busses/i2c-i801.c
drivers/i2c/busses/i2c-nforce2.c
drivers/i2c/busses/i2c-piix4.c
drivers/i2c/busses/i2c-sis5595.c
drivers/i2c/busses/i2c-sis630.c
drivers/i2c/busses/i2c-sis96x.c
drivers/i2c/busses/i2c-stub.c
drivers/i2c/busses/i2c-viapro.c

index 35812823787bd7030f1cdc2452f923a9e06641a8..eb8f72ca02f45cfe954da3a1240e5a18fdd5d2bd 100644 (file)
@@ -320,7 +320,7 @@ static int try_address(struct i2c_adapter *i2c_adap,
                       unsigned char addr, int retries)
 {
        struct i2c_algo_bit_data *adap = i2c_adap->algo_data;
-       int i, ret = -1;
+       int i, ret = 0;
 
        for (i = 0; i <= retries; i++) {
                ret = i2c_outb(i2c_adap, addr);
@@ -508,7 +508,7 @@ static int bit_doAddress(struct i2c_adapter *i2c_adap, struct i2c_msg *msg)
                        addr ^= 1;
                ret = try_address(i2c_adap, addr, retries);
                if ((ret != 1) && !nak_ok)
-                       return -EREMOTEIO;
+                       return -ENXIO;
        }
 
        return 0;
index f14372ac2fc5d08ef0b8ced5b994d86af7a5dee5..c21e4d96382ea4d37dcdaa727bead406afe2ce09 100644 (file)
@@ -259,7 +259,7 @@ static int ali1535_transaction(struct i2c_adapter *adap)
                        dev_err(&adap->dev,
                                "SMBus reset failed! (0x%02x) - controller or "
                                "device on bus is probably hung\n", temp);
-                       return -1;
+                       return -EBUSY;
                }
        } else {
                /* check and clear done bit */
@@ -281,12 +281,12 @@ static int ali1535_transaction(struct i2c_adapter *adap)
 
        /* If the SMBus is still busy, we give up */
        if (timeout >= MAX_TIMEOUT) {
-               result = -1;
+               result = -ETIMEDOUT;
                dev_err(&adap->dev, "SMBus Timeout!\n");
        }
 
        if (temp & ALI1535_STS_FAIL) {
-               result = -1;
+               result = -EIO;
                dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
        }
 
@@ -295,7 +295,7 @@ static int ali1535_transaction(struct i2c_adapter *adap)
         * do a printk.  This means that bus collisions go unreported.
         */
        if (temp & ALI1535_STS_BUSERR) {
-               result = -1;
+               result = -ENXIO;
                dev_dbg(&adap->dev,
                        "Error: no response or bus collision ADD=%02x\n",
                        inb_p(SMBHSTADD));
@@ -303,13 +303,13 @@ static int ali1535_transaction(struct i2c_adapter *adap)
 
        /* haven't ever seen this */
        if (temp & ALI1535_STS_DEV) {
-               result = -1;
+               result = -EIO;
                dev_err(&adap->dev, "Error: device error\n");
        }
 
        /* check to see if the "command complete" indication is set */
        if (!(temp & ALI1535_STS_DONE)) {
-               result = -1;
+               result = -ETIMEDOUT;
                dev_err(&adap->dev, "Error: command never completed\n");
        }
 
@@ -332,7 +332,7 @@ static int ali1535_transaction(struct i2c_adapter *adap)
        return result;
 }
 
-/* Return -1 on error. */
+/* Return negative errno on error. */
 static s32 ali1535_access(struct i2c_adapter *adap, u16 addr,
                          unsigned short flags, char read_write, u8 command,
                          int size, union i2c_smbus_data *data)
@@ -359,7 +359,7 @@ static s32 ali1535_access(struct i2c_adapter *adap, u16 addr,
        switch (size) {
        case I2C_SMBUS_PROC_CALL:
                dev_err(&adap->dev, "I2C_SMBUS_PROC_CALL not supported!\n");
-               result = -1;
+               result = -EOPNOTSUPP;
                goto EXIT;
        case I2C_SMBUS_QUICK:
                outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
@@ -420,11 +420,9 @@ static s32 ali1535_access(struct i2c_adapter *adap, u16 addr,
                break;
        }
 
-       if (ali1535_transaction(adap)) {
-               /* Error in transaction */
-               result = -1;
+       result = ali1535_transaction(adap);
+       if (result)
                goto EXIT;
-       }
 
        if ((read_write == I2C_SMBUS_WRITE) || (size == ALI1535_QUICK)) {
                result = 0;
index 6b68074e518a072d1239c1e1f8ba61287cc4b456..30bd3ee7038607da867f4818d82b340c1e0c1085 100644 (file)
@@ -67,6 +67,7 @@ static int ali1563_transaction(struct i2c_adapter * a, int size)
 {
        u32 data;
        int timeout;
+       int status = -EIO;
 
        dev_dbg(&a->dev, "Transaction (pre): STS=%02x, CNTL1=%02x, "
                "CNTL2=%02x, CMD=%02x, ADD=%02x, DAT0=%02x, DAT1=%02x\n",
@@ -103,13 +104,15 @@ static int ali1563_transaction(struct i2c_adapter * a, int size)
                /* Issue 'kill' to host controller */
                outb_p(HST_CNTL2_KILL,SMB_HST_CNTL2);
                data = inb_p(SMB_HST_STS);
+               status = -ETIMEDOUT;
        }
 
        /* device error - no response, ignore the autodetection case */
-       if ((data & HST_STS_DEVERR) && (size != HST_CNTL2_QUICK)) {
-               dev_err(&a->dev, "Device error!\n");
+       if (data & HST_STS_DEVERR) {
+               if (size != HST_CNTL2_QUICK)
+                       dev_err(&a->dev, "Device error!\n");
+               status = -ENXIO;
        }
-
        /* bus collision */
        if (data & HST_STS_BUSERR) {
                dev_err(&a->dev, "Bus collision!\n");
@@ -122,13 +125,14 @@ static int ali1563_transaction(struct i2c_adapter * a, int size)
                outb_p(0x0,SMB_HST_CNTL2);
        }
 
-       return -1;
+       return status;
 }
 
 static int ali1563_block_start(struct i2c_adapter * a)
 {
        u32 data;
        int timeout;
+       int status = -EIO;
 
        dev_dbg(&a->dev, "Block (pre): STS=%02x, CNTL1=%02x, "
                "CNTL2=%02x, CMD=%02x, ADD=%02x, DAT0=%02x, DAT1=%02x\n",
@@ -164,13 +168,20 @@ static int ali1563_block_start(struct i2c_adapter * a)
 
        if (timeout && !(data & HST_STS_BAD))
                return 0;
+
+       if (timeout == 0)
+               status = -ETIMEDOUT;
+
+       if (data & HST_STS_DEVERR)
+               status = -ENXIO;
+
        dev_err(&a->dev, "SMBus Error: %s%s%s%s%s\n",
-               timeout ? "Timeout " : "",
+               timeout ? "" : "Timeout ",
                data & HST_STS_FAIL ? "Transaction Failed " : "",
                data & HST_STS_BUSERR ? "No response or Bus Collision " : "",
                data & HST_STS_DEVERR ? "Device Error " : "",
                !(data & HST_STS_DONE) ? "Transaction Never Finished " : "");
-       return -1;
+       return status;
 }
 
 static int ali1563_block(struct i2c_adapter * a, union i2c_smbus_data * data, u8 rw)
index 93bf87d709618fff0ba489aa17028b2d84a39f23..3d752561dc3769bb5d079a23e0187dc30a48e95f 100644 (file)
@@ -282,7 +282,7 @@ static int ali15x3_transaction(struct i2c_adapter *adap)
                        dev_err(&adap->dev, "SMBus reset failed! (0x%02x) - "
                                "controller or device on bus is probably hung\n",
                                temp);
-                       return -1;
+                       return -EBUSY;
                }
        } else {
                /* check and clear done bit */
@@ -304,12 +304,12 @@ static int ali15x3_transaction(struct i2c_adapter *adap)
 
        /* If the SMBus is still busy, we give up */
        if (timeout >= MAX_TIMEOUT) {
-               result = -1;
+               result = -ETIMEDOUT;
                dev_err(&adap->dev, "SMBus Timeout!\n");
        }
 
        if (temp & ALI15X3_STS_TERM) {
-               result = -1;
+               result = -EIO;
                dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
        }
 
@@ -320,7 +320,7 @@ static int ali15x3_transaction(struct i2c_adapter *adap)
          This means that bus collisions go unreported.
        */
        if (temp & ALI15X3_STS_COLL) {
-               result = -1;
+               result = -ENXIO;
                dev_dbg(&adap->dev,
                        "Error: no response or bus collision ADD=%02x\n",
                        inb_p(SMBHSTADD));
@@ -328,7 +328,7 @@ static int ali15x3_transaction(struct i2c_adapter *adap)
 
        /* haven't ever seen this */
        if (temp & ALI15X3_STS_DEV) {
-               result = -1;
+               result = -EIO;
                dev_err(&adap->dev, "Error: device error\n");
        }
        dev_dbg(&adap->dev, "Transaction (post): STS=%02x, CNT=%02x, CMD=%02x, "
@@ -338,7 +338,7 @@ static int ali15x3_transaction(struct i2c_adapter *adap)
        return result;
 }
 
-/* Return -1 on error. */
+/* Return negative errno on error. */
 static s32 ali15x3_access(struct i2c_adapter * adap, u16 addr,
                   unsigned short flags, char read_write, u8 command,
                   int size, union i2c_smbus_data * data)
@@ -364,7 +364,7 @@ static s32 ali15x3_access(struct i2c_adapter * adap, u16 addr,
        switch (size) {
        case I2C_SMBUS_PROC_CALL:
                dev_err(&adap->dev, "I2C_SMBUS_PROC_CALL not supported!\n");
-               return -1;
+               return -EOPNOTSUPP;
        case I2C_SMBUS_QUICK:
                outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
                       SMBHSTADD);
@@ -421,8 +421,9 @@ static s32 ali15x3_access(struct i2c_adapter * adap, u16 addr,
 
        outb_p(size, SMBHSTCNT);        /* output command */
 
-       if (ali15x3_transaction(adap))  /* Error in transaction */
-               return -1;
+       temp = ali15x3_transaction(adap);
+       if (temp)
+               return temp;
 
        if ((read_write == I2C_SMBUS_WRITE) || (size == ALI15X3_QUICK))
                return 0;
index c38a0a112208286787d94966f57048980ad459b8..2f150e33c74c9b19ae6f93dc6e1828ebd619d933 100644 (file)
@@ -58,7 +58,7 @@ static s32 amd756_access_virt0(struct i2c_adapter * adap, u16 addr,
        /* We exclude the multiplexed addresses */
        if (addr == 0x4c || (addr & 0xfc) == 0x50 || (addr & 0xfc) == 0x30
         || addr == 0x18)
-               return -1;
+               return -ENXIO;
 
        mutex_lock(&amd756_lock);
 
@@ -86,7 +86,7 @@ static inline s32 amd756_access_channel(struct i2c_adapter * adap, u16 addr,
 
        /* We exclude the non-multiplexed addresses */
        if (addr != 0x4c && (addr & 0xfc) != 0x50 && (addr & 0xfc) != 0x30)
-               return -1;
+               return -ENXIO;
 
        mutex_lock(&amd756_lock);
 
index 43508d61eb7cf455c03fee1c82d4dfe501fbd260..3d5bcb65e9e01cd9283f31a71498333f7acdc987 100644 (file)
@@ -151,17 +151,17 @@ static int amd756_transaction(struct i2c_adapter *adap)
        }
 
        if (temp & GS_PRERR_STS) {
-               result = -1;
+               result = -ENXIO;
                dev_dbg(&adap->dev, "SMBus Protocol error (no response)!\n");
        }
 
        if (temp & GS_COL_STS) {
-               result = -1;
+               result = -EIO;
                dev_warn(&adap->dev, "SMBus collision!\n");
        }
 
        if (temp & GS_TO_STS) {
-               result = -1;
+               result = -ETIMEDOUT;
                dev_dbg(&adap->dev, "SMBus protocol timeout!\n");
        }
 
@@ -189,22 +189,23 @@ static int amd756_transaction(struct i2c_adapter *adap)
        outw_p(inw(SMB_GLOBAL_ENABLE) | GE_ABORT, SMB_GLOBAL_ENABLE);
        msleep(100);
        outw_p(GS_CLEAR_STS, SMB_GLOBAL_STATUS);
-       return -1;
+       return -EIO;
 }
 
-/* Return -1 on error. */
+/* Return negative errno on error. */
 static s32 amd756_access(struct i2c_adapter * adap, u16 addr,
                  unsigned short flags, char read_write,
                  u8 command, int size, union i2c_smbus_data * data)
 {
        int i, len;
+       int status;
 
        /** TODO: Should I supporte the 10-bit transfers? */
        switch (size) {
        case I2C_SMBUS_PROC_CALL:
                dev_dbg(&adap->dev, "I2C_SMBUS_PROC_CALL not supported!\n");
                /* TODO: Well... It is supported, I'm just not sure what to do here... */
-               return -1;
+               return -EOPNOTSUPP;
        case I2C_SMBUS_QUICK:
                outw_p(((addr & 0x7f) << 1) | (read_write & 0x01),
                       SMB_HOST_ADDRESS);
@@ -256,8 +257,9 @@ static s32 amd756_access(struct i2c_adapter * adap, u16 addr,
        /* How about enabling interrupts... */
        outw_p(size & GE_CYC_TYPE_MASK, SMB_GLOBAL_ENABLE);
 
-       if (amd756_transaction(adap))   /* Error in transaction */
-               return -1;
+       status = amd756_transaction(adap);
+       if (status)
+               return status;
 
        if ((read_write == I2C_SMBUS_WRITE) || (size == AMD756_QUICK))
                return 0;
index 5d1a27ef250450bc76457c8f34b48484beba5e54..a4f687915de1a2d0d6cbaeeeaac0b4c3f537b156 100644 (file)
@@ -77,7 +77,7 @@ static unsigned int amd_ec_wait_write(struct amd_smbus *smbus)
        if (!timeout) {
                dev_warn(&smbus->dev->dev,
                         "Timeout while waiting for IBF to clear\n");
-               return -1;
+               return -ETIMEDOUT;
        }
 
        return 0;
@@ -93,7 +93,7 @@ static unsigned int amd_ec_wait_read(struct amd_smbus *smbus)
        if (!timeout) {
                dev_warn(&smbus->dev->dev,
                         "Timeout while waiting for OBF to set\n");
-               return -1;
+               return -ETIMEDOUT;
        }
 
        return 0;
@@ -102,16 +102,21 @@ static unsigned int amd_ec_wait_read(struct amd_smbus *smbus)
 static unsigned int amd_ec_read(struct amd_smbus *smbus, unsigned char address,
                unsigned char *data)
 {
-       if (amd_ec_wait_write(smbus))
-               return -1;
+       int status;
+
+       status = amd_ec_wait_write(smbus);
+       if (status)
+               return status;
        outb(AMD_EC_CMD_RD, smbus->base + AMD_EC_CMD);
 
-       if (amd_ec_wait_write(smbus))
-               return -1;
+       status = amd_ec_wait_write(smbus);
+       if (status)
+               return status;
        outb(address, smbus->base + AMD_EC_DATA);
 
-       if (amd_ec_wait_read(smbus))
-               return -1;
+       status = amd_ec_wait_read(smbus);
+       if (status)
+               return status;
        *data = inb(smbus->base + AMD_EC_DATA);
 
        return 0;
@@ -120,16 +125,21 @@ static unsigned int amd_ec_read(struct amd_smbus *smbus, unsigned char address,
 static unsigned int amd_ec_write(struct amd_smbus *smbus, unsigned char address,
                unsigned char data)
 {
-       if (amd_ec_wait_write(smbus))
-               return -1;
+       int status;
+
+       status = amd_ec_wait_write(smbus);
+       if (status)
+               return status;
        outb(AMD_EC_CMD_WR, smbus->base + AMD_EC_CMD);
 
-       if (amd_ec_wait_write(smbus))
-               return -1;
+       status = amd_ec_wait_write(smbus);
+       if (status)
+               return status;
        outb(address, smbus->base + AMD_EC_DATA);
 
-       if (amd_ec_wait_write(smbus))
-               return -1;
+       status = amd_ec_wait_write(smbus);
+       if (status)
+               return status;
        outb(data, smbus->base + AMD_EC_DATA);
 
        return 0;
@@ -267,12 +277,17 @@ static s32 amd8111_access(struct i2c_adapter * adap, u16 addr,
 
                default:
                        dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
-                       return -1;
+                       return -EOPNOTSUPP;
        }
 
        amd_ec_write(smbus, AMD_SMB_ADDR, addr << 1);
        amd_ec_write(smbus, AMD_SMB_PRTCL, protocol);
 
+       /* FIXME this discards status from ec_read(); so temp[0] will
+        * hold stack garbage ... the rest of this routine will act
+        * nonsensically.  Ignored ec_write() status might explain
+        * some such failures...
+        */
        amd_ec_read(smbus, AMD_SMB_STS, temp + 0);
 
        if (~temp[0] & AMD_SMB_STS_DONE) {
@@ -286,7 +301,7 @@ static s32 amd8111_access(struct i2c_adapter * adap, u16 addr,
        }
 
        if ((~temp[0] & AMD_SMB_STS_DONE) || (temp[0] & AMD_SMB_STS_STATUS))
-               return -1;
+               return -EIO;
 
        if (read_write == I2C_SMBUS_WRITE)
                return 0;
index b0f771fe43265df51f425593fc1f42ee47ba058e..7d6d9dfcc58a6bb8a40a5492b0b428664e5b861a 100644 (file)
@@ -151,7 +151,7 @@ static int i801_transaction(int xact)
                outb_p(temp, SMBHSTSTS);
                if ((temp = (0x1f & inb_p(SMBHSTSTS))) != 0x00) {
                        dev_dbg(&I801_dev->dev, "Failed! (%02x)\n", temp);
-                       return -1;
+                       return -EBUSY;
                } else {
                        dev_dbg(&I801_dev->dev, "Successful!\n");
                }
@@ -170,7 +170,7 @@ static int i801_transaction(int xact)
        /* If the SMBus is still busy, we give up */
        if (timeout >= MAX_TIMEOUT) {
                dev_dbg(&I801_dev->dev, "SMBus Timeout!\n");
-               result = -1;
+               result = -ETIMEDOUT;
                /* try to stop the current command */
                dev_dbg(&I801_dev->dev, "Terminating the current operation\n");
                outb_p(inb_p(SMBHSTCNT) | SMBHSTCNT_KILL, SMBHSTCNT);
@@ -179,19 +179,19 @@ static int i801_transaction(int xact)
        }
 
        if (temp & SMBHSTSTS_FAILED) {
-               result = -1;
+               result = -EIO;
                dev_dbg(&I801_dev->dev, "Error: Failed bus transaction\n");
        }
 
        if (temp & SMBHSTSTS_BUS_ERR) {
-               result = -1;
+               result = -EIO;
                dev_err(&I801_dev->dev, "Bus collision! SMBus may be locked "
                        "until next hard reset. (sorry!)\n");
                /* Clock stops and slave is stuck in mid-transmission */
        }
 
        if (temp & SMBHSTSTS_DEV_ERR) {
-               result = -1;
+               result = -ENXIO;
                dev_dbg(&I801_dev->dev, "Error: no response!\n");
        }
 
@@ -231,6 +231,7 @@ static int i801_block_transaction_by_block(union i2c_smbus_data *data,
                                           char read_write, int hwpec)
 {
        int i, len;
+       int status;
 
        inb_p(SMBHSTCNT); /* reset the data buffer index */
 
@@ -242,14 +243,15 @@ static int i801_block_transaction_by_block(union i2c_smbus_data *data,
                        outb_p(data->block[i+1], SMBBLKDAT);
        }
 
-       if (i801_transaction(I801_BLOCK_DATA | ENABLE_INT9 |
-                            I801_PEC_EN * hwpec))
-               return -1;
+       status = i801_transaction(I801_BLOCK_DATA | ENABLE_INT9 |
+                                 I801_PEC_EN * hwpec);
+       if (status)
+               return status;
 
        if (read_write == I2C_SMBUS_READ) {
                len = inb_p(SMBHSTDAT0);
                if (len < 1 || len > I2C_SMBUS_BLOCK_MAX)
-                       return -1;
+                       return -EPROTO;
 
                data->block[0] = len;
                for (i = 0; i < len; i++)
@@ -314,11 +316,11 @@ static int i801_block_transaction_byte_by_byte(union i2c_smbus_data *data,
                        if (((temp = inb_p(SMBHSTSTS)) & errmask) != 0x00) {
                                dev_err(&I801_dev->dev,
                                        "Reset failed! (%02x)\n", temp);
-                               return -1;
+                               return -EBUSY;
                        }
                        if (i != 1)
                                /* if die in middle of block transaction, fail */
-                               return -1;
+                               return -EIO;
                }
 
                if (i == 1)
@@ -342,19 +344,19 @@ static int i801_block_transaction_byte_by_byte(union i2c_smbus_data *data,
                        msleep(1);
                        outb_p(inb_p(SMBHSTCNT) & (~SMBHSTCNT_KILL),
                                SMBHSTCNT);
-                       result = -1;
+                       result = -ETIMEDOUT;
                        dev_dbg(&I801_dev->dev, "SMBus Timeout!\n");
                }
 
                if (temp & SMBHSTSTS_FAILED) {
-                       result = -1;
+                       result = -EIO;
                        dev_dbg(&I801_dev->dev,
                                "Error: Failed bus transaction\n");
                } else if (temp & SMBHSTSTS_BUS_ERR) {
-                       result = -1;
+                       result = -EIO;
                        dev_err(&I801_dev->dev, "Bus collision!\n");
                } else if (temp & SMBHSTSTS_DEV_ERR) {
-                       result = -1;
+                       result = -ENXIO;
                        dev_dbg(&I801_dev->dev, "Error: no response!\n");
                }
 
@@ -362,7 +364,7 @@ static int i801_block_transaction_byte_by_byte(union i2c_smbus_data *data,
                 && command != I2C_SMBUS_I2C_BLOCK_DATA) {
                        len = inb_p(SMBHSTDAT0);
                        if (len < 1 || len > I2C_SMBUS_BLOCK_MAX)
-                               return -1;
+                               return -EPROTO;
                        data->block[0] = len;
                }
 
@@ -394,7 +396,7 @@ static int i801_set_block_buffer_mode(void)
 {
        outb_p(inb_p(SMBAUXCTL) | SMBAUXCTL_E32B, SMBAUXCTL);
        if ((inb_p(SMBAUXCTL) & SMBAUXCTL_E32B) == 0)
-               return -1;
+               return -EIO;
        return 0;
 }
 
@@ -414,7 +416,7 @@ static int i801_block_transaction(union i2c_smbus_data *data, char read_write,
                } else if (!(i801_features & FEATURE_I2C_BLOCK_READ)) {
                        dev_err(&I801_dev->dev,
                                "I2C block read is unsupported!\n");
-                       return -1;
+                       return -EOPNOTSUPP;
                }
        }
 
@@ -449,7 +451,7 @@ static int i801_block_transaction(union i2c_smbus_data *data, char read_write,
        return result;
 }
 
-/* Return -1 on error. */
+/* Return negative errno on error. */
 static s32 i801_access(struct i2c_adapter * adap, u16 addr,
                       unsigned short flags, char read_write, u8 command,
                       int size, union i2c_smbus_data * data)
@@ -514,7 +516,7 @@ static s32 i801_access(struct i2c_adapter * adap, u16 addr,
        case I2C_SMBUS_PROC_CALL:
        default:
                dev_err(&I801_dev->dev, "Unsupported transaction %d\n", size);
-               return -1;
+               return -EOPNOTSUPP;
        }
 
        if (hwpec)      /* enable/disable hardware PEC */
@@ -537,7 +539,7 @@ static s32 i801_access(struct i2c_adapter * adap, u16 addr,
        if(block)
                return ret;
        if(ret)
-               return -1;
+               return ret;
        if ((read_write == I2C_SMBUS_WRITE) || (xact == I801_QUICK))
                return 0;
 
index f95efff9b3d1900d4c00744919021cf2da2e0202..081fdf3393f447a63d47bcafb34f8e953e09b114 100644 (file)
@@ -172,16 +172,16 @@ static int nforce2_check_status(struct i2c_adapter *adap)
                dev_dbg(&adap->dev, "SMBus Timeout!\n");
                if (smbus->can_abort)
                        nforce2_abort(adap);
-               return -1;
+               return -ETIMEDOUT;
        }
        if (!(temp & NVIDIA_SMB_STS_DONE) || (temp & NVIDIA_SMB_STS_STATUS)) {
                dev_dbg(&adap->dev, "Transaction failed (0x%02x)!\n", temp);
-               return -1;
+               return -EIO;
        }
        return 0;
 }
 
-/* Return -1 on error */
+/* Return negative errno on error */
 static s32 nforce2_access(struct i2c_adapter * adap, u16 addr,
                unsigned short flags, char read_write,
                u8 command, int size, union i2c_smbus_data * data)
@@ -189,7 +189,7 @@ static s32 nforce2_access(struct i2c_adapter * adap, u16 addr,
        struct nforce2_smbus *smbus = adap->algo_data;
        unsigned char protocol, pec;
        u8 len;
-       int i;
+       int i, status;
 
        protocol = (read_write == I2C_SMBUS_READ) ? NVIDIA_SMB_PRTCL_READ :
                NVIDIA_SMB_PRTCL_WRITE;
@@ -233,7 +233,7 @@ static s32 nforce2_access(struct i2c_adapter * adap, u16 addr,
                                                "Transaction failed "
                                                "(requested block size: %d)\n",
                                                len);
-                                       return -1;
+                                       return -EINVAL;
                                }
                                outb_p(len, NVIDIA_SMB_BCNT);
                                for (i = 0; i < I2C_SMBUS_BLOCK_MAX; i++)
@@ -245,14 +245,15 @@ static s32 nforce2_access(struct i2c_adapter * adap, u16 addr,
 
                default:
                        dev_err(&adap->dev, "Unsupported transaction %d\n", size);
-                       return -1;
+                       return -EOPNOTSUPP;
        }
 
        outb_p((addr & 0x7f) << 1, NVIDIA_SMB_ADDR);
        outb_p(protocol, NVIDIA_SMB_PRTCL);
 
-       if (nforce2_check_status(adap))
-               return -1;
+       status = nforce2_check_status(adap);
+       if (status)
+               return status;
 
        if (read_write == I2C_SMBUS_WRITE)
                return 0;
@@ -274,7 +275,7 @@ static s32 nforce2_access(struct i2c_adapter * adap, u16 addr,
                                dev_err(&adap->dev, "Transaction failed "
                                        "(received block size: 0x%02x)\n",
                                        len);
-                               return -1;
+                               return -EPROTO;
                        }
                        for (i = 0; i < len; i++)
                                data->block[i+1] = inb_p(NVIDIA_SMB_DATA + i);
@@ -335,7 +336,7 @@ static int __devinit nforce2_probe_smb (struct pci_dev *dev, int bar,
                    != PCIBIOS_SUCCESSFUL) {
                        dev_err(&dev->dev, "Error reading PCI config for %s\n",
                                name);
-                       return -1;
+                       return -EIO;
                }
 
                smbus->base = iobase & PCI_BASE_ADDRESS_IO_MASK;
@@ -345,7 +346,7 @@ static int __devinit nforce2_probe_smb (struct pci_dev *dev, int bar,
        if (!request_region(smbus->base, smbus->size, nforce2_driver.name)) {
                dev_err(&smbus->adapter.dev, "Error requesting region %02x .. %02X for %s\n",
                        smbus->base, smbus->base+smbus->size-1, name);
-               return -1;
+               return -EBUSY;
        }
        smbus->adapter.owner = THIS_MODULE;
        smbus->adapter.id = I2C_HW_SMBUS_NFORCE2;
@@ -360,7 +361,7 @@ static int __devinit nforce2_probe_smb (struct pci_dev *dev, int bar,
        if (error) {
                dev_err(&smbus->adapter.dev, "Failed to register adapter.\n");
                release_region(smbus->base, smbus->size);
-               return -1;
+               return error;
        }
        dev_info(&smbus->adapter.dev, "nForce2 SMBus adapter at %#x\n", smbus->base);
        return 0;
index ac916596858764481f08afdde261b770be1a1b54..dc76c0e2dc653f0dfa0126d7995f23f5f9c55b3e 100644 (file)
@@ -253,7 +253,7 @@ static int piix4_transaction(void)
                outb_p(temp, SMBHSTSTS);
                if ((temp = inb_p(SMBHSTSTS)) != 0x00) {
                        dev_err(&piix4_adapter.dev, "Failed! (%02x)\n", temp);
-                       return -1;
+                       return -EBUSY;
                } else {
                        dev_dbg(&piix4_adapter.dev, "Successful!\n");
                }
@@ -275,23 +275,23 @@ static int piix4_transaction(void)
        /* If the SMBus is still busy, we give up */
        if (timeout >= MAX_TIMEOUT) {
                dev_err(&piix4_adapter.dev, "SMBus Timeout!\n");
-               result = -1;
+               result = -ETIMEDOUT;
        }
 
        if (temp & 0x10) {
-               result = -1;
+               result = -EIO;
                dev_err(&piix4_adapter.dev, "Error: Failed bus transaction\n");
        }
 
        if (temp & 0x08) {
-               result = -1;
+               result = -EIO;
                dev_dbg(&piix4_adapter.dev, "Bus collision! SMBus may be "
                        "locked until next hard reset. (sorry!)\n");
                /* Clock stops and slave is stuck in mid-transmission */
        }
 
        if (temp & 0x04) {
-               result = -1;
+               result = -ENXIO;
                dev_dbg(&piix4_adapter.dev, "Error: no response!\n");
        }
 
@@ -309,17 +309,18 @@ static int piix4_transaction(void)
        return result;
 }
 
-/* Return -1 on error. */
+/* Return negative errno on error. */
 static s32 piix4_access(struct i2c_adapter * adap, u16 addr,
                 unsigned short flags, char read_write,
                 u8 command, int size, union i2c_smbus_data * data)
 {
        int i, len;
+       int status;
 
        switch (size) {
        case I2C_SMBUS_PROC_CALL:
                dev_err(&adap->dev, "I2C_SMBUS_PROC_CALL not supported!\n");
-               return -1;
+               return -EOPNOTSUPP;
        case I2C_SMBUS_QUICK:
                outb_p(((addr & 0x7f) << 1) | (read_write & 0x01),
                       SMBHSTADD);
@@ -371,8 +372,9 @@ static s32 piix4_access(struct i2c_adapter * adap, u16 addr,
 
        outb_p((size & 0x1C) + (ENABLE_INT9 & 1), SMBHSTCNT);
 
-       if (piix4_transaction())        /* Error in transaction */
-               return -1;
+       status = piix4_transaction();
+       if (status)
+               return status;
 
        if ((read_write == I2C_SMBUS_WRITE) || (size == PIIX4_QUICK))
                return 0;
index 9ca8f9155f958c40378a50770eb3327a0702c2e6..328441bb547065a35fec28167e0f04df28586009 100644 (file)
@@ -236,7 +236,7 @@ static int sis5595_transaction(struct i2c_adapter *adap)
                sis5595_write(SMB_STS_HI, temp >> 8);
                if ((temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8)) != 0x00) {
                        dev_dbg(&adap->dev, "Failed! (%02x)\n", temp);
-                       return -1;
+                       return -EBUSY;
                } else {
                        dev_dbg(&adap->dev, "Successful!\n");
                }
@@ -254,19 +254,19 @@ static int sis5595_transaction(struct i2c_adapter *adap)
        /* If the SMBus is still busy, we give up */
        if (timeout >= MAX_TIMEOUT) {
                dev_dbg(&adap->dev, "SMBus Timeout!\n");
-               result = -1;
+               result = -ETIMEDOUT;
        }
 
        if (temp & 0x10) {
                dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
-               result = -1;
+               result = -ENXIO;
        }
 
        if (temp & 0x20) {
                dev_err(&adap->dev, "Bus collision! SMBus may be locked until "
                        "next hard reset (or not...)\n");
                /* Clock stops and slave is stuck in mid-transmission */
-               result = -1;
+               result = -EIO;
        }
 
        temp = sis5595_read(SMB_STS_LO) + (sis5595_read(SMB_STS_HI) << 8);
@@ -282,11 +282,13 @@ static int sis5595_transaction(struct i2c_adapter *adap)
        return result;
 }
 
-/* Return -1 on error. */
+/* Return negative errno on error. */
 static s32 sis5595_access(struct i2c_adapter *adap, u16 addr,
                          unsigned short flags, char read_write,
                          u8 command, int size, union i2c_smbus_data *data)
 {
+       int status;
+
        switch (size) {
        case I2C_SMBUS_QUICK:
                sis5595_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
@@ -318,13 +320,14 @@ static s32 sis5595_access(struct i2c_adapter *adap, u16 addr,
                break;
        default:
                dev_warn(&adap->dev, "Unsupported transaction %d\n", size);
-               return -1;
+               return -EOPNOTSUPP;
        }
 
        sis5595_write(SMB_CTL_LO, ((size & 0x0E)));
 
-       if (sis5595_transaction(adap))
-               return -1;
+       status = sis5595_transaction(adap);
+       if (status)
+               return status;
 
        if ((size != SIS5595_PROC_CALL) &&
            ((read_write == I2C_SMBUS_WRITE) || (size == SIS5595_QUICK)))
index 3765dd7f450f06e7c71f6623d67795c9e4cc056d..c4cc5eddf50dc10f0f658833d693c3db85a81952 100644 (file)
@@ -134,7 +134,7 @@ static int sis630_transaction_start(struct i2c_adapter *adap, int size, u8 *oldc
 
                if ((temp = sis630_read(SMB_CNT) & 0x03) != 0x00) {
                        dev_dbg(&adap->dev, "Failed! (%02x)\n", temp);
-                       return -1;
+                       return -EBUSY;
                 } else {
                        dev_dbg(&adap->dev, "Successful!\n");
                }
@@ -177,17 +177,17 @@ static int sis630_transaction_wait(struct i2c_adapter *adap, int size)
        /* If the SMBus is still busy, we give up */
        if (timeout >= MAX_TIMEOUT) {
                dev_dbg(&adap->dev, "SMBus Timeout!\n");
-               result = -1;
+               result = -ETIMEDOUT;
        }
 
        if (temp & 0x02) {
                dev_dbg(&adap->dev, "Error: Failed bus transaction\n");
-               result = -1;
+               result = -ENXIO;
        }
 
        if (temp & 0x04) {
                dev_err(&adap->dev, "Bus collision!\n");
-               result = -1;
+               result = -EIO;
                /*
                  TBD: Datasheet say:
                  the software should clear this bit and restart SMBUS operation.
@@ -250,8 +250,10 @@ static int sis630_block_data(struct i2c_adapter *adap, union i2c_smbus_data *dat
                        if (i==8 || (len<8 && i==len)) {
                                dev_dbg(&adap->dev, "start trans len=%d i=%d\n",len ,i);
                                /* first transaction */
-                               if (sis630_transaction_start(adap, SIS630_BLOCK_DATA, &oldclock))
-                                       return -1;
+                               rc = sis630_transaction_start(adap,
+                                               SIS630_BLOCK_DATA, &oldclock);
+                               if (rc)
+                                       return rc;
                        }
                        else if ((i-1)%8 == 7 || i==len) {
                                dev_dbg(&adap->dev, "trans_wait len=%d i=%d\n",len,i);
@@ -264,9 +266,10 @@ static int sis630_block_data(struct i2c_adapter *adap, union i2c_smbus_data *dat
                                        */
                                        sis630_write(SMB_STS,0x10);
                                }
-                               if (sis630_transaction_wait(adap, SIS630_BLOCK_DATA)) {
+                               rc = sis630_transaction_wait(adap,
+                                               SIS630_BLOCK_DATA);
+                               if (rc) {
                                        dev_dbg(&adap->dev, "trans_wait failed\n");
-                                       rc = -1;
                                        break;
                                }
                        }
@@ -275,13 +278,14 @@ static int sis630_block_data(struct i2c_adapter *adap, union i2c_smbus_data *dat
        else {
                /* read request */
                data->block[0] = len = 0;
-               if (sis630_transaction_start(adap, SIS630_BLOCK_DATA, &oldclock)) {
-                       return -1;
-               }
+               rc = sis630_transaction_start(adap,
+                               SIS630_BLOCK_DATA, &oldclock);
+               if (rc)
+                       return rc;
                do {
-                       if (sis630_transaction_wait(adap, SIS630_BLOCK_DATA)) {
+                       rc = sis630_transaction_wait(adap, SIS630_BLOCK_DATA);
+                       if (rc) {
                                dev_dbg(&adap->dev, "trans_wait failed\n");
-                               rc = -1;
                                break;
                        }
                        /* if this first transaction then read byte count */
@@ -311,11 +315,13 @@ static int sis630_block_data(struct i2c_adapter *adap, union i2c_smbus_data *dat
        return rc;
 }
 
-/* Return -1 on error. */
+/* Return negative errno on error. */
 static s32 sis630_access(struct i2c_adapter *adap, u16 addr,
                         unsigned short flags, char read_write,
                         u8 command, int size, union i2c_smbus_data *data)
 {
+       int status;
+
        switch (size) {
                case I2C_SMBUS_QUICK:
                        sis630_write(SMB_ADDR, ((addr & 0x7f) << 1) | (read_write & 0x01));
@@ -350,13 +356,13 @@ static s32 sis630_access(struct i2c_adapter *adap, u16 addr,
                        size = SIS630_BLOCK_DATA;
                        return sis630_block_data(adap, data, read_write);
                default:
-                       printk("Unsupported I2C size\n");
-                       return -1;
-                       break;
+                       printk("Unsupported SMBus operation\n");
+                       return -EOPNOTSUPP;
        }
 
-       if (sis630_transaction(adap, size))
-               return -1;
+       status = sis630_transaction(adap, size);
+       if (status)
+               return status;
 
        if ((size != SIS630_PCALL) &&
                ((read_write == I2C_SMBUS_WRITE) || (size == SIS630_QUICK))) {
@@ -373,8 +379,7 @@ static s32 sis630_access(struct i2c_adapter *adap, u16 addr,
                        data->word = sis630_read(SMB_BYTE) + (sis630_read(SMB_BYTE + 1) << 8);
                        break;
                default:
-                       return -1;
-                       break;
+                       return -EOPNOTSUPP;
        }
 
        return 0;
index dc235bb8e24d448ae5f815ff45314bdea789d740..29757b2e11dd81280d7cd35d87a5b0fc59175b0e 100644 (file)
@@ -111,7 +111,7 @@ static int sis96x_transaction(int size)
                /* check it again */
                if (((temp = sis96x_read(SMB_CNT)) & 0x03) != 0x00) {
                        dev_dbg(&sis96x_adapter.dev, "Failed (0x%02x)\n", temp);
-                       return -1;
+                       return -EBUSY;
                } else {
                        dev_dbg(&sis96x_adapter.dev, "Successful\n");
                }
@@ -136,19 +136,19 @@ static int sis96x_transaction(int size)
        /* If the SMBus is still busy, we give up */
        if (timeout >= MAX_TIMEOUT) {
                dev_dbg(&sis96x_adapter.dev, "SMBus Timeout! (0x%02x)\n", temp);
-               result = -1;
+               result = -ETIMEDOUT;
        }
 
        /* device error - probably missing ACK */
        if (temp & 0x02) {
                dev_dbg(&sis96x_adapter.dev, "Failed bus transaction!\n");
-               result = -1;
+               result = -ENXIO;
        }
 
        /* bus collision */
        if (temp & 0x04) {
                dev_dbg(&sis96x_adapter.dev, "Bus collision!\n");
-               result = -1;
+               result = -EIO;
        }
 
        /* Finish up by resetting the bus */
@@ -161,11 +161,12 @@ static int sis96x_transaction(int size)
        return result;
 }
 
-/* Return -1 on error. */
+/* Return negative errno on error. */
 static s32 sis96x_access(struct i2c_adapter * adap, u16 addr,
                         unsigned short flags, char read_write,
                         u8 command, int size, union i2c_smbus_data * data)
 {
+       int status;
 
        switch (size) {
        case I2C_SMBUS_QUICK:
@@ -203,17 +204,17 @@ static s32 sis96x_access(struct i2c_adapter * adap, u16 addr,
        case I2C_SMBUS_BLOCK_DATA:
                /* TO DO: */
                dev_info(&adap->dev, "SMBus block not implemented!\n");
-               return -1;
+               return -EOPNOTSUPP;
                break;
 
        default:
-               dev_info(&adap->dev, "Unsupported I2C size\n");
-               return -1;
-               break;
+               dev_info(&adap->dev, "Unsupported SMBus operation\n");
+               return -EOPNOTSUPP;
        }
 
-       if (sis96x_transaction(size))
-               return -1;
+       status = sis96x_transaction(size);
+       if (status)
+               return status;
 
        if ((size != SIS96x_PROC_CALL) &&
                ((read_write == I2C_SMBUS_WRITE) || (size == SIS96x_QUICK)))
index d08eeec53913ce9759a74e82b984bdc06dcf18b8..e37ccd80f77a3b22d8bd488b944d50c8ee972515 100644 (file)
@@ -43,7 +43,7 @@ struct stub_chip {
 
 static struct stub_chip *stub_chips;
 
-/* Return -1 on error. */
+/* Return negative errno on error. */
 static s32 stub_xfer(struct i2c_adapter * adap, u16 addr, unsigned short flags,
        char read_write, u8 command, int size, union i2c_smbus_data * data)
 {
@@ -120,7 +120,7 @@ static s32 stub_xfer(struct i2c_adapter * adap, u16 addr, unsigned short flags,
 
        default:
                dev_dbg(&adap->dev, "Unsupported I2C/SMBus command\n");
-               ret = -1;
+               ret = -EOPNOTSUPP;
                break;
        } /* switch (size) */
 
index 77b13d027f86336a08eda1d6e8110131aff1d84e..7628fe8e0946b1a7dcc6ec5fc48900fe800428d2 100644 (file)
@@ -152,7 +152,7 @@ static int vt596_transaction(u8 size)
                if ((temp = inb_p(SMBHSTSTS)) & 0x1F) {
                        dev_err(&vt596_adapter.dev, "SMBus reset failed! "
                                "(0x%02x)\n", temp);
-                       return -1;
+                       return -EBUSY;
                }
        }
 
@@ -167,24 +167,24 @@ static int vt596_transaction(u8 size)
 
        /* If the SMBus is still busy, we give up */
        if (timeout >= MAX_TIMEOUT) {
-               result = -1;
+               result = -ETIMEDOUT;
                dev_err(&vt596_adapter.dev, "SMBus timeout!\n");
        }
 
        if (temp & 0x10) {
-               result = -1;
+               result = -EIO;
                dev_err(&vt596_adapter.dev, "Transaction failed (0x%02x)\n",
                        size);
        }
 
        if (temp & 0x08) {
-               result = -1;
+               result = -EIO;
                dev_err(&vt596_adapter.dev, "SMBus collision!\n");
        }
 
        if (temp & 0x04) {
                int read = inb_p(SMBHSTADD) & 0x01;
-               result = -1;
+               result = -ENXIO;
                /* The quick and receive byte commands are used to probe
                   for chips, so errors are expected, and we don't want
                   to frighten the user. */
@@ -202,12 +202,13 @@ static int vt596_transaction(u8 size)
        return result;
 }
 
-/* Return -1 on error, 0 on success */
+/* Return negative errno on error, 0 on success */
 static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
                unsigned short flags, char read_write, u8 command,
                int size, union i2c_smbus_data *data)
 {
        int i;
+       int status;
 
        switch (size) {
        case I2C_SMBUS_QUICK:
@@ -258,8 +259,9 @@ static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
 
        outb_p(((addr & 0x7f) << 1) | read_write, SMBHSTADD);
 
-       if (vt596_transaction(size)) /* Error in transaction */
-               return -1;
+       status = vt596_transaction(size);
+       if (status)
+               return status;
 
        if ((read_write == I2C_SMBUS_WRITE) || (size == VT596_QUICK))
                return 0;
@@ -287,7 +289,7 @@ static s32 vt596_access(struct i2c_adapter *adap, u16 addr,
 exit_unsupported:
        dev_warn(&vt596_adapter.dev, "Unsupported command invoked! (0x%02x)\n",
                 size);
-       return -1;
+       return -EOPNOTSUPP;
 }
 
 static u32 vt596_func(struct i2c_adapter *adapter)