1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Real Time Clock (RTC) Driver for sd3078 |
4 | * Copyright (C) 2018 Zoro Li |
5 | */ |
6 | |
7 | #include <linux/bcd.h> |
8 | #include <linux/i2c.h> |
9 | #include <linux/module.h> |
10 | #include <linux/regmap.h> |
11 | #include <linux/rtc.h> |
12 | #include <linux/slab.h> |
13 | |
14 | #define SD3078_REG_SC 0x00 |
15 | #define SD3078_REG_MN 0x01 |
16 | #define SD3078_REG_HR 0x02 |
17 | #define SD3078_REG_DW 0x03 |
18 | #define SD3078_REG_DM 0x04 |
19 | #define SD3078_REG_MO 0x05 |
20 | #define SD3078_REG_YR 0x06 |
21 | |
22 | #define SD3078_REG_CTRL1 0x0f |
23 | #define SD3078_REG_CTRL2 0x10 |
24 | #define SD3078_REG_CTRL3 0x11 |
25 | |
26 | #define KEY_WRITE1 0x80 |
27 | #define KEY_WRITE2 0x04 |
28 | #define KEY_WRITE3 0x80 |
29 | |
30 | #define NUM_TIME_REGS (SD3078_REG_YR - SD3078_REG_SC + 1) |
31 | |
32 | /* |
33 | * The sd3078 has write protection |
34 | * and we can choose whether or not to use it. |
35 | * Write protection is turned off by default. |
36 | */ |
37 | #define WRITE_PROTECT_EN 0 |
38 | |
39 | struct sd3078 { |
40 | struct rtc_device *rtc; |
41 | struct regmap *regmap; |
42 | }; |
43 | |
44 | /* |
45 | * In order to prevent arbitrary modification of the time register, |
46 | * when modification of the register, |
47 | * the "write" bit needs to be written in a certain order. |
48 | * 1. set WRITE1 bit |
49 | * 2. set WRITE2 bit |
50 | * 3. set WRITE3 bit |
51 | */ |
52 | static void sd3078_enable_reg_write(struct sd3078 *sd3078) |
53 | { |
54 | regmap_update_bits(map: sd3078->regmap, SD3078_REG_CTRL2, |
55 | KEY_WRITE1, KEY_WRITE1); |
56 | regmap_update_bits(map: sd3078->regmap, SD3078_REG_CTRL1, |
57 | KEY_WRITE2, KEY_WRITE2); |
58 | regmap_update_bits(map: sd3078->regmap, SD3078_REG_CTRL1, |
59 | KEY_WRITE3, KEY_WRITE3); |
60 | } |
61 | |
62 | #if WRITE_PROTECT_EN |
63 | /* |
64 | * In order to prevent arbitrary modification of the time register, |
65 | * we should disable the write function. |
66 | * when disable write, |
67 | * the "write" bit needs to be clear in a certain order. |
68 | * 1. clear WRITE2 bit |
69 | * 2. clear WRITE3 bit |
70 | * 3. clear WRITE1 bit |
71 | */ |
72 | static void sd3078_disable_reg_write(struct sd3078 *sd3078) |
73 | { |
74 | regmap_update_bits(sd3078->regmap, SD3078_REG_CTRL1, |
75 | KEY_WRITE2, 0); |
76 | regmap_update_bits(sd3078->regmap, SD3078_REG_CTRL1, |
77 | KEY_WRITE3, 0); |
78 | regmap_update_bits(sd3078->regmap, SD3078_REG_CTRL2, |
79 | KEY_WRITE1, 0); |
80 | } |
81 | #endif |
82 | |
83 | static int sd3078_rtc_read_time(struct device *dev, struct rtc_time *tm) |
84 | { |
85 | unsigned char hour; |
86 | unsigned char rtc_data[NUM_TIME_REGS] = {0}; |
87 | struct i2c_client *client = to_i2c_client(dev); |
88 | struct sd3078 *sd3078 = i2c_get_clientdata(client); |
89 | int ret; |
90 | |
91 | ret = regmap_bulk_read(map: sd3078->regmap, SD3078_REG_SC, val: rtc_data, |
92 | NUM_TIME_REGS); |
93 | if (ret < 0) { |
94 | dev_err(dev, "reading from RTC failed with err:%d\n" , ret); |
95 | return ret; |
96 | } |
97 | |
98 | tm->tm_sec = bcd2bin(rtc_data[SD3078_REG_SC] & 0x7F); |
99 | tm->tm_min = bcd2bin(rtc_data[SD3078_REG_MN] & 0x7F); |
100 | |
101 | /* |
102 | * The sd3078 supports 12/24 hour mode. |
103 | * When getting time, |
104 | * we need to convert the 12 hour mode to the 24 hour mode. |
105 | */ |
106 | hour = rtc_data[SD3078_REG_HR]; |
107 | if (hour & 0x80) /* 24H MODE */ |
108 | tm->tm_hour = bcd2bin(rtc_data[SD3078_REG_HR] & 0x3F); |
109 | else if (hour & 0x20) /* 12H MODE PM */ |
110 | tm->tm_hour = bcd2bin(rtc_data[SD3078_REG_HR] & 0x1F) + 12; |
111 | else /* 12H MODE AM */ |
112 | tm->tm_hour = bcd2bin(rtc_data[SD3078_REG_HR] & 0x1F); |
113 | |
114 | tm->tm_mday = bcd2bin(rtc_data[SD3078_REG_DM] & 0x3F); |
115 | tm->tm_wday = rtc_data[SD3078_REG_DW] & 0x07; |
116 | tm->tm_mon = bcd2bin(rtc_data[SD3078_REG_MO] & 0x1F) - 1; |
117 | tm->tm_year = bcd2bin(rtc_data[SD3078_REG_YR]) + 100; |
118 | |
119 | return 0; |
120 | } |
121 | |
122 | static int sd3078_rtc_set_time(struct device *dev, struct rtc_time *tm) |
123 | { |
124 | unsigned char rtc_data[NUM_TIME_REGS]; |
125 | struct i2c_client *client = to_i2c_client(dev); |
126 | struct sd3078 *sd3078 = i2c_get_clientdata(client); |
127 | int ret; |
128 | |
129 | rtc_data[SD3078_REG_SC] = bin2bcd(tm->tm_sec); |
130 | rtc_data[SD3078_REG_MN] = bin2bcd(tm->tm_min); |
131 | rtc_data[SD3078_REG_HR] = bin2bcd(tm->tm_hour) | 0x80; |
132 | rtc_data[SD3078_REG_DM] = bin2bcd(tm->tm_mday); |
133 | rtc_data[SD3078_REG_DW] = tm->tm_wday & 0x07; |
134 | rtc_data[SD3078_REG_MO] = bin2bcd(tm->tm_mon) + 1; |
135 | rtc_data[SD3078_REG_YR] = bin2bcd(tm->tm_year - 100); |
136 | |
137 | #if WRITE_PROTECT_EN |
138 | sd3078_enable_reg_write(sd3078); |
139 | #endif |
140 | |
141 | ret = regmap_bulk_write(map: sd3078->regmap, SD3078_REG_SC, val: rtc_data, |
142 | NUM_TIME_REGS); |
143 | if (ret < 0) { |
144 | dev_err(dev, "writing to RTC failed with err:%d\n" , ret); |
145 | return ret; |
146 | } |
147 | |
148 | #if WRITE_PROTECT_EN |
149 | sd3078_disable_reg_write(sd3078); |
150 | #endif |
151 | |
152 | return 0; |
153 | } |
154 | |
155 | static const struct rtc_class_ops sd3078_rtc_ops = { |
156 | .read_time = sd3078_rtc_read_time, |
157 | .set_time = sd3078_rtc_set_time, |
158 | }; |
159 | |
160 | static const struct regmap_config regmap_config = { |
161 | .reg_bits = 8, |
162 | .val_bits = 8, |
163 | .max_register = 0x11, |
164 | }; |
165 | |
166 | static int sd3078_probe(struct i2c_client *client) |
167 | { |
168 | int ret; |
169 | struct sd3078 *sd3078; |
170 | |
171 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_I2C)) |
172 | return -ENODEV; |
173 | |
174 | sd3078 = devm_kzalloc(dev: &client->dev, size: sizeof(*sd3078), GFP_KERNEL); |
175 | if (!sd3078) |
176 | return -ENOMEM; |
177 | |
178 | sd3078->regmap = devm_regmap_init_i2c(client, ®map_config); |
179 | if (IS_ERR(ptr: sd3078->regmap)) { |
180 | dev_err(&client->dev, "regmap allocation failed\n" ); |
181 | return PTR_ERR(ptr: sd3078->regmap); |
182 | } |
183 | |
184 | i2c_set_clientdata(client, data: sd3078); |
185 | |
186 | sd3078->rtc = devm_rtc_allocate_device(dev: &client->dev); |
187 | if (IS_ERR(ptr: sd3078->rtc)) |
188 | return PTR_ERR(ptr: sd3078->rtc); |
189 | |
190 | sd3078->rtc->ops = &sd3078_rtc_ops; |
191 | sd3078->rtc->range_min = RTC_TIMESTAMP_BEGIN_2000; |
192 | sd3078->rtc->range_max = RTC_TIMESTAMP_END_2099; |
193 | |
194 | ret = devm_rtc_register_device(sd3078->rtc); |
195 | if (ret) |
196 | return ret; |
197 | |
198 | sd3078_enable_reg_write(sd3078); |
199 | |
200 | return 0; |
201 | } |
202 | |
203 | static const struct i2c_device_id sd3078_id[] = { |
204 | {"sd3078" , 0}, |
205 | { } |
206 | }; |
207 | MODULE_DEVICE_TABLE(i2c, sd3078_id); |
208 | |
209 | static const __maybe_unused struct of_device_id rtc_dt_match[] = { |
210 | { .compatible = "whwave,sd3078" }, |
211 | {}, |
212 | }; |
213 | MODULE_DEVICE_TABLE(of, rtc_dt_match); |
214 | |
215 | static struct i2c_driver sd3078_driver = { |
216 | .driver = { |
217 | .name = "sd3078" , |
218 | .of_match_table = of_match_ptr(rtc_dt_match), |
219 | }, |
220 | .probe = sd3078_probe, |
221 | .id_table = sd3078_id, |
222 | }; |
223 | |
224 | module_i2c_driver(sd3078_driver); |
225 | |
226 | MODULE_AUTHOR("Dianlong Li <long17.cool@163.com>" ); |
227 | MODULE_DESCRIPTION("SD3078 RTC driver" ); |
228 | MODULE_LICENSE("GPL v2" ); |
229 | |