blob: b53992ab30908e9987735a32cb8b891b95db8e70 [file] [log] [blame]
David Brownell1abb0dc2006-06-25 05:48:17 -07001/*
2 * rtc-ds1307.c - RTC driver for some mostly-compatible I2C chips.
3 *
4 * Copyright (C) 2005 James Chapman (ds1337 core)
5 * Copyright (C) 2006 David Brownell
Matthias Fuchsa2166852009-03-31 15:24:58 -07006 * Copyright (C) 2009 Matthias Fuchs (rx8025 support)
Bertrand Achardbc48b902013-04-29 16:19:26 -07007 * Copyright (C) 2012 Bertrand Achard (nvram access fixes)
David Brownell1abb0dc2006-06-25 05:48:17 -07008 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14#include <linux/module.h>
15#include <linux/init.h>
16#include <linux/slab.h>
17#include <linux/i2c.h>
18#include <linux/string.h>
19#include <linux/rtc.h>
20#include <linux/bcd.h>
Wolfram Sangeb86c302012-05-29 15:07:38 -070021#include <linux/rtc/ds1307.h>
David Brownell1abb0dc2006-06-25 05:48:17 -070022
David Anders40ce9722012-03-23 15:02:37 -070023/*
24 * We can't determine type by probing, but if we expect pre-Linux code
David Brownell1abb0dc2006-06-25 05:48:17 -070025 * to have set the chip up as a clock (turning on the oscillator and
26 * setting the date and time), Linux can ignore the non-clock features.
27 * That's a natural job for a factory or repair bench.
David Brownell1abb0dc2006-06-25 05:48:17 -070028 */
29enum ds_type {
David Brownell045e0e82007-07-17 04:04:55 -070030 ds_1307,
31 ds_1337,
32 ds_1338,
33 ds_1339,
34 ds_1340,
Joakim Tjernlund33df2ee2009-06-17 16:26:08 -070035 ds_1388,
Wolfram Sang97f902b2009-06-17 16:26:10 -070036 ds_3231,
David Brownell045e0e82007-07-17 04:04:55 -070037 m41t00,
David Anders43fcb812011-11-02 13:37:53 -070038 mcp7941x,
Matthias Fuchsa2166852009-03-31 15:24:58 -070039 rx_8025,
Wolfram Sang32d322b2012-03-23 15:02:36 -070040 last_ds_type /* always last */
David Anders40ce9722012-03-23 15:02:37 -070041 /* rs5c372 too? different address... */
David Brownell1abb0dc2006-06-25 05:48:17 -070042};
43
David Brownell1abb0dc2006-06-25 05:48:17 -070044
45/* RTC registers don't differ much, except for the century flag */
46#define DS1307_REG_SECS 0x00 /* 00-59 */
47# define DS1307_BIT_CH 0x80
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -070048# define DS1340_BIT_nEOSC 0x80
David Anders43fcb812011-11-02 13:37:53 -070049# define MCP7941X_BIT_ST 0x80
David Brownell1abb0dc2006-06-25 05:48:17 -070050#define DS1307_REG_MIN 0x01 /* 00-59 */
51#define DS1307_REG_HOUR 0x02 /* 00-23, or 1-12{am,pm} */
David Brownellc065f352007-07-17 04:05:10 -070052# define DS1307_BIT_12HR 0x40 /* in REG_HOUR */
53# define DS1307_BIT_PM 0x20 /* in REG_HOUR */
David Brownell1abb0dc2006-06-25 05:48:17 -070054# define DS1340_BIT_CENTURY_EN 0x80 /* in REG_HOUR */
55# define DS1340_BIT_CENTURY 0x40 /* in REG_HOUR */
56#define DS1307_REG_WDAY 0x03 /* 01-07 */
David Anders43fcb812011-11-02 13:37:53 -070057# define MCP7941X_BIT_VBATEN 0x08
David Brownell1abb0dc2006-06-25 05:48:17 -070058#define DS1307_REG_MDAY 0x04 /* 01-31 */
59#define DS1307_REG_MONTH 0x05 /* 01-12 */
60# define DS1337_BIT_CENTURY 0x80 /* in REG_MONTH */
61#define DS1307_REG_YEAR 0x06 /* 00-99 */
62
David Anders40ce9722012-03-23 15:02:37 -070063/*
64 * Other registers (control, status, alarms, trickle charge, NVRAM, etc)
David Brownell045e0e82007-07-17 04:04:55 -070065 * start at 7, and they differ a LOT. Only control and status matter for
66 * basic RTC date and time functionality; be careful using them.
David Brownell1abb0dc2006-06-25 05:48:17 -070067 */
David Brownell045e0e82007-07-17 04:04:55 -070068#define DS1307_REG_CONTROL 0x07 /* or ds1338 */
David Brownell1abb0dc2006-06-25 05:48:17 -070069# define DS1307_BIT_OUT 0x80
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -070070# define DS1338_BIT_OSF 0x20
David Brownell1abb0dc2006-06-25 05:48:17 -070071# define DS1307_BIT_SQWE 0x10
72# define DS1307_BIT_RS1 0x02
73# define DS1307_BIT_RS0 0x01
74#define DS1337_REG_CONTROL 0x0e
75# define DS1337_BIT_nEOSC 0x80
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -070076# define DS1339_BIT_BBSQI 0x20
Wolfram Sang97f902b2009-06-17 16:26:10 -070077# define DS3231_BIT_BBSQW 0x40 /* same as BBSQI */
David Brownell1abb0dc2006-06-25 05:48:17 -070078# define DS1337_BIT_RS2 0x10
79# define DS1337_BIT_RS1 0x08
80# define DS1337_BIT_INTCN 0x04
81# define DS1337_BIT_A2IE 0x02
82# define DS1337_BIT_A1IE 0x01
David Brownell045e0e82007-07-17 04:04:55 -070083#define DS1340_REG_CONTROL 0x07
84# define DS1340_BIT_OUT 0x80
85# define DS1340_BIT_FT 0x40
86# define DS1340_BIT_CALIB_SIGN 0x20
87# define DS1340_M_CALIBRATION 0x1f
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -070088#define DS1340_REG_FLAG 0x09
89# define DS1340_BIT_OSF 0x80
David Brownell1abb0dc2006-06-25 05:48:17 -070090#define DS1337_REG_STATUS 0x0f
91# define DS1337_BIT_OSF 0x80
92# define DS1337_BIT_A2I 0x02
93# define DS1337_BIT_A1I 0x01
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -070094#define DS1339_REG_ALARM1_SECS 0x07
Wolfram Sangeb86c302012-05-29 15:07:38 -070095
96#define DS13XX_TRICKLE_CHARGER_MAGIC 0xa0
David Brownell1abb0dc2006-06-25 05:48:17 -070097
Matthias Fuchsa2166852009-03-31 15:24:58 -070098#define RX8025_REG_CTRL1 0x0e
99# define RX8025_BIT_2412 0x20
100#define RX8025_REG_CTRL2 0x0f
101# define RX8025_BIT_PON 0x10
102# define RX8025_BIT_VDET 0x40
103# define RX8025_BIT_XST 0x20
David Brownell1abb0dc2006-06-25 05:48:17 -0700104
105
106struct ds1307 {
Joakim Tjernlund33df2ee2009-06-17 16:26:08 -0700107 u8 offset; /* register's offset */
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700108 u8 regs[11];
Austin Boyle9eab0a72012-03-23 15:02:38 -0700109 u16 nvram_offset;
110 struct bin_attribute *nvram;
David Brownell1abb0dc2006-06-25 05:48:17 -0700111 enum ds_type type;
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700112 unsigned long flags;
113#define HAS_NVRAM 0 /* bit 0 == sysfs file active */
114#define HAS_ALARM 1 /* bit 1 == irq claimed */
David Brownell045e0e82007-07-17 04:04:55 -0700115 struct i2c_client *client;
David Brownell1abb0dc2006-06-25 05:48:17 -0700116 struct rtc_device *rtc;
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700117 struct work_struct work;
Jean Delvare0cc43a12011-01-10 22:11:23 +0100118 s32 (*read_block_data)(const struct i2c_client *client, u8 command,
Ed Swierk30e7b032009-03-31 15:24:56 -0700119 u8 length, u8 *values);
Jean Delvare0cc43a12011-01-10 22:11:23 +0100120 s32 (*write_block_data)(const struct i2c_client *client, u8 command,
Ed Swierk30e7b032009-03-31 15:24:56 -0700121 u8 length, const u8 *values);
David Brownell1abb0dc2006-06-25 05:48:17 -0700122};
123
David Brownell045e0e82007-07-17 04:04:55 -0700124struct chip_desc {
David Brownell045e0e82007-07-17 04:04:55 -0700125 unsigned alarm:1;
Austin Boyle9eab0a72012-03-23 15:02:38 -0700126 u16 nvram_offset;
127 u16 nvram_size;
Wolfram Sangeb86c302012-05-29 15:07:38 -0700128 u16 trickle_charger_reg;
David Brownell045e0e82007-07-17 04:04:55 -0700129};
130
Wolfram Sang32d322b2012-03-23 15:02:36 -0700131static const struct chip_desc chips[last_ds_type] = {
132 [ds_1307] = {
Austin Boyle9eab0a72012-03-23 15:02:38 -0700133 .nvram_offset = 8,
134 .nvram_size = 56,
Wolfram Sang32d322b2012-03-23 15:02:36 -0700135 },
136 [ds_1337] = {
137 .alarm = 1,
138 },
139 [ds_1338] = {
Austin Boyle9eab0a72012-03-23 15:02:38 -0700140 .nvram_offset = 8,
141 .nvram_size = 56,
Wolfram Sang32d322b2012-03-23 15:02:36 -0700142 },
143 [ds_1339] = {
144 .alarm = 1,
Wolfram Sangeb86c302012-05-29 15:07:38 -0700145 .trickle_charger_reg = 0x10,
146 },
147 [ds_1340] = {
148 .trickle_charger_reg = 0x08,
149 },
150 [ds_1388] = {
151 .trickle_charger_reg = 0x0a,
Wolfram Sang32d322b2012-03-23 15:02:36 -0700152 },
153 [ds_3231] = {
154 .alarm = 1,
155 },
Austin Boyle9eab0a72012-03-23 15:02:38 -0700156 [mcp7941x] = {
157 /* this is battery backed SRAM */
158 .nvram_offset = 0x20,
159 .nvram_size = 0x40,
160 },
Wolfram Sang32d322b2012-03-23 15:02:36 -0700161};
David Brownell045e0e82007-07-17 04:04:55 -0700162
Jean Delvare3760f732008-04-29 23:11:40 +0200163static const struct i2c_device_id ds1307_id[] = {
164 { "ds1307", ds_1307 },
165 { "ds1337", ds_1337 },
166 { "ds1338", ds_1338 },
167 { "ds1339", ds_1339 },
Joakim Tjernlund33df2ee2009-06-17 16:26:08 -0700168 { "ds1388", ds_1388 },
Jean Delvare3760f732008-04-29 23:11:40 +0200169 { "ds1340", ds_1340 },
Wolfram Sang97f902b2009-06-17 16:26:10 -0700170 { "ds3231", ds_3231 },
Jean Delvare3760f732008-04-29 23:11:40 +0200171 { "m41t00", m41t00 },
David Anders43fcb812011-11-02 13:37:53 -0700172 { "mcp7941x", mcp7941x },
Priyanka Jain31c17712011-06-27 16:18:04 -0700173 { "pt7c4338", ds_1307 },
Matthias Fuchsa2166852009-03-31 15:24:58 -0700174 { "rx8025", rx_8025 },
Jean Delvare3760f732008-04-29 23:11:40 +0200175 { }
176};
177MODULE_DEVICE_TABLE(i2c, ds1307_id);
David Brownell1abb0dc2006-06-25 05:48:17 -0700178
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700179/*----------------------------------------------------------------------*/
180
Ed Swierk30e7b032009-03-31 15:24:56 -0700181#define BLOCK_DATA_MAX_TRIES 10
182
Jean Delvare0cc43a12011-01-10 22:11:23 +0100183static s32 ds1307_read_block_data_once(const struct i2c_client *client,
184 u8 command, u8 length, u8 *values)
Ed Swierk30e7b032009-03-31 15:24:56 -0700185{
186 s32 i, data;
187
188 for (i = 0; i < length; i++) {
189 data = i2c_smbus_read_byte_data(client, command + i);
190 if (data < 0)
191 return data;
192 values[i] = data;
193 }
194 return i;
195}
196
Jean Delvare0cc43a12011-01-10 22:11:23 +0100197static s32 ds1307_read_block_data(const struct i2c_client *client, u8 command,
Ed Swierk30e7b032009-03-31 15:24:56 -0700198 u8 length, u8 *values)
199{
Bertrand Achardbc48b902013-04-29 16:19:26 -0700200 u8 oldvalues[255];
Ed Swierk30e7b032009-03-31 15:24:56 -0700201 s32 ret;
202 int tries = 0;
203
204 dev_dbg(&client->dev, "ds1307_read_block_data (length=%d)\n", length);
205 ret = ds1307_read_block_data_once(client, command, length, values);
206 if (ret < 0)
207 return ret;
208 do {
209 if (++tries > BLOCK_DATA_MAX_TRIES) {
210 dev_err(&client->dev,
211 "ds1307_read_block_data failed\n");
212 return -EIO;
213 }
214 memcpy(oldvalues, values, length);
215 ret = ds1307_read_block_data_once(client, command, length,
216 values);
217 if (ret < 0)
218 return ret;
219 } while (memcmp(oldvalues, values, length));
220 return length;
221}
222
Jean Delvare0cc43a12011-01-10 22:11:23 +0100223static s32 ds1307_write_block_data(const struct i2c_client *client, u8 command,
Ed Swierk30e7b032009-03-31 15:24:56 -0700224 u8 length, const u8 *values)
225{
Bertrand Achardbc48b902013-04-29 16:19:26 -0700226 u8 currvalues[255];
Ed Swierk30e7b032009-03-31 15:24:56 -0700227 int tries = 0;
228
229 dev_dbg(&client->dev, "ds1307_write_block_data (length=%d)\n", length);
230 do {
231 s32 i, ret;
232
233 if (++tries > BLOCK_DATA_MAX_TRIES) {
234 dev_err(&client->dev,
235 "ds1307_write_block_data failed\n");
236 return -EIO;
237 }
238 for (i = 0; i < length; i++) {
239 ret = i2c_smbus_write_byte_data(client, command + i,
240 values[i]);
241 if (ret < 0)
242 return ret;
243 }
244 ret = ds1307_read_block_data_once(client, command, length,
245 currvalues);
246 if (ret < 0)
247 return ret;
248 } while (memcmp(currvalues, values, length));
249 return length;
250}
251
252/*----------------------------------------------------------------------*/
253
Bertrand Achardbc48b902013-04-29 16:19:26 -0700254/* These RTC devices are not designed to be connected to a SMbus adapter.
255 SMbus limits block operations length to 32 bytes, whereas it's not
256 limited on I2C buses. As a result, accesses may exceed 32 bytes;
257 in that case, split them into smaller blocks */
258
259static s32 ds1307_native_smbus_write_block_data(const struct i2c_client *client,
260 u8 command, u8 length, const u8 *values)
261{
262 u8 suboffset = 0;
263
264 if (length <= I2C_SMBUS_BLOCK_MAX)
265 return i2c_smbus_write_i2c_block_data(client,
266 command, length, values);
267
268 while (suboffset < length) {
269 s32 retval = i2c_smbus_write_i2c_block_data(client,
270 command + suboffset,
271 min(I2C_SMBUS_BLOCK_MAX, length - suboffset),
272 values + suboffset);
273 if (retval < 0)
274 return retval;
275
276 suboffset += I2C_SMBUS_BLOCK_MAX;
277 }
278 return length;
279}
280
281static s32 ds1307_native_smbus_read_block_data(const struct i2c_client *client,
282 u8 command, u8 length, u8 *values)
283{
284 u8 suboffset = 0;
285
286 if (length <= I2C_SMBUS_BLOCK_MAX)
287 return i2c_smbus_read_i2c_block_data(client,
288 command, length, values);
289
290 while (suboffset < length) {
291 s32 retval = i2c_smbus_read_i2c_block_data(client,
292 command + suboffset,
293 min(I2C_SMBUS_BLOCK_MAX, length - suboffset),
294 values + suboffset);
295 if (retval < 0)
296 return retval;
297
298 suboffset += I2C_SMBUS_BLOCK_MAX;
299 }
300 return length;
301}
302
303/*----------------------------------------------------------------------*/
304
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700305/*
306 * The IRQ logic includes a "real" handler running in IRQ context just
307 * long enough to schedule this workqueue entry. We need a task context
308 * to talk to the RTC, since I2C I/O calls require that; and disable the
309 * IRQ until we clear its status on the chip, so that this handler can
310 * work with any type of triggering (not just falling edge).
311 *
312 * The ds1337 and ds1339 both have two alarms, but we only use the first
313 * one (with a "seconds" field). For ds1337 we expect nINTA is our alarm
314 * signal; ds1339 chips have only one alarm signal.
315 */
316static void ds1307_work(struct work_struct *work)
317{
318 struct ds1307 *ds1307;
319 struct i2c_client *client;
320 struct mutex *lock;
321 int stat, control;
322
323 ds1307 = container_of(work, struct ds1307, work);
324 client = ds1307->client;
325 lock = &ds1307->rtc->ops_lock;
326
327 mutex_lock(lock);
328 stat = i2c_smbus_read_byte_data(client, DS1337_REG_STATUS);
329 if (stat < 0)
330 goto out;
331
332 if (stat & DS1337_BIT_A1I) {
333 stat &= ~DS1337_BIT_A1I;
334 i2c_smbus_write_byte_data(client, DS1337_REG_STATUS, stat);
335
336 control = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
337 if (control < 0)
338 goto out;
339
340 control &= ~DS1337_BIT_A1IE;
341 i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL, control);
342
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700343 rtc_update_irq(ds1307->rtc, 1, RTC_AF | RTC_IRQF);
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700344 }
345
346out:
347 if (test_bit(HAS_ALARM, &ds1307->flags))
348 enable_irq(client->irq);
349 mutex_unlock(lock);
350}
351
352static irqreturn_t ds1307_irq(int irq, void *dev_id)
353{
354 struct i2c_client *client = dev_id;
355 struct ds1307 *ds1307 = i2c_get_clientdata(client);
356
357 disable_irq_nosync(irq);
358 schedule_work(&ds1307->work);
359 return IRQ_HANDLED;
360}
361
362/*----------------------------------------------------------------------*/
363
David Brownell1abb0dc2006-06-25 05:48:17 -0700364static int ds1307_get_time(struct device *dev, struct rtc_time *t)
365{
366 struct ds1307 *ds1307 = dev_get_drvdata(dev);
367 int tmp;
368
David Brownell045e0e82007-07-17 04:04:55 -0700369 /* read the RTC date and time registers all at once */
Ed Swierk30e7b032009-03-31 15:24:56 -0700370 tmp = ds1307->read_block_data(ds1307->client,
Joakim Tjernlund33df2ee2009-06-17 16:26:08 -0700371 ds1307->offset, 7, ds1307->regs);
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800372 if (tmp != 7) {
David Brownell1abb0dc2006-06-25 05:48:17 -0700373 dev_err(dev, "%s error %d\n", "read", tmp);
374 return -EIO;
375 }
376
Andy Shevchenko01a4ca12013-02-21 16:44:22 -0800377 dev_dbg(dev, "%s: %7ph\n", "read", ds1307->regs);
David Brownell1abb0dc2006-06-25 05:48:17 -0700378
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700379 t->tm_sec = bcd2bin(ds1307->regs[DS1307_REG_SECS] & 0x7f);
380 t->tm_min = bcd2bin(ds1307->regs[DS1307_REG_MIN] & 0x7f);
David Brownell1abb0dc2006-06-25 05:48:17 -0700381 tmp = ds1307->regs[DS1307_REG_HOUR] & 0x3f;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700382 t->tm_hour = bcd2bin(tmp);
383 t->tm_wday = bcd2bin(ds1307->regs[DS1307_REG_WDAY] & 0x07) - 1;
384 t->tm_mday = bcd2bin(ds1307->regs[DS1307_REG_MDAY] & 0x3f);
David Brownell1abb0dc2006-06-25 05:48:17 -0700385 tmp = ds1307->regs[DS1307_REG_MONTH] & 0x1f;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700386 t->tm_mon = bcd2bin(tmp) - 1;
David Brownell1abb0dc2006-06-25 05:48:17 -0700387
388 /* assume 20YY not 19YY, and ignore DS1337_BIT_CENTURY */
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700389 t->tm_year = bcd2bin(ds1307->regs[DS1307_REG_YEAR]) + 100;
David Brownell1abb0dc2006-06-25 05:48:17 -0700390
391 dev_dbg(dev, "%s secs=%d, mins=%d, "
392 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
393 "read", t->tm_sec, t->tm_min,
394 t->tm_hour, t->tm_mday,
395 t->tm_mon, t->tm_year, t->tm_wday);
396
David Brownell045e0e82007-07-17 04:04:55 -0700397 /* initial clock setting can be undefined */
398 return rtc_valid_tm(t);
David Brownell1abb0dc2006-06-25 05:48:17 -0700399}
400
401static int ds1307_set_time(struct device *dev, struct rtc_time *t)
402{
403 struct ds1307 *ds1307 = dev_get_drvdata(dev);
404 int result;
405 int tmp;
406 u8 *buf = ds1307->regs;
407
408 dev_dbg(dev, "%s secs=%d, mins=%d, "
409 "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
Jeff Garzik11966ad2006-10-04 04:41:53 -0400410 "write", t->tm_sec, t->tm_min,
411 t->tm_hour, t->tm_mday,
412 t->tm_mon, t->tm_year, t->tm_wday);
David Brownell1abb0dc2006-06-25 05:48:17 -0700413
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700414 buf[DS1307_REG_SECS] = bin2bcd(t->tm_sec);
415 buf[DS1307_REG_MIN] = bin2bcd(t->tm_min);
416 buf[DS1307_REG_HOUR] = bin2bcd(t->tm_hour);
417 buf[DS1307_REG_WDAY] = bin2bcd(t->tm_wday + 1);
418 buf[DS1307_REG_MDAY] = bin2bcd(t->tm_mday);
419 buf[DS1307_REG_MONTH] = bin2bcd(t->tm_mon + 1);
David Brownell1abb0dc2006-06-25 05:48:17 -0700420
421 /* assume 20YY not 19YY */
422 tmp = t->tm_year - 100;
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700423 buf[DS1307_REG_YEAR] = bin2bcd(tmp);
David Brownell1abb0dc2006-06-25 05:48:17 -0700424
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700425 switch (ds1307->type) {
426 case ds_1337:
427 case ds_1339:
Wolfram Sang97f902b2009-06-17 16:26:10 -0700428 case ds_3231:
David Brownell1abb0dc2006-06-25 05:48:17 -0700429 buf[DS1307_REG_MONTH] |= DS1337_BIT_CENTURY;
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700430 break;
431 case ds_1340:
David Brownell1abb0dc2006-06-25 05:48:17 -0700432 buf[DS1307_REG_HOUR] |= DS1340_BIT_CENTURY_EN
433 | DS1340_BIT_CENTURY;
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700434 break;
David Anders43fcb812011-11-02 13:37:53 -0700435 case mcp7941x:
David Anders40ce9722012-03-23 15:02:37 -0700436 /*
437 * these bits were cleared when preparing the date/time
438 * values and need to be set again before writing the
439 * buffer out to the device.
440 */
David Anders43fcb812011-11-02 13:37:53 -0700441 buf[DS1307_REG_SECS] |= MCP7941X_BIT_ST;
442 buf[DS1307_REG_WDAY] |= MCP7941X_BIT_VBATEN;
443 break;
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700444 default:
445 break;
446 }
David Brownell1abb0dc2006-06-25 05:48:17 -0700447
Andy Shevchenko01a4ca12013-02-21 16:44:22 -0800448 dev_dbg(dev, "%s: %7ph\n", "write", buf);
David Brownell1abb0dc2006-06-25 05:48:17 -0700449
Joakim Tjernlund33df2ee2009-06-17 16:26:08 -0700450 result = ds1307->write_block_data(ds1307->client,
451 ds1307->offset, 7, buf);
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800452 if (result < 0) {
453 dev_err(dev, "%s error %d\n", "write", result);
454 return result;
David Brownell1abb0dc2006-06-25 05:48:17 -0700455 }
456 return 0;
457}
458
Jüri Reitel74d88eb2009-01-07 18:07:16 -0800459static int ds1337_read_alarm(struct device *dev, struct rtc_wkalrm *t)
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700460{
461 struct i2c_client *client = to_i2c_client(dev);
462 struct ds1307 *ds1307 = i2c_get_clientdata(client);
463 int ret;
464
465 if (!test_bit(HAS_ALARM, &ds1307->flags))
466 return -EINVAL;
467
468 /* read all ALARM1, ALARM2, and status registers at once */
Ed Swierk30e7b032009-03-31 15:24:56 -0700469 ret = ds1307->read_block_data(client,
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800470 DS1339_REG_ALARM1_SECS, 9, ds1307->regs);
471 if (ret != 9) {
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700472 dev_err(dev, "%s error %d\n", "alarm read", ret);
473 return -EIO;
474 }
475
476 dev_dbg(dev, "%s: %02x %02x %02x %02x, %02x %02x %02x, %02x %02x\n",
477 "alarm read",
478 ds1307->regs[0], ds1307->regs[1],
479 ds1307->regs[2], ds1307->regs[3],
480 ds1307->regs[4], ds1307->regs[5],
481 ds1307->regs[6], ds1307->regs[7],
482 ds1307->regs[8]);
483
David Anders40ce9722012-03-23 15:02:37 -0700484 /*
485 * report alarm time (ALARM1); assume 24 hour and day-of-month modes,
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700486 * and that all four fields are checked matches
487 */
488 t->time.tm_sec = bcd2bin(ds1307->regs[0] & 0x7f);
489 t->time.tm_min = bcd2bin(ds1307->regs[1] & 0x7f);
490 t->time.tm_hour = bcd2bin(ds1307->regs[2] & 0x3f);
491 t->time.tm_mday = bcd2bin(ds1307->regs[3] & 0x3f);
492 t->time.tm_mon = -1;
493 t->time.tm_year = -1;
494 t->time.tm_wday = -1;
495 t->time.tm_yday = -1;
496 t->time.tm_isdst = -1;
497
498 /* ... and status */
499 t->enabled = !!(ds1307->regs[7] & DS1337_BIT_A1IE);
500 t->pending = !!(ds1307->regs[8] & DS1337_BIT_A1I);
501
502 dev_dbg(dev, "%s secs=%d, mins=%d, "
503 "hours=%d, mday=%d, enabled=%d, pending=%d\n",
504 "alarm read", t->time.tm_sec, t->time.tm_min,
505 t->time.tm_hour, t->time.tm_mday,
506 t->enabled, t->pending);
507
508 return 0;
509}
510
Jüri Reitel74d88eb2009-01-07 18:07:16 -0800511static int ds1337_set_alarm(struct device *dev, struct rtc_wkalrm *t)
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700512{
David Anders40ce9722012-03-23 15:02:37 -0700513 struct i2c_client *client = to_i2c_client(dev);
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700514 struct ds1307 *ds1307 = i2c_get_clientdata(client);
515 unsigned char *buf = ds1307->regs;
516 u8 control, status;
517 int ret;
518
519 if (!test_bit(HAS_ALARM, &ds1307->flags))
520 return -EINVAL;
521
522 dev_dbg(dev, "%s secs=%d, mins=%d, "
523 "hours=%d, mday=%d, enabled=%d, pending=%d\n",
524 "alarm set", t->time.tm_sec, t->time.tm_min,
525 t->time.tm_hour, t->time.tm_mday,
526 t->enabled, t->pending);
527
528 /* read current status of both alarms and the chip */
Ed Swierk30e7b032009-03-31 15:24:56 -0700529 ret = ds1307->read_block_data(client,
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800530 DS1339_REG_ALARM1_SECS, 9, buf);
531 if (ret != 9) {
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700532 dev_err(dev, "%s error %d\n", "alarm write", ret);
533 return -EIO;
534 }
535 control = ds1307->regs[7];
536 status = ds1307->regs[8];
537
538 dev_dbg(dev, "%s: %02x %02x %02x %02x, %02x %02x %02x, %02x %02x\n",
539 "alarm set (old status)",
540 ds1307->regs[0], ds1307->regs[1],
541 ds1307->regs[2], ds1307->regs[3],
542 ds1307->regs[4], ds1307->regs[5],
543 ds1307->regs[6], control, status);
544
545 /* set ALARM1, using 24 hour and day-of-month modes */
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700546 buf[0] = bin2bcd(t->time.tm_sec);
547 buf[1] = bin2bcd(t->time.tm_min);
548 buf[2] = bin2bcd(t->time.tm_hour);
549 buf[3] = bin2bcd(t->time.tm_mday);
550
551 /* set ALARM2 to non-garbage */
552 buf[4] = 0;
553 buf[5] = 0;
554 buf[6] = 0;
555
556 /* optionally enable ALARM1 */
557 buf[7] = control & ~(DS1337_BIT_A1IE | DS1337_BIT_A2IE);
558 if (t->enabled) {
559 dev_dbg(dev, "alarm IRQ armed\n");
560 buf[7] |= DS1337_BIT_A1IE; /* only ALARM1 is used */
561 }
562 buf[8] = status & ~(DS1337_BIT_A1I | DS1337_BIT_A2I);
563
Ed Swierk30e7b032009-03-31 15:24:56 -0700564 ret = ds1307->write_block_data(client,
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800565 DS1339_REG_ALARM1_SECS, 9, buf);
566 if (ret < 0) {
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700567 dev_err(dev, "can't set alarm time\n");
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800568 return ret;
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700569 }
570
571 return 0;
572}
573
John Stultz16380c12011-02-02 17:02:41 -0800574static int ds1307_alarm_irq_enable(struct device *dev, unsigned int enabled)
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700575{
576 struct i2c_client *client = to_i2c_client(dev);
577 struct ds1307 *ds1307 = i2c_get_clientdata(client);
578 int ret;
579
John Stultz16380c12011-02-02 17:02:41 -0800580 if (!test_bit(HAS_ALARM, &ds1307->flags))
581 return -ENOTTY;
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700582
John Stultz16380c12011-02-02 17:02:41 -0800583 ret = i2c_smbus_read_byte_data(client, DS1337_REG_CONTROL);
584 if (ret < 0)
585 return ret;
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700586
John Stultz16380c12011-02-02 17:02:41 -0800587 if (enabled)
588 ret |= DS1337_BIT_A1IE;
589 else
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700590 ret &= ~DS1337_BIT_A1IE;
591
John Stultz16380c12011-02-02 17:02:41 -0800592 ret = i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL, ret);
593 if (ret < 0)
594 return ret;
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700595
596 return 0;
597}
598
David Brownellff8371a2006-09-30 23:28:17 -0700599static const struct rtc_class_ops ds13xx_rtc_ops = {
David Brownell1abb0dc2006-06-25 05:48:17 -0700600 .read_time = ds1307_get_time,
601 .set_time = ds1307_set_time,
Jüri Reitel74d88eb2009-01-07 18:07:16 -0800602 .read_alarm = ds1337_read_alarm,
603 .set_alarm = ds1337_set_alarm,
John Stultz16380c12011-02-02 17:02:41 -0800604 .alarm_irq_enable = ds1307_alarm_irq_enable,
David Brownell1abb0dc2006-06-25 05:48:17 -0700605};
606
David Brownell682d73f2007-11-14 16:58:32 -0800607/*----------------------------------------------------------------------*/
608
David Brownell682d73f2007-11-14 16:58:32 -0800609static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700610ds1307_nvram_read(struct file *filp, struct kobject *kobj,
611 struct bin_attribute *attr,
David Brownell682d73f2007-11-14 16:58:32 -0800612 char *buf, loff_t off, size_t count)
613{
614 struct i2c_client *client;
615 struct ds1307 *ds1307;
David Brownell682d73f2007-11-14 16:58:32 -0800616 int result;
617
frederic Rodofcd8db02008-02-06 01:38:55 -0800618 client = kobj_to_i2c_client(kobj);
David Brownell682d73f2007-11-14 16:58:32 -0800619 ds1307 = i2c_get_clientdata(client);
620
Austin Boyle9eab0a72012-03-23 15:02:38 -0700621 if (unlikely(off >= ds1307->nvram->size))
David Brownell682d73f2007-11-14 16:58:32 -0800622 return 0;
Austin Boyle9eab0a72012-03-23 15:02:38 -0700623 if ((off + count) > ds1307->nvram->size)
624 count = ds1307->nvram->size - off;
David Brownell682d73f2007-11-14 16:58:32 -0800625 if (unlikely(!count))
626 return count;
627
Austin Boyle9eab0a72012-03-23 15:02:38 -0700628 result = ds1307->read_block_data(client, ds1307->nvram_offset + off,
629 count, buf);
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800630 if (result < 0)
David Brownell682d73f2007-11-14 16:58:32 -0800631 dev_err(&client->dev, "%s error %d\n", "nvram read", result);
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800632 return result;
David Brownell682d73f2007-11-14 16:58:32 -0800633}
634
635static ssize_t
Chris Wright2c3c8be2010-05-12 18:28:57 -0700636ds1307_nvram_write(struct file *filp, struct kobject *kobj,
637 struct bin_attribute *attr,
David Brownell682d73f2007-11-14 16:58:32 -0800638 char *buf, loff_t off, size_t count)
639{
640 struct i2c_client *client;
Ed Swierk30e7b032009-03-31 15:24:56 -0700641 struct ds1307 *ds1307;
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800642 int result;
David Brownell682d73f2007-11-14 16:58:32 -0800643
frederic Rodofcd8db02008-02-06 01:38:55 -0800644 client = kobj_to_i2c_client(kobj);
Ed Swierk30e7b032009-03-31 15:24:56 -0700645 ds1307 = i2c_get_clientdata(client);
David Brownell682d73f2007-11-14 16:58:32 -0800646
Austin Boyle9eab0a72012-03-23 15:02:38 -0700647 if (unlikely(off >= ds1307->nvram->size))
David Brownell682d73f2007-11-14 16:58:32 -0800648 return -EFBIG;
Austin Boyle9eab0a72012-03-23 15:02:38 -0700649 if ((off + count) > ds1307->nvram->size)
650 count = ds1307->nvram->size - off;
David Brownell682d73f2007-11-14 16:58:32 -0800651 if (unlikely(!count))
652 return count;
653
Austin Boyle9eab0a72012-03-23 15:02:38 -0700654 result = ds1307->write_block_data(client, ds1307->nvram_offset + off,
655 count, buf);
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800656 if (result < 0) {
657 dev_err(&client->dev, "%s error %d\n", "nvram write", result);
658 return result;
659 }
660 return count;
David Brownell682d73f2007-11-14 16:58:32 -0800661}
662
David Brownell682d73f2007-11-14 16:58:32 -0800663/*----------------------------------------------------------------------*/
664
Greg Kroah-Hartman5a167f42012-12-21 13:09:38 -0800665static int ds1307_probe(struct i2c_client *client,
666 const struct i2c_device_id *id)
David Brownell1abb0dc2006-06-25 05:48:17 -0700667{
668 struct ds1307 *ds1307;
669 int err = -ENODEV;
David Brownell1abb0dc2006-06-25 05:48:17 -0700670 int tmp;
Jean Delvare3760f732008-04-29 23:11:40 +0200671 const struct chip_desc *chip = &chips[id->driver_data];
David Brownellc065f352007-07-17 04:05:10 -0700672 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700673 int want_irq = false;
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800674 unsigned char *buf;
Wolfram Sangeb86c302012-05-29 15:07:38 -0700675 struct ds1307_platform_data *pdata = client->dev.platform_data;
Wolfram Sang97f902b2009-06-17 16:26:10 -0700676 static const int bbsqi_bitpos[] = {
677 [ds_1337] = 0,
678 [ds_1339] = DS1339_BIT_BBSQI,
679 [ds_3231] = DS3231_BIT_BBSQW,
680 };
David Brownell1abb0dc2006-06-25 05:48:17 -0700681
Ed Swierk30e7b032009-03-31 15:24:56 -0700682 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)
683 && !i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
David Brownellc065f352007-07-17 04:05:10 -0700684 return -EIO;
David Brownell1abb0dc2006-06-25 05:48:17 -0700685
David Anders40ce9722012-03-23 15:02:37 -0700686 ds1307 = kzalloc(sizeof(struct ds1307), GFP_KERNEL);
687 if (!ds1307)
David Brownellc065f352007-07-17 04:05:10 -0700688 return -ENOMEM;
David Brownell045e0e82007-07-17 04:04:55 -0700689
David Brownell1abb0dc2006-06-25 05:48:17 -0700690 i2c_set_clientdata(client, ds1307);
Joakim Tjernlund33df2ee2009-06-17 16:26:08 -0700691
692 ds1307->client = client;
693 ds1307->type = id->driver_data;
Joakim Tjernlund33df2ee2009-06-17 16:26:08 -0700694
Wolfram Sangeb86c302012-05-29 15:07:38 -0700695 if (pdata && pdata->trickle_charger_setup && chip->trickle_charger_reg)
696 i2c_smbus_write_byte_data(client, chip->trickle_charger_reg,
697 DS13XX_TRICKLE_CHARGER_MAGIC | pdata->trickle_charger_setup);
698
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800699 buf = ds1307->regs;
Ed Swierk30e7b032009-03-31 15:24:56 -0700700 if (i2c_check_functionality(adapter, I2C_FUNC_SMBUS_I2C_BLOCK)) {
Bertrand Achardbc48b902013-04-29 16:19:26 -0700701 ds1307->read_block_data = ds1307_native_smbus_read_block_data;
702 ds1307->write_block_data = ds1307_native_smbus_write_block_data;
Ed Swierk30e7b032009-03-31 15:24:56 -0700703 } else {
704 ds1307->read_block_data = ds1307_read_block_data;
705 ds1307->write_block_data = ds1307_write_block_data;
706 }
David Brownell045e0e82007-07-17 04:04:55 -0700707
708 switch (ds1307->type) {
709 case ds_1337:
710 case ds_1339:
Wolfram Sang97f902b2009-06-17 16:26:10 -0700711 case ds_3231:
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700712 /* get registers that the "rtc" read below won't read... */
Ed Swierk30e7b032009-03-31 15:24:56 -0700713 tmp = ds1307->read_block_data(ds1307->client,
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800714 DS1337_REG_CONTROL, 2, buf);
David Brownell1abb0dc2006-06-25 05:48:17 -0700715 if (tmp != 2) {
Jingoo Han6df80e22013-04-29 16:19:28 -0700716 dev_dbg(&client->dev, "read error %d\n", tmp);
David Brownell1abb0dc2006-06-25 05:48:17 -0700717 err = -EIO;
718 goto exit_free;
719 }
720
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700721 /* oscillator off? turn it on, so clock can tick. */
722 if (ds1307->regs[0] & DS1337_BIT_nEOSC)
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700723 ds1307->regs[0] &= ~DS1337_BIT_nEOSC;
724
David Anders40ce9722012-03-23 15:02:37 -0700725 /*
726 * Using IRQ? Disable the square wave and both alarms.
Wolfram Sang97f902b2009-06-17 16:26:10 -0700727 * For some variants, be sure alarms can trigger when we're
728 * running on Vbackup (BBSQI/BBSQW)
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700729 */
Wolfram Sangb24a7262012-03-23 15:02:37 -0700730 if (ds1307->client->irq > 0 && chip->alarm) {
731 INIT_WORK(&ds1307->work, ds1307_work);
732
Wolfram Sang97f902b2009-06-17 16:26:10 -0700733 ds1307->regs[0] |= DS1337_BIT_INTCN
734 | bbsqi_bitpos[ds1307->type];
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700735 ds1307->regs[0] &= ~(DS1337_BIT_A2IE | DS1337_BIT_A1IE);
Wolfram Sangb24a7262012-03-23 15:02:37 -0700736
737 want_irq = true;
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700738 }
739
740 i2c_smbus_write_byte_data(client, DS1337_REG_CONTROL,
741 ds1307->regs[0]);
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700742
743 /* oscillator fault? clear flag, and warn */
744 if (ds1307->regs[1] & DS1337_BIT_OSF) {
745 i2c_smbus_write_byte_data(client, DS1337_REG_STATUS,
746 ds1307->regs[1] & ~DS1337_BIT_OSF);
747 dev_warn(&client->dev, "SET TIME!\n");
David Brownell1abb0dc2006-06-25 05:48:17 -0700748 }
David Brownell045e0e82007-07-17 04:04:55 -0700749 break;
Matthias Fuchsa2166852009-03-31 15:24:58 -0700750
751 case rx_8025:
752 tmp = i2c_smbus_read_i2c_block_data(ds1307->client,
753 RX8025_REG_CTRL1 << 4 | 0x08, 2, buf);
754 if (tmp != 2) {
Jingoo Han6df80e22013-04-29 16:19:28 -0700755 dev_dbg(&client->dev, "read error %d\n", tmp);
Matthias Fuchsa2166852009-03-31 15:24:58 -0700756 err = -EIO;
757 goto exit_free;
758 }
759
760 /* oscillator off? turn it on, so clock can tick. */
761 if (!(ds1307->regs[1] & RX8025_BIT_XST)) {
762 ds1307->regs[1] |= RX8025_BIT_XST;
763 i2c_smbus_write_byte_data(client,
764 RX8025_REG_CTRL2 << 4 | 0x08,
765 ds1307->regs[1]);
766 dev_warn(&client->dev,
767 "oscillator stop detected - SET TIME!\n");
768 }
769
770 if (ds1307->regs[1] & RX8025_BIT_PON) {
771 ds1307->regs[1] &= ~RX8025_BIT_PON;
772 i2c_smbus_write_byte_data(client,
773 RX8025_REG_CTRL2 << 4 | 0x08,
774 ds1307->regs[1]);
775 dev_warn(&client->dev, "power-on detected\n");
776 }
777
778 if (ds1307->regs[1] & RX8025_BIT_VDET) {
779 ds1307->regs[1] &= ~RX8025_BIT_VDET;
780 i2c_smbus_write_byte_data(client,
781 RX8025_REG_CTRL2 << 4 | 0x08,
782 ds1307->regs[1]);
783 dev_warn(&client->dev, "voltage drop detected\n");
784 }
785
786 /* make sure we are running in 24hour mode */
787 if (!(ds1307->regs[0] & RX8025_BIT_2412)) {
788 u8 hour;
789
790 /* switch to 24 hour mode */
791 i2c_smbus_write_byte_data(client,
792 RX8025_REG_CTRL1 << 4 | 0x08,
793 ds1307->regs[0] |
794 RX8025_BIT_2412);
795
796 tmp = i2c_smbus_read_i2c_block_data(ds1307->client,
797 RX8025_REG_CTRL1 << 4 | 0x08, 2, buf);
798 if (tmp != 2) {
Jingoo Han6df80e22013-04-29 16:19:28 -0700799 dev_dbg(&client->dev, "read error %d\n", tmp);
Matthias Fuchsa2166852009-03-31 15:24:58 -0700800 err = -EIO;
801 goto exit_free;
802 }
803
804 /* correct hour */
805 hour = bcd2bin(ds1307->regs[DS1307_REG_HOUR]);
806 if (hour == 12)
807 hour = 0;
808 if (ds1307->regs[DS1307_REG_HOUR] & DS1307_BIT_PM)
809 hour += 12;
810
811 i2c_smbus_write_byte_data(client,
812 DS1307_REG_HOUR << 4 | 0x08,
813 hour);
814 }
815 break;
Joakim Tjernlund33df2ee2009-06-17 16:26:08 -0700816 case ds_1388:
817 ds1307->offset = 1; /* Seconds starts at 1 */
818 break;
David Brownell045e0e82007-07-17 04:04:55 -0700819 default:
820 break;
821 }
David Brownell1abb0dc2006-06-25 05:48:17 -0700822
823read_rtc:
824 /* read RTC registers */
Joakim Tjernlund96fc3a42010-06-29 15:05:34 -0700825 tmp = ds1307->read_block_data(ds1307->client, ds1307->offset, 8, buf);
BARRE Sebastienfed40b72009-01-07 18:07:13 -0800826 if (tmp != 8) {
Jingoo Han6df80e22013-04-29 16:19:28 -0700827 dev_dbg(&client->dev, "read error %d\n", tmp);
David Brownell1abb0dc2006-06-25 05:48:17 -0700828 err = -EIO;
829 goto exit_free;
830 }
831
David Anders40ce9722012-03-23 15:02:37 -0700832 /*
833 * minimal sanity checking; some chips (like DS1340) don't
David Brownell1abb0dc2006-06-25 05:48:17 -0700834 * specify the extra bits as must-be-zero, but there are
835 * still a few values that are clearly out-of-range.
836 */
837 tmp = ds1307->regs[DS1307_REG_SECS];
David Brownell045e0e82007-07-17 04:04:55 -0700838 switch (ds1307->type) {
839 case ds_1307:
David Brownell045e0e82007-07-17 04:04:55 -0700840 case m41t00:
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700841 /* clock halted? turn it on, so clock can tick. */
David Brownell045e0e82007-07-17 04:04:55 -0700842 if (tmp & DS1307_BIT_CH) {
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700843 i2c_smbus_write_byte_data(client, DS1307_REG_SECS, 0);
844 dev_warn(&client->dev, "SET TIME!\n");
David Brownell045e0e82007-07-17 04:04:55 -0700845 goto read_rtc;
David Brownell1abb0dc2006-06-25 05:48:17 -0700846 }
David Brownell045e0e82007-07-17 04:04:55 -0700847 break;
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700848 case ds_1338:
849 /* clock halted? turn it on, so clock can tick. */
David Brownell045e0e82007-07-17 04:04:55 -0700850 if (tmp & DS1307_BIT_CH)
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700851 i2c_smbus_write_byte_data(client, DS1307_REG_SECS, 0);
852
853 /* oscillator fault? clear flag, and warn */
854 if (ds1307->regs[DS1307_REG_CONTROL] & DS1338_BIT_OSF) {
855 i2c_smbus_write_byte_data(client, DS1307_REG_CONTROL,
David Brownellbd16f9e2007-07-26 10:41:00 -0700856 ds1307->regs[DS1307_REG_CONTROL]
Rodolfo Giomettibe5f59f2007-07-17 04:05:06 -0700857 & ~DS1338_BIT_OSF);
858 dev_warn(&client->dev, "SET TIME!\n");
859 goto read_rtc;
860 }
David Brownell045e0e82007-07-17 04:04:55 -0700861 break;
frederic Rodofcd8db02008-02-06 01:38:55 -0800862 case ds_1340:
863 /* clock halted? turn it on, so clock can tick. */
864 if (tmp & DS1340_BIT_nEOSC)
865 i2c_smbus_write_byte_data(client, DS1307_REG_SECS, 0);
866
867 tmp = i2c_smbus_read_byte_data(client, DS1340_REG_FLAG);
868 if (tmp < 0) {
Jingoo Han6df80e22013-04-29 16:19:28 -0700869 dev_dbg(&client->dev, "read error %d\n", tmp);
frederic Rodofcd8db02008-02-06 01:38:55 -0800870 err = -EIO;
871 goto exit_free;
872 }
873
874 /* oscillator fault? clear flag, and warn */
875 if (tmp & DS1340_BIT_OSF) {
876 i2c_smbus_write_byte_data(client, DS1340_REG_FLAG, 0);
877 dev_warn(&client->dev, "SET TIME!\n");
878 }
879 break;
David Anders43fcb812011-11-02 13:37:53 -0700880 case mcp7941x:
881 /* make sure that the backup battery is enabled */
882 if (!(ds1307->regs[DS1307_REG_WDAY] & MCP7941X_BIT_VBATEN)) {
883 i2c_smbus_write_byte_data(client, DS1307_REG_WDAY,
884 ds1307->regs[DS1307_REG_WDAY]
885 | MCP7941X_BIT_VBATEN);
886 }
887
888 /* clock halted? turn it on, so clock can tick. */
889 if (!(tmp & MCP7941X_BIT_ST)) {
890 i2c_smbus_write_byte_data(client, DS1307_REG_SECS,
891 MCP7941X_BIT_ST);
892 dev_warn(&client->dev, "SET TIME!\n");
893 goto read_rtc;
894 }
895
896 break;
Wolfram Sang32d322b2012-03-23 15:02:36 -0700897 default:
David Brownell045e0e82007-07-17 04:04:55 -0700898 break;
David Brownell1abb0dc2006-06-25 05:48:17 -0700899 }
David Brownell045e0e82007-07-17 04:04:55 -0700900
David Brownell1abb0dc2006-06-25 05:48:17 -0700901 tmp = ds1307->regs[DS1307_REG_HOUR];
David Brownellc065f352007-07-17 04:05:10 -0700902 switch (ds1307->type) {
903 case ds_1340:
904 case m41t00:
David Anders40ce9722012-03-23 15:02:37 -0700905 /*
906 * NOTE: ignores century bits; fix before deploying
David Brownellc065f352007-07-17 04:05:10 -0700907 * systems that will run through year 2100.
908 */
909 break;
Matthias Fuchsa2166852009-03-31 15:24:58 -0700910 case rx_8025:
911 break;
David Brownellc065f352007-07-17 04:05:10 -0700912 default:
913 if (!(tmp & DS1307_BIT_12HR))
914 break;
915
David Anders40ce9722012-03-23 15:02:37 -0700916 /*
917 * Be sure we're in 24 hour mode. Multi-master systems
David Brownellc065f352007-07-17 04:05:10 -0700918 * take note...
919 */
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700920 tmp = bcd2bin(tmp & 0x1f);
David Brownellc065f352007-07-17 04:05:10 -0700921 if (tmp == 12)
922 tmp = 0;
923 if (ds1307->regs[DS1307_REG_HOUR] & DS1307_BIT_PM)
924 tmp += 12;
David Brownell1abb0dc2006-06-25 05:48:17 -0700925 i2c_smbus_write_byte_data(client,
Joakim Tjernlund96fc3a42010-06-29 15:05:34 -0700926 ds1307->offset + DS1307_REG_HOUR,
Adrian Bunkfe20ba72008-10-18 20:28:41 -0700927 bin2bcd(tmp));
David Brownell1abb0dc2006-06-25 05:48:17 -0700928 }
929
David Brownell1abb0dc2006-06-25 05:48:17 -0700930 ds1307->rtc = rtc_device_register(client->name, &client->dev,
931 &ds13xx_rtc_ops, THIS_MODULE);
932 if (IS_ERR(ds1307->rtc)) {
933 err = PTR_ERR(ds1307->rtc);
934 dev_err(&client->dev,
935 "unable to register the class device\n");
David Brownellc065f352007-07-17 04:05:10 -0700936 goto exit_free;
David Brownell1abb0dc2006-06-25 05:48:17 -0700937 }
938
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700939 if (want_irq) {
Dmitry Eremin-Solenikov43d15bc2009-12-15 16:46:14 -0800940 err = request_irq(client->irq, ds1307_irq, IRQF_SHARED,
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700941 ds1307->rtc->name, client);
942 if (err) {
943 dev_err(&client->dev,
944 "unable to request IRQ!\n");
945 goto exit_irq;
946 }
Anton Vorontsov26b3c012009-12-17 15:27:23 -0800947
948 device_set_wakeup_capable(&client->dev, 1);
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700949 set_bit(HAS_ALARM, &ds1307->flags);
950 dev_dbg(&client->dev, "got IRQ %d\n", client->irq);
951 }
952
Austin Boyle9eab0a72012-03-23 15:02:38 -0700953 if (chip->nvram_size) {
954 ds1307->nvram = kzalloc(sizeof(struct bin_attribute),
955 GFP_KERNEL);
956 if (!ds1307->nvram) {
957 err = -ENOMEM;
958 goto exit_nvram;
David Brownell682d73f2007-11-14 16:58:32 -0800959 }
Austin Boyle9eab0a72012-03-23 15:02:38 -0700960 ds1307->nvram->attr.name = "nvram";
961 ds1307->nvram->attr.mode = S_IRUGO | S_IWUSR;
Anatolij Gustschin3f5ec5e2012-04-25 16:01:51 -0700962 sysfs_bin_attr_init(ds1307->nvram);
Steffen Trumtrarb9c35702013-04-29 16:20:16 -0700963 ds1307->nvram->read = ds1307_nvram_read;
964 ds1307->nvram->write = ds1307_nvram_write;
Austin Boyle9eab0a72012-03-23 15:02:38 -0700965 ds1307->nvram->size = chip->nvram_size;
966 ds1307->nvram_offset = chip->nvram_offset;
967 err = sysfs_create_bin_file(&client->dev.kobj, ds1307->nvram);
968 if (err) {
969 kfree(ds1307->nvram);
970 goto exit_nvram;
971 }
972 set_bit(HAS_NVRAM, &ds1307->flags);
973 dev_info(&client->dev, "%zu bytes nvram\n", ds1307->nvram->size);
David Brownell682d73f2007-11-14 16:58:32 -0800974 }
975
David Brownell1abb0dc2006-06-25 05:48:17 -0700976 return 0;
977
Austin Boyle9eab0a72012-03-23 15:02:38 -0700978exit_nvram:
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700979exit_irq:
Julia Lawall72445af2009-09-22 16:46:29 -0700980 rtc_device_unregister(ds1307->rtc);
David Brownell1abb0dc2006-06-25 05:48:17 -0700981exit_free:
982 kfree(ds1307);
David Brownell1abb0dc2006-06-25 05:48:17 -0700983 return err;
984}
985
Greg Kroah-Hartman5a167f42012-12-21 13:09:38 -0800986static int ds1307_remove(struct i2c_client *client)
David Brownell1abb0dc2006-06-25 05:48:17 -0700987{
David Anders40ce9722012-03-23 15:02:37 -0700988 struct ds1307 *ds1307 = i2c_get_clientdata(client);
David Brownell1abb0dc2006-06-25 05:48:17 -0700989
Rodolfo Giometticb49a5e2008-10-15 22:02:58 -0700990 if (test_and_clear_bit(HAS_ALARM, &ds1307->flags)) {
991 free_irq(client->irq, client);
992 cancel_work_sync(&ds1307->work);
993 }
994
Austin Boyle9eab0a72012-03-23 15:02:38 -0700995 if (test_and_clear_bit(HAS_NVRAM, &ds1307->flags)) {
996 sysfs_remove_bin_file(&client->dev.kobj, ds1307->nvram);
997 kfree(ds1307->nvram);
998 }
David Brownell682d73f2007-11-14 16:58:32 -0800999
David Brownell1abb0dc2006-06-25 05:48:17 -07001000 rtc_device_unregister(ds1307->rtc);
David Brownell1abb0dc2006-06-25 05:48:17 -07001001 kfree(ds1307);
1002 return 0;
1003}
1004
1005static struct i2c_driver ds1307_driver = {
1006 .driver = {
David Brownellc065f352007-07-17 04:05:10 -07001007 .name = "rtc-ds1307",
David Brownell1abb0dc2006-06-25 05:48:17 -07001008 .owner = THIS_MODULE,
1009 },
David Brownellc065f352007-07-17 04:05:10 -07001010 .probe = ds1307_probe,
Greg Kroah-Hartman5a167f42012-12-21 13:09:38 -08001011 .remove = ds1307_remove,
Jean Delvare3760f732008-04-29 23:11:40 +02001012 .id_table = ds1307_id,
David Brownell1abb0dc2006-06-25 05:48:17 -07001013};
1014
Axel Lin0abc9202012-03-23 15:02:31 -07001015module_i2c_driver(ds1307_driver);
David Brownell1abb0dc2006-06-25 05:48:17 -07001016
1017MODULE_DESCRIPTION("RTC driver for DS1307 and similar chips");
1018MODULE_LICENSE("GPL");