xref: /titanic_44/usr/src/uts/sun4u/io/todds1337.c (revision b11e536c7bee7ad575c31194d5e3da89f572ebb5)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include <sys/types.h>
30 #include <sys/conf.h>
31 #include <sys/devops.h>
32 #include <sys/kmem.h>
33 #include <sys/open.h>
34 #include <sys/file.h>
35 #include <sys/note.h>
36 #include <sys/ddi.h>
37 #include <sys/sunddi.h>
38 
39 #include <sys/modctl.h>
40 #include <sys/stat.h>
41 #include <sys/clock.h>
42 #include <sys/reboot.h>
43 #include <sys/machsystm.h>
44 #include <sys/poll.h>
45 #include <sys/pbio.h>
46 #include <sys/sysmacros.h>
47 #include <sys/cyclic.h>
48 
49 /* Added for prom interface */
50 #include <sys/promif.h>
51 #include <sys/promimpl.h>
52 
53 #include <sys/i2c/misc/i2c_svc.h>
54 #include <sys/todds1337.h>
55 
56 #define	DS1337_DEVICE_TYPE	"rtc"
57 
58 /*
59  * Driver entry routines
60  */
61 static int todds1337_attach(dev_info_t *, ddi_attach_cmd_t);
62 static int todds1337_detach(dev_info_t *, ddi_detach_cmd_t);
63 static int todds1337_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
64 
65 /*
66  * tod_ops entry routines
67  */
68 static timestruc_t	todds1337_get(void);
69 static void		todds1337_set(timestruc_t);
70 static uint_t		todds1337_set_watchdog_timer(uint_t);
71 static uint_t		todds1337_clear_watchdog_timer(void);
72 static void		todds1337_set_power_alarm(timestruc_t);
73 static void		todds1337_clear_power_alarm(void);
74 static int		todds1337_setup_prom();
75 static void		todds1337_rele_prom();
76 static int		todds1337_prom_getdate(struct rtc_t *rtc);
77 static int		todds1337_prom_setdate(struct rtc_t *rtc);
78 
79 /*
80  * Local functions
81  */
82 static int		todds1337_read_rtc(struct rtc_t *);
83 static int		todds1337_write_rtc(struct rtc_t *);
84 
85 /* Anchor for soft state structure */
86 static void	*ds1337_statep;
87 static int	instance = -1;
88 static int	todds1337_attach_done = 0;
89 static kmutex_t	todds1337_rd_lock;
90 static kmutex_t	todds1337_alarm_lock;
91 static ihandle_t todds1337_ihandle = 0;
92 
93 /* one second time out */
94 #define	I2C_CYCLIC_TIMEOUT	1000000000
95 uint_t i2c_cyclic_timeout = I2C_CYCLIC_TIMEOUT;
96 static int sync_clock_once = 1;
97 static 	struct	rtc_t	 soft_rtc;
98 
99 /*
100  * cp_ops structure
101  */
102 static struct cb_ops ds1337_cbops = {
103 	nodev,				/* open */
104 	nodev,				/* close */
105 	nodev,				/* strategy */
106 	nodev,				/* print */
107 	nodev,				/* dump */
108 	nodev,				/* read */
109 	nodev,				/* write */
110 	nodev,				/* ioctl */
111 	nodev,				/* devmap */
112 	nodev,				/* mmap */
113 	nodev,				/* segmap */
114 	NULL,				/* poll */
115 	ddi_prop_op,			/* cb_prop_op */
116 	NULL,				/* streamtab */
117 	D_NEW | D_MP,			/* Driver compatibility flag */
118 	CB_REV,				/* rev */
119 	nodev,				/* int (*cb_aread)() */
120 	nodev				/* int (*cb_awrite)() */
121 };
122 
123 /*
124  * dev_ops structure
125  */
126 static struct dev_ops ds1337_ops = {
127 	DEVO_REV,		/* devo_rev */
128 	0,			/* refcnt - reference cnt always set to 0 */
129 	todds1337_getinfo,	/* getinfo - Maybe requred */
130 	nulldev,		/* identify */
131 	nulldev,		/* probe */
132 	todds1337_attach,	/* attach */
133 	todds1337_detach,	/* detach */
134 	nodev,			/* reset */
135 	&ds1337_cbops,		/* cb_ops - ds1337 does not need this(?) */
136 	NULL
137 };
138 
139 static struct modldrv todds1337_modldrv = {
140 	&mod_driverops,		/* Type of module. This one is a driver */
141 	"tod driver for DS1337 %I%",   /* Name of the module. */
142 	&ds1337_ops,			/* Pointer to dev_ops */
143 };
144 
145 /*
146  * Module linkage structure
147  */
148 static struct modlinkage todds1337_modlinkage = {
149 	MODREV_1,
150 	&todds1337_modldrv,
151 	0
152 };
153 
154 int
155 _init(void)
156 {
157 	int error;
158 
159 	if (strcmp(tod_module_name, "todds1337") == 0) {
160 		if ((error = ddi_soft_state_init(&ds1337_statep,
161 			sizeof (ds1337_state_t), 0)) != DDI_SUCCESS) {
162 			return (error);
163 		}
164 
165 		tod_ops.tod_get = todds1337_get;
166 		tod_ops.tod_set = todds1337_set;
167 		tod_ops.tod_set_watchdog_timer = todds1337_set_watchdog_timer;
168 		tod_ops.tod_clear_watchdog_timer =
169 		    todds1337_clear_watchdog_timer;
170 		tod_ops.tod_set_power_alarm = todds1337_set_power_alarm;
171 		tod_ops.tod_clear_power_alarm = todds1337_clear_power_alarm;
172 	}
173 
174 	(void) todds1337_setup_prom();
175 
176 	/*
177 	 * Install the module
178 	 */
179 	if ((error = mod_install(&todds1337_modlinkage)) != 0) {
180 		ddi_soft_state_fini(&ds1337_statep);
181 		return (error);
182 	}
183 	mutex_init(&todds1337_rd_lock, NULL, MUTEX_DEFAULT, NULL);
184 	mutex_init(&todds1337_alarm_lock, NULL, MUTEX_DEFAULT, NULL);
185 
186 	return (0);
187 }
188 
189 int
190 _fini(void)
191 {
192 	int error = 0;
193 
194 	if (strcmp(tod_module_name, "todds1337") == 0) {
195 		error = EBUSY;
196 	} else {
197 		if ((error = mod_remove(&todds1337_modlinkage)) == 0) {
198 			ddi_soft_state_fini(&ds1337_statep);
199 			mutex_destroy(&todds1337_rd_lock);
200 			mutex_destroy(&todds1337_alarm_lock);
201 			todds1337_rele_prom();
202 		}
203 	}
204 
205 	return (error);
206 }
207 
208 int
209 _info(struct modinfo *modinfop)
210 {
211 	return (mod_info(&todds1337_modlinkage, modinfop));
212 }
213 
214 /*
215  * cyclical call to get tod.
216  */
217 static void
218 todds1337_cyclic(void *arg)
219 {
220 
221 	(void) todds1337_read_rtc((struct rtc_t *)arg);
222 
223 }
224 
225 /*
226  * register ds1337 client device with i2c services, and
227  * allocate & initialize soft state structure.
228  */
229 static int
230 todds1337_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
231 {
232 	static ds1337_state_t	*statep = NULL;
233 	i2c_transfer_t	*i2c_tp = NULL;
234 	uint8_t tempVal = (uint8_t)0;
235 	cyc_handler_t cychand;
236 	cyc_time_t  cyctime;
237 
238 	switch (cmd) {
239 	case DDI_ATTACH:
240 		break;
241 	case DDI_RESUME:
242 		return (DDI_SUCCESS);
243 	default:
244 		return (DDI_FAILURE);
245 	}
246 
247 	if (instance != -1) {
248 		cmn_err(CE_WARN, "todds1337_attach: wrong instance");
249 		return (DDI_FAILURE);
250 	}
251 
252 	instance = ddi_get_instance(dip);
253 
254 	/*
255 	 * Allocate soft state structure
256 	 */
257 	if (ddi_soft_state_zalloc(ds1337_statep, instance) != DDI_SUCCESS) {
258 		cmn_err(CE_WARN, "todds1337_attach: cannot allocate soft "
259 		    "state");
260 		instance = -1;
261 		return (DDI_FAILURE);
262 	}
263 
264 	statep = ddi_get_soft_state(ds1337_statep, instance);
265 	if (statep == NULL) {
266 		cmn_err(CE_WARN, "todds1337_attach: cannot acquire soft "
267 		    "state");
268 		instance = -1;
269 		return (DDI_FAILURE);
270 	}
271 
272 	statep->dip = dip;
273 
274 	if (i2c_client_register(dip, &statep->ds1337_i2c_hdl) != I2C_SUCCESS) {
275 		ddi_soft_state_free(ds1337_statep, instance);
276 		cmn_err(CE_WARN, "todds1337_attach: cannot register i2c "
277 		    "client");
278 		instance = -1;
279 		return (DDI_FAILURE);
280 	}
281 
282 	/* check and initialize the oscillator */
283 
284 	(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl,
285 	    &i2c_tp, 1, 1, I2C_SLEEP);
286 	i2c_tp->i2c_version = I2C_XFER_REV;
287 	i2c_tp->i2c_flags = I2C_WR_RD;
288 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_STATUS; /* Read Status register */
289 	i2c_tp->i2c_wlen = 1;
290 	i2c_tp->i2c_rlen = 1;
291 
292 	if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp)) != I2C_SUCCESS) {
293 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
294 		i2c_client_unregister(statep->ds1337_i2c_hdl);
295 		ddi_soft_state_free(ds1337_statep, instance);
296 		cmn_err(CE_WARN, "todds1337_attach: failed to read DS1337 "
297 		    "status register");
298 		instance = -1;
299 		return (DDI_FAILURE);
300 	}
301 
302 	tempVal = i2c_tp->i2c_rbuf[0];
303 
304 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
305 
306 	/*
307 	 * Check Oscillator and initialize chip if OBP failed to do it
308 	 */
309 
310 	if (tempVal & RTC_CTL_EOSC) {
311 		(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl, &i2c_tp,
312 		    2, 0, I2C_SLEEP);
313 		i2c_tp->i2c_version = I2C_XFER_REV;
314 		i2c_tp->i2c_flags = I2C_WR;
315 		i2c_tp->i2c_wbuf[0] = RTC_CTL; /* Write Control register */
316 		i2c_tp->i2c_wbuf[1] = (uchar_t)(RTC_CTL_RS2 | RTC_CTL_RS1 |
317 		    RTC_CTL_INTCN);
318 		if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp))
319 		    != I2C_SUCCESS) {
320 			(void) i2c_transfer_free(statep->ds1337_i2c_hdl,
321 			    i2c_tp);
322 			i2c_client_unregister(statep->ds1337_i2c_hdl);
323 			ddi_soft_state_free(ds1337_statep, instance);
324 			cmn_err(CE_WARN, "todds1337_attach: failed to write "
325 			    "DS1337 control register");
326 			instance = -1;
327 			return (DDI_FAILURE);
328 		}
329 
330 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
331 
332 		/*
333 		 * Now reset the OSF flag in the Status register
334 		 */
335 		(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl, &i2c_tp,
336 		    2, 0, I2C_SLEEP);
337 		i2c_tp->i2c_version = I2C_XFER_REV;
338 		i2c_tp->i2c_flags = I2C_WR;
339 		i2c_tp->i2c_wbuf[0] = RTC_STATUS;
340 		i2c_tp->i2c_wbuf[1] = (uchar_t)0;
341 		if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp))
342 		    != I2C_SUCCESS) {
343 			(void) i2c_transfer_free(statep->ds1337_i2c_hdl,
344 			    i2c_tp);
345 			i2c_client_unregister(statep->ds1337_i2c_hdl);
346 			ddi_soft_state_free(ds1337_statep, instance);
347 			cmn_err(CE_WARN, "todds1337_attach: failed to write "
348 			    "DS1337 status register");
349 			instance = -1;
350 			return (DDI_FAILURE);
351 		}
352 
353 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
354 	}
355 
356 	/* Create a cyclic handler to read TOD */
357 	cychand.cyh_func = todds1337_cyclic;
358 	cychand.cyh_arg = &soft_rtc;
359 	cychand.cyh_level = CY_LOW_LEVEL;
360 	cyctime.cyt_when = 0;
361 	cyctime.cyt_interval = i2c_cyclic_timeout;
362 	ASSERT(statep->cycid == CYCLIC_NONE);
363 	mutex_enter(&cpu_lock);
364 	statep->cycid = cyclic_add(&cychand, &cyctime);
365 	mutex_exit(&cpu_lock);
366 	ASSERT(statep->cycid != CYCLIC_NONE);
367 
368 	statep->state = TOD_ATTACHED;
369 	todds1337_attach_done = 1;
370 	ddi_report_dev(dip);
371 
372 	return (DDI_SUCCESS);
373 }
374 
375 /*ARGSUSED*/
376 static int
377 todds1337_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
378 {
379 	/*
380 	 * Once attached, do not allow detach because the system constantly
381 	 * calling todds1337_get() to get the time.  If the driver is detached
382 	 * and the system try to get the time, the system will have memory
383 	 * problem.
384 	 *
385 	 */
386 	switch (cmd) {
387 	case DDI_SUSPEND:
388 		return (DDI_SUCCESS);
389 	default:
390 		return (DDI_FAILURE);
391 	}
392 }
393 
394 /* *********************** tod_ops entry points ******************** */
395 
396 /*
397  * Read the current time from the DS1337 chip and convert to UNIX form.
398  * Should be called with tod_clock held.
399  */
400 
401 static timestruc_t
402 todds1337_get(void)
403 {
404 	timestruc_t	ts;
405 	todinfo_t	tod;
406 	struct	rtc_t	rtc;
407 
408 	ASSERT(MUTEX_HELD(&tod_lock));
409 
410 	if (sync_clock_once) {
411 		(void) todds1337_read_rtc(&soft_rtc);
412 		sync_clock_once = 0;
413 	} else {
414 		tod_fault_reset();
415 		return (hrestime);
416 	}
417 
418 	bcopy(&soft_rtc, &rtc, sizeof (rtc));
419 
420 	/*
421 	 * 00 - 68 = 2000 thru 2068
422 	 * 69-99 = 1969 thru 1999
423 	 */
424 	tod.tod_year    = rtc.rtc_year;
425 	if (rtc.rtc_year <= 68)
426 		tod.tod_year += 100;
427 	tod.tod_month	= rtc.rtc_mon;
428 	tod.tod_day	= rtc.rtc_dom;
429 	tod.tod_dow	= rtc.rtc_dow;
430 	tod.tod_hour	= rtc.rtc_hrs;
431 	tod.tod_min	= rtc.rtc_min;
432 	tod.tod_sec	= rtc.rtc_sec;
433 
434 	ts.tv_sec = tod_to_utc(tod);
435 	ts.tv_nsec = 0;
436 	return (ts);
437 }
438 
439 /*
440  * Program DS1337 with the specified time.
441  * Must be called with tod_lock held. The TOD
442  * chip supports date from 1969-2068 only. We must
443  * reject requests to set date below 1969.
444  */
445 static void
446 todds1337_set(timestruc_t ts)
447 {
448 	struct rtc_t	rtc;
449 	todinfo_t	tod = utc_to_tod(ts.tv_sec);
450 	int		year;
451 
452 
453 	ASSERT(MUTEX_HELD(&tod_lock));
454 
455 	/*
456 	 * Year is base 1900, valid year range 1969-2068
457 	 */
458 	if ((tod.tod_year < 69) || (tod.tod_year > 168))
459 		return;
460 
461 	year = tod.tod_year;
462 	if (year >= 100)
463 		year -= 100;
464 
465 	rtc.rtc_year	= (uint8_t)year;
466 	rtc.rtc_mon	= (uint8_t)tod.tod_month;
467 	rtc.rtc_dom	= (uint8_t)tod.tod_day;
468 	rtc.rtc_dow	= (uint8_t)tod.tod_dow;
469 	rtc.rtc_hrs	= (uint8_t)tod.tod_hour;
470 	rtc.rtc_min	= (uint8_t)tod.tod_min;
471 	rtc.rtc_sec	= (uint8_t)tod.tod_sec;
472 
473 	(void) todds1337_write_rtc(&rtc);
474 }
475 
476 /*
477  * Program ds1337 registers for alarm to go off at the specified time.
478  * Alarm #1 is used (Alarm #2 stays idle)
479  */
480 /* ARGSUSED */
481 static void
482 todds1337_set_power_alarm(timestruc_t ts)
483 {
484 	todinfo_t	tod;
485 	ds1337_state_t	*statep = NULL;
486 	i2c_transfer_t	*i2c_tp = NULL;
487 	uint8_t tmpval;
488 
489 	ASSERT(MUTEX_HELD(&tod_lock));
490 
491 	if (!todds1337_attach_done) {
492 		cmn_err(CE_WARN, "todds1337: driver not attached");
493 		return;
494 	}
495 
496 	statep = ddi_get_soft_state(ds1337_statep, instance);
497 	if (statep == NULL) {
498 		cmn_err(CE_WARN, "todds1337: ddi_get_soft_state failed");
499 		return;
500 	}
501 
502 	tod = utc_to_tod(ts.tv_sec);
503 
504 	/*
505 	 * i2c_transfe() may block; to avoid locking clock() which
506 	 * is running in interrupt context at PIL10 we temporarely exit
507 	 * the tod_mutex and enter alarm lock. Time/date and alarm hardware
508 	 * have non-interlsecting registers, it is safe to use different locks.
509 	 */
510 	mutex_exit(&tod_lock);
511 	mutex_enter(&todds1337_alarm_lock);
512 
513 	/*
514 	 * Disable Power Alarm (A1IE)
515 	 */
516 	(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl,
517 	    &i2c_tp, 1, 1, I2C_SLEEP);
518 	i2c_tp->i2c_version = I2C_XFER_REV;
519 	i2c_tp->i2c_flags = I2C_WR_RD;
520 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_CTL; /* Read Control register */
521 
522 	if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp)) != I2C_SUCCESS) {
523 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
524 		cmn_err(CE_WARN, "todds1337_set_power_alarm: failed to read "
525 		    "DS1337 control register");
526 		mutex_exit(&todds1337_alarm_lock);
527 		mutex_enter(&tod_lock);
528 		return;
529 	}
530 
531 	tmpval = i2c_tp->i2c_rbuf[0];
532 
533 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
534 
535 	(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl,
536 	    &i2c_tp, 2, 0, I2C_SLEEP);
537 	i2c_tp->i2c_version = I2C_XFER_REV;
538 	i2c_tp->i2c_flags = I2C_WR;
539 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_CTL; /* Write Control register */
540 	i2c_tp->i2c_wbuf[1] = tmpval & ~RTC_CTL_A1IE;
541 
542 	if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp)) != I2C_SUCCESS) {
543 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
544 		cmn_err(CE_WARN, "todds1337_set_power_alarm: failed to write "
545 		    "DS1337control register");
546 		mutex_exit(&todds1337_alarm_lock);
547 		mutex_enter(&tod_lock);
548 		return;
549 	}
550 
551 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
552 
553 
554 	/*
555 	 * Write Alarm #1 registers
556 	 */
557 
558 	(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl,
559 	    &i2c_tp, 5, 0, I2C_SLEEP);
560 	i2c_tp->i2c_version = I2C_XFER_REV;
561 	i2c_tp->i2c_flags = I2C_WR;
562 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_ALARM_SEC; /* Alarm #1 Seconds */
563 	i2c_tp->i2c_wbuf[1] = BYTE_TO_BCD(tod.tod_sec);
564 	i2c_tp->i2c_wbuf[2] = BYTE_TO_BCD(tod.tod_min);
565 	i2c_tp->i2c_wbuf[3] = BYTE_TO_BCD(tod.tod_hour);
566 	i2c_tp->i2c_wbuf[4] = BYTE_TO_BCD(tod.tod_day);
567 
568 	if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp)) != I2C_SUCCESS) {
569 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
570 		cmn_err(CE_WARN, "todds1337_set_power_alarm: failed to write "
571 		    "DS1337 alarm registers");
572 		mutex_exit(&todds1337_alarm_lock);
573 		mutex_enter(&tod_lock);
574 		return;
575 	}
576 
577 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
578 
579 
580 	/*
581 	 * Enable Power Alarm
582 	 */
583 	(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl,
584 	    &i2c_tp, 2, 0, I2C_SLEEP);
585 	i2c_tp->i2c_version = I2C_XFER_REV;
586 	i2c_tp->i2c_flags = I2C_WR;
587 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_CTL; /* Write Control register */
588 	i2c_tp->i2c_wbuf[1] = tmpval | RTC_CTL_A1IE;
589 
590 	if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp)) != I2C_SUCCESS) {
591 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
592 		cmn_err(CE_WARN, "todds1337_set_power_alarm: failed to enable "
593 		    "DS1337 alarm");
594 		mutex_exit(&todds1337_alarm_lock);
595 		mutex_enter(&tod_lock);
596 		return;
597 	}
598 
599 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
600 
601 	mutex_exit(&todds1337_alarm_lock);
602 	mutex_enter(&tod_lock);
603 }
604 
605 /* ARGSUSED */
606 static void
607 todds1337_clear_power_alarm(void)
608 {
609 	ds1337_state_t	*statep = NULL;
610 	i2c_transfer_t	*i2c_tp = NULL;
611 	uint8_t tmpval;
612 
613 	ASSERT(MUTEX_HELD(&tod_lock));
614 
615 	if (!todds1337_attach_done) {
616 		cmn_err(CE_WARN, "todds1337: driver was not attached");
617 		return;
618 	}
619 
620 	statep = ddi_get_soft_state(ds1337_statep, instance);
621 	if (statep == NULL) {
622 		cmn_err(CE_WARN, "todds1337: ddi_get_soft_state has failed");
623 		return;
624 	}
625 
626 	/*
627 	 * i2c_transfe() may block; to avoid locking clock() which
628 	 * is running in interrupt context at PIL10 we temporarely exit
629 	 * the tod_mutex and enter alarm lock. Time/date and alarm hardware
630 	 * have non-interlsecting registers, it is safe to use different locks.
631 	 */
632 	mutex_exit(&tod_lock);
633 	mutex_enter(&todds1337_alarm_lock);
634 
635 	/*
636 	 * Disable Alarm #1 Interrupt
637 	 */
638 	(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl,
639 	    &i2c_tp, 1, 1, I2C_SLEEP);
640 	i2c_tp->i2c_version = I2C_XFER_REV;
641 	i2c_tp->i2c_flags = I2C_WR_RD;
642 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_CTL; /* Read Control register */
643 
644 	if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp)) != I2C_SUCCESS) {
645 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
646 		cmn_err(CE_WARN, "todds1337_clear_power_alarm: failed to read "
647 		    "DS1337 control register");
648 		mutex_exit(&todds1337_alarm_lock);
649 		mutex_enter(&tod_lock);
650 		return;
651 	}
652 
653 	tmpval = i2c_tp->i2c_rbuf[0];
654 
655 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
656 
657 	(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl,
658 	    &i2c_tp, 2, 0, I2C_SLEEP);
659 	i2c_tp->i2c_version = I2C_XFER_REV;
660 	i2c_tp->i2c_flags = I2C_WR;
661 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_CTL; /* Write Control register */
662 	i2c_tp->i2c_wbuf[1] = tmpval & ~RTC_CTL_A1IE;
663 
664 	if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp)) != I2C_SUCCESS) {
665 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
666 		cmn_err(CE_WARN, "todds1337_clear_power_alarm: failed to write "
667 		    "DS1337 control register");
668 		mutex_exit(&todds1337_alarm_lock);
669 		mutex_enter(&tod_lock);
670 		return;
671 	}
672 
673 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
674 
675 	/*
676 	 * Reset Alarm #1 Flag
677 	 */
678 	(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl,
679 	    &i2c_tp, 1, 1, I2C_SLEEP);
680 	i2c_tp->i2c_version = I2C_XFER_REV;
681 	i2c_tp->i2c_flags = I2C_WR_RD;
682 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_STATUS; /* Read Status register */
683 
684 	if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp)) != I2C_SUCCESS) {
685 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
686 		cmn_err(CE_WARN, "todds1337_clear_power_alarm: failed to read "
687 		    "DS1337 status register");
688 		mutex_exit(&todds1337_alarm_lock);
689 		mutex_enter(&tod_lock);
690 		return;
691 	}
692 
693 	tmpval = i2c_tp->i2c_rbuf[0];
694 
695 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
696 
697 	(void) i2c_transfer_alloc(statep->ds1337_i2c_hdl,
698 	    &i2c_tp, 2, 0, I2C_SLEEP);
699 	i2c_tp->i2c_version = I2C_XFER_REV;
700 	i2c_tp->i2c_flags = I2C_WR;
701 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_STATUS; /* Write Status register */
702 	i2c_tp->i2c_wbuf[1] = tmpval & ~RTC_STATUS_A1F;
703 
704 	if ((i2c_transfer(statep->ds1337_i2c_hdl, i2c_tp)) != I2C_SUCCESS) {
705 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
706 		cmn_err(CE_WARN, "todds1337_clear_power_alarm: failed to write "
707 		    "DS1337 status register");
708 		mutex_exit(&todds1337_alarm_lock);
709 		mutex_enter(&tod_lock);
710 		return;
711 	}
712 
713 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
714 
715 	mutex_exit(&todds1337_alarm_lock);
716 	mutex_enter(&tod_lock);
717 }
718 
719 /* ARGSUSED */
720 static uint_t
721 todds1337_set_watchdog_timer(uint_t timeoutval)
722 {
723 	ASSERT(MUTEX_HELD(&tod_lock));
724 	return (0);
725 }
726 
727 /* ARGSUSED */
728 static uint_t
729 todds1337_clear_watchdog_timer(void)
730 {
731 	ASSERT(MUTEX_HELD(&tod_lock));
732 	return (0);
733 }
734 
735 /* ********************** Local functions ***************************** */
736 
737 static char tod_read[7] = {-1, -1, -1, -1, -1, -1, -1};
738 static int
739 todds1337_read_rtc(struct rtc_t *rtc)
740 {
741 	static	ds1337_state_t	*statep = NULL;
742 	i2c_transfer_t	*i2c_tp = NULL;
743 	int i2c_cmd_status = I2C_FAILURE;
744 	int counter = 4;
745 
746 	if (!todds1337_attach_done) {
747 		return (todds1337_prom_getdate(rtc));
748 	}
749 
750 	statep = ddi_get_soft_state(ds1337_statep, instance);
751 	if (statep == NULL) {
752 		cmn_err(CE_WARN, "todds1337: ddi_get_soft_state failing");
753 		return (DDI_FAILURE);
754 	}
755 
756 	mutex_enter(&todds1337_rd_lock);
757 
758 	/*
759 	 * Allocate 1 byte for write buffer and 7 bytes for read buffer to
760 	 * to accomodate sec, min, hrs, dayOfWeek, dayOfMonth, year
761 	 */
762 	if ((i2c_transfer_alloc(statep->ds1337_i2c_hdl, &i2c_tp, 1,
763 	    7, I2C_SLEEP)) != I2C_SUCCESS) {
764 		mutex_exit(&todds1337_rd_lock);
765 		return (DDI_FAILURE);
766 	}
767 
768 	do {
769 		i2c_tp->i2c_version = I2C_XFER_REV;
770 		i2c_tp->i2c_flags = I2C_WR_RD;
771 		i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_SEC; /* Start from 0x00 */
772 		i2c_tp->i2c_wlen = 1;	/* Write one byte address */
773 		i2c_tp->i2c_rlen = 7;	/* Read 7 regs */
774 
775 		if ((i2c_cmd_status = i2c_transfer(statep->ds1337_i2c_hdl,
776 		    i2c_tp)) != I2C_SUCCESS) {
777 			goto done;
778 		}
779 	    /* for first read, need to get valid data */
780 	    while (tod_read[0] == -1 && counter > 0) {
781 	    /* move data to static buffer */
782 		bcopy(i2c_tp->i2c_rbuf, tod_read, 7);
783 
784 		/* now read again */
785 		/* Start reading reg from 0x00 */
786 		i2c_tp->i2c_wbuf[0] = (uchar_t)0x00;
787 		i2c_tp->i2c_wlen = 1;	/* Write one byte address */
788 		i2c_tp->i2c_rlen = 7;	/* Read 7 regs */
789 		if ((i2c_cmd_status = i2c_transfer(statep->ds1337_i2c_hdl,
790 		    i2c_tp)) != I2C_SUCCESS) {
791 		    goto done;
792 		}
793 		/* if they are not the same, then read again */
794 		if (bcmp(tod_read, i2c_tp->i2c_rbuf, 7) != 0) {
795 		    tod_read[0] = -1;
796 		    counter--;
797 		}
798 	    }
799 
800 	} while (i2c_tp->i2c_rbuf[0] == 0x59 &&
801 	    /* if seconds register is 0x59 (BCD), add data should match */
802 		bcmp(&tod_read[1], &i2c_tp->i2c_rbuf[1], 6) != 0 &&
803 		    counter-- > 0);
804 
805 	if (counter < 0)
806 	    cmn_err(CE_WARN, "i2ctod: TOD Chip failed ??");
807 
808 	/* move data to static buffer */
809 	bcopy(i2c_tp->i2c_rbuf, tod_read, 7);
810 
811 
812 	rtc->rtc_year	= BCD_TO_BYTE(i2c_tp->i2c_rbuf[6]);
813 	rtc->rtc_mon	= BCD_TO_BYTE(i2c_tp->i2c_rbuf[5]);
814 	rtc->rtc_dom	= BCD_TO_BYTE(i2c_tp->i2c_rbuf[4]);
815 	rtc->rtc_dow	= BCD_TO_BYTE(i2c_tp->i2c_rbuf[3]);
816 	rtc->rtc_hrs	= BCD_TO_BYTE(i2c_tp->i2c_rbuf[2]);
817 	rtc->rtc_min	= BCD_TO_BYTE(i2c_tp->i2c_rbuf[1]);
818 	rtc->rtc_sec	= BCD_TO_BYTE(i2c_tp->i2c_rbuf[0]);
819 
820 done:
821 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
822 
823 	mutex_exit(&todds1337_rd_lock);
824 	return (i2c_cmd_status);
825 }
826 
827 
828 static int
829 todds1337_write_rtc(struct rtc_t *rtc)
830 {
831 	ds1337_state_t	*statep = NULL;
832 	i2c_transfer_t	*i2c_tp = NULL;
833 	int i2c_cmd_status = I2C_SUCCESS;
834 
835 
836 	if (!todds1337_attach_done) {
837 		return (todds1337_prom_setdate(rtc));
838 	}
839 
840 	statep = ddi_get_soft_state(ds1337_statep, instance);
841 	if (statep == NULL) {
842 		return (DDI_FAILURE);
843 	}
844 
845 	if ((i2c_cmd_status = i2c_transfer_alloc(statep->ds1337_i2c_hdl,
846 	    &i2c_tp, 8, 0, I2C_SLEEP)) != I2C_SUCCESS) {
847 		return (i2c_cmd_status);
848 	}
849 
850 	i2c_tp->i2c_version = I2C_XFER_REV;
851 	i2c_tp->i2c_flags = I2C_WR;
852 	i2c_tp->i2c_wbuf[0] = (uchar_t)RTC_SEC;
853 	i2c_tp->i2c_wbuf[1] = BYTE_TO_BCD(rtc->rtc_sec);
854 	i2c_tp->i2c_wbuf[2] = BYTE_TO_BCD(rtc->rtc_min);
855 	i2c_tp->i2c_wbuf[3] = BYTE_TO_BCD(rtc->rtc_hrs);
856 	i2c_tp->i2c_wbuf[4] = BYTE_TO_BCD(rtc->rtc_dow);
857 	i2c_tp->i2c_wbuf[5] = BYTE_TO_BCD(rtc->rtc_dom);
858 	i2c_tp->i2c_wbuf[6] = BYTE_TO_BCD(rtc->rtc_mon);
859 	i2c_tp->i2c_wbuf[7] = BYTE_TO_BCD(rtc->rtc_year);
860 	i2c_tp->i2c_wlen = 8;
861 
862 	if ((i2c_cmd_status = i2c_transfer(statep->ds1337_i2c_hdl,
863 	    i2c_tp)) != I2C_SUCCESS) {
864 		(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
865 		return (i2c_cmd_status);
866 	}
867 
868 	tod_read[0] = -1;  /* invalidate saved data from read routine */
869 
870 	(void) i2c_transfer_free(statep->ds1337_i2c_hdl, i2c_tp);
871 
872 	return (i2c_cmd_status);
873 }
874 
875 
876 /*ARGSUSED*/
877 static int
878 todds1337_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
879     void **result)
880 {
881 	ds1337_state_t *softsp;
882 
883 	if (instance == -1) {
884 		return (DDI_FAILURE);
885 	}
886 
887 	switch (infocmd) {
888 	case DDI_INFO_DEVT2DEVINFO:
889 		if ((softsp = ddi_get_soft_state(ds1337_statep, instance)) ==
890 		    NULL)
891 			return (DDI_FAILURE);
892 		*result = (void *)softsp->dip;
893 		return (DDI_SUCCESS);
894 	case DDI_INFO_DEVT2INSTANCE:
895 		*result = (void *)(uintptr_t)instance;
896 		return (DDI_SUCCESS);
897 	default:
898 		return (DDI_FAILURE);
899 	}
900 }
901 
902 /*
903  * Finds the device node with device_type "rtc" and opens it to
904  * execute the get-time method
905  */
906 static int
907 todds1337_setup_prom()
908 {
909 	pnode_t todnode;
910 	char tod1337_devpath[MAXNAMELEN];
911 
912 	if ((todnode = prom_findnode_bydevtype(prom_rootnode(),
913 	    DS1337_DEVICE_TYPE)) == OBP_NONODE)
914 		return (DDI_FAILURE);
915 
916 	/*
917 	 * We now have the phandle of the rtc node, we need to open the
918 	 * node and get the ihandle
919 	 */
920 	if (prom_phandle_to_path(todnode, tod1337_devpath,
921 	    sizeof (tod1337_devpath)) < 0) {
922 		cmn_err(CE_WARN, "prom_phandle_to_path failed");
923 		return (DDI_FAILURE);
924 	}
925 
926 	/*
927 	 * Now open the node and store it's ihandle
928 	 */
929 	if ((todds1337_ihandle = prom_open(tod1337_devpath)) == NULL) {
930 		cmn_err(CE_WARN, "prom_open failed");
931 		return (DDI_FAILURE);
932 	}
933 
934 	return (DDI_SUCCESS);
935 }
936 
937 /*
938  * Closes the prom interface
939  */
940 static void
941 todds1337_rele_prom()
942 {
943 	(void) prom_close(todds1337_ihandle);
944 }
945 
946 /*
947  * Read the date using "get-time" method in rtc node
948  * PROM returns 1969-1999 when reading 69-99 and
949  * 2000-2068 when reading 00-68
950  */
951 static int
952 todds1337_prom_getdate(struct rtc_t *rtc)
953 {
954 	int year;
955 	cell_t ci[12];
956 
957 	ci[0] = p1275_ptr2cell("call-method");  /* Service name */
958 	ci[1] = 2; /* # of arguments */
959 	ci[2] = 7; /* # of result cells */
960 	ci[3] = p1275_ptr2cell("get-time");
961 	ci[4] = p1275_ihandle2cell(todds1337_ihandle);
962 
963 	promif_preprom();
964 	(void) p1275_cif_handler(&ci);
965 	promif_postprom();
966 
967 	year 		= p1275_cell2int(ci[6]);
968 	rtc->rtc_mon	= p1275_cell2int(ci[7]);
969 	rtc->rtc_dom	= p1275_cell2int(ci[8]);
970 	rtc->rtc_dow	= 0;
971 	rtc->rtc_hrs	= p1275_cell2int(ci[9]);
972 	rtc->rtc_min	= p1275_cell2int(ci[10]);
973 	rtc->rtc_sec	= p1275_cell2int(ci[11]);
974 	if (year >= 2000)
975 		year -= 2000;
976 	else
977 		year -= 1900;
978 	rtc->rtc_year	= year;
979 
980 	return (DDI_SUCCESS);
981 }
982 
983 /*
984  * Read the date using "set-time" method in rtc node
985  * For values 00 - 68, write 2000-2068, and for 69-99,
986  * write 1969-1999
987  */
988 static int
989 todds1337_prom_setdate(struct rtc_t *rtc)
990 {
991 	int year;
992 	cell_t ci[12];
993 
994 	year = rtc->rtc_year;
995 
996 	if ((year < 0) || (year > 99))
997 		return (DDI_FAILURE);
998 
999 	if (year <= 68)
1000 		year = rtc->rtc_year + 2000;
1001 	else
1002 		year = rtc->rtc_year + 1900;
1003 
1004 	ci[0] = p1275_ptr2cell("call-method");  /* Service name */
1005 	ci[1] = 8; /* # of arguments */
1006 	ci[2] = 0; /* # of result cells */
1007 	ci[3] = p1275_ptr2cell("set-time");
1008 	ci[4] = p1275_ihandle2cell(todds1337_ihandle);
1009 	ci[5] = p1275_int2cell(year);
1010 	ci[6] = p1275_int2cell(rtc->rtc_mon);
1011 	ci[7] = p1275_int2cell(rtc->rtc_dom);
1012 	ci[8] = p1275_int2cell(rtc->rtc_hrs);
1013 	ci[9] = p1275_int2cell(rtc->rtc_min);
1014 	ci[10] = p1275_int2cell(rtc->rtc_sec);
1015 
1016 	promif_preprom();
1017 	(void) p1275_cif_handler(&ci);
1018 	promif_postprom();
1019 
1020 	return (DDI_SUCCESS);
1021 }
1022