?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ALSA: hda - Fix missing stream for second ADC on Realtek ALC260 HDA codec
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / rtc / rtc-fm3130.c
blobff6fce61ea41afff5e0d9d6bd8bd480c6f8d37d4
1 /*
2 * rtc-fm3130.c - RTC driver for Ramtron FM3130 I2C chip.
3 *
4 * Copyright (C) 2008 Sergey Lapin
5 * Based on ds1307 driver by James Chapman and David Brownell
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12 #include <linux/module.h>
13 #include <linux/i2c.h>
14 #include <linux/rtc.h>
15 #include <linux/bcd.h>
16 #include <linux/slab.h>
17
18 #define FM3130_RTC_CONTROL (0x0)
19 #define FM3130_CAL_CONTROL (0x1)
20 #define FM3130_RTC_SECONDS (0x2)
21 #define FM3130_RTC_MINUTES (0x3)
22 #define FM3130_RTC_HOURS (0x4)
23 #define FM3130_RTC_DAY (0x5)
24 #define FM3130_RTC_DATE (0x6)
25 #define FM3130_RTC_MONTHS (0x7)
26 #define FM3130_RTC_YEARS (0x8)
27
28 #define FM3130_ALARM_SECONDS (0x9)
29 #define FM3130_ALARM_MINUTES (0xa)
30 #define FM3130_ALARM_HOURS (0xb)
31 #define FM3130_ALARM_DATE (0xc)
32 #define FM3130_ALARM_MONTHS (0xd)
33 #define FM3130_ALARM_WP_CONTROL (0xe)
34
35 #define FM3130_CAL_CONTROL_BIT_nOSCEN (1 << 7) /* Osciallator enabled */
36 #define FM3130_RTC_CONTROL_BIT_LB (1 << 7) /* Low battery */
37 #define FM3130_RTC_CONTROL_BIT_AF (1 << 6) /* Alarm flag */
38 #define FM3130_RTC_CONTROL_BIT_CF (1 << 5) /* Century overflow */
39 #define FM3130_RTC_CONTROL_BIT_POR (1 << 4) /* Power on reset */
40 #define FM3130_RTC_CONTROL_BIT_AEN (1 << 3) /* Alarm enable */
41 #define FM3130_RTC_CONTROL_BIT_CAL (1 << 2) /* Calibration mode */
42 #define FM3130_RTC_CONTROL_BIT_WRITE (1 << 1) /* W=1 -> write mode W=0 normal */
43 #define FM3130_RTC_CONTROL_BIT_READ (1 << 0) /* R=1 -> read mode R=0 normal */
44
45 #define FM3130_CLOCK_REGS 7
46 #define FM3130_ALARM_REGS 5
47
48 struct fm3130 {
49 u8 reg_addr_time;
50 u8 reg_addr_alarm;
51 u8 regs[15];
52 struct i2c_msg msg[4];
53 struct i2c_client *client;
54 struct rtc_device *rtc;
55 int data_valid;
56 int alarm;
57 };
58 static const struct i2c_device_id fm3130_id[] = {
59 { "fm3130", 0 },
60 { }
61 };
62 MODULE_DEVICE_TABLE(i2c, fm3130_id);
63
64 #define FM3130_MODE_NORMAL 0
65 #define FM3130_MODE_WRITE 1
66 #define FM3130_MODE_READ 2
67
68 static void fm3130_rtc_mode(struct device *dev, int mode)
69 {
70 struct fm3130 *fm3130 = dev_get_drvdata(dev);
71
72 fm3130->regs[FM3130_RTC_CONTROL] =
73 i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
74 switch (mode) {
75 case FM3130_MODE_NORMAL:
76 fm3130->regs[FM3130_RTC_CONTROL] &=
77 ~(FM3130_RTC_CONTROL_BIT_WRITE |
78 FM3130_RTC_CONTROL_BIT_READ);
79 break;
80 case FM3130_MODE_WRITE:
81 fm3130->regs[FM3130_RTC_CONTROL] |= FM3130_RTC_CONTROL_BIT_WRITE;
82 break;
83 case FM3130_MODE_READ:
84 fm3130->regs[FM3130_RTC_CONTROL] |= FM3130_RTC_CONTROL_BIT_READ;
85 break;
86 default:
87 dev_dbg(dev, "invalid mode %d\n", mode);
88 break;
89 }
90 /* Checking for alarm */
91 if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AF) {
92 fm3130->alarm = 1;
93 fm3130->regs[FM3130_RTC_CONTROL] &= ~FM3130_RTC_CONTROL_BIT_AF;
94 }
95 i2c_smbus_write_byte_data(fm3130->client,
96 FM3130_RTC_CONTROL, fm3130->regs[FM3130_RTC_CONTROL]);
97 }
98
99 static int fm3130_get_time(struct device *dev, struct rtc_time *t)
100 {
101 struct fm3130 *fm3130 = dev_get_drvdata(dev);
102 int tmp;
103
104 if (!fm3130->data_valid) {
105 /* We have invalid data in RTC, probably due
106 to battery faults or other problems. Return EIO
107 for now, it will allow us to set data later insted
108 of error during probing which disables device */
109 return -EIO;
110 }
111 fm3130_rtc_mode(dev, FM3130_MODE_READ);
112
113 /* read the RTC date and time registers all at once */
114 tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
115 fm3130->msg, 2);
116 if (tmp != 2) {
117 dev_err(dev, "%s error %d\n", "read", tmp);
118 return -EIO;
119 }
120
121 fm3130_rtc_mode(dev, FM3130_MODE_NORMAL);
122
123 dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x %02x"
124 "%02x %02x %02x %02x %02x %02x %02x\n",
125 "read",
126 fm3130->regs[0], fm3130->regs[1],
127 fm3130->regs[2], fm3130->regs[3],
128 fm3130->regs[4], fm3130->regs[5],
129 fm3130->regs[6], fm3130->regs[7],
130 fm3130->regs[8], fm3130->regs[9],
131 fm3130->regs[0xa], fm3130->regs[0xb],
132 fm3130->regs[0xc], fm3130->regs[0xd],
133 fm3130->regs[0xe]);
134
135 t->tm_sec = bcd2bin(fm3130->regs[FM3130_RTC_SECONDS] & 0x7f);
136 t->tm_min = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
137 tmp = fm3130->regs[FM3130_RTC_HOURS] & 0x3f;
138 t->tm_hour = bcd2bin(tmp);
139 t->tm_wday = bcd2bin(fm3130->regs[FM3130_RTC_DAY] & 0x07) - 1;
140 t->tm_mday = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
141 tmp = fm3130->regs[FM3130_RTC_MONTHS] & 0x1f;
142 t->tm_mon = bcd2bin(tmp) - 1;
143
144 /* assume 20YY not 19YY, and ignore CF bit */
145 t->tm_year = bcd2bin(fm3130->regs[FM3130_RTC_YEARS]) + 100;
146
147 dev_dbg(dev, "%s secs=%d, mins=%d, "
148 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
149 "read", t->tm_sec, t->tm_min,
150 t->tm_hour, t->tm_mday,
151 t->tm_mon, t->tm_year, t->tm_wday);
152
153 /* initial clock setting can be undefined */
154 return rtc_valid_tm(t);
155 }
156
157
158 static int fm3130_set_time(struct device *dev, struct rtc_time *t)
159 {
160 struct fm3130 *fm3130 = dev_get_drvdata(dev);
161 int tmp, i;
162 u8 *buf = fm3130->regs;
163
164 dev_dbg(dev, "%s secs=%d, mins=%d, "
165 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
166 "write", t->tm_sec, t->tm_min,
167 t->tm_hour, t->tm_mday,
168 t->tm_mon, t->tm_year, t->tm_wday);
169
170 /* first register addr */
171 buf[FM3130_RTC_SECONDS] = bin2bcd(t->tm_sec);
172 buf[FM3130_RTC_MINUTES] = bin2bcd(t->tm_min);
173 buf[FM3130_RTC_HOURS] = bin2bcd(t->tm_hour);
174 buf[FM3130_RTC_DAY] = bin2bcd(t->tm_wday + 1);
175 buf[FM3130_RTC_DATE] = bin2bcd(t->tm_mday);
176 buf[FM3130_RTC_MONTHS] = bin2bcd(t->tm_mon + 1);
177
178 /* assume 20YY not 19YY */
179 tmp = t->tm_year - 100;
180 buf[FM3130_RTC_YEARS] = bin2bcd(tmp);
181
182 dev_dbg(dev, "%s: %02x %02x %02x %02x %02x %02x %02x"
183 "%02x %02x %02x %02x %02x %02x %02x %02x\n",
184 "write", buf[0], buf[1], buf[2], buf[3],
185 buf[4], buf[5], buf[6], buf[7],
186 buf[8], buf[9], buf[0xa], buf[0xb],
187 buf[0xc], buf[0xd], buf[0xe]);
188
189 fm3130_rtc_mode(dev, FM3130_MODE_WRITE);
190
191 /* Writing time registers, we don't support multibyte transfers */
192 for (i = 0; i < FM3130_CLOCK_REGS; i++) {
193 i2c_smbus_write_byte_data(fm3130->client,
194 FM3130_RTC_SECONDS + i,
195 fm3130->regs[FM3130_RTC_SECONDS + i]);
196 }
197
198 fm3130_rtc_mode(dev, FM3130_MODE_NORMAL);
199
200 /* We assume here that data are valid once written */
201 if (!fm3130->data_valid)
202 fm3130->data_valid = 1;
203 return 0;
204 }
205
206 static int fm3130_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
207 {
208 struct fm3130 *fm3130 = dev_get_drvdata(dev);
209 int tmp;
210 struct rtc_time *tm = &alrm->time;
211 /* read the RTC alarm registers all at once */
212 tmp = i2c_transfer(to_i2c_adapter(fm3130->client->dev.parent),
213 &fm3130->msg[2], 2);
214 if (tmp != 2) {
215 dev_err(dev, "%s error %d\n", "read", tmp);
216 return -EIO;
217 }
218 dev_dbg(dev, "alarm read %02x %02x %02x %02x %02x\n",
219 fm3130->regs[FM3130_ALARM_SECONDS],
220 fm3130->regs[FM3130_ALARM_MINUTES],
221 fm3130->regs[FM3130_ALARM_HOURS],
222 fm3130->regs[FM3130_ALARM_DATE],
223 fm3130->regs[FM3130_ALARM_MONTHS]);
224
225
226 tm->tm_sec = bcd2bin(fm3130->regs[FM3130_ALARM_SECONDS] & 0x7F);
227 tm->tm_min = bcd2bin(fm3130->regs[FM3130_ALARM_MINUTES] & 0x7F);
228 tm->tm_hour = bcd2bin(fm3130->regs[FM3130_ALARM_HOURS] & 0x3F);
229 tm->tm_mday = bcd2bin(fm3130->regs[FM3130_ALARM_DATE] & 0x3F);
230 tm->tm_mon = bcd2bin(fm3130->regs[FM3130_ALARM_MONTHS] & 0x1F);
231 if (tm->tm_mon > 0)
232 tm->tm_mon -= 1; /* RTC is 1-12, tm_mon is 0-11 */
233 dev_dbg(dev, "%s secs=%d, mins=%d, "
234 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
235 "read alarm", tm->tm_sec, tm->tm_min,
236 tm->tm_hour, tm->tm_mday,
237 tm->tm_mon, tm->tm_year, tm->tm_wday);
238
239 return 0;
240 }
241
242 static int fm3130_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
243 {
244 struct fm3130 *fm3130 = dev_get_drvdata(dev);
245 struct rtc_time *tm = &alrm->time;
246 int i;
247
248 dev_dbg(dev, "%s secs=%d, mins=%d, "
249 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
250 "write alarm", tm->tm_sec, tm->tm_min,
251 tm->tm_hour, tm->tm_mday,
252 tm->tm_mon, tm->tm_year, tm->tm_wday);
253
254 if (tm->tm_sec != -1)
255 fm3130->regs[FM3130_ALARM_SECONDS] =
256 bin2bcd(tm->tm_sec) | 0x80;
257
258 if (tm->tm_min != -1)
259 fm3130->regs[FM3130_ALARM_MINUTES] =
260 bin2bcd(tm->tm_min) | 0x80;
261
262 if (tm->tm_hour != -1)
263 fm3130->regs[FM3130_ALARM_HOURS] =
264 bin2bcd(tm->tm_hour) | 0x80;
265
266 if (tm->tm_mday != -1)
267 fm3130->regs[FM3130_ALARM_DATE] =
268 bin2bcd(tm->tm_mday) | 0x80;
269
270 if (tm->tm_mon != -1)
271 fm3130->regs[FM3130_ALARM_MONTHS] =
272 bin2bcd(tm->tm_mon + 1) | 0x80;
273
274 dev_dbg(dev, "alarm write %02x %02x %02x %02x %02x\n",
275 fm3130->regs[FM3130_ALARM_SECONDS],
276 fm3130->regs[FM3130_ALARM_MINUTES],
277 fm3130->regs[FM3130_ALARM_HOURS],
278 fm3130->regs[FM3130_ALARM_DATE],
279 fm3130->regs[FM3130_ALARM_MONTHS]);
280 /* Writing time registers, we don't support multibyte transfers */
281 for (i = 0; i < FM3130_ALARM_REGS; i++) {
282 i2c_smbus_write_byte_data(fm3130->client,
283 FM3130_ALARM_SECONDS + i,
284 fm3130->regs[FM3130_ALARM_SECONDS + i]);
285 }
286 fm3130->regs[FM3130_RTC_CONTROL] =
287 i2c_smbus_read_byte_data(fm3130->client, FM3130_RTC_CONTROL);
288 /* Checking for alarm */
289 if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AF) {
290 fm3130->alarm = 1;
291 fm3130->regs[FM3130_RTC_CONTROL] &= ~FM3130_RTC_CONTROL_BIT_AF;
292 }
293 if (alrm->enabled) {
294 i2c_smbus_write_byte_data(fm3130->client, FM3130_RTC_CONTROL,
295 (fm3130->regs[FM3130_RTC_CONTROL] &
296 ~(FM3130_RTC_CONTROL_BIT_CAL)) |
297 FM3130_RTC_CONTROL_BIT_AEN);
298 } else {
299 i2c_smbus_write_byte_data(fm3130->client, FM3130_RTC_CONTROL,
300 fm3130->regs[FM3130_RTC_CONTROL] &
301 ~(FM3130_RTC_CONTROL_BIT_AEN));
302 }
303 return 0;
304 }
305
306 static const struct rtc_class_ops fm3130_rtc_ops = {
307 .read_time = fm3130_get_time,
308 .set_time = fm3130_set_time,
309 .read_alarm = fm3130_read_alarm,
310 .set_alarm = fm3130_set_alarm,
311 };
312
313 static struct i2c_driver fm3130_driver;
314
315 static int __devinit fm3130_probe(struct i2c_client *client,
316 const struct i2c_device_id *id)
317 {
318 struct fm3130 *fm3130;
319 int err = -ENODEV;
320 int tmp;
321 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
322
323 if (!i2c_check_functionality(adapter,
324 I2C_FUNC_I2C | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
325 return -EIO;
326
327 fm3130 = kzalloc(sizeof(struct fm3130), GFP_KERNEL);
328
329 if (!fm3130)
330 return -ENOMEM;
331
332 fm3130->client = client;
333 i2c_set_clientdata(client, fm3130);
334 fm3130->reg_addr_time = FM3130_RTC_SECONDS;
335 fm3130->reg_addr_alarm = FM3130_ALARM_SECONDS;
336
337 /* Messages to read time */
338 fm3130->msg[0].addr = client->addr;
339 fm3130->msg[0].flags = 0;
340 fm3130->msg[0].len = 1;
341 fm3130->msg[0].buf = &fm3130->reg_addr_time;
342
343 fm3130->msg[1].addr = client->addr;
344 fm3130->msg[1].flags = I2C_M_RD;
345 fm3130->msg[1].len = FM3130_CLOCK_REGS;
346 fm3130->msg[1].buf = &fm3130->regs[FM3130_RTC_SECONDS];
347
348 /* Messages to read alarm */
349 fm3130->msg[2].addr = client->addr;
350 fm3130->msg[2].flags = 0;
351 fm3130->msg[2].len = 1;
352 fm3130->msg[2].buf = &fm3130->reg_addr_alarm;
353
354 fm3130->msg[3].addr = client->addr;
355 fm3130->msg[3].flags = I2C_M_RD;
356 fm3130->msg[3].len = FM3130_ALARM_REGS;
357 fm3130->msg[3].buf = &fm3130->regs[FM3130_ALARM_SECONDS];
358
359 fm3130->data_valid = 0;
360
361 tmp = i2c_transfer(adapter, fm3130->msg, 4);
362 if (tmp != 4) {
363 pr_debug("read error %d\n", tmp);
364 err = -EIO;
365 goto exit_free;
366 }
367
368 fm3130->regs[FM3130_RTC_CONTROL] =
369 i2c_smbus_read_byte_data(client, FM3130_RTC_CONTROL);
370 fm3130->regs[FM3130_CAL_CONTROL] =
371 i2c_smbus_read_byte_data(client, FM3130_CAL_CONTROL);
372
373 /* Checking for alarm */
374 if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_AF) {
375 fm3130->alarm = 1;
376 fm3130->regs[FM3130_RTC_CONTROL] &= ~FM3130_RTC_CONTROL_BIT_AF;
377 }
378
379 /* Disabling calibration mode */
380 if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_CAL) {
381 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
382 fm3130->regs[FM3130_RTC_CONTROL] &
383 ~(FM3130_RTC_CONTROL_BIT_CAL));
384 dev_warn(&client->dev, "Disabling calibration mode!\n");
385 }
386
387 /* Disabling read and write modes */
388 if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_WRITE ||
389 fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_READ) {
390 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
391 fm3130->regs[FM3130_RTC_CONTROL] &
392 ~(FM3130_RTC_CONTROL_BIT_READ |
393 FM3130_RTC_CONTROL_BIT_WRITE));
394 dev_warn(&client->dev, "Disabling READ or WRITE mode!\n");
395 }
396
397 /* oscillator off? turn it on, so clock can tick. */
398 if (fm3130->regs[FM3130_CAL_CONTROL] & FM3130_CAL_CONTROL_BIT_nOSCEN)
399 i2c_smbus_write_byte_data(client, FM3130_CAL_CONTROL,
400 fm3130->regs[FM3130_CAL_CONTROL] &
401 ~(FM3130_CAL_CONTROL_BIT_nOSCEN));
402
403 /* oscillator fault? clear flag, and warn */
404 if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_LB)
405 dev_warn(&client->dev, "Low battery!\n");
406
407 /* oscillator fault? clear flag, and warn */
408 if (fm3130->regs[FM3130_RTC_CONTROL] & FM3130_RTC_CONTROL_BIT_POR) {
409 i2c_smbus_write_byte_data(client, FM3130_RTC_CONTROL,
410 fm3130->regs[FM3130_RTC_CONTROL] &
411 ~FM3130_RTC_CONTROL_BIT_POR);
412 dev_warn(&client->dev, "SET TIME!\n");
413 }
414 /* ACS is controlled by alarm */
415 i2c_smbus_write_byte_data(client, FM3130_ALARM_WP_CONTROL, 0x80);
416
417 /* TODO */
418 /* TODO need to sanity check alarm */
419 tmp = fm3130->regs[FM3130_RTC_SECONDS];
420 tmp = bcd2bin(tmp & 0x7f);
421 if (tmp > 60)
422 goto exit_bad;
423 tmp = bcd2bin(fm3130->regs[FM3130_RTC_MINUTES] & 0x7f);
424 if (tmp > 60)
425 goto exit_bad;
426
427 tmp = bcd2bin(fm3130->regs[FM3130_RTC_DATE] & 0x3f);
428 if (tmp == 0 || tmp > 31)
429 goto exit_bad;
430
431 tmp = bcd2bin(fm3130->regs[FM3130_RTC_MONTHS] & 0x1f);
432 if (tmp == 0 || tmp > 12)
433 goto exit_bad;
434
435 tmp = fm3130->regs[FM3130_RTC_HOURS];
436
437 fm3130->data_valid = 1;
438
439 exit_bad:
440 if (!fm3130->data_valid)
441 dev_dbg(&client->dev,
442 "%s: %02x %02x %02x %02x %02x %02x %02x %02x"
443 "%02x %02x %02x %02x %02x %02x %02x\n",
444 "bogus registers",
445 fm3130->regs[0], fm3130->regs[1],
446 fm3130->regs[2], fm3130->regs[3],
447 fm3130->regs[4], fm3130->regs[5],
448 fm3130->regs[6], fm3130->regs[7],
449 fm3130->regs[8], fm3130->regs[9],
450 fm3130->regs[0xa], fm3130->regs[0xb],
451 fm3130->regs[0xc], fm3130->regs[0xd],
452 fm3130->regs[0xe]);
453
454 /* We won't bail out here because we just got invalid data.
455 Time setting from u-boot doesn't work anyway */
456 fm3130->rtc = rtc_device_register(client->name, &client->dev,
457 &fm3130_rtc_ops, THIS_MODULE);
458 if (IS_ERR(fm3130->rtc)) {
459 err = PTR_ERR(fm3130->rtc);
460 dev_err(&client->dev,
461 "unable to register the class device\n");
462 goto exit_free;
463 }
464 return 0;
465 exit_free:
466 kfree(fm3130);
467 return err;
468 }
469
470 static int __devexit fm3130_remove(struct i2c_client *client)
471 {
472 struct fm3130 *fm3130 = i2c_get_clientdata(client);
473
474 rtc_device_unregister(fm3130->rtc);
475 kfree(fm3130);
476 return 0;
477 }
478
479 static struct i2c_driver fm3130_driver = {
480 .driver = {
481 .name = "rtc-fm3130",
482 .owner = THIS_MODULE,
483 },
484 .probe = fm3130_probe,
485 .remove = __devexit_p(fm3130_remove),
486 .id_table = fm3130_id,
487 };
488
489 static int __init fm3130_init(void)
490 {
491 return i2c_add_driver(&fm3130_driver);
492 }
493 module_init(fm3130_init);
494
495 static void __exit fm3130_exit(void)
496 {
497 i2c_del_driver(&fm3130_driver);
498 }
499 module_exit(fm3130_exit);
500
501 MODULE_DESCRIPTION("RTC driver for FM3130");
502 MODULE_AUTHOR("Sergey Lapin <slapin@ossfans.org>");
503 MODULE_LICENSE("GPL");
504
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree