Linux 下 i2c switch(选路芯片mux) — pca9548

作者： 韩大卫@吉林师范大学




    现有的关于i2c switch 资料非常少。即使阅读完官方的datasheet.也不能写出完全正确的操作。


因为内核中的驱动本身不是那么完善的。还有一些资料是单片机编程的，可惜在linux上并不能成功执行。


pca954x 系列是一种 i2c switch 芯片，比如pca9548 可实现8个开关， 进而实现多了8条i2c通道。


这样可以在有限的i2c 资源上扩展出足够多的接口。解决了在使用 i2c总线容量的问题。




   Pca954x 内部只有一个控制寄存器。属于无子地址设备。做I/O 访问时，只需要向0x00 地址处做写操作即可，这就可实现pca954x 下挂设备 i2c bus 的选路。


但是在现有的pca954x 驱动函数中，没有实现自动对内部控制寄存器进行相应配置，这样的话就需要额外的写一个附加的配置函数，实现这种功能。


如果没有这种配置函数，只是使用现有的内核代码，那么会出现有一些难以发现的问题，但是还是被我遇到了。


在我看来，这种问题暂且不能算bug，但至少应该去优化，毕竟，如果每次在访问不同的i2c bus 时，


需要我们手动的去操作i2c switch 的开关，这多少会影响执行效率，代码量变大。还有一点，


我们自己编写的配置函数，是严重依赖于硬件的，即我们的开关位置打开的位置需要自己判断，


在代码上固定写出， 可移植性差。稍后可以在我的代码中看到这种缺陷。


基于以上原因， 我认为pca954x 的驱动应该修改。有时间的话我会整理出自己的代码，融入到内核代码中去，再提供出API 供大家使用。




I2C 1 地址 0x71,0x72,0x73 上都是pca9548, 每个pca9548上 挂了8 个 千兆以太网光模块sfp。 这样 我们系统上就可以同时挂载 24 个 千兆以太网光模块sfp。


I2C 0 地址  0x70 也是pca9548， 挂了2个万兆以太网光模块XFP，还有3个温度传感器TMP411.


*********** ***************


下面的内容是i2c bus 选路函数。之后是从内核代码入手的分析过程，以证明我的判断，阅读起来肯定是


有些难度，因为驱动的工作本身亦如此。如果不是从事嵌入式linux驱动的，就不必深究。


阅读本文前提是在linux的用户层和内核层要有所了解，请参考其他资料。
*********** ************************
如果需要完整的代码，请联系我:[e-mail]


转载请务必表明出处。
******* ****************************


// 这是需要我们自己添加的函数。使用它来控制 i2c bus 的选路。


//   0x70  在i2c 0上 , 0x71 0x72 0x73   在i2c 1 上。


//  如果是操作的 i2c bus 是/dev/i2c-10，程序根据 10 来判断i2c bus 的选路。


// /dev/i2c-2 到/dev/i2c-9 属于 0x70 的pca9548


// /dev/i2c-10 到/dev/i2c-17 属于 0x71 的pca9548 


// /dev/i2c-18 到/dev/i2c-25 属于0x72 的pca9548


// /dev/i2c-26 到/dev/i2c-33 属于 0x73 的pca9548


inline int i2c_bus_chan_enable(char* argv,intflag){
                 
    int ret,tmp;       
    unsigned char val = 0;
    unsigned short addr;
    char *s = argv;    
                       
    while(*s++ != '-' && *s);
                 
    if(*s)             
        ret  =atoi(s); 
                       
    if(ret < 10 && ret !=1)
        addr = 0x70;   
    else               
        addr = ret < 18 ?0x71 : (ret > 25 ? 0x73 : 0x72);
                                  
    if(addr != 0x70){   
        tmp = ( addr == 0x71? 10 : (addr == 0x72 ? 18 : 25));     
        val = 1 <<((ret - tmp) % 8 ) ;
    }                  
    else{              
     
// 给相应的 i2c  bus 置1            
        if( ret == 2 ) 
            val =1 << 1;
        else if( ret == 3 )
            val =1 << 2;
        else if( ret == 4 )
            val =1 << 3;
        else if( ret == 9 )
            val =1 << 7;
        else if( ret == 8 )
            val =1 << 6;
    }            
                       
// 先向 pca9548 的i2c 地址 写相应的数值，打开相应的i2c bus
    ret =i2c_write_data(addr,0x00,val);
    if(ret < 0){       
        printf("i2cswitch init error!\n");
        return -1;                                              
   }       
    return 0;   
}           
  




********* *******************


下面是在此函数的使用：


main.c{
…..
                int ret,tmp;
                   unsigned char val   = 0;
                   char cmd_buf[1024]  = {0};
                   unsigned short addr ;
                        
                   i2c_path(argv[2],0);                                                                                         
                   i2c_bus_chan_enable(argv[2],1);
                        
                   printf("offset = 0x%x\n",offset);
                   for(addr = 0x00; addr < 0xff ;addr++){
                       ret = i2c_read_data(addr,0x00,&val);
                       if(!ret)
                           printf("addr = %x,val =%x\n",addr,val);
                   }    
               }else    
                       error_info();
        }        




…..
}




inline int
i2c_read_data(u16 addr, u8 offset, u8 *val)
{
    int ret = 0;
   
    struct i2c_rdwr_ioctl_data *data;
   
    if ((data = (structi2c_rdwr_ioctl_data *)malloc(sizeof(struct i2c_rdwr_ioctl_data))) == NULL)
    return -1;
   
    data->nmsgs = 2;
    if ((data->msgs = (structi2c_msg *)malloc(data->nmsgs * sizeof(struct i2c_msg))) == NULL) {
        ret = -1;
        goto errexit3;
    }
    if ((data->msgs[0].buf =(unsigned char *)malloc(sizeof(unsigned char))) == NULL) {
        ret = -1;
        goto errexit2;
    }
    if ((data->msgs[1].buf =(unsigned char *)malloc(sizeof(unsigned char))) == NULL) {
        ret = -1;
        goto errexit1;
    }
   
    data->msgs[0].addr     = addr;
    data->msgs[0].flags    = 0;
    data->msgs[0].len      = 1;
    data->msgs[0].buf[0]   = offset;
   
    data->msgs[1].addr     = addr;
    data->msgs[1].flags    = I2C_M_RD;
    data->msgs[1].len      = 1;        
    data->msgs[1].buf[0]   = 0;
   
    if ((ret = __i2c_send(fd, data))< 0)
        goto errexit0;


    *val = data->msgs[1].buf[0];
    
errexit0:
    free(data->msgs[1].buf);
errexit1:
    free(data->msgs[0].buf);
errexit2:
    free(data->msgs);
errexit3:
    free(data);
    
    return ret;
}   
   
static int
__i2c_send(int fd, struct i2c_rdwr_ioctl_data*data)
{  
    int ret;
   
    if (fd < 0)
        return -1;
   
    if (data == NULL)
        return -1;
   
    if (data->msgs == NULL ||data->nmsgs == 0)
        return -1;
    
    ret = ioctl(fd, I2C_RDWR,(unsigned long)data) ;
    if(ret < 0)
        return -1;
   
    return 0;    
}  




********* **********************


下面是驱动的分析过程， /driver/i2c/i2c-mux.c 到/driver/i2c/muxes/pca954x.c


******** **********************


在内核源代码 drivers/i2c/i2c-mux.c  中：




struct i2c_mux_priv {
    struct i2c_adapter adap;
    struct i2c_algorithm algo;
  
    struct i2c_adapter *parent;
    void *mux_priv; /* the mux chip/device */
    u32  chan_id;   /* the channel id */
  
    int (*select)(struct i2c_adapter*, void *mux_priv, u32 chan_id);
    int (*deselect)(struct i2c_adapter*, void *mux_priv, u32 chan_id);
};
  




static int i2c_mux_master_xfer(structi2c_adapter *adap,
                  struct i2c_msg msgs[], int num)
{
    struct i2c_mux_priv *priv =adap->algo_data;
    struct i2c_adapter *parent =priv->parent;
    int ret;
 
    /* Switch to the right mux portand perform the transfer. */
 
    ret = priv->select(parent,priv->mux_priv, priv->chan_id);
    if (ret >= 0)
        ret =parent->algo->master_xfer(parent, msgs, num);
    if (priv->deselect)
       priv->deselect(parent, priv->mux_priv, priv->chan_id);
 
    return ret;
}
 


/* i2c_mux_master_xfer() 这个函数 的实现调用：parent->algo->master_xfer()


master_xfer() 在上一层是在i2c-core.c中的i2c_transfer().


master_xfer() 的下一层是在driver/i2c/busses/i2c-XXX.c 中的


xxx_i2c_xfer() ,xxx为具体cpu，这个xxx_i2c_xfer()真正读写了cpu的i2c 

寄存器，实现了数据通信。


*/




static int i2c_mux_smbus_xfer(struct i2c_adapter*adap,
                 u16 addr, unsigned short flags,
                 char read_write, u8 command,
                 int size, union i2c_smbus_data *data)
{   
    struct i2c_mux_priv *priv =adap->algo_data;
    struct i2c_adapter *parent =priv->parent;
    int ret;
    
    /* Select the right mux port andperform the transfer. */
    
    ret = priv->select(parent,priv->mux_priv, priv->chan_id);
    if (ret >= 0)
        ret =parent->algo->smbus_xfer(parent, addr, flags,
                   read_write, command, size, data);                                                                            
    if (priv->deselect)
       priv->deselect(parent, priv->mux_priv, priv->chan_id);
    
    return ret;
}   
    




/*  
smbus_xfer()  同master_xfer()  。


在 driver/i2c/i2c.h 中可以看到：


struct i2c_algorithm {
    /* If an adapter algorithm can'tdo I2C-level access, set master_xfer
       to NULL. If an adapteralgorithm can do SMBus access, set
       smbus_xfer. If set toNULL, the SMBus protocol is simulated
       using common I2Cmessages */
    /* master_xfer should return thenumber of messages successfully
       processed, or anegative value on error */
    int (*master_xfer)(structi2c_adapter *adap, struct i2c_msg *msgs,
              int num);
    int (*smbus_xfer) (structi2c_adapter *adap, u16 addr,                                                                        
              unsigned short flags, char read_write,
              u8 command, int size, union i2c_smbus_data *data);
             
    /* To determine what the adaptersupports */
    u32 (*functionality) (structi2c_adapter *);
};                           
    


通过  parent->algo->smbus_xfer


但是重要的master_xfer(), smbus_xfer() 在一般cpu中没有相应的实现。


比如我的 driver/i2c/busses/i2c-octeon.c ：


static const struct i2c_algorithmocteon_i2c_algo = {
    .master_xfer = octeon_i2c_xfer,
    .functionality =octeon_i2c_functionality,
};  
    
可以看到，只有 master_xfer 的实现函数。


*/




/* Return the parent's functionality */
static u32 i2c_mux_functionality(structi2c_adapter *adap)
{                  
    struct i2c_mux_priv *priv =adap->algo_data;
    struct i2c_adapter *parent =priv->parent;
                   
    returnparent->algo->functionality(parent);
}    
/*
这个函数填充了struct i2c_algorithm中的


 u32 (*functionality) (struct i2c_adapter*);


*/




struct i2c_adapter *i2c_add_mux_adapter(structi2c_adapter *parent,
               struct device *mux_dev,
               void *mux_priv, u32 force_nr, u32 chan_id,
               int (*select) (struct i2c_adapter *,
                          void *, u32),
               int (*deselect) (struct i2c_adapter *,
                        void *, u32))
{                             
    struct i2c_mux_priv *priv; 
    int ret;                  
                              
    priv = kzalloc(sizeof(structi2c_mux_priv), GFP_KERNEL);
    if (!priv)                
        return NULL;          
                              
    /* Set up private adapter data */
    priv->parent = parent;    
    priv->mux_priv =mux_priv; 
    priv->chan_id = chan_id;  
    priv->select = select;    
    priv->deselect =deselect; 
                              
    /* Need to do algo dynamicallybecause we don't know ahead
     * of time what sort ofphysical adapter we'll be dealing with.
     */                       
    if(parent->algo->master_xfer)
        priv->algo.master_xfer= i2c_mux_master_xfer;
    if(parent->algo->smbus_xfer)
       priv->algo.smbus_xfer = i2c_mux_smbus_xfer;
    priv->algo.functionality =i2c_mux_functionality;
                              
   /* Now fill out new adapterstructure */
    snprintf(priv->adap.name,sizeof(priv->adap.name),
        "i2c-%d-mux (chan_id %d)", i2c_adapter_id(parent), chan_id);
    priv->adap.owner = THIS_MODULE;
    priv->adap.id = parent->id;
    priv->adap.algo =&priv->algo;
    priv->adap.algo_data = priv;
    priv->adap.dev.parent =&parent->dev;
                        
    if (force_nr) {     
        priv->adap.nr =force_nr;
        ret =i2c_add_numbered_adapter(&priv->adap);
    } else {            
        ret =i2c_add_adapter(&priv->adap);
    }                   
    if (ret < 0) {      
       dev_err(&parent->dev, 
           "failed to add mux-adapter (error=%d)\n",
            ret);       
        kfree(priv);    
        return NULL;    
    }                   
                        
    dev_info(&parent->dev,"Added multiplexed i2c bus %d\n",
        i2c_adapter_id(&priv->adap));
    
#ifdef CONFIG_OF     
    /* Try to get populate the muxadapter's of_node */
    if (mux_dev->of_node) {  
        struct device_node*child = NULL;
        const __be32 *reg;   
        int len;  
     
        for (;;) {  
            child= of_get_next_child(mux_dev->of_node, child);
            if(!child)       
               break;
            reg =of_get_property(child, "reg", &len);
            if(!reg || (len < sizeof(__be32)))
               continue;     
            if(chan_id == be32_to_cpup(reg)) {
               priv->adap.dev.of_node = child;
               break;
            }
        }
    }
    of_i2c_register_devices(&priv->adap);
#endif
                     
    return &priv->adap;
}                            






/*


这个函数的作用是：向内核注册一个 i2c_mux_adap


过程是：填充一个 struct i2c_mux_priv *priv;  


最后返回这个进行设备注册过的priv->adap

结构体定义是：


struct i2c_mux_priv {
    struct i2c_adapter adap;
    struct i2c_algorithm algo;
    struct i2c_adapter *parent;
    void *mux_priv; //the muxchip/device 
    u32  chan_id;   // the channel id


// 使能函数，关闭函数
    int (*select)(struct i2c_adapter*, void *mux_priv, u32 chan_id);
    int (*deselect)(struct i2c_adapter*, void *mux_priv, u32 chan_id);
};


1）priv->parent = parent;    
    priv->mux_priv =mux_priv; 
    priv->chan_id = chan_id;  
    priv->select = select;    
    priv->deselect =deselect; 




2）根据parent 中algo中存在的master_xfer(),smbus_xfer()函数 ，做相应填充。


  if (parent->algo->master_xfer)
       priv->algo.master_xfer = i2c_mux_master_xfer;
    if(parent->algo->smbus_xfer)
       priv->algo.smbus_xfer = i2c_mux_smbus_xfer;
    priv->algo.functionality =i2c_mux_functionality;
               
3） 填充priv的 adap.


Adap的结构是：
struct i2c_adapter {
    struct module *owner;
    unsigned int id;
    unsigned int class;      /* classes to allow probing for */
    const struct i2c_algorithm *algo;/* the algorithm to access the bus */
    void *algo_data;
   
    /* data fields that are valid forall devices   */
    u8 level;          /* nesting level for lockdep */
    struct mutex bus_lock;
   
    int timeout;           /* in jiffies */
    int retries;
    struct device dev;     /* the adapter device */
   
    int nr;
    char name[48];
    struct completion dev_released;
}; 




priv->adap.owner = THIS_MODULE;
    priv->adap.id = parent->id;                                                                                                 
    priv->adap.algo =&priv->algo;
    priv->adap.algo_data = priv;
    priv->adap.dev.parent =&parent->dev;
               
4）根据 force_nr 决定怎样将priv->adap进行注册。


 if (force_nr) {     
        priv->adap.nr = force_nr;
        ret =i2c_add_numbered_adapter(&priv->adap);
    } else {           
        ret =i2c_add_adapter(&priv->adap);
    }                                  

5）
of_i2c_register_devices(&priv->adap);


最后将priv->adap 进行 设备注册。
*/


*************************************************




drivers/i2c/muxes/pca954x.c


                       
static struct i2c_driver pca954x_driver = {
    .driver     = {    
        .name   ="pca954x",
        .owner  =THIS_MODULE,
    },                 
    .probe      =pca954x_probe,
    .remove     =pca954x_remove,
    .id_table   = pca954x_id,
};                     
     


在pca054x_prove() 中：




static int pca954x_probe(struct i2c_client*client,
            const struct i2c_device_id *id)
{   
    struct i2c_adapter *adap =to_i2c_adapter(client->dev.parent);
    struct pca954x_platform_data*pdata = client->dev.platform_data;
    int num, force;
    struct pca954x *data;
    int ret = -ENODEV;
    
    if (!i2c_check_functionality(adap,I2C_FUNC_SMBUS_BYTE))
        goto err;
    
    data = kzalloc(sizeof(structpca954x), GFP_KERNEL);
    if (!data) {
        ret = -ENOMEM;
        goto err;
    }
    
    i2c_set_clientdata(client, data);
    
    /* Write the mux register at addrto verify
     * that the mux is in factpresent. This also
     * initializes the mux todisconnected state.
     */
    if (i2c_smbus_write_byte(client,0) < 0) {
       dev_warn(&client->dev, "probe failed\n");
        goto exit_free;
    }
    
    data->type =id->driver_data;
    data->last_chan = 0;          /* force the first selection */


  /* Now create an adapter for each channel*/
    for (num = 0; num <chips[data->type].nchans; num++) {
        force = 0;           /* dynamic adap number */
        if (pdata) {
            if(num < pdata->num_modes)
               /* force static number */
               force = pdata->modes[num].adap_id;
            else
               /* discard unconfigured channels */
               break;
        }
    
       data->virt_adaps[num] =
           i2c_add_mux_adapter(adap, &client->dev, client,
               force, num, pca954x_select_chan,
               (pdata && pdata->modes[num].deselect_on_exit)
                   ? pca954x_deselect_mux : NULL);
    
        if(data->virt_adaps[num] == NULL) {
            ret =-ENODEV;
           dev_err(&client->dev,
               "failed to register multiplexed adapter"
               " %d as bus %d\n", num, force);
            gotovirt_reg_failed;
        }
    }
    
    dev_info(&client->dev,
        "registered %d multiplexed busses for I2C %s %s\n",                                                                     
         num,chips[data->type].muxtype == pca954x_ismux
               ? "mux" : "switch", client->name);
    
    return 0;
    
virt_reg_failed:
    for (num--; num >= 0; num--)
       i2c_del_mux_adapter(data->virt_adaps[num]);
exit_free:
    kfree(data);
err:
    return ret;
}   


/*




pca954x_platfrom_data 的结构定义是：


 struct pca954x_platform_data 
 
/* Per channel initialisation data:
 * @adap_id: bus number for the adapter. 0= don't care
 * @deselect_on_exit: set this entry to 1,if your H/W needs deselection
 *                   of this channel after transaction.
 * 
 */
struct pca954x_platform_mode {
    int     adap_id;
    unsigned int   deselect_on_exit:1;
};  
    


/* Per mux/switch data, used withi2c_register_board_info */
struct pca954x_platform_data {
    struct pca954x_platform_mode*modes;                                                                                         
    int num_modes;
};  
    


2） chips[]   的定义是：


static const struct chip_desc chips[] = {
    [pca_9540] = {
        .nchans = 2,
        .enable = 0x4,
        .muxtype =pca954x_ismux,
    },
    [pca_9543] = {
        .nchans = 2,
        .muxtype =pca954x_isswi,
    },
    [pca_9544] = {
        .nchans = 4,
        .enable = 0x4,
        .muxtype =pca954x_ismux,
    },
    [pca_9545] = {
        .nchans = 4,
        .muxtype =pca954x_isswi,
    },
    [pca_9547] = {
        .nchans = 8,
        .enable = 0x8,
        .muxtype =pca954x_ismux,
    },
    [pca_9548] = {
        .nchans = 8,
        .muxtype =pca954x_isswi,
    },
};  


其中， pca_9540， pca_9542 等被定义为枚举类型：
一共8个 芯片类型。


enum pca_type {
    pca_9540,
    pca_9542,
    pca_9543,
    pca_9544,
    pca_9545,
    pca_9546,
    pca_9547,
    pca_9548,
};  
    




*/


              
static int pca954x_select_chan(structi2c_adapter *adap,
                  void *client, u32 chan)
{             
    struct pca954x *data =i2c_get_clientdata(client);
    const struct chip_desc *chip =&chips[data->type];
    u8 regval; 
    int ret = 0;
              
    /* we make switches look likemuxes, not sure how to be smarter */
    if (chip->muxtype ==pca954x_ismux)
        regval = chan |chip->enable;
    else       
        regval = 1 <<chan;
              
   
    /* Only select the channel if itsdifferent from the last channel */
    if (data->last_chan != regval){
        ret =pca954x_reg_write(adap, client, regval);
        data->last_chan =regval;
    }         
              
    return ret;
}             


一，
填充一个struct pca954x 的结构体， 定义如下：


struct pca954x {
    enum pca_type type;
    struct i2c_adapter*virt_adaps[PCA954X_MAX_NCHANS];                                                                           
    
    u8 last_chan;      /* last register value */
};  
    




enum pca_tyep type  的定义是：


enum pca_type {                                                                                                                 
    pca_9540,
    pca_9542,
    pca_9543,
    pca_9544,
    pca_9545,
    pca_9546,
    pca_9547,
    pca_9548,
};        
  


二，struct chip_desc  的定义是：




struct chip_desc {                                                                                                              
    u8 nchans;
    u8 enable;  /* used for muxesonly */
    enum muxtype {
        pca954x_ismux = 0,
        pca954x_isswi
    } muxtype;
};
 


const struct chip_desc *chip =&chips[data->type];


用一个指针“引用”到了具体类型的pca954x芯片数据。 


if (chip->muxtype == pca954x_ismux)                                                                                         
        regval = chan |chip->enable;
    else                            
        regval = 1 <<chan;          


根据具体芯片的 muxtype 来决定 选路通道。


  if (data->last_chan != regval) {
        ret =pca954x_reg_write(adap, client, regval);                                                                           
        data->last_chan =regval;
    }                   
                        
如果该选路 不是芯片上一次使用的通道，那么执行新选路，执行后再将此选路作为新的last_chan.




pca954x_reg_write() 函数作用是： 通知cpu，client执行新选路通道。


定义如下：


static int pca954x_reg_write(struct i2c_adapter*adap,                                                                            
                struct i2c_client *client, u8 val)
{
    int ret = -ENODEV;
 
    if (adap->algo->master_xfer){
        struct i2c_msg msg;
        char buf[1];
 
        msg.addr =client->addr;
        msg.flags = 0;
        msg.len = 1;
        buf[0] = val;
        msg.buf = buf;
        ret =adap->algo->master_xfer(adap, &msg, 1);
    } else {
        union i2c_smbus_datadata;
        ret =adap->algo->smbus_xfer(adap, client->addr,
                        client->flags,
                        I2C_SMBUS_WRITE,
                        val, I2C_SMBUS_BYTE, &data);
    }                  
                       
    return ret;        
}  
/* Write to mux register. Don't usei2c_transfer()/i2c_smbus_xfer()
   for this as they will try to lockadapter a second time */


根据提示，不能使用i2c_transfer()/i2c_smbus_xfer(), 


只能使用  adap->algo->master_xfer() ,或者adap->algo->smbus_xfer()


 struct i2c_msg msg;
        char buf[1];
    
        msg.addr =client->addr;
        msg.flags = 0;
        msg.len = 1;
        buf[0] = val;
        msg.buf = buf;




包装一个 struct  i2c_msg  .   将其直接使用master_xfer()发送出去。master_xfer() 的实现就是在具体的


cpu层的 octeon_i2c_xfer（） 函数。
static int octeon_i2c_xfer(struct i2c_adapter*adap,
              struct i2c_msg *msgs,
              int num)
{   
    
    struct i2c_msg *pmsg;
    int i;
    int ret = 0;
    struct octeon_i2c *i2c =i2c_get_adapdata(adap);
    
    if (num == 1) {
        if (msgs[0].len >0 && msgs[0].len <= 8) {
            if(msgs[0].flags & I2C_M_RD){
               ret = octeon_i2c_simple_read(i2c, msgs);
            }else{
               ret = octeon_i2c_simple_write(i2c, msgs);
            }gotoout;
        }


.....
}
// 下面这个内容不用关心
这个octeon_i2c_simple_write() 函数如下：


static int octeon_i2c_simple_write(structocteon_i2c *i2c, struct i2c_msg *msgs)                                                   
{
    u64 cmd;
    int i, j;
    int ret = 0;
   
    octeon_i2c_enable_hlc(i2c);
   
retry:
    cmd = SW_TWSI_V | SW_TWSI_SOVR;
    /* SIZE */
    cmd |= (u64)(msgs[0].len - 1)<< SW_TWSI_SIZE_SHIFT;
    /* A */
    cmd |= (u64)(msgs[0].addr &0x7full) << SW_TWSI_A_SHIFT;
   
    if (msgs[0].flags & I2C_M_TEN)
        cmd |=SW_TWSI_OP_10;
    else
        cmd |= SW_TWSI_OP_7;
   
    for (i = 0, j = msgs[0].len - 1; i < msgs[0].len && i < 4; i++, j--){
        cmd |=(u64)msgs[0].buf[j] << (8 * i);
    
    }
    if (msgs[0].len >= 4) {
        u64 ext = 0;
        for (i = 0; i <msgs[0].len - 4 && i < 4; i++, j--)
            ext |=(u64)msgs[0].buf[j] << (8 * i);
   
        __raw_writeq(ext,i2c->twsi_base + SW_TWSI_EXT);
    }
   
  octeon_i2c_hlc_int_clear(i2c);
    __raw_writeq(cmd,i2c->twsi_base + SW_TWSI);
   
    ret = octeon_i2c_hlc_wait(i2c);
   
    if (ret)
        goto err;
   
    cmd = __raw_readq(i2c->twsi_base+ SW_TWSI);
 
    if ((cmd & SW_TWSI_R) == 0) {
        if(octeon_i2c_lost_arb(cmd))
            gotoretry;
        ret = -EIO;
        goto err;
    }
   
err:
    return ret;
}  


上面的宏是Cpu中相应的寄存器地址。


总的来说就是根据函数，参数填充一个 64bit 的cmd， 将cmd交给cpu 执行。


可以看这个地方：


cmd |= (u64)(msgs[0].addr & 0x7full)<< SW_TWSI_A_SHIFT;


作用是将addr 填充到 cmd 的“i2c 从设备地址” 寄存器处。


  for (i = 0, j = msgs[0].len - 1; i < msgs[0].len && i < 4; i++, j--){
        cmd |=(u64)msgs[0].buf[j] << (8 * i);




的作用是将buf[] 填充到cmd 的“偏移地址” 寄存器处。




 __raw_writeq(cmd, i2c->twsi_base +SW_TWSI);


执行cmd。  这样就把buf（内容为regval） 执行了。Regval的意义体现在此。 


这样的一次操作可以通知cpu , 接下来的动作要进入的i2c通道。


综上，   ret = pca954x_reg_write(adap,client, regval);    


的作用就是通知cpu ： 打开通道为regval 的通道。下一次cpu执行命令，直接进入这条通道。


********* *****************


下面是实验记录：




可以看到，两次 data->last_chan 不一样时候，先写寄存器.


两次data->last_chan 相同时候，不做操作。


root@(none):~# eep -d /dev/i2c-10 -ro 0x50 0x02
07
root@(none):~# dmesg 
[  424.482728] i2c-dev.c i2cdev_ioctl: cmd = 1794 , arg = 3
[  424.482741] i2c-dev.c i2cdev_ioctl: cmd = 1793 , arg = 3
[  424.482974] i2c-dev.c i2cdev_ioctl: cmd = 1799 , arg = 4916637712
[  424.482984] i2c-dev.c:i2cdev_ioctl_rdrw:arg = 250df010 
[  424.482997] i2c_mux_master_xfer: msgs =50 , num = 2
[  424.483008]pca954x_select_chan:before.data->last_chan = 1, regval = 1
[  424.483019]pca954x_select_chan:after.data->last_chan = 1
[  424.483028] octeon_i2c_xfer: num = 2
[  424.483038] octeon_i2c_xfer:msgs[0].addr= 50, msgs[0].flags = 0, msgs[0].len = 1
[  424.483050]octeon_i2c_xfer:msgs[0].buf[0] = 2
[  424.483060] octeon_i2c_xfer:msgs[1].addr= 50, msgs[1].flags = 1, msgs[1].len = 1
[  424.483072]octeon_i2c_xfer:msgs[1].buf[1] = 0
[  424.483082] octeon_i2c_ia_read:beferreadq:cmd = 8380500200000000
[  424.483494] octeon_i2c_ia_read:aferreadq:cmd = 0380500200000007
[  424.483505] octeon_i2c_ia_read:msgs.buf[0] = 07
[  424.483512] 




//两次data->last_chan 相同.不做操作.


root@(none):~# eep -d /dev/i2c-11 -ro 0x50 0x02
07
root@(none):~# dmesg 
[  452.262746] i2c-dev.c i2cdev_ioctl: cmd = 1794 , arg = 3
[  452.262758] i2c-dev.c i2cdev_ioctl: cmd = 1793 , arg = 3
[  452.262992] i2c-dev.c i2cdev_ioctl: cmd = 1799 , arg = 5013766160
[  452.263002] i2c-dev.c:i2cdev_ioctl_rdrw:arg = 2ad80010 
[  452.263015] i2c_mux_master_xfer: msgs =50 , num = 2
[  452.263026]pca954x_select_chan:before.data->last_chan = 1, regval = 2
[  452.263037] octeon_i2c_xfer: num = 1
[  452.263047] octeon_i2c_xfer:msgs[0].addr= 71, msgs[0].flags = 0, msgs[0].len = 1
[  452.263075]octeon_i2c_xfer:msgs[0].buf[0] = 2
[  452.263084] octeon_i2c_simple_write:
[  452.263091] octeon_i2c_simple_write:cmd= 8080710000000000
[  452.263102]octeon_i2c_simple_write:msgs[0].buf[0] = 02,cmd = 8080710000000002
[  452.263319]octeon_i2c_simple_write:after readq cmd = 01807100ffffffff
[  452.263328] 
[  452.263334]pca954x_select_chan:after.data->last_chan = 2
[  452.263344] octeon_i2c_xfer: num = 2
[  452.263353] octeon_i2c_xfer:msgs[0].addr= 50, msgs[0].flags = 0, msgs[0].len = 1
[  452.263365]octeon_i2c_xfer:msgs[0].buf[0] = 2
[  452.263375] octeon_i2c_xfer:msgs[1].addr= 50, msgs[1].flags = 1, msgs[1].len = 1
[  452.263387]octeon_i2c_xfer:msgs[1].buf[1] = 0
[  452.263396] octeon_i2c_ia_read:beferreadq:cmd = 8380500200000000
[  452.263799] octeon_i2c_ia_read:aferreadq:cmd = 0380500200000007
[  452.263810] octeon_i2c_ia_read:msgs.buf[0] = 07
[  452.263817] 




//不同的时候，有相应的操作。

********** ********************

http://www.xuebuyuan.com/1453220.html