drivers/i2c/chips/x1205.c

   1 /*
   2  *  x1205.c - An i2c driver for the Xicor X1205 RTC
   3  *  Copyright 2004 Karen Spearel
   4  *  Copyright 2005 Alessandro Zummo
   5  *
   6  *  please send all reports to:
   7  *      kas11 at tampabay dot rr dot com
   8  *      a dot zummo at towertech dot it
   9  *
  10  *  based on the other drivers in this same directory.
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/init.h>
  20 #include <linux/slab.h>
  21 #include <linux/i2c.h>
  22 #include <linux/string.h>
  23 #include <linux/bcd.h>
  24 #include <linux/rtc.h>
  25 #include <linux/list.h>
  26
  27 #include <linux/x1205.h>
  28
  29 #define DRV_VERSION "0.9.9"
  30
  31 /* Addresses to scan: none. This chip is located at
  32  * 0x6f and uses a two bytes register addressing.
  33  * Two bytes need to be written to read a single register,
  34  * while most other chips just require one and take the second
  35  * one as the data to be written. To prevent corrupting
  36  * unknown chips, the user must explicitely set the probe parameter.
  37  */
  38
  39 static unsigned short normal_i2c[] = { I2C_CLIENT_END };
  40
  41 /* Insmod parameters */
  42 I2C_CLIENT_INSMOD;
  43 I2C_CLIENT_MODULE_PARM(hctosys,
  44         "Set the system time from the hardware clock upon initialization");
  45
  46 /* offsets into CCR area */
  47
  48 #define CCR_SEC                 0
  49 #define CCR_MIN                 1
  50 #define CCR_HOUR                2
  51 #define CCR_MDAY                3
  52 #define CCR_MONTH               4
  53 #define CCR_YEAR                5
  54 #define CCR_WDAY                6
  55 #define CCR_Y2K                 7
  56
  57 #define X1205_REG_SR            0x3F    /* status register */
  58 #define X1205_REG_Y2K           0x37
  59 #define X1205_REG_DW            0x36
  60 #define X1205_REG_YR            0x35
  61 #define X1205_REG_MO            0x34
  62 #define X1205_REG_DT            0x33
  63 #define X1205_REG_HR            0x32
  64 #define X1205_REG_MN            0x31
  65 #define X1205_REG_SC            0x30
  66 #define X1205_REG_DTR           0x13
  67 #define X1205_REG_ATR           0x12
  68 #define X1205_REG_INT           0x11
  69 #define X1205_REG_0             0x10
  70 #define X1205_REG_Y2K1          0x0F
  71 #define X1205_REG_DWA1          0x0E
  72 #define X1205_REG_YRA1          0x0D
  73 #define X1205_REG_MOA1          0x0C
  74 #define X1205_REG_DTA1          0x0B
  75 #define X1205_REG_HRA1          0x0A
  76 #define X1205_REG_MNA1          0x09
  77 #define X1205_REG_SCA1          0x08
  78 #define X1205_REG_Y2K0          0x07
  79 #define X1205_REG_DWA0          0x06
  80 #define X1205_REG_YRA0          0x05
  81 #define X1205_REG_MOA0          0x04
  82 #define X1205_REG_DTA0          0x03
  83 #define X1205_REG_HRA0          0x02
  84 #define X1205_REG_MNA0          0x01
  85 #define X1205_REG_SCA0          0x00
  86
  87 #define X1205_CCR_BASE          0x30    /* Base address of CCR */
  88 #define X1205_ALM0_BASE         0x00    /* Base address of ALARM0 */
  89
  90 #define X1205_SR_RTCF           0x01    /* Clock failure */
  91 #define X1205_SR_WEL            0x02    /* Write Enable Latch */
  92 #define X1205_SR_RWEL           0x04    /* Register Write Enable */
  93
  94 #define X1205_DTR_DTR0          0x01
  95 #define X1205_DTR_DTR1          0x02
  96 #define X1205_DTR_DTR2          0x04
  97
  98 #define X1205_HR_MIL            0x80    /* Set in ccr.hour for 24 hr mode */
  99
 100 /* Prototypes */
 101 static int x1205_attach(struct i2c_adapter *adapter);
 102 static int x1205_detach(struct i2c_client *client);
 103 static int x1205_probe(struct i2c_adapter *adapter, int address, int kind);
 104 static int x1205_command(struct i2c_client *client, unsigned int cmd,
 105         void *arg);
 106
 107 static struct i2c_driver x1205_driver = {
 108         .owner          = THIS_MODULE,
 109         .name           = "x1205",
 110         .attach_adapter = &x1205_attach,
 111         .detach_client  = &x1205_detach,
 112 };
 113
 114 struct x1205_data {
 115         struct i2c_client client;
 116         struct list_head list;
 117         unsigned int epoch;
 118 };
 119
 120 static const unsigned char days_in_mo[] =
 121         { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 122
 123 static LIST_HEAD(x1205_clients);
 124
 125 /* Workaround until the I2C subsytem will allow to send
 126  * commands to a specific client. This function will send the command
 127  * to the first client.
 128  */
 129 int x1205_do_command(unsigned int cmd, void *arg)
 130 {
 131         struct list_head *walk;
 132         struct list_head *tmp;
 133         struct x1205_data *data;
 134
 135         list_for_each_safe(walk, tmp, &x1205_clients) {
 136                 data = list_entry(walk, struct x1205_data, list);
 137                 return x1205_command(&data->client, cmd, arg);
 138         }
 139
 140         return -ENODEV;
 141 }
 142
 143 #define is_leap(year) \
 144         ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
 145
 146 /* make sure the rtc_time values are in bounds */
 147 static int x1205_validate_tm(struct rtc_time *tm)
 148 {
 149         int year = tm->tm_year + 1900;
 150
 151         if ((tm->tm_year < 70) || (tm->tm_year > 255))
 152                 return -EINVAL;
 153
 154         if ((tm->tm_mon > 11) || (tm->tm_mday == 0))
 155                 return -EINVAL;
 156
 157         if (tm->tm_mday > days_in_mo[tm->tm_mon]
 158                 + ((tm->tm_mon == 1) && is_leap(year)))
 159                 return -EINVAL;
 160
 161         if ((tm->tm_hour >= 24) || (tm->tm_min >= 60) || (tm->tm_sec >= 60))
 162                 return -EINVAL;
 163
 164         return 0;
 165 }
 166
 167 /*
 168  * In the routines that deal directly with the x1205 hardware, we use
 169  * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch
 170  * Epoch is initialized as 2000. Time is set to UTC.
 171  */
 172 static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm,
 173                                 u8 reg_base)
 174 {
 175         unsigned char dt_addr[2] = { 0, reg_base };
 176         static unsigned char sr_addr[2] = { 0, X1205_REG_SR };
 177
 178         unsigned char buf[8], sr;
 179
 180         struct i2c_msg msgs[] = {
 181                 { client->addr, 0, 2, sr_addr },        /* setup read ptr */
 182                 { client->addr, I2C_M_RD, 1, &sr },     /* read status */
 183                 { client->addr, 0, 2, dt_addr },        /* setup read ptr */
 184                 { client->addr, I2C_M_RD, 8, buf },     /* read date */
 185         };
 186
 187         struct x1205_data *data = i2c_get_clientdata(client);
 188
 189         /* read status register */
 190         if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
 191                 dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
 192                 return -EIO;
 193         }
 194
 195         /* check for battery failure */
 196         if (sr & X1205_SR_RTCF) {
 197                 dev_warn(&client->dev,
 198                         "Clock had a power failure, you must set the date.\n");
 199                 return -EINVAL;
 200         }
 201
 202         /* read date registers */
 203         if ((i2c_transfer(client->adapter, &msgs[2], 2)) != 2) {
 204                 dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
 205                 return -EIO;
 206         }
 207
 208         dev_dbg(&client->dev,
 209                 "%s: raw read data - sec=%02x, min=%02x, hr=%02x, "
 210                 "mday=%02x, mon=%02x, year=%02x, wday=%02x, y2k=%02x\n",
 211                 __FUNCTION__,
 212                 buf[0], buf[1], buf[2], buf[3],
 213                 buf[4], buf[5], buf[6], buf[7]);
 214
 215         tm->tm_sec = BCD2BIN(buf[CCR_SEC]);
 216         tm->tm_min = BCD2BIN(buf[CCR_MIN]);
 217         tm->tm_hour = BCD2BIN(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */
 218         tm->tm_mday = BCD2BIN(buf[CCR_MDAY]);
 219         tm->tm_mon = BCD2BIN(buf[CCR_MONTH]);
 220         data->epoch = BCD2BIN(buf[CCR_Y2K]) * 100;
 221         tm->tm_year = BCD2BIN(buf[CCR_YEAR]) + data->epoch - 1900;
 222         tm->tm_wday = buf[CCR_WDAY];
 223
 224         dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
 225                 "mday=%d, mon=%d, year=%d, wday=%d\n",
 226                 __FUNCTION__,
 227                 tm->tm_sec, tm->tm_min, tm->tm_hour,
 228                 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 229
 230         return 0;
 231 }
 232
 233 static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm,
 234                                 int datetoo, u8 reg_base)
 235 {
 236         int i, err, xfer;
 237
 238         unsigned char buf[8];
 239
 240         static const unsigned char wel[3] = { 0, X1205_REG_SR,
 241                                                 X1205_SR_WEL };
 242
 243         static const unsigned char rwel[3] = { 0, X1205_REG_SR,
 244                                                 X1205_SR_WEL | X1205_SR_RWEL };
 245
 246         static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 };
 247
 248         struct x1205_data *data = i2c_get_clientdata(client);
 249
 250         /* check if all values in the tm struct are correct */
 251         if ((err = x1205_validate_tm(tm)) < 0)
 252                 return err;
 253
 254         dev_dbg(&client->dev, "%s: secs=%d, mins=%d, hours=%d, "
 255                 "mday=%d, mon=%d, year=%d, wday=%d\n",
 256                 __FUNCTION__,
 257                 tm->tm_sec, tm->tm_min, tm->tm_hour,
 258                 tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
 259
 260         buf[CCR_SEC] = BIN2BCD(tm->tm_sec);
 261         buf[CCR_MIN] = BIN2BCD(tm->tm_min);
 262
 263         /* set hour and 24hr bit */
 264         buf[CCR_HOUR] = BIN2BCD(tm->tm_hour) | X1205_HR_MIL;
 265
 266         /* should we also set the date? */
 267         if (datetoo) {
 268                 buf[CCR_MDAY] = BIN2BCD(tm->tm_mday);
 269
 270                 /* month, 0 - 11 */
 271                 buf[CCR_MONTH] = BIN2BCD(tm->tm_mon);
 272
 273                 /* year, since 1900 */
 274                 buf[CCR_YEAR] = BIN2BCD(tm->tm_year + 1900 - data->epoch);
 275                 buf[CCR_WDAY] = tm->tm_wday & 0x07;
 276                 buf[CCR_Y2K] = BIN2BCD(data->epoch / 100);
 277         }
 278
 279         /* this sequence is required to unlock the chip */
 280         xfer = i2c_master_send(client, wel, 3);
 281         if (xfer != 3) {
 282                 dev_err(&client->dev, "%s: wel - %d\n", __FUNCTION__, xfer);
 283                 return -EIO;
 284         }
 285
 286         xfer = i2c_master_send(client, rwel, 3);
 287         if (xfer != 3) {
 288                 dev_err(&client->dev, "%s: rwel - %d\n", __FUNCTION__, xfer);
 289                 return -EIO;
 290         }
 291
 292         /* write register's data */
 293         for (i = 0; i < (datetoo ? 8 : 3); i++) {
 294                 unsigned char rdata[3] = { 0, reg_base + i, buf[i] };
 295
 296                 xfer = i2c_master_send(client, rdata, 3);
 297                 if (xfer != 3) {
 298                         dev_err(&client->dev,
 299                                 "%s: xfer=%d addr=%02x, data=%02x\n",
 300                                 __FUNCTION__,
 301                                  xfer, rdata[1], rdata[2]);
 302                         return -EIO;
 303                 }
 304         };
 305
 306         /* disable further writes */
 307         xfer = i2c_master_send(client, diswe, 3);
 308         if (xfer != 3) {
 309                 dev_err(&client->dev, "%s: diswe - %d\n", __FUNCTION__, xfer);
 310                 return -EIO;
 311         }
 312
 313         return 0;
 314 }
 315
 316 static int x1205_get_dtrim(struct i2c_client *client, int *trim)
 317 {
 318         unsigned char dtr;
 319         static unsigned char dtr_addr[2] = { 0, X1205_REG_DTR };
 320
 321         struct i2c_msg msgs[] = {
 322                 { client->addr, 0, 2, dtr_addr },       /* setup read ptr */
 323                 { client->addr, I2C_M_RD, 1, &dtr },    /* read dtr */
 324         };
 325
 326         /* read dtr register */
 327         if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
 328                 dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
 329                 return -EIO;
 330         }
 331
 332         dev_dbg(&client->dev, "%s: raw dtr=%x\n", __FUNCTION__, dtr);
 333
 334         *trim = 0;
 335
 336         if (dtr & X1205_DTR_DTR0)
 337                 *trim += 20;
 338
 339         if (dtr & X1205_DTR_DTR1)
 340                 *trim += 10;
 341
 342         if (dtr & X1205_DTR_DTR2)
 343                 *trim = -*trim;
 344
 345         return 0;
 346 }
 347
 348 static int x1205_get_atrim(struct i2c_client *client, int *trim)
 349 {
 350         s8 atr;
 351         static unsigned char atr_addr[2] = { 0, X1205_REG_ATR };
 352
 353         struct i2c_msg msgs[] = {
 354                 { client->addr, 0, 2, atr_addr },       /* setup read ptr */
 355                 { client->addr, I2C_M_RD, 1, &atr },    /* read atr */
 356         };
 357
 358         /* read atr register */
 359         if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) {
 360                 dev_err(&client->dev, "%s: read error\n", __FUNCTION__);
 361                 return -EIO;
 362         }
 363
 364         dev_dbg(&client->dev, "%s: raw atr=%x\n", __FUNCTION__, atr);
 365
 366         /* atr is a two's complement value on 6 bits,
 367          * perform sign extension. The formula is
 368          * Catr = (atr * 0.25pF) + 11.00pF.
 369          */
 370         if (atr & 0x20)
 371                 atr |= 0xC0;
 372
 373         dev_dbg(&client->dev, "%s: raw atr=%x (%d)\n", __FUNCTION__, atr, atr);
 374
 375         *trim = (atr * 250) + 11000;
 376
 377         dev_dbg(&client->dev, "%s: real=%d\n", __FUNCTION__, *trim);
 378
 379         return 0;
 380 }
 381
 382 static int x1205_hctosys(struct i2c_client *client)
 383 {
 384         int err;
 385
 386         struct rtc_time tm;
 387         struct timespec tv;
 388
 389         err = x1205_command(client, X1205_CMD_GETDATETIME, &tm);
 390
 391         if (err) {
 392                 dev_err(&client->dev,
 393                         "Unable to set the system clock\n");
 394                 return err;
 395         }
 396
 397         /* IMPORTANT: the RTC only stores whole seconds. It is arbitrary
 398          * whether it stores the most close value or the value with partial
 399          * seconds truncated. However, it is important that we use it to store
 400          * the truncated value. This is because otherwise it is necessary,
 401          * in an rtc sync function, to read both xtime.tv_sec and
 402          * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read
 403          * of >32bits is not possible. So storing the most close value would
 404          * slow down the sync API. So here we have the truncated value and
 405          * the best guess is to add 0.5s.
 406          */
 407
 408         tv.tv_nsec = NSEC_PER_SEC >> 1;
 409
 410         /* WARNING: this is not the C library 'mktime' call, it is a built in
 411          * inline function from include/linux/time.h.  It expects (requires)
 412          * the month to be in the range 1-12
 413          */
 414
 415         tv.tv_sec  = mktime(tm.tm_year + 1900, tm.tm_mon + 1,
 416                                 tm.tm_mday, tm.tm_hour,
 417                                 tm.tm_min, tm.tm_sec);
 418
 419         do_settimeofday(&tv);
 420
 421         dev_info(&client->dev,
 422                 "setting the system clock to %d-%d-%d %d:%d:%d\n",
 423                 tm.tm_year + 1900, tm.tm_mon + 1,
 424                 tm.tm_mday, tm.tm_hour, tm.tm_min,
 425                 tm.tm_sec);
 426
 427         return 0;
 428 }
 429
 430 struct x1205_limit
 431 {
 432         unsigned char reg;
 433         unsigned char mask;
 434         unsigned char min;
 435         unsigned char max;
 436 };
 437
 438 static int x1205_validate_client(struct i2c_client *client)
 439 {
 440         int i, xfer;
 441
 442         /* Probe array. We will read the register at the specified
 443          * address and check if the given bits are zero.
 444          */
 445         static const unsigned char probe_zero_pattern[] = {
 446                 /* register, mask */
 447                 X1205_REG_SR,   0x18,
 448                 X1205_REG_DTR,  0xF8,
 449                 X1205_REG_ATR,  0xC0,
 450                 X1205_REG_INT,  0x18,
 451                 X1205_REG_0,    0xFF,
 452         };
 453
 454         static const struct x1205_limit probe_limits_pattern[] = {
 455                 /* register, mask, min, max */
 456                 { X1205_REG_Y2K,        0xFF,   19,     20      },
 457                 { X1205_REG_DW,         0xFF,   0,      6       },
 458                 { X1205_REG_YR,         0xFF,   0,      99      },
 459                 { X1205_REG_MO,         0xFF,   0,      12      },
 460                 { X1205_REG_DT,         0xFF,   0,      31      },
 461                 { X1205_REG_HR,         0x7F,   0,      23      },
 462                 { X1205_REG_MN,         0xFF,   0,      59      },
 463                 { X1205_REG_SC,         0xFF,   0,      59      },
 464                 { X1205_REG_Y2K1,       0xFF,   19,     20      },
 465                 { X1205_REG_Y2K0,       0xFF,   19,     20      },
 466         };
 467
 468         /* check that registers have bits a 0 where expected */
 469         for (i = 0; i < ARRAY_SIZE(probe_zero_pattern); i += 2) {
 470                 unsigned char buf;
 471
 472                 unsigned char addr[2] = { 0, probe_zero_pattern[i] };
 473
 474                 struct i2c_msg msgs[2] = {
 475                         { client->addr, 0, 2, addr },
 476                         { client->addr, I2C_M_RD, 1, &buf },
 477                 };
 478
 479                 xfer = i2c_transfer(client->adapter, msgs, 2);
 480                 if (xfer != 2) {
 481                         dev_err(&client->adapter->dev,
 482                                 "%s: could not read register %x\n",
 483                                 __FUNCTION__, addr[1]);
 484
 485                         return -EIO;
 486                 }
 487
 488                 if ((buf & probe_zero_pattern[i+1]) != 0) {
 489                         dev_err(&client->adapter->dev,
 490                                 "%s: register=%02x, zero pattern=%d, value=%x\n",
 491                                 __FUNCTION__, addr[1], i, buf);
 492
 493                         return -ENODEV;
 494                 }
 495         }
 496
 497         /* check limits (only registers with bcd values) */
 498         for (i = 0; i < ARRAY_SIZE(probe_limits_pattern); i++) {
 499                 unsigned char reg, value;
 500
 501                 unsigned char addr[2] = { 0, probe_limits_pattern[i].reg };
 502
 503                 struct i2c_msg msgs[2] = {
 504                         { client->addr, 0, 2, addr },
 505                         { client->addr, I2C_M_RD, 1, &reg },
 506                 };
 507
 508                 xfer = i2c_transfer(client->adapter, msgs, 2);
 509
 510                 if (xfer != 2) {
 511                         dev_err(&client->adapter->dev,
 512                                 "%s: could not read register %x\n",
 513                                 __FUNCTION__, addr[1]);
 514
 515                         return -EIO;
 516                 }
 517
 518                 value = BCD2BIN(reg & probe_limits_pattern[i].mask);
 519
 520                 if (value > probe_limits_pattern[i].max ||
 521                         value < probe_limits_pattern[i].min) {
 522                         dev_dbg(&client->adapter->dev,
 523                                 "%s: register=%x, lim pattern=%d, value=%d\n",
 524                                 __FUNCTION__, addr[1], i, value);
 525
 526                         return -ENODEV;
 527                 }
 528         }
 529
 530         return 0;
 531 }
 532
 533 static int x1205_attach(struct i2c_adapter *adapter)
 534 {
 535         dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
 536
 537         return i2c_probe(adapter, &addr_data, x1205_probe);
 538 }
 539
 540 int x1205_direct_attach(int adapter_id,
 541         struct i2c_client_address_data *address_data)
 542 {
 543         int err;
 544         struct i2c_adapter *adapter = i2c_get_adapter(adapter_id);
 545
 546         if (adapter) {
 547                 err = i2c_probe(adapter,
 548                         address_data, x1205_probe);
 549
 550                 i2c_put_adapter(adapter);
 551
 552                 return err;
 553         }
 554
 555         return -ENODEV;
 556 }
 557
 558 static int x1205_probe(struct i2c_adapter *adapter, int address, int kind)
 559 {
 560         struct i2c_client *client;
 561         struct x1205_data *data;
 562
 563         int err = 0;
 564
 565         dev_dbg(&adapter->dev, "%s\n", __FUNCTION__);
 566
 567         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
 568                 err = -ENODEV;
 569                 goto exit;
 570         }
 571
 572         if (!(data = kzalloc(sizeof(struct x1205_data), GFP_KERNEL))) {
 573                 err = -ENOMEM;
 574                 goto exit;
 575         }
 576
 577         /* Initialize our structures */
 578         data->epoch = 2000;
 579
 580         client = &data->client;
 581         client->addr = address;
 582         client->driver = &x1205_driver;
 583         client->adapter = adapter;
 584
 585         strlcpy(client->name, "x1205", I2C_NAME_SIZE);
 586
 587         i2c_set_clientdata(client, data);
 588
 589         /* Verify the chip is really an X1205 */
 590         if (kind < 0) {
 591                 if (x1205_validate_client(client) < 0) {
 592                         err = -ENODEV;
 593                         goto exit_kfree;
 594                 }
 595         }
 596
 597         /* Inform the i2c layer */
 598         if ((err = i2c_attach_client(client)))
 599                 goto exit_kfree;
 600
 601         list_add(&data->list, &x1205_clients);
 602
 603         dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n");
 604
 605         /* If requested, set the system time */
 606         if (hctosys)
 607                 x1205_hctosys(client);
 608
 609         return 0;
 610
 611 exit_kfree:
 612         kfree(data);
 613
 614 exit:
 615         return err;
 616 }
 617
 618 static int x1205_detach(struct i2c_client *client)
 619 {
 620         int err;
 621         struct x1205_data *data = i2c_get_clientdata(client);
 622
 623         dev_dbg(&client->dev, "%s\n", __FUNCTION__);
 624
 625         if ((err = i2c_detach_client(client)))
 626                 return err;
 627
 628         list_del(&data->list);
 629
 630         kfree(data);
 631
 632         return 0;
 633 }
 634
 635 static int x1205_command(struct i2c_client *client, unsigned int cmd,
 636         void *param)
 637 {
 638         if (param == NULL)
 639                 return -EINVAL;
 640
 641         if (!capable(CAP_SYS_TIME))
 642                 return -EACCES;
 643
 644         dev_dbg(&client->dev, "%s: cmd=%d\n", __FUNCTION__, cmd);
 645
 646         switch (cmd) {
 647         case X1205_CMD_GETDATETIME:
 648                 return x1205_get_datetime(client, param, X1205_CCR_BASE);
 649
 650         case X1205_CMD_SETTIME:
 651                 return x1205_set_datetime(client, param, 0,
 652                                 X1205_CCR_BASE);
 653
 654         case X1205_CMD_SETDATETIME:
 655                 return x1205_set_datetime(client, param, 1,
 656                                 X1205_CCR_BASE);
 657
 658         case X1205_CMD_GETALARM:
 659                 return x1205_get_datetime(client, param, X1205_ALM0_BASE);
 660
 661         case X1205_CMD_SETALARM:
 662                 return x1205_set_datetime(client, param, 1,
 663                                 X1205_ALM0_BASE);
 664
 665         case X1205_CMD_GETDTRIM:
 666                 return x1205_get_dtrim(client, param);
 667
 668         case X1205_CMD_GETATRIM:
 669                 return x1205_get_atrim(client, param);
 670
 671         default:
 672                 return -EINVAL;
 673         }
 674 }
 675
 676 static int __init x1205_init(void)
 677 {
 678         return i2c_add_driver(&x1205_driver);
 679 }
 680
 681 static void __exit x1205_exit(void)
 682 {
 683         i2c_del_driver(&x1205_driver);
 684 }
 685
 686 MODULE_AUTHOR(
 687         "Karen Spearel <kas11@tampabay.rr.com>, "
 688         "Alessandro Zummo <a.zummo@towertech.it>");
 689 MODULE_DESCRIPTION("Xicor X1205 RTC driver");
 690 MODULE_LICENSE("GPL");
 691 MODULE_VERSION(DRV_VERSION);
 692
 693 EXPORT_SYMBOL_GPL(x1205_do_command);
 694 EXPORT_SYMBOL_GPL(x1205_direct_attach);
 695
 696 module_init(x1205_init);
 697 module_exit(x1205_exit);