Logo Search packages:      
Sourcecode: linux version File versions  Download package

m41t00.c

/*
 * I2C client/driver for the ST M41T00 family of i2c rtc chips.
 *
 * Author: Mark A. Greer <mgreer@mvista.com>
 *
 * 2005, 2006 (c) MontaVista Software, Inc. This file is licensed under
 * the terms of the GNU General Public License version 2. This program
 * is licensed "as is" without any warranty of any kind, whether express
 * or implied.
 */
/*
 * This i2c client/driver wedges between the drivers/char/genrtc.c RTC
 * interface and the SMBus interface of the i2c subsystem.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/i2c.h>
#include <linux/rtc.h>
#include <linux/bcd.h>
#include <linux/workqueue.h>
#include <linux/platform_device.h>
#include <linux/m41t00.h>
#include <asm/time.h>
#include <asm/rtc.h>

static struct i2c_driver m41t00_driver;
static struct i2c_client *save_client;

static unsigned short ignore[] = { I2C_CLIENT_END };
static unsigned short normal_addr[] = { I2C_CLIENT_END, I2C_CLIENT_END };

static struct i2c_client_address_data addr_data = {
      .normal_i2c = normal_addr,
      .probe            = ignore,
      .ignore           = ignore,
};

struct m41t00_chip_info {
      u8    type;
      char  *name;
      u8    read_limit;
      u8    sec;        /* Offsets for chip regs */
      u8    min;
      u8    hour;
      u8    day;
      u8    mon;
      u8    year;
      u8    alarm_mon;
      u8    alarm_hour;
      u8    sqw;
      u8    sqw_freq;
};

static struct m41t00_chip_info m41t00_chip_info_tbl[] = {
      {
            .type       = M41T00_TYPE_M41T00,
            .name       = "m41t00",
            .read_limit = 5,
            .sec        = 0,
            .min        = 1,
            .hour       = 2,
            .day        = 4,
            .mon        = 5,
            .year       = 6,
      },
      {
            .type       = M41T00_TYPE_M41T81,
            .name       = "m41t81",
            .read_limit = 1,
            .sec        = 1,
            .min        = 2,
            .hour       = 3,
            .day        = 5,
            .mon        = 6,
            .year       = 7,
            .alarm_mon  = 0xa,
            .alarm_hour = 0xc,
            .sqw        = 0x13,
      },
      {
            .type       = M41T00_TYPE_M41T85,
            .name       = "m41t85",
            .read_limit = 1,
            .sec        = 1,
            .min        = 2,
            .hour       = 3,
            .day        = 5,
            .mon        = 6,
            .year       = 7,
            .alarm_mon  = 0xa,
            .alarm_hour = 0xc,
            .sqw        = 0x13,
      },
};
static struct m41t00_chip_info *m41t00_chip;

ulong
m41t00_get_rtc_time(void)
{
      s32 sec, min, hour, day, mon, year;
      s32 sec1, min1, hour1, day1, mon1, year1;
      u8 reads = 0;
      u8 buf[8], msgbuf[1] = { 0 }; /* offset into rtc's regs */
      struct i2c_msg msgs[] = {
            {
                  .addr = save_client->addr,
                  .flags      = 0,
                  .len  = 1,
                  .buf  = msgbuf,
            },
            {
                  .addr = save_client->addr,
                  .flags      = I2C_M_RD,
                  .len  = 8,
                  .buf  = buf,
            },
      };

      sec = min = hour = day = mon = year = 0;

      do {
            if (i2c_transfer(save_client->adapter, msgs, 2) < 0)
                  goto read_err;

            sec1 = sec;
            min1 = min;
            hour1 = hour;
            day1 = day;
            mon1 = mon;
            year1 = year;

            sec = buf[m41t00_chip->sec] & 0x7f;
            min = buf[m41t00_chip->min] & 0x7f;
            hour = buf[m41t00_chip->hour] & 0x3f;
            day = buf[m41t00_chip->day] & 0x3f;
            mon = buf[m41t00_chip->mon] & 0x1f;
            year = buf[m41t00_chip->year];
      } while ((++reads < m41t00_chip->read_limit) && ((sec != sec1)
                  || (min != min1) || (hour != hour1) || (day != day1)
                  || (mon != mon1) || (year != year1)));

      if ((m41t00_chip->read_limit > 1) && ((sec != sec1) || (min != min1)
                  || (hour != hour1) || (day != day1) || (mon != mon1)
                  || (year != year1)))
            goto read_err;

      sec = BCD2BIN(sec);
      min = BCD2BIN(min);
      hour = BCD2BIN(hour);
      day = BCD2BIN(day);
      mon = BCD2BIN(mon);
      year = BCD2BIN(year);

      year += 1900;
      if (year < 1970)
            year += 100;

      return mktime(year, mon, day, hour, min, sec);

read_err:
      dev_err(&save_client->dev, "m41t00_get_rtc_time: Read error\n");
      return 0;
}
EXPORT_SYMBOL_GPL(m41t00_get_rtc_time);

static void
m41t00_set(void *arg)
{
      struct rtc_time   tm;
      int nowtime = *(int *)arg;
      s32 sec, min, hour, day, mon, year;
      u8 wbuf[9], *buf = &wbuf[1], msgbuf[1] = { 0 };
      struct i2c_msg msgs[] = {
            {
                  .addr = save_client->addr,
                  .flags      = 0,
                  .len  = 1,
                  .buf  = msgbuf,
            },
            {
                  .addr = save_client->addr,
                  .flags      = I2C_M_RD,
                  .len  = 8,
                  .buf  = buf,
            },
      };

      to_tm(nowtime, &tm);
      tm.tm_year = (tm.tm_year - 1900) % 100;

      sec = BIN2BCD(tm.tm_sec);
      min = BIN2BCD(tm.tm_min);
      hour = BIN2BCD(tm.tm_hour);
      day = BIN2BCD(tm.tm_mday);
      mon = BIN2BCD(tm.tm_mon);
      year = BIN2BCD(tm.tm_year);

      /* Read reg values into buf[0..7]/wbuf[1..8] */
      if (i2c_transfer(save_client->adapter, msgs, 2) < 0) {
            dev_err(&save_client->dev, "m41t00_set: Read error\n");
            return;
      }

      wbuf[0] = 0; /* offset into rtc's regs */
      buf[m41t00_chip->sec] = (buf[m41t00_chip->sec] & ~0x7f) | (sec & 0x7f);
      buf[m41t00_chip->min] = (buf[m41t00_chip->min] & ~0x7f) | (min & 0x7f);
      buf[m41t00_chip->hour] = (buf[m41t00_chip->hour] & ~0x3f) | (hour& 0x3f);
      buf[m41t00_chip->day] = (buf[m41t00_chip->day] & ~0x3f) | (day & 0x3f);
      buf[m41t00_chip->mon] = (buf[m41t00_chip->mon] & ~0x1f) | (mon & 0x1f);
      buf[m41t00_chip->year] = year;

      if (i2c_master_send(save_client, wbuf, 9) < 0)
            dev_err(&save_client->dev, "m41t00_set: Write error\n");
}

static ulong new_time;
/* well, isn't this API just _lovely_? */
static void
m41t00_barf(struct work_struct *unusable)
{
      m41t00_set(&new_time);
}

static struct workqueue_struct *m41t00_wq;
static DECLARE_WORK(m41t00_work, m41t00_barf);

int
m41t00_set_rtc_time(ulong nowtime)
{
      new_time = nowtime;

      if (in_interrupt())
            queue_work(m41t00_wq, &m41t00_work);
      else
            m41t00_set(&new_time);

      return 0;
}
EXPORT_SYMBOL_GPL(m41t00_set_rtc_time);

/*
 *****************************************************************************
 *
 *    platform_data Driver Interface
 *
 *****************************************************************************
 */
static int __init
m41t00_platform_probe(struct platform_device *pdev)
{
      struct m41t00_platform_data *pdata;
      int i;

      if (pdev && (pdata = pdev->dev.platform_data)) {
            normal_addr[0] = pdata->i2c_addr;

            for (i=0; i<ARRAY_SIZE(m41t00_chip_info_tbl); i++)
                  if (m41t00_chip_info_tbl[i].type == pdata->type) {
                        m41t00_chip = &m41t00_chip_info_tbl[i];
                        m41t00_chip->sqw_freq = pdata->sqw_freq;
                        return 0;
                  }
      }
      return -ENODEV;
}

static int __exit
m41t00_platform_remove(struct platform_device *pdev)
{
      return 0;
}

static struct platform_driver m41t00_platform_driver = {
      .probe  = m41t00_platform_probe,
      .remove = m41t00_platform_remove,
      .driver = {
            .owner = THIS_MODULE,
            .name  = M41T00_DRV_NAME,
      },
};

/*
 *****************************************************************************
 *
 *    Driver Interface
 *
 *****************************************************************************
 */
static int
m41t00_probe(struct i2c_adapter *adap, int addr, int kind)
{
      struct i2c_client *client;
      int rc;

      if (!i2c_check_functionality(adap, I2C_FUNC_I2C
                  | I2C_FUNC_SMBUS_BYTE_DATA))
            return 0;

      client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
      if (!client)
            return -ENOMEM;

      strlcpy(client->name, m41t00_chip->name, I2C_NAME_SIZE);
      client->addr = addr;
      client->adapter = adap;
      client->driver = &m41t00_driver;

      if ((rc = i2c_attach_client(client)))
            goto attach_err;

      if (m41t00_chip->type != M41T00_TYPE_M41T00) {
            /* If asked, disable SQW, set SQW frequency & re-enable */
            if (m41t00_chip->sqw_freq)
                  if (((rc = i2c_smbus_read_byte_data(client,
                              m41t00_chip->alarm_mon)) < 0)
                   || ((rc = i2c_smbus_write_byte_data(client,
                              m41t00_chip->alarm_mon, rc & ~0x40)) <0)
                   || ((rc = i2c_smbus_write_byte_data(client,
                              m41t00_chip->sqw,
                              m41t00_chip->sqw_freq)) < 0)
                   || ((rc = i2c_smbus_write_byte_data(client,
                              m41t00_chip->alarm_mon, rc | 0x40)) <0))
                        goto sqw_err;

            /* Make sure HT (Halt Update) bit is cleared */
            if ((rc = i2c_smbus_read_byte_data(client,
                        m41t00_chip->alarm_hour)) < 0)
                  goto ht_err;

            if (rc & 0x40)
                  if ((rc = i2c_smbus_write_byte_data(client,
                              m41t00_chip->alarm_hour, rc & ~0x40))<0)
                        goto ht_err;
      }

      /* Make sure ST (stop) bit is cleared */
      if ((rc = i2c_smbus_read_byte_data(client, m41t00_chip->sec)) < 0)
            goto st_err;

      if (rc & 0x80)
            if ((rc = i2c_smbus_write_byte_data(client, m41t00_chip->sec,
                        rc & ~0x80)) < 0)
                  goto st_err;

      m41t00_wq = create_singlethread_workqueue(m41t00_chip->name);
      save_client = client;
      return 0;

st_err:
      dev_err(&client->dev, "m41t00_probe: Can't clear ST bit\n");
      goto attach_err;
ht_err:
      dev_err(&client->dev, "m41t00_probe: Can't clear HT bit\n");
      goto attach_err;
sqw_err:
      dev_err(&client->dev, "m41t00_probe: Can't set SQW Frequency\n");
attach_err:
      kfree(client);
      return rc;
}

static int
m41t00_attach(struct i2c_adapter *adap)
{
      return i2c_probe(adap, &addr_data, m41t00_probe);
}

static int
m41t00_detach(struct i2c_client *client)
{
      int rc;

      if ((rc = i2c_detach_client(client)) == 0) {
            kfree(client);
            destroy_workqueue(m41t00_wq);
      }
      return rc;
}

static struct i2c_driver m41t00_driver = {
      .driver = {
            .name = M41T00_DRV_NAME,
      },
      .id         = I2C_DRIVERID_STM41T00,
      .attach_adapter   = m41t00_attach,
      .detach_client    = m41t00_detach,
};

static int __init
m41t00_init(void)
{
      int rc;

      if (!(rc = platform_driver_register(&m41t00_platform_driver)))
            rc = i2c_add_driver(&m41t00_driver);
      return rc;
}

static void __exit
m41t00_exit(void)
{
      i2c_del_driver(&m41t00_driver);
      platform_driver_unregister(&m41t00_platform_driver);
}

module_init(m41t00_init);
module_exit(m41t00_exit);

MODULE_AUTHOR("Mark A. Greer <mgreer@mvista.com>");
MODULE_DESCRIPTION("ST Microelectronics M41T00 RTC I2C Client Driver");
MODULE_LICENSE("GPL");

Generated by  Doxygen 1.6.0   Back to index