todds1307.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/machsystm.h>
#include <sys/sysmacros.h>
/* Added for prom interface */
#include <sys/promimpl.h>
#include <sys/todds1307.h>
#define I2C_DELAY 20000
#define DS1307_DEVICE_TYPE "rtc"
/*
* Driver enrty routines
*/
/*
* tod_ops entry routines
*/
static timestruc_t todds1307_get(void);
static void todds1307_set(timestruc_t);
static uint_t todds1307_clear_watchdog_timer(void);
static void todds1307_set_power_alarm(timestruc_t);
static void todds1307_clear_power_alarm(void);
static int todds1307_setup_prom();
static void todds1307_rele_prom();
/*
* Local functions
*/
static int todds1307_read_rtc(struct rtc_t *);
static int todds1307_write_rtc(struct rtc_t *);
/* Anchor for soft state structure */
static void *ds1307_statep;
static int instance = -1;
static int todds1307_attach_done = 0;
static kmutex_t todds1307_rd_lock;
static ihandle_t todds1307_ihandle = 0;
/* one second time out */
#define I2c_CYCLIC_TIMEOUT 1000000000
static int sync_clock_once = 1;
/*
* For debugging only
*/
/*
* cp_ops structure
*/
static struct cb_ops ds1307_cbops = {
nodev, /* open */
nodev, /* close */
nodev, /* strategy */
nodev, /* print */
nodev, /* dump */
nodev, /* read */
nodev, /* write */
nodev, /* ioctl */
nodev, /* devmap */
nodev, /* mmap */
nodev, /* segmap */
NULL, /* poll */
ddi_prop_op, /* cb_prop_op */
NULL, /* streamtab */
CB_REV, /* rev */
nodev, /* int (*cb_aread)() */
nodev /* int (*cb_awrite)() */
};
/*
* dev_ops structure
*/
static struct dev_ops ds1307_ops = {
DEVO_REV, /* devo_rev */
0, /* refcnt - reference cnt always set to 0 */
todds1307_getinfo, /* getinfo - Maybe requred */
nulldev, /* identify */
nulldev, /* probe */
todds1307_attach, /* attach */
todds1307_detach, /* detach */
nodev, /* reset */
&ds1307_cbops, /* cb_ops - ds1307 does not need this(?) */
};
static struct modldrv todds1307_modldrv = {
&mod_driverops, /* Type of module. This one is a driver */
"tod driver for DS1307 v%I%", /* Name of the module */
&ds1307_ops, /* Pointer to dev_ops */
};
/*
* Module linkage structure
*/
static struct modlinkage todds1307_modlinkage = {
0
};
int
_init(void)
{
int error;
sizeof (ds1307_state_t), 0)) != DDI_SUCCESS) {
return (error);
}
}
(void) todds1307_setup_prom();
/*
* Install the module
*/
return (error);
}
return (0);
}
int
_fini(void)
{
int error = 0;
} else {
}
}
return (error);
}
int
{
}
/*
* cyclical call to get tod.
*/
static void
todds1307_cyclic(void *arg)
{
}
/*
* register ds1307 client device with i2c services, and
* allocate & initialize soft state structure.
*/
static int
{
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (instance != -1) {
return (DDI_FAILURE);
}
/*
* Allocate soft state structure
*/
return (DDI_FAILURE);
}
return (DDI_FAILURE);
}
return (DDI_FAILURE);
}
/* check and initialize the oscillator */
return (DDI_FAILURE);
}
/* Enable oscillator */
!= I2C_SUCCESS) {
i2c_tp);
return (DDI_FAILURE);
}
}
/* Create a cyclic handler to read TOD */
return (DDI_SUCCESS);
}
/*
* Unregister ds1307 client device with i2c services and free
* soft state structure.
*/
/*ARGSUSED*/
static int
{
switch (cmd) {
/*
* Once attached, do not allow detach because the system constantly
* calling todds1307_get() to get the time. If the driver is detached
* and the system try to get the time, the system will have memory
* problem.
*
* ds1307_state_t *statep = NULL;
* case DDI_DETACH:
* if ((statep = ddi_get_soft_state(ds1307_statep,
* instance)) == NULL) {
* return (ENOMEM);
* }
* i2c_client_unregister(statep->ds1307_i2c_hdl);
* ddi_soft_state_free(ds1307_statep, instance);
* return (DDI_SUCCESS);
*/
case DDI_SUSPEND:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
/* *********************** tod_ops entry points ******************** */
/*
* Read the current time from the DS1307 chip and convert to UNIX form.
* Should be called with tod_clock held.
*/
static timestruc_t
todds1307_get(void)
{
if (sync_clock_once) {
sync_clock_once = 0;
} else {
return (hrestime);
}
/*
* 00 - 68 = 2000 thru 2068
* 69-99 = 1969 thru 1999
*/
return (ts);
}
/*
* Program DS1307 with the specified time.
* Must be called with tod_lock held. The TOD
* chip supports date from 1969-2068 only. We must
* reject requests to set date below 2000.
*/
static void
{
int year;
/*
* Year is base 1900, valid year range 1969-2068
*/
return;
if (year >= 100)
year -= 100;
}
/* ARGSUSED */
static void
{
}
/* ARGSUSED */
static void
{
}
/* ARGSUSED */
static uint_t
{
return (0);
}
/* ARGSUSED */
static uint_t
{
return (0);
}
/* ********************** Local functions ***************************** */
static int
{
int i2c_cmd_status = I2C_FAILURE;
int counter = 4;
if (!todds1307_attach_done) {
return (todds1307_prom_getdate(rtc));
}
return (DDI_FAILURE);
}
/*
* Allocate 1 byte for write buffer and 7 bytes for read buffer to
* to accomodate sec, min, hrs, dayOfWeek, dayOfMonth, year
*/
return (DDI_FAILURE);
}
do {
i2c_tp)) != I2C_SUCCESS) {
goto done;
}
/* for first read, need to get valid data */
/* move data to static buffer */
/* now read again */
/* Start reading reg from 0x00 */
i2c_tp)) != I2C_SUCCESS) {
goto done;
}
/* if they are not the same, then read again */
tod_read[0] = -1;
counter--;
}
}
/* if seconds register is 0x59 (BCD), add data should match */
counter-- > 0);
if (counter < 0)
/* move data to static buffer */
done:
return (i2c_cmd_status);
}
static int
{
int i2c_cmd_status = I2C_SUCCESS;
if (!todds1307_attach_done) {
return (todds1307_prom_setdate(rtc));
}
return (DDI_FAILURE);
}
return (i2c_cmd_status);
}
i2c_tp)) != I2C_SUCCESS) {
/* delay(drv_usectohz(I2C_DELAY)); */
return (i2c_cmd_status);
}
return (i2c_cmd_status);
}
/*ARGSUSED*/
static int
void **result)
{
if (instance == -1) {
return (DDI_FAILURE);
}
switch (infocmd) {
case DDI_INFO_DEVT2DEVINFO:
== NULL)
return (DDI_FAILURE);
return (DDI_SUCCESS);
case DDI_INFO_DEVT2INSTANCE:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
}
/*
* Conversion functions
*/
static unsigned char
}
static int
}
/*
* Finds the device node with device_type "rtc" and opens it to
* execute the get-time method
*/
static int
{
char tod1307_devpath[MAXNAMELEN];
DS1307_DEVICE_TYPE)) == OBP_NONODE)
return (DDI_FAILURE);
/*
* We now have the phandle of the rtc node, we need to open the
* node and get the ihandle
*/
sizeof (tod1307_devpath)) < 0) {
return (DDI_FAILURE);
}
/*
* Now open the node and store it's ihandle
*/
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
}
/*
* Closes the prom interface
*/
static void
{
(void) prom_close(todds1307_ihandle);
}
/*
* Read the date using "get-time" method in rtc node
* PROM returns 1969-1999 when reading 69-99 and
* 2000-2068 when reading 00-68
*/
static int
{
int year;
(void) p1275_cif_handler(&ci);
if (year >= 2000)
year -= 2000;
else
year -= 1900;
return (DDI_SUCCESS);
}
/*
* Read the date using "set-time" method in rtc node
* For values 00 - 68, write 2000-2068, and for 69-99,
* write 1969-1999
*/
static int
{
int year;
return (DDI_FAILURE);
if (year <= 68)
else
(void) p1275_cif_handler(&ci);
return (DDI_SUCCESS);
}