drivers/i2c/chips/m41t00.c

   1 /*
   2  * I2C client/driver for the ST M41T00 family of i2c rtc chips.
   3  *
   4  * Author: Mark A. Greer <mgreer@mvista.com>
   5  *
   6  * 2005, 2006 (c) MontaVista Software, Inc. This file is licensed under
   7  * the terms of the GNU General Public License version 2. This program
   8  * is licensed "as is" without any warranty of any kind, whether express
   9  * or implied.
  10  */
  11 /*
  12  * This i2c client/driver wedges between the drivers/char/genrtc.c RTC
  13  * interface and the SMBus interface of the i2c subsystem.
  14  */
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/i2c.h>
  20 #include <linux/rtc.h>
  21 #include <linux/bcd.h>
  22 #include <linux/workqueue.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/m41t00.h>
  25 #include <asm/time.h>
  26 #include <asm/rtc.h>
  27
  28 static struct i2c_driver m41t00_driver;
  29 static struct i2c_client *save_client;
  30
  31 static unsigned short ignore[] = { I2C_CLIENT_END };
  32 static unsigned short normal_addr[] = { I2C_CLIENT_END, I2C_CLIENT_END };
  33
  34 static struct i2c_client_address_data addr_data = {
  35         .normal_i2c     = normal_addr,
  36         .probe          = ignore,
  37         .ignore         = ignore,
  38 };
  39
  40 struct m41t00_chip_info {
  41         u8      type;
  42         char    *name;
  43         u8      read_limit;
  44         u8      sec;            /* Offsets for chip regs */
  45         u8      min;
  46         u8      hour;
  47         u8      day;
  48         u8      mon;
  49         u8      year;
  50         u8      alarm_mon;
  51         u8      alarm_hour;
  52         u8      sqw;
  53         u8      sqw_freq;
  54 };
  55
  56 static struct m41t00_chip_info m41t00_chip_info_tbl[] = {
  57         {
  58                 .type           = M41T00_TYPE_M41T00,
  59                 .name           = "m41t00",
  60                 .read_limit     = 5,
  61                 .sec            = 0,
  62                 .min            = 1,
  63                 .hour           = 2,
  64                 .day            = 4,
  65                 .mon            = 5,
  66                 .year           = 6,
  67         },
  68         {
  69                 .type           = M41T00_TYPE_M41T81,
  70                 .name           = "m41t81",
  71                 .read_limit     = 1,
  72                 .sec            = 1,
  73                 .min            = 2,
  74                 .hour           = 3,
  75                 .day            = 5,
  76                 .mon            = 6,
  77                 .year           = 7,
  78                 .alarm_mon      = 0xa,
  79                 .alarm_hour     = 0xc,
  80                 .sqw            = 0x13,
  81         },
  82         {
  83                 .type           = M41T00_TYPE_M41T85,
  84                 .name           = "m41t85",
  85                 .read_limit     = 1,
  86                 .sec            = 1,
  87                 .min            = 2,
  88                 .hour           = 3,
  89                 .day            = 5,
  90                 .mon            = 6,
  91                 .year           = 7,
  92                 .alarm_mon      = 0xa,
  93                 .alarm_hour     = 0xc,
  94                 .sqw            = 0x13,
  95         },
  96 };
  97 static struct m41t00_chip_info *m41t00_chip;
  98
  99 ulong
 100 m41t00_get_rtc_time(void)
 101 {
 102         s32 sec, min, hour, day, mon, year;
 103         s32 sec1, min1, hour1, day1, mon1, year1;
 104         u8 reads = 0;
 105         u8 buf[8], msgbuf[1] = { 0 }; /* offset into rtc's regs */
 106         struct i2c_msg msgs[] = {
 107                 {
 108                         .addr   = save_client->addr,
 109                         .flags  = 0,
 110                         .len    = 1,
 111                         .buf    = msgbuf,
 112                 },
 113                 {
 114                         .addr   = save_client->addr,
 115                         .flags  = I2C_M_RD,
 116                         .len    = 8,
 117                         .buf    = buf,
 118                 },
 119         };
 120
 121         sec = min = hour = day = mon = year = 0;
 122
 123         do {
 124                 if (i2c_transfer(save_client->adapter, msgs, 2) < 0)
 125                         goto read_err;
 126
 127                 sec1 = sec;
 128                 min1 = min;
 129                 hour1 = hour;
 130                 day1 = day;
 131                 mon1 = mon;
 132                 year1 = year;
 133
 134                 sec = buf[m41t00_chip->sec] & 0x7f;
 135                 min = buf[m41t00_chip->min] & 0x7f;
 136                 hour = buf[m41t00_chip->hour] & 0x3f;
 137                 day = buf[m41t00_chip->day] & 0x3f;
 138                 mon = buf[m41t00_chip->mon] & 0x1f;
 139                 year = buf[m41t00_chip->year];
 140         } while ((++reads < m41t00_chip->read_limit) && ((sec != sec1)
 141                         || (min != min1) || (hour != hour1) || (day != day1)
 142                         || (mon != mon1) || (year != year1)));
 143
 144         if ((m41t00_chip->read_limit > 1) && ((sec != sec1) || (min != min1)
 145                         || (hour != hour1) || (day != day1) || (mon != mon1)
 146                         || (year != year1)))
 147                 goto read_err;
 148
 149         sec = BCD2BIN(sec);
 150         min = BCD2BIN(min);
 151         hour = BCD2BIN(hour);
 152         day = BCD2BIN(day);
 153         mon = BCD2BIN(mon);
 154         year = BCD2BIN(year);
 155
 156         year += 1900;
 157         if (year < 1970)
 158                 year += 100;
 159
 160         return mktime(year, mon, day, hour, min, sec);
 161
 162 read_err:
 163         dev_err(&save_client->dev, "m41t00_get_rtc_time: Read error\n");
 164         return 0;
 165 }
 166 EXPORT_SYMBOL_GPL(m41t00_get_rtc_time);
 167
 168 static void
 169 m41t00_set(void *arg)
 170 {
 171         struct rtc_time tm;
 172         int nowtime = *(int *)arg;
 173         s32 sec, min, hour, day, mon, year;
 174         u8 wbuf[9], *buf = &wbuf[1], msgbuf[1] = { 0 };
 175         struct i2c_msg msgs[] = {
 176                 {
 177                         .addr   = save_client->addr,
 178                         .flags  = 0,
 179                         .len    = 1,
 180                         .buf    = msgbuf,
 181                 },
 182                 {
 183                         .addr   = save_client->addr,
 184                         .flags  = I2C_M_RD,
 185                         .len    = 8,
 186                         .buf    = buf,
 187                 },
 188         };
 189
 190         to_tm(nowtime, &tm);
 191         tm.tm_year = (tm.tm_year - 1900) % 100;
 192
 193         sec = BIN2BCD(tm.tm_sec);
 194         min = BIN2BCD(tm.tm_min);
 195         hour = BIN2BCD(tm.tm_hour);
 196         day = BIN2BCD(tm.tm_mday);
 197         mon = BIN2BCD(tm.tm_mon);
 198         year = BIN2BCD(tm.tm_year);
 199
 200         /* Read reg values into buf[0..7]/wbuf[1..8] */
 201         if (i2c_transfer(save_client->adapter, msgs, 2) < 0) {
 202                 dev_err(&save_client->dev, "m41t00_set: Read error\n");
 203                 return;
 204         }
 205
 206         wbuf[0] = 0; /* offset into rtc's regs */
 207         buf[m41t00_chip->sec] = (buf[m41t00_chip->sec] & ~0x7f) | (sec & 0x7f);
 208         buf[m41t00_chip->min] = (buf[m41t00_chip->min] & ~0x7f) | (min & 0x7f);
 209         buf[m41t00_chip->hour] = (buf[m41t00_chip->hour] & ~0x3f) | (hour& 0x3f);
 210         buf[m41t00_chip->day] = (buf[m41t00_chip->day] & ~0x3f) | (day & 0x3f);
 211         buf[m41t00_chip->mon] = (buf[m41t00_chip->mon] & ~0x1f) | (mon & 0x1f);
 212
 213         if (i2c_master_send(save_client, wbuf, 9) < 0)
 214                 dev_err(&save_client->dev, "m41t00_set: Write error\n");
 215 }
 216
 217 static ulong new_time;
 218 /* well, isn't this API just _lovely_? */
 219 static void
 220 m41t00_barf(struct work_struct *unusable)
 221 {
 222         m41t00_set(&new_time);
 223 }
 224
 225 static struct workqueue_struct *m41t00_wq;
 226 static DECLARE_WORK(m41t00_work, m41t00_barf);
 227
 228 int
 229 m41t00_set_rtc_time(ulong nowtime)
 230 {
 231         new_time = nowtime;
 232
 233         if (in_interrupt())
 234                 queue_work(m41t00_wq, &m41t00_work);
 235         else
 236                 m41t00_set(&new_time);
 237
 238         return 0;
 239 }
 240 EXPORT_SYMBOL_GPL(m41t00_set_rtc_time);
 241
 242 /*
 243  *****************************************************************************
 244  *
 245  *      platform_data Driver Interface
 246  *
 247  *****************************************************************************
 248  */
 249 static int __init
 250 m41t00_platform_probe(struct platform_device *pdev)
 251 {
 252         struct m41t00_platform_data *pdata;
 253         int i;
 254
 255         if (pdev && (pdata = pdev->dev.platform_data)) {
 256                 normal_addr[0] = pdata->i2c_addr;
 257
 258                 for (i=0; i<ARRAY_SIZE(m41t00_chip_info_tbl); i++)
 259                         if (m41t00_chip_info_tbl[i].type == pdata->type) {
 260                                 m41t00_chip = &m41t00_chip_info_tbl[i];
 261                                 m41t00_chip->sqw_freq = pdata->sqw_freq;
 262                                 return 0;
 263                         }
 264         }
 265         return -ENODEV;
 266 }
 267
 268 static int __exit
 269 m41t00_platform_remove(struct platform_device *pdev)
 270 {
 271         return 0;
 272 }
 273
 274 static struct platform_driver m41t00_platform_driver = {
 275         .probe  = m41t00_platform_probe,
 276         .remove = m41t00_platform_remove,
 277         .driver = {
 278                 .owner = THIS_MODULE,
 279                 .name  = M41T00_DRV_NAME,
 280         },
 281 };
 282
 283 /*
 284  *****************************************************************************
 285  *
 286  *      Driver Interface
 287  *
 288  *****************************************************************************
 289  */
 290 static int
 291 m41t00_probe(struct i2c_adapter *adap, int addr, int kind)
 292 {
 293         struct i2c_client *client;
 294         int rc;
 295
 296         if (!i2c_check_functionality(adap, I2C_FUNC_I2C
 297                         | I2C_FUNC_SMBUS_BYTE_DATA))
 298                 return 0;
 299
 300         client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 301         if (!client)
 302                 return -ENOMEM;
 303
 304         strlcpy(client->name, m41t00_chip->name, I2C_NAME_SIZE);
 305         client->addr = addr;
 306         client->adapter = adap;
 307         client->driver = &m41t00_driver;
 308
 309         if ((rc = i2c_attach_client(client)))
 310                 goto attach_err;
 311
 312         if (m41t00_chip->type != M41T00_TYPE_M41T00) {
 313                 /* If asked, disable SQW, set SQW frequency & re-enable */
 314                 if (m41t00_chip->sqw_freq)
 315                         if (((rc = i2c_smbus_read_byte_data(client,
 316                                         m41t00_chip->alarm_mon)) < 0)
 317                          || ((rc = i2c_smbus_write_byte_data(client,
 318                                         m41t00_chip->alarm_mon, rc & ~0x40)) <0)
 319                          || ((rc = i2c_smbus_write_byte_data(client,
 320                                         m41t00_chip->sqw,
 321                                         m41t00_chip->sqw_freq)) < 0)
 322                          || ((rc = i2c_smbus_write_byte_data(client,
 323                                         m41t00_chip->alarm_mon, rc | 0x40)) <0))
 324                                 goto sqw_err;
 325
 326                 /* Make sure HT (Halt Update) bit is cleared */
 327                 if ((rc = i2c_smbus_read_byte_data(client,
 328                                 m41t00_chip->alarm_hour)) < 0)
 329                         goto ht_err;
 330
 331                 if (rc & 0x40)
 332                         if ((rc = i2c_smbus_write_byte_data(client,
 333                                         m41t00_chip->alarm_hour, rc & ~0x40))<0)
 334                                 goto ht_err;
 335         }
 336
 337         /* Make sure ST (stop) bit is cleared */
 338         if ((rc = i2c_smbus_read_byte_data(client, m41t00_chip->sec)) < 0)
 339                 goto st_err;
 340
 341         if (rc & 0x80)
 342                 if ((rc = i2c_smbus_write_byte_data(client, m41t00_chip->sec,
 343                                 rc & ~0x80)) < 0)
 344                         goto st_err;
 345
 346         m41t00_wq = create_singlethread_workqueue(m41t00_chip->name);
 347         save_client = client;
 348         return 0;
 349
 350 st_err:
 351         dev_err(&client->dev, "m41t00_probe: Can't clear ST bit\n");
 352         goto attach_err;
 353 ht_err:
 354         dev_err(&client->dev, "m41t00_probe: Can't clear HT bit\n");
 355         goto attach_err;
 356 sqw_err:
 357         dev_err(&client->dev, "m41t00_probe: Can't set SQW Frequency\n");
 358 attach_err:
 359         kfree(client);
 360         return rc;
 361 }
 362
 363 static int
 364 m41t00_attach(struct i2c_adapter *adap)
 365 {
 366         return i2c_probe(adap, &addr_data, m41t00_probe);
 367 }
 368
 369 static int
 370 m41t00_detach(struct i2c_client *client)
 371 {
 372         int rc;
 373
 374         if ((rc = i2c_detach_client(client)) == 0) {
 375                 kfree(client);
 376                 destroy_workqueue(m41t00_wq);
 377         }
 378         return rc;
 379 }
 380
 381 static struct i2c_driver m41t00_driver = {
 382         .driver = {
 383                 .name   = M41T00_DRV_NAME,
 384         },
 385         .id             = I2C_DRIVERID_STM41T00,
 386         .attach_adapter = m41t00_attach,
 387         .detach_client  = m41t00_detach,
 388 };
 389
 390 static int __init
 391 m41t00_init(void)
 392 {
 393         int rc;
 394
 395         if (!(rc = platform_driver_register(&m41t00_platform_driver)))
 396                 rc = i2c_add_driver(&m41t00_driver);
 397         return rc;
 398 }
 399
 400 static void __exit
 401 m41t00_exit(void)
 402 {
 403         i2c_del_driver(&m41t00_driver);
 404         platform_driver_unregister(&m41t00_platform_driver);
 405 }
 406
 407 module_init(m41t00_init);
 408 module_exit(m41t00_exit);
 409
 410 MODULE_AUTHOR("Mark A. Greer <mgreer@mvista.com>");
 411 MODULE_DESCRIPTION("ST Microelectronics M41T00 RTC I2C Client Driver");
 412 MODULE_LICENSE("GPL");