forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/drivers/rtc/rtc-rv3029c2.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 /*
23  * Micro Crystal RV-3029 / RV-3049 rtc class driver
34  *
....@@ -5,11 +6,6 @@
56  *         Michael Buesch <m@bues.ch>
67  *
78  * based on previously existing rtc class drivers
8
- *
9
- * This program is free software; you can redistribute it and/or modify
10
- * it under the terms of the GNU General Public License version 2 as
11
- * published by the Free Software Foundation.
12
- *
139  */
1410 
1511 #include <linux/module.h>
....@@ -113,10 +109,8 @@
113109 #define RV3029_CONTROL_E2P_TOV_MASK	0x3F /* XTAL turnover temp mask */
114110 
115111 /* user ram section */
116
-#define RV3029_USR1_RAM_PAGE		0x38
117
-#define RV3029_USR1_SECTION_LEN		0x04
118
-#define RV3029_USR2_RAM_PAGE		0x3C
119
-#define RV3029_USR2_SECTION_LEN		0x04
112
+#define RV3029_RAM_PAGE			0x38
113
+#define RV3029_RAM_SECTION_LEN		8
120114 
121115 struct rv3029_data {
122116 	struct device		*dev;
....@@ -125,77 +119,13 @@
125119 	int irq;
126120 };
127121 
128
-static int rv3029_read_regs(struct device *dev, u8 reg, u8 *buf,
129
-			    unsigned int len)
122
+static int rv3029_eeprom_busywait(struct rv3029_data *rv3029)
130123 {
131
-	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
132
-
133
-	if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
134
-	    (reg + len > RV3029_USR1_RAM_PAGE + 8))
135
-		return -EINVAL;
136
-
137
-	return regmap_bulk_read(rv3029->regmap, reg, buf, len);
138
-}
139
-
140
-static int rv3029_write_regs(struct device *dev, u8 reg, u8 const buf[],
141
-			     unsigned int len)
142
-{
143
-	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
144
-
145
-	if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
146
-	    (reg + len > RV3029_USR1_RAM_PAGE + 8))
147
-		return -EINVAL;
148
-
149
-	return regmap_bulk_write(rv3029->regmap, reg, buf, len);
150
-}
151
-
152
-static int rv3029_update_bits(struct device *dev, u8 reg, u8 mask, u8 set)
153
-{
154
-	u8 buf;
155
-	int ret;
156
-
157
-	ret = rv3029_read_regs(dev, reg, &buf, 1);
158
-	if (ret < 0)
159
-		return ret;
160
-	buf &= ~mask;
161
-	buf |= set & mask;
162
-	ret = rv3029_write_regs(dev, reg, &buf, 1);
163
-	if (ret < 0)
164
-		return ret;
165
-
166
-	return 0;
167
-}
168
-
169
-static int rv3029_get_sr(struct device *dev, u8 *buf)
170
-{
171
-	int ret = rv3029_read_regs(dev, RV3029_STATUS, buf, 1);
172
-
173
-	if (ret < 0)
174
-		return -EIO;
175
-	dev_dbg(dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
176
-	return 0;
177
-}
178
-
179
-static int rv3029_set_sr(struct device *dev, u8 val)
180
-{
181
-	u8 buf[1];
182
-	int sr;
183
-
184
-	buf[0] = val;
185
-	sr = rv3029_write_regs(dev, RV3029_STATUS, buf, 1);
186
-	dev_dbg(dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
187
-	if (sr < 0)
188
-		return -EIO;
189
-	return 0;
190
-}
191
-
192
-static int rv3029_eeprom_busywait(struct device *dev)
193
-{
124
+	unsigned int sr;
194125 	int i, ret;
195
-	u8 sr;
196126 
197127 	for (i = 100; i > 0; i--) {
198
-		ret = rv3029_get_sr(dev, &sr);
128
+		ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
199129 		if (ret < 0)
200130 			break;
201131 		if (!(sr & RV3029_STATUS_EEBUSY))
....@@ -203,126 +133,128 @@
203133 		usleep_range(1000, 10000);
204134 	}
205135 	if (i <= 0) {
206
-		dev_err(dev, "EEPROM busy wait timeout.\n");
136
+		dev_err(rv3029->dev, "EEPROM busy wait timeout.\n");
207137 		return -ETIMEDOUT;
208138 	}
209139 
210140 	return ret;
211141 }
212142 
213
-static int rv3029_eeprom_exit(struct device *dev)
143
+static int rv3029_eeprom_exit(struct rv3029_data *rv3029)
214144 {
215145 	/* Re-enable eeprom refresh */
216
-	return rv3029_update_bits(dev, RV3029_ONOFF_CTRL,
146
+	return regmap_update_bits(rv3029->regmap, RV3029_ONOFF_CTRL,
217147 				  RV3029_ONOFF_CTRL_EERE,
218148 				  RV3029_ONOFF_CTRL_EERE);
219149 }
220150 
221
-static int rv3029_eeprom_enter(struct device *dev)
151
+static int rv3029_eeprom_enter(struct rv3029_data *rv3029)
222152 {
153
+	unsigned int sr;
223154 	int ret;
224
-	u8 sr;
225155 
226156 	/* Check whether we are in the allowed voltage range. */
227
-	ret = rv3029_get_sr(dev, &sr);
157
+	ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
228158 	if (ret < 0)
229159 		return ret;
230
-	if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) {
160
+	if (sr & RV3029_STATUS_VLOW2)
161
+		return -ENODEV;
162
+	if (sr & RV3029_STATUS_VLOW1) {
231163 		/* We clear the bits and retry once just in case
232164 		 * we had a brown out in early startup.
233165 		 */
234
-		sr &= ~RV3029_STATUS_VLOW1;
235
-		sr &= ~RV3029_STATUS_VLOW2;
236
-		ret = rv3029_set_sr(dev, sr);
166
+		ret = regmap_update_bits(rv3029->regmap, RV3029_STATUS,
167
+					 RV3029_STATUS_VLOW1, 0);
237168 		if (ret < 0)
238169 			return ret;
239170 		usleep_range(1000, 10000);
240
-		ret = rv3029_get_sr(dev, &sr);
171
+		ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
241172 		if (ret < 0)
242173 			return ret;
243
-		if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) {
244
-			dev_err(dev,
174
+		if (sr & RV3029_STATUS_VLOW1) {
175
+			dev_err(rv3029->dev,
245176 				"Supply voltage is too low to safely access the EEPROM.\n");
246177 			return -ENODEV;
247178 		}
248179 	}
249180 
250181 	/* Disable eeprom refresh. */
251
-	ret = rv3029_update_bits(dev, RV3029_ONOFF_CTRL, RV3029_ONOFF_CTRL_EERE,
252
-				 0);
182
+	ret = regmap_update_bits(rv3029->regmap, RV3029_ONOFF_CTRL,
183
+				 RV3029_ONOFF_CTRL_EERE, 0);
253184 	if (ret < 0)
254185 		return ret;
255186 
256187 	/* Wait for any previous eeprom accesses to finish. */
257
-	ret = rv3029_eeprom_busywait(dev);
188
+	ret = rv3029_eeprom_busywait(rv3029);
258189 	if (ret < 0)
259
-		rv3029_eeprom_exit(dev);
190
+		rv3029_eeprom_exit(rv3029);
260191 
261192 	return ret;
262193 }
263194 
264
-static int rv3029_eeprom_read(struct device *dev, u8 reg,
195
+static int rv3029_eeprom_read(struct rv3029_data *rv3029, u8 reg,
265196 			      u8 buf[], size_t len)
266197 {
267198 	int ret, err;
268199 
269
-	err = rv3029_eeprom_enter(dev);
200
+	err = rv3029_eeprom_enter(rv3029);
270201 	if (err < 0)
271202 		return err;
272203 
273
-	ret = rv3029_read_regs(dev, reg, buf, len);
204
+	ret = regmap_bulk_read(rv3029->regmap, reg, buf, len);
274205 
275
-	err = rv3029_eeprom_exit(dev);
206
+	err = rv3029_eeprom_exit(rv3029);
276207 	if (err < 0)
277208 		return err;
278209 
279210 	return ret;
280211 }
281212 
282
-static int rv3029_eeprom_write(struct device *dev, u8 reg,
213
+static int rv3029_eeprom_write(struct rv3029_data *rv3029, u8 reg,
283214 			       u8 const buf[], size_t len)
284215 {
216
+	unsigned int tmp;
285217 	int ret, err;
286218 	size_t i;
287
-	u8 tmp;
288219 
289
-	err = rv3029_eeprom_enter(dev);
220
+	err = rv3029_eeprom_enter(rv3029);
290221 	if (err < 0)
291222 		return err;
292223 
293224 	for (i = 0; i < len; i++, reg++) {
294
-		ret = rv3029_read_regs(dev, reg, &tmp, 1);
225
+		ret = regmap_read(rv3029->regmap, reg, &tmp);
295226 		if (ret < 0)
296227 			break;
297228 		if (tmp != buf[i]) {
298
-			ret = rv3029_write_regs(dev, reg, &buf[i], 1);
229
+			tmp = buf[i];
230
+			ret = regmap_write(rv3029->regmap, reg, tmp);
299231 			if (ret < 0)
300232 				break;
301233 		}
302
-		ret = rv3029_eeprom_busywait(dev);
234
+		ret = rv3029_eeprom_busywait(rv3029);
303235 		if (ret < 0)
304236 			break;
305237 	}
306238 
307
-	err = rv3029_eeprom_exit(dev);
239
+	err = rv3029_eeprom_exit(rv3029);
308240 	if (err < 0)
309241 		return err;
310242 
311243 	return ret;
312244 }
313245 
314
-static int rv3029_eeprom_update_bits(struct device *dev,
246
+static int rv3029_eeprom_update_bits(struct rv3029_data *rv3029,
315247 				     u8 reg, u8 mask, u8 set)
316248 {
317249 	u8 buf;
318250 	int ret;
319251 
320
-	ret = rv3029_eeprom_read(dev, reg, &buf, 1);
252
+	ret = rv3029_eeprom_read(rv3029, reg, &buf, 1);
321253 	if (ret < 0)
322254 		return ret;
323255 	buf &= ~mask;
324256 	buf |= set & mask;
325
-	ret = rv3029_eeprom_write(dev, reg, &buf, 1);
257
+	ret = rv3029_eeprom_write(rv3029, reg, &buf, 1);
326258 	if (ret < 0)
327259 		return ret;
328260 
....@@ -334,20 +266,20 @@
334266 	struct device *dev = dev_id;
335267 	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
336268 	struct mutex *lock = &rv3029->rtc->ops_lock;
269
+	unsigned int flags, controls;
337270 	unsigned long events = 0;
338
-	u8 flags, controls;
339271 	int ret;
340272 
341273 	mutex_lock(lock);
342274 
343
-	ret = rv3029_read_regs(dev, RV3029_IRQ_CTRL, &controls, 1);
275
+	ret = regmap_read(rv3029->regmap, RV3029_IRQ_CTRL, &controls);
344276 	if (ret) {
345277 		dev_warn(dev, "Read IRQ Control Register error %d\n", ret);
346278 		mutex_unlock(lock);
347279 		return IRQ_NONE;
348280 	}
349281 
350
-	ret = rv3029_read_regs(dev, RV3029_IRQ_FLAGS, &flags, 1);
282
+	ret = regmap_read(rv3029->regmap, RV3029_IRQ_FLAGS, &flags);
351283 	if (ret) {
352284 		dev_warn(dev, "Read IRQ Flags Register error %d\n", ret);
353285 		mutex_unlock(lock);
....@@ -362,8 +294,8 @@
362294 
363295 	if (events) {
364296 		rtc_update_irq(rv3029->rtc, 1, events);
365
-		rv3029_write_regs(dev, RV3029_IRQ_FLAGS, &flags, 1);
366
-		rv3029_write_regs(dev, RV3029_IRQ_CTRL, &controls, 1);
297
+		regmap_write(rv3029->regmap, RV3029_IRQ_FLAGS, flags);
298
+		regmap_write(rv3029->regmap, RV3029_IRQ_CTRL, controls);
367299 	}
368300 	mutex_unlock(lock);
369301 
....@@ -372,22 +304,22 @@
372304 
373305 static int rv3029_read_time(struct device *dev, struct rtc_time *tm)
374306 {
375
-	u8 buf[1];
307
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
308
+	unsigned int sr;
376309 	int ret;
377310 	u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, };
378311 
379
-	ret = rv3029_get_sr(dev, buf);
380
-	if (ret < 0) {
381
-		dev_err(dev, "%s: reading SR failed\n", __func__);
382
-		return -EIO;
383
-	}
384
-
385
-	ret = rv3029_read_regs(dev, RV3029_W_SEC, regs,
386
-			       RV3029_WATCH_SECTION_LEN);
387
-	if (ret < 0) {
388
-		dev_err(dev, "%s: reading RTC section failed\n", __func__);
312
+	ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
313
+	if (ret < 0)
389314 		return ret;
390
-	}
315
+
316
+	if (sr & (RV3029_STATUS_VLOW2 | RV3029_STATUS_PON))
317
+		return -EINVAL;
318
+
319
+	ret = regmap_bulk_read(rv3029->regmap, RV3029_W_SEC, regs,
320
+			       RV3029_WATCH_SECTION_LEN);
321
+	if (ret < 0)
322
+		return ret;
391323 
392324 	tm->tm_sec = bcd2bin(regs[RV3029_W_SEC - RV3029_W_SEC]);
393325 	tm->tm_min = bcd2bin(regs[RV3029_W_MINUTES - RV3029_W_SEC]);
....@@ -415,34 +347,24 @@
415347 
416348 static int rv3029_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
417349 {
350
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
418351 	struct rtc_time *const tm = &alarm->time;
352
+	unsigned int controls, flags;
419353 	int ret;
420
-	u8 regs[8], controls, flags;
354
+	u8 regs[8];
421355 
422
-	ret = rv3029_get_sr(dev, regs);
423
-	if (ret < 0) {
424
-		dev_err(dev, "%s: reading SR failed\n", __func__);
425
-		return -EIO;
426
-	}
427
-
428
-	ret = rv3029_read_regs(dev, RV3029_A_SC, regs,
356
+	ret = regmap_bulk_read(rv3029->regmap, RV3029_A_SC, regs,
429357 			       RV3029_ALARM_SECTION_LEN);
358
+	if (ret < 0)
359
+		return ret;
430360 
431
-	if (ret < 0) {
432
-		dev_err(dev, "%s: reading alarm section failed\n", __func__);
361
+	ret = regmap_read(rv3029->regmap, RV3029_IRQ_CTRL, &controls);
362
+	if (ret)
433363 		return ret;
434
-	}
435364 
436
-	ret = rv3029_read_regs(dev, RV3029_IRQ_CTRL, &controls, 1);
437
-	if (ret) {
438
-		dev_err(dev, "Read IRQ Control Register error %d\n", ret);
365
+	ret = regmap_read(rv3029->regmap, RV3029_IRQ_FLAGS, &flags);
366
+	if (ret < 0)
439367 		return ret;
440
-	}
441
-	ret = rv3029_read_regs(dev, RV3029_IRQ_FLAGS, &flags, 1);
442
-	if (ret < 0) {
443
-		dev_err(dev, "Read IRQ Flags Register error %d\n", ret);
444
-		return ret;
445
-	}
446368 
447369 	tm->tm_sec = bcd2bin(regs[RV3029_A_SC - RV3029_A_SC] & 0x7f);
448370 	tm->tm_min = bcd2bin(regs[RV3029_A_MN - RV3029_A_SC] & 0x7f);
....@@ -460,49 +382,19 @@
460382 
461383 static int rv3029_alarm_irq_enable(struct device *dev, unsigned int enable)
462384 {
463
-	int ret;
464
-	u8 controls;
385
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
465386 
466
-	ret = rv3029_read_regs(dev, RV3029_IRQ_CTRL, &controls, 1);
467
-	if (ret < 0) {
468
-		dev_warn(dev, "Read IRQ Control Register error %d\n", ret);
469
-		return ret;
470
-	}
471
-
472
-	/* enable/disable AIE irq */
473
-	if (enable)
474
-		controls |= RV3029_IRQ_CTRL_AIE;
475
-	else
476
-		controls &= ~RV3029_IRQ_CTRL_AIE;
477
-
478
-	ret = rv3029_write_regs(dev, RV3029_IRQ_CTRL, &controls, 1);
479
-	if (ret < 0) {
480
-		dev_err(dev, "can't update INT reg\n");
481
-		return ret;
482
-	}
483
-
484
-	return 0;
387
+	return regmap_update_bits(rv3029->regmap, RV3029_IRQ_CTRL,
388
+				  RV3029_IRQ_CTRL_AIE,
389
+				  enable ? RV3029_IRQ_CTRL_AIE : 0);
485390 }
486391 
487392 static int rv3029_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
488393 {
394
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
489395 	struct rtc_time *const tm = &alarm->time;
490396 	int ret;
491397 	u8 regs[8];
492
-
493
-	/*
494
-	 * The clock has an 8 bit wide bcd-coded register (they never learn)
495
-	 * for the year. tm_year is an offset from 1900 and we are interested
496
-	 * in the 2000-2099 range, so any value less than 100 is invalid.
497
-	*/
498
-	if (tm->tm_year < 100)
499
-		return -EINVAL;
500
-
501
-	ret = rv3029_get_sr(dev, regs);
502
-	if (ret < 0) {
503
-		dev_err(dev, "%s: reading SR failed\n", __func__);
504
-		return -EIO;
505
-	}
506398 
507399 	/* Activate all the alarms with AE_x bit */
508400 	regs[RV3029_A_SC - RV3029_A_SC] = bin2bcd(tm->tm_sec) | RV3029_A_AE_X;
....@@ -519,38 +411,19 @@
519411 		| RV3029_A_AE_X;
520412 
521413 	/* Write the alarm */
522
-	ret = rv3029_write_regs(dev, RV3029_A_SC, regs,
414
+	ret = regmap_bulk_write(rv3029->regmap, RV3029_A_SC, regs,
523415 				RV3029_ALARM_SECTION_LEN);
524416 	if (ret < 0)
525417 		return ret;
526418 
527
-	if (alarm->enabled) {
528
-		/* enable AIE irq */
529
-		ret = rv3029_alarm_irq_enable(dev, 1);
530
-		if (ret)
531
-			return ret;
532
-	} else {
533
-		/* disable AIE irq */
534
-		ret = rv3029_alarm_irq_enable(dev, 0);
535
-		if (ret)
536
-			return ret;
537
-	}
538
-
539
-	return 0;
419
+	return rv3029_alarm_irq_enable(dev, alarm->enabled);
540420 }
541421 
542422 static int rv3029_set_time(struct device *dev, struct rtc_time *tm)
543423 {
424
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
544425 	u8 regs[8];
545426 	int ret;
546
-
547
-	/*
548
-	 * The clock has an 8 bit wide bcd-coded register (they never learn)
549
-	 * for the year. tm_year is an offset from 1900 and we are interested
550
-	 * in the 2000-2099 range, so any value less than 100 is invalid.
551
-	*/
552
-	if (tm->tm_year < 100)
553
-		return -EINVAL;
554427 
555428 	regs[RV3029_W_SEC - RV3029_W_SEC] = bin2bcd(tm->tm_sec);
556429 	regs[RV3029_W_MINUTES - RV3029_W_SEC] = bin2bcd(tm->tm_min);
....@@ -560,24 +433,55 @@
560433 	regs[RV3029_W_DAYS - RV3029_W_SEC] = bin2bcd(tm->tm_wday + 1) & 0x7;
561434 	regs[RV3029_W_YEARS - RV3029_W_SEC] = bin2bcd(tm->tm_year - 100);
562435 
563
-	ret = rv3029_write_regs(dev, RV3029_W_SEC, regs,
436
+	ret = regmap_bulk_write(rv3029->regmap, RV3029_W_SEC, regs,
564437 				RV3029_WATCH_SECTION_LEN);
565438 	if (ret < 0)
566439 		return ret;
567440 
568
-	ret = rv3029_get_sr(dev, regs);
569
-	if (ret < 0) {
570
-		dev_err(dev, "%s: reading SR failed\n", __func__);
571
-		return ret;
572
-	}
573
-	/* clear PON bit */
574
-	ret = rv3029_set_sr(dev, (regs[0] & ~RV3029_STATUS_PON));
575
-	if (ret < 0) {
576
-		dev_err(dev, "%s: reading SR failed\n", __func__);
577
-		return ret;
578
-	}
441
+	/* clear PON and VLOW2 bits */
442
+	return regmap_update_bits(rv3029->regmap, RV3029_STATUS,
443
+				  RV3029_STATUS_PON | RV3029_STATUS_VLOW2, 0);
444
+}
579445 
580
-	return 0;
446
+static int rv3029_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
447
+{
448
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
449
+	unsigned long vl = 0;
450
+	int sr, ret = 0;
451
+
452
+	switch (cmd) {
453
+	case RTC_VL_READ:
454
+		ret = regmap_read(rv3029->regmap, RV3029_STATUS, &sr);
455
+		if (ret < 0)
456
+			return ret;
457
+
458
+		if (sr & RV3029_STATUS_VLOW1)
459
+			vl = RTC_VL_ACCURACY_LOW;
460
+
461
+		if (sr & (RV3029_STATUS_VLOW2 | RV3029_STATUS_PON))
462
+			vl |= RTC_VL_DATA_INVALID;
463
+
464
+		return put_user(vl, (unsigned int __user *)arg);
465
+
466
+	case RTC_VL_CLR:
467
+		return regmap_update_bits(rv3029->regmap, RV3029_STATUS,
468
+					  RV3029_STATUS_VLOW1, 0);
469
+
470
+	default:
471
+		return -ENOIOCTLCMD;
472
+	}
473
+}
474
+
475
+static int rv3029_nvram_write(void *priv, unsigned int offset, void *val,
476
+			      size_t bytes)
477
+{
478
+	return regmap_bulk_write(priv, RV3029_RAM_PAGE + offset, val, bytes);
479
+}
480
+
481
+static int rv3029_nvram_read(void *priv, unsigned int offset, void *val,
482
+			     size_t bytes)
483
+{
484
+	return regmap_bulk_read(priv, RV3029_RAM_PAGE + offset, val, bytes);
581485 }
582486 
583487 static const struct rv3029_trickle_tab_elem {
....@@ -639,6 +543,7 @@
639543 
640544 static void rv3029_trickle_config(struct device *dev)
641545 {
546
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
642547 	struct device_node *of_node = dev->of_node;
643548 	const struct rv3029_trickle_tab_elem *elem;
644549 	int i, err;
....@@ -665,7 +570,7 @@
665570 			 "Trickle charger enabled at %d ohms resistance.\n",
666571 			 elem->r);
667572 	}
668
-	err = rv3029_eeprom_update_bits(dev, RV3029_CONTROL_E2P_EECTRL,
573
+	err = rv3029_eeprom_update_bits(rv3029, RV3029_CONTROL_E2P_EECTRL,
669574 					RV3029_TRICKLE_MASK,
670575 					trickle_set_bits);
671576 	if (err < 0)
....@@ -674,12 +579,12 @@
674579 
675580 #ifdef CONFIG_RTC_DRV_RV3029_HWMON
676581 
677
-static int rv3029_read_temp(struct device *dev, int *temp_mC)
582
+static int rv3029_read_temp(struct rv3029_data *rv3029, int *temp_mC)
678583 {
584
+	unsigned int temp;
679585 	int ret;
680
-	u8 temp;
681586 
682
-	ret = rv3029_read_regs(dev, RV3029_TEMP_PAGE, &temp, 1);
587
+	ret = regmap_read(rv3029->regmap, RV3029_TEMP_PAGE, &temp);
683588 	if (ret < 0)
684589 		return ret;
685590 
....@@ -692,9 +597,10 @@
692597 				      struct device_attribute *attr,
693598 				      char *buf)
694599 {
600
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
695601 	int ret, temp_mC;
696602 
697
-	ret = rv3029_read_temp(dev, &temp_mC);
603
+	ret = rv3029_read_temp(rv3029, &temp_mC);
698604 	if (ret < 0)
699605 		return ret;
700606 
....@@ -706,9 +612,10 @@
706612 						const char *buf,
707613 						size_t count)
708614 {
615
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
616
+	unsigned int th_set_bits = 0;
709617 	unsigned long interval_ms;
710618 	int ret;
711
-	u8 th_set_bits = 0;
712619 
713620 	ret = kstrtoul(buf, 10, &interval_ms);
714621 	if (ret < 0)
....@@ -719,7 +626,7 @@
719626 		if (interval_ms >= 16000)
720627 			th_set_bits |= RV3029_EECTRL_THP;
721628 	}
722
-	ret = rv3029_eeprom_update_bits(dev, RV3029_CONTROL_E2P_EECTRL,
629
+	ret = rv3029_eeprom_update_bits(rv3029, RV3029_CONTROL_E2P_EECTRL,
723630 					RV3029_EECTRL_THE | RV3029_EECTRL_THP,
724631 					th_set_bits);
725632 	if (ret < 0)
....@@ -732,10 +639,11 @@
732639 						 struct device_attribute *attr,
733640 						 char *buf)
734641 {
642
+	struct rv3029_data *rv3029 = dev_get_drvdata(dev);
735643 	int ret, interval_ms;
736644 	u8 eectrl;
737645 
738
-	ret = rv3029_eeprom_read(dev, RV3029_CONTROL_E2P_EECTRL,
646
+	ret = rv3029_eeprom_read(rv3029, RV3029_CONTROL_E2P_EECTRL,
739647 				 &eectrl, 1);
740648 	if (ret < 0)
741649 		return ret;
....@@ -789,14 +697,23 @@
789697 static struct rtc_class_ops rv3029_rtc_ops = {
790698 	.read_time	= rv3029_read_time,
791699 	.set_time	= rv3029_set_time,
700
+	.ioctl		= rv3029_ioctl,
792701 };
793702 
794703 static int rv3029_probe(struct device *dev, struct regmap *regmap, int irq,
795704 			const char *name)
796705 {
797706 	struct rv3029_data *rv3029;
707
+	struct nvmem_config nvmem_cfg = {
708
+		.name = "rv3029_nvram",
709
+		.word_size = 1,
710
+		.stride = 1,
711
+		.size = RV3029_RAM_SECTION_LEN,
712
+		.type = NVMEM_TYPE_BATTERY_BACKED,
713
+		.reg_read = rv3029_nvram_read,
714
+		.reg_write = rv3029_nvram_write,
715
+	};
798716 	int rc = 0;
799
-	u8 buf[1];
800717 
801718 	rv3029 = devm_kzalloc(dev, sizeof(*rv3029), GFP_KERNEL);
802719 	if (!rv3029)
....@@ -807,21 +724,12 @@
807724 	rv3029->dev = dev;
808725 	dev_set_drvdata(dev, rv3029);
809726 
810
-	rc = rv3029_get_sr(dev, buf);
811
-	if (rc < 0) {
812
-		dev_err(dev, "reading status failed\n");
813
-		return rc;
814
-	}
815
-
816727 	rv3029_trickle_config(dev);
817728 	rv3029_hwmon_register(dev, name);
818729 
819
-	rv3029->rtc = devm_rtc_device_register(dev, name, &rv3029_rtc_ops,
820
-					       THIS_MODULE);
821
-	if (IS_ERR(rv3029->rtc)) {
822
-		dev_err(dev, "unable to register the class device\n");
730
+	rv3029->rtc = devm_rtc_allocate_device(dev);
731
+	if (IS_ERR(rv3029->rtc))
823732 		return PTR_ERR(rv3029->rtc);
824
-	}
825733 
826734 	if (rv3029->irq > 0) {
827735 		rc = devm_request_threaded_irq(dev, rv3029->irq,
....@@ -838,8 +746,41 @@
838746 		}
839747 	}
840748 
749
+	rv3029->rtc->ops = &rv3029_rtc_ops;
750
+	rv3029->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000;
751
+	rv3029->rtc->range_max = RTC_TIMESTAMP_END_2079;
752
+
753
+	rc = rtc_register_device(rv3029->rtc);
754
+	if (rc)
755
+		return rc;
756
+
757
+	nvmem_cfg.priv = rv3029->regmap;
758
+	rtc_nvmem_register(rv3029->rtc, &nvmem_cfg);
759
+
841760 	return 0;
842761 }
762
+
763
+static const struct regmap_range rv3029_holes_range[] = {
764
+	regmap_reg_range(0x05, 0x07),
765
+	regmap_reg_range(0x0f, 0x0f),
766
+	regmap_reg_range(0x17, 0x17),
767
+	regmap_reg_range(0x1a, 0x1f),
768
+	regmap_reg_range(0x21, 0x27),
769
+	regmap_reg_range(0x34, 0x37),
770
+};
771
+
772
+static const struct regmap_access_table rv3029_regs = {
773
+	.no_ranges =	rv3029_holes_range,
774
+	.n_no_ranges =	ARRAY_SIZE(rv3029_holes_range),
775
+};
776
+
777
+static const struct regmap_config config = {
778
+	.reg_bits = 8,
779
+	.val_bits = 8,
780
+	.rd_table = &rv3029_regs,
781
+	.wr_table = &rv3029_regs,
782
+	.max_register = 0x3f,
783
+};
843784 
844785 #if IS_ENABLED(CONFIG_I2C)
845786 
....@@ -847,11 +788,6 @@
847788 			    const struct i2c_device_id *id)
848789 {
849790 	struct regmap *regmap;
850
-	static const struct regmap_config config = {
851
-		.reg_bits = 8,
852
-		.val_bits = 8,
853
-	};
854
-
855791 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK |
856792 				     I2C_FUNC_SMBUS_BYTE)) {
857793 		dev_err(&client->dev, "Adapter does not support SMBUS_I2C_BLOCK or SMBUS_I2C_BYTE\n");
....@@ -859,11 +795,8 @@
859795 	}
860796 
861797 	regmap = devm_regmap_init_i2c(client, &config);
862
-	if (IS_ERR(regmap)) {
863
-		dev_err(&client->dev, "%s: regmap allocation failed: %ld\n",
864
-			__func__, PTR_ERR(regmap));
798
+	if (IS_ERR(regmap))
865799 		return PTR_ERR(regmap);
866
-	}
867800 
868801 	return rv3029_probe(&client->dev, regmap, client->irq, client->name);
869802 }
....@@ -877,24 +810,20 @@
877810 
878811 static const struct of_device_id rv3029_of_match[] = {
879812 	{ .compatible = "microcrystal,rv3029" },
880
-	/* Backward compatibility only, do not use compatibles below: */
881
-	{ .compatible = "rv3029" },
882
-	{ .compatible = "rv3029c2" },
883
-	{ .compatible = "mc,rv3029c2" },
884813 	{ }
885814 };
886815 MODULE_DEVICE_TABLE(of, rv3029_of_match);
887816 
888817 static struct i2c_driver rv3029_driver = {
889818 	.driver = {
890
-		.name = "rtc-rv3029c2",
819
+		.name = "rv3029",
891820 		.of_match_table = of_match_ptr(rv3029_of_match),
892821 	},
893822 	.probe		= rv3029_i2c_probe,
894823 	.id_table	= rv3029_id,
895824 };
896825 
897
-static int rv3029_register_driver(void)
826
+static int __init rv3029_register_driver(void)
898827 {
899828 	return i2c_add_driver(&rv3029_driver);
900829 }
....@@ -906,7 +835,7 @@
906835 
907836 #else
908837 
909
-static int rv3029_register_driver(void)
838
+static int __init rv3029_register_driver(void)
910839 {
911840 	return 0;
912841 }
....@@ -921,18 +850,11 @@
921850 
922851 static int rv3049_probe(struct spi_device *spi)
923852 {
924
-	static const struct regmap_config config = {
925
-		.reg_bits = 8,
926
-		.val_bits = 8,
927
-	};
928853 	struct regmap *regmap;
929854 
930855 	regmap = devm_regmap_init_spi(spi, &config);
931
-	if (IS_ERR(regmap)) {
932
-		dev_err(&spi->dev, "%s: regmap allocation failed: %ld\n",
933
-			__func__, PTR_ERR(regmap));
856
+	if (IS_ERR(regmap))
934857 		return PTR_ERR(regmap);
935
-	}
936858 
937859 	return rv3029_probe(&spi->dev, regmap, spi->irq, "rv3049");
938860 }
....@@ -944,24 +866,24 @@
944866 	.probe   = rv3049_probe,
945867 };
946868 
947
-static int rv3049_register_driver(void)
869
+static int __init rv3049_register_driver(void)
948870 {
949871 	return spi_register_driver(&rv3049_driver);
950872 }
951873 
952
-static void rv3049_unregister_driver(void)
874
+static void __exit rv3049_unregister_driver(void)
953875 {
954876 	spi_unregister_driver(&rv3049_driver);
955877 }
956878 
957879 #else
958880 
959
-static int rv3049_register_driver(void)
881
+static int __init rv3049_register_driver(void)
960882 {
961883 	return 0;
962884 }
963885 
964
-static void rv3049_unregister_driver(void)
886
+static void __exit rv3049_unregister_driver(void)
965887 {
966888 }
967889 
....@@ -972,16 +894,12 @@
972894 	int ret;
973895 
974896 	ret = rv3029_register_driver();
975
-	if (ret) {
976
-		pr_err("Failed to register rv3029 driver: %d\n", ret);
897
+	if (ret)
977898 		return ret;
978
-	}
979899 
980900 	ret = rv3049_register_driver();
981
-	if (ret) {
982
-		pr_err("Failed to register rv3049 driver: %d\n", ret);
901
+	if (ret)
983902 		rv3029_unregister_driver();
984
-	}
985903 
986904 	return ret;
987905 }