From 73ec7248a6afa80e2db3c4560ae86d85464a71c8 Mon Sep 17 00:00:00 2001 From: Rod Whitby Date: Tue, 23 Jan 2007 05:01:14 +0000 Subject: nslu2-kernel: Moved to obsolete - replaced long ago by ixp4xx-kernel. --- .../nslu2-kernel/2.6.14-mm/30-i2c-x1205-mm1.patch | 1036 ++++++++++++++++++++ 1 file changed, 1036 insertions(+) create mode 100644 packages/obsolete/nslu2/nslu2-kernel/2.6.14-mm/30-i2c-x1205-mm1.patch (limited to 'packages/obsolete/nslu2/nslu2-kernel/2.6.14-mm/30-i2c-x1205-mm1.patch') diff --git a/packages/obsolete/nslu2/nslu2-kernel/2.6.14-mm/30-i2c-x1205-mm1.patch b/packages/obsolete/nslu2/nslu2-kernel/2.6.14-mm/30-i2c-x1205-mm1.patch new file mode 100644 index 0000000000..67cbd4cdf4 --- /dev/null +++ b/packages/obsolete/nslu2/nslu2-kernel/2.6.14-mm/30-i2c-x1205-mm1.patch @@ -0,0 +1,1036 @@ +--- linux-2.6.14/drivers/i2c/chips/Kconfig.orig 2005-11-07 22:30:30.413306237 -0800 ++++ linux-2.6.14/drivers/i2c/chips/Kconfig 2005-11-07 22:41:15.785916976 -0800 +@@ -126,13 +126,13 @@ config SENSORS_MAX6875 + This driver can also be built as a module. If so, the module + will be called max6875. + +-config RTC_X1205_I2C +- tristate "Xicor X1205 RTC chip" +- depends on I2C && EXPERIMENTAL +- help +- If you say yes here you get support for the Xicor X1205 RTC chip. ++config SENSORS_X1205 ++ tristate "Xicor X1205 RTC chip" ++ depends on I2C ++ help ++ If you say yes here you get support for the Xicor X1205 RTC chip. + +- This driver can also be built as a module. If so, the module +- will be called x1205. ++ This driver can also be built as a module. If so, the module ++ will be called x1205 + + endmenu +--- linux-2.6.14/drivers/i2c/chips/Makefile.orig 2005-11-07 22:30:30.417306489 -0800 ++++ linux-2.6.14/drivers/i2c/chips/Makefile 2005-11-07 22:41:59.616675071 -0800 +@@ -13,7 +13,7 @@ obj-$(CONFIG_SENSORS_PCF8591) += pcf8591 + obj-$(CONFIG_SENSORS_RTC8564) += rtc8564.o + obj-$(CONFIG_ISP1301_OMAP) += isp1301_omap.o + obj-$(CONFIG_TPS65010) += tps65010.o +-obj-$(CONFIG_RTC_X1205_I2C) += x1205.o ++obj-$(CONFIG_SENSORS_X1205) += x1205.o + + ifeq ($(CONFIG_I2C_DEBUG_CHIP),y) + EXTRA_CFLAGS += -DDEBUG +--- linux-2.6.14/drivers/i2c/chips/x1205.c.orig 2005-11-07 22:30:30.421306741 -0800 ++++ linux-2.6.14/drivers/i2c/chips/x1205.c 2005-11-07 22:42:54.960157617 -0800 +@@ -1,14 +1,16 @@ + /* +- * x1205.c - An i2c driver for the Xicor X1205 RTC ++ * linux/drivers/i2c/chips/x1205.c ++ * ++ * x1205.c - An 12c driver for the Xicor X1205 RTC + * Copyright 2004 Karen Spearel + * Copyright 2005 Alessandro Zummo + * + * please send all reports to: + * kas11 at tampabay dot rr dot com + * a dot zummo at towertech dot it +- * ++ * + * based on the other drivers in this same directory. +- * ++ * + * 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 +@@ -26,83 +28,36 @@ + + #include + +-#define DRV_VERSION "0.9.9" ++#define EPOCH_1900 1900 ++#define EPOCH_1970 1970 ++ ++#define DRIVER_VERSION "0.9.6" ++#define DRIVER_NAME (x1205_driver.name) + +-/* Addresses to scan: none. This chip is located at +- * 0x6f and uses a two bytes register addressing. +- * Two bytes need to be written to read a single register, +- * while most other chips just require one and take the second +- * one as the data to be written. To prevent corrupting +- * unknown chips, the user must explicitely set the probe parameter. +- */ + +-static unsigned short normal_i2c[] = { I2C_CLIENT_END }; ++/* Addresses to scan */ ++static unsigned short normal_i2c[] = { X1205_I2C_BUS_ADDR, I2C_CLIENT_END }; + + /* Insmod parameters */ + I2C_CLIENT_INSMOD; + I2C_CLIENT_MODULE_PARM(hctosys, + "Set the system time from the hardware clock upon initialization"); + +-/* offsets into CCR area */ +- +-#define CCR_SEC 0 +-#define CCR_MIN 1 +-#define CCR_HOUR 2 +-#define CCR_MDAY 3 +-#define CCR_MONTH 4 +-#define CCR_YEAR 5 +-#define CCR_WDAY 6 +-#define CCR_Y2K 7 +- +-#define X1205_REG_SR 0x3F /* status register */ +-#define X1205_REG_Y2K 0x37 +-#define X1205_REG_DW 0x36 +-#define X1205_REG_YR 0x35 +-#define X1205_REG_MO 0x34 +-#define X1205_REG_DT 0x33 +-#define X1205_REG_HR 0x32 +-#define X1205_REG_MN 0x31 +-#define X1205_REG_SC 0x30 +-#define X1205_REG_DTR 0x13 +-#define X1205_REG_ATR 0x12 +-#define X1205_REG_INT 0x11 +-#define X1205_REG_0 0x10 +-#define X1205_REG_Y2K1 0x0F +-#define X1205_REG_DWA1 0x0E +-#define X1205_REG_YRA1 0x0D +-#define X1205_REG_MOA1 0x0C +-#define X1205_REG_DTA1 0x0B +-#define X1205_REG_HRA1 0x0A +-#define X1205_REG_MNA1 0x09 +-#define X1205_REG_SCA1 0x08 +-#define X1205_REG_Y2K0 0x07 +-#define X1205_REG_DWA0 0x06 +-#define X1205_REG_YRA0 0x05 +-#define X1205_REG_MOA0 0x04 +-#define X1205_REG_DTA0 0x03 +-#define X1205_REG_HRA0 0x02 +-#define X1205_REG_MNA0 0x01 +-#define X1205_REG_SCA0 0x00 +- +-#define X1205_CCR_BASE 0x30 /* Base address of CCR */ +-#define X1205_ALM0_BASE 0x00 /* Base address of ALARM0 */ +- +-#define X1205_SR_RTCF 0x01 /* Clock failure */ +-#define X1205_SR_WEL 0x02 /* Write Enable Latch */ +-#define X1205_SR_RWEL 0x04 /* Register Write Enable */ +- +-#define X1205_DTR_DTR0 0x01 +-#define X1205_DTR_DTR1 0x02 +-#define X1205_DTR_DTR2 0x04 +- +-#define X1205_HR_MIL 0x80 /* Set in ccr.hour for 24 hr mode */ +- + /* Prototypes */ ++ + static int x1205_attach(struct i2c_adapter *adapter); + static int x1205_detach(struct i2c_client *client); + static int x1205_probe(struct i2c_adapter *adapter, int address, int kind); +-static int x1205_command(struct i2c_client *client, unsigned int cmd, +- void *arg); ++static int x1205_validate_client(struct i2c_client *client); ++ ++static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm, ++ u8 reg_base); ++static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm, ++ int datetoo, u8 reg_base); ++static int x1205_validate_tm(struct rtc_time *tm); ++static int x1205_command(struct i2c_client *client, unsigned int cmd, void *arg); ++static int x1205_hctosys(struct i2c_client *client); ++ + + static struct i2c_driver x1205_driver = { + .owner = THIS_MODULE, +@@ -110,6 +65,7 @@ static struct i2c_driver x1205_driver = + .flags = I2C_DF_NOTIFY, + .attach_adapter = &x1205_attach, + .detach_client = &x1205_detach, ++/* .command = &x1205_command,*/ + }; + + struct x1205_data { +@@ -118,8 +74,9 @@ struct x1205_data { + unsigned int epoch; + }; + +-static const unsigned char days_in_mo[] = +- { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; ++ ++static const unsigned char days_in_mo[] = ++{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; + + static LIST_HEAD(x1205_clients); + +@@ -127,6 +84,7 @@ static LIST_HEAD(x1205_clients); + * commands to a specific client. This function will send the command + * to the first client. + */ ++ + int x1205_do_command(unsigned int cmd, void *arg) + { + struct list_head *walk; +@@ -141,114 +99,98 @@ int x1205_do_command(unsigned int cmd, v + return -ENODEV; + } + +-#define is_leap(year) \ +- ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0)) +- +-/* make sure the rtc_time values are in bounds */ +-static int x1205_validate_tm(struct rtc_time *tm) +-{ +- int year = tm->tm_year + 1900; +- +- if ((tm->tm_year < 70) || (tm->tm_year > 255)) +- return -EINVAL; +- +- if ((tm->tm_mon > 11) || (tm->tm_mday == 0)) +- return -EINVAL; +- +- if (tm->tm_mday > days_in_mo[tm->tm_mon] +- + ((tm->tm_mon == 1) && is_leap(year))) +- return -EINVAL; +- +- if ((tm->tm_hour >= 24) || (tm->tm_min >= 60) || (tm->tm_sec >= 60)) +- return -EINVAL; +- +- return 0; +-} + + /* +- * In the routines that deal directly with the x1205 hardware, we use ++ * in the routines that deal directly with the x1205 hardware, we use + * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch +- * Epoch is initialized as 2000. Time is set to UTC. ++ * Epoch is inited as 2000. Time is set to UT + */ ++ + static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm, + u8 reg_base) + { +- unsigned char dt_addr[2] = { 0, reg_base }; +- static unsigned char sr_addr[2] = { 0, X1205_REG_SR }; ++ static unsigned char dt_addr[] = { 0, }; ++ static unsigned char sr_addr[] = { 0, }; + +- unsigned char buf[8], sr; ++ unsigned char buf[8], sr; + + struct i2c_msg msgs[] = { +- { client->addr, 0, 2, sr_addr }, /* setup read ptr */ +- { client->addr, I2C_M_RD, 1, &sr }, /* read status */ +- { client->addr, 0, 2, dt_addr }, /* setup read ptr */ +- { client->addr, I2C_M_RD, 8, buf }, /* read date */ ++ { client->addr, 0, 2, sr_addr }, /* random read */ ++ { client->addr, I2C_M_RD, 1, &sr }, ++ { client->addr, 0, 2, dt_addr }, /* random read */ ++ { client->addr, I2C_M_RD, 8, buf }, + }; + +- struct x1205_data *data = i2c_get_clientdata(client); ++ struct x1205_data *xdata = i2c_get_clientdata(client); + +- /* read status register */ +- if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) { +- dev_err(&client->dev, "%s: read error\n", __FUNCTION__); +- return -EIO; +- } ++ dt_addr[1] = reg_base; ++ sr_addr[1] = X1205_REG_SR; + +- /* check for battery failure */ +- if (sr & X1205_SR_RTCF) { +- dev_warn(&client->dev, +- "Clock had a power failure, you must set the date.\n"); +- return -EINVAL; +- } ++ if ((i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs))) == ++ ARRAY_SIZE(msgs)) { ++ /* did we read the correct number of messages? */ ++ ++ /* check for battery failure */ ++ if (sr & X1205_SR_RTCF) ++ { ++ dev_info(&client->adapter->dev, ++ "%s: Clock had a power failure, you must set the date.\n", ++ DRIVER_NAME); + +- /* read date registers */ +- if ((i2c_transfer(client->adapter, &msgs[2], 2)) != 2) { +- dev_err(&client->dev, "%s: read error\n", __FUNCTION__); +- return -EIO; +- } +- +- dev_dbg(&client->dev, +- "%s: raw read data - sec=%02x, min=%02x, hr=%02x, " +- "mday=%02x, mon=%02x, year=%02x, wday=%02x, y2k=%02x\n", +- __FUNCTION__, +- buf[0], buf[1], buf[2], buf[3], +- buf[4], buf[5], buf[6], buf[7]); +- +- tm->tm_sec = BCD2BIN(buf[CCR_SEC]); +- tm->tm_min = BCD2BIN(buf[CCR_MIN]); +- tm->tm_hour = BCD2BIN(buf[CCR_HOUR] & 0x3F); /* hr is 0-23 */ +- tm->tm_mday = BCD2BIN(buf[CCR_MDAY]); +- tm->tm_mon = BCD2BIN(buf[CCR_MONTH]); +- data->epoch = BCD2BIN(buf[CCR_Y2K]) * 100; +- tm->tm_year = BCD2BIN(buf[CCR_YEAR]) + data->epoch - 1900; +- tm->tm_wday = buf[CCR_WDAY]; ++ return -EINVAL; ++ } + +- dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, " +- "mday=%d, mon=%d, year=%d, wday=%d\n", +- __FUNCTION__, +- tm->tm_sec, tm->tm_min, tm->tm_hour, +- tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); ++ dev_dbg(&client->dev, ++ "%s: raw read data - sec-%02x min-%02x hr-%02x" ++ " mday-%02x mon-%02x year-%02x wday-%02x y2k-%02x\n", ++ __FUNCTION__, ++ buf[0], buf[1], buf[2], buf[3], ++ buf[4], buf[5], buf[6], buf[7]); ++ ++ tm->tm_sec = BCD2BIN(buf[CCR_SEC]); ++ tm->tm_min = BCD2BIN(buf[CCR_MIN]); ++ buf[CCR_HOUR] &= ~X1205_HR_MIL; ++ tm->tm_hour = BCD2BIN(buf[CCR_HOUR]); /* hr is 0-23 */ ++ tm->tm_mday = BCD2BIN(buf[CCR_MDAY]); ++ tm->tm_mon = BCD2BIN(buf[CCR_MONTH]); ++ xdata->epoch = BCD2BIN(buf[CCR_Y2K]) * 100; ++ tm->tm_year = BCD2BIN(buf[CCR_YEAR]) + xdata->epoch - EPOCH_1900; ++ tm->tm_wday = buf[CCR_WDAY]; ++ ++ dev_dbg(&client->dev, "%s: tm is secs=%d, mins=%d, hours=%d, " ++ "mday=%d, mon=%d, year=%d, wday=%d\n", ++ __FUNCTION__, ++ tm->tm_sec, tm->tm_min, tm->tm_hour, ++ tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); + ++ } else { ++ dev_dbg(&client->dev, "%s: read error\n", __FUNCTION__); ++ return -EIO; ++ } ++ + return 0; + } + ++ + static int x1205_set_datetime(struct i2c_client *client, struct rtc_time *tm, + int datetoo, u8 reg_base) + { + int i, err, xfer; + +- unsigned char buf[8]; ++ static unsigned char wel[3] = { 0, X1205_REG_SR, ++ X1205_SR_WEL }; + +- static const unsigned char wel[3] = { 0, X1205_REG_SR, +- X1205_SR_WEL }; + +- static const unsigned char rwel[3] = { 0, X1205_REG_SR, +- X1205_SR_WEL | X1205_SR_RWEL }; ++ static unsigned char rwel[3] = { 0, X1205_REG_SR, ++ X1205_SR_WEL | X1205_SR_RWEL }; + +- static const unsigned char diswe[3] = { 0, X1205_REG_SR, 0 }; ++ static unsigned char diswe[3] = { 0, X1205_REG_SR, 0 }; + +- struct x1205_data *data = i2c_get_clientdata(client); ++ static unsigned char data[3] = { 0, }; ++ static unsigned char buf[8]; ++ ++ struct x1205_data *xdata = i2c_get_clientdata(client); + +- /* check if all values in the tm struct are correct */ + if ((err = x1205_validate_tm(tm)) < 0) + return err; + +@@ -258,124 +200,52 @@ static int x1205_set_datetime(struct i2c + tm->tm_sec, tm->tm_min, tm->tm_hour, + tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday); + +- buf[CCR_SEC] = BIN2BCD(tm->tm_sec); +- buf[CCR_MIN] = BIN2BCD(tm->tm_min); + +- /* set hour and 24hr bit */ ++ buf[CCR_SEC] = BIN2BCD(tm->tm_sec); ++ buf[CCR_MIN] = BIN2BCD(tm->tm_min); ++ ++ /* Set 24HR format */ + buf[CCR_HOUR] = BIN2BCD(tm->tm_hour) | X1205_HR_MIL; + +- /* should we also set the date? */ +- if (datetoo) { +- buf[CCR_MDAY] = BIN2BCD(tm->tm_mday); ++ if (datetoo == X1205_DATETOO) { ++ buf[CCR_MDAY] = BIN2BCD(tm->tm_mday); + + /* month, 0 - 11 */ +- buf[CCR_MONTH] = BIN2BCD(tm->tm_mon); ++ buf[CCR_MONTH] = BIN2BCD(tm->tm_mon); /* input is 0-11 */ + + /* year, since 1900 */ +- buf[CCR_YEAR] = BIN2BCD(tm->tm_year + 1900 - data->epoch); +- buf[CCR_WDAY] = tm->tm_wday & 0x07; +- buf[CCR_Y2K] = BIN2BCD(data->epoch / 100); ++ buf[CCR_YEAR] = BIN2BCD((tm->tm_year + EPOCH_1900 - xdata->epoch)); ++ buf[CCR_WDAY] = tm->tm_wday & 7; ++ buf[CCR_Y2K] = BIN2BCD(xdata->epoch / 100); + } + +- /* this sequence is required to unlock the chip */ + xfer = i2c_master_send(client, wel, 3); +- if (xfer != 3) { +- dev_err(&client->dev, "%s: wel - %d\n", __FUNCTION__, xfer); ++ dev_dbg(&client->dev, "%s: wen - %x\n", __FUNCTION__, xfer); ++ if (xfer != 3) + return -EIO; +- } + + xfer = i2c_master_send(client, rwel, 3); +- if (xfer != 3) { +- dev_err(&client->dev, "%s: rwel - %d\n", __FUNCTION__, xfer); ++ dev_dbg(&client->dev, "%s: wenb - %x\n", __FUNCTION__, xfer); ++ if (xfer != 3) + return -EIO; +- } + +- /* write register's data */ +- for (i = 0; i < (datetoo ? 8 : 3); i++) { +- unsigned char rdata[3] = { 0, reg_base + i, buf[i] }; +- +- xfer = i2c_master_send(client, rdata, 3); +- if (xfer != 3) { +- dev_err(&client->dev, +- "%s: xfer=%d addr=%02x, data=%02x\n", +- __FUNCTION__, +- xfer, rdata[1], rdata[2]); ++ for (i = 0; i < 8; i++) { ++ data[1] = i + reg_base; ++ data[2] = buf[i]; ++ xfer = i2c_master_send(client, data, 3); ++ ++ dev_dbg(&client->dev, "%s: xfer %d addr, %02x, data %02x\n", ++ __FUNCTION__, ++ xfer, data[1], data[2]); ++ ++ if (xfer != 3) + return -EIO; +- } + }; + +- /* disable further writes */ + xfer = i2c_master_send(client, diswe, 3); +- if (xfer != 3) { +- dev_err(&client->dev, "%s: diswe - %d\n", __FUNCTION__, xfer); +- return -EIO; +- } +- +- return 0; +-} +- +-static int x1205_get_dtrim(struct i2c_client *client, int *trim) +-{ +- unsigned char dtr; +- static unsigned char dtr_addr[2] = { 0, X1205_REG_DTR }; +- +- struct i2c_msg msgs[] = { +- { client->addr, 0, 2, dtr_addr }, /* setup read ptr */ +- { client->addr, I2C_M_RD, 1, &dtr }, /* read dtr */ +- }; +- +- /* read dtr register */ +- if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) { +- dev_err(&client->dev, "%s: read error\n", __FUNCTION__); +- return -EIO; +- } +- +- dev_dbg(&client->dev, "%s: raw dtr=%x\n", __FUNCTION__, dtr); +- +- *trim = 0; +- +- if (dtr & X1205_DTR_DTR0) +- *trim += 20; +- +- if (dtr & X1205_DTR_DTR1) +- *trim += 10; +- +- if (dtr & X1205_DTR_DTR2) +- *trim = -*trim; +- +- return 0; +-} +- +-static int x1205_get_atrim(struct i2c_client *client, int *trim) +-{ +- s8 atr; +- static unsigned char atr_addr[2] = { 0, X1205_REG_ATR }; +- +- struct i2c_msg msgs[] = { +- { client->addr, 0, 2, atr_addr }, /* setup read ptr */ +- { client->addr, I2C_M_RD, 1, &atr }, /* read atr */ +- }; +- +- /* read atr register */ +- if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) { +- dev_err(&client->dev, "%s: read error\n", __FUNCTION__); +- return -EIO; +- } +- +- dev_dbg(&client->dev, "%s: raw atr=%x\n", __FUNCTION__, atr); +- +- /* atr is a two's complement value on 6 bits, +- * perform sign extension. The formula is +- * Catr = (atr * 0.25pF) + 11.00pF. +- */ +- if (atr & 0x20) +- atr |= 0xC0; +- +- dev_dbg(&client->dev, "%s: raw atr=%x (%d)\n", __FUNCTION__, atr, atr); +- +- *trim = (atr * 250) + 11000; +- +- dev_dbg(&client->dev, "%s: real=%d\n", __FUNCTION__, *trim); ++ dev_dbg(&client->dev, "%s: wdis - %x\n", __FUNCTION__, xfer); ++ if (xfer != 3) ++ return -EIO; + + return 0; + } +@@ -386,24 +256,28 @@ static int x1205_hctosys(struct i2c_clie + + struct rtc_time tm; + struct timespec tv; ++ + + err = x1205_command(client, X1205_CMD_GETDATETIME, &tm); + +- if (err) { +- dev_err(&client->dev, +- "Unable to set the system clock\n"); ++ if (err) ++ { ++ dev_info(&client->adapter->dev, ++ "%s: Unable to set the system clock\n", ++ DRIVER_NAME); ++ + return err; ++ + } + +- /* IMPORTANT: the RTC only stores whole seconds. It is arbitrary +- * whether it stores the most close value or the value with partial +- * seconds truncated. However, it is important that we use it to store +- * the truncated value. This is because otherwise it is necessary, +- * in an rtc sync function, to read both xtime.tv_sec and +- * xtime.tv_nsec. On some processors (i.e. ARM), an atomic read +- * of >32bits is not possible. So storing the most close value would +- * slow down the sync API. So here we have the truncated value and +- * the best guess is to add 0.5s. ++ /* IMPORTANT: the RTC only stores whole seconds. It is arbitrary whether ++ * it stores the most close value or the value with partial seconds ++ * truncated, however it is important for x1205_sync_rtc that it be ++ * defined to store the truncated value. This is because otherwise it ++ * is necessary to read both xtime.tv_sec and xtime.tv_nsec in the ++ * sync function, and atomic reads of >32bits on ARM are not possible. ++ * So storing the most close value would slow down the sync API. So ++ * Here we have the truncated value and the best guess is to add 0.5s + */ + + tv.tv_nsec = NSEC_PER_SEC >> 1; +@@ -413,15 +287,16 @@ static int x1205_hctosys(struct i2c_clie + * the month to be in the range 1-12 + */ + +- tv.tv_sec = mktime(tm.tm_year + 1900, tm.tm_mon + 1, ++ tv.tv_sec = mktime(tm.tm_year + EPOCH_1900, tm.tm_mon + 1, + tm.tm_mday, tm.tm_hour, + tm.tm_min, tm.tm_sec); + + do_settimeofday(&tv); + +- dev_info(&client->dev, +- "setting the system clock to %d-%d-%d %d:%d:%d\n", +- tm.tm_year + 1900, tm.tm_mon + 1, ++ dev_info(&client->adapter->dev, ++ "%s: Setting the system clock to %d-%d-%d %d:%d:%d\n", ++ DRIVER_NAME, ++ tm.tm_year + EPOCH_1900, tm.tm_mon + 1, + tm.tm_mday, tm.tm_hour, tm.tm_min, + tm.tm_sec); + +@@ -432,7 +307,7 @@ struct x1205_limit + { + unsigned char reg; + unsigned char mask; +- unsigned char min; ++ unsigned char min; + unsigned char max; + }; + +@@ -443,16 +318,34 @@ static int x1205_validate_client(struct + /* Probe array. We will read the register at the specified + * address and check if the given bits are zero. + */ +- static const unsigned char probe_zero_pattern[] = { +- /* register, mask */ ++ ++ const unsigned char probe_zero_pattern[] = { ++ + X1205_REG_SR, 0x18, ++ X1205_REG_Y2K, 0xC6, ++ X1205_REG_DW, 0xF8, ++ X1205_REG_MO, 0xE0, ++ X1205_REG_DT, 0xC0, ++ X1205_REG_HR, 0x40, ++ X1205_REG_MN, 0x80, ++ X1205_REG_SC, 0x80, + X1205_REG_DTR, 0xF8, + X1205_REG_ATR, 0xC0, + X1205_REG_INT, 0x18, + X1205_REG_0, 0xFF, ++ X1205_REG_Y2K1, 0xC6, ++ X1205_REG_DWA1, 0x78, ++ X1205_REG_MOA1, 0x60, ++ X1205_REG_DTA1, 0x40, ++ X1205_REG_HRA1, 0x40, ++ X1205_REG_Y2K0, 0xC6, ++ X1205_REG_DWA0, 0x78, ++ X1205_REG_MOA0, 0x60, ++ X1205_REG_DTA0, 0x40, ++ X1205_REG_HRA0, 0x40, + }; + +- static const struct x1205_limit probe_limits_pattern[] = { ++ const struct x1205_limit probe_limits_pattern[] = { + /* register, mask, min, max */ + { X1205_REG_Y2K, 0xFF, 19, 20 }, + { X1205_REG_DW, 0xFF, 0, 6 }, +@@ -463,23 +356,41 @@ static int x1205_validate_client(struct + { X1205_REG_MN, 0xFF, 0, 59 }, + { X1205_REG_SC, 0xFF, 0, 59 }, + { X1205_REG_Y2K1, 0xFF, 19, 20 }, ++ { X1205_REG_DWA1, 0x7F, 0, 6 }, ++ { X1205_REG_MOA1, 0x7F, 0, 12 }, ++ { X1205_REG_DTA1, 0x7F, 0, 31 }, ++ { X1205_REG_HRA1, 0x7F, 0, 23 }, ++ { X1205_REG_MNA1, 0x7F, 0, 59 }, ++ { X1205_REG_SCA1, 0x7F, 0, 59 }, + { X1205_REG_Y2K0, 0xFF, 19, 20 }, ++ { X1205_REG_DWA0, 0x7F, 0, 6 }, ++ { X1205_REG_MOA0, 0x7F, 0, 12 }, ++ { X1205_REG_DTA0, 0x7F, 0, 31 }, ++ { X1205_REG_HRA0, 0x7F, 0, 23 }, ++ { X1205_REG_MNA0, 0x7F, 0, 59 }, ++ { X1205_REG_SCA0, 0x7F, 0, 59 }, + }; + + /* check that registers have bits a 0 where expected */ +- for (i = 0; i < ARRAY_SIZE(probe_zero_pattern); i += 2) { ++ ++ for (i = 0; i < ARRAY_SIZE(probe_zero_pattern); i += 2) ++ { + unsigned char buf; + +- unsigned char addr[2] = { 0, probe_zero_pattern[i] }; ++ static unsigned char addr[2]; + + struct i2c_msg msgs[2] = { +- { client->addr, 0, 2, addr }, ++ { client->addr, 0, 2, addr }, /* random read */ + { client->addr, I2C_M_RD, 1, &buf }, + }; + ++ addr[0] = 0x00; ++ addr[1] = probe_zero_pattern[i]; ++ + xfer = i2c_transfer(client->adapter, msgs, 2); ++ + if (xfer != 2) { +- dev_err(&client->adapter->dev, ++ dev_dbg(&client->adapter->dev, + "%s: could not read register %x\n", + __FUNCTION__, addr[1]); + +@@ -487,42 +398,47 @@ static int x1205_validate_client(struct + } + + if ((buf & probe_zero_pattern[i+1]) != 0) { +- dev_err(&client->adapter->dev, +- "%s: register=%02x, zero pattern=%d, value=%x\n", ++ dev_dbg(&client->adapter->dev, ++ "%s: register %x, zero pattern %d: %x\n", + __FUNCTION__, addr[1], i, buf); + + return -ENODEV; + } + } + +- /* check limits (only registers with bcd values) */ +- for (i = 0; i < ARRAY_SIZE(probe_limits_pattern); i++) { +- unsigned char reg, value; ++ /* check limits */ + +- unsigned char addr[2] = { 0, probe_limits_pattern[i].reg }; ++ for (i = 0; i < ARRAY_SIZE(probe_limits_pattern); i++) ++ { ++ unsigned char buf, val; ++ ++ static unsigned char addr[2]; + + struct i2c_msg msgs[2] = { +- { client->addr, 0, 2, addr }, +- { client->addr, I2C_M_RD, 1, ® }, ++ { client->addr, 0, 2, addr }, /* random read */ ++ { client->addr, I2C_M_RD, 1, &buf }, + }; + ++ addr[0] = 0x00; ++ addr[1] = probe_limits_pattern[i].reg; ++ + xfer = i2c_transfer(client->adapter, msgs, 2); + + if (xfer != 2) { +- dev_err(&client->adapter->dev, ++ dev_dbg(&client->adapter->dev, + "%s: could not read register %x\n", + __FUNCTION__, addr[1]); + + return -EIO; + } + +- value = BCD2BIN(reg & probe_limits_pattern[i].mask); ++ val = BCD2BIN(buf & probe_limits_pattern[i].mask); + +- if (value > probe_limits_pattern[i].max || +- value < probe_limits_pattern[i].min) { ++ if (val > probe_limits_pattern[i].max || ++ val < probe_limits_pattern[i].min) { + dev_dbg(&client->adapter->dev, +- "%s: register=%x, lim pattern=%d, value=%d\n", +- __FUNCTION__, addr[1], i, value); ++ "%s: register %x, lim pattern %d: %d\n", ++ __FUNCTION__, addr[1], i, val); + + return -ENODEV; + } +@@ -538,79 +454,66 @@ static int x1205_attach(struct i2c_adapt + return i2c_probe(adapter, &addr_data, x1205_probe); + } + +-int x1205_direct_attach(int adapter_id, +- struct i2c_client_address_data *address_data) +-{ +- int err; +- struct i2c_adapter *adapter = i2c_get_adapter(adapter_id); +- +- if (adapter) { +- err = i2c_probe(adapter, +- address_data, x1205_probe); +- +- i2c_put_adapter(adapter); +- +- return err; +- } +- +- return -ENODEV; +-} +- + static int x1205_probe(struct i2c_adapter *adapter, int address, int kind) + { +- struct i2c_client *client; +- struct x1205_data *data; ++ struct i2c_client *new_client; ++ struct x1205_data *xdata; + + int err = 0; + + dev_dbg(&adapter->dev, "%s\n", __FUNCTION__); + +- if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) { +- err = -ENODEV; +- goto exit; +- } +- +- if (!(data = kzalloc(sizeof(struct x1205_data), GFP_KERNEL))) { ++ if (!(xdata = kmalloc(sizeof(struct x1205_data), GFP_KERNEL))) { + err = -ENOMEM; + goto exit; + } + +- /* Initialize our structures */ +- data->epoch = 2000; ++ /* Fill our data structure */ + +- client = &data->client; +- client->addr = address; +- client->driver = &x1205_driver; +- client->adapter = adapter; ++ memset(xdata, 0, sizeof(struct x1205_data)); + +- strlcpy(client->name, "x1205", I2C_NAME_SIZE); ++ xdata->epoch = 2000; ++ ++ ++ /* Prepare i2c_client structure */ ++ ++ new_client = &xdata->client; ++ i2c_set_clientdata(new_client, xdata); ++ new_client->addr = address; ++ new_client->adapter = adapter; ++ new_client->driver = &x1205_driver; ++ new_client->flags = 0; ++ ++ strlcpy(new_client->name, "x1205", I2C_NAME_SIZE); + +- i2c_set_clientdata(client, data); + + /* Verify the chip is really an X1205 */ +- if (kind < 0) { +- if (x1205_validate_client(client) < 0) { ++ ++ if (kind < 0) ++ { ++ if (x1205_validate_client(new_client) < 0) { + err = -ENODEV; + goto exit_kfree; + } + } + + /* Inform the i2c layer */ +- if ((err = i2c_attach_client(client))) ++ if ((err = i2c_attach_client(new_client))) + goto exit_kfree; + +- list_add(&data->list, &x1205_clients); ++ list_add(&xdata->list, &x1205_clients); + +- dev_info(&client->dev, "chip found, driver version " DRV_VERSION "\n"); ++ dev_info(&adapter->dev, "%s: Chip found, driver " DRIVER_VERSION "\n", ++ DRIVER_NAME); + +- /* If requested, set the system time */ ++ /* If requested, se the system time */ + if (hctosys) +- x1205_hctosys(client); ++ x1205_hctosys(new_client); + + return 0; + + exit_kfree: +- kfree(data); ++ kfree(xdata); + + exit: + return err; +@@ -620,23 +523,44 @@ static int x1205_detach(struct i2c_clien + { + int err; + struct x1205_data *data = i2c_get_clientdata(client); +- ++ + dev_dbg(&client->dev, "%s\n", __FUNCTION__); + + if ((err = i2c_detach_client(client))) + return err; + + list_del(&data->list); +- + kfree(data); ++ return 0; ++} ++ ++/* make sure the rtc_time values are in bounds */ ++static int x1205_validate_tm(struct rtc_time *tm) ++{ ++ tm->tm_year += 1900; ++ ++ if (tm->tm_year < EPOCH_1970) ++ return -EINVAL; ++ ++ if ((tm->tm_mon > 11) || (tm->tm_mday == 0)) ++ return -EINVAL; ++ ++ if (tm->tm_mday > (days_in_mo[tm->tm_mon] + ( (tm->tm_mon == 1) && ++ ((!(tm->tm_year % 4) && (tm->tm_year % 100) ) || !(tm->tm_year % 400))))) ++ return -EINVAL; ++ ++ if ((tm->tm_year -= EPOCH_1900) > 255) ++ return -EINVAL; ++ ++ if ((tm->tm_hour >= 24) || (tm->tm_min >= 60) || (tm->tm_sec >= 60)) ++ return -EINVAL; + + return 0; + } + +-static int x1205_command(struct i2c_client *client, unsigned int cmd, +- void *param) ++static int x1205_command(struct i2c_client *client, unsigned int cmd, void *tm) + { +- if (param == NULL) ++ if (client == NULL || tm == NULL) + return -EINVAL; + + if (!capable(CAP_SYS_TIME)) +@@ -646,34 +570,26 @@ static int x1205_command(struct i2c_clie + + switch (cmd) { + case X1205_CMD_GETDATETIME: +- return x1205_get_datetime(client, param, X1205_CCR_BASE); ++ return x1205_get_datetime(client, tm, X1205_CCR_BASE); + + case X1205_CMD_SETTIME: +- return x1205_set_datetime(client, param, 0, +- X1205_CCR_BASE); ++ return x1205_set_datetime(client, tm, X1205_NODATE, X1205_CCR_BASE); + + case X1205_CMD_SETDATETIME: +- return x1205_set_datetime(client, param, 1, +- X1205_CCR_BASE); ++ return x1205_set_datetime(client, tm, X1205_DATETOO, X1205_CCR_BASE); + + case X1205_CMD_GETALARM: +- return x1205_get_datetime(client, param, X1205_ALM0_BASE); ++ return x1205_get_datetime(client, tm, X1205_ALM0_BASE); + + case X1205_CMD_SETALARM: +- return x1205_set_datetime(client, param, 1, +- X1205_ALM0_BASE); +- +- case X1205_CMD_GETDTRIM: +- return x1205_get_dtrim(client, param); +- +- case X1205_CMD_GETATRIM: +- return x1205_get_atrim(client, param); ++ return x1205_set_datetime(client, tm, X1205_DATETOO, X1205_ALM0_BASE); + + default: + return -EINVAL; + } + } + ++ + static int __init x1205_init(void) + { + return i2c_add_driver(&x1205_driver); +@@ -689,10 +605,8 @@ MODULE_AUTHOR( + "Alessandro Zummo "); + MODULE_DESCRIPTION("Xicor X1205 RTC driver"); + MODULE_LICENSE("GPL"); +-MODULE_VERSION(DRV_VERSION); + + EXPORT_SYMBOL_GPL(x1205_do_command); +-EXPORT_SYMBOL_GPL(x1205_direct_attach); + + module_init(x1205_init); + module_exit(x1205_exit); +--- linux-2.6.14/include/linux/x1205.h.orig 2005-11-07 22:38:42.196252187 -0800 ++++ linux-2.6.14/include/linux/x1205.h 2005-11-07 22:42:54.960157617 -0800 +@@ -1,31 +1,67 @@ +-/* +- * x1205.h - defines for drivers/i2c/chips/x1205.c +- * Copyright 2004 Karen Spearel +- * Copyright 2005 Alessandro Zummo +- * +- * 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. +- */ +- +-#ifndef __LINUX_X1205_H__ +-#define __LINUX_X1205_H__ + + /* commands */ + +-#define X1205_CMD_GETDATETIME 0 +-#define X1205_CMD_SETTIME 1 +-#define X1205_CMD_SETDATETIME 2 ++#define X1205_CMD_GETDATETIME 0 ++#define X1205_CMD_SETTIME 1 ++#define X1205_CMD_SETDATETIME 2 + #define X1205_CMD_GETALARM 3 + #define X1205_CMD_SETALARM 4 +-#define X1205_CMD_GETDTRIM 5 +-#define X1205_CMD_SETDTRIM 6 +-#define X1205_CMD_GETATRIM 7 +-#define X1205_CMD_SETATRIM 8 ++ ++/* flags */ ++ ++#define X1205_NODATE 0 ++#define X1205_DATETOO 1 ++ ++/* offsets into read buf - add 2 for write buf */ ++ ++#define CCR_SEC 0 ++#define CCR_MIN 1 ++#define CCR_HOUR 2 ++#define CCR_MDAY 3 ++#define CCR_MONTH 4 ++#define CCR_YEAR 5 ++#define CCR_WDAY 6 ++#define CCR_Y2K 7 ++ ++#define X1205_REG_SR 0x3F /* status register */ ++#define X1205_REG_Y2K 0x37 ++#define X1205_REG_DW 0x36 ++#define X1205_REG_YR 0x35 ++#define X1205_REG_MO 0x34 ++#define X1205_REG_DT 0x33 ++#define X1205_REG_HR 0x32 ++#define X1205_REG_MN 0x31 ++#define X1205_REG_SC 0x30 ++#define X1205_REG_DTR 0x13 ++#define X1205_REG_ATR 0x12 ++#define X1205_REG_INT 0x11 ++#define X1205_REG_0 0x10 ++#define X1205_REG_Y2K1 0x0F ++#define X1205_REG_DWA1 0x0E ++#define X1205_REG_YRA1 0x0D ++#define X1205_REG_MOA1 0x0C ++#define X1205_REG_DTA1 0x0B ++#define X1205_REG_HRA1 0x0A ++#define X1205_REG_MNA1 0x09 ++#define X1205_REG_SCA1 0x08 ++#define X1205_REG_Y2K0 0x07 ++#define X1205_REG_DWA0 0x06 ++#define X1205_REG_YRA0 0x05 ++#define X1205_REG_MOA0 0x04 ++#define X1205_REG_DTA0 0x03 ++#define X1205_REG_HRA0 0x02 ++#define X1205_REG_MNA0 0x01 ++#define X1205_REG_SCA0 0x00 ++ ++#define X1205_I2C_BUS_ADDR 0x6f /* hardwired into x1205 */ ++#define X1205_CCR_BASE 0x30 /* Base address of CCR */ ++#define X1205_ALM0_BASE 0x00 /* Base address of ALARM0 */ ++ ++#define X1205_SR_RTCF 0x01 ++#define X1205_SR_WEL 0x02 /* Write Enable Latch bit */ ++#define X1205_SR_RWEL 0x04 /* Register Write Enable Bit */ ++ ++#define X1205_HR_MIL 0x80 /* set in ccr.hour for 24 hr mode */ + + extern int x1205_do_command(unsigned int cmd, void *arg); +-extern int x1205_direct_attach(int adapter_id, +- struct i2c_client_address_data *address_data); + +-#endif /* __LINUX_X1205_H__ */ -- cgit v1.2.3