xref: /linux/drivers/rtc/rtc-rv8803.c (revision f86fd32d) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * RTC driver for the Micro Crystal RV8803
4  *
5  * Copyright (C) 2015 Micro Crystal SA
6  * Alexandre Belloni <alexandre.belloni@bootlin.com>
7  *
8  */
9 
10 #include <linux/bcd.h>
11 #include <linux/bitops.h>
12 #include <linux/log2.h>
13 #include <linux/i2c.h>
14 #include <linux/interrupt.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/of_device.h>
18 #include <linux/rtc.h>
19 
20 #define RV8803_I2C_TRY_COUNT		4
21 
22 #define RV8803_SEC			0x00
23 #define RV8803_MIN			0x01
24 #define RV8803_HOUR			0x02
25 #define RV8803_WEEK			0x03
26 #define RV8803_DAY			0x04
27 #define RV8803_MONTH			0x05
28 #define RV8803_YEAR			0x06
29 #define RV8803_RAM			0x07
30 #define RV8803_ALARM_MIN		0x08
31 #define RV8803_ALARM_HOUR		0x09
32 #define RV8803_ALARM_WEEK_OR_DAY	0x0A
33 #define RV8803_EXT			0x0D
34 #define RV8803_FLAG			0x0E
35 #define RV8803_CTRL			0x0F
36 
37 #define RV8803_EXT_WADA			BIT(6)
38 
39 #define RV8803_FLAG_V1F			BIT(0)
40 #define RV8803_FLAG_V2F			BIT(1)
41 #define RV8803_FLAG_AF			BIT(3)
42 #define RV8803_FLAG_TF			BIT(4)
43 #define RV8803_FLAG_UF			BIT(5)
44 
45 #define RV8803_CTRL_RESET		BIT(0)
46 
47 #define RV8803_CTRL_EIE			BIT(2)
48 #define RV8803_CTRL_AIE			BIT(3)
49 #define RV8803_CTRL_TIE			BIT(4)
50 #define RV8803_CTRL_UIE			BIT(5)
51 
52 #define RX8900_BACKUP_CTRL		0x18
53 #define RX8900_FLAG_SWOFF		BIT(2)
54 #define RX8900_FLAG_VDETOFF		BIT(3)
55 
56 enum rv8803_type {
57 	rv_8803,
58 	rx_8900
59 };
60 
61 struct rv8803_data {
62 	struct i2c_client *client;
63 	struct rtc_device *rtc;
64 	struct mutex flags_lock;
65 	u8 ctrl;
66 	enum rv8803_type type;
67 };
68 
69 static int rv8803_read_reg(const struct i2c_client *client, u8 reg)
70 {
71 	int try = RV8803_I2C_TRY_COUNT;
72 	s32 ret;
73 
74 	/*
75 	 * There is a 61µs window during which the RTC does not acknowledge I2C
76 	 * transfers. In that case, ensure that there are multiple attempts.
77 	 */
78 	do
79 		ret = i2c_smbus_read_byte_data(client, reg);
80 	while ((ret == -ENXIO || ret == -EIO) && --try);
81 	if (ret < 0)
82 		dev_err(&client->dev, "Unable to read register 0x%02x\n", reg);
83 
84 	return ret;
85 }
86 
87 static int rv8803_read_regs(const struct i2c_client *client,
88 			    u8 reg, u8 count, u8 *values)
89 {
90 	int try = RV8803_I2C_TRY_COUNT;
91 	s32 ret;
92 
93 	do
94 		ret = i2c_smbus_read_i2c_block_data(client, reg, count, values);
95 	while ((ret == -ENXIO || ret == -EIO) && --try);
96 	if (ret != count) {
97 		dev_err(&client->dev,
98 			"Unable to read registers 0x%02x..0x%02x\n",
99 			reg, reg + count - 1);
100 		return ret < 0 ? ret : -EIO;
101 	}
102 
103 	return 0;
104 }
105 
106 static int rv8803_write_reg(const struct i2c_client *client, u8 reg, u8 value)
107 {
108 	int try = RV8803_I2C_TRY_COUNT;
109 	s32 ret;
110 
111 	do
112 		ret = i2c_smbus_write_byte_data(client, reg, value);
113 	while ((ret == -ENXIO || ret == -EIO) && --try);
114 	if (ret)
115 		dev_err(&client->dev, "Unable to write register 0x%02x\n", reg);
116 
117 	return ret;
118 }
119 
120 static int rv8803_write_regs(const struct i2c_client *client,
121 			     u8 reg, u8 count, const u8 *values)
122 {
123 	int try = RV8803_I2C_TRY_COUNT;
124 	s32 ret;
125 
126 	do
127 		ret = i2c_smbus_write_i2c_block_data(client, reg, count,
128 						     values);
129 	while ((ret == -ENXIO || ret == -EIO) && --try);
130 	if (ret)
131 		dev_err(&client->dev,
132 			"Unable to write registers 0x%02x..0x%02x\n",
133 			reg, reg + count - 1);
134 
135 	return ret;
136 }
137 
138 static irqreturn_t rv8803_handle_irq(int irq, void *dev_id)
139 {
140 	struct i2c_client *client = dev_id;
141 	struct rv8803_data *rv8803 = i2c_get_clientdata(client);
142 	unsigned long events = 0;
143 	int flags;
144 
145 	mutex_lock(&rv8803->flags_lock);
146 
147 	flags = rv8803_read_reg(client, RV8803_FLAG);
148 	if (flags <= 0) {
149 		mutex_unlock(&rv8803->flags_lock);
150 		return IRQ_NONE;
151 	}
152 
153 	if (flags & RV8803_FLAG_V1F)
154 		dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
155 
156 	if (flags & RV8803_FLAG_V2F)
157 		dev_warn(&client->dev, "Voltage low, data loss detected.\n");
158 
159 	if (flags & RV8803_FLAG_TF) {
160 		flags &= ~RV8803_FLAG_TF;
161 		rv8803->ctrl &= ~RV8803_CTRL_TIE;
162 		events |= RTC_PF;
163 	}
164 
165 	if (flags & RV8803_FLAG_AF) {
166 		flags &= ~RV8803_FLAG_AF;
167 		rv8803->ctrl &= ~RV8803_CTRL_AIE;
168 		events |= RTC_AF;
169 	}
170 
171 	if (flags & RV8803_FLAG_UF) {
172 		flags &= ~RV8803_FLAG_UF;
173 		rv8803->ctrl &= ~RV8803_CTRL_UIE;
174 		events |= RTC_UF;
175 	}
176 
177 	if (events) {
178 		rtc_update_irq(rv8803->rtc, 1, events);
179 		rv8803_write_reg(client, RV8803_FLAG, flags);
180 		rv8803_write_reg(rv8803->client, RV8803_CTRL, rv8803->ctrl);
181 	}
182 
183 	mutex_unlock(&rv8803->flags_lock);
184 
185 	return IRQ_HANDLED;
186 }
187 
188 static int rv8803_get_time(struct device *dev, struct rtc_time *tm)
189 {
190 	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
191 	u8 date1[7];
192 	u8 date2[7];
193 	u8 *date = date1;
194 	int ret, flags;
195 
196 	flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
197 	if (flags < 0)
198 		return flags;
199 
200 	if (flags & RV8803_FLAG_V2F) {
201 		dev_warn(dev, "Voltage low, data is invalid.\n");
202 		return -EINVAL;
203 	}
204 
205 	ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date);
206 	if (ret)
207 		return ret;
208 
209 	if ((date1[RV8803_SEC] & 0x7f) == bin2bcd(59)) {
210 		ret = rv8803_read_regs(rv8803->client, RV8803_SEC, 7, date2);
211 		if (ret)
212 			return ret;
213 
214 		if ((date2[RV8803_SEC] & 0x7f) != bin2bcd(59))
215 			date = date2;
216 	}
217 
218 	tm->tm_sec  = bcd2bin(date[RV8803_SEC] & 0x7f);
219 	tm->tm_min  = bcd2bin(date[RV8803_MIN] & 0x7f);
220 	tm->tm_hour = bcd2bin(date[RV8803_HOUR] & 0x3f);
221 	tm->tm_wday = ilog2(date[RV8803_WEEK] & 0x7f);
222 	tm->tm_mday = bcd2bin(date[RV8803_DAY] & 0x3f);
223 	tm->tm_mon  = bcd2bin(date[RV8803_MONTH] & 0x1f) - 1;
224 	tm->tm_year = bcd2bin(date[RV8803_YEAR]) + 100;
225 
226 	return 0;
227 }
228 
229 static int rv8803_set_time(struct device *dev, struct rtc_time *tm)
230 {
231 	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
232 	u8 date[7];
233 	int ctrl, flags, ret;
234 
235 	ctrl = rv8803_read_reg(rv8803->client, RV8803_CTRL);
236 	if (ctrl < 0)
237 		return ctrl;
238 
239 	/* Stop the clock */
240 	ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
241 			       ctrl | RV8803_CTRL_RESET);
242 	if (ret)
243 		return ret;
244 
245 	date[RV8803_SEC]   = bin2bcd(tm->tm_sec);
246 	date[RV8803_MIN]   = bin2bcd(tm->tm_min);
247 	date[RV8803_HOUR]  = bin2bcd(tm->tm_hour);
248 	date[RV8803_WEEK]  = 1 << (tm->tm_wday);
249 	date[RV8803_DAY]   = bin2bcd(tm->tm_mday);
250 	date[RV8803_MONTH] = bin2bcd(tm->tm_mon + 1);
251 	date[RV8803_YEAR]  = bin2bcd(tm->tm_year - 100);
252 
253 	ret = rv8803_write_regs(rv8803->client, RV8803_SEC, 7, date);
254 	if (ret)
255 		return ret;
256 
257 	/* Restart the clock */
258 	ret = rv8803_write_reg(rv8803->client, RV8803_CTRL,
259 			       ctrl & ~RV8803_CTRL_RESET);
260 	if (ret)
261 		return ret;
262 
263 	mutex_lock(&rv8803->flags_lock);
264 
265 	flags = rv8803_read_reg(rv8803->client, RV8803_FLAG);
266 	if (flags < 0) {
267 		mutex_unlock(&rv8803->flags_lock);
268 		return flags;
269 	}
270 
271 	ret = rv8803_write_reg(rv8803->client, RV8803_FLAG,
272 			       flags & ~(RV8803_FLAG_V1F | RV8803_FLAG_V2F));
273 
274 	mutex_unlock(&rv8803->flags_lock);
275 
276 	return ret;
277 }
278 
279 static int rv8803_get_alarm(struct device *dev, struct rtc_wkalrm *alrm)
280 {
281 	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
282 	struct i2c_client *client = rv8803->client;
283 	u8 alarmvals[3];
284 	int flags, ret;
285 
286 	ret = rv8803_read_regs(client, RV8803_ALARM_MIN, 3, alarmvals);
287 	if (ret)
288 		return ret;
289 
290 	flags = rv8803_read_reg(client, RV8803_FLAG);
291 	if (flags < 0)
292 		return flags;
293 
294 	alrm->time.tm_sec  = 0;
295 	alrm->time.tm_min  = bcd2bin(alarmvals[0] & 0x7f);
296 	alrm->time.tm_hour = bcd2bin(alarmvals[1] & 0x3f);
297 	alrm->time.tm_mday = bcd2bin(alarmvals[2] & 0x3f);
298 
299 	alrm->enabled = !!(rv8803->ctrl & RV8803_CTRL_AIE);
300 	alrm->pending = (flags & RV8803_FLAG_AF) && alrm->enabled;
301 
302 	return 0;
303 }
304 
305 static int rv8803_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
306 {
307 	struct i2c_client *client = to_i2c_client(dev);
308 	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
309 	u8 alarmvals[3];
310 	u8 ctrl[2];
311 	int ret, err;
312 
313 	/* The alarm has no seconds, round up to nearest minute */
314 	if (alrm->time.tm_sec) {
315 		time64_t alarm_time = rtc_tm_to_time64(&alrm->time);
316 
317 		alarm_time += 60 - alrm->time.tm_sec;
318 		rtc_time64_to_tm(alarm_time, &alrm->time);
319 	}
320 
321 	mutex_lock(&rv8803->flags_lock);
322 
323 	ret = rv8803_read_regs(client, RV8803_FLAG, 2, ctrl);
324 	if (ret) {
325 		mutex_unlock(&rv8803->flags_lock);
326 		return ret;
327 	}
328 
329 	alarmvals[0] = bin2bcd(alrm->time.tm_min);
330 	alarmvals[1] = bin2bcd(alrm->time.tm_hour);
331 	alarmvals[2] = bin2bcd(alrm->time.tm_mday);
332 
333 	if (rv8803->ctrl & (RV8803_CTRL_AIE | RV8803_CTRL_UIE)) {
334 		rv8803->ctrl &= ~(RV8803_CTRL_AIE | RV8803_CTRL_UIE);
335 		err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
336 				       rv8803->ctrl);
337 		if (err) {
338 			mutex_unlock(&rv8803->flags_lock);
339 			return err;
340 		}
341 	}
342 
343 	ctrl[1] &= ~RV8803_FLAG_AF;
344 	err = rv8803_write_reg(rv8803->client, RV8803_FLAG, ctrl[1]);
345 	mutex_unlock(&rv8803->flags_lock);
346 	if (err)
347 		return err;
348 
349 	err = rv8803_write_regs(rv8803->client, RV8803_ALARM_MIN, 3, alarmvals);
350 	if (err)
351 		return err;
352 
353 	if (alrm->enabled) {
354 		if (rv8803->rtc->uie_rtctimer.enabled)
355 			rv8803->ctrl |= RV8803_CTRL_UIE;
356 		if (rv8803->rtc->aie_timer.enabled)
357 			rv8803->ctrl |= RV8803_CTRL_AIE;
358 
359 		err = rv8803_write_reg(rv8803->client, RV8803_CTRL,
360 				       rv8803->ctrl);
361 		if (err)
362 			return err;
363 	}
364 
365 	return 0;
366 }
367 
368 static int rv8803_alarm_irq_enable(struct device *dev, unsigned int enabled)
369 {
370 	struct i2c_client *client = to_i2c_client(dev);
371 	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
372 	int ctrl, flags, err;
373 
374 	ctrl = rv8803->ctrl;
375 
376 	if (enabled) {
377 		if (rv8803->rtc->uie_rtctimer.enabled)
378 			ctrl |= RV8803_CTRL_UIE;
379 		if (rv8803->rtc->aie_timer.enabled)
380 			ctrl |= RV8803_CTRL_AIE;
381 	} else {
382 		if (!rv8803->rtc->uie_rtctimer.enabled)
383 			ctrl &= ~RV8803_CTRL_UIE;
384 		if (!rv8803->rtc->aie_timer.enabled)
385 			ctrl &= ~RV8803_CTRL_AIE;
386 	}
387 
388 	mutex_lock(&rv8803->flags_lock);
389 	flags = rv8803_read_reg(client, RV8803_FLAG);
390 	if (flags < 0) {
391 		mutex_unlock(&rv8803->flags_lock);
392 		return flags;
393 	}
394 	flags &= ~(RV8803_FLAG_AF | RV8803_FLAG_UF);
395 	err = rv8803_write_reg(client, RV8803_FLAG, flags);
396 	mutex_unlock(&rv8803->flags_lock);
397 	if (err)
398 		return err;
399 
400 	if (ctrl != rv8803->ctrl) {
401 		rv8803->ctrl = ctrl;
402 		err = rv8803_write_reg(client, RV8803_CTRL, rv8803->ctrl);
403 		if (err)
404 			return err;
405 	}
406 
407 	return 0;
408 }
409 
410 static int rv8803_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
411 {
412 	struct i2c_client *client = to_i2c_client(dev);
413 	struct rv8803_data *rv8803 = dev_get_drvdata(dev);
414 	unsigned int vl = 0;
415 	int flags, ret = 0;
416 
417 	switch (cmd) {
418 	case RTC_VL_READ:
419 		flags = rv8803_read_reg(client, RV8803_FLAG);
420 		if (flags < 0)
421 			return flags;
422 
423 		if (flags & RV8803_FLAG_V1F) {
424 			dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
425 			vl = RTC_VL_ACCURACY_LOW;
426 		}
427 
428 		if (flags & RV8803_FLAG_V2F)
429 			vl |= RTC_VL_DATA_INVALID;
430 
431 		return put_user(vl, (unsigned int __user *)arg);
432 
433 	case RTC_VL_CLR:
434 		mutex_lock(&rv8803->flags_lock);
435 		flags = rv8803_read_reg(client, RV8803_FLAG);
436 		if (flags < 0) {
437 			mutex_unlock(&rv8803->flags_lock);
438 			return flags;
439 		}
440 
441 		flags &= ~RV8803_FLAG_V1F;
442 		ret = rv8803_write_reg(client, RV8803_FLAG, flags);
443 		mutex_unlock(&rv8803->flags_lock);
444 		if (ret)
445 			return ret;
446 
447 		return 0;
448 
449 	default:
450 		return -ENOIOCTLCMD;
451 	}
452 }
453 
454 static int rv8803_nvram_write(void *priv, unsigned int offset, void *val,
455 			      size_t bytes)
456 {
457 	int ret;
458 
459 	ret = rv8803_write_reg(priv, RV8803_RAM, *(u8 *)val);
460 	if (ret)
461 		return ret;
462 
463 	return 0;
464 }
465 
466 static int rv8803_nvram_read(void *priv, unsigned int offset,
467 			     void *val, size_t bytes)
468 {
469 	int ret;
470 
471 	ret = rv8803_read_reg(priv, RV8803_RAM);
472 	if (ret < 0)
473 		return ret;
474 
475 	*(u8 *)val = ret;
476 
477 	return 0;
478 }
479 
480 static struct rtc_class_ops rv8803_rtc_ops = {
481 	.read_time = rv8803_get_time,
482 	.set_time = rv8803_set_time,
483 	.ioctl = rv8803_ioctl,
484 };
485 
486 static int rx8900_trickle_charger_init(struct rv8803_data *rv8803)
487 {
488 	struct i2c_client *client = rv8803->client;
489 	struct device_node *node = client->dev.of_node;
490 	int err;
491 	u8 flags;
492 
493 	if (!node)
494 		return 0;
495 
496 	if (rv8803->type != rx_8900)
497 		return 0;
498 
499 	err = i2c_smbus_read_byte_data(rv8803->client, RX8900_BACKUP_CTRL);
500 	if (err < 0)
501 		return err;
502 
503 	flags = ~(RX8900_FLAG_VDETOFF | RX8900_FLAG_SWOFF) & (u8)err;
504 
505 	if (of_property_read_bool(node, "epson,vdet-disable"))
506 		flags |= RX8900_FLAG_VDETOFF;
507 
508 	if (of_property_read_bool(node, "trickle-diode-disable"))
509 		flags |= RX8900_FLAG_SWOFF;
510 
511 	return i2c_smbus_write_byte_data(rv8803->client, RX8900_BACKUP_CTRL,
512 					 flags);
513 }
514 
515 static int rv8803_probe(struct i2c_client *client,
516 			const struct i2c_device_id *id)
517 {
518 	struct i2c_adapter *adapter = client->adapter;
519 	struct rv8803_data *rv8803;
520 	int err, flags;
521 	struct nvmem_config nvmem_cfg = {
522 		.name = "rv8803_nvram",
523 		.word_size = 1,
524 		.stride = 1,
525 		.size = 1,
526 		.reg_read = rv8803_nvram_read,
527 		.reg_write = rv8803_nvram_write,
528 		.priv = client,
529 	};
530 
531 	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA |
532 				     I2C_FUNC_SMBUS_I2C_BLOCK)) {
533 		dev_err(&adapter->dev, "doesn't support I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK\n");
534 		return -EIO;
535 	}
536 
537 	rv8803 = devm_kzalloc(&client->dev, sizeof(struct rv8803_data),
538 			      GFP_KERNEL);
539 	if (!rv8803)
540 		return -ENOMEM;
541 
542 	mutex_init(&rv8803->flags_lock);
543 	rv8803->client = client;
544 	if (client->dev.of_node)
545 		rv8803->type = (enum rv8803_type)
546 			of_device_get_match_data(&client->dev);
547 	else
548 		rv8803->type = id->driver_data;
549 	i2c_set_clientdata(client, rv8803);
550 
551 	flags = rv8803_read_reg(client, RV8803_FLAG);
552 	if (flags < 0)
553 		return flags;
554 
555 	if (flags & RV8803_FLAG_V1F)
556 		dev_warn(&client->dev, "Voltage low, temperature compensation stopped.\n");
557 
558 	if (flags & RV8803_FLAG_V2F)
559 		dev_warn(&client->dev, "Voltage low, data loss detected.\n");
560 
561 	if (flags & RV8803_FLAG_AF)
562 		dev_warn(&client->dev, "An alarm maybe have been missed.\n");
563 
564 	rv8803->rtc = devm_rtc_allocate_device(&client->dev);
565 	if (IS_ERR(rv8803->rtc))
566 		return PTR_ERR(rv8803->rtc);
567 
568 	if (client->irq > 0) {
569 		err = devm_request_threaded_irq(&client->dev, client->irq,
570 						NULL, rv8803_handle_irq,
571 						IRQF_TRIGGER_LOW | IRQF_ONESHOT,
572 						"rv8803", client);
573 		if (err) {
574 			dev_warn(&client->dev, "unable to request IRQ, alarms disabled\n");
575 			client->irq = 0;
576 		} else {
577 			rv8803_rtc_ops.read_alarm = rv8803_get_alarm;
578 			rv8803_rtc_ops.set_alarm = rv8803_set_alarm;
579 			rv8803_rtc_ops.alarm_irq_enable = rv8803_alarm_irq_enable;
580 		}
581 	}
582 
583 	err = rv8803_write_reg(rv8803->client, RV8803_EXT, RV8803_EXT_WADA);
584 	if (err)
585 		return err;
586 
587 	err = rx8900_trickle_charger_init(rv8803);
588 	if (err) {
589 		dev_err(&client->dev, "failed to init charger\n");
590 		return err;
591 	}
592 
593 	rv8803->rtc->ops = &rv8803_rtc_ops;
594 	rv8803->rtc->nvram_old_abi = true;
595 	rv8803->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
596 	rv8803->rtc->range_max = RTC_TIMESTAMP_END_2099;
597 	err = rtc_register_device(rv8803->rtc);
598 	if (err)
599 		return err;
600 
601 	rtc_nvmem_register(rv8803->rtc, &nvmem_cfg);
602 
603 	rv8803->rtc->max_user_freq = 1;
604 
605 	return 0;
606 }
607 
608 static const struct i2c_device_id rv8803_id[] = {
609 	{ "rv8803", rv_8803 },
610 	{ "rx8803", rv_8803 },
611 	{ "rx8900", rx_8900 },
612 	{ }
613 };
614 MODULE_DEVICE_TABLE(i2c, rv8803_id);
615 
616 static const struct of_device_id rv8803_of_match[] = {
617 	{
618 		.compatible = "microcrystal,rv8803",
619 		.data = (void *)rv_8803
620 	},
621 	{
622 		.compatible = "epson,rx8803",
623 		.data = (void *)rv_8803
624 	},
625 	{
626 		.compatible = "epson,rx8900",
627 		.data = (void *)rx_8900
628 	},
629 	{ }
630 };
631 MODULE_DEVICE_TABLE(of, rv8803_of_match);
632 
633 static struct i2c_driver rv8803_driver = {
634 	.driver = {
635 		.name = "rtc-rv8803",
636 		.of_match_table = of_match_ptr(rv8803_of_match),
637 	},
638 	.probe		= rv8803_probe,
639 	.id_table	= rv8803_id,
640 };
641 module_i2c_driver(rv8803_driver);
642 
643 MODULE_AUTHOR("Alexandre Belloni <alexandre.belloni@bootlin.com>");
644 MODULE_DESCRIPTION("Micro Crystal RV8803 RTC driver");
645 MODULE_LICENSE("GPL v2");
646