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