Changeset 3321

Timestamp:

07/18/99 20:18:10 (14 years ago)

Author:

frodo

Message:

SMBus access integrated into i2c-core

I think I have done the same thing as Kyösti in his patch, but I included
the real SMBus code too. What was smbus_access is now called i2c_smbus_xfer;
all other functions are prepended with i2c_.

Next thing to do: modify i2c-dev.

Location:

i2c/trunk/kernel

Files:

• i2c-algo-bit.c (modified) (1 diff)
• i2c-algo-pcf.c (modified) (1 diff)
• i2c-core.c (modified) (9 diffs)
• i2c.h (modified) (4 diffs)

i2c/trunk/kernel/i2c-algo-bit.c

@@ -534 +534 @@
         I2C_ALGO_BIT,
         bit_xfer,
+        NULL,
         NULL,                           /* slave_xmit           */
         NULL,                           /* slave_recv           */

i2c/trunk/kernel/i2c-algo-pcf.c

@@ -516 +516 @@
         I2C_ALGO_PCF,
         pcf_xfer,
+        NULL,
         NULL,                           /* slave_xmit           */
         NULL,                           /* slave_recv           */

i2c/trunk/kernel/i2c-core.c

@@ -21 +21 @@
 /* ------------------------------------------------------------------------- */
 
-/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi> and even
-   Frodo Looijaard <frodol@dds.nl> */
+/* With some changes from Kyösti Mälkki <kmalkki@cc.hut.fi>.
+   All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl> */
 
 #include <linux/module.h>
@@ -345 +345 @@
         int ret;
 
-        DEB(printk("master_xfer: %s with %d msgs.\n",adap->name,num));
-
-        I2C_LOCK(adap);
-        ret = adap->algo->master_xfer(adap,msgs,num);
-        I2C_UNLOCK(adap);
-
-        return ret;
+        if (adap->algo->master_xfer) {
+                DEB(printk("master_xfer: %s with %d msgs.\n",adap->name,num));
+
+                I2C_LOCK(adap);
+                ret = adap->algo->master_xfer(adap,msgs,num);
+                I2C_UNLOCK(adap);
+
+                return ret;
+        } else {
+                printk("I2C adapter %04x: I2C level transfers not supported\n",
+                       adap->id);
+                return 0;
+        }
 }
 
@@ -359 +365 @@
         struct i2c_adapter *adap=client->adapter;
         struct i2c_msg msg;
-        msg.addr   = client->addr;
-        msg.flags = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
-        msg.len = count;
-        (const char *)msg.buf = buf;
-
-        DEB(printk("master_send: writing %d bytes on %s.\n",
-                count,client->adapter->name));
-
-        I2C_LOCK(adap);
-        ret = adap->algo->master_xfer(adap,&msg,1);
-        I2C_UNLOCK(adap);
-
-        /* if everything went ok (i.e. 1 msg transmitted), return #bytes
-         * transmitted, else error code.
-         */
-        return (ret == 1 )? count : ret;
+
+        if (client->adapter->algo->master_xfer) {
+                msg.addr   = client->addr;
+                msg.flags = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
+                msg.len = count;
+                (const char *)msg.buf = buf;
+        
+                DEB(printk("master_send: writing %d bytes on %s.\n",
+                        count,client->adapter->name));
+        
+                I2C_LOCK(adap);
+                ret = adap->algo->master_xfer(adap,&msg,1);
+                I2C_UNLOCK(adap);
+
+                /* if everything went ok (i.e. 1 msg transmitted), return #bytes
+                 * transmitted, else error code.
+                 */
+                return (ret == 1 )? count : ret;
+        } else {
+                printk("I2C adapter %04x: I2C level transfers not supported\n",
+                       client->adapter->id);
+                return 0;
+        }
 }
 
@@ -385 +398 @@
         struct i2c_msg msg;
 
-        c = (char*)kmalloc(sizeof(char)*(count+1),GFP_KERNEL);
-        if (0 == c) 
-                return -ENOMEM;
-
-        msg.addr   = client->addr;
-        msg.flags  = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
-        msg.len = count+1;
-        (const char *)msg.buf = c;
+        if (client->adapter->algo->master_xfer) {
+                c = (char*)kmalloc(sizeof(char)*(count+1),GFP_KERNEL);
+                if (0 == c) 
+                        return -ENOMEM;
+        
+                msg.addr   = client->addr;
+                msg.flags  = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
+                msg.len = count+1;
+                (const char *)msg.buf = c;
+                        
+                c[0] = subadress;
+                memcpy(&c[1], buf, sizeof(char)*count);
                 
-        c[0] = subadress;
-        memcpy(&c[1], buf, sizeof(char)*count);
-        
-        DEB(printk("master_send_subadress: writing %d bytes on %s. (sa:0x%02x)\n",
-                count,client->adapter->name,subadress));
-
-        I2C_LOCK(adap);
-        ret = adap->algo->master_xfer(adap,&msg,1);
-        I2C_UNLOCK(adap);
-
-        /* if everything went ok (i.e. 1 msg transmitted), return #bytes
-         * transmitted, else error code.
-         */
+                DEB(printk("master_send_subadress: writing %d bytes on %s. (sa:0x%02x)\n",
+                        count,client->adapter->name,subadress));
+        
+                I2C_LOCK(adap);
+                ret = adap->algo->master_xfer(adap,&msg,1);
+                I2C_UNLOCK(adap);
+
+                /* if everything went ok (i.e. 1 msg transmitted), return #bytes
+                * transmitted, else error code.
+                */
          
-        kfree(c);
-         
-        return (ret == 1 )? count : ret;
+                kfree(c);
+                
+                return (ret == 1 )? count : ret;
+        } else {
+                printk("I2C adapter %04x: I2C level transfers not supported\n",
+                       client->adapter->id);
+                return 0;
+        }
 }
 
@@ -420 +439 @@
         struct  i2c_msg msg[2];
         
-        msg[0].addr     = client->addr;
-        msg[0].flags    = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
-        msg[0].len      = 1;
-        (const char*)msg[0].buf = (const char*)&subadress;
-
-        msg[1].addr     = client->addr;
-        msg[1].flags    = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
-        msg[1].flags    |= I2C_M_RD;
-        msg[1].len      = count;
-        (const char*)msg[1].buf = (const char*)buf;
-        
-        DEB(printk("master_recv_subadress: reading %d bytes from subadress %d on %s.\n",
-                count,subadress,client->adapter->name));
-
-        I2C_LOCK(adap);
-        ret = adap->algo->master_xfer(adap,msg,2);
-        I2C_UNLOCK(adap);
-
-        /* if everything went ok (i.e. 1 msg transmitted),
-           return 0, else return error code.
-         */
-        return (ret == 1 ) ? 0 : ret;
+        if (client->adapter->algo->master_xfer) {
+                msg[0].addr     = client->addr;
+                msg[0].flags    = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
+                msg[0].len      = 1;
+                (const char*)msg[0].buf = (const char*)&subadress;
+        
+                msg[1].addr     = client->addr;
+                msg[1].flags    = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
+                msg[1].flags    |= I2C_M_RD;
+                msg[1].len      = count;
+                (const char*)msg[1].buf = (const char*)buf;
+                
+                DEB(printk("master_recv_subadress: reading %d bytes from subadress %d on %s.\n",
+                        count,subadress,client->adapter->name));
+        
+                I2C_LOCK(adap);
+                ret = adap->algo->master_xfer(adap,msg,2);
+                I2C_UNLOCK(adap);
+
+                /* if everything went ok (i.e. 1 msg transmitted),
+                return 0, else return error code.
+                */
+                return (ret == 1 ) ? 0 : ret;
+        } else {
+                printk("I2C adapter %04x: I2C level transfers not supported\n",
+                       client->adapter->id);
+                return 0;
+        }
 }
 
@@ -451 +476 @@
         struct i2c_msg msg;
         int ret;
-        msg.addr   = client->addr;
-        msg.flags = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
-        msg.flags |= I2C_M_RD;
-        msg.len = count;
-        msg.buf = buf;
-
-        DEB(printk("master_recv: reading %d bytes on %s.\n",
-                count,client->adapter->name));
-
-        I2C_LOCK(adap);
-        ret = adap->algo->master_xfer(adap,&msg,1);
-        I2C_UNLOCK(adap);
-
-        DEB(printk("master_recv: return:%d (count:%d, addr:0x%02x)\n",
-                ret, count, client->addr));
-
-        /* if everything went ok (i.e. 1 msg transmitted), return #bytes
-         * transmitted, else error code.
-         */
-        return (ret == 1 )? count : ret;
+        if (client->adapter->algo->master_xfer) {
+                msg.addr   = client->addr;
+                msg.flags = client->flags & ( I2C_M_TEN|I2C_M_TENMASK );
+                msg.flags |= I2C_M_RD;
+                msg.len = count;
+                msg.buf = buf;
+
+                DEB(printk("master_recv: reading %d bytes on %s.\n",
+                        count,client->adapter->name));
+        
+                I2C_LOCK(adap);
+                ret = adap->algo->master_xfer(adap,&msg,1);
+                I2C_UNLOCK(adap);
+        
+                DEB(printk("master_recv: return:%d (count:%d, addr:0x%02x)\n",
+                        ret, count, client->addr));
+        
+                /* if everything went ok (i.e. 1 msg transmitted), return #bytes
+                * transmitted, else error code.
+                */
+                return (ret == 1 )? count : ret;
+        } else {
+                printk("I2C adapter %04x: I2C level transfers not supported\n",
+                       client->adapter->id);
+                return 0;
+        }
 }
 
@@ -495 +526 @@
 }
 
+
 int i2c_probe(struct i2c_client *client, int low_addr, int hi_addr)
 {
         int i;
         struct i2c_msg msg;
-        msg.flags=client->flags & (I2C_M_TENMASK | I2C_M_TEN );
-        msg.buf = NULL;
-        msg.len = 0;
-        I2C_LOCK(client->adapter);
-        for (i = low_addr; i <= hi_addr; i++) {
-                msg.addr=i;
-                /* TODO: implement a control statement in the algo layer 
-                 * that does address lookup only.
-                 */
-                if (1 == client->adapter->
-                    algo->master_xfer(client->adapter,&msg,1))
-                        break;
-        }
-        I2C_UNLOCK(client->adapter);
-        return (i <= hi_addr) ? (client->addr=i) : -1;
+        if (client->adapter->algo->master_xfer) {
+                msg.flags=client->flags & (I2C_M_TENMASK | I2C_M_TEN );
+                msg.buf = NULL;
+                msg.len = 0;
+                I2C_LOCK(client->adapter);
+                for (i = low_addr; i <= hi_addr; i++) {
+                        msg.addr=i;
+                        /* TODO: implement a control statement in the algo layer 
+                        * that does address lookup only.
+                        */
+                        if (1 == client->adapter->
+                        algo->master_xfer(client->adapter,&msg,1))
+                                break;
+                }
+                I2C_UNLOCK(client->adapter);
+                return (i <= hi_addr) ? (client->addr=i) : -1;
+        } else {
+                printk("I2C adapter %04x: I2C level transfers not supported\n",
+                       client->adapter->id);
+                return 0;
+        }
 }
 
@@ -527 +565 @@
         return -1;
 }
+
+/* The SMBus parts */
+
+extern s32 i2c_smbus_write_quick(struct i2c_adapter * adapter, u8 addr, 
+                                        u8 value)
+{
+        return i2c_smbus_xfer(adapter,addr,value,0,I2C_SMBUS_QUICK,NULL);
+}
+
+extern s32 i2c_smbus_read_byte(struct i2c_adapter * adapter,u8 addr)
+{
+        union i2c_smbus_data data;
+        if (i2c_smbus_xfer(adapter,addr,I2C_SMBUS_READ,0,I2C_SMBUS_BYTE,
+                           &data))
+                return -1;
+        else
+                return 0x0FF & data.byte;
+}
+
+extern s32 i2c_smbus_write_byte(struct i2c_adapter * adapter, u8 addr, 
+                                       u8 value)
+{
+        return i2c_smbus_xfer(adapter,addr,I2C_SMBUS_WRITE,value, 
+                              I2C_SMBUS_BYTE,NULL);
+}
+
+extern s32 i2c_smbus_read_byte_data(struct i2c_adapter * adapter,
+                                           u8 addr, u8 command)
+{
+        union i2c_smbus_data data;
+        if (i2c_smbus_xfer(adapter,addr,I2C_SMBUS_READ,command,
+                           I2C_SMBUS_BYTE_DATA,&data))
+                return -1;
+        else
+                return 0x0FF & data.byte;
+}
+
+extern s32 i2c_smbus_write_byte_data(struct i2c_adapter * adapter,
+                                        u8 addr, u8 command, u8 value)
+{
+        union i2c_smbus_data data;
+        data.byte = value;
+        return i2c_smbus_xfer(adapter,addr,I2C_SMBUS_WRITE,command,
+                              I2C_SMBUS_BYTE_DATA,&data);
+}
+
+extern s32 i2c_smbus_read_word_data(struct i2c_adapter * adapter,
+                                           u8 addr, u8 command)
+{
+        union i2c_smbus_data data;
+        if (i2c_smbus_xfer(adapter,addr,I2C_SMBUS_READ,command,
+                           I2C_SMBUS_WORD_DATA, &data))
+                return -1;
+        else
+                return 0x0FFFF & data.word;
+}
+
+extern s32 i2c_smbus_write_word_data(struct i2c_adapter * adapter,
+                                            u8 addr, u8 command, u16 value)
+{
+        union i2c_smbus_data data;
+        data.word = value;
+        return i2c_smbus_xfer(adapter,addr,I2C_SMBUS_WRITE,command,
+                              I2C_SMBUS_WORD_DATA,&data);
+}
+
+extern s32 i2c_smbus_process_call(struct i2c_adapter * adapter,
+                                     u8 addr, u8 command, u16 value)
+{
+        union i2c_smbus_data data;
+        data.word = value;
+        if (i2c_smbus_xfer(adapter,addr,I2C_SMBUS_WRITE,command,
+                           I2C_SMBUS_PROC_CALL, &data))
+                return -1;
+        else
+                return 0x0FFFF & data.word;
+}
+
+/* Returns the number of read bytes */
+extern s32 i2c_smbus_read_block_data(struct i2c_adapter * adapter,
+                                            u8 addr, u8 command, u8 *values)
+{
+        union i2c_smbus_data data;
+        int i;
+        if (i2c_smbus_xfer(adapter,addr,I2C_SMBUS_READ,command,
+                           I2C_SMBUS_BLOCK_DATA,&data))
+                return -1;
+        else {
+                for (i = 1; i <= data.block[0]; i++)
+                        values[i-1] = data.block[i];
+                return data.block[0];
+        }
+}
+
+extern s32 i2c_smbus_write_block_data(struct i2c_adapter * adapter,
+                                             u8 addr, u8 command, u8 length,
+                                             u8 *values)
+{
+        union i2c_smbus_data data;
+        int i;
+        if (length > 32)
+                length = 32;
+        for (i = 1; i <= length; i++)
+                data.block[i] = values[i-1];
+        data.block[0] = length;
+        return i2c_smbus_xfer(adapter,addr,I2C_SMBUS_WRITE,command,
+                              I2C_SMBUS_BLOCK_DATA,&data);
+}
+
+/* Simulate a SMBus command using the i2c protocol 
+   No checking of parameters is done!  */
+static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u8 addr, 
+                                   char read_write, u8 command, int size, 
+                                   union i2c_smbus_data * data)
+{
+        /* So we need to generate a series of msgs. In the case of writing, we
+          need to use only one message; when reading, we need two. We initialize
+          most things with sane defaults, to keep the code below somewhat
+          simpler. */
+        unsigned char msgbuf0[33];
+        unsigned char msgbuf1[33];
+        int num = read_write == I2C_SMBUS_READ?2:1;
+        struct i2c_msg msg[2] = { { addr, 0, 1, msgbuf0 }, 
+                                  { addr, I2C_M_RD, 0, msgbuf1 }
+                                };
+        int i;
+
+        msgbuf0[0] = command;
+        switch(size) {
+        case I2C_SMBUS_QUICK:
+                msg[0].len = 0;
+                num = 1; /* Special case: The read/write field is used 
+                            as data */
+                break;
+        case I2C_SMBUS_BYTE:
+                if (read_write == I2C_SMBUS_READ) {
+                        /* Special case: only a read! */
+                        msg[0].flags = I2C_M_RD;
+                        num = 1;
+                }
+                break;
+        case I2C_SMBUS_BYTE_DATA:
+                if (read_write == I2C_SMBUS_READ)
+                        msg[1].len = 1;
+                else {
+                        msg[0].len = 2;
+                        msgbuf0[1] = data->byte;
+                }
+                break;
+        case I2C_SMBUS_WORD_DATA:
+                if (read_write == I2C_SMBUS_READ)
+                        msg[1].len = 2;
+                else {
+                        msg[0].len=3;
+                        msgbuf0[1] = data->word & 0xff;
+                        msgbuf0[2] = (data->word >> 8) & 0xff;
+                }
+                break;
+        case I2C_SMBUS_PROC_CALL:
+                num = 2; /* Special case */
+                msg[0].len = 3;
+                msg[1].len = 2;
+                msgbuf0[1] = data->word & 0xff;
+                msgbuf0[2] = (data->word >> 8) & 0xff;
+                break;
+        case I2C_SMBUS_BLOCK_DATA:
+                if (read_write == I2C_SMBUS_READ) {
+                        printk("smbus.o: Block read not supported under "
+                               "I2C emulation!\n");
+                return -1;
+                } else {
+                        msg[1].len = data->block[0] + 1;
+                        if (msg[1].len > 32) {
+                                printk("smbus.o: smbus_access called with "
+                                       "invalid block write size (%d)\n",
+                                       msg[1].len);
+                                return -1;
+                        }
+                        for (i = 1; i <= msg[1].len; i++)
+                                msgbuf0[i] = data->block[i];
+                }
+                break;
+        default:
+                printk("smbus.o: smbus_access called with invalid size (%d)\n",
+                       size);
+                return -1;
+        }
+    
+        if (i2c_transfer(adapter, msg, num) < 0)
+                return -1;
+
+        if (read_write == I2C_SMBUS_READ)
+                switch(size) {
+                        case I2C_SMBUS_BYTE:
+                                data->byte = msgbuf0[0];
+                                break;
+                        case I2C_SMBUS_BYTE_DATA:
+                                data->byte = msgbuf1[0];
+                                break;
+                        case I2C_SMBUS_WORD_DATA: 
+                        case I2C_SMBUS_PROC_CALL:
+                                data->word = msgbuf1[0] | (msgbuf1[1] << 8);
+                                break;
+                }
+        return 0;
+}
+
+
+s32 i2c_smbus_xfer(struct i2c_adapter * adapter, u8 addr, char read_write,
+                   u8 command, int size, union i2c_smbus_data * data)
+{
+        s32 res;
+        if (adapter->algo->smbus_xfer) {
+                down(&adapter->lock);
+                res = adapter->algo->smbus_xfer(adapter,addr,read_write,
+                                                command,size,data);
+                up(&adapter->lock);
+        } else
+                res = i2c_smbus_xfer_emulated(adapter,addr,read_write,
+                                                command,size,data);
+        return res;
+}
+
 
 int __init i2c_init(void)
@@ -633 +894 @@
 EXPORT_SYMBOL(i2c_transfer);
 
+EXPORT_SYMBOL(i2c_smbus_xfer);
+EXPORT_SYMBOL(i2c_smbus_write_quick);
+EXPORT_SYMBOL(i2c_smbus_read_byte);
+EXPORT_SYMBOL(i2c_smbus_write_byte);
+EXPORT_SYMBOL(i2c_smbus_read_byte_data);
+EXPORT_SYMBOL(i2c_smbus_write_byte_data);
+EXPORT_SYMBOL(i2c_smbus_read_word_data);
+EXPORT_SYMBOL(i2c_smbus_write_word_data);
+EXPORT_SYMBOL(i2c_smbus_process_call);
+EXPORT_SYMBOL(i2c_smbus_read_block_data);
+EXPORT_SYMBOL(i2c_smbus_write_block_data);
+
 int init_module(void) 
 {

i2c/trunk/kernel/i2c.h

@@ -48 +48 @@
 struct i2c_client;
 struct i2c_driver;
+union i2c_smbus_data;
 
 
@@ -96 +97 @@
         char *buf;              /* pointer to msg data                  */
 };
+
+
+/* This is the very generalized SMBus access routine. You probably do not
+   want to use this, though; one of the functions below may be much easier,
+   and probably just as fast. 
+   Note that we use i2c_adapter here, because you do not need a specific
+   smbus adapter to call this function. */
+extern s32 i2c_smbus_xfer (struct i2c_adapter * adapter, u8 addr, 
+                           char read_write, u8 command, int size,
+                           union i2c_smbus_data * data);
+
+/* Now follow the 'nice' access routines. These also document the calling
+   conventions of smbus_access. */
+
+extern s32 i2c_smbus_write_quick(struct i2c_adapter * adapter, u8 addr, 
+                                 u8 value);
+extern s32 i2c_smbus_read_byte(struct i2c_adapter * adapter,u8 addr);
+extern s32 i2c_smbus_write_byte(struct i2c_adapter * adapter, u8 addr, 
+                                u8 value);
+extern s32 i2c_smbus_read_byte_data(struct i2c_adapter * adapter,
+                                    u8 addr, u8 command);
+extern s32 i2c_smbus_write_byte_data(struct i2c_adapter * adapter,
+                                 u8 addr, u8 command, u8 value);
+extern s32 i2c_smbus_read_word_data(struct i2c_adapter * adapter,
+                                    u8 addr, u8 command);
+extern s32 i2c_smbus_write_word_data(struct i2c_adapter * adapter,
+                                     u8 addr, u8 command, u16 value);
+extern s32 i2c_smbus_process_call(struct i2c_adapter * adapter,
+                              u8 addr, u8 command, u16 value);
+/* Returns the number of read bytes */
+extern s32 i2c_smbus_read_block_data(struct i2c_adapter * adapter,
+                                     u8 addr, u8 command, u8 *values);
+extern s32 i2c_smbus_write_block_data(struct i2c_adapter * adapter,
+                                      u8 addr, u8 command, u8 length,
+                                      u8 *values);
+
 
 /*
@@ -171 +208 @@
         char name[32];                          /* textual description  */
         unsigned int id;       
+
+        /* If a adapter algorithm can't to I2C-level access, set master_xfer
+           to NULL. If an adapter algorithm can do SMBus access, set 
+           smbus_xfer. If set to NULL, the SMBus protocol is simulated
+           using common I2C messages */
         int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg msgs[], 
                            int num);
+        int (*smbus_xfer) (struct i2c_adapter *adap, u8 addr, char read_write,
+                           u8 command, int size, union i2c_smbus_data * data);
 
         /* --- these optional/future use for some adapter types.*/
@@ -263 +307 @@
 
 #endif /* __KERNEL__ */
+
+/* 
+ * Data for SMBus Messages 
+ */
+union i2c_smbus_data { 
+        __u8 byte;
+        __u16 word;
+        __u8 block[33]; /* block[0] is used for length */
+};
+
+/* smbus_access read or write markers */
+#define I2C_SMBUS_READ      1
+#define I2C_SMBUS_WRITE     0
+
+/* SMBus transaction types (size parameter in the above functions) 
+   Note: these no longer correspond to the (arbitrary) PIIX4 internal codes! */
+#define I2C_SMBUS_QUICK      0
+#define I2C_SMBUS_BYTE       1
+#define I2C_SMBUS_BYTE_DATA  2 
+#define I2C_SMBUS_WORD_DATA  3
+#define I2C_SMBUS_PROC_CALL  4
+#define I2C_SMBUS_BLOCK_DATA 5