Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/rtc/rtc-abx80x.c

  1 /*
  2  * A driver for the I2C members of the Abracon AB x8xx RTC family,
  3  * and compatible: AB 1805 and AB 0805
  4  *
  5  * Copyright 2014-2015 Macq S.A.
  6  *
  7  * Author: Philippe De Muyter <phdm@macqel.be>
  8  * Author: Alexandre Belloni <alexandre.belloni@free-electrons.com>
  9  *
 10  * This program is free software; you can redistribute it and/or modify
 11  * it under the terms of the GNU General Public License version 2 as
 12  * published by the Free Software Foundation.
 13  *
 14  */
 15 
 16 #include <linux/bcd.h>
 17 #include <linux/i2c.h>
 18 #include <linux/module.h>
 19 #include <linux/rtc.h>
 20 
 21 #define ABX8XX_REG_HTH          0x00
 22 #define ABX8XX_REG_SC           0x01
 23 #define ABX8XX_REG_MN           0x02
 24 #define ABX8XX_REG_HR           0x03
 25 #define ABX8XX_REG_DA           0x04
 26 #define ABX8XX_REG_MO           0x05
 27 #define ABX8XX_REG_YR           0x06
 28 #define ABX8XX_REG_WD           0x07
 29 
 30 #define ABX8XX_REG_AHTH         0x08
 31 #define ABX8XX_REG_ASC          0x09
 32 #define ABX8XX_REG_AMN          0x0a
 33 #define ABX8XX_REG_AHR          0x0b
 34 #define ABX8XX_REG_ADA          0x0c
 35 #define ABX8XX_REG_AMO          0x0d
 36 #define ABX8XX_REG_AWD          0x0e
 37 
 38 #define ABX8XX_REG_STATUS       0x0f
 39 #define ABX8XX_STATUS_AF        BIT(2)
 40 
 41 #define ABX8XX_REG_CTRL1        0x10
 42 #define ABX8XX_CTRL_WRITE       BIT(0)
 43 #define ABX8XX_CTRL_ARST        BIT(2)
 44 #define ABX8XX_CTRL_12_24       BIT(6)
 45 
 46 #define ABX8XX_REG_IRQ          0x12
 47 #define ABX8XX_IRQ_AIE          BIT(2)
 48 #define ABX8XX_IRQ_IM_1_4       (0x3 << 5)
 49 
 50 #define ABX8XX_REG_CD_TIMER_CTL 0x18
 51 
 52 #define ABX8XX_REG_OSC          0x1c
 53 #define ABX8XX_OSC_FOS          BIT(3)
 54 #define ABX8XX_OSC_BOS          BIT(4)
 55 #define ABX8XX_OSC_ACAL_512     BIT(5)
 56 #define ABX8XX_OSC_ACAL_1024    BIT(6)
 57 
 58 #define ABX8XX_OSC_OSEL         BIT(7)
 59 
 60 #define ABX8XX_REG_OSS          0x1d
 61 #define ABX8XX_OSS_OF           BIT(1)
 62 #define ABX8XX_OSS_OMODE        BIT(4)
 63 
 64 #define ABX8XX_REG_CFG_KEY      0x1f
 65 #define ABX8XX_CFG_KEY_OSC      0xa1
 66 #define ABX8XX_CFG_KEY_MISC     0x9d
 67 
 68 #define ABX8XX_REG_ID0          0x28
 69 
 70 #define ABX8XX_REG_TRICKLE      0x20
 71 #define ABX8XX_TRICKLE_CHARGE_ENABLE    0xa0
 72 #define ABX8XX_TRICKLE_STANDARD_DIODE   0x8
 73 #define ABX8XX_TRICKLE_SCHOTTKY_DIODE   0x4
 74 
 75 static u8 trickle_resistors[] = {0, 3, 6, 11};
 76 
 77 enum abx80x_chip {AB0801, AB0803, AB0804, AB0805,
 78         AB1801, AB1803, AB1804, AB1805, ABX80X};
 79 
 80 struct abx80x_cap {
 81         u16 pn;
 82         bool has_tc;
 83 };
 84 
 85 static struct abx80x_cap abx80x_caps[] = {
 86         [AB0801] = {.pn = 0x0801},
 87         [AB0803] = {.pn = 0x0803},
 88         [AB0804] = {.pn = 0x0804, .has_tc = true},
 89         [AB0805] = {.pn = 0x0805, .has_tc = true},
 90         [AB1801] = {.pn = 0x1801},
 91         [AB1803] = {.pn = 0x1803},
 92         [AB1804] = {.pn = 0x1804, .has_tc = true},
 93         [AB1805] = {.pn = 0x1805, .has_tc = true},
 94         [ABX80X] = {.pn = 0}
 95 };
 96 
 97 static int abx80x_is_rc_mode(struct i2c_client *client)
 98 {
 99         int flags = 0;
100 
101         flags =  i2c_smbus_read_byte_data(client, ABX8XX_REG_OSS);
102         if (flags < 0) {
103                 dev_err(&client->dev,
104                         "Failed to read autocalibration attribute\n");
105                 return flags;
106         }
107 
108         return (flags & ABX8XX_OSS_OMODE) ? 1 : 0;
109 }
110 
111 static int abx80x_enable_trickle_charger(struct i2c_client *client,
112                                          u8 trickle_cfg)
113 {
114         int err;
115 
116         /*
117          * Write the configuration key register to enable access to the Trickle
118          * register
119          */
120         err = i2c_smbus_write_byte_data(client, ABX8XX_REG_CFG_KEY,
121                                         ABX8XX_CFG_KEY_MISC);
122         if (err < 0) {
123                 dev_err(&client->dev, "Unable to write configuration key\n");
124                 return -EIO;
125         }
126 
127         err = i2c_smbus_write_byte_data(client, ABX8XX_REG_TRICKLE,
128                                         ABX8XX_TRICKLE_CHARGE_ENABLE |
129                                         trickle_cfg);
130         if (err < 0) {
131                 dev_err(&client->dev, "Unable to write trickle register\n");
132                 return -EIO;
133         }
134 
135         return 0;
136 }
137 
138 static int abx80x_rtc_read_time(struct device *dev, struct rtc_time *tm)
139 {
140         struct i2c_client *client = to_i2c_client(dev);
141         unsigned char buf[8];
142         int err, flags, rc_mode = 0;
143 
144         /* Read the Oscillator Failure only in XT mode */
145         rc_mode = abx80x_is_rc_mode(client);
146         if (rc_mode < 0)
147                 return rc_mode;
148 
149         if (!rc_mode) {
150                 flags = i2c_smbus_read_byte_data(client, ABX8XX_REG_OSS);
151                 if (flags < 0)
152                         return flags;
153 
154                 if (flags & ABX8XX_OSS_OF) {
155                         dev_err(dev, "Oscillator failure, data is invalid.\n");
156                         return -EINVAL;
157                 }
158         }
159 
160         err = i2c_smbus_read_i2c_block_data(client, ABX8XX_REG_HTH,
161                                             sizeof(buf), buf);
162         if (err < 0) {
163                 dev_err(&client->dev, "Unable to read date\n");
164                 return -EIO;
165         }
166 
167         tm->tm_sec = bcd2bin(buf[ABX8XX_REG_SC] & 0x7F);
168         tm->tm_min = bcd2bin(buf[ABX8XX_REG_MN] & 0x7F);
169         tm->tm_hour = bcd2bin(buf[ABX8XX_REG_HR] & 0x3F);
170         tm->tm_wday = buf[ABX8XX_REG_WD] & 0x7;
171         tm->tm_mday = bcd2bin(buf[ABX8XX_REG_DA] & 0x3F);
172         tm->tm_mon = bcd2bin(buf[ABX8XX_REG_MO] & 0x1F) - 1;
173         tm->tm_year = bcd2bin(buf[ABX8XX_REG_YR]) + 100;
174 
175         err = rtc_valid_tm(tm);
176         if (err < 0)
177                 dev_err(&client->dev, "retrieved date/time is not valid.\n");
178 
179         return err;
180 }
181 
182 static int abx80x_rtc_set_time(struct device *dev, struct rtc_time *tm)
183 {
184         struct i2c_client *client = to_i2c_client(dev);
185         unsigned char buf[8];
186         int err, flags;
187 
188         if (tm->tm_year < 100)
189                 return -EINVAL;
190 
191         buf[ABX8XX_REG_HTH] = 0;
192         buf[ABX8XX_REG_SC] = bin2bcd(tm->tm_sec);
193         buf[ABX8XX_REG_MN] = bin2bcd(tm->tm_min);
194         buf[ABX8XX_REG_HR] = bin2bcd(tm->tm_hour);
195         buf[ABX8XX_REG_DA] = bin2bcd(tm->tm_mday);
196         buf[ABX8XX_REG_MO] = bin2bcd(tm->tm_mon + 1);
197         buf[ABX8XX_REG_YR] = bin2bcd(tm->tm_year - 100);
198         buf[ABX8XX_REG_WD] = tm->tm_wday;
199 
200         err = i2c_smbus_write_i2c_block_data(client, ABX8XX_REG_HTH,
201                                              sizeof(buf), buf);
202         if (err < 0) {
203                 dev_err(&client->dev, "Unable to write to date registers\n");
204                 return -EIO;
205         }
206 
207         /* Clear the OF bit of Oscillator Status Register */
208         flags = i2c_smbus_read_byte_data(client, ABX8XX_REG_OSS);
209         if (flags < 0)
210                 return flags;
211 
212         err = i2c_smbus_write_byte_data(client, ABX8XX_REG_OSS,
213                                         flags & ~ABX8XX_OSS_OF);
214         if (err < 0) {
215                 dev_err(&client->dev, "Unable to write oscillator status register\n");
216                 return err;
217         }
218 
219         return 0;
220 }
221 
222 static irqreturn_t abx80x_handle_irq(int irq, void *dev_id)
223 {
224         struct i2c_client *client = dev_id;
225         struct rtc_device *rtc = i2c_get_clientdata(client);
226         int status;
227 
228         status = i2c_smbus_read_byte_data(client, ABX8XX_REG_STATUS);
229         if (status < 0)
230                 return IRQ_NONE;
231 
232         if (status & ABX8XX_STATUS_AF)
233                 rtc_update_irq(rtc, 1, RTC_AF | RTC_IRQF);
234 
235         i2c_smbus_write_byte_data(client, ABX8XX_REG_STATUS, 0);
236 
237         return IRQ_HANDLED;
238 }
239 
240 static int abx80x_read_alarm(struct device *dev, struct rtc_wkalrm *t)
241 {
242         struct i2c_client *client = to_i2c_client(dev);
243         unsigned char buf[7];
244 
245         int irq_mask, err;
246 
247         if (client->irq <= 0)
248                 return -EINVAL;
249 
250         err = i2c_smbus_read_i2c_block_data(client, ABX8XX_REG_ASC,
251                                             sizeof(buf), buf);
252         if (err)
253                 return err;
254 
255         irq_mask = i2c_smbus_read_byte_data(client, ABX8XX_REG_IRQ);
256         if (irq_mask < 0)
257                 return irq_mask;
258 
259         t->time.tm_sec = bcd2bin(buf[0] & 0x7F);
260         t->time.tm_min = bcd2bin(buf[1] & 0x7F);
261         t->time.tm_hour = bcd2bin(buf[2] & 0x3F);
262         t->time.tm_mday = bcd2bin(buf[3] & 0x3F);
263         t->time.tm_mon = bcd2bin(buf[4] & 0x1F) - 1;
264         t->time.tm_wday = buf[5] & 0x7;
265 
266         t->enabled = !!(irq_mask & ABX8XX_IRQ_AIE);
267         t->pending = (buf[6] & ABX8XX_STATUS_AF) && t->enabled;
268 
269         return err;
270 }
271 
272 static int abx80x_set_alarm(struct device *dev, struct rtc_wkalrm *t)
273 {
274         struct i2c_client *client = to_i2c_client(dev);
275         u8 alarm[6];
276         int err;
277 
278         if (client->irq <= 0)
279                 return -EINVAL;
280 
281         alarm[0] = 0x0;
282         alarm[1] = bin2bcd(t->time.tm_sec);
283         alarm[2] = bin2bcd(t->time.tm_min);
284         alarm[3] = bin2bcd(t->time.tm_hour);
285         alarm[4] = bin2bcd(t->time.tm_mday);
286         alarm[5] = bin2bcd(t->time.tm_mon + 1);
287 
288         err = i2c_smbus_write_i2c_block_data(client, ABX8XX_REG_AHTH,
289                                              sizeof(alarm), alarm);
290         if (err < 0) {
291                 dev_err(&client->dev, "Unable to write alarm registers\n");
292                 return -EIO;
293         }
294 
295         if (t->enabled) {
296                 err = i2c_smbus_write_byte_data(client, ABX8XX_REG_IRQ,
297                                                 (ABX8XX_IRQ_IM_1_4 |
298                                                  ABX8XX_IRQ_AIE));
299                 if (err)
300                         return err;
301         }
302 
303         return 0;
304 }
305 
306 static int abx80x_rtc_set_autocalibration(struct device *dev,
307                                           int autocalibration)
308 {
309         struct i2c_client *client = to_i2c_client(dev);
310         int retval, flags = 0;
311 
312         if ((autocalibration != 0) && (autocalibration != 1024) &&
313             (autocalibration != 512)) {
314                 dev_err(dev, "autocalibration value outside permitted range\n");
315                 return -EINVAL;
316         }
317 
318         flags = i2c_smbus_read_byte_data(client, ABX8XX_REG_OSC);
319         if (flags < 0)
320                 return flags;
321 
322         if (autocalibration == 0) {
323                 flags &= ~(ABX8XX_OSC_ACAL_512 | ABX8XX_OSC_ACAL_1024);
324         } else if (autocalibration == 1024) {
325                 /* 1024 autocalibration is 0x10 */
326                 flags |= ABX8XX_OSC_ACAL_1024;
327                 flags &= ~(ABX8XX_OSC_ACAL_512);
328         } else {
329                 /* 512 autocalibration is 0x11 */
330                 flags |= (ABX8XX_OSC_ACAL_1024 | ABX8XX_OSC_ACAL_512);
331         }
332 
333         /* Unlock write access to Oscillator Control Register */
334         retval = i2c_smbus_write_byte_data(client, ABX8XX_REG_CFG_KEY,
335                                            ABX8XX_CFG_KEY_OSC);
336         if (retval < 0) {
337                 dev_err(dev, "Failed to write CONFIG_KEY register\n");
338                 return retval;
339         }
340 
341         retval = i2c_smbus_write_byte_data(client, ABX8XX_REG_OSC, flags);
342 
343         return retval;
344 }
345 
346 static int abx80x_rtc_get_autocalibration(struct device *dev)
347 {
348         struct i2c_client *client = to_i2c_client(dev);
349         int flags = 0, autocalibration;
350 
351         flags =  i2c_smbus_read_byte_data(client, ABX8XX_REG_OSC);
352         if (flags < 0)
353                 return flags;
354 
355         if (flags & ABX8XX_OSC_ACAL_512)
356                 autocalibration = 512;
357         else if (flags & ABX8XX_OSC_ACAL_1024)
358                 autocalibration = 1024;
359         else
360                 autocalibration = 0;
361 
362         return autocalibration;
363 }
364 
365 static ssize_t autocalibration_store(struct device *dev,
366                                      struct device_attribute *attr,
367                                      const char *buf, size_t count)
368 {
369         int retval;
370         unsigned long autocalibration = 0;
371 
372         retval = kstrtoul(buf, 10, &autocalibration);
373         if (retval < 0) {
374                 dev_err(dev, "Failed to store RTC autocalibration attribute\n");
375                 return -EINVAL;
376         }
377 
378         retval = abx80x_rtc_set_autocalibration(dev, autocalibration);
379 
380         return retval ? retval : count;
381 }
382 
383 static ssize_t autocalibration_show(struct device *dev,
384                                     struct device_attribute *attr, char *buf)
385 {
386         int autocalibration = 0;
387 
388         autocalibration = abx80x_rtc_get_autocalibration(dev);
389         if (autocalibration < 0) {
390                 dev_err(dev, "Failed to read RTC autocalibration\n");
391                 sprintf(buf, "\n");
392                 return autocalibration;
393         }
394 
395         return sprintf(buf, "%d\n", autocalibration);
396 }
397 
398 static DEVICE_ATTR_RW(autocalibration);
399 
400 static ssize_t oscillator_store(struct device *dev,
401                                 struct device_attribute *attr,
402                                 const char *buf, size_t count)
403 {
404         struct i2c_client *client = to_i2c_client(dev);
405         int retval, flags, rc_mode = 0;
406 
407         if (strncmp(buf, "rc", 2) == 0) {
408                 rc_mode = 1;
409         } else if (strncmp(buf, "xtal", 4) == 0) {
410                 rc_mode = 0;
411         } else {
412                 dev_err(dev, "Oscillator selection value outside permitted ones\n");
413                 return -EINVAL;
414         }
415 
416         flags =  i2c_smbus_read_byte_data(client, ABX8XX_REG_OSC);
417         if (flags < 0)
418                 return flags;
419 
420         if (rc_mode == 0)
421                 flags &= ~(ABX8XX_OSC_OSEL);
422         else
423                 flags |= (ABX8XX_OSC_OSEL);
424 
425         /* Unlock write access on Oscillator Control register */
426         retval = i2c_smbus_write_byte_data(client, ABX8XX_REG_CFG_KEY,
427                                            ABX8XX_CFG_KEY_OSC);
428         if (retval < 0) {
429                 dev_err(dev, "Failed to write CONFIG_KEY register\n");
430                 return retval;
431         }
432 
433         retval = i2c_smbus_write_byte_data(client, ABX8XX_REG_OSC, flags);
434         if (retval < 0) {
435                 dev_err(dev, "Failed to write Oscillator Control register\n");
436                 return retval;
437         }
438 
439         return retval ? retval : count;
440 }
441 
442 static ssize_t oscillator_show(struct device *dev,
443                                struct device_attribute *attr, char *buf)
444 {
445         int rc_mode = 0;
446         struct i2c_client *client = to_i2c_client(dev);
447 
448         rc_mode = abx80x_is_rc_mode(client);
449 
450         if (rc_mode < 0) {
451                 dev_err(dev, "Failed to read RTC oscillator selection\n");
452                 sprintf(buf, "\n");
453                 return rc_mode;
454         }
455 
456         if (rc_mode)
457                 return sprintf(buf, "rc\n");
458         else
459                 return sprintf(buf, "xtal\n");
460 }
461 
462 static DEVICE_ATTR_RW(oscillator);
463 
464 static struct attribute *rtc_calib_attrs[] = {
465         &dev_attr_autocalibration.attr,
466         &dev_attr_oscillator.attr,
467         NULL,
468 };
469 
470 static const struct attribute_group rtc_calib_attr_group = {
471         .attrs          = rtc_calib_attrs,
472 };
473 
474 static int abx80x_alarm_irq_enable(struct device *dev, unsigned int enabled)
475 {
476         struct i2c_client *client = to_i2c_client(dev);
477         int err;
478 
479         if (enabled)
480                 err = i2c_smbus_write_byte_data(client, ABX8XX_REG_IRQ,
481                                                 (ABX8XX_IRQ_IM_1_4 |
482                                                  ABX8XX_IRQ_AIE));
483         else
484                 err = i2c_smbus_write_byte_data(client, ABX8XX_REG_IRQ,
485                                                 ABX8XX_IRQ_IM_1_4);
486         return err;
487 }
488 
489 static const struct rtc_class_ops abx80x_rtc_ops = {
490         .read_time      = abx80x_rtc_read_time,
491         .set_time       = abx80x_rtc_set_time,
492         .read_alarm     = abx80x_read_alarm,
493         .set_alarm      = abx80x_set_alarm,
494         .alarm_irq_enable = abx80x_alarm_irq_enable,
495 };
496 
497 static int abx80x_dt_trickle_cfg(struct device_node *np)
498 {
499         const char *diode;
500         int trickle_cfg = 0;
501         int i, ret;
502         u32 tmp;
503 
504         ret = of_property_read_string(np, "abracon,tc-diode", &diode);
505         if (ret)
506                 return ret;
507 
508         if (!strcmp(diode, "standard"))
509                 trickle_cfg |= ABX8XX_TRICKLE_STANDARD_DIODE;
510         else if (!strcmp(diode, "schottky"))
511                 trickle_cfg |= ABX8XX_TRICKLE_SCHOTTKY_DIODE;
512         else
513                 return -EINVAL;
514 
515         ret = of_property_read_u32(np, "abracon,tc-resistor", &tmp);
516         if (ret)
517                 return ret;
518 
519         for (i = 0; i < sizeof(trickle_resistors); i++)
520                 if (trickle_resistors[i] == tmp)
521                         break;
522 
523         if (i == sizeof(trickle_resistors))
524                 return -EINVAL;
525 
526         return (trickle_cfg | i);
527 }
528 
529 static void rtc_calib_remove_sysfs_group(void *_dev)
530 {
531         struct device *dev = _dev;
532 
533         sysfs_remove_group(&dev->kobj, &rtc_calib_attr_group);
534 }
535 
536 static int abx80x_probe(struct i2c_client *client,
537                         const struct i2c_device_id *id)
538 {
539         struct device_node *np = client->dev.of_node;
540         struct rtc_device *rtc;
541         int i, data, err, trickle_cfg = -EINVAL;
542         char buf[7];
543         unsigned int part = id->driver_data;
544         unsigned int partnumber;
545         unsigned int majrev, minrev;
546         unsigned int lot;
547         unsigned int wafer;
548         unsigned int uid;
549 
550         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
551                 return -ENODEV;
552 
553         err = i2c_smbus_read_i2c_block_data(client, ABX8XX_REG_ID0,
554                                             sizeof(buf), buf);
555         if (err < 0) {
556                 dev_err(&client->dev, "Unable to read partnumber\n");
557                 return -EIO;
558         }
559 
560         partnumber = (buf[0] << 8) | buf[1];
561         majrev = buf[2] >> 3;
562         minrev = buf[2] & 0x7;
563         lot = ((buf[4] & 0x80) << 2) | ((buf[6] & 0x80) << 1) | buf[3];
564         uid = ((buf[4] & 0x7f) << 8) | buf[5];
565         wafer = (buf[6] & 0x7c) >> 2;
566         dev_info(&client->dev, "model %04x, revision %u.%u, lot %x, wafer %x, uid %x\n",
567                  partnumber, majrev, minrev, lot, wafer, uid);
568 
569         data = i2c_smbus_read_byte_data(client, ABX8XX_REG_CTRL1);
570         if (data < 0) {
571                 dev_err(&client->dev, "Unable to read control register\n");
572                 return -EIO;
573         }
574 
575         err = i2c_smbus_write_byte_data(client, ABX8XX_REG_CTRL1,
576                                         ((data & ~(ABX8XX_CTRL_12_24 |
577                                                    ABX8XX_CTRL_ARST)) |
578                                          ABX8XX_CTRL_WRITE));
579         if (err < 0) {
580                 dev_err(&client->dev, "Unable to write control register\n");
581                 return -EIO;
582         }
583 
584         /* part autodetection */
585         if (part == ABX80X) {
586                 for (i = 0; abx80x_caps[i].pn; i++)
587                         if (partnumber == abx80x_caps[i].pn)
588                                 break;
589                 if (abx80x_caps[i].pn == 0) {
590                         dev_err(&client->dev, "Unknown part: %04x\n",
591                                 partnumber);
592                         return -EINVAL;
593                 }
594                 part = i;
595         }
596 
597         if (partnumber != abx80x_caps[part].pn) {
598                 dev_err(&client->dev, "partnumber mismatch %04x != %04x\n",
599                         partnumber, abx80x_caps[part].pn);
600                 return -EINVAL;
601         }
602 
603         if (np && abx80x_caps[part].has_tc)
604                 trickle_cfg = abx80x_dt_trickle_cfg(np);
605 
606         if (trickle_cfg > 0) {
607                 dev_info(&client->dev, "Enabling trickle charger: %02x\n",
608                          trickle_cfg);
609                 abx80x_enable_trickle_charger(client, trickle_cfg);
610         }
611 
612         err = i2c_smbus_write_byte_data(client, ABX8XX_REG_CD_TIMER_CTL,
613                                         BIT(2));
614         if (err)
615                 return err;
616 
617         rtc = devm_rtc_device_register(&client->dev, "abx8xx",
618                                        &abx80x_rtc_ops, THIS_MODULE);
619 
620         if (IS_ERR(rtc))
621                 return PTR_ERR(rtc);
622 
623         i2c_set_clientdata(client, rtc);
624 
625         if (client->irq > 0) {
626                 dev_info(&client->dev, "IRQ %d supplied\n", client->irq);
627                 err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
628                                                 abx80x_handle_irq,
629                                                 IRQF_SHARED | IRQF_ONESHOT,
630                                                 "abx8xx",
631                                                 client);
632                 if (err) {
633                         dev_err(&client->dev, "unable to request IRQ, alarms disabled\n");
634                         client->irq = 0;
635                 }
636         }
637 
638         /* Export sysfs entries */
639         err = sysfs_create_group(&(&client->dev)->kobj, &rtc_calib_attr_group);
640         if (err) {
641                 dev_err(&client->dev, "Failed to create sysfs group: %d\n",
642                         err);
643                 return err;
644         }
645 
646         err = devm_add_action_or_reset(&client->dev,
647                                        rtc_calib_remove_sysfs_group,
648                                        &client->dev);
649         if (err)
650                 dev_err(&client->dev,
651                         "Failed to add sysfs cleanup action: %d\n",
652                         err);
653 
654         return err;
655 }
656 
657 static int abx80x_remove(struct i2c_client *client)
658 {
659         return 0;
660 }
661 
662 static const struct i2c_device_id abx80x_id[] = {
663         { "abx80x", ABX80X },
664         { "ab0801", AB0801 },
665         { "ab0803", AB0803 },
666         { "ab0804", AB0804 },
667         { "ab0805", AB0805 },
668         { "ab1801", AB1801 },
669         { "ab1803", AB1803 },
670         { "ab1804", AB1804 },
671         { "ab1805", AB1805 },
672         { "rv1805", AB1805 },
673         { }
674 };
675 MODULE_DEVICE_TABLE(i2c, abx80x_id);
676 
677 static struct i2c_driver abx80x_driver = {
678         .driver         = {
679                 .name   = "rtc-abx80x",
680         },
681         .probe          = abx80x_probe,
682         .remove         = abx80x_remove,
683         .id_table       = abx80x_id,
684 };
685 
686 module_i2c_driver(abx80x_driver);
687 
688 MODULE_AUTHOR("Philippe De Muyter <phdm@macqel.be>");
689 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@free-electrons.com>");
690 MODULE_DESCRIPTION("Abracon ABX80X RTC driver");
691 MODULE_LICENSE("GPL v2");
692 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us