drivers/rtc/rtc-rx8025.c

   1 /*
   2  * Driver for Epson's RTC module RX-8025 SA/NB
   3  *
   4  * Copyright (C) 2009 Wolfgang Grandegger <wg@grandegger.com>
   5  *
   6  * Copyright (C) 2005 by Digi International Inc.
   7  * All rights reserved.
   8  *
   9  * Modified by fengjh at rising.com.cn
  10  * <http://lists.lm-sensors.org/mailman/listinfo/lm-sensors>
  11  * 2006.11
  12  *
  13  * Code cleanup by Sergei Poselenov, <sposelenov@emcraft.com>
  14  * Converted to new style by Wolfgang Grandegger <wg@grandegger.com>
  15  * Alarm and periodic interrupt added by Dmitry Rakhchev <rda@emcraft.com>
  16  *
  17  * This program is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU General Public License
  19  * version 2 as published by the Free Software Foundation.
  20  */
  21 #include <linux/bcd.h>
  22 #include <linux/i2c.h>
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/rtc.h>
  26
  27 /* Register definitions */
  28 #define RX8025_REG_SEC          0x00
  29 #define RX8025_REG_MIN          0x01
  30 #define RX8025_REG_HOUR         0x02
  31 #define RX8025_REG_WDAY         0x03
  32 #define RX8025_REG_MDAY         0x04
  33 #define RX8025_REG_MONTH        0x05
  34 #define RX8025_REG_YEAR         0x06
  35 #define RX8025_REG_DIGOFF       0x07
  36 #define RX8025_REG_ALWMIN       0x08
  37 #define RX8025_REG_ALWHOUR      0x09
  38 #define RX8025_REG_ALWWDAY      0x0a
  39 #define RX8025_REG_ALDMIN       0x0b
  40 #define RX8025_REG_ALDHOUR      0x0c
  41 /* 0x0d is reserved */
  42 #define RX8025_REG_CTRL1        0x0e
  43 #define RX8025_REG_CTRL2        0x0f
  44
  45 #define RX8025_BIT_CTRL1_CT     (7 << 0)
  46 /* 1 Hz periodic level irq */
  47 #define RX8025_BIT_CTRL1_CT_1HZ 4
  48 #define RX8025_BIT_CTRL1_TEST   (1 << 3)
  49 #define RX8025_BIT_CTRL1_1224   (1 << 5)
  50 #define RX8025_BIT_CTRL1_DALE   (1 << 6)
  51 #define RX8025_BIT_CTRL1_WALE   (1 << 7)
  52
  53 #define RX8025_BIT_CTRL2_DAFG   (1 << 0)
  54 #define RX8025_BIT_CTRL2_WAFG   (1 << 1)
  55 #define RX8025_BIT_CTRL2_CTFG   (1 << 2)
  56 #define RX8025_BIT_CTRL2_PON    (1 << 4)
  57 #define RX8025_BIT_CTRL2_XST    (1 << 5)
  58 #define RX8025_BIT_CTRL2_VDET   (1 << 6)
  59
  60 /* Clock precision adjustment */
  61 #define RX8025_ADJ_RESOLUTION   3050 /* in ppb */
  62 #define RX8025_ADJ_DATA_MAX     62
  63 #define RX8025_ADJ_DATA_MIN     -62
  64
  65 static const struct i2c_device_id rx8025_id[] = {
  66         { "rx8025", 0 },
  67         { }
  68 };
  69 MODULE_DEVICE_TABLE(i2c, rx8025_id);
  70
  71 struct rx8025_data {
  72         struct i2c_client *client;
  73         struct rtc_device *rtc;
  74         struct work_struct work;
  75         u8 ctrl1;
  76         unsigned exiting:1;
  77 };
  78
  79 static int rx8025_read_reg(struct i2c_client *client, int number, u8 *value)
  80 {
  81         int ret = i2c_smbus_read_byte_data(client, (number << 4) | 0x08);
  82
  83         if (ret < 0) {
  84                 dev_err(&client->dev, "Unable to read register #%d\n", number);
  85                 return ret;
  86         }
  87
  88         *value = ret;
  89         return 0;
  90 }
  91
  92 static int rx8025_read_regs(struct i2c_client *client,
  93                             int number, u8 length, u8 *values)
  94 {
  95         int ret = i2c_smbus_read_i2c_block_data(client, (number << 4) | 0x08,
  96                                                 length, values);
  97
  98         if (ret != length) {
  99                 dev_err(&client->dev, "Unable to read registers #%d..#%d\n",
 100                         number, number + length - 1);
 101                 return ret < 0 ? ret : -EIO;
 102         }
 103
 104         return 0;
 105 }
 106
 107 static int rx8025_write_reg(struct i2c_client *client, int number, u8 value)
 108 {
 109         int ret = i2c_smbus_write_byte_data(client, number << 4, value);
 110
 111         if (ret)
 112                 dev_err(&client->dev, "Unable to write register #%d\n",
 113                         number);
 114
 115         return ret;
 116 }
 117
 118 static int rx8025_write_regs(struct i2c_client *client,
 119                              int number, u8 length, u8 *values)
 120 {
 121         int ret = i2c_smbus_write_i2c_block_data(client, (number << 4) | 0x08,
 122                                                  length, values);
 123
 124         if (ret)
 125                 dev_err(&client->dev, "Unable to write registers #%d..#%d\n",
 126                         number, number + length - 1);
 127
 128         return ret;
 129 }
 130
 131 static irqreturn_t rx8025_irq(int irq, void *dev_id)
 132 {
 133         struct i2c_client *client = dev_id;
 134         struct rx8025_data *rx8025 = i2c_get_clientdata(client);
 135
 136         disable_irq_nosync(irq);
 137         schedule_work(&rx8025->work);
 138         return IRQ_HANDLED;
 139 }
 140
 141 static void rx8025_work(struct work_struct *work)
 142 {
 143         struct rx8025_data *rx8025 = container_of(work, struct rx8025_data,
 144                                                   work);
 145         struct i2c_client *client = rx8025->client;
 146         struct mutex *lock = &rx8025->rtc->ops_lock;
 147         u8 status;
 148
 149         mutex_lock(lock);
 150
 151         if (rx8025_read_reg(client, RX8025_REG_CTRL2, &status))
 152                 goto out;
 153
 154         if (!(status & RX8025_BIT_CTRL2_XST))
 155                 dev_warn(&client->dev, "Oscillation stop was detected,"
 156                          "you may have to readjust the clock\n");
 157
 158         if (status & RX8025_BIT_CTRL2_CTFG) {
 159                 /* periodic */
 160                 status &= ~RX8025_BIT_CTRL2_CTFG;
 161                 rtc_update_irq(rx8025->rtc, 1, RTC_PF | RTC_IRQF);
 162         }
 163
 164         if (status & RX8025_BIT_CTRL2_DAFG) {
 165                 /* alarm */
 166                 status &= RX8025_BIT_CTRL2_DAFG;
 167                 if (rx8025_write_reg(client, RX8025_REG_CTRL1,
 168                                      rx8025->ctrl1 & ~RX8025_BIT_CTRL1_DALE))
 169                         goto out;
 170                 rtc_update_irq(rx8025->rtc, 1, RTC_AF | RTC_IRQF);
 171         }
 172
 173         /* acknowledge IRQ */
 174         rx8025_write_reg(client, RX8025_REG_CTRL2,
 175                          status | RX8025_BIT_CTRL2_XST);
 176
 177 out:
 178         if (!rx8025->exiting)
 179                 enable_irq(client->irq);
 180
 181         mutex_unlock(lock);
 182 }
 183
 184 static int rx8025_get_time(struct device *dev, struct rtc_time *dt)
 185 {
 186         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 187         u8 date[7];
 188         int err;
 189
 190         err = rx8025_read_regs(rx8025->client, RX8025_REG_SEC, 7, date);
 191         if (err)
 192                 return err;
 193
 194         dev_dbg(dev, "%s: read 0x%02x 0x%02x "
 195                 "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n", __func__,
 196                 date[0], date[1], date[2], date[3], date[4],
 197                 date[5], date[6]);
 198
 199         dt->tm_sec = bcd2bin(date[RX8025_REG_SEC] & 0x7f);
 200         dt->tm_min = bcd2bin(date[RX8025_REG_MIN] & 0x7f);
 201         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 202                 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x3f);
 203         else
 204                 dt->tm_hour = bcd2bin(date[RX8025_REG_HOUR] & 0x1f) % 12
 205                         + (date[RX8025_REG_HOUR] & 0x20 ? 12 : 0);
 206
 207         dt->tm_mday = bcd2bin(date[RX8025_REG_MDAY] & 0x3f);
 208         dt->tm_mon = bcd2bin(date[RX8025_REG_MONTH] & 0x1f) - 1;
 209         dt->tm_year = bcd2bin(date[RX8025_REG_YEAR]);
 210
 211         if (dt->tm_year < 70)
 212                 dt->tm_year += 100;
 213
 214         dev_dbg(dev, "%s: date %ds %dm %dh %dmd %dm %dy\n", __func__,
 215                 dt->tm_sec, dt->tm_min, dt->tm_hour,
 216                 dt->tm_mday, dt->tm_mon, dt->tm_year);
 217
 218         return rtc_valid_tm(dt);
 219 }
 220
 221 static int rx8025_set_time(struct device *dev, struct rtc_time *dt)
 222 {
 223         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 224         u8 date[7];
 225
 226         /*
 227          * BUG: The HW assumes every year that is a multiple of 4 to be a leap
 228          * year.  Next time this is wrong is 2100, which will not be a leap
 229          * year.
 230          */
 231
 232         /*
 233          * Here the read-only bits are written as "0".  I'm not sure if that
 234          * is sound.
 235          */
 236         date[RX8025_REG_SEC] = bin2bcd(dt->tm_sec);
 237         date[RX8025_REG_MIN] = bin2bcd(dt->tm_min);
 238         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 239                 date[RX8025_REG_HOUR] = bin2bcd(dt->tm_hour);
 240         else
 241                 date[RX8025_REG_HOUR] = (dt->tm_hour >= 12 ? 0x20 : 0)
 242                         | bin2bcd((dt->tm_hour + 11) % 12 + 1);
 243
 244         date[RX8025_REG_WDAY] = bin2bcd(dt->tm_wday);
 245         date[RX8025_REG_MDAY] = bin2bcd(dt->tm_mday);
 246         date[RX8025_REG_MONTH] = bin2bcd(dt->tm_mon + 1);
 247         date[RX8025_REG_YEAR] = bin2bcd(dt->tm_year % 100);
 248
 249         dev_dbg(dev,
 250                 "%s: write 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n",
 251                 __func__,
 252                 date[0], date[1], date[2], date[3], date[4], date[5], date[6]);
 253
 254         return rx8025_write_regs(rx8025->client, RX8025_REG_SEC, 7, date);
 255 }
 256
 257 static int rx8025_init_client(struct i2c_client *client, int *need_reset)
 258 {
 259         struct rx8025_data *rx8025 = i2c_get_clientdata(client);
 260         u8 ctrl[2], ctrl2;
 261         int need_clear = 0;
 262         int err;
 263
 264         err = rx8025_read_regs(rx8025->client, RX8025_REG_CTRL1, 2, ctrl);
 265         if (err)
 266                 goto out;
 267
 268         /* Keep test bit zero ! */
 269         rx8025->ctrl1 = ctrl[0] & ~RX8025_BIT_CTRL1_TEST;
 270
 271         if (ctrl[1] & RX8025_BIT_CTRL2_PON) {
 272                 dev_warn(&client->dev, "power-on reset was detected, "
 273                          "you may have to readjust the clock\n");
 274                 *need_reset = 1;
 275         }
 276
 277         if (ctrl[1] & RX8025_BIT_CTRL2_VDET) {
 278                 dev_warn(&client->dev, "a power voltage drop was detected, "
 279                          "you may have to readjust the clock\n");
 280                 *need_reset = 1;
 281         }
 282
 283         if (!(ctrl[1] & RX8025_BIT_CTRL2_XST)) {
 284                 dev_warn(&client->dev, "Oscillation stop was detected,"
 285                          "you may have to readjust the clock\n");
 286                 *need_reset = 1;
 287         }
 288
 289         if (ctrl[1] & (RX8025_BIT_CTRL2_DAFG | RX8025_BIT_CTRL2_WAFG)) {
 290                 dev_warn(&client->dev, "Alarm was detected\n");
 291                 need_clear = 1;
 292         }
 293
 294         if (!(ctrl[1] & RX8025_BIT_CTRL2_CTFG))
 295                 need_clear = 1;
 296
 297         if (*need_reset || need_clear) {
 298                 ctrl2 = ctrl[0];
 299                 ctrl2 &= ~(RX8025_BIT_CTRL2_PON | RX8025_BIT_CTRL2_VDET |
 300                            RX8025_BIT_CTRL2_CTFG | RX8025_BIT_CTRL2_WAFG |
 301                            RX8025_BIT_CTRL2_DAFG);
 302                 ctrl2 |= RX8025_BIT_CTRL2_XST;
 303
 304                 err = rx8025_write_reg(client, RX8025_REG_CTRL2, ctrl2);
 305         }
 306 out:
 307         return err;
 308 }
 309
 310 /* Alarm support */
 311 static int rx8025_read_alarm(struct device *dev, struct rtc_wkalrm *t)
 312 {
 313         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 314         struct i2c_client *client = rx8025->client;
 315         u8 ctrl2, ald[2];
 316         int err;
 317
 318         if (client->irq <= 0)
 319                 return -EINVAL;
 320
 321         err = rx8025_read_regs(client, RX8025_REG_ALDMIN, 2, ald);
 322         if (err)
 323                 return err;
 324
 325         err = rx8025_read_reg(client, RX8025_REG_CTRL2, &ctrl2);
 326         if (err)
 327                 return err;
 328
 329         dev_dbg(dev, "%s: read alarm 0x%02x 0x%02x ctrl2 %02x\n",
 330                 __func__, ald[0], ald[1], ctrl2);
 331
 332         /* Hardware alarms precision is 1 minute! */
 333         t->time.tm_sec = 0;
 334         t->time.tm_min = bcd2bin(ald[0] & 0x7f);
 335         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 336                 t->time.tm_hour = bcd2bin(ald[1] & 0x3f);
 337         else
 338                 t->time.tm_hour = bcd2bin(ald[1] & 0x1f) % 12
 339                         + (ald[1] & 0x20 ? 12 : 0);
 340
 341         t->time.tm_wday = -1;
 342         t->time.tm_mday = -1;
 343         t->time.tm_mon = -1;
 344         t->time.tm_year = -1;
 345
 346         dev_dbg(dev, "%s: date: %ds %dm %dh %dmd %dm %dy\n",
 347                 __func__,
 348                 t->time.tm_sec, t->time.tm_min, t->time.tm_hour,
 349                 t->time.tm_mday, t->time.tm_mon, t->time.tm_year);
 350         t->enabled = !!(rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE);
 351         t->pending = (ctrl2 & RX8025_BIT_CTRL2_DAFG) && t->enabled;
 352
 353         return err;
 354 }
 355
 356 static int rx8025_set_alarm(struct device *dev, struct rtc_wkalrm *t)
 357 {
 358         struct i2c_client *client = to_i2c_client(dev);
 359         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 360         u8 ald[2];
 361         int err;
 362
 363         if (client->irq <= 0)
 364                 return -EINVAL;
 365
 366         /* Hardware alarm precision is 1 minute! */
 367         ald[0] = bin2bcd(t->time.tm_min);
 368         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_1224)
 369                 ald[1] = bin2bcd(t->time.tm_hour);
 370         else
 371                 ald[1] = (t->time.tm_hour >= 12 ? 0x20 : 0)
 372                         | bin2bcd((t->time.tm_hour + 11) % 12 + 1);
 373
 374         dev_dbg(dev, "%s: write 0x%02x 0x%02x\n", __func__, ald[0], ald[1]);
 375
 376         if (rx8025->ctrl1 & RX8025_BIT_CTRL1_DALE) {
 377                 rx8025->ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
 378                 err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
 379                                        rx8025->ctrl1);
 380                 if (err)
 381                         return err;
 382         }
 383         err = rx8025_write_regs(rx8025->client, RX8025_REG_ALDMIN, 2, ald);
 384         if (err)
 385                 return err;
 386
 387         if (t->enabled) {
 388                 rx8025->ctrl1 |= RX8025_BIT_CTRL1_DALE;
 389                 err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
 390                                        rx8025->ctrl1);
 391                 if (err)
 392                         return err;
 393         }
 394
 395         return 0;
 396 }
 397
 398 static int rx8025_alarm_irq_enable(struct device *dev, unsigned int enabled)
 399 {
 400         struct rx8025_data *rx8025 = dev_get_drvdata(dev);
 401         u8 ctrl1;
 402         int err;
 403
 404         ctrl1 = rx8025->ctrl1;
 405         if (enabled)
 406                 ctrl1 |= RX8025_BIT_CTRL1_DALE;
 407         else
 408                 ctrl1 &= ~RX8025_BIT_CTRL1_DALE;
 409
 410         if (ctrl1 != rx8025->ctrl1) {
 411                 rx8025->ctrl1 = ctrl1;
 412                 err = rx8025_write_reg(rx8025->client, RX8025_REG_CTRL1,
 413                                        rx8025->ctrl1);
 414                 if (err)
 415                         return err;
 416         }
 417         return 0;
 418 }
 419
 420 static struct rtc_class_ops rx8025_rtc_ops = {
 421         .read_time = rx8025_get_time,
 422         .set_time = rx8025_set_time,
 423         .read_alarm = rx8025_read_alarm,
 424         .set_alarm = rx8025_set_alarm,
 425         .alarm_irq_enable = rx8025_alarm_irq_enable,
 426 };
 427
 428 /*
 429  * Clock precision adjustment support
 430  *
 431  * According to the RX8025 SA/NB application manual the frequency and
 432  * temperature characteristics can be approximated using the following
 433  * equation:
 434  *
 435  *   df = a * (ut - t)**2
 436  *
 437  *   df: Frequency deviation in any temperature
 438  *   a : Coefficient = (-35 +-5) * 10**-9
 439  *   ut: Ultimate temperature in degree = +25 +-5 degree
 440  *   t : Any temperature in degree
 441  *
 442  * Note that the clock adjustment in ppb must be entered (which is
 443  * the negative value of the deviation).
 444  */
 445 static int rx8025_get_clock_adjust(struct device *dev, int *adj)
 446 {
 447         struct i2c_client *client = to_i2c_client(dev);
 448         u8 digoff;
 449         int err;
 450
 451         err = rx8025_read_reg(client, RX8025_REG_DIGOFF, &digoff);
 452         if (err)
 453                 return err;
 454
 455         *adj = digoff >= 64 ? digoff - 128 : digoff;
 456         if (*adj > 0)
 457                 (*adj)--;
 458         *adj *= -RX8025_ADJ_RESOLUTION;
 459
 460         return 0;
 461 }
 462
 463 static int rx8025_set_clock_adjust(struct device *dev, int adj)
 464 {
 465         struct i2c_client *client = to_i2c_client(dev);
 466         u8 digoff;
 467         int err;
 468
 469         adj /= -RX8025_ADJ_RESOLUTION;
 470         if (adj > RX8025_ADJ_DATA_MAX)
 471                 adj = RX8025_ADJ_DATA_MAX;
 472         else if (adj < RX8025_ADJ_DATA_MIN)
 473                 adj = RX8025_ADJ_DATA_MIN;
 474         else if (adj > 0)
 475                 adj++;
 476         else if (adj < 0)
 477                 adj += 128;
 478         digoff = adj;
 479
 480         err = rx8025_write_reg(client, RX8025_REG_DIGOFF, digoff);
 481         if (err)
 482                 return err;
 483
 484         dev_dbg(dev, "%s: write 0x%02x\n", __func__, digoff);
 485
 486         return 0;
 487 }
 488
 489 static ssize_t rx8025_sysfs_show_clock_adjust(struct device *dev,
 490                                               struct device_attribute *attr,
 491                                               char *buf)
 492 {
 493         int err, adj;
 494
 495         err = rx8025_get_clock_adjust(dev, &adj);
 496         if (err)
 497                 return err;
 498
 499         return sprintf(buf, "%d\n", adj);
 500 }
 501
 502 static ssize_t rx8025_sysfs_store_clock_adjust(struct device *dev,
 503                                                struct device_attribute *attr,
 504                                                const char *buf, size_t count)
 505 {
 506         int adj, err;
 507
 508         if (sscanf(buf, "%i", &adj) != 1)
 509                 return -EINVAL;
 510
 511         err = rx8025_set_clock_adjust(dev, adj);
 512
 513         return err ? err : count;
 514 }
 515
 516 static DEVICE_ATTR(clock_adjust_ppb, S_IRUGO | S_IWUSR,
 517                    rx8025_sysfs_show_clock_adjust,
 518                    rx8025_sysfs_store_clock_adjust);
 519
 520 static int rx8025_sysfs_register(struct device *dev)
 521 {
 522         return device_create_file(dev, &dev_attr_clock_adjust_ppb);
 523 }
 524
 525 static void rx8025_sysfs_unregister(struct device *dev)
 526 {
 527         device_remove_file(dev, &dev_attr_clock_adjust_ppb);
 528 }
 529
 530 static int rx8025_probe(struct i2c_client *client,
 531                         const struct i2c_device_id *id)
 532 {
 533         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
 534         struct rx8025_data *rx8025;
 535         int err, need_reset = 0;
 536
 537         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA
 538                                      | I2C_FUNC_SMBUS_I2C_BLOCK)) {
 539                 dev_err(&adapter->dev,
 540                         "doesn't support required functionality\n");
 541                 err = -EIO;
 542                 goto errout;
 543         }
 544
 545         rx8025 = devm_kzalloc(&client->dev, sizeof(*rx8025), GFP_KERNEL);
 546         if (!rx8025) {
 547                 err = -ENOMEM;
 548                 goto errout;
 549         }
 550
 551         rx8025->client = client;
 552         i2c_set_clientdata(client, rx8025);
 553         INIT_WORK(&rx8025->work, rx8025_work);
 554
 555         err = rx8025_init_client(client, &need_reset);
 556         if (err)
 557                 goto errout;
 558
 559         if (need_reset) {
 560                 struct rtc_time tm;
 561                 dev_info(&client->dev,
 562                          "bad conditions detected, resetting date\n");
 563                 rtc_time_to_tm(0, &tm); /* 1970/1/1 */
 564                 rx8025_set_time(&client->dev, &tm);
 565         }
 566
 567         rx8025->rtc = devm_rtc_device_register(&client->dev, client->name,
 568                                           &rx8025_rtc_ops, THIS_MODULE);
 569         if (IS_ERR(rx8025->rtc)) {
 570                 err = PTR_ERR(rx8025->rtc);
 571                 dev_err(&client->dev, "unable to register the class device\n");
 572                 goto errout;
 573         }
 574
 575         if (client->irq > 0) {
 576                 dev_info(&client->dev, "IRQ %d supplied\n", client->irq);
 577                 err = request_irq(client->irq, rx8025_irq,
 578                                   0, "rx8025", client);
 579                 if (err) {
 580                         dev_err(&client->dev, "unable to request IRQ\n");
 581                         goto errout;
 582                 }
 583         }
 584
 585         rx8025->rtc->irq_freq = 1;
 586         rx8025->rtc->max_user_freq = 1;
 587
 588         err = rx8025_sysfs_register(&client->dev);
 589         if (err)
 590                 goto errout_irq;
 591
 592         return 0;
 593
 594 errout_irq:
 595         if (client->irq > 0)
 596                 free_irq(client->irq, client);
 597
 598 errout:
 599         dev_err(&adapter->dev, "probing for rx8025 failed\n");
 600         return err;
 601 }
 602
 603 static int rx8025_remove(struct i2c_client *client)
 604 {
 605         struct rx8025_data *rx8025 = i2c_get_clientdata(client);
 606         struct mutex *lock = &rx8025->rtc->ops_lock;
 607
 608         if (client->irq > 0) {
 609                 mutex_lock(lock);
 610                 rx8025->exiting = 1;
 611                 mutex_unlock(lock);
 612
 613                 free_irq(client->irq, client);
 614                 cancel_work_sync(&rx8025->work);
 615         }
 616
 617         rx8025_sysfs_unregister(&client->dev);
 618         return 0;
 619 }
 620
 621 static struct i2c_driver rx8025_driver = {
 622         .driver = {
 623                 .name = "rtc-rx8025",
 624         },
 625         .probe          = rx8025_probe,
 626         .remove         = rx8025_remove,
 627         .id_table       = rx8025_id,
 628 };
 629
 630 module_i2c_driver(rx8025_driver);
 631
 632 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
 633 MODULE_DESCRIPTION("RX-8025 SA/NB RTC driver");
 634 MODULE_LICENSE("GPL");