RTC驱动 m41t80 代码简析

RTC驱动十分常见，这篇博文就以m41t80为例，简单分析一下RTC驱动的常用套路，本文注重重代码逻辑，轻寄存器hack，寄存器hack，请参考datasheet。

 

代码解析

源码路径drivers/rtc/rtc-m41t80.c

首先分析驱动的probe函数

static int m41t80_probe(struct i2c_client *client,
            const struct i2c_device_id *id)
{
    struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
    int rc = 0;
    struct rtc_time tm;
    struct m41t80_data *m41t80_data = NULL;
    bool wakeup_source = false;


    //判断i2c适配器能力，是否支持连续多字节读写  I2C_FUNC_SMBUS_I2C_BLOCK
    //判断i2c适配器能力，是否支持按字节读写      I2C_FUNC_SMBUS_BYTE_DATA
    if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK |
                     I2C_FUNC_SMBUS_BYTE_DATA)) {
        dev_err(&adapter->dev, "doesn't support I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK\n");
        return -ENODEV;
    }

    //为驱动结构体m41t80动态分配内存
    m41t80_data = devm_kzalloc(&client->dev, sizeof(*m41t80_data),
                   GFP_KERNEL);
    if (!m41t80_data)
        return -ENOMEM;

    //m41t80结构体赋值
    m41t80_data->client = client;
    if (client->dev.of_node)
        m41t80_data->features = (unsigned long)
            of_device_get_match_data(&client->dev);
    else
        m41t80_data->features = id->driver_data;

    //client->dev.driver_data = m41t80_data;
    i2c_set_clientdata(client, m41t80_data);

    //动态分配rtc设备结构体
    m41t80_data->rtc =  devm_rtc_allocate_device(&client->dev);
    if (IS_ERR(m41t80_data->rtc))
        return PTR_ERR(m41t80_data->rtc);


    //wakeup_source变量赋值
#ifdef CONFIG_OF
    wakeup_source = of_property_read_bool(client->dev.of_node,
                          "wakeup-source");
#endif


    if (client->irq > 0) {
    //申请中断号，注册中断处理程序，用于闹钟功能。
        rc = devm_request_threaded_irq(&client->dev, client->irq,
                           NULL, m41t80_handle_irq,
                           IRQF_TRIGGER_LOW | IRQF_ONESHOT,
                           "m41t80", client);
        if (rc) {
            dev_warn(&client->dev, "unable to request IRQ, alarms disabled\n");
            client->irq = 0;
            wakeup_source = false;
        }
    }

    if (client->irq > 0 || wakeup_source) {
        //设置回调函数
        m41t80_rtc_ops.read_alarm = m41t80_read_alarm; //用于读取闹钟时钟
        m41t80_rtc_ops.set_alarm = m41t80_set_alarm;   //用于写入闹钟时钟
        m41t80_rtc_ops.alarm_irq_enable = m41t80_alarm_irq_enable; //用于打开闹钟中断。
        /* Enable the wakealarm */
        device_init_wakeup(&client->dev, true);  //初始化设置休眠唤醒功能
    }

    //回调函数ops赋值
    m41t80_data->rtc->ops = &m41t80_rtc_ops;

    if (client->irq <= 0) {//不支持irq中断上报（闹钟）
        /* We cannot support UIE mode if we do not have an IRQ line */
        m41t80_data->rtc->uie_unsupported = 1;
    }

    /* Make sure HT (Halt Update) bit is cleared */
    rc = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_HOUR);//

    if (rc >= 0 && rc & M41T80_ALHOUR_HT) {//查看系统看门狗复位检测位，是否为1
        if (m41t80_data->features & M41T80_FEATURE_HT) {
            m41t80_rtc_read_time(&client->dev, &tm);//读取时间
            dev_info(&client->dev, "HT bit was set!\n");
            dev_info(&client->dev, "Power Down at %ptR\n", &tm);
        }
        rc = i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_HOUR,//该位清零
                           rc & ~M41T80_ALHOUR_HT);
    }

    if (rc < 0) {
        dev_err(&client->dev, "Can't clear HT bit\n");
        return rc;
    }

    /* Make sure ST (stop) bit is cleared */
    rc = i2c_smbus_read_byte_data(client, M41T80_REG_SEC);

    if (rc >= 0 && rc & M41T80_SEC_ST)//检查ST位，是否已经清零。
        rc = i2c_smbus_write_byte_data(client, M41T80_REG_SEC,//ST位清零
                           rc & ~M41T80_SEC_ST);
    if (rc < 0) {
        dev_err(&client->dev, "Can't clear ST bit\n");
        return rc;
    }

#ifdef CONFIG_RTC_DRV_M41T80_WDT
    if (m41t80_data->features & M41T80_FEATURE_HT) {//看门狗初始化
        save_client = client;
        rc = misc_register(&wdt_dev);
        if (rc)
            return rc;
        rc = register_reboot_notifier(&wdt_notifier);
        if (rc) {
            misc_deregister(&wdt_dev);
            return rc;
        }
    }
#endif
#ifdef CONFIG_COMMON_CLK
    if (m41t80_data->features & M41T80_FEATURE_SQ)
        m41t80_sqw_register_clk(m41t80_data);//注册方波输出的功能
#endif

    rc = rtc_register_device(m41t80_data->rtc);//rtc驱动注册
    if (rc)
        return rc;

    return 0;
}

简单说一下就是初始化了几个个重要的结构体，mt41t80_data用于存放驱动数据。

主要做了：

1.注册包括rtc设备结构体的填充，使其支持闹钟，和rtc功能。

2.看门狗功能注册。

3.有一个引脚可以作为方波输出，故注册了方波功能。

 

闹钟是由irq中断实现，当闹钟产生，中断cpu，cpu在中断处理函数中处理之。来看看：

static irqreturn_t m41t80_handle_irq(int irq, void *dev_id)//闹钟中断产生
{
    struct i2c_client *client = dev_id;
    struct m41t80_data *m41t80 = i2c_get_clientdata(client);
    struct mutex *lock = &m41t80->rtc->ops_lock;
    unsigned long events = 0;
    int flags, flags_afe;

    mutex_lock(lock);

    flags_afe = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_MON);//读取Alarm Flag 使能位
    if (flags_afe < 0) {
        mutex_unlock(lock);
        return IRQ_NONE;
    }

    flags = i2c_smbus_read_byte_data(client, M41T80_REG_FLAGS);//读取闹钟flag位，为1则表示闹钟产生
    if (flags <= 0) {
        mutex_unlock(lock);
        return IRQ_NONE;
    }

    if (flags & M41T80_FLAGS_AF) {
        flags &= ~M41T80_FLAGS_AF; //闹钟flag位清零
        flags_afe &= ~M41T80_ALMON_AFE; //Alarm Flag 使能位 清零
        events |= RTC_AF; 
    }

    if (events) {
        rtc_update_irq(m41t80->rtc, 1, events); //闹钟上报
        i2c_smbus_write_byte_data(client, M41T80_REG_FLAGS, flags);// 闹钟flag位清零
        i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON,    // Alarm Flag 使能位 清零
                      flags_afe);
    }

    mutex_unlock(lock);

    return IRQ_HANDLED;
}

总来说就是清掉flag位，上报闹钟至rtc子系统。

再来看看闹钟设置ops函数

static int m41t80_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)//设置闹钟时间
{
    struct i2c_client *client = to_i2c_client(dev);
    u8 alarmvals[5];
    int ret, err;

    alarmvals[0] = bin2bcd(alrm->time.tm_mon + 1);
    alarmvals[1] = bin2bcd(alrm->time.tm_mday);
    alarmvals[2] = bin2bcd(alrm->time.tm_hour);
    alarmvals[3] = bin2bcd(alrm->time.tm_min);
    alarmvals[4] = bin2bcd(alrm->time.tm_sec);

    /* Clear AF and AFE flags */
    ret = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_MON);
    if (ret < 0)
        return ret;
    err = i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON,
                    ret & ~(M41T80_ALMON_AFE));
    if (err < 0) {
        dev_err(dev, "Unable to clear AFE bit\n");
        return err;
    }

    /* Keep SQWE bit value */
    alarmvals[0] |= (ret & M41T80_ALMON_SQWE);

    ret = i2c_smbus_read_byte_data(client, M41T80_REG_FLAGS);
    if (ret < 0)
        return ret;

    err = i2c_smbus_write_byte_data(client, M41T80_REG_FLAGS,
                    ret & ~(M41T80_FLAGS_AF));
    if (err < 0) {
        dev_err(dev, "Unable to clear AF bit\n");
        return err;
    }

    /* Write the alarm */
    err = i2c_smbus_write_i2c_block_data(client, M41T80_REG_ALARM_MON,
                         5, alarmvals);
    if (err)
        return err;

    /* Enable the alarm interrupt */
    if (alrm->enabled) {
        alarmvals[0] |= M41T80_ALMON_AFE;
        err = i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON,
                        alarmvals[0]);
        if (err)
            return err;
    }

    return 0;
}

static int m41t80_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)//读取闹钟时间
{
    struct i2c_client *client = to_i2c_client(dev);
    u8 alarmvals[5];
    int flags, ret;

    ret = i2c_smbus_read_i2c_block_data(client, M41T80_REG_ALARM_MON,
                        5, alarmvals);
    if (ret != 5)
        return ret < 0 ? ret : -EIO;

    flags = i2c_smbus_read_byte_data(client, M41T80_REG_FLAGS);
    if (flags < 0)
        return flags;

    alrm->time.tm_sec  = bcd2bin(alarmvals[4] & 0x7f);
    alrm->time.tm_min  = bcd2bin(alarmvals[3] & 0x7f);
    alrm->time.tm_hour = bcd2bin(alarmvals[2] & 0x3f);
    alrm->time.tm_mday = bcd2bin(alarmvals[1] & 0x3f);
    alrm->time.tm_mon  = bcd2bin(alarmvals[0] & 0x3f) - 1;

    alrm->enabled = !!(alarmvals[0] & M41T80_ALMON_AFE);
    alrm->pending = (flags & M41T80_FLAGS_AF) && alrm->enabled;

    return 0;
}

 

简单的寄存器读写相应位实现了闹钟的设置和查看。

再来看看rtc部分，与闹钟部分类似。

static struct rtc_class_ops m41t80_rtc_ops = {
    .read_time = m41t80_rtc_read_time,
    .set_time = m41t80_rtc_set_time,
    .proc = m41t80_rtc_proc,
};


static int m41t80_rtc_read_time(struct device *dev, struct rtc_time *tm)//读取rtc时钟
{
    struct i2c_client *client = to_i2c_client(dev);
    unsigned char buf[8];
    int err, flags;

    flags = i2c_smbus_read_byte_data(client, M41T80_REG_FLAGS);
    if (flags < 0)
        return flags;

    if (flags & M41T80_FLAGS_OF) {//晶振flag置位报错
        dev_err(&client->dev, "Oscillator failure, data is invalid.\n");
        return -EINVAL;
    }

    err = i2c_smbus_read_i2c_block_data(client, M41T80_REG_SSEC,//读取时间
                        sizeof(buf), buf);
    if (err < 0) {
        dev_err(&client->dev, "Unable to read date\n");
        return err;
    }

    tm->tm_sec = bcd2bin(buf[M41T80_REG_SEC] & 0x7f);//bcd码转10进制
    tm->tm_min = bcd2bin(buf[M41T80_REG_MIN] & 0x7f);
    tm->tm_hour = bcd2bin(buf[M41T80_REG_HOUR] & 0x3f);
    tm->tm_mday = bcd2bin(buf[M41T80_REG_DAY] & 0x3f);
    tm->tm_wday = buf[M41T80_REG_WDAY] & 0x07;
    tm->tm_mon = bcd2bin(buf[M41T80_REG_MON] & 0x1f) - 1;

    /* assume 20YY not 19YY, and ignore the Century Bit */
    tm->tm_year = bcd2bin(buf[M41T80_REG_YEAR]) + 100;
    return 0;
}

static int m41t80_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct m41t80_data *clientdata = i2c_get_clientdata(client);
    unsigned char buf[8];
    int err, flags;

    if (tm->tm_year < 100 || tm->tm_year > 199)
        return -EINVAL;

    buf[M41T80_REG_SSEC] = 0;
    buf[M41T80_REG_SEC] = bin2bcd(tm->tm_sec);//10进制转bcd码
    buf[M41T80_REG_MIN] = bin2bcd(tm->tm_min);
    buf[M41T80_REG_HOUR] = bin2bcd(tm->tm_hour);
    buf[M41T80_REG_DAY] = bin2bcd(tm->tm_mday);
    buf[M41T80_REG_MON] = bin2bcd(tm->tm_mon + 1);
    buf[M41T80_REG_YEAR] = bin2bcd(tm->tm_year - 100);
    buf[M41T80_REG_WDAY] = tm->tm_wday;

    /* If the square wave output is controlled in the weekday register */
    if (clientdata->features & M41T80_FEATURE_SQ_ALT) {//方波使能位保留
        int val;

        val = i2c_smbus_read_byte_data(client, M41T80_REG_WDAY);
        if (val < 0)
            return val;

        buf[M41T80_REG_WDAY] |= (val & 0xf0);
    }

    err = i2c_smbus_write_i2c_block_data(client, M41T80_REG_SSEC,//写入时间
                         sizeof(buf), buf);
    if (err < 0) {
        dev_err(&client->dev, "Unable to write to date registers\n");
        return err;
    }

    /* Clear the OF bit of Flags Register */
    flags = i2c_smbus_read_byte_data(client, M41T80_REG_FLAGS);
    if (flags < 0)
        return flags;

    err = i2c_smbus_write_byte_data(client, M41T80_REG_FLAGS,//OF位清零
                    flags & ~M41T80_FLAGS_OF);
    if (err < 0) {
        dev_err(&client->dev, "Unable to write flags register\n");
        return err;
    }

    return err;
}

static int m41t80_rtc_proc(struct device *dev, struct seq_file *seq)
{
    struct i2c_client *client = to_i2c_client(dev);
    struct m41t80_data *clientdata = i2c_get_clientdata(client);
    int reg;
    
    if (clientdata->features & M41T80_FEATURE_BL) {//电源没电了吗？
        reg = i2c_smbus_read_byte_data(client, M41T80_REG_FLAGS);
        if (reg < 0)
            return reg; 
        seq_printf(seq, "battery\t\t: %s\n", 
               (reg & M41T80_FLAGS_BATT_LOW) ? "exhausted" : "ok");
    }
    return 0;
}

可见rtc驱动很简单。

再来看看方波使能部分，还是读写相关寄存器就可以实现。

static unsigned long m41t80_sqw_recalc_rate(struct clk_hw *hw,//获得当前方波 频率
                        unsigned long parent_rate)
{
    return sqw_to_m41t80_data(hw)->freq;
}

static long m41t80_sqw_round_rate(struct clk_hw *hw, unsigned long rate,//获得rourd_rate
                  unsigned long *prate)
{
    if (rate >= M41T80_SQW_MAX_FREQ)
        return M41T80_SQW_MAX_FREQ;
    if (rate >= M41T80_SQW_MAX_FREQ / 4)
        return M41T80_SQW_MAX_FREQ / 4;
    if (!rate)
        return 0;
    return 1 << ilog2(rate);
}

static int m41t80_sqw_set_rate(struct clk_hw *hw, unsigned long rate,//设置方波频率
                   unsigned long parent_rate)
{
    struct m41t80_data *m41t80 = sqw_to_m41t80_data(hw);
    struct i2c_client *client = m41t80->client;
    int reg_sqw = (m41t80->features & M41T80_FEATURE_SQ_ALT) ?
        M41T80_REG_WDAY : M41T80_REG_SQW;
    int reg, ret, val = 0;

    if (rate >= M41T80_SQW_MAX_FREQ)
        val = 1;
    else if (rate >= M41T80_SQW_MAX_FREQ / 4)
        val = 2;
    else if (rate)
        val = 15 - ilog2(rate);

    reg = i2c_smbus_read_byte_data(client, reg_sqw);
    if (reg < 0)
        return reg;

    reg = (reg & 0x0f) | (val << 4);

    ret = i2c_smbus_write_byte_data(client, reg_sqw, reg);
    if (!ret)
        m41t80->freq = m41t80_decode_freq(val);
    return ret;
}

static int m41t80_sqw_control(struct clk_hw *hw, bool enable)//使能/禁能 方波输出
{
    struct m41t80_data *m41t80 = sqw_to_m41t80_data(hw);
    struct i2c_client *client = m41t80->client;
    int ret = i2c_smbus_read_byte_data(client, M41T80_REG_ALARM_MON);

    if (ret < 0)
        return ret;

    if (enable)
        ret |= M41T80_ALMON_SQWE;
    else
        ret &= ~M41T80_ALMON_SQWE;

    ret = i2c_smbus_write_byte_data(client, M41T80_REG_ALARM_MON, ret);
    if (!ret)
        m41t80->sqwe = enable;
    return ret;
}

static int m41t80_sqw_prepare(struct clk_hw *hw)//使能方波输出
{
    return m41t80_sqw_control(hw, 1);
}

static void m41t80_sqw_unprepare(struct clk_hw *hw)//禁能方波输出
{
    m41t80_sqw_control(hw, 0);
}

static int m41t80_sqw_is_prepared(struct clk_hw *hw)//查看方波是否已经使能
{
    return sqw_to_m41t80_data(hw)->sqwe;
}

static const struct clk_ops m41t80_sqw_ops = {
    .prepare = m41t80_sqw_prepare,
    .unprepare = m41t80_sqw_unprepare,
    .is_prepared = m41t80_sqw_is_prepared,
    .recalc_rate = m41t80_sqw_recalc_rate,
    .round_rate = m41t80_sqw_round_rate,
    .set_rate = m41t80_sqw_set_rate,
};

至此，m41t80的rtc/闹钟/方波输出 部分已经分析完毕，rtc的常用套路，你掌握了吗？