forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2024-02-20 102a0743326a03cd1a1202ceda21e175b7d3575c 
 kernel/drivers/rtc/rtc-cmos.c
....@@ -750,6 +750,168 @@
750750 		return IRQ_NONE;
751751 }
752752 
753
+#ifdef	CONFIG_ACPI
754
+
755
+#include <linux/acpi.h>
756
+
757
+static u32 rtc_handler(void *context)
758
+{
759
+	struct device *dev = context;
760
+	struct cmos_rtc *cmos = dev_get_drvdata(dev);
761
+	unsigned char rtc_control = 0;
762
+	unsigned char rtc_intr;
763
+	unsigned long flags;
764
+
765
+
766
+	/*
767
+	 * Always update rtc irq when ACPI is used as RTC Alarm.
768
+	 * Or else, ACPI SCI is enabled during suspend/resume only,
769
+	 * update rtc irq in that case.
770
+	 */
771
+	if (cmos_use_acpi_alarm())
772
+		cmos_interrupt(0, (void *)cmos->rtc);
773
+	else {
774
+		/* Fix me: can we use cmos_interrupt() here as well? */
775
+		spin_lock_irqsave(&rtc_lock, flags);
776
+		if (cmos_rtc.suspend_ctrl)
777
+			rtc_control = CMOS_READ(RTC_CONTROL);
778
+		if (rtc_control & RTC_AIE) {
779
+			cmos_rtc.suspend_ctrl &= ~RTC_AIE;
780
+			CMOS_WRITE(rtc_control, RTC_CONTROL);
781
+			rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
782
+			rtc_update_irq(cmos->rtc, 1, rtc_intr);
783
+		}
784
+		spin_unlock_irqrestore(&rtc_lock, flags);
785
+	}
786
+
787
+	pm_wakeup_hard_event(dev);
788
+	acpi_clear_event(ACPI_EVENT_RTC);
789
+	acpi_disable_event(ACPI_EVENT_RTC, 0);
790
+	return ACPI_INTERRUPT_HANDLED;
791
+}
792
+
793
+static void acpi_rtc_event_setup(struct device *dev)
794
+{
795
+	if (acpi_disabled)
796
+		return;
797
+
798
+	acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, dev);
799
+	/*
800
+	 * After the RTC handler is installed, the Fixed_RTC event should
801
+	 * be disabled. Only when the RTC alarm is set will it be enabled.
802
+	 */
803
+	acpi_clear_event(ACPI_EVENT_RTC);
804
+	acpi_disable_event(ACPI_EVENT_RTC, 0);
805
+}
806
+
807
+static void acpi_rtc_event_cleanup(void)
808
+{
809
+	if (acpi_disabled)
810
+		return;
811
+
812
+	acpi_remove_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler);
813
+}
814
+
815
+static void rtc_wake_on(struct device *dev)
816
+{
817
+	acpi_clear_event(ACPI_EVENT_RTC);
818
+	acpi_enable_event(ACPI_EVENT_RTC, 0);
819
+}
820
+
821
+static void rtc_wake_off(struct device *dev)
822
+{
823
+	acpi_disable_event(ACPI_EVENT_RTC, 0);
824
+}
825
+
826
+#ifdef CONFIG_X86
827
+/* Enable use_acpi_alarm mode for Intel platforms no earlier than 2015 */
828
+static void use_acpi_alarm_quirks(void)
829
+{
830
+	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
831
+		return;
832
+
833
+	if (!is_hpet_enabled())
834
+		return;
835
+
836
+	if (dmi_get_bios_year() < 2015)
837
+		return;
838
+
839
+	use_acpi_alarm = true;
840
+}
841
+#else
842
+static inline void use_acpi_alarm_quirks(void) { }
843
+#endif
844
+
845
+static void acpi_cmos_wake_setup(struct device *dev)
846
+{
847
+	if (acpi_disabled)
848
+		return;
849
+
850
+	use_acpi_alarm_quirks();
851
+
852
+	cmos_rtc.wake_on = rtc_wake_on;
853
+	cmos_rtc.wake_off = rtc_wake_off;
854
+
855
+	/* ACPI tables bug workaround. */
856
+	if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
857
+		dev_dbg(dev, "bogus FADT month_alarm (%d)\n",
858
+			acpi_gbl_FADT.month_alarm);
859
+		acpi_gbl_FADT.month_alarm = 0;
860
+	}
861
+
862
+	cmos_rtc.day_alrm = acpi_gbl_FADT.day_alarm;
863
+	cmos_rtc.mon_alrm = acpi_gbl_FADT.month_alarm;
864
+	cmos_rtc.century = acpi_gbl_FADT.century;
865
+
866
+	if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
867
+		dev_info(dev, "RTC can wake from S4\n");
868
+
869
+	/* RTC always wakes from S1/S2/S3, and often S4/STD */
870
+	device_init_wakeup(dev, 1);
871
+}
872
+
873
+static void cmos_check_acpi_rtc_status(struct device *dev,
874
+					      unsigned char *rtc_control)
875
+{
876
+	struct cmos_rtc *cmos = dev_get_drvdata(dev);
877
+	acpi_event_status rtc_status;
878
+	acpi_status status;
879
+
880
+	if (acpi_gbl_FADT.flags & ACPI_FADT_FIXED_RTC)
881
+		return;
882
+
883
+	status = acpi_get_event_status(ACPI_EVENT_RTC, &rtc_status);
884
+	if (ACPI_FAILURE(status)) {
885
+		dev_err(dev, "Could not get RTC status\n");
886
+	} else if (rtc_status & ACPI_EVENT_FLAG_SET) {
887
+		unsigned char mask;
888
+		*rtc_control &= ~RTC_AIE;
889
+		CMOS_WRITE(*rtc_control, RTC_CONTROL);
890
+		mask = CMOS_READ(RTC_INTR_FLAGS);
891
+		rtc_update_irq(cmos->rtc, 1, mask);
892
+	}
893
+}
894
+
895
+#else /* !CONFIG_ACPI */
896
+
897
+static inline void acpi_rtc_event_setup(struct device *dev)
898
+{
899
+}
900
+
901
+static inline void acpi_rtc_event_cleanup(void)
902
+{
903
+}
904
+
905
+static inline void acpi_cmos_wake_setup(struct device *dev)
906
+{
907
+}
908
+
909
+static inline void cmos_check_acpi_rtc_status(struct device *dev,
910
+					      unsigned char *rtc_control)
911
+{
912
+}
913
+#endif /* CONFIG_ACPI */
914
+
753915 #ifdef	CONFIG_PNP
754916 #define	INITSECTION
755917 
....@@ -833,18 +995,26 @@
833995 		if (info->address_space)
834996 			address_space = info->address_space;
835997 
836
-		if (info->rtc_day_alarm && info->rtc_day_alarm < 128)
837
-			cmos_rtc.day_alrm = info->rtc_day_alarm;
838
-		if (info->rtc_mon_alarm && info->rtc_mon_alarm < 128)
839
-			cmos_rtc.mon_alrm = info->rtc_mon_alarm;
840
-		if (info->rtc_century && info->rtc_century < 128)
841
-			cmos_rtc.century = info->rtc_century;
998
+		cmos_rtc.day_alrm = info->rtc_day_alarm;
999
+		cmos_rtc.mon_alrm = info->rtc_mon_alarm;
1000
+		cmos_rtc.century = info->rtc_century;
8421001 
8431002 		if (info->wake_on && info->wake_off) {
8441003 			cmos_rtc.wake_on = info->wake_on;
8451004 			cmos_rtc.wake_off = info->wake_off;
8461005 		}
1006
+	} else {
1007
+		acpi_cmos_wake_setup(dev);
8471008 	}
1009
+
1010
+	if (cmos_rtc.day_alrm >= 128)
1011
+		cmos_rtc.day_alrm = 0;
1012
+
1013
+	if (cmos_rtc.mon_alrm >= 128)
1014
+		cmos_rtc.mon_alrm = 0;
1015
+
1016
+	if (cmos_rtc.century >= 128)
1017
+		cmos_rtc.century = 0;
8481018 
8491019 	cmos_rtc.dev = dev;
8501020 	dev_set_drvdata(dev, &cmos_rtc);
....@@ -933,6 +1103,13 @@
9331103 	if (rtc_nvmem_register(cmos_rtc.rtc, &nvmem_cfg))
9341104 		dev_err(dev, "nvmem registration failed\n");
9351105 
1106
+	/*
1107
+	 * Everything has gone well so far, so by default register a handler for
1108
+	 * the ACPI RTC fixed event.
1109
+	 */
1110
+	if (!info)
1111
+		acpi_rtc_event_setup(dev);
1112
+
9361113 	dev_info(dev, "%s%s, %d bytes nvram%s\n",
9371114 		 !is_valid_irq(rtc_irq) ? "no alarms" :
9381115 		 cmos_rtc.mon_alrm ? "alarms up to one year" :
....@@ -977,6 +1154,9 @@
9771154 		if (use_hpet_alarm())
9781155 			hpet_unregister_irq_handler(cmos_interrupt);
9791156 	}
1157
+
1158
+	if (!dev_get_platdata(dev))
1159
+		acpi_rtc_event_cleanup();
9801160 
9811161 	cmos->rtc = NULL;
9821162 
....@@ -1127,9 +1307,6 @@
11271307 	}
11281308 }
11291309 
1130
-static void cmos_check_acpi_rtc_status(struct device *dev,
1131
-				       unsigned char *rtc_control);
1132
-
11331310 static int __maybe_unused cmos_resume(struct device *dev)
11341311 {
11351312 	struct cmos_rtc	*cmos = dev_get_drvdata(dev);
....@@ -1196,174 +1373,16 @@
11961373  * predate even PNPBIOS should set up platform_bus devices.
11971374  */
11981375 
1199
-#ifdef	CONFIG_ACPI
1200
-
1201
-#include <linux/acpi.h>
1202
-
1203
-static u32 rtc_handler(void *context)
1204
-{
1205
-	struct device *dev = context;
1206
-	struct cmos_rtc *cmos = dev_get_drvdata(dev);
1207
-	unsigned char rtc_control = 0;
1208
-	unsigned char rtc_intr;
1209
-	unsigned long flags;
1210
-
1211
-
1212
-	/*
1213
-	 * Always update rtc irq when ACPI is used as RTC Alarm.
1214
-	 * Or else, ACPI SCI is enabled during suspend/resume only,
1215
-	 * update rtc irq in that case.
1216
-	 */
1217
-	if (cmos_use_acpi_alarm())
1218
-		cmos_interrupt(0, (void *)cmos->rtc);
1219
-	else {
1220
-		/* Fix me: can we use cmos_interrupt() here as well? */
1221
-		spin_lock_irqsave(&rtc_lock, flags);
1222
-		if (cmos_rtc.suspend_ctrl)
1223
-			rtc_control = CMOS_READ(RTC_CONTROL);
1224
-		if (rtc_control & RTC_AIE) {
1225
-			cmos_rtc.suspend_ctrl &= ~RTC_AIE;
1226
-			CMOS_WRITE(rtc_control, RTC_CONTROL);
1227
-			rtc_intr = CMOS_READ(RTC_INTR_FLAGS);
1228
-			rtc_update_irq(cmos->rtc, 1, rtc_intr);
1229
-		}
1230
-		spin_unlock_irqrestore(&rtc_lock, flags);
1231
-	}
1232
-
1233
-	pm_wakeup_hard_event(dev);
1234
-	acpi_clear_event(ACPI_EVENT_RTC);
1235
-	acpi_disable_event(ACPI_EVENT_RTC, 0);
1236
-	return ACPI_INTERRUPT_HANDLED;
1237
-}
1238
-
1239
-static inline void rtc_wake_setup(struct device *dev)
1240
-{
1241
-	acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, dev);
1242
-	/*
1243
-	 * After the RTC handler is installed, the Fixed_RTC event should
1244
-	 * be disabled. Only when the RTC alarm is set will it be enabled.
1245
-	 */
1246
-	acpi_clear_event(ACPI_EVENT_RTC);
1247
-	acpi_disable_event(ACPI_EVENT_RTC, 0);
1248
-}
1249
-
1250
-static void rtc_wake_on(struct device *dev)
1251
-{
1252
-	acpi_clear_event(ACPI_EVENT_RTC);
1253
-	acpi_enable_event(ACPI_EVENT_RTC, 0);
1254
-}
1255
-
1256
-static void rtc_wake_off(struct device *dev)
1257
-{
1258
-	acpi_disable_event(ACPI_EVENT_RTC, 0);
1259
-}
1260
-
1261
-#ifdef CONFIG_X86
1262
-/* Enable use_acpi_alarm mode for Intel platforms no earlier than 2015 */
1263
-static void use_acpi_alarm_quirks(void)
1264
-{
1265
-	if (boot_cpu_data.x86_vendor != X86_VENDOR_INTEL)
1266
-		return;
1267
-
1268
-	if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))
1269
-		return;
1270
-
1271
-	if (!is_hpet_enabled())
1272
-		return;
1273
-
1274
-	if (dmi_get_bios_year() < 2015)
1275
-		return;
1276
-
1277
-	use_acpi_alarm = true;
1278
-}
1279
-#else
1280
-static inline void use_acpi_alarm_quirks(void) { }
1281
-#endif
1282
-
1283
-/* Every ACPI platform has a mc146818 compatible "cmos rtc".  Here we find
1284
- * its device node and pass extra config data.  This helps its driver use
1285
- * capabilities that the now-obsolete mc146818 didn't have, and informs it
1286
- * that this board's RTC is wakeup-capable (per ACPI spec).
1287
- */
1288
-static struct cmos_rtc_board_info acpi_rtc_info;
1289
-
1290
-static void cmos_wake_setup(struct device *dev)
1291
-{
1292
-	if (acpi_disabled)
1293
-		return;
1294
-
1295
-	use_acpi_alarm_quirks();
1296
-
1297
-	rtc_wake_setup(dev);
1298
-	acpi_rtc_info.wake_on = rtc_wake_on;
1299
-	acpi_rtc_info.wake_off = rtc_wake_off;
1300
-
1301
-	/* workaround bug in some ACPI tables */
1302
-	if (acpi_gbl_FADT.month_alarm && !acpi_gbl_FADT.day_alarm) {
1303
-		dev_dbg(dev, "bogus FADT month_alarm (%d)\n",
1304
-			acpi_gbl_FADT.month_alarm);
1305
-		acpi_gbl_FADT.month_alarm = 0;
1306
-	}
1307
-
1308
-	acpi_rtc_info.rtc_day_alarm = acpi_gbl_FADT.day_alarm;
1309
-	acpi_rtc_info.rtc_mon_alarm = acpi_gbl_FADT.month_alarm;
1310
-	acpi_rtc_info.rtc_century = acpi_gbl_FADT.century;
1311
-
1312
-	/* NOTE:  S4_RTC_WAKE is NOT currently useful to Linux */
1313
-	if (acpi_gbl_FADT.flags & ACPI_FADT_S4_RTC_WAKE)
1314
-		dev_info(dev, "RTC can wake from S4\n");
1315
-
1316
-	dev->platform_data = &acpi_rtc_info;
1317
-
1318
-	/* RTC always wakes from S1/S2/S3, and often S4/STD */
1319
-	device_init_wakeup(dev, 1);
1320
-}
1321
-
1322
-static void cmos_check_acpi_rtc_status(struct device *dev,
1323
-				       unsigned char *rtc_control)
1324
-{
1325
-	struct cmos_rtc *cmos = dev_get_drvdata(dev);
1326
-	acpi_event_status rtc_status;
1327
-	acpi_status status;
1328
-
1329
-	if (acpi_gbl_FADT.flags & ACPI_FADT_FIXED_RTC)
1330
-		return;
1331
-
1332
-	status = acpi_get_event_status(ACPI_EVENT_RTC, &rtc_status);
1333
-	if (ACPI_FAILURE(status)) {
1334
-		dev_err(dev, "Could not get RTC status\n");
1335
-	} else if (rtc_status & ACPI_EVENT_FLAG_SET) {
1336
-		unsigned char mask;
1337
-		*rtc_control &= ~RTC_AIE;
1338
-		CMOS_WRITE(*rtc_control, RTC_CONTROL);
1339
-		mask = CMOS_READ(RTC_INTR_FLAGS);
1340
-		rtc_update_irq(cmos->rtc, 1, mask);
1341
-	}
1342
-}
1343
-
1344
-#else
1345
-
1346
-static void cmos_wake_setup(struct device *dev)
1347
-{
1348
-}
1349
-
1350
-static void cmos_check_acpi_rtc_status(struct device *dev,
1351
-				       unsigned char *rtc_control)
1352
-{
1353
-}
1354
-
1355
-#endif
1356
-
13571376 #ifdef	CONFIG_PNP
13581377 
13591378 #include <linux/pnp.h>
13601379 
13611380 static int cmos_pnp_probe(struct pnp_dev *pnp, const struct pnp_device_id *id)
13621381 {
1363
-	cmos_wake_setup(&pnp->dev);
1382
+	int irq;
13641383 
13651384 	if (pnp_port_start(pnp, 0) == 0x70 && !pnp_irq_valid(pnp, 0)) {
1366
-		unsigned int irq = 0;
1385
+		irq = 0;
13671386 #ifdef CONFIG_X86
13681387 		/* Some machines contain a PNP entry for the RTC, but
13691388 		 * don't define the IRQ. It should always be safe to
....@@ -1372,13 +1391,11 @@
13721391 		if (nr_legacy_irqs())
13731392 			irq = RTC_IRQ;
13741393 #endif
1375
-		return cmos_do_probe(&pnp->dev,
1376
-				pnp_get_resource(pnp, IORESOURCE_IO, 0), irq);
13771394 	} else {
1378
-		return cmos_do_probe(&pnp->dev,
1379
-				pnp_get_resource(pnp, IORESOURCE_IO, 0),
1380
-				pnp_irq(pnp, 0));
1395
+		irq = pnp_irq(pnp, 0);
13811396 	}
1397
+
1398
+	return cmos_do_probe(&pnp->dev, pnp_get_resource(pnp, IORESOURCE_IO, 0), irq);
13821399 }
13831400 
13841401 static void cmos_pnp_remove(struct pnp_dev *pnp)
....@@ -1465,7 +1482,6 @@
14651482 	int irq;
14661483 
14671484 	cmos_of_init(pdev);
1468
-	cmos_wake_setup(&pdev->dev);
14691485 
14701486 	if (RTC_IOMAPPED)
14711487 		resource = platform_get_resource(pdev, IORESOURCE_IO, 0);