summaryrefslogtreecommitdiffstats
path: root/drivers/rtc/rtc-loongson.c
blob: e8ffc1ab90b02fbf6a383efaa79ea57cee4ae67b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Loongson RTC driver
 *
 * Maintained out-of-tree by Huacai Chen <chenhuacai@kernel.org>.
 * Rewritten for mainline by WANG Xuerui <git@xen0n.name>.
 *                           Binbin Zhou <zhoubinbin@loongson.cn>
 */

#include <linux/bitfield.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/rtc.h>
#include <linux/acpi.h>

/* Time Of Year(TOY) counters registers */
#define TOY_TRIM_REG		0x20 /* Must be initialized to 0 */
#define TOY_WRITE0_REG		0x24 /* TOY low 32-bits value (write-only) */
#define TOY_WRITE1_REG		0x28 /* TOY high 32-bits value (write-only) */
#define TOY_READ0_REG		0x2c /* TOY low 32-bits value (read-only) */
#define TOY_READ1_REG		0x30 /* TOY high 32-bits value (read-only) */
#define TOY_MATCH0_REG		0x34 /* TOY timing interrupt 0 */
#define TOY_MATCH1_REG		0x38 /* TOY timing interrupt 1 */
#define TOY_MATCH2_REG		0x3c /* TOY timing interrupt 2 */

/* RTC counters registers */
#define RTC_CTRL_REG		0x40 /* TOY and RTC control register */
#define RTC_TRIM_REG		0x60 /* Must be initialized to 0 */
#define RTC_WRITE0_REG		0x64 /* RTC counters value (write-only) */
#define RTC_READ0_REG		0x68 /* RTC counters value (read-only) */
#define RTC_MATCH0_REG		0x6c /* RTC timing interrupt 0 */
#define RTC_MATCH1_REG		0x70 /* RTC timing interrupt 1 */
#define RTC_MATCH2_REG		0x74 /* RTC timing interrupt 2 */

/* bitmask of TOY_WRITE0_REG */
#define TOY_MON			GENMASK(31, 26)
#define TOY_DAY			GENMASK(25, 21)
#define TOY_HOUR		GENMASK(20, 16)
#define TOY_MIN			GENMASK(15, 10)
#define TOY_SEC			GENMASK(9, 4)
#define TOY_MSEC		GENMASK(3, 0)

/* bitmask of TOY_MATCH0/1/2_REG */
#define TOY_MATCH_YEAR		GENMASK(31, 26)
#define TOY_MATCH_MON		GENMASK(25, 22)
#define TOY_MATCH_DAY		GENMASK(21, 17)
#define TOY_MATCH_HOUR		GENMASK(16, 12)
#define TOY_MATCH_MIN		GENMASK(11, 6)
#define TOY_MATCH_SEC		GENMASK(5, 0)

/* bitmask of RTC_CTRL_REG */
#define RTC_ENABLE		BIT(13) /* 1: RTC counters enable */
#define TOY_ENABLE		BIT(11) /* 1: TOY counters enable */
#define OSC_ENABLE		BIT(8) /* 1: 32.768k crystal enable */
#define TOY_ENABLE_MASK		(TOY_ENABLE | OSC_ENABLE)

/* PM domain registers */
#define PM1_STS_REG		0x0c	/* Power management 1 status register */
#define RTC_STS			BIT(10)	/* RTC status */
#define PM1_EN_REG		0x10	/* Power management 1 enable register */
#define RTC_EN			BIT(10)	/* RTC event enable */

/*
 * According to the LS1C manual, RTC_CTRL and alarm-related registers are not defined.
 * Accessing the relevant registers will cause the system to hang.
 */
#define LS1C_RTC_CTRL_WORKAROUND	BIT(0)

struct loongson_rtc_config {
	u32 pm_offset;	/* Offset of PM domain, for RTC alarm wakeup */
	u32 flags;	/* Workaround bits */
};

struct loongson_rtc_priv {
	spinlock_t lock;	/* protects PM registers access */
	u32 fix_year;		/* RTC alarm year compensation value */
	struct rtc_device *rtcdev;
	struct regmap *regmap;
	void __iomem *pm_base;	/* PM domain base, for RTC alarm wakeup */
	const struct loongson_rtc_config *config;
};

static const struct loongson_rtc_config ls1b_rtc_config = {
	.pm_offset = 0,
	.flags = 0,
};

static const struct loongson_rtc_config ls1c_rtc_config = {
	.pm_offset = 0,
	.flags = LS1C_RTC_CTRL_WORKAROUND,
};

static const struct loongson_rtc_config generic_rtc_config = {
	.pm_offset = 0x100,
	.flags = 0,
};

static const struct loongson_rtc_config ls2k1000_rtc_config = {
	.pm_offset = 0x800,
	.flags = 0,
};

static const struct regmap_config loongson_rtc_regmap_config = {
	.reg_bits = 32,
	.val_bits = 32,
	.reg_stride = 4,
};

/* RTC alarm irq handler */
static irqreturn_t loongson_rtc_isr(int irq, void *id)
{
	struct loongson_rtc_priv *priv = (struct loongson_rtc_priv *)id;

	rtc_update_irq(priv->rtcdev, 1, RTC_AF | RTC_IRQF);
	return IRQ_HANDLED;
}

/* For ACPI fixed event handler */
static u32 loongson_rtc_handler(void *id)
{
	struct loongson_rtc_priv *priv = (struct loongson_rtc_priv *)id;

	spin_lock(&priv->lock);
	/* Disable RTC alarm wakeup and interrupt */
	writel(readl(priv->pm_base + PM1_EN_REG) & ~RTC_EN,
	       priv->pm_base + PM1_EN_REG);

	/* Clear RTC interrupt status */
	writel(RTC_STS, priv->pm_base + PM1_STS_REG);
	spin_unlock(&priv->lock);

	/*
	 * The TOY_MATCH0_REG should be cleared 0 here,
	 * otherwise the interrupt cannot be cleared.
	 */
	return regmap_write(priv->regmap, TOY_MATCH0_REG, 0);
}

static int loongson_rtc_set_enabled(struct device *dev)
{
	struct loongson_rtc_priv *priv = dev_get_drvdata(dev);

	if (priv->config->flags & LS1C_RTC_CTRL_WORKAROUND)
		return 0;

	/* Enable RTC TOY counters and crystal */
	return regmap_update_bits(priv->regmap, RTC_CTRL_REG, TOY_ENABLE_MASK,
				  TOY_ENABLE_MASK);
}

static bool loongson_rtc_get_enabled(struct device *dev)
{
	int ret;
	u32 ctrl_data;
	struct loongson_rtc_priv *priv = dev_get_drvdata(dev);

	if (priv->config->flags & LS1C_RTC_CTRL_WORKAROUND)
		return true;

	ret = regmap_read(priv->regmap, RTC_CTRL_REG, &ctrl_data);
	if (ret < 0)
		return false;

	return ctrl_data & TOY_ENABLE_MASK;
}

static int loongson_rtc_read_time(struct device *dev, struct rtc_time *tm)
{
	int ret;
	u32 rtc_data[2];
	struct loongson_rtc_priv *priv = dev_get_drvdata(dev);

	if (!loongson_rtc_get_enabled(dev))
		return -EINVAL;

	ret = regmap_bulk_read(priv->regmap, TOY_READ0_REG, rtc_data,
			       ARRAY_SIZE(rtc_data));
	if (ret < 0)
		return ret;

	tm->tm_sec = FIELD_GET(TOY_SEC, rtc_data[0]);
	tm->tm_min = FIELD_GET(TOY_MIN, rtc_data[0]);
	tm->tm_hour = FIELD_GET(TOY_HOUR, rtc_data[0]);
	tm->tm_mday = FIELD_GET(TOY_DAY, rtc_data[0]);
	tm->tm_mon = FIELD_GET(TOY_MON, rtc_data[0]) - 1;
	tm->tm_year = rtc_data[1];

	/* Prepare for RTC alarm year compensation value. */
	priv->fix_year = tm->tm_year / 64 * 64;
	return 0;
}

static int loongson_rtc_set_time(struct device *dev, struct rtc_time *tm)
{
	int ret;
	u32 rtc_data[2];
	struct loongson_rtc_priv *priv = dev_get_drvdata(dev);

	rtc_data[0] = FIELD_PREP(TOY_SEC, tm->tm_sec)
		    | FIELD_PREP(TOY_MIN, tm->tm_min)
		    | FIELD_PREP(TOY_HOUR, tm->tm_hour)
		    | FIELD_PREP(TOY_DAY, tm->tm_mday)
		    | FIELD_PREP(TOY_MON, tm->tm_mon + 1);
	rtc_data[1] = tm->tm_year;

	ret = regmap_bulk_write(priv->regmap, TOY_WRITE0_REG, rtc_data,
				ARRAY_SIZE(rtc_data));
	if (ret < 0)
		return ret;

	return loongson_rtc_set_enabled(dev);
}

static int loongson_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	int ret;
	u32 alarm_data;
	struct loongson_rtc_priv *priv = dev_get_drvdata(dev);

	ret = regmap_read(priv->regmap, TOY_MATCH0_REG, &alarm_data);
	if (ret < 0)
		return ret;

	alrm->time.tm_sec = FIELD_GET(TOY_MATCH_SEC, alarm_data);
	alrm->time.tm_min = FIELD_GET(TOY_MATCH_MIN, alarm_data);
	alrm->time.tm_hour = FIELD_GET(TOY_MATCH_HOUR, alarm_data);
	alrm->time.tm_mday = FIELD_GET(TOY_MATCH_DAY, alarm_data);
	alrm->time.tm_mon = FIELD_GET(TOY_MATCH_MON, alarm_data) - 1;
	/*
	 * This is a hardware bug: the year field of SYS_TOYMATCH is only 6 bits,
	 * making it impossible to save year values larger than 64.
	 *
	 * SYS_TOYMATCH is used to match the alarm time value and determine if
	 * an alarm is triggered, so we must keep the lower 6 bits of the year
	 * value constant during the value conversion.
	 *
	 * In summary, we need to manually add 64(or a multiple of 64) to the
	 * year value to avoid the invalid alarm prompt at startup.
	 */
	alrm->time.tm_year = FIELD_GET(TOY_MATCH_YEAR, alarm_data) + priv->fix_year;

	alrm->enabled = !!(readl(priv->pm_base + PM1_EN_REG) & RTC_EN);
	return 0;
}

static int loongson_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
{
	u32 val;
	struct loongson_rtc_priv *priv = dev_get_drvdata(dev);

	spin_lock(&priv->lock);
	val = readl(priv->pm_base + PM1_EN_REG);
	/* Enable RTC alarm wakeup */
	writel(enabled ? val | RTC_EN : val & ~RTC_EN,
	       priv->pm_base + PM1_EN_REG);
	spin_unlock(&priv->lock);

	return 0;
}

static int loongson_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
{
	int ret;
	u32 alarm_data;
	struct loongson_rtc_priv *priv = dev_get_drvdata(dev);

	alarm_data = FIELD_PREP(TOY_MATCH_SEC, alrm->time.tm_sec)
		   | FIELD_PREP(TOY_MATCH_MIN, alrm->time.tm_min)
		   | FIELD_PREP(TOY_MATCH_HOUR, alrm->time.tm_hour)
		   | FIELD_PREP(TOY_MATCH_DAY, alrm->time.tm_mday)
		   | FIELD_PREP(TOY_MATCH_MON, alrm->time.tm_mon + 1)
		   | FIELD_PREP(TOY_MATCH_YEAR, alrm->time.tm_year - priv->fix_year);

	ret = regmap_write(priv->regmap, TOY_MATCH0_REG, alarm_data);
	if (ret < 0)
		return ret;

	return loongson_rtc_alarm_irq_enable(dev, alrm->enabled);
}

static const struct rtc_class_ops loongson_rtc_ops = {
	.read_time = loongson_rtc_read_time,
	.set_time = loongson_rtc_set_time,
	.read_alarm = loongson_rtc_read_alarm,
	.set_alarm = loongson_rtc_set_alarm,
	.alarm_irq_enable = loongson_rtc_alarm_irq_enable,
};

static int loongson_rtc_probe(struct platform_device *pdev)
{
	int ret, alarm_irq;
	void __iomem *regs;
	struct loongson_rtc_priv *priv;
	struct device *dev = &pdev->dev;

	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	regs = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(regs))
		return dev_err_probe(dev, PTR_ERR(regs),
				     "devm_platform_ioremap_resource failed\n");

	priv->regmap = devm_regmap_init_mmio(dev, regs,
					     &loongson_rtc_regmap_config);
	if (IS_ERR(priv->regmap))
		return dev_err_probe(dev, PTR_ERR(priv->regmap),
				     "devm_regmap_init_mmio failed\n");

	priv->config = device_get_match_data(dev);
	spin_lock_init(&priv->lock);
	platform_set_drvdata(pdev, priv);

	priv->rtcdev = devm_rtc_allocate_device(dev);
	if (IS_ERR(priv->rtcdev))
		return dev_err_probe(dev, PTR_ERR(priv->rtcdev),
				     "devm_rtc_allocate_device failed\n");

	/* Get RTC alarm irq */
	alarm_irq = platform_get_irq(pdev, 0);
	if (alarm_irq > 0) {
		ret = devm_request_irq(dev, alarm_irq, loongson_rtc_isr,
				       0, "loongson-alarm", priv);
		if (ret < 0)
			return dev_err_probe(dev, ret, "Unable to request irq %d\n",
					     alarm_irq);

		priv->pm_base = regs - priv->config->pm_offset;
		device_init_wakeup(dev, 1);

		if (has_acpi_companion(dev))
			acpi_install_fixed_event_handler(ACPI_EVENT_RTC,
							 loongson_rtc_handler, priv);
	} else {
		/* Loongson-1C RTC does not support alarm */
		clear_bit(RTC_FEATURE_ALARM, priv->rtcdev->features);
	}

	/* Loongson RTC does not support UIE */
	clear_bit(RTC_FEATURE_UPDATE_INTERRUPT, priv->rtcdev->features);
	priv->rtcdev->ops = &loongson_rtc_ops;
	priv->rtcdev->range_min = RTC_TIMESTAMP_BEGIN_2000;
	priv->rtcdev->range_max = RTC_TIMESTAMP_END_2099;

	return devm_rtc_register_device(priv->rtcdev);
}

static void loongson_rtc_remove(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct loongson_rtc_priv *priv = dev_get_drvdata(dev);

	if (!test_bit(RTC_FEATURE_ALARM, priv->rtcdev->features))
		return;

	if (has_acpi_companion(dev))
		acpi_remove_fixed_event_handler(ACPI_EVENT_RTC,
						loongson_rtc_handler);

	device_init_wakeup(dev, 0);
	loongson_rtc_alarm_irq_enable(dev, 0);
}

static const struct of_device_id loongson_rtc_of_match[] = {
	{ .compatible = "loongson,ls1b-rtc", .data = &ls1b_rtc_config },
	{ .compatible = "loongson,ls1c-rtc", .data = &ls1c_rtc_config },
	{ .compatible = "loongson,ls7a-rtc", .data = &generic_rtc_config },
	{ .compatible = "loongson,ls2k1000-rtc", .data = &ls2k1000_rtc_config },
	{ /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, loongson_rtc_of_match);

static const struct acpi_device_id loongson_rtc_acpi_match[] = {
	{ "LOON0001", .driver_data = (kernel_ulong_t)&generic_rtc_config },
	{ }
};
MODULE_DEVICE_TABLE(acpi, loongson_rtc_acpi_match);

static struct platform_driver loongson_rtc_driver = {
	.probe		= loongson_rtc_probe,
	.remove_new	= loongson_rtc_remove,
	.driver		= {
		.name	= "loongson-rtc",
		.of_match_table = loongson_rtc_of_match,
		.acpi_match_table = loongson_rtc_acpi_match,
	},
};
module_platform_driver(loongson_rtc_driver);

MODULE_DESCRIPTION("Loongson RTC driver");
MODULE_AUTHOR("Binbin Zhou <zhoubinbin@loongson.cn>");
MODULE_AUTHOR("WANG Xuerui <git@xen0n.name>");
MODULE_AUTHOR("Huacai Chen <chenhuacai@kernel.org>");
MODULE_LICENSE("GPL");