aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/rtc
diff options
context:
space:
mode:
authorMylène Josserand <mylene.josserand@free-electrons.com>2016-05-03 05:54:33 -0400
committerAlexandre Belloni <alexandre.belloni@free-electrons.com>2016-05-21 11:04:11 -0400
commite6e380821236b628a1379db97d777da3e36b8240 (patch)
tree515fdbb16fbc097783932a60f552d31df5a4e59d /drivers/rtc
parent4e7f1a6051d7d5a62021fde0c9ed7005a1a82307 (diff)
rtc: rv3029: convert to use regmap
To add support of rv3049, the current driver is converted to use regmap. Signed-off-by: Mylène Josserand <mylene.josserand@free-electrons.com> Signed-off-by: Alexandre Belloni <alexandre.belloni@free-electrons.com>
Diffstat (limited to 'drivers/rtc')
-rw-r--r--drivers/rtc/rtc-rv3029c2.c275
1 files changed, 142 insertions, 133 deletions
diff --git a/drivers/rtc/rtc-rv3029c2.c b/drivers/rtc/rtc-rv3029c2.c
index 091be483e3e9..96dd1665220c 100644
--- a/drivers/rtc/rtc-rv3029c2.c
+++ b/drivers/rtc/rtc-rv3029c2.c
@@ -20,7 +20,7 @@
20#include <linux/of.h> 20#include <linux/of.h>
21#include <linux/hwmon.h> 21#include <linux/hwmon.h>
22#include <linux/hwmon-sysfs.h> 22#include <linux/hwmon-sysfs.h>
23 23#include <linux/regmap.h>
24 24
25/* Register map */ 25/* Register map */
26/* control section */ 26/* control section */
@@ -116,81 +116,84 @@
116#define RV3029_USR2_RAM_PAGE 0x3C 116#define RV3029_USR2_RAM_PAGE 0x3C
117#define RV3029_USR2_SECTION_LEN 0x04 117#define RV3029_USR2_SECTION_LEN 0x04
118 118
119static int rv3029_read_regs(struct i2c_client *client, u8 reg, u8 *buf, 119struct rv3029_data {
120 struct device *dev;
121 struct rtc_device *rtc;
122 struct regmap *regmap;
123 int irq;
124};
125
126static int rv3029_read_regs(struct device *dev, u8 reg, u8 *buf,
120 unsigned len) 127 unsigned len)
121{ 128{
122 int ret; 129 struct rv3029_data *rv3029 = dev_get_drvdata(dev);
123 130
124 if ((reg > RV3029_USR1_RAM_PAGE + 7) || 131 if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
125 (reg + len > RV3029_USR1_RAM_PAGE + 8)) 132 (reg + len > RV3029_USR1_RAM_PAGE + 8))
126 return -EINVAL; 133 return -EINVAL;
127 134
128 ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf); 135 return regmap_bulk_read(rv3029->regmap, reg, buf, len);
129 if (ret < 0)
130 return ret;
131 if (ret < len)
132 return -EIO;
133 return 0;
134} 136}
135 137
136static int rv3029_write_regs(struct i2c_client *client, u8 reg, u8 const buf[], 138static int rv3029_write_regs(struct device *dev, u8 reg, u8 const buf[],
137 unsigned len) 139 unsigned len)
138{ 140{
141 struct rv3029_data *rv3029 = dev_get_drvdata(dev);
142
139 if ((reg > RV3029_USR1_RAM_PAGE + 7) || 143 if ((reg > RV3029_USR1_RAM_PAGE + 7) ||
140 (reg + len > RV3029_USR1_RAM_PAGE + 8)) 144 (reg + len > RV3029_USR1_RAM_PAGE + 8))
141 return -EINVAL; 145 return -EINVAL;
142 146
143 return i2c_smbus_write_i2c_block_data(client, reg, len, buf); 147 return regmap_bulk_write(rv3029->regmap, reg, buf, len);
144} 148}
145 149
146static int rv3029_update_bits(struct i2c_client *client, u8 reg, u8 mask, 150static int rv3029_update_bits(struct device *dev, u8 reg, u8 mask, u8 set)
147 u8 set)
148{ 151{
149 u8 buf; 152 u8 buf;
150 int ret; 153 int ret;
151 154
152 ret = rv3029_read_regs(client, reg, &buf, 1); 155 ret = rv3029_read_regs(dev, reg, &buf, 1);
153 if (ret < 0) 156 if (ret < 0)
154 return ret; 157 return ret;
155 buf &= ~mask; 158 buf &= ~mask;
156 buf |= set & mask; 159 buf |= set & mask;
157 ret = rv3029_write_regs(client, reg, &buf, 1); 160 ret = rv3029_write_regs(dev, reg, &buf, 1);
158 if (ret < 0) 161 if (ret < 0)
159 return ret; 162 return ret;
160 163
161 return 0; 164 return 0;
162} 165}
163 166
164static int rv3029_get_sr(struct i2c_client *client, u8 *buf) 167static int rv3029_get_sr(struct device *dev, u8 *buf)
165{ 168{
166 int ret = rv3029_read_regs(client, RV3029_STATUS, buf, 1); 169 int ret = rv3029_read_regs(dev, RV3029_STATUS, buf, 1);
167 170
168 if (ret < 0) 171 if (ret < 0)
169 return -EIO; 172 return -EIO;
170 dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]); 173 dev_dbg(dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
171 return 0; 174 return 0;
172} 175}
173 176
174static int rv3029_set_sr(struct i2c_client *client, u8 val) 177static int rv3029_set_sr(struct device *dev, u8 val)
175{ 178{
176 u8 buf[1]; 179 u8 buf[1];
177 int sr; 180 int sr;
178 181
179 buf[0] = val; 182 buf[0] = val;
180 sr = rv3029_write_regs(client, RV3029_STATUS, buf, 1); 183 sr = rv3029_write_regs(dev, RV3029_STATUS, buf, 1);
181 dev_dbg(&client->dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]); 184 dev_dbg(dev, "status = 0x%.2x (%d)\n", buf[0], buf[0]);
182 if (sr < 0) 185 if (sr < 0)
183 return -EIO; 186 return -EIO;
184 return 0; 187 return 0;
185} 188}
186 189
187static int rv3029_eeprom_busywait(struct i2c_client *client) 190static int rv3029_eeprom_busywait(struct device *dev)
188{ 191{
189 int i, ret; 192 int i, ret;
190 u8 sr; 193 u8 sr;
191 194
192 for (i = 100; i > 0; i--) { 195 for (i = 100; i > 0; i--) {
193 ret = rv3029_get_sr(client, &sr); 196 ret = rv3029_get_sr(dev, &sr);
194 if (ret < 0) 197 if (ret < 0)
195 break; 198 break;
196 if (!(sr & RV3029_STATUS_EEBUSY)) 199 if (!(sr & RV3029_STATUS_EEBUSY))
@@ -198,28 +201,28 @@ static int rv3029_eeprom_busywait(struct i2c_client *client)
198 usleep_range(1000, 10000); 201 usleep_range(1000, 10000);
199 } 202 }
200 if (i <= 0) { 203 if (i <= 0) {
201 dev_err(&client->dev, "EEPROM busy wait timeout.\n"); 204 dev_err(dev, "EEPROM busy wait timeout.\n");
202 return -ETIMEDOUT; 205 return -ETIMEDOUT;
203 } 206 }
204 207
205 return ret; 208 return ret;
206} 209}
207 210
208static int rv3029_eeprom_exit(struct i2c_client *client) 211static int rv3029_eeprom_exit(struct device *dev)
209{ 212{
210 /* Re-enable eeprom refresh */ 213 /* Re-enable eeprom refresh */
211 return rv3029_update_bits(client, RV3029_ONOFF_CTRL, 214 return rv3029_update_bits(dev, RV3029_ONOFF_CTRL,
212 RV3029_ONOFF_CTRL_EERE, 215 RV3029_ONOFF_CTRL_EERE,
213 RV3029_ONOFF_CTRL_EERE); 216 RV3029_ONOFF_CTRL_EERE);
214} 217}
215 218
216static int rv3029_eeprom_enter(struct i2c_client *client) 219static int rv3029_eeprom_enter(struct device *dev)
217{ 220{
218 int ret; 221 int ret;
219 u8 sr; 222 u8 sr;
220 223
221 /* Check whether we are in the allowed voltage range. */ 224 /* Check whether we are in the allowed voltage range. */
222 ret = rv3029_get_sr(client, &sr); 225 ret = rv3029_get_sr(dev, &sr);
223 if (ret < 0) 226 if (ret < 0)
224 return ret; 227 return ret;
225 if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) { 228 if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) {
@@ -228,119 +231,118 @@ static int rv3029_eeprom_enter(struct i2c_client *client)
228 */ 231 */
229 sr &= ~RV3029_STATUS_VLOW1; 232 sr &= ~RV3029_STATUS_VLOW1;
230 sr &= ~RV3029_STATUS_VLOW2; 233 sr &= ~RV3029_STATUS_VLOW2;
231 ret = rv3029_set_sr(client, sr); 234 ret = rv3029_set_sr(dev, sr);
232 if (ret < 0) 235 if (ret < 0)
233 return ret; 236 return ret;
234 usleep_range(1000, 10000); 237 usleep_range(1000, 10000);
235 ret = rv3029_get_sr(client, &sr); 238 ret = rv3029_get_sr(dev, &sr);
236 if (ret < 0) 239 if (ret < 0)
237 return ret; 240 return ret;
238 if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) { 241 if (sr & (RV3029_STATUS_VLOW1 | RV3029_STATUS_VLOW2)) {
239 dev_err(&client->dev, 242 dev_err(dev,
240 "Supply voltage is too low to safely access the EEPROM.\n"); 243 "Supply voltage is too low to safely access the EEPROM.\n");
241 return -ENODEV; 244 return -ENODEV;
242 } 245 }
243 } 246 }
244 247
245 /* Disable eeprom refresh. */ 248 /* Disable eeprom refresh. */
246 ret = rv3029_update_bits(client, RV3029_ONOFF_CTRL, 249 ret = rv3029_update_bits(dev, RV3029_ONOFF_CTRL, RV3029_ONOFF_CTRL_EERE,
247 RV3029_ONOFF_CTRL_EERE, 0); 250 0);
248 if (ret < 0) 251 if (ret < 0)
249 return ret; 252 return ret;
250 253
251 /* Wait for any previous eeprom accesses to finish. */ 254 /* Wait for any previous eeprom accesses to finish. */
252 ret = rv3029_eeprom_busywait(client); 255 ret = rv3029_eeprom_busywait(dev);
253 if (ret < 0) 256 if (ret < 0)
254 rv3029_eeprom_exit(client); 257 rv3029_eeprom_exit(dev);
255 258
256 return ret; 259 return ret;
257} 260}
258 261
259static int rv3029_eeprom_read(struct i2c_client *client, u8 reg, 262static int rv3029_eeprom_read(struct device *dev, u8 reg,
260 u8 buf[], size_t len) 263 u8 buf[], size_t len)
261{ 264{
262 int ret, err; 265 int ret, err;
263 266
264 err = rv3029_eeprom_enter(client); 267 err = rv3029_eeprom_enter(dev);
265 if (err < 0) 268 if (err < 0)
266 return err; 269 return err;
267 270
268 ret = rv3029_read_regs(client, reg, buf, len); 271 ret = rv3029_read_regs(dev, reg, buf, len);
269 272
270 err = rv3029_eeprom_exit(client); 273 err = rv3029_eeprom_exit(dev);
271 if (err < 0) 274 if (err < 0)
272 return err; 275 return err;
273 276
274 return ret; 277 return ret;
275} 278}
276 279
277static int rv3029_eeprom_write(struct i2c_client *client, u8 reg, 280static int rv3029_eeprom_write(struct device *dev, u8 reg,
278 u8 const buf[], size_t len) 281 u8 const buf[], size_t len)
279{ 282{
280 int ret, err; 283 int ret, err;
281 size_t i; 284 size_t i;
282 u8 tmp; 285 u8 tmp;
283 286
284 err = rv3029_eeprom_enter(client); 287 err = rv3029_eeprom_enter(dev);
285 if (err < 0) 288 if (err < 0)
286 return err; 289 return err;
287 290
288 for (i = 0; i < len; i++, reg++) { 291 for (i = 0; i < len; i++, reg++) {
289 ret = rv3029_read_regs(client, reg, &tmp, 1); 292 ret = rv3029_read_regs(dev, reg, &tmp, 1);
290 if (ret < 0) 293 if (ret < 0)
291 break; 294 break;
292 if (tmp != buf[i]) { 295 if (tmp != buf[i]) {
293 ret = rv3029_write_regs(client, reg, &buf[i], 1); 296 ret = rv3029_write_regs(dev, reg, &buf[i], 1);
294 if (ret < 0) 297 if (ret < 0)
295 break; 298 break;
296 } 299 }
297 ret = rv3029_eeprom_busywait(client); 300 ret = rv3029_eeprom_busywait(dev);
298 if (ret < 0) 301 if (ret < 0)
299 break; 302 break;
300 } 303 }
301 304
302 err = rv3029_eeprom_exit(client); 305 err = rv3029_eeprom_exit(dev);
303 if (err < 0) 306 if (err < 0)
304 return err; 307 return err;
305 308
306 return ret; 309 return ret;
307} 310}
308 311
309static int rv3029_eeprom_update_bits(struct i2c_client *client, 312static int rv3029_eeprom_update_bits(struct device *dev,
310 u8 reg, u8 mask, u8 set) 313 u8 reg, u8 mask, u8 set)
311{ 314{
312 u8 buf; 315 u8 buf;
313 int ret; 316 int ret;
314 317
315 ret = rv3029_eeprom_read(client, reg, &buf, 1); 318 ret = rv3029_eeprom_read(dev, reg, &buf, 1);
316 if (ret < 0) 319 if (ret < 0)
317 return ret; 320 return ret;
318 buf &= ~mask; 321 buf &= ~mask;
319 buf |= set & mask; 322 buf |= set & mask;
320 ret = rv3029_eeprom_write(client, reg, &buf, 1); 323 ret = rv3029_eeprom_write(dev, reg, &buf, 1);
321 if (ret < 0) 324 if (ret < 0)
322 return ret; 325 return ret;
323 326
324 return 0; 327 return 0;
325} 328}
326 329
327static int rv3029_read_time(struct i2c_client *client, struct rtc_time *tm) 330static int rv3029_read_time(struct device *dev, struct rtc_time *tm)
328{ 331{
329 u8 buf[1]; 332 u8 buf[1];
330 int ret; 333 int ret;
331 u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, }; 334 u8 regs[RV3029_WATCH_SECTION_LEN] = { 0, };
332 335
333 ret = rv3029_get_sr(client, buf); 336 ret = rv3029_get_sr(dev, buf);
334 if (ret < 0) { 337 if (ret < 0) {
335 dev_err(&client->dev, "%s: reading SR failed\n", __func__); 338 dev_err(dev, "%s: reading SR failed\n", __func__);
336 return -EIO; 339 return -EIO;
337 } 340 }
338 341
339 ret = rv3029_read_regs(client, RV3029_W_SEC, regs, 342 ret = rv3029_read_regs(dev, RV3029_W_SEC, regs,
340 RV3029_WATCH_SECTION_LEN); 343 RV3029_WATCH_SECTION_LEN);
341 if (ret < 0) { 344 if (ret < 0) {
342 dev_err(&client->dev, "%s: reading RTC section failed\n", 345 dev_err(dev, "%s: reading RTC section failed\n", __func__);
343 __func__);
344 return ret; 346 return ret;
345 } 347 }
346 348
@@ -368,30 +370,23 @@ static int rv3029_read_time(struct i2c_client *client, struct rtc_time *tm)
368 return 0; 370 return 0;
369} 371}
370 372
371static int rv3029_rtc_read_time(struct device *dev, struct rtc_time *tm) 373static int rv3029_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
372{
373 return rv3029_read_time(to_i2c_client(dev), tm);
374}
375
376static int rv3029_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
377{ 374{
378 struct i2c_client *client = to_i2c_client(dev);
379 struct rtc_time *const tm = &alarm->time; 375 struct rtc_time *const tm = &alarm->time;
380 int ret; 376 int ret;
381 u8 regs[8]; 377 u8 regs[8];
382 378
383 ret = rv3029_get_sr(client, regs); 379 ret = rv3029_get_sr(dev, regs);
384 if (ret < 0) { 380 if (ret < 0) {
385 dev_err(&client->dev, "%s: reading SR failed\n", __func__); 381 dev_err(dev, "%s: reading SR failed\n", __func__);
386 return -EIO; 382 return -EIO;
387 } 383 }
388 384
389 ret = rv3029_read_regs(client, RV3029_A_SC, regs, 385 ret = rv3029_read_regs(dev, RV3029_A_SC, regs,
390 RV3029_ALARM_SECTION_LEN); 386 RV3029_ALARM_SECTION_LEN);
391 387
392 if (ret < 0) { 388 if (ret < 0) {
393 dev_err(&client->dev, "%s: reading alarm section failed\n", 389 dev_err(dev, "%s: reading alarm section failed\n", __func__);
394 __func__);
395 return ret; 390 return ret;
396 } 391 }
397 392
@@ -406,25 +401,23 @@ static int rv3029_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
406 return 0; 401 return 0;
407} 402}
408 403
409static int rv3029_rtc_alarm_set_irq(struct i2c_client *client, int enable) 404static int rv3029_rtc_alarm_set_irq(struct device *dev, int enable)
410{ 405{
411 int ret; 406 int ret;
412 407
413 /* enable/disable AIE irq */ 408 /* enable/disable AIE irq */
414 ret = rv3029_update_bits(client, RV3029_IRQ_CTRL, 409 ret = rv3029_update_bits(dev, RV3029_IRQ_CTRL, RV3029_IRQ_CTRL_AIE,
415 RV3029_IRQ_CTRL_AIE,
416 (enable ? RV3029_IRQ_CTRL_AIE : 0)); 410 (enable ? RV3029_IRQ_CTRL_AIE : 0));
417 if (ret < 0) { 411 if (ret < 0) {
418 dev_err(&client->dev, "can't update INT reg\n"); 412 dev_err(dev, "can't update INT reg\n");
419 return ret; 413 return ret;
420 } 414 }
421 415
422 return 0; 416 return 0;
423} 417}
424 418
425static int rv3029_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm) 419static int rv3029_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
426{ 420{
427 struct i2c_client *client = to_i2c_client(dev);
428 struct rtc_time *const tm = &alarm->time; 421 struct rtc_time *const tm = &alarm->time;
429 int ret; 422 int ret;
430 u8 regs[8]; 423 u8 regs[8];
@@ -437,9 +430,9 @@ static int rv3029_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
437 if (tm->tm_year < 100) 430 if (tm->tm_year < 100)
438 return -EINVAL; 431 return -EINVAL;
439 432
440 ret = rv3029_get_sr(client, regs); 433 ret = rv3029_get_sr(dev, regs);
441 if (ret < 0) { 434 if (ret < 0) {
442 dev_err(&client->dev, "%s: reading SR failed\n", __func__); 435 dev_err(dev, "%s: reading SR failed\n", __func__);
443 return -EIO; 436 return -EIO;
444 } 437 }
445 regs[RV3029_A_SC-RV3029_A_SC] = bin2bcd(tm->tm_sec & 0x7f); 438 regs[RV3029_A_SC-RV3029_A_SC] = bin2bcd(tm->tm_sec & 0x7f);
@@ -450,38 +443,38 @@ static int rv3029_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
450 regs[RV3029_A_DW-RV3029_A_SC] = bin2bcd((tm->tm_wday & 7) - 1); 443 regs[RV3029_A_DW-RV3029_A_SC] = bin2bcd((tm->tm_wday & 7) - 1);
451 regs[RV3029_A_YR-RV3029_A_SC] = bin2bcd((tm->tm_year & 0x7f) - 100); 444 regs[RV3029_A_YR-RV3029_A_SC] = bin2bcd((tm->tm_year & 0x7f) - 100);
452 445
453 ret = rv3029_write_regs(client, RV3029_A_SC, regs, 446 ret = rv3029_write_regs(dev, RV3029_A_SC, regs,
454 RV3029_ALARM_SECTION_LEN); 447 RV3029_ALARM_SECTION_LEN);
455 if (ret < 0) 448 if (ret < 0)
456 return ret; 449 return ret;
457 450
458 if (alarm->enabled) { 451 if (alarm->enabled) {
459 /* clear AF flag */ 452 /* clear AF flag */
460 ret = rv3029_update_bits(client, RV3029_IRQ_FLAGS, 453 ret = rv3029_update_bits(dev, RV3029_IRQ_FLAGS,
461 RV3029_IRQ_FLAGS_AF, 0); 454 RV3029_IRQ_FLAGS_AF, 0);
462 if (ret < 0) { 455 if (ret < 0) {
463 dev_err(&client->dev, "can't clear alarm flag\n"); 456 dev_err(dev, "can't clear alarm flag\n");
464 return ret; 457 return ret;
465 } 458 }
466 /* enable AIE irq */ 459 /* enable AIE irq */
467 ret = rv3029_rtc_alarm_set_irq(client, 1); 460 ret = rv3029_rtc_alarm_set_irq(dev, 1);
468 if (ret) 461 if (ret)
469 return ret; 462 return ret;
470 463
471 dev_dbg(&client->dev, "alarm IRQ armed\n"); 464 dev_dbg(dev, "alarm IRQ armed\n");
472 } else { 465 } else {
473 /* disable AIE irq */ 466 /* disable AIE irq */
474 ret = rv3029_rtc_alarm_set_irq(client, 0); 467 ret = rv3029_rtc_alarm_set_irq(dev, 0);
475 if (ret) 468 if (ret)
476 return ret; 469 return ret;
477 470
478 dev_dbg(&client->dev, "alarm IRQ disabled\n"); 471 dev_dbg(dev, "alarm IRQ disabled\n");
479 } 472 }
480 473
481 return 0; 474 return 0;
482} 475}
483 476
484static int rv3029_set_time(struct i2c_client *client, struct rtc_time const *tm) 477static int rv3029_set_time(struct device *dev, struct rtc_time *tm)
485{ 478{
486 u8 regs[8]; 479 u8 regs[8];
487 int ret; 480 int ret;
@@ -502,31 +495,25 @@ static int rv3029_set_time(struct i2c_client *client, struct rtc_time const *tm)
502 regs[RV3029_W_DAYS-RV3029_W_SEC] = bin2bcd((tm->tm_wday & 7)+1); 495 regs[RV3029_W_DAYS-RV3029_W_SEC] = bin2bcd((tm->tm_wday & 7)+1);
503 regs[RV3029_W_YEARS-RV3029_W_SEC] = bin2bcd(tm->tm_year - 100); 496 regs[RV3029_W_YEARS-RV3029_W_SEC] = bin2bcd(tm->tm_year - 100);
504 497
505 ret = rv3029_write_regs(client, RV3029_W_SEC, regs, 498 ret = rv3029_write_regs(dev, RV3029_W_SEC, regs,
506 RV3029_WATCH_SECTION_LEN); 499 RV3029_WATCH_SECTION_LEN);
507 if (ret < 0) 500 if (ret < 0)
508 return ret; 501 return ret;
509 502
510 ret = rv3029_get_sr(client, regs); 503 ret = rv3029_get_sr(dev, regs);
511 if (ret < 0) { 504 if (ret < 0) {
512 dev_err(&client->dev, "%s: reading SR failed\n", __func__); 505 dev_err(dev, "%s: reading SR failed\n", __func__);
513 return ret; 506 return ret;
514 } 507 }
515 /* clear PON bit */ 508 /* clear PON bit */
516 ret = rv3029_set_sr(client, (regs[0] & ~RV3029_STATUS_PON)); 509 ret = rv3029_set_sr(dev, (regs[0] & ~RV3029_STATUS_PON));
517 if (ret < 0) { 510 if (ret < 0) {
518 dev_err(&client->dev, "%s: reading SR failed\n", __func__); 511 dev_err(dev, "%s: reading SR failed\n", __func__);
519 return ret; 512 return ret;
520 } 513 }
521 514
522 return 0; 515 return 0;
523} 516}
524
525static int rv3029_rtc_set_time(struct device *dev, struct rtc_time *tm)
526{
527 return rv3029_set_time(to_i2c_client(dev), tm);
528}
529
530static const struct rv3029_trickle_tab_elem { 517static const struct rv3029_trickle_tab_elem {
531 u32 r; /* resistance in ohms */ 518 u32 r; /* resistance in ohms */
532 u8 conf; /* trickle config bits */ 519 u8 conf; /* trickle config bits */
@@ -584,9 +571,9 @@ static const struct rv3029_trickle_tab_elem {
584 }, 571 },
585}; 572};
586 573
587static void rv3029_trickle_config(struct i2c_client *client) 574static void rv3029_trickle_config(struct device *dev)
588{ 575{
589 struct device_node *of_node = client->dev.of_node; 576 struct device_node *of_node = dev->of_node;
590 const struct rv3029_trickle_tab_elem *elem; 577 const struct rv3029_trickle_tab_elem *elem;
591 int i, err; 578 int i, err;
592 u32 ohms; 579 u32 ohms;
@@ -608,27 +595,26 @@ static void rv3029_trickle_config(struct i2c_client *client)
608 break; 595 break;
609 } 596 }
610 trickle_set_bits = elem->conf; 597 trickle_set_bits = elem->conf;
611 dev_info(&client->dev, 598 dev_info(dev,
612 "Trickle charger enabled at %d ohms resistance.\n", 599 "Trickle charger enabled at %d ohms resistance.\n",
613 elem->r); 600 elem->r);
614 } 601 }
615 err = rv3029_eeprom_update_bits(client, RV3029_CONTROL_E2P_EECTRL, 602 err = rv3029_eeprom_update_bits(dev, RV3029_CONTROL_E2P_EECTRL,
616 RV3029_TRICKLE_MASK, 603 RV3029_TRICKLE_MASK,
617 trickle_set_bits); 604 trickle_set_bits);
618 if (err < 0) { 605 if (err < 0) {
619 dev_err(&client->dev, 606 dev_err(dev, "Failed to update trickle charger config\n");
620 "Failed to update trickle charger config\n");
621 } 607 }
622} 608}
623 609
624#ifdef CONFIG_RTC_DRV_RV3029_HWMON 610#ifdef CONFIG_RTC_DRV_RV3029_HWMON
625 611
626static int rv3029_read_temp(struct i2c_client *client, int *temp_mC) 612static int rv3029_read_temp(struct device *dev, int *temp_mC)
627{ 613{
628 int ret; 614 int ret;
629 u8 temp; 615 u8 temp;
630 616
631 ret = rv3029_read_regs(client, RV3029_TEMP_PAGE, &temp, 1); 617 ret = rv3029_read_regs(dev, RV3029_TEMP_PAGE, &temp, 1);
632 if (ret < 0) 618 if (ret < 0)
633 return ret; 619 return ret;
634 620
@@ -641,10 +627,9 @@ static ssize_t rv3029_hwmon_show_temp(struct device *dev,
641 struct device_attribute *attr, 627 struct device_attribute *attr,
642 char *buf) 628 char *buf)
643{ 629{
644 struct i2c_client *client = dev_get_drvdata(dev);
645 int ret, temp_mC; 630 int ret, temp_mC;
646 631
647 ret = rv3029_read_temp(client, &temp_mC); 632 ret = rv3029_read_temp(dev, &temp_mC);
648 if (ret < 0) 633 if (ret < 0)
649 return ret; 634 return ret;
650 635
@@ -656,7 +641,6 @@ static ssize_t rv3029_hwmon_set_update_interval(struct device *dev,
656 const char *buf, 641 const char *buf,
657 size_t count) 642 size_t count)
658{ 643{
659 struct i2c_client *client = dev_get_drvdata(dev);
660 unsigned long interval_ms; 644 unsigned long interval_ms;
661 int ret; 645 int ret;
662 u8 th_set_bits = 0; 646 u8 th_set_bits = 0;
@@ -670,7 +654,7 @@ static ssize_t rv3029_hwmon_set_update_interval(struct device *dev,
670 if (interval_ms >= 16000) 654 if (interval_ms >= 16000)
671 th_set_bits |= RV3029_EECTRL_THP; 655 th_set_bits |= RV3029_EECTRL_THP;
672 } 656 }
673 ret = rv3029_eeprom_update_bits(client, RV3029_CONTROL_E2P_EECTRL, 657 ret = rv3029_eeprom_update_bits(dev, RV3029_CONTROL_E2P_EECTRL,
674 RV3029_EECTRL_THE | RV3029_EECTRL_THP, 658 RV3029_EECTRL_THE | RV3029_EECTRL_THP,
675 th_set_bits); 659 th_set_bits);
676 if (ret < 0) 660 if (ret < 0)
@@ -683,11 +667,10 @@ static ssize_t rv3029_hwmon_show_update_interval(struct device *dev,
683 struct device_attribute *attr, 667 struct device_attribute *attr,
684 char *buf) 668 char *buf)
685{ 669{
686 struct i2c_client *client = dev_get_drvdata(dev);
687 int ret, interval_ms; 670 int ret, interval_ms;
688 u8 eectrl; 671 u8 eectrl;
689 672
690 ret = rv3029_eeprom_read(client, RV3029_CONTROL_E2P_EECTRL, 673 ret = rv3029_eeprom_read(dev, RV3029_CONTROL_E2P_EECTRL,
691 &eectrl, 1); 674 &eectrl, 1);
692 if (ret < 0) 675 if (ret < 0)
693 return ret; 676 return ret;
@@ -717,32 +700,32 @@ static struct attribute *rv3029_hwmon_attrs[] = {
717}; 700};
718ATTRIBUTE_GROUPS(rv3029_hwmon); 701ATTRIBUTE_GROUPS(rv3029_hwmon);
719 702
720static void rv3029_hwmon_register(struct i2c_client *client) 703static void rv3029_hwmon_register(struct device *dev, const char *name)
721{ 704{
705 struct rv3029_data *rv3029 = dev_get_drvdata(dev);
722 struct device *hwmon_dev; 706 struct device *hwmon_dev;
723 707
724 hwmon_dev = devm_hwmon_device_register_with_groups( 708 hwmon_dev = devm_hwmon_device_register_with_groups(dev, name, rv3029,
725 &client->dev, client->name, client, rv3029_hwmon_groups); 709 rv3029_hwmon_groups);
726 if (IS_ERR(hwmon_dev)) { 710 if (IS_ERR(hwmon_dev)) {
727 dev_warn(&client->dev, 711 dev_warn(dev, "unable to register hwmon device %ld\n",
728 "unable to register hwmon device %ld\n",
729 PTR_ERR(hwmon_dev)); 712 PTR_ERR(hwmon_dev));
730 } 713 }
731} 714}
732 715
733#else /* CONFIG_RTC_DRV_RV3029_HWMON */ 716#else /* CONFIG_RTC_DRV_RV3029_HWMON */
734 717
735static void rv3029_hwmon_register(struct i2c_client *client) 718static void rv3029_hwmon_register(struct device *dev, const char *name)
736{ 719{
737} 720}
738 721
739#endif /* CONFIG_RTC_DRV_RV3029_HWMON */ 722#endif /* CONFIG_RTC_DRV_RV3029_HWMON */
740 723
741static const struct rtc_class_ops rv3029_rtc_ops = { 724static const struct rtc_class_ops rv3029_rtc_ops = {
742 .read_time = rv3029_rtc_read_time, 725 .read_time = rv3029_read_time,
743 .set_time = rv3029_rtc_set_time, 726 .set_time = rv3029_set_time,
744 .read_alarm = rv3029_rtc_read_alarm, 727 .read_alarm = rv3029_read_alarm,
745 .set_alarm = rv3029_rtc_set_alarm, 728 .set_alarm = rv3029_set_alarm,
746}; 729};
747 730
748static struct i2c_device_id rv3029_id[] = { 731static struct i2c_device_id rv3029_id[] = {
@@ -752,41 +735,67 @@ static struct i2c_device_id rv3029_id[] = {
752}; 735};
753MODULE_DEVICE_TABLE(i2c, rv3029_id); 736MODULE_DEVICE_TABLE(i2c, rv3029_id);
754 737
755static int rv3029_probe(struct i2c_client *client, 738static int rv3029_probe(struct device *dev, struct regmap *regmap, int irq,
756 const struct i2c_device_id *id) 739 const char *name)
757{ 740{
758 struct rtc_device *rtc; 741 struct rv3029_data *rv3029;
759 int rc = 0; 742 int rc = 0;
760 u8 buf[1]; 743 u8 buf[1];
761 744
762 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_EMUL)) 745 rv3029 = devm_kzalloc(dev, sizeof(*rv3029), GFP_KERNEL);
763 return -ENODEV; 746 if (!rv3029)
747 return -ENOMEM;
748
749 rv3029->regmap = regmap;
750 rv3029->irq = irq;
751 rv3029->dev = dev;
752 dev_set_drvdata(dev, rv3029);
764 753
765 rc = rv3029_get_sr(client, buf); 754 rc = rv3029_get_sr(dev, buf);
766 if (rc < 0) { 755 if (rc < 0) {
767 dev_err(&client->dev, "reading status failed\n"); 756 dev_err(dev, "reading status failed\n");
768 return rc; 757 return rc;
769 } 758 }
770 759
771 rv3029_trickle_config(client); 760 rv3029_trickle_config(dev);
772 rv3029_hwmon_register(client); 761 rv3029_hwmon_register(dev, name);
762
763 rv3029->rtc = devm_rtc_device_register(dev, name, &rv3029_rtc_ops,
764 THIS_MODULE);
773 765
774 rtc = devm_rtc_device_register(&client->dev, client->name, 766 return PTR_ERR_OR_ZERO(rv3029->rtc);
775 &rv3029_rtc_ops, THIS_MODULE); 767}
776 768
777 if (IS_ERR(rtc)) 769static int rv3029_i2c_probe(struct i2c_client *client,
778 return PTR_ERR(rtc); 770 const struct i2c_device_id *id)
771{
772 struct regmap *regmap;
773 static const struct regmap_config config = {
774 .reg_bits = 8,
775 .val_bits = 8,
776 };
777
778 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_I2C_BLOCK |
779 I2C_FUNC_SMBUS_BYTE)) {
780 dev_err(&client->dev, "Adapter does not support SMBUS_I2C_BLOCK or SMBUS_I2C_BYTE\n");
781 return -ENODEV;
782 }
779 783
780 i2c_set_clientdata(client, rtc); 784 regmap = devm_regmap_init_i2c(client, &config);
785 if (IS_ERR(regmap)) {
786 dev_err(&client->dev, "%s: regmap allocation failed: %ld\n",
787 __func__, PTR_ERR(regmap));
788 return PTR_ERR(regmap);
789 }
781 790
782 return 0; 791 return rv3029_probe(&client->dev, regmap, client->irq, client->name);
783} 792}
784 793
785static struct i2c_driver rv3029_driver = { 794static struct i2c_driver rv3029_driver = {
786 .driver = { 795 .driver = {
787 .name = "rtc-rv3029c2", 796 .name = "rtc-rv3029c2",
788 }, 797 },
789 .probe = rv3029_probe, 798 .probe = rv3029_i2c_probe,
790 .id_table = rv3029_id, 799 .id_table = rv3029_id,
791}; 800};
792 801
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-15 16:41:19 -0500