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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 27 #include <sys/types.h> 28 #include <sys/conf.h> 29 #include <sys/devops.h> 30 #include <sys/kmem.h> 31 #include <sys/open.h> 32 #include <sys/file.h> 33 #include <sys/note.h> 34 #include <sys/ddi.h> 35 #include <sys/sunddi.h> 36 37 #include <sys/modctl.h> 38 #include <sys/stat.h> 39 #include <sys/clock.h> 40 #include <sys/reboot.h> 41 #include <sys/machsystm.h> 42 #include <sys/poll.h> 43 #include <sys/pbio.h> 44 #include <sys/sysmacros.h> 45 46 /* Added for prom interface */ 47 #include <sys/promif.h> 48 #include <sys/promimpl.h> 49 50 #include <sys/i2c/misc/i2c_svc.h> 51 #include <sys/todds1307.h> 52 53 #define I2C_DELAY 20000 54 #define DS1307_DEVICE_TYPE "rtc" 55 56 /* 57 * Driver enrty routines 58 */ 59 static int todds1307_attach(dev_info_t *, ddi_attach_cmd_t); 60 static int todds1307_detach(dev_info_t *, ddi_detach_cmd_t); 61 static int todds1307_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 62 63 /* 64 * tod_ops entry routines 65 */ 66 static timestruc_t todds1307_get(void); 67 static void todds1307_set(timestruc_t); 68 static uint_t todds1307_set_watchdog_timer(uint_t); 69 static uint_t todds1307_clear_watchdog_timer(void); 70 static void todds1307_set_power_alarm(timestruc_t); 71 static void todds1307_clear_power_alarm(void); 72 static int todds1307_setup_prom(); 73 static void todds1307_rele_prom(); 74 static int todds1307_prom_getdate(struct rtc_t *rtc); 75 static int todds1307_prom_setdate(struct rtc_t *rtc); 76 77 /* 78 * Local functions 79 */ 80 static int todds1307_read_rtc(struct rtc_t *); 81 static int todds1307_write_rtc(struct rtc_t *); 82 83 /* Anchor for soft state structure */ 84 static void *ds1307_statep; 85 static int instance = -1; 86 static int todds1307_attach_done = 0; 87 static kmutex_t todds1307_rd_lock; 88 static ihandle_t todds1307_ihandle = 0; 89 90 /* one second time out */ 91 #define I2c_CYCLIC_TIMEOUT 1000000000 92 uint_t i2c_cyclic_timeout = I2c_CYCLIC_TIMEOUT; 93 static int sync_clock_once = 1; 94 static struct rtc_t soft_rtc; 95 96 /* 97 * For debugging only 98 */ 99 static unsigned char int2bcd(int num); 100 static int bcd2int(unsigned char num); 101 102 /* 103 * cp_ops structure 104 */ 105 static struct cb_ops ds1307_cbops = { 106 nodev, /* open */ 107 nodev, /* close */ 108 nodev, /* strategy */ 109 nodev, /* print */ 110 nodev, /* dump */ 111 nodev, /* read */ 112 nodev, /* write */ 113 nodev, /* ioctl */ 114 nodev, /* devmap */ 115 nodev, /* mmap */ 116 nodev, /* segmap */ 117 NULL, /* poll */ 118 ddi_prop_op, /* cb_prop_op */ 119 NULL, /* streamtab */ 120 D_NEW | D_MP, /* Driver compatibility flag */ 121 CB_REV, /* rev */ 122 nodev, /* int (*cb_aread)() */ 123 nodev /* int (*cb_awrite)() */ 124 }; 125 126 /* 127 * dev_ops structure 128 */ 129 static struct dev_ops ds1307_ops = { 130 DEVO_REV, /* devo_rev */ 131 0, /* refcnt - reference cnt always set to 0 */ 132 todds1307_getinfo, /* getinfo - Maybe requred */ 133 nulldev, /* identify */ 134 nulldev, /* probe */ 135 todds1307_attach, /* attach */ 136 todds1307_detach, /* detach */ 137 nodev, /* reset */ 138 &ds1307_cbops, /* cb_ops - ds1307 does not need this(?) */ 139 NULL, /* bus_ops */ 140 NULL, /* power */ 141 ddi_quiesce_not_needed, /* quiesce */ 142 }; 143 144 static struct modldrv todds1307_modldrv = { 145 &mod_driverops, /* Type of module. This one is a driver */ 146 "tod driver for DS1307 v1.12", /* Name of the module */ 147 &ds1307_ops, /* Pointer to dev_ops */ 148 }; 149 150 /* 151 * Module linkage structure 152 */ 153 static struct modlinkage todds1307_modlinkage = { 154 MODREV_1, 155 &todds1307_modldrv, 156 0 157 }; 158 159 int 160 _init(void) 161 { 162 int error; 163 164 if (strcmp(tod_module_name, "todds1307") == 0) { 165 if ((error = ddi_soft_state_init(&ds1307_statep, 166 sizeof (ds1307_state_t), 0)) != DDI_SUCCESS) { 167 return (error); 168 } 169 170 tod_ops.tod_get = todds1307_get; 171 tod_ops.tod_set = todds1307_set; 172 tod_ops.tod_set_watchdog_timer = todds1307_set_watchdog_timer; 173 tod_ops.tod_clear_watchdog_timer = 174 todds1307_clear_watchdog_timer; 175 tod_ops.tod_set_power_alarm = todds1307_set_power_alarm; 176 tod_ops.tod_clear_power_alarm = todds1307_clear_power_alarm; 177 } 178 179 (void) todds1307_setup_prom(); 180 181 /* 182 * Install the module 183 */ 184 if ((error = mod_install(&todds1307_modlinkage)) != 0) { 185 ddi_soft_state_fini(&ds1307_statep); 186 return (error); 187 } 188 mutex_init(&todds1307_rd_lock, NULL, MUTEX_DEFAULT, NULL); 189 190 return (0); 191 } 192 193 int 194 _fini(void) 195 { 196 int error = 0; 197 198 if (strcmp(tod_module_name, "todds1307") == 0) { 199 error = EBUSY; 200 } else { 201 if ((error = mod_remove(&todds1307_modlinkage)) == 0) { 202 ddi_soft_state_fini(&ds1307_statep); 203 mutex_destroy(&todds1307_rd_lock); 204 todds1307_rele_prom(); 205 } 206 } 207 208 return (error); 209 } 210 211 int 212 _info(struct modinfo *modinfop) 213 { 214 return (mod_info(&todds1307_modlinkage, modinfop)); 215 } 216 217 /* 218 * cyclical call to get tod. 219 */ 220 static void 221 todds1307_cyclic(void *arg) 222 { 223 224 (void) todds1307_read_rtc((struct rtc_t *)arg); 225 226 } 227 228 /* 229 * register ds1307 client device with i2c services, and 230 * allocate & initialize soft state structure. 231 */ 232 static int 233 todds1307_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 234 { 235 static ds1307_state_t *statep = NULL; 236 i2c_transfer_t *i2c_tp = NULL; 237 uint8_t tempVal = (uint8_t)0; 238 switch (cmd) { 239 240 case DDI_ATTACH: 241 break; 242 case DDI_RESUME: 243 return (DDI_SUCCESS); 244 default: 245 return (DDI_FAILURE); 246 } 247 248 if (instance != -1) { 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(ds1307_statep, instance) != DDI_SUCCESS) { 258 return (DDI_FAILURE); 259 } 260 261 statep = ddi_get_soft_state(ds1307_statep, instance); 262 if (statep == NULL) { 263 return (DDI_FAILURE); 264 } 265 266 statep->dip = dip; 267 268 if (i2c_client_register(dip, &statep->ds1307_i2c_hdl) != I2C_SUCCESS) { 269 ddi_soft_state_free(ds1307_statep, instance); 270 delay(drv_usectohz(I2C_DELAY)); 271 return (DDI_FAILURE); 272 } 273 274 /* check and initialize the oscillator */ 275 276 (void) i2c_transfer_alloc(statep->ds1307_i2c_hdl, 277 &i2c_tp, 1, 1, I2C_SLEEP); 278 i2c_tp->i2c_version = I2C_XFER_REV; 279 i2c_tp->i2c_flags = I2C_WR_RD; 280 i2c_tp->i2c_wbuf[0] = (uchar_t)0x00; /* Read 00h */ 281 i2c_tp->i2c_wlen = 1; 282 i2c_tp->i2c_rlen = 1; 283 284 if ((i2c_transfer(statep->ds1307_i2c_hdl, i2c_tp)) != I2C_SUCCESS) { 285 (void) i2c_transfer_free(statep->ds1307_i2c_hdl, i2c_tp); 286 ddi_soft_state_free(ds1307_statep, instance); 287 delay(drv_usectohz(I2C_DELAY)); 288 return (DDI_FAILURE); 289 } 290 291 tempVal = i2c_tp->i2c_rbuf[0]; 292 293 (void) i2c_transfer_free(statep->ds1307_i2c_hdl, i2c_tp); 294 295 if (tempVal & 0x80) { /* check Oscillator */ 296 (void) i2c_transfer_alloc(statep->ds1307_i2c_hdl, &i2c_tp, 297 2, 1, I2C_SLEEP); 298 i2c_tp->i2c_version = I2C_XFER_REV; 299 i2c_tp->i2c_flags = I2C_WR; 300 i2c_tp->i2c_wbuf[0] = 0x00; 301 i2c_tp->i2c_wbuf[1] = 302 (uchar_t)(i2c_tp->i2c_rbuf[0]& 0x7f); 303 i2c_tp->i2c_wlen = 2; 304 /* Enable oscillator */ 305 if ((i2c_transfer(statep->ds1307_i2c_hdl, i2c_tp)) 306 != I2C_SUCCESS) { 307 (void) i2c_transfer_free(statep->ds1307_i2c_hdl, 308 i2c_tp); 309 ddi_soft_state_free(ds1307_statep, instance); 310 return (DDI_FAILURE); 311 } 312 (void) i2c_transfer_free(statep->ds1307_i2c_hdl, i2c_tp); 313 } 314 315 /* 316 * Create a periodical handler to read TOD. 317 */ 318 ASSERT(statep->cycid == NULL); 319 statep->cycid = ddi_periodic_add(todds1307_cyclic, &soft_rtc, 320 i2c_cyclic_timeout, DDI_IPL_1); 321 322 statep->state = TOD_ATTACHED; 323 todds1307_attach_done = 1; 324 ddi_report_dev(dip); 325 326 return (DDI_SUCCESS); 327 } 328 329 /* 330 * Unregister ds1307 client device with i2c services and free 331 * soft state structure. 332 */ 333 /*ARGSUSED*/ 334 static int 335 todds1307_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 336 { 337 switch (cmd) { 338 339 /* 340 * Once attached, do not allow detach because the system constantly 341 * calling todds1307_get() to get the time. If the driver is detached 342 * and the system try to get the time, the system will have memory 343 * problem. 344 * 345 * ds1307_state_t *statep = NULL; 346 * case DDI_DETACH: 347 * if ((statep = ddi_get_soft_state(ds1307_statep, 348 * instance)) == NULL) { 349 * return (ENOMEM); 350 * } 351 * i2c_client_unregister(statep->ds1307_i2c_hdl); 352 * ddi_soft_state_free(ds1307_statep, instance); 353 * return (DDI_SUCCESS); 354 */ 355 case DDI_SUSPEND: 356 return (DDI_SUCCESS); 357 358 default: 359 return (DDI_FAILURE); 360 } 361 } 362 363 /* *********************** tod_ops entry points ******************** */ 364 365 /* 366 * Read the current time from the DS1307 chip and convert to UNIX form. 367 * Should be called with tod_clock held. 368 */ 369 370 static timestruc_t 371 todds1307_get(void) 372 { 373 timestruc_t ts; 374 todinfo_t tod; 375 struct rtc_t rtc; 376 377 ASSERT(MUTEX_HELD(&tod_lock)); 378 379 if (sync_clock_once) { 380 (void) todds1307_read_rtc(&soft_rtc); 381 sync_clock_once = 0; 382 } else { 383 tod_status_set(TOD_GET_FAILED); 384 return (hrestime); 385 } 386 387 bcopy(&soft_rtc, &rtc, sizeof (rtc)); 388 389 /* 390 * 00 - 68 = 2000 thru 2068 391 * 69-99 = 1969 thru 1999 392 */ 393 tod.tod_year = rtc.rtc_year; 394 if (rtc.rtc_year <= 68) 395 tod.tod_year += 100; 396 tod.tod_month = rtc.rtc_mon; 397 tod.tod_day = rtc.rtc_dom; 398 tod.tod_dow = rtc.rtc_dow; 399 tod.tod_hour = rtc.rtc_hrs; 400 tod.tod_min = rtc.rtc_min; 401 tod.tod_sec = rtc.rtc_sec; 402 403 /* read was successful so ensure failure flag is clear */ 404 tod_status_clear(TOD_GET_FAILED); 405 406 ts.tv_sec = tod_to_utc(tod); 407 ts.tv_nsec = 0; 408 return (ts); 409 } 410 411 /* 412 * Program DS1307 with the specified time. 413 * Must be called with tod_lock held. The TOD 414 * chip supports date from 1969-2068 only. We must 415 * reject requests to set date below 2000. 416 */ 417 static void 418 todds1307_set(timestruc_t ts) 419 { 420 struct rtc_t rtc; 421 todinfo_t tod = utc_to_tod(ts.tv_sec); 422 int year; 423 424 425 ASSERT(MUTEX_HELD(&tod_lock)); 426 427 /* 428 * Year is base 1900, valid year range 1969-2068 429 */ 430 if ((tod.tod_year < 69) || (tod.tod_year > 168)) 431 return; 432 433 year = tod.tod_year; 434 if (year >= 100) 435 year -= 100; 436 437 rtc.rtc_year = int2bcd(year); 438 rtc.rtc_mon = int2bcd(tod.tod_month); 439 rtc.rtc_dom = int2bcd(tod.tod_day); 440 rtc.rtc_dow = int2bcd(tod.tod_dow); 441 rtc.rtc_hrs = int2bcd(tod.tod_hour); 442 rtc.rtc_min = int2bcd(tod.tod_min); 443 rtc.rtc_sec = int2bcd(tod.tod_sec); 444 445 (void) todds1307_write_rtc(&rtc); 446 } 447 448 /* ARGSUSED */ 449 static void 450 todds1307_set_power_alarm(timestruc_t ts) 451 { 452 ASSERT(MUTEX_HELD(&tod_lock)); 453 } 454 455 /* ARGSUSED */ 456 static void 457 todds1307_clear_power_alarm(void) 458 { 459 ASSERT(MUTEX_HELD(&tod_lock)); 460 } 461 462 /* ARGSUSED */ 463 static uint_t 464 todds1307_set_watchdog_timer(uint_t timeoutval) 465 { 466 ASSERT(MUTEX_HELD(&tod_lock)); 467 return (0); 468 } 469 470 /* ARGSUSED */ 471 static uint_t 472 todds1307_clear_watchdog_timer(void) 473 { 474 ASSERT(MUTEX_HELD(&tod_lock)); 475 return (0); 476 } 477 478 /* ********************** Local functions ***************************** */ 479 480 static char tod_read[7] = {-1, -1, -1, -1, -1, -1, -1}; 481 static int 482 todds1307_read_rtc(struct rtc_t *rtc) 483 { 484 static ds1307_state_t *statep = NULL; 485 i2c_transfer_t *i2c_tp = NULL; 486 int i2c_cmd_status = I2C_FAILURE; 487 int counter = 4; 488 489 if (!todds1307_attach_done) { 490 return (todds1307_prom_getdate(rtc)); 491 } 492 493 statep = ddi_get_soft_state(ds1307_statep, instance); 494 if (statep == NULL) { 495 cmn_err(CE_WARN, "todds1307: ddi_get_soft_state failed"); 496 return (DDI_FAILURE); 497 } 498 499 mutex_enter(&todds1307_rd_lock); 500 501 /* 502 * Allocate 1 byte for write buffer and 7 bytes for read buffer to 503 * to accomodate sec, min, hrs, dayOfWeek, dayOfMonth, year 504 */ 505 if ((i2c_transfer_alloc(statep->ds1307_i2c_hdl, &i2c_tp, 1, 506 7, I2C_SLEEP)) != I2C_SUCCESS) { 507 mutex_exit(&todds1307_rd_lock); 508 return (DDI_FAILURE); 509 } 510 511 do { 512 i2c_tp->i2c_version = I2C_XFER_REV; 513 i2c_tp->i2c_flags = I2C_WR_RD; 514 i2c_tp->i2c_wbuf[0] = (uchar_t)0x00; /* Start from reg 0x00 */ 515 i2c_tp->i2c_wlen = 1; /* Write one byte address */ 516 i2c_tp->i2c_rlen = 7; /* Read 7 regs */ 517 518 if ((i2c_cmd_status = i2c_transfer(statep->ds1307_i2c_hdl, 519 i2c_tp)) != I2C_SUCCESS) { 520 drv_usecwait(I2C_DELAY); 521 goto done; 522 } 523 /* for first read, need to get valid data */ 524 while (tod_read[0] == -1 && counter > 0) { 525 /* move data to static buffer */ 526 bcopy(i2c_tp->i2c_rbuf, tod_read, 7); 527 528 /* now read again */ 529 /* Start reading reg from 0x00 */ 530 i2c_tp->i2c_wbuf[0] = (uchar_t)0x00; 531 i2c_tp->i2c_wlen = 1; /* Write one byte address */ 532 i2c_tp->i2c_rlen = 7; /* Read 7 regs */ 533 if ((i2c_cmd_status = i2c_transfer(statep->ds1307_i2c_hdl, 534 i2c_tp)) != I2C_SUCCESS) { 535 drv_usecwait(I2C_DELAY); 536 goto done; 537 } 538 /* if they are not the same, then read again */ 539 if (bcmp(tod_read, i2c_tp->i2c_rbuf, 7) != 0) { 540 tod_read[0] = -1; 541 counter--; 542 } 543 } 544 545 } while (i2c_tp->i2c_rbuf[0] == 0x59 && 546 /* if seconds register is 0x59 (BCD), add data should match */ 547 bcmp(&tod_read[1], &i2c_tp->i2c_rbuf[1], 6) != 0 && 548 counter-- > 0); 549 550 if (counter < 0) 551 cmn_err(CE_WARN, "i2ctod: TOD Chip failed ??"); 552 553 /* move data to static buffer */ 554 bcopy(i2c_tp->i2c_rbuf, tod_read, 7); 555 556 557 rtc->rtc_year = bcd2int(i2c_tp->i2c_rbuf[6]); 558 rtc->rtc_mon = bcd2int(i2c_tp->i2c_rbuf[5]); 559 rtc->rtc_dom = bcd2int(i2c_tp->i2c_rbuf[4]); 560 rtc->rtc_dow = bcd2int(i2c_tp->i2c_rbuf[3]); 561 rtc->rtc_hrs = bcd2int(i2c_tp->i2c_rbuf[2]); 562 rtc->rtc_min = bcd2int(i2c_tp->i2c_rbuf[1]); 563 rtc->rtc_sec = bcd2int(i2c_tp->i2c_rbuf[0]); 564 565 done: 566 (void) i2c_transfer_free(statep->ds1307_i2c_hdl, i2c_tp); 567 568 mutex_exit(&todds1307_rd_lock); 569 return (i2c_cmd_status); 570 } 571 572 573 static int 574 todds1307_write_rtc(struct rtc_t *rtc) 575 { 576 ds1307_state_t *statep = NULL; 577 i2c_transfer_t *i2c_tp = NULL; 578 int i2c_cmd_status = I2C_SUCCESS; 579 580 581 if (!todds1307_attach_done) { 582 return (todds1307_prom_setdate(rtc)); 583 } 584 585 statep = ddi_get_soft_state(ds1307_statep, instance); 586 if (statep == NULL) { 587 return (DDI_FAILURE); 588 } 589 590 if ((i2c_cmd_status = i2c_transfer_alloc(statep->ds1307_i2c_hdl, 591 &i2c_tp, 8, 0, I2C_SLEEP)) != I2C_SUCCESS) { 592 return (i2c_cmd_status); 593 } 594 595 i2c_tp->i2c_version = I2C_XFER_REV; 596 i2c_tp->i2c_flags = I2C_WR; 597 i2c_tp->i2c_wbuf[0] = (uchar_t)0x00; 598 i2c_tp->i2c_wbuf[1] = rtc->rtc_sec; 599 i2c_tp->i2c_wbuf[2] = rtc->rtc_min; 600 i2c_tp->i2c_wbuf[3] = rtc->rtc_hrs; 601 i2c_tp->i2c_wbuf[4] = rtc->rtc_dow; 602 i2c_tp->i2c_wbuf[5] = rtc->rtc_dom; 603 i2c_tp->i2c_wbuf[6] = rtc->rtc_mon; 604 i2c_tp->i2c_wbuf[7] = rtc->rtc_year; 605 i2c_tp->i2c_wlen = 8; 606 607 if ((i2c_cmd_status = i2c_transfer(statep->ds1307_i2c_hdl, 608 i2c_tp)) != I2C_SUCCESS) { 609 (void) i2c_transfer_free(statep->ds1307_i2c_hdl, i2c_tp); 610 /* delay(drv_usectohz(I2C_DELAY)); */ 611 drv_usecwait(I2C_DELAY); 612 return (i2c_cmd_status); 613 } 614 615 tod_read[0] = -1; /* invalidate saved data from read routine */ 616 617 (void) i2c_transfer_free(statep->ds1307_i2c_hdl, i2c_tp); 618 619 return (i2c_cmd_status); 620 } 621 622 623 /*ARGSUSED*/ 624 static int 625 todds1307_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, 626 void **result) 627 { 628 ds1307_state_t *softsp; 629 630 if (instance == -1) { 631 return (DDI_FAILURE); 632 } 633 634 switch (infocmd) { 635 case DDI_INFO_DEVT2DEVINFO: 636 if ((softsp = ddi_get_soft_state(ds1307_statep, instance)) 637 == NULL) 638 return (DDI_FAILURE); 639 *result = (void *)softsp->dip; 640 return (DDI_SUCCESS); 641 642 case DDI_INFO_DEVT2INSTANCE: 643 *result = (void *)(uintptr_t)instance; 644 return (DDI_SUCCESS); 645 646 default: 647 return (DDI_FAILURE); 648 } 649 } 650 651 /* 652 * Conversion functions 653 */ 654 static unsigned char 655 int2bcd(int num) { 656 return (((num / 10) << 4) /* tens BCD digit in high four bits */ 657 + (num % 10)); /* units digit goes in low four bits */ 658 } 659 660 static int 661 bcd2int(unsigned char num) { 662 return (((num >> 4) * 10) /* 10 times high-order four bits */ 663 + (num & 0x0f)); /* plus low-order four bits */ 664 } 665 666 /* 667 * Finds the device node with device_type "rtc" and opens it to 668 * execute the get-time method 669 */ 670 static int 671 todds1307_setup_prom() 672 { 673 pnode_t todnode; 674 char tod1307_devpath[MAXNAMELEN]; 675 676 if ((todnode = prom_findnode_bydevtype(prom_rootnode(), 677 DS1307_DEVICE_TYPE)) == OBP_NONODE) 678 return (DDI_FAILURE); 679 680 /* 681 * We now have the phandle of the rtc node, we need to open the 682 * node and get the ihandle 683 */ 684 if (prom_phandle_to_path(todnode, tod1307_devpath, 685 sizeof (tod1307_devpath)) < 0) { 686 cmn_err(CE_WARN, "prom_phandle_to_path failed"); 687 return (DDI_FAILURE); 688 } 689 690 /* 691 * Now open the node and store it's ihandle 692 */ 693 if ((todds1307_ihandle = prom_open(tod1307_devpath)) == NULL) { 694 cmn_err(CE_WARN, "prom_open failed"); 695 return (DDI_FAILURE); 696 } 697 698 return (DDI_SUCCESS); 699 } 700 701 /* 702 * Closes the prom interface 703 */ 704 static void 705 todds1307_rele_prom() 706 { 707 (void) prom_close(todds1307_ihandle); 708 } 709 710 /* 711 * Read the date using "get-time" method in rtc node 712 * PROM returns 1969-1999 when reading 69-99 and 713 * 2000-2068 when reading 00-68 714 */ 715 static int 716 todds1307_prom_getdate(struct rtc_t *rtc) 717 { 718 int year; 719 cell_t ci[12]; 720 721 ci[0] = p1275_ptr2cell("call-method"); /* Service name */ 722 ci[1] = 2; /* # of arguments */ 723 ci[2] = 7; /* # of result cells */ 724 ci[3] = p1275_ptr2cell("get-time"); 725 ci[4] = p1275_ihandle2cell(todds1307_ihandle); 726 727 promif_preprom(); 728 (void) p1275_cif_handler(&ci); 729 promif_postprom(); 730 731 year = p1275_cell2int(ci[6]); 732 rtc->rtc_mon = p1275_cell2int(ci[7]); 733 rtc->rtc_dom = p1275_cell2int(ci[8]); 734 rtc->rtc_dow = 0; 735 rtc->rtc_hrs = p1275_cell2int(ci[9]); 736 rtc->rtc_min = p1275_cell2int(ci[10]); 737 rtc->rtc_sec = p1275_cell2int(ci[11]); 738 if (year >= 2000) 739 year -= 2000; 740 else 741 year -= 1900; 742 rtc->rtc_year = year; 743 744 return (DDI_SUCCESS); 745 } 746 747 /* 748 * Read the date using "set-time" method in rtc node 749 * For values 00 - 68, write 2000-2068, and for 69-99, 750 * write 1969-1999 751 */ 752 static int 753 todds1307_prom_setdate(struct rtc_t *rtc) 754 { 755 int year; 756 cell_t ci[12]; 757 758 year = rtc->rtc_year; 759 760 if ((year < 0) || (year > 99)) 761 return (DDI_FAILURE); 762 763 if (year <= 68) 764 year = rtc->rtc_year + 2000; 765 else 766 year = rtc->rtc_year + 1900; 767 768 ci[0] = p1275_ptr2cell("call-method"); /* Service name */ 769 ci[1] = 8; /* # of arguments */ 770 ci[2] = 0; /* # of result cells */ 771 ci[3] = p1275_ptr2cell("set-time"); 772 ci[4] = p1275_ihandle2cell(todds1307_ihandle); 773 ci[5] = p1275_int2cell(year); 774 ci[6] = p1275_int2cell(rtc->rtc_mon); 775 ci[7] = p1275_int2cell(rtc->rtc_dom); 776 ci[8] = p1275_int2cell(rtc->rtc_hrs); 777 ci[9] = p1275_int2cell(rtc->rtc_min); 778 ci[10] = p1275_int2cell(rtc->rtc_sec); 779 780 promif_preprom(); 781 (void) p1275_cif_handler(&ci); 782 promif_postprom(); 783 784 return (DDI_SUCCESS); 785 } 786