rtc-isl1208.c 20.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * Intersil ISL1208 rtc class driver
 *
 * Copyright 2005,2006 Hebert Valerio Riedel <hvr@gnu.org>
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 *
 */

#include <linux/bcd.h>
14 15
#include <linux/i2c.h>
#include <linux/module.h>
16
#include <linux/of_irq.h>
17
#include <linux/rtc.h>
18 19 20 21 22 23

/* Register map */
/* rtc section */
#define ISL1208_REG_SC  0x00
#define ISL1208_REG_MN  0x01
#define ISL1208_REG_HR  0x02
24 25
#define ISL1208_REG_HR_MIL     (1<<7)	/* 24h/12h mode */
#define ISL1208_REG_HR_PM      (1<<5)	/* PM/AM bit in 12h mode */
26 27 28 29 30 31 32 33
#define ISL1208_REG_DT  0x03
#define ISL1208_REG_MO  0x04
#define ISL1208_REG_YR  0x05
#define ISL1208_REG_DW  0x06
#define ISL1208_RTC_SECTION_LEN 7

/* control/status section */
#define ISL1208_REG_SR  0x07
34 35 36
#define ISL1208_REG_SR_ARST    (1<<7)	/* auto reset */
#define ISL1208_REG_SR_XTOSCB  (1<<6)	/* crystal oscillator */
#define ISL1208_REG_SR_WRTC    (1<<4)	/* write rtc */
37
#define ISL1208_REG_SR_EVT     (1<<3)	/* event */
38 39 40
#define ISL1208_REG_SR_ALM     (1<<2)	/* alarm */
#define ISL1208_REG_SR_BAT     (1<<1)	/* battery */
#define ISL1208_REG_SR_RTCF    (1<<0)	/* rtc fail */
41
#define ISL1208_REG_INT 0x08
42 43
#define ISL1208_REG_INT_ALME   (1<<6)   /* alarm enable */
#define ISL1208_REG_INT_IM     (1<<7)   /* interrupt/alarm mode */
44 45
#define ISL1219_REG_EV  0x09
#define ISL1219_REG_EV_EVEN    (1<<4)   /* event detection enable */
46
#define ISL1219_REG_EV_EVIENB  (1<<7)   /* event in pull-up disable */
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
#define ISL1208_REG_ATR 0x0a
#define ISL1208_REG_DTR 0x0b

/* alarm section */
#define ISL1208_REG_SCA 0x0c
#define ISL1208_REG_MNA 0x0d
#define ISL1208_REG_HRA 0x0e
#define ISL1208_REG_DTA 0x0f
#define ISL1208_REG_MOA 0x10
#define ISL1208_REG_DWA 0x11
#define ISL1208_ALARM_SECTION_LEN 6

/* user section */
#define ISL1208_REG_USR1 0x12
#define ISL1208_REG_USR2 0x13
#define ISL1208_USR_SECTION_LEN 2

64 65 66 67 68 69 70 71 72
/* event section */
#define ISL1219_REG_SCT 0x14
#define ISL1219_REG_MNT 0x15
#define ISL1219_REG_HRT 0x16
#define ISL1219_REG_DTT 0x17
#define ISL1219_REG_MOT 0x18
#define ISL1219_REG_YRT 0x19
#define ISL1219_EVT_SECTION_LEN 6

73
static struct i2c_driver isl1208_driver;
74

75 76 77 78 79 80 81
/* ISL1208 various variants */
enum {
	TYPE_ISL1208 = 0,
	TYPE_ISL1218,
	TYPE_ISL1219,
};

82 83 84
/* block read */
static int
isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[],
85
		      unsigned len)
86 87 88
{
	int ret;

89 90
	WARN_ON(reg > ISL1219_REG_YRT);
	WARN_ON(reg + len > ISL1219_REG_YRT + 1);
91

92 93
	ret = i2c_smbus_read_i2c_block_data(client, reg, len, buf);
	return (ret < 0) ? ret : 0;
94 95 96 97 98
}

/* block write */
static int
isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[],
99
		     unsigned len)
100 101 102
{
	int ret;

103 104
	WARN_ON(reg > ISL1219_REG_YRT);
	WARN_ON(reg + len > ISL1219_REG_YRT + 1);
105

106 107
	ret = i2c_smbus_write_i2c_block_data(client, reg, len, buf);
	return (ret < 0) ? ret : 0;
108 109
}

110
/* simple check to see whether we have a isl1208 */
111 112
static int
isl1208_i2c_validate_client(struct i2c_client *client)
113 114 115 116 117 118 119 120 121 122 123 124 125
{
	u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
	u8 zero_mask[ISL1208_RTC_SECTION_LEN] = {
		0x80, 0x80, 0x40, 0xc0, 0xe0, 0x00, 0xf8
	};
	int i;
	int ret;

	ret = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
	if (ret < 0)
		return ret;

	for (i = 0; i < ISL1208_RTC_SECTION_LEN; ++i) {
126
		if (regs[i] & zero_mask[i])	/* check if bits are cleared */
127 128 129 130 131 132
			return -ENODEV;
	}

	return 0;
}

133 134
static int
isl1208_i2c_get_sr(struct i2c_client *client)
135
{
136
	return i2c_smbus_read_byte_data(client, ISL1208_REG_SR);
137 138
}

139 140
static int
isl1208_i2c_get_atr(struct i2c_client *client)
141 142 143
{
	int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR);
	if (atr < 0)
144
		return atr;
145 146 147 148 149 150 151 152 153 154 155 156

	/* The 6bit value in the ATR register controls the load
	 * capacitance C_load * in steps of 0.25pF
	 *
	 * bit (1<<5) of the ATR register is inverted
	 *
	 * C_load(ATR=0x20) =  4.50pF
	 * C_load(ATR=0x00) = 12.50pF
	 * C_load(ATR=0x1f) = 20.25pF
	 *
	 */

157 158 159
	atr &= 0x3f;		/* mask out lsb */
	atr ^= 1 << 5;		/* invert 6th bit */
	atr += 2 * 9;		/* add offset of 4.5pF; unit[atr] = 0.25pF */
160 161 162 163

	return atr;
}

164
/* returns adjustment value + 100 */
165 166
static int
isl1208_i2c_get_dtr(struct i2c_client *client)
167 168 169 170 171 172
{
	int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR);
	if (dtr < 0)
		return -EIO;

	/* dtr encodes adjustments of {-60,-40,-20,0,20,40,60} ppm */
173
	dtr = ((dtr & 0x3) * 20) * (dtr & (1 << 2) ? -1 : 1);
174

175
	return dtr + 100;
176 177
}

178 179
static int
isl1208_i2c_get_usr(struct i2c_client *client)
180 181 182 183
{
	u8 buf[ISL1208_USR_SECTION_LEN] = { 0, };
	int ret;

184 185
	ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1, buf,
				    ISL1208_USR_SECTION_LEN);
186 187 188 189 190 191
	if (ret < 0)
		return ret;

	return (buf[1] << 8) | buf[0];
}

192 193
static int
isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)
194 195 196 197 198 199
{
	u8 buf[ISL1208_USR_SECTION_LEN];

	buf[0] = usr & 0xff;
	buf[1] = (usr >> 8) & 0xff;

200 201
	return isl1208_i2c_set_regs(client, ISL1208_REG_USR1, buf,
				    ISL1208_USR_SECTION_LEN);
202 203
}

204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
static int
isl1208_rtc_toggle_alarm(struct i2c_client *client, int enable)
{
	int icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);

	if (icr < 0) {
		dev_err(&client->dev, "%s: reading INT failed\n", __func__);
		return icr;
	}

	if (enable)
		icr |= ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM;
	else
		icr &= ~(ISL1208_REG_INT_ALME | ISL1208_REG_INT_IM);

	icr = i2c_smbus_write_byte_data(client, ISL1208_REG_INT, icr);
	if (icr < 0) {
		dev_err(&client->dev, "%s: writing INT failed\n", __func__);
		return icr;
	}

	return 0;
}

228 229
static int
isl1208_rtc_proc(struct device *dev, struct seq_file *seq)
230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
{
	struct i2c_client *const client = to_i2c_client(dev);
	int sr, dtr, atr, usr;

	sr = isl1208_i2c_get_sr(client);
	if (sr < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return sr;
	}

	seq_printf(seq, "status_reg\t:%s%s%s%s%s%s (0x%.2x)\n",
		   (sr & ISL1208_REG_SR_RTCF) ? " RTCF" : "",
		   (sr & ISL1208_REG_SR_BAT) ? " BAT" : "",
		   (sr & ISL1208_REG_SR_ALM) ? " ALM" : "",
		   (sr & ISL1208_REG_SR_WRTC) ? " WRTC" : "",
		   (sr & ISL1208_REG_SR_XTOSCB) ? " XTOSCB" : "",
246
		   (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr);
247 248 249 250 251

	seq_printf(seq, "batt_status\t: %s\n",
		   (sr & ISL1208_REG_SR_RTCF) ? "bad" : "okay");

	dtr = isl1208_i2c_get_dtr(client);
252 253
	if (dtr >= 0)
		seq_printf(seq, "digital_trim\t: %d ppm\n", dtr - 100);
254 255 256 257

	atr = isl1208_i2c_get_atr(client);
	if (atr >= 0)
		seq_printf(seq, "analog_trim\t: %d.%.2d pF\n",
258
			   atr >> 2, (atr & 0x3) * 25);
259 260 261 262 263 264 265 266

	usr = isl1208_i2c_get_usr(client);
	if (usr >= 0)
		seq_printf(seq, "user_data\t: 0x%.4x\n", usr);

	return 0;
}

267 268
static int
isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
{
	int sr;
	u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };

	sr = isl1208_i2c_get_sr(client);
	if (sr < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return -EIO;
	}

	sr = isl1208_i2c_read_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
	if (sr < 0) {
		dev_err(&client->dev, "%s: reading RTC section failed\n",
			__func__);
		return sr;
	}

286 287
	tm->tm_sec = bcd2bin(regs[ISL1208_REG_SC]);
	tm->tm_min = bcd2bin(regs[ISL1208_REG_MN]);
288 289 290

	/* HR field has a more complex interpretation */
	{
291
		const u8 _hr = regs[ISL1208_REG_HR];
292
		if (_hr & ISL1208_REG_HR_MIL)	/* 24h format */
293
			tm->tm_hour = bcd2bin(_hr & 0x3f);
294 295
		else {
			/* 12h format */
296
			tm->tm_hour = bcd2bin(_hr & 0x1f);
297
			if (_hr & ISL1208_REG_HR_PM)	/* PM flag set */
298 299 300 301
				tm->tm_hour += 12;
		}
	}

302 303 304 305
	tm->tm_mday = bcd2bin(regs[ISL1208_REG_DT]);
	tm->tm_mon = bcd2bin(regs[ISL1208_REG_MO]) - 1;	/* rtc starts at 1 */
	tm->tm_year = bcd2bin(regs[ISL1208_REG_YR]) + 100;
	tm->tm_wday = bcd2bin(regs[ISL1208_REG_DW]);
306 307 308 309

	return 0;
}

310 311
static int
isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
312 313 314
{
	struct rtc_time *const tm = &alarm->time;
	u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
315
	int icr, yr, sr = isl1208_i2c_get_sr(client);
316 317 318 319 320 321 322

	if (sr < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return sr;
	}

	sr = isl1208_i2c_read_regs(client, ISL1208_REG_SCA, regs,
323
				   ISL1208_ALARM_SECTION_LEN);
324 325 326 327 328 329 330
	if (sr < 0) {
		dev_err(&client->dev, "%s: reading alarm section failed\n",
			__func__);
		return sr;
	}

	/* MSB of each alarm register is an enable bit */
331 332 333 334
	tm->tm_sec = bcd2bin(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
	tm->tm_min = bcd2bin(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
	tm->tm_hour = bcd2bin(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
	tm->tm_mday = bcd2bin(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
335
	tm->tm_mon =
336 337
		bcd2bin(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
	tm->tm_wday = bcd2bin(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
338

339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
	/* The alarm doesn't store the year so get it from the rtc section */
	yr = i2c_smbus_read_byte_data(client, ISL1208_REG_YR);
	if (yr < 0) {
		dev_err(&client->dev, "%s: reading RTC YR failed\n", __func__);
		return yr;
	}
	tm->tm_year = bcd2bin(yr) + 100;

	icr = i2c_smbus_read_byte_data(client, ISL1208_REG_INT);
	if (icr < 0) {
		dev_err(&client->dev, "%s: reading INT failed\n", __func__);
		return icr;
	}
	alarm->enabled = !!(icr & ISL1208_REG_INT_ALME);

	return 0;
}

static int
isl1208_i2c_set_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
{
	struct rtc_time *alarm_tm = &alarm->time;
	u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
	const int offs = ISL1208_REG_SCA;
	struct rtc_time rtc_tm;
	int err, enable;

	err = isl1208_i2c_read_time(client, &rtc_tm);
	if (err)
		return err;

	/* If the alarm time is before the current time disable the alarm */
371
	if (!alarm->enabled || rtc_tm_sub(alarm_tm, &rtc_tm) <= 0)
372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
		enable = 0x00;
	else
		enable = 0x80;

	/* Program the alarm and enable it for each setting */
	regs[ISL1208_REG_SCA - offs] = bin2bcd(alarm_tm->tm_sec) | enable;
	regs[ISL1208_REG_MNA - offs] = bin2bcd(alarm_tm->tm_min) | enable;
	regs[ISL1208_REG_HRA - offs] = bin2bcd(alarm_tm->tm_hour) |
		ISL1208_REG_HR_MIL | enable;

	regs[ISL1208_REG_DTA - offs] = bin2bcd(alarm_tm->tm_mday) | enable;
	regs[ISL1208_REG_MOA - offs] = bin2bcd(alarm_tm->tm_mon + 1) | enable;
	regs[ISL1208_REG_DWA - offs] = bin2bcd(alarm_tm->tm_wday & 7) | enable;

	/* write ALARM registers */
	err = isl1208_i2c_set_regs(client, offs, regs,
				  ISL1208_ALARM_SECTION_LEN);
	if (err < 0) {
		dev_err(&client->dev, "%s: writing ALARM section failed\n",
			__func__);
		return err;
	}

	err = isl1208_rtc_toggle_alarm(client, enable);
	if (err)
		return err;

399 400 401
	return 0;
}

402 403
static int
isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)
404 405 406 407
{
	return isl1208_i2c_read_time(to_i2c_client(dev), tm);
}

408 409
static int
isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
410 411 412 413
{
	int sr;
	u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };

414 415 416 417 418 419 420
	/* The clock has an 8 bit wide bcd-coded register (they never learn)
	 * for the year. tm_year is an offset from 1900 and we are interested
	 * in the 2000-2099 range, so any value less than 100 is invalid.
	 */
	if (tm->tm_year < 100)
		return -EINVAL;

421 422 423
	regs[ISL1208_REG_SC] = bin2bcd(tm->tm_sec);
	regs[ISL1208_REG_MN] = bin2bcd(tm->tm_min);
	regs[ISL1208_REG_HR] = bin2bcd(tm->tm_hour) | ISL1208_REG_HR_MIL;
424

425 426 427
	regs[ISL1208_REG_DT] = bin2bcd(tm->tm_mday);
	regs[ISL1208_REG_MO] = bin2bcd(tm->tm_mon + 1);
	regs[ISL1208_REG_YR] = bin2bcd(tm->tm_year - 100);
428

429
	regs[ISL1208_REG_DW] = bin2bcd(tm->tm_wday & 7);
430 431 432 433 434 435 436 437

	sr = isl1208_i2c_get_sr(client);
	if (sr < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return sr;
	}

	/* set WRTC */
438
	sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
				       sr | ISL1208_REG_SR_WRTC);
	if (sr < 0) {
		dev_err(&client->dev, "%s: writing SR failed\n", __func__);
		return sr;
	}

	/* write RTC registers */
	sr = isl1208_i2c_set_regs(client, 0, regs, ISL1208_RTC_SECTION_LEN);
	if (sr < 0) {
		dev_err(&client->dev, "%s: writing RTC section failed\n",
			__func__);
		return sr;
	}

	/* clear WRTC again */
454 455 456 457 458
	sr = isl1208_i2c_get_sr(client);
	if (sr < 0) {
		dev_err(&client->dev, "%s: reading SR failed\n", __func__);
		return sr;
	}
459
	sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
460 461 462 463 464 465 466 467 468 469
				       sr & ~ISL1208_REG_SR_WRTC);
	if (sr < 0) {
		dev_err(&client->dev, "%s: writing SR failed\n", __func__);
		return sr;
	}

	return 0;
}


470 471
static int
isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)
472 473 474 475
{
	return isl1208_i2c_set_time(to_i2c_client(dev), tm);
}

476 477
static int
isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
478 479 480 481
{
	return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);
}

482 483 484 485 486 487
static int
isl1208_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
{
	return isl1208_i2c_set_alarm(to_i2c_client(dev), alarm);
}

488 489 490 491
static ssize_t timestamp0_store(struct device *dev,
				struct device_attribute *attr,
				const char *buf, size_t count)
{
492
	struct i2c_client *client = to_i2c_client(dev->parent);
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513
	int sr;

	sr = isl1208_i2c_get_sr(client);
	if (sr < 0) {
		dev_err(dev, "%s: reading SR failed\n", __func__);
		return sr;
	}

	sr &= ~ISL1208_REG_SR_EVT;

	sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
	if (sr < 0)
		dev_err(dev, "%s: writing SR failed\n",
			__func__);

	return count;
};

static ssize_t timestamp0_show(struct device *dev,
			       struct device_attribute *attr, char *buf)
{
514
	struct i2c_client *client = to_i2c_client(dev->parent);
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
	u8 regs[ISL1219_EVT_SECTION_LEN] = { 0, };
	struct rtc_time tm;
	int sr;

	sr = isl1208_i2c_get_sr(client);
	if (sr < 0) {
		dev_err(dev, "%s: reading SR failed\n", __func__);
		return sr;
	}

	if (!(sr & ISL1208_REG_SR_EVT))
		return 0;

	sr = isl1208_i2c_read_regs(client, ISL1219_REG_SCT, regs,
				   ISL1219_EVT_SECTION_LEN);
	if (sr < 0) {
		dev_err(dev, "%s: reading event section failed\n",
			__func__);
		return 0;
	}

	/* MSB of each alarm register is an enable bit */
	tm.tm_sec = bcd2bin(regs[ISL1219_REG_SCT - ISL1219_REG_SCT] & 0x7f);
	tm.tm_min = bcd2bin(regs[ISL1219_REG_MNT - ISL1219_REG_SCT] & 0x7f);
	tm.tm_hour = bcd2bin(regs[ISL1219_REG_HRT - ISL1219_REG_SCT] & 0x3f);
	tm.tm_mday = bcd2bin(regs[ISL1219_REG_DTT - ISL1219_REG_SCT] & 0x3f);
	tm.tm_mon =
		bcd2bin(regs[ISL1219_REG_MOT - ISL1219_REG_SCT] & 0x1f) - 1;
	tm.tm_year = bcd2bin(regs[ISL1219_REG_YRT - ISL1219_REG_SCT]) + 100;

	sr = rtc_valid_tm(&tm);
	if (sr)
		return sr;

	return sprintf(buf, "%llu\n",
				(unsigned long long)rtc_tm_to_time64(&tm));
};

static DEVICE_ATTR_RW(timestamp0);

555 556 557 558 559
static irqreturn_t
isl1208_rtc_interrupt(int irq, void *data)
{
	unsigned long timeout = jiffies + msecs_to_jiffies(1000);
	struct i2c_client *client = data;
560
	struct rtc_device *rtc = i2c_get_clientdata(client);
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582
	int handled = 0, sr, err;

	/*
	 * I2C reads get NAK'ed if we read straight away after an interrupt?
	 * Using a mdelay/msleep didn't seem to help either, so we work around
	 * this by continually trying to read the register for a short time.
	 */
	while (1) {
		sr = isl1208_i2c_get_sr(client);
		if (sr >= 0)
			break;

		if (time_after(jiffies, timeout)) {
			dev_err(&client->dev, "%s: reading SR failed\n",
				__func__);
			return sr;
		}
	}

	if (sr & ISL1208_REG_SR_ALM) {
		dev_dbg(&client->dev, "alarm!\n");

583 584
		rtc_update_irq(rtc, 1, RTC_IRQF | RTC_AF);

585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
		/* Clear the alarm */
		sr &= ~ISL1208_REG_SR_ALM;
		sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR, sr);
		if (sr < 0)
			dev_err(&client->dev, "%s: writing SR failed\n",
				__func__);
		else
			handled = 1;

		/* Disable the alarm */
		err = isl1208_rtc_toggle_alarm(client, 0);
		if (err)
			return err;
	}

600 601 602 603 604 605 606
	if (sr & ISL1208_REG_SR_EVT) {
		sysfs_notify(&rtc->dev.kobj, NULL,
			     dev_attr_timestamp0.attr.name);
		dev_warn(&client->dev, "event detected");
		handled = 1;
	}

607 608 609
	return handled ? IRQ_HANDLED : IRQ_NONE;
}

610
static const struct rtc_class_ops isl1208_rtc_ops = {
611 612 613 614
	.proc = isl1208_rtc_proc,
	.read_time = isl1208_rtc_read_time,
	.set_time = isl1208_rtc_set_time,
	.read_alarm = isl1208_rtc_read_alarm,
615
	.set_alarm = isl1208_rtc_set_alarm,
616 617 618 619
};

/* sysfs interface */

620 621 622
static ssize_t
isl1208_sysfs_show_atrim(struct device *dev,
			 struct device_attribute *attr, char *buf)
623
{
624
	int atr = isl1208_i2c_get_atr(to_i2c_client(dev->parent));
625 626 627
	if (atr < 0)
		return atr;

628
	return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25);
629
}
630

631 632
static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL);

633 634 635
static ssize_t
isl1208_sysfs_show_dtrim(struct device *dev,
			 struct device_attribute *attr, char *buf)
636
{
637
	int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev->parent));
638 639 640
	if (dtr < 0)
		return dtr;

641
	return sprintf(buf, "%d ppm\n", dtr - 100);
642
}
643

644 645
static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL);

646 647 648
static ssize_t
isl1208_sysfs_show_usr(struct device *dev,
		       struct device_attribute *attr, char *buf)
649
{
650
	int usr = isl1208_i2c_get_usr(to_i2c_client(dev->parent));
651 652 653 654 655 656
	if (usr < 0)
		return usr;

	return sprintf(buf, "0x%.4x\n", usr);
}

657 658 659 660
static ssize_t
isl1208_sysfs_store_usr(struct device *dev,
			struct device_attribute *attr,
			const char *buf, size_t count)
661 662 663 664 665 666 667 668 669 670 671 672 673 674
{
	int usr = -1;

	if (buf[0] == '0' && (buf[1] == 'x' || buf[1] == 'X')) {
		if (sscanf(buf, "%x", &usr) != 1)
			return -EINVAL;
	} else {
		if (sscanf(buf, "%d", &usr) != 1)
			return -EINVAL;
	}

	if (usr < 0 || usr > 0xffff)
		return -EINVAL;

675 676 677 678
	if (isl1208_i2c_set_usr(to_i2c_client(dev->parent), usr))
		return -EIO;

	return count;
679
}
680

681 682 683
static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
		   isl1208_sysfs_store_usr);

684 685 686 687 688 689
static struct attribute *isl1208_rtc_attrs[] = {
	&dev_attr_atrim.attr,
	&dev_attr_dtrim.attr,
	&dev_attr_usr.attr,
	NULL
};
690

691 692 693
static const struct attribute_group isl1208_rtc_sysfs_files = {
	.attrs	= isl1208_rtc_attrs,
};
694

695 696 697 698 699 700 701 702 703
static struct attribute *isl1219_rtc_attrs[] = {
	&dev_attr_timestamp0.attr,
	NULL
};

static const struct attribute_group isl1219_rtc_sysfs_files = {
	.attrs	= isl1219_rtc_attrs,
};

704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721
static int isl1208_setup_irq(struct i2c_client *client, int irq)
{
	int rc = devm_request_threaded_irq(&client->dev, irq, NULL,
					isl1208_rtc_interrupt,
					IRQF_SHARED | IRQF_ONESHOT,
					isl1208_driver.driver.name,
					client);
	if (!rc) {
		device_init_wakeup(&client->dev, 1);
		enable_irq_wake(irq);
	} else {
		dev_err(&client->dev,
			"Unable to request irq %d, no alarm support\n",
			irq);
	}
	return rc;
}

722
static int
723
isl1208_probe(struct i2c_client *client, const struct i2c_device_id *id)
724 725 726
{
	int rc = 0;
	struct rtc_device *rtc;
727
	int evdet_irq = -1;
728

729 730
	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
		return -ENODEV;
731

732 733 734
	if (isl1208_i2c_validate_client(client) < 0)
		return -ENODEV;

735
	rtc = devm_rtc_allocate_device(&client->dev);
736 737
	if (IS_ERR(rtc))
		return PTR_ERR(rtc);
738

739 740
	rtc->ops = &isl1208_rtc_ops;

741
	i2c_set_clientdata(client, rtc);
742

743
	rc = isl1208_i2c_get_sr(client);
744
	if (rc < 0) {
745
		dev_err(&client->dev, "reading status failed\n");
746
		return rc;
747 748 749
	}

	if (rc & ISL1208_REG_SR_RTCF)
750
		dev_warn(&client->dev, "rtc power failure detected, "
751 752
			 "please set clock.\n");

753
	if (id->driver_data == TYPE_ISL1219) {
754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769
		struct device_node *np = client->dev.of_node;
		u32 evienb;

		rc = i2c_smbus_read_byte_data(client, ISL1219_REG_EV);
		if (rc < 0) {
			dev_err(&client->dev, "failed to read EV reg\n");
			return rc;
		}
		rc |= ISL1219_REG_EV_EVEN;
		if (!of_property_read_u32(np, "isil,ev-evienb", &evienb)) {
			if (evienb)
				rc |= ISL1219_REG_EV_EVIENB;
			else
				rc &= ~ISL1219_REG_EV_EVIENB;
		}
		rc = i2c_smbus_write_byte_data(client, ISL1219_REG_EV, rc);
770 771 772 773 774 775 776
		if (rc < 0) {
			dev_err(&client->dev, "could not enable tamper detection\n");
			return rc;
		}
		rc = rtc_add_group(rtc, &isl1219_rtc_sysfs_files);
		if (rc)
			return rc;
777
		evdet_irq = of_irq_get_byname(np, "evdet");
778 779
	}

780
	rc = rtc_add_group(rtc, &isl1208_rtc_sysfs_files);
781
	if (rc)
782
		return rc;
783

784 785 786 787 788 789 790 791 792
	if (client->irq > 0)
		rc = isl1208_setup_irq(client, client->irq);
	if (rc)
		return rc;

	if (evdet_irq > 0 && evdet_irq != client->irq)
		rc = isl1208_setup_irq(client, evdet_irq);
	if (rc)
		return rc;
793

794
	return rtc_register_device(rtc);
795 796
}

797
static const struct i2c_device_id isl1208_id[] = {
798 799 800
	{ "isl1208", TYPE_ISL1208 },
	{ "isl1218", TYPE_ISL1218 },
	{ "isl1219", TYPE_ISL1219 },
801 802 803 804
	{ }
};
MODULE_DEVICE_TABLE(i2c, isl1208_id);

805 806 807
static const struct of_device_id isl1208_of_match[] = {
	{ .compatible = "isil,isl1208" },
	{ .compatible = "isil,isl1218" },
808
	{ .compatible = "isil,isl1219" },
809 810 811 812
	{ }
};
MODULE_DEVICE_TABLE(of, isl1208_of_match);

813 814
static struct i2c_driver isl1208_driver = {
	.driver = {
815 816 817
		.name = "rtc-isl1208",
		.of_match_table = of_match_ptr(isl1208_of_match),
	},
818
	.probe = isl1208_probe,
819
	.id_table = isl1208_id,
820
};
821

822
module_i2c_driver(isl1208_driver);
823 824 825 826

MODULE_AUTHOR("Herbert Valerio Riedel <hvr@gnu.org>");
MODULE_DESCRIPTION("Intersil ISL1208 RTC driver");
MODULE_LICENSE("GPL");