forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-05-10 ee930fffee469d076998274a2ca55e13dc1efb67 
 kernel/drivers/rtc/rtc-ab-b5ze-s3.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0+
12 /*
23  * rtc-ab-b5ze-s3 - Driver for Abracon AB-RTCMC-32.768Khz-B5ZE-S3
34  *                  I2C RTC / Alarm chip
....@@ -6,23 +7,13 @@
67  *
78  * Detailed datasheet of the chip is available here:
89  *
9
- *  http://www.abracon.com/realtimeclock/AB-RTCMC-32.768kHz-B5ZE-S3-Application-Manual.pdf
10
+ *  https://www.abracon.com/realtimeclock/AB-RTCMC-32.768kHz-B5ZE-S3-Application-Manual.pdf
1011  *
1112  * This work is based on ISL12057 driver (drivers/rtc/rtc-isl12057.c).
1213  *
13
- * This program is free software; you can redistribute it and/or modify
14
- * it under the terms of the GNU General Public License as published by
15
- * the Free Software Foundation; either version 2 of the License, or
16
- * (at your option) any later version.
17
- *
18
- * This program is distributed in the hope that it will be useful,
19
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21
- * GNU General Public License for more details.
2214  */
2315 
2416 #include <linux/module.h>
25
-#include <linux/mutex.h>
2617 #include <linux/rtc.h>
2718 #include <linux/i2c.h>
2819 #include <linux/bcd.h>
....@@ -128,7 +119,6 @@
128119 struct abb5zes3_rtc_data {
129120 	struct rtc_device *rtc;
130121 	struct regmap *regmap;
131
-	struct mutex lock;
132122 
133123 	int irq;
134124 
....@@ -138,8 +128,7 @@
138128 
139129 /*
140130  * Try and match register bits w/ fixed null values to see whether we
141
- * are dealing with an ABB5ZES3. Note: this function is called early
142
- * during init and hence does need mutex protection.
131
+ * are dealing with an ABB5ZES3.
143132  */
144133 static int abb5zes3_i2c_validate_chip(struct regmap *regmap)
145134 {
....@@ -230,14 +219,12 @@
230219 	if (ret) {
231220 		dev_err(dev, "%s: reading RTC time failed (%d)\n",
232221 			__func__, ret);
233
-		goto err;
222
+		return ret;
234223 	}
235224 
236225 	/* If clock integrity is not guaranteed, do not return a time value */
237
-	if (regs[ABB5ZES3_REG_RTC_SC] & ABB5ZES3_REG_RTC_SC_OSC) {
238
-		ret = -ENODATA;
239
-		goto err;
240
-	}
226
+	if (regs[ABB5ZES3_REG_RTC_SC] & ABB5ZES3_REG_RTC_SC_OSC)
227
+		return -ENODATA;
241228 
242229 	tm->tm_sec = bcd2bin(regs[ABB5ZES3_REG_RTC_SC] & 0x7F);
243230 	tm->tm_min = bcd2bin(regs[ABB5ZES3_REG_RTC_MN]);
....@@ -255,7 +242,6 @@
255242 	tm->tm_mon  = bcd2bin(regs[ABB5ZES3_REG_RTC_MO]) - 1; /* starts at 1 */
256243 	tm->tm_year = bcd2bin(regs[ABB5ZES3_REG_RTC_YR]) + 100;
257244 
258
-err:
259245 	return ret;
260246 }
261247 
....@@ -273,12 +259,9 @@
273259 	regs[ABB5ZES3_REG_RTC_MO] = bin2bcd(tm->tm_mon + 1);
274260 	regs[ABB5ZES3_REG_RTC_YR] = bin2bcd(tm->tm_year - 100);
275261 
276
-	mutex_lock(&data->lock);
277262 	ret = regmap_bulk_write(data->regmap, ABB5ZES3_REG_RTC_SC,
278263 				regs + ABB5ZES3_REG_RTC_SC,
279264 				ABB5ZES3_RTC_SEC_LEN);
280
-	mutex_unlock(&data->lock);
281
-
282265 
283266 	return ret;
284267 }
....@@ -332,38 +315,35 @@
332315 	if (ret) {
333316 		dev_err(dev, "%s: reading Timer A section failed (%d)\n",
334317 			__func__, ret);
335
-		goto err;
318
+		return ret;
336319 	}
337320 
338321 	/* get current time ... */
339322 	ret = _abb5zes3_rtc_read_time(dev, &rtc_tm);
340323 	if (ret)
341
-		goto err;
324
+		return ret;
342325 
343326 	/* ... convert to seconds ... */
344
-	ret = rtc_tm_to_time(&rtc_tm, &rtc_secs);
345
-	if (ret)
346
-		goto err;
327
+	rtc_secs = rtc_tm_to_time64(&rtc_tm);
347328 
348329 	/* ... add remaining timer A time ... */
349330 	ret = sec_from_timer_a(&timer_secs, regs[1], regs[2]);
350331 	if (ret)
351
-		goto err;
332
+		return ret;
352333 
353334 	/* ... and convert back. */
354
-	rtc_time_to_tm(rtc_secs + timer_secs, alarm_tm);
335
+	rtc_time64_to_tm(rtc_secs + timer_secs, alarm_tm);
355336 
356337 	ret = regmap_read(data->regmap, ABB5ZES3_REG_CTRL2, &reg);
357338 	if (ret) {
358339 		dev_err(dev, "%s: reading ctrl reg failed (%d)\n",
359340 			__func__, ret);
360
-		goto err;
341
+		return ret;
361342 	}
362343 
363344 	alarm->enabled = !!(reg & ABB5ZES3_REG_CTRL2_WTAIE);
364345 
365
-err:
366
-	return ret;
346
+	return 0;
367347 }
368348 
369349 /* Read alarm currently configured via a RTC alarm registers. */
....@@ -382,7 +362,7 @@
382362 	if (ret) {
383363 		dev_err(dev, "%s: reading alarm section failed (%d)\n",
384364 			__func__, ret);
385
-		goto err;
365
+		return ret;
386366 	}
387367 
388368 	alarm_tm->tm_sec  = 0;
....@@ -398,18 +378,13 @@
398378 	 */
399379 	ret = _abb5zes3_rtc_read_time(dev, &rtc_tm);
400380 	if (ret)
401
-		goto err;
381
+		return ret;
402382 
403383 	alarm_tm->tm_year = rtc_tm.tm_year;
404384 	alarm_tm->tm_mon = rtc_tm.tm_mon;
405385 
406
-	ret = rtc_tm_to_time(&rtc_tm, &rtc_secs);
407
-	if (ret)
408
-		goto err;
409
-
410
-	ret = rtc_tm_to_time(alarm_tm, &alarm_secs);
411
-	if (ret)
412
-		goto err;
386
+	rtc_secs = rtc_tm_to_time64(&rtc_tm);
387
+	alarm_secs = rtc_tm_to_time64(alarm_tm);
413388 
414389 	if (alarm_secs < rtc_secs) {
415390 		if (alarm_tm->tm_mon == 11) {
....@@ -424,13 +399,12 @@
424399 	if (ret) {
425400 		dev_err(dev, "%s: reading ctrl reg failed (%d)\n",
426401 			__func__, ret);
427
-		goto err;
402
+		return ret;
428403 	}
429404 
430405 	alarm->enabled = !!(reg & ABB5ZES3_REG_CTRL1_AIE);
431406 
432
-err:
433
-	return ret;
407
+	return 0;
434408 }
435409 
436410 /*
....@@ -447,12 +421,10 @@
447421 	struct abb5zes3_rtc_data *data = dev_get_drvdata(dev);
448422 	int ret;
449423 
450
-	mutex_lock(&data->lock);
451424 	if (data->timer_alarm)
452425 		ret = _abb5zes3_rtc_read_timer(dev, alarm);
453426 	else
454427 		ret = _abb5zes3_rtc_read_alarm(dev, alarm);
455
-	mutex_unlock(&data->lock);
456428 
457429 	return ret;
458430 }
....@@ -466,33 +438,25 @@
466438 {
467439 	struct abb5zes3_rtc_data *data = dev_get_drvdata(dev);
468440 	struct rtc_time *alarm_tm = &alarm->time;
469
-	unsigned long rtc_secs, alarm_secs;
470441 	u8 regs[ABB5ZES3_ALRM_SEC_LEN];
471442 	struct rtc_time rtc_tm;
472443 	int ret, enable = 1;
473444 
474
-	ret = _abb5zes3_rtc_read_time(dev, &rtc_tm);
475
-	if (ret)
476
-		goto err;
477
-
478
-	ret = rtc_tm_to_time(&rtc_tm, &rtc_secs);
479
-	if (ret)
480
-		goto err;
481
-
482
-	ret = rtc_tm_to_time(alarm_tm, &alarm_secs);
483
-	if (ret)
484
-		goto err;
485
-
486
-	/* If alarm time is before current time, disable the alarm */
487
-	if (!alarm->enabled || alarm_secs <= rtc_secs) {
445
+	if (!alarm->enabled) {
488446 		enable = 0;
489447 	} else {
448
+		unsigned long rtc_secs, alarm_secs;
449
+
490450 		/*
491451 		 * Chip only support alarms up to one month in the future. Let's
492452 		 * return an error if we get something after that limit.
493453 		 * Comparison is done by incrementing rtc_tm month field by one
494454 		 * and checking alarm value is still below.
495455 		 */
456
+		ret = _abb5zes3_rtc_read_time(dev, &rtc_tm);
457
+		if (ret)
458
+			return ret;
459
+
496460 		if (rtc_tm.tm_mon == 11) { /* handle year wrapping */
497461 			rtc_tm.tm_mon = 0;
498462 			rtc_tm.tm_year += 1;
....@@ -500,15 +464,13 @@
500464 			rtc_tm.tm_mon += 1;
501465 		}
502466 
503
-		ret = rtc_tm_to_time(&rtc_tm, &rtc_secs);
504
-		if (ret)
505
-			goto err;
467
+		rtc_secs = rtc_tm_to_time64(&rtc_tm);
468
+		alarm_secs = rtc_tm_to_time64(alarm_tm);
506469 
507470 		if (alarm_secs > rtc_secs) {
508
-			dev_err(dev, "%s: alarm maximum is one month in the "
509
-				"future (%d)\n", __func__, ret);
510
-			ret = -EINVAL;
511
-			goto err;
471
+			dev_err(dev, "%s: alarm maximum is one month in the future (%d)\n",
472
+				__func__, ret);
473
+			return -EINVAL;
512474 		}
513475 	}
514476 
....@@ -526,17 +488,14 @@
526488 	if (ret < 0) {
527489 		dev_err(dev, "%s: writing ALARM section failed (%d)\n",
528490 			__func__, ret);
529
-		goto err;
491
+		return ret;
530492 	}
531493 
532494 	/* Record currently configured alarm is not a timer */
533495 	data->timer_alarm = 0;
534496 
535497 	/* Enable or disable alarm interrupt generation */
536
-	ret = _abb5zes3_rtc_update_alarm(dev, enable);
537
-
538
-err:
539
-	return ret;
498
+	return _abb5zes3_rtc_update_alarm(dev, enable);
540499 }
541500 
542501 /*
....@@ -557,7 +516,7 @@
557516 				ABB5ZES3_TIMA_SEC_LEN);
558517 	if (ret < 0) {
559518 		dev_err(dev, "%s: writing timer section failed\n", __func__);
560
-		goto err;
519
+		return ret;
561520 	}
562521 
563522 	/* Configure Timer A as a watchdog timer */
....@@ -570,10 +529,7 @@
570529 	data->timer_alarm = 1;
571530 
572531 	/* Enable or disable timer interrupt generation */
573
-	ret = _abb5zes3_rtc_update_timer(dev, alarm->enabled);
574
-
575
-err:
576
-	return ret;
532
+	return _abb5zes3_rtc_update_timer(dev, alarm->enabled);
577533 }
578534 
579535 /*
....@@ -590,31 +546,25 @@
590546 	struct rtc_time rtc_tm;
591547 	int ret;
592548 
593
-	mutex_lock(&data->lock);
594549 	ret = _abb5zes3_rtc_read_time(dev, &rtc_tm);
595550 	if (ret)
596
-		goto err;
551
+		return ret;
597552 
598
-	ret = rtc_tm_to_time(&rtc_tm, &rtc_secs);
599
-	if (ret)
600
-		goto err;
601
-
602
-	ret = rtc_tm_to_time(alarm_tm, &alarm_secs);
603
-	if (ret)
604
-		goto err;
553
+	rtc_secs = rtc_tm_to_time64(&rtc_tm);
554
+	alarm_secs = rtc_tm_to_time64(alarm_tm);
605555 
606556 	/* Let's first disable both the alarm and the timer interrupts */
607557 	ret = _abb5zes3_rtc_update_alarm(dev, false);
608558 	if (ret < 0) {
609559 		dev_err(dev, "%s: unable to disable alarm (%d)\n", __func__,
610560 			ret);
611
-		goto err;
561
+		return ret;
612562 	}
613563 	ret = _abb5zes3_rtc_update_timer(dev, false);
614564 	if (ret < 0) {
615565 		dev_err(dev, "%s: unable to disable timer (%d)\n", __func__,
616566 			ret);
617
-		goto err;
567
+		return ret;
618568 	}
619569 
620570 	data->timer_alarm = 0;
....@@ -628,9 +578,6 @@
628578 					      alarm_secs - rtc_secs);
629579 	else
630580 		ret = _abb5zes3_rtc_set_alarm(dev, alarm);
631
-
632
- err:
633
-	mutex_unlock(&data->lock);
634581 
635582 	if (ret)
636583 		dev_err(dev, "%s: unable to configure alarm (%d)\n", __func__,
....@@ -650,8 +597,7 @@
650597 
651598 /*
652599  * Check current RTC status and enable/disable what needs to be. Return 0 if
653
- * everything went ok and a negative value upon error. Note: this function
654
- * is called early during init and hence does need mutex protection.
600
+ * everything went ok and a negative value upon error.
655601  */
656602 static int abb5zes3_rtc_check_setup(struct device *dev)
657603 {
....@@ -675,8 +621,9 @@
675621 		ABB5ZES3_REG_TIM_CLK_COF1 | ABB5ZES3_REG_TIM_CLK_COF2 |
676622 		ABB5ZES3_REG_TIM_CLK_TBM | ABB5ZES3_REG_TIM_CLK_TAM);
677623 	ret = regmap_update_bits(regmap, ABB5ZES3_REG_TIM_CLK, mask,
678
-		ABB5ZES3_REG_TIM_CLK_COF0 | ABB5ZES3_REG_TIM_CLK_COF1 |
679
-		ABB5ZES3_REG_TIM_CLK_COF2);
624
+				 ABB5ZES3_REG_TIM_CLK_COF0 |
625
+				 ABB5ZES3_REG_TIM_CLK_COF1 |
626
+				 ABB5ZES3_REG_TIM_CLK_COF2);
680627 	if (ret < 0) {
681628 		dev_err(dev, "%s: unable to initialize clkout register (%d)\n",
682629 			__func__, ret);
....@@ -729,9 +676,9 @@
729676 	 * switchover flag but not battery low flag. The latter is checked
730677 	 * later below.
731678 	 */
732
-	mask = (ABB5ZES3_REG_CTRL3_PM0 | ABB5ZES3_REG_CTRL3_PM1 |
733
-		ABB5ZES3_REG_CTRL3_PM2 | ABB5ZES3_REG_CTRL3_BLIE |
734
-		ABB5ZES3_REG_CTRL3_BSIE| ABB5ZES3_REG_CTRL3_BSF);
679
+	mask = (ABB5ZES3_REG_CTRL3_PM0  | ABB5ZES3_REG_CTRL3_PM1 |
680
+		ABB5ZES3_REG_CTRL3_PM2  | ABB5ZES3_REG_CTRL3_BLIE |
681
+		ABB5ZES3_REG_CTRL3_BSIE | ABB5ZES3_REG_CTRL3_BSF);
735682 	ret = regmap_update_bits(regmap, ABB5ZES3_REG_CTRL3, mask, 0);
736683 	if (ret < 0) {
737684 		dev_err(dev, "%s: unable to initialize CTRL3 register (%d)\n",
....@@ -748,10 +695,8 @@
748695 	}
749696 
750697 	if (reg & ABB5ZES3_REG_RTC_SC_OSC) {
751
-		dev_err(dev, "clock integrity not guaranteed. Osc. has stopped "
752
-			"or has been interrupted.\n");
753
-		dev_err(dev, "change battery (if not already done) and  "
754
-			"then set time to reset osc. failure flag.\n");
698
+		dev_err(dev, "clock integrity not guaranteed. Osc. has stopped or has been interrupted.\n");
699
+		dev_err(dev, "change battery (if not already done) and then set time to reset osc. failure flag.\n");
755700 	}
756701 
757702 	/*
....@@ -769,13 +714,12 @@
769714 
770715 	data->battery_low = reg & ABB5ZES3_REG_CTRL3_BLF;
771716 	if (data->battery_low) {
772
-		dev_err(dev, "RTC battery is low; please, consider "
773
-			"changing it!\n");
717
+		dev_err(dev, "RTC battery is low; please, consider changing it!\n");
774718 
775719 		ret = _abb5zes3_rtc_battery_low_irq_enable(regmap, false);
776720 		if (ret)
777
-			dev_err(dev, "%s: disabling battery low interrupt "
778
-				"generation failed (%d)\n", __func__, ret);
721
+			dev_err(dev, "%s: disabling battery low interrupt generation failed (%d)\n",
722
+				__func__, ret);
779723 	}
780724 
781725 	return ret;
....@@ -788,12 +732,10 @@
788732 	int ret = 0;
789733 
790734 	if (rtc_data->irq) {
791
-		mutex_lock(&rtc_data->lock);
792735 		if (rtc_data->timer_alarm)
793736 			ret = _abb5zes3_rtc_update_timer(dev, enable);
794737 		else
795738 			ret = _abb5zes3_rtc_update_alarm(dev, enable);
796
-		mutex_unlock(&rtc_data->lock);
797739 	}
798740 
799741 	return ret;
....@@ -885,49 +827,44 @@
885827 
886828 	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
887829 				     I2C_FUNC_SMBUS_BYTE_DATA |
888
-				     I2C_FUNC_SMBUS_I2C_BLOCK)) {
889
-		ret = -ENODEV;
890
-		goto err;
891
-	}
830
+				     I2C_FUNC_SMBUS_I2C_BLOCK))
831
+		return -ENODEV;
892832 
893833 	regmap = devm_regmap_init_i2c(client, &abb5zes3_rtc_regmap_config);
894834 	if (IS_ERR(regmap)) {
895835 		ret = PTR_ERR(regmap);
896836 		dev_err(dev, "%s: regmap allocation failed: %d\n",
897837 			__func__, ret);
898
-		goto err;
838
+		return ret;
899839 	}
900840 
901841 	ret = abb5zes3_i2c_validate_chip(regmap);
902842 	if (ret)
903
-		goto err;
843
+		return ret;
904844 
905845 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
906
-	if (!data) {
907
-		ret = -ENOMEM;
908
-		goto err;
909
-	}
846
+	if (!data)
847
+		return -ENOMEM;
910848 
911
-	mutex_init(&data->lock);
912849 	data->regmap = regmap;
913850 	dev_set_drvdata(dev, data);
914851 
915852 	ret = abb5zes3_rtc_check_setup(dev);
916853 	if (ret)
917
-		goto err;
854
+		return ret;
918855 
919856 	data->rtc = devm_rtc_allocate_device(dev);
920857 	ret = PTR_ERR_OR_ZERO(data->rtc);
921858 	if (ret) {
922859 		dev_err(dev, "%s: unable to allocate RTC device (%d)\n",
923860 			__func__, ret);
924
-		goto err;
861
+		return ret;
925862 	}
926863 
927864 	if (client->irq > 0) {
928865 		ret = devm_request_threaded_irq(dev, client->irq, NULL,
929866 						_abb5zes3_rtc_interrupt,
930
-						IRQF_SHARED|IRQF_ONESHOT,
867
+						IRQF_SHARED | IRQF_ONESHOT,
931868 						DRV_NAME, client);
932869 		if (!ret) {
933870 			device_init_wakeup(dev, true);
....@@ -949,8 +886,8 @@
949886 	if (!data->battery_low && data->irq) {
950887 		ret = _abb5zes3_rtc_battery_low_irq_enable(regmap, true);
951888 		if (ret) {
952
-			dev_err(dev, "%s: enabling battery low interrupt "
953
-				"generation failed (%d)\n", __func__, ret);
889
+			dev_err(dev, "%s: enabling battery low interrupt generation failed (%d)\n",
890
+				__func__, ret);
954891 			goto err;
955892 		}
956893 	}
....@@ -958,19 +895,9 @@
958895 	ret = rtc_register_device(data->rtc);
959896 
960897 err:
961
-	if (ret && data && data->irq)
898
+	if (ret && data->irq)
962899 		device_init_wakeup(dev, false);
963900 	return ret;
964
-}
965
-
966
-static int abb5zes3_remove(struct i2c_client *client)
967
-{
968
-	struct abb5zes3_rtc_data *rtc_data = dev_get_drvdata(&client->dev);
969
-
970
-	if (rtc_data->irq > 0)
971
-		device_init_wakeup(&client->dev, false);
972
-
973
-	return 0;
974901 }
975902 
976903 #ifdef CONFIG_PM_SLEEP
....@@ -1019,7 +946,6 @@
1019946 		.of_match_table = of_match_ptr(abb5zes3_dt_match),
1020947 	},
1021948 	.probe	  = abb5zes3_probe,
1022
-	.remove	  = abb5zes3_remove,
1023949 	.id_table = abb5zes3_id,
1024950 };
1025951 module_i2c_driver(abb5zes3_driver);