S3C6410使用---26IIC总线控制器驱动分析

一. I2C控制器设备的定义
1.0 I2C控制器设备的定义及注册
a. 在arch/arm/plat-samsung/dev-i2c0.c中,定义了I2C控制器设备的资源,

static struct resource s3c_i2c_resource[] = {
    [0] = {
        .start = S3C_PA_IIC,
        .end = S3C_PA_IIC + SZ_4K - 1,
        .flags = IORESOURCE_MEM,
    },
    [1] = {
        .start = IRQ_IIC,
        .end = IRQ_IIC,
        .flags = IORESOURCE_IRQ,
    },
};

struct platform_device s3c_device_i2c0 = {
    .name         = "s3c2410-i2c",
#ifdef CONFIG_S3C_DEV_I2C1
    .id         = 0,
#else
    .id         = -1,
#endif
    .num_resources     = ARRAY_SIZE(s3c_i2c_resource),
    .resource     = s3c_i2c_resource,
};
I2C控制器设备的私有成员定义
static struct s3c2410_platform_i2c default_i2c_data0 __initdata = {
    .flags        = 0,
    .slave_addr    = 0x10,
    .frequency    = 100*1000,
    .sda_delay    = 100,
};

b. I2C控制器设备的注册
注册过程还是老样子, 在machine_init中完成的
arch/arm/mach-s3c64xx/mach-smdk6410.c

static struct platform_device *smdk6410_devices[] __initdata = {
    &s3c_device_i2c0,
}
static void __init smdk6410_machine_init(void)
{
    s3c_i2c0_set_platdata(NULL);
    platform_add_devices(smdk6410_devices, ARRAY_SIZE(smdk6410_devices));
}

---

二. I2C控制器设备驱动
2.1 I2C控制器的初始化
a. I2C控制器的驱动在文件, drivers/i2c/busses/i2c-s3c2410.c中

static struct platform_device_id s3c24xx_driver_ids[] = {
    {
        .name        = "s3c2410-i2c",
        .driver_data    = TYPE_S3C2410,
    }, {
        .name        = "s3c2440-i2c",
        .driver_data    = TYPE_S3C2440,
    }, { },
};
MODULE_DEVICE_TABLE(platform, s3c24xx_driver_ids);

static struct platform_driver s3c24xx_i2c_driver = {
    .probe        = s3c24xx_i2c_probe,
    .remove        = s3c24xx_i2c_remove,
    .id_table    = s3c24xx_driver_ids,                //可以实现一个设备驱动对应多个设备
    .driver        = {
        .owner    = THIS_MODULE,
        .name    = "s3c-i2c",
        .pm    = S3C24XX_DEV_PM_OPS,
    },
};

static int __init i2c_adap_s3c_init(void)
{
    return platform_driver_register(&s3c24xx_i2c_driver);
}

注意: 在I2C控制器的设备定义中名字是 s2c2410-i2c而这儿是s3c-i2c,两个名字不相同,如何匹配呢?
答案在s3c24xx_driver_ids中,如果没有s3c24xx_driver_ids,那么I2C控制器设备与I2C控制器设备驱动是一一对应的,一个设备对应一个设备驱动;
但是有了s3c24xx_driver_ids之后,一个设备驱动可以对应多个设备
b. 进入probe函数

static int s3c24xx_i2c_probe(struct platform_device *pdev)
{
    struct s3c2410_platform_i2c* pdata = pdev->dev.platform_data;
    //申请一个s3c24xx_i2c结构体并初始化
    struct s3c24xx_i2c * i2c = kzalloc(sizeof(struct s3c24xx_i2c), GFP_KERNEL);
    strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));
    i2c->adap.owner = THIS_MODULE;
    i2c->adap.algo = &s3c24xx_i2c_algorithm;
    i2c->adap.retries = 2;
    i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
    i2c->tx_setup = 50;
    spin_lock_init(&i2c->lock);
    init_waitqueue_head(&i2c->wait);
    i2c->dev = &pdev->dev;
    i2c->clk = clk_get(&pdev->dev, "i2c");             //时钟使能
    clk_enable(i2c->clk);
    //映射i2c的控制寄存器
    struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    i2c->ioarea = request_mem_region(res->start, resource_size(res), pdev->name);
    i2c->regs = ioremap(res->start, resource_size(res));
    i2c->adap.algo_data = i2c;
    i2c->adap.dev.parent = &pdev->dev;
    ret = s3c24xx_i2c_init(i2c);                        //配置寄存器,初始化i2c
    //获取中断
    i2c->irq = ret = platform_get_irq(pdev, 0);
    ret = request_irq(i2c->irq, s3c24xx_i2c_irq, IRQF_DISABLED, dev_name(&pdev->dev), i2c);
    ret = s3c24xx_i2c_register_cpufreq(i2c);
    i2c->adap.nr = pdata->bus_num;
    ret = i2c_add_numbered_adapter(&i2c->adap);         //最关键的一步,把这个i2c控制器添加到adapter中
    platform_set_drvdata(pdev, i2c);
    clk_disable(i2c->clk);
    return 0;
}

c. i2c控制器的初始化函数
s3c24xx_i2c_probe
    --> s3c24xx_i2c_init

static int s3c24xx_i2c_init(struct s3c24xx_i2c *i2c)
{
    unsigned long iicon = S3C2410_IICCON_IRQEN | S3C2410_IICCON_ACKEN;
    struct s3c2410_platform_i2c *pdata;
    unsigned int freq;
    pdata = i2c->dev->platform_data;
    if (pdata->cfg_gpio)
        pdata->cfg_gpio(to_platform_device(i2c->dev));
    writeb(pdata->slave_addr, i2c->regs + S3C2410_IICADD);
    writel(iicon, i2c->regs + S3C2410_IICCON);
    s3c24xx_i2c_clockrate(i2c, &freq);
    return 0;
}

d. i2c控制器及其上的设备注册过程
s3c24xx_i2c_probe
    --> i2c_add_numbered_adapter

int i2c_add_numbered_adapter(struct i2c_adapter *adap)
{
retry:
    if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
        return -ENOMEM;

    mutex_lock(&core_lock);

    status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);

    mutex_unlock(&core_lock);
    if (status == -EAGAIN)
        goto retry;

    if (status == 0)
        status = i2c_register_adapter(adap);                //注册i2c总线及其上的设备
    return status;
}

s3c24xx_i2c_probe
    --> i2c_add_numbered_adapter
        --> i2c_register_adapter

static int i2c_register_adapter(struct i2c_adapter *adap)
{
    int res = 0;

    rt_mutex_init(&adap->bus_lock);
    mutex_init(&adap->userspace_clients_lock);
    INIT_LIST_HEAD(&adap->userspace_clients);

    if (adap->timeout == 0)
        adap->timeout = HZ;

    dev_set_name(&adap->dev, "i2c-%d", adap->nr);
    adap->dev.bus = &i2c_bus_type;
    adap->dev.type = &i2c_adapter_type;
    res = device_register(&adap->dev);            //注册i2c控制器
    if (adap->nr < __i2c_first_dynamic_bus_num)
        i2c_scan_static_board_info(adap);        //扫描i2c总线上的所有设备,并注册每一个设备

    mutex_lock(&core_lock);
    bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
    mutex_unlock(&core_lock);

    return 0;
}

s3c24xx_i2c_probe
    --> i2c_add_numbered_adapter
        --> i2c_register_adapter
            --> i2c_scan_static_board_info

static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
{
    //__i2c_board_list是在smdk6410.c中初始化的,是系统中全部i2c设备的列表
    //这儿要扫描全部的i2c设备,并为每一个i2c设备注册
    down_read(&__i2c_board_lock);
    list_for_each_entry(devinfo, &__i2c_board_list, list) {
        if (devinfo->busnum == adapter->nr && !i2c_new_device(adapter, &devinfo->board_info))
            dev_err(&adapter->dev,"Can't create device at 0x%02x\n", devinfo->board_info.addr);
    }
    up_read(&__i2c_board_lock);
}

s3c24xx_i2c_probe
    --> i2c_add_numbered_adapter
        --> i2c_register_adapter
            --> i2c_scan_static_board_info
                --> i2c_new_device

struct i2c_client * i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
    struct i2c_client * client = kzalloc(sizeof *client, GFP_KERNEL);          //申请i2c_client结构体的内存

    //把i2c_client结构体初始化一下
    client->adapter = adap;
    client->dev.platform_data = info->platform_data;
    if (info->archdata)
        client->dev.archdata = *info->archdata;
    client->flags = info->flags;
    client->addr = info->addr;
    client->irq = info->irq;
    strlcpy(client->name, info->type, sizeof(client->name));
    status = i2c_check_client_addr_validity(client);
    status = i2c_check_addr_busy(adap, client->addr);

    //把client->dev结构体初始化一下
    client->dev.parent = &client->adapter->dev;
    client->dev.bus = &i2c_bus_type;
    client->dev.type = &i2c_client_type;
    client->dev.of_node = info->of_node;
    dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap), client->addr);
    status = device_register(&client->dev);     //注册client->dev
    return client;      //这里虽然返回client结构体,但是没有使用
}

注意: !i2c_new_device(adapter, &devinfo->board_info);
i2c_new_device虽然有个client结构体但是没有人使用,只是把client->dev 注册了一下,client中剩余的部分如变量的addr flags没有人管.
那问题出来了,在使用时如果需要client->addr怎么办? (例如: i2c在数据传输时需要器件地址 addr=0x30)
答: 用小结构体得到大结构体 --> container_of -->struct i2c_client    *client = i2c_verify_client(dev);

2.2 I2C控制器的algorithm
s3c24xx_i2c_probe中注册了i2c控制器的algorithm是s3c24xx_i2c_algorithm

static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
    .master_xfer        = s3c24xx_i2c_xfer,
    .functionality        = s3c24xx_i2c_func,
};

a.下面就看一下,s3c24xx_i2c_xfer

static int s3c24xx_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
    struct s3c24xx_i2c *i2c = (struct s3c24xx_i2c *)adap->algo_data;
    clk_enable(i2c->clk);              //使能i2c时钟
    //调用s3c24xx_i2c_doxfer行进传输
    //重复adap->retries次,如果不成功则sleep 100us
    for (retry = 0; retry < adap->retries; retry++) {
        ret = s3c24xx_i2c_doxfer(i2c, msgs, num);      //传输msg,但是真正的数据传输的过程是中断
        if (ret != -EAGAIN) {
            clk_disable(i2c->clk);
            return ret;
        }
        udelay(100);
    }
    clk_disable(i2c->clk);              //关闭i2c时钟
    return -EREMOTEIO;
}

b. 进入开始传输状态
s3c24xx_i2c_xfer
    --> s3c24xx_i2c_doxfer

static int s3c24xx_i2c_doxfer(struct s3c24xx_i2c *i2c, struct i2c_msg *msgs, int num)
{
    unsigned long iicstat, timeout;
    int spins = 20;
    int ret;

    if (i2c->suspended)
        return -EIO;

    ret = s3c24xx_i2c_set_master(i2c);       //等侍I2C总线为空闲状态
    spin_lock_irq(&i2c->lock);
    i2c->msg = msgs;
    i2c->msg_num = num;
    i2c->msg_ptr = 0;
    i2c->msg_idx = 0;
    i2c->state = STATE_START;                //设定此时状态为START
    s3c24xx_i2c_enable_irq(i2c);             //开中断
    s3c24xx_i2c_message_start(i2c, msgs);    //进入start传输状态,剩下的事就交给中断了
    spin_unlock_irq(&i2c->lock);

    timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);   //进入等侍状态,直到传输结束,产生stop信号将其唤醒
    ret = i2c->msg_idx;
    do {
        iicstat = readl(i2c->regs + S3C2410_IICSTAT);
    } while ((iicstat & S3C2410_IICSTAT_START) && --spins);

    if (!spins) {
        msleep(1);
        iicstat = readl(i2c->regs + S3C2410_IICSTAT);
    }
 out:
    return ret;
}

注意 I2C的状态:一个是通过i2c->state可以叫做软件层的状态标志,另一个就是读取i2c的IICSTAT寄存器标志着当前IIC控制器总线的状态是空闲还是忙
c. 等侍IIC总结空闲
s3c24xx_i2c_xfer
    --> s3c24xx_i2c_doxfer
            --> s3c24xx_i2c_set_master

static int s3c24xx_i2c_set_master(struct s3c24xx_i2c *i2c)
{
    //读取IICSTAT寄存器的状态,直到IIC总线是空闲状态
    //重复读取400次,每次不成功sleep 1ms
    unsigned long iicstat;
    int timeout = 400;
    while (timeout-- > 0) {
        iicstat = readl(i2c->regs + S3C2410_IICSTAT);
        if (!(iicstat & S3C2410_IICSTAT_BUSBUSY))
            return 0;
        msleep(1);
    }
    return -ETIMEDOUT;
}

IICSTAT[bit5] -->  read 0 --> not busy
IICSTAT[bit5] -->  read 1 --> busy
IICSTAT[bit5] -->  write 0 --> 产生一个stop signal
IICSTAT[bit5] -->  write 1 --> 产生一个start signal
d. 进行传输开始状态

static void s3c24xx_i2c_message_start(struct s3c24xx_i2c *i2c, struct i2c_msg *msg)
{
    unsigned int addr = (msg->addr & 0x7f) << 1;
    unsigned long stat;
    unsigned long iiccon;

    stat = 0;
    stat |= S3C2410_IICSTAT_TXRXEN;

    if (msg->flags & I2C_M_RD) {
        stat |= S3C2410_IICSTAT_MASTER_RX;
        addr |= 1;
    } else
        stat |= S3C2410_IICSTAT_MASTER_TX;

    if (msg->flags & I2C_M_REV_DIR_ADDR)
        addr ^= 1;

    /* todo - check for wether ack wanted or not */
    s3c24xx_i2c_enable_ack(i2c);

    iiccon = readl(i2c->regs + S3C2410_IICCON);
    writel(stat, i2c->regs + S3C2410_IICSTAT);

    writeb(addr, i2c->regs + S3C2410_IICDS);

    ndelay(i2c->tx_setup);

    writel(iiccon, i2c->regs + S3C2410_IICCON);

    //IICSTAT[bit5] --> write 1 --> 产生一个start signal,下面就进入中断了
    stat |= S3C2410_IICSTAT_START;
    writel(stat, i2c->regs + S3C2410_IICSTAT);
}

e. 在中断中进行实际的传输
IIC产生中断的条件:
    第1种情况是: 产生了start信号
    第2种情况是: IIC仲裁失败
    第3种情况是: 产生了stop信号

static irqreturn_t s3c24xx_i2c_irq(int irqno, void *dev_id)
{
    struct s3c24xx_i2c *i2c = dev_id;
    unsigned long status;
    unsigned long tmp;

    status = readl(i2c->regs + S3C2410_IICSTAT);

    //如果是第2种情况--> IIC仲裁失败,则打印出错信息
    if (status & S3C2410_IICSTAT_ARBITR)
        dev_err(i2c->dev, "deal with arbitration loss\n");
    //如果当前的状态是IDLE,说明状态出错了
    if (i2c->state == STATE_IDLE) {
        tmp = readl(i2c->regs + S3C2410_IICCON);
        tmp &= ~S3C2410_IICCON_IRQPEND;
        writel(tmp, i2c->regs + S3C2410_IICCON);
        goto out;
    }
    //进入中断调用过程
    i2c_s3c_irq_nextbyte(i2c, status);
 out:
    return IRQ_HANDLED;
}

f. 中断调用过程
s3c24xx_i2c_irq
    --> i2c_s3c_irq_nextbyte

static int i2c_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
{
    unsigned long tmp;
    unsigned char byte;
    int ret = 0;

    switch (i2c->state) {
    case STATE_IDLE:
        goto out;

    case STATE_STOP:
        s3c24xx_i2c_disable_irq(i2c);
        goto out_ack;

    case STATE_START:
        if (iicstat & S3C2410_IICSTAT_LASTBIT && !(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
            s3c24xx_i2c_stop(i2c, -ENXIO);
            goto out_ack;
        }

        if (i2c->msg->flags & I2C_M_RD)
            i2c->state = STATE_READ;
        else
            i2c->state = STATE_WRITE;

        if (is_lastmsg(i2c) && i2c->msg->len == 0) {
            s3c24xx_i2c_stop(i2c, 0);
            goto out_ack;
        }

        if (i2c->state == STATE_READ)
            goto prepare_read;
                                                    //注意:这儿没有break,所以直接到STATE_WRITE或者prepare_read
    case STATE_WRITE:
        if (!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
            if (iicstat & S3C2410_IICSTAT_LASTBIT) {
                s3c24xx_i2c_stop(i2c, -ECONNREFUSED);
                goto out_ack;
            }
        }
 retry_write:
        if (!is_msgend(i2c)) {                         //如果这个msg中的数据还没有传完
            byte = i2c->msg->buf[i2c->msg_ptr++];       //获取下一个要传输的字节
            writeb(byte, i2c->regs + S3C2410_IICDS);    //向IIC中写入数据
            ndelay(i2c->tx_setup);
        } else if (!is_lastmsg(i2c)) {                  //如果还有其它的msg
            i2c->msg_ptr = 0;
            i2c->msg_idx++;
            i2c->msg++;                                //移动到下一个msg
            if (i2c->msg->flags & I2C_M_NOSTART) {
                if (i2c->msg->flags & I2C_M_RD)
                    s3c24xx_i2c_stop(i2c, -EINVAL);
                goto retry_write;
            } else {                                   //产生一个start信号
                s3c24xx_i2c_message_start(i2c, i2c->msg);
                i2c->state = STATE_START;
            }
        } else {
            s3c24xx_i2c_stop(i2c, 0);                //终于传完了,就发送结束singal,并关中断
        }
        break;
    case STATE_READ:
        byte = readb(i2c->regs + S3C2410_IICDS);
        i2c->msg->buf[i2c->msg_ptr++] = byte;

 prepare_read:
        if (is_msglast(i2c)) {
            if (is_lastmsg(i2c))
                s3c24xx_i2c_disable_ack(i2c);
        } else if (is_msgend(i2c)) {
            if (is_lastmsg(i2c))
                s3c24xx_i2c_stop(i2c, 0);
            else {
                i2c->msg_ptr = 0;
                i2c->msg_idx++;
                i2c->msg++;
            }
        }
        break;
    }
 out_ack:
    tmp = readl(i2c->regs + S3C2410_IICCON);
    tmp &= ~S3C2410_IICCON_IRQPEND;
    writel(tmp, i2c->regs + S3C2410_IICCON);
 out:
    return ret;
}

s3c24xx_i2c_irq
    --> i2c_s3c_irq_nextbyte
        --> s3c24xx_i2c_stop

static inline void s3c24xx_i2c_stop(struct s3c24xx_i2c *i2c, int ret)
{
    unsigned long iicstat = readl(i2c->regs + S3C2410_IICSTAT);

    iicstat &= ~S3C2410_IICSTAT_START;
    writel(iicstat, i2c->regs + S3C2410_IICSTAT);

    i2c->state = STATE_STOP;                    //状态改为STOP

    s3c24xx_i2c_master_complete(i2c, ret);       //wake_up等侍队列,这时候函数s3c24xx_i2c_doxfer就可以返回了
    s3c24xx_i2c_disable_irq(i2c);                //关中断,不能再让中断产生了
}

---

三. 总结