target/linux/ixp4xx/patches-2.6.25/010-rtc_isl1208_new_style.patch

   1 ---
   2  drivers/rtc/rtc-isl1208.c |  357 +++++++++++++++++++++-------------------------
   3  1 file changed, 170 insertions(+), 187 deletions(-)
   4
   5 Index: linux-2.6.25.4/drivers/rtc/rtc-isl1208.c
   6 ===================================================================
   7 --- linux-2.6.25.4.orig/drivers/rtc/rtc-isl1208.c
   8 +++ linux-2.6.25.4/drivers/rtc/rtc-isl1208.c
   9 @@ -15,16 +15,15 @@
  10  #include <linux/bcd.h>
  11  #include <linux/rtc.h>
  12
  13 -#define DRV_NAME "isl1208"
  14 -#define DRV_VERSION "0.2"
  15 +#define DRV_VERSION "0.3"
  16
  17  /* Register map */
  18  /* rtc section */
  19  #define ISL1208_REG_SC  0x00
  20  #define ISL1208_REG_MN  0x01
  21  #define ISL1208_REG_HR  0x02
  22 -#define ISL1208_REG_HR_MIL     (1<<7) /* 24h/12h mode */
  23 -#define ISL1208_REG_HR_PM      (1<<5) /* PM/AM bit in 12h mode */
  24 +#define ISL1208_REG_HR_MIL     (1<<7)  /* 24h/12h mode */
  25 +#define ISL1208_REG_HR_PM      (1<<5)  /* PM/AM bit in 12h mode */
  26  #define ISL1208_REG_DT  0x03
  27  #define ISL1208_REG_MO  0x04
  28  #define ISL1208_REG_YR  0x05
  29 @@ -33,14 +32,14 @@
  30
  31  /* control/status section */
  32  #define ISL1208_REG_SR  0x07
  33 -#define ISL1208_REG_SR_ARST    (1<<7) /* auto reset */
  34 -#define ISL1208_REG_SR_XTOSCB  (1<<6) /* crystal oscillator */
  35 -#define ISL1208_REG_SR_WRTC    (1<<4) /* write rtc */
  36 -#define ISL1208_REG_SR_ALM     (1<<2) /* alarm */
  37 -#define ISL1208_REG_SR_BAT     (1<<1) /* battery */
  38 -#define ISL1208_REG_SR_RTCF    (1<<0) /* rtc fail */
  39 +#define ISL1208_REG_SR_ARST    (1<<7)  /* auto reset */
  40 +#define ISL1208_REG_SR_XTOSCB  (1<<6)  /* crystal oscillator */
  41 +#define ISL1208_REG_SR_WRTC    (1<<4)  /* write rtc */
  42 +#define ISL1208_REG_SR_ALM     (1<<2)  /* alarm */
  43 +#define ISL1208_REG_SR_BAT     (1<<1)  /* battery */
  44 +#define ISL1208_REG_SR_RTCF    (1<<0)  /* rtc fail */
  45  #define ISL1208_REG_INT 0x08
  46 -#define ISL1208_REG_09  0x09 /* reserved */
  47 +#define ISL1208_REG_09  0x09   /* reserved */
  48  #define ISL1208_REG_ATR 0x0a
  49  #define ISL1208_REG_DTR 0x0b
  50
  51 @@ -58,39 +57,21 @@
  52  #define ISL1208_REG_USR2 0x13
  53  #define ISL1208_USR_SECTION_LEN 2
  54
  55 -/* i2c configuration */
  56 -#define ISL1208_I2C_ADDR 0xde
  57 -
  58 -static const unsigned short normal_i2c[] = {
  59 -       ISL1208_I2C_ADDR>>1, I2C_CLIENT_END
  60 -};
  61 -I2C_CLIENT_INSMOD; /* defines addr_data */
  62 -
  63 -static int isl1208_attach_adapter(struct i2c_adapter *adapter);
  64 -static int isl1208_detach_client(struct i2c_client *client);
  65 -
  66 -static struct i2c_driver isl1208_driver = {
  67 -       .driver         = {
  68 -               .name   = DRV_NAME,
  69 -       },
  70 -       .id             = I2C_DRIVERID_ISL1208,
  71 -       .attach_adapter = &isl1208_attach_adapter,
  72 -       .detach_client  = &isl1208_detach_client,
  73 -};
  74 +static struct i2c_driver isl1208_driver;
  75
  76  /* block read */
  77  static int
  78  isl1208_i2c_read_regs(struct i2c_client *client, u8 reg, u8 buf[],
  79 -                      unsigned len)
  80 +                     unsigned len)
  81  {
  82         u8 reg_addr[1] = { reg };
  83         struct i2c_msg msgs[2] = {
  84 -               { client->addr, client->flags, sizeof(reg_addr), reg_addr },
  85 -               { client->addr, client->flags | I2C_M_RD, len, buf }
  86 +               {client->addr, client->flags, sizeof(reg_addr), reg_addr}
  87 +               ,
  88 +               {client->addr, client->flags | I2C_M_RD, len, buf}
  89         };
  90         int ret;
  91
  92 -       BUG_ON(len == 0);
  93         BUG_ON(reg > ISL1208_REG_USR2);
  94         BUG_ON(reg + len > ISL1208_REG_USR2 + 1);
  95
  96 @@ -103,15 +84,14 @@ isl1208_i2c_read_regs(struct i2c_client
  97  /* block write */
  98  static int
  99  isl1208_i2c_set_regs(struct i2c_client *client, u8 reg, u8 const buf[],
 100 -                      unsigned len)
 101 +                    unsigned len)
 102  {
 103         u8 i2c_buf[ISL1208_REG_USR2 + 2];
 104         struct i2c_msg msgs[1] = {
 105 -               { client->addr, client->flags, len + 1, i2c_buf }
 106 +               {client->addr, client->flags, len + 1, i2c_buf}
 107         };
 108         int ret;
 109
 110 -       BUG_ON(len == 0);
 111         BUG_ON(reg > ISL1208_REG_USR2);
 112         BUG_ON(reg + len > ISL1208_REG_USR2 + 1);
 113
 114 @@ -125,7 +105,8 @@ isl1208_i2c_set_regs(struct i2c_client *
 115  }
 116
 117  /* simple check to see wether we have a isl1208 */
 118 -static int isl1208_i2c_validate_client(struct i2c_client *client)
 119 +static int
 120 +isl1208_i2c_validate_client(struct i2c_client *client)
 121  {
 122         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 123         u8 zero_mask[ISL1208_RTC_SECTION_LEN] = {
 124 @@ -139,24 +120,29 @@ static int isl1208_i2c_validate_client(s
 125                 return ret;
 126
 127         for (i = 0; i < ISL1208_RTC_SECTION_LEN; ++i) {
 128 -               if (regs[i] & zero_mask[i]) /* check if bits are cleared */
 129 +               if (regs[i] & zero_mask[i])     /* check if bits are cleared */
 130                         return -ENODEV;
 131         }
 132
 133         return 0;
 134  }
 135
 136 -static int isl1208_i2c_get_sr(struct i2c_client *client)
 137 +static int
 138 +isl1208_i2c_get_sr(struct i2c_client *client)
 139  {
 140 -       return i2c_smbus_read_byte_data(client, ISL1208_REG_SR) == -1 ? -EIO:0;
 141 +       int sr = i2c_smbus_read_byte_data(client, ISL1208_REG_SR);
 142 +       if (sr < 0)
 143 +               return -EIO;
 144 +
 145 +       return sr;
 146  }
 147
 148 -static int isl1208_i2c_get_atr(struct i2c_client *client)
 149 +static int
 150 +isl1208_i2c_get_atr(struct i2c_client *client)
 151  {
 152         int atr = i2c_smbus_read_byte_data(client, ISL1208_REG_ATR);
 153 -
 154         if (atr < 0)
 155 -               return -EIO;
 156 +               return atr;
 157
 158         /* The 6bit value in the ATR register controls the load
 159          * capacitance C_load * in steps of 0.25pF
 160 @@ -169,51 +155,54 @@ static int isl1208_i2c_get_atr(struct i2
 161          *
 162          */
 163
 164 -       atr &= 0x3f; /* mask out lsb */
 165 -       atr ^= 1<<5; /* invert 6th bit */
 166 -       atr += 2*9; /* add offset of 4.5pF; unit[atr] = 0.25pF */
 167 +       atr &= 0x3f;            /* mask out lsb */
 168 +       atr ^= 1 << 5;          /* invert 6th bit */
 169 +       atr += 2 * 9;           /* add offset of 4.5pF; unit[atr] = 0.25pF */
 170
 171         return atr;
 172  }
 173
 174 -static int isl1208_i2c_get_dtr(struct i2c_client *client)
 175 +static int
 176 +isl1208_i2c_get_dtr(struct i2c_client *client)
 177  {
 178         int dtr = i2c_smbus_read_byte_data(client, ISL1208_REG_DTR);
 179 -
 180         if (dtr < 0)
 181                 return -EIO;
 182
 183         /* dtr encodes adjustments of {-60,-40,-20,0,20,40,60} ppm */
 184 -       dtr = ((dtr & 0x3) * 20) * (dtr & (1<<2) ? -1 : 1);
 185 +       dtr = ((dtr & 0x3) * 20) * (dtr & (1 << 2) ? -1 : 1);
 186
 187         return dtr;
 188  }
 189
 190 -static int isl1208_i2c_get_usr(struct i2c_client *client)
 191 +static int
 192 +isl1208_i2c_get_usr(struct i2c_client *client)
 193  {
 194         u8 buf[ISL1208_USR_SECTION_LEN] = { 0, };
 195         int ret;
 196
 197 -       ret = isl1208_i2c_read_regs (client, ISL1208_REG_USR1, buf,
 198 -                                  ISL1208_USR_SECTION_LEN);
 199 +       ret = isl1208_i2c_read_regs(client, ISL1208_REG_USR1, buf,
 200 +                                   ISL1208_USR_SECTION_LEN);
 201         if (ret < 0)
 202                 return ret;
 203
 204         return (buf[1] << 8) | buf[0];
 205  }
 206
 207 -static int isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)
 208 +static int
 209 +isl1208_i2c_set_usr(struct i2c_client *client, u16 usr)
 210  {
 211         u8 buf[ISL1208_USR_SECTION_LEN];
 212
 213         buf[0] = usr & 0xff;
 214         buf[1] = (usr >> 8) & 0xff;
 215
 216 -       return isl1208_i2c_set_regs (client, ISL1208_REG_USR1, buf,
 217 -                                    ISL1208_USR_SECTION_LEN);
 218 +       return isl1208_i2c_set_regs(client, ISL1208_REG_USR1, buf,
 219 +                                   ISL1208_USR_SECTION_LEN);
 220  }
 221
 222 -static int isl1208_rtc_proc(struct device *dev, struct seq_file *seq)
 223 +static int
 224 +isl1208_rtc_proc(struct device *dev, struct seq_file *seq)
 225  {
 226         struct i2c_client *const client = to_i2c_client(dev);
 227         int sr, dtr, atr, usr;
 228 @@ -230,20 +219,19 @@ static int isl1208_rtc_proc(struct devic
 229                    (sr & ISL1208_REG_SR_ALM) ? " ALM" : "",
 230                    (sr & ISL1208_REG_SR_WRTC) ? " WRTC" : "",
 231                    (sr & ISL1208_REG_SR_XTOSCB) ? " XTOSCB" : "",
 232 -                  (sr & ISL1208_REG_SR_ARST) ? " ARST" : "",
 233 -                  sr);
 234 +                  (sr & ISL1208_REG_SR_ARST) ? " ARST" : "", sr);
 235
 236         seq_printf(seq, "batt_status\t: %s\n",
 237                    (sr & ISL1208_REG_SR_RTCF) ? "bad" : "okay");
 238
 239         dtr = isl1208_i2c_get_dtr(client);
 240 -       if (dtr >= 0 -1)
 241 +       if (dtr >= 0 - 1)
 242                 seq_printf(seq, "digital_trim\t: %d ppm\n", dtr);
 243
 244         atr = isl1208_i2c_get_atr(client);
 245         if (atr >= 0)
 246                 seq_printf(seq, "analog_trim\t: %d.%.2d pF\n",
 247 -                          atr>>2, (atr&0x3)*25);
 248 +                          atr >> 2, (atr & 0x3) * 25);
 249
 250         usr = isl1208_i2c_get_usr(client);
 251         if (usr >= 0)
 252 @@ -252,9 +240,8 @@ static int isl1208_rtc_proc(struct devic
 253         return 0;
 254  }
 255
 256 -
 257 -static int isl1208_i2c_read_time(struct i2c_client *client,
 258 -                                struct rtc_time *tm)
 259 +static int
 260 +isl1208_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
 261  {
 262         int sr;
 263         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 264 @@ -274,27 +261,30 @@ static int isl1208_i2c_read_time(struct
 265
 266         tm->tm_sec = BCD2BIN(regs[ISL1208_REG_SC]);
 267         tm->tm_min = BCD2BIN(regs[ISL1208_REG_MN]);
 268 -       { /* HR field has a more complex interpretation */
 269 +
 270 +       /* HR field has a more complex interpretation */
 271 +       {
 272                 const u8 _hr = regs[ISL1208_REG_HR];
 273 -               if (_hr & ISL1208_REG_HR_MIL) /* 24h format */
 274 +               if (_hr & ISL1208_REG_HR_MIL)   /* 24h format */
 275                         tm->tm_hour = BCD2BIN(_hr & 0x3f);
 276 -               else { // 12h format
 277 +               else {
 278 +                       /* 12h format */
 279                         tm->tm_hour = BCD2BIN(_hr & 0x1f);
 280 -                       if (_hr & ISL1208_REG_HR_PM) /* PM flag set */
 281 +                       if (_hr & ISL1208_REG_HR_PM)    /* PM flag set */
 282                                 tm->tm_hour += 12;
 283                 }
 284         }
 285
 286         tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DT]);
 287 -       tm->tm_mon = BCD2BIN(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */
 288 +       tm->tm_mon = BCD2BIN(regs[ISL1208_REG_MO]) - 1; /* rtc starts at 1 */
 289         tm->tm_year = BCD2BIN(regs[ISL1208_REG_YR]) + 100;
 290         tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DW]);
 291
 292         return 0;
 293  }
 294
 295 -static int isl1208_i2c_read_alarm(struct i2c_client *client,
 296 -                                 struct rtc_wkalrm *alarm)
 297 +static int
 298 +isl1208_i2c_read_alarm(struct i2c_client *client, struct rtc_wkalrm *alarm)
 299  {
 300         struct rtc_time *const tm = &alarm->time;
 301         u8 regs[ISL1208_ALARM_SECTION_LEN] = { 0, };
 302 @@ -307,7 +297,7 @@ static int isl1208_i2c_read_alarm(struct
 303         }
 304
 305         sr = isl1208_i2c_read_regs(client, ISL1208_REG_SCA, regs,
 306 -                                 ISL1208_ALARM_SECTION_LEN);
 307 +                                  ISL1208_ALARM_SECTION_LEN);
 308         if (sr < 0) {
 309                 dev_err(&client->dev, "%s: reading alarm section failed\n",
 310                         __func__);
 311 @@ -315,23 +305,25 @@ static int isl1208_i2c_read_alarm(struct
 312         }
 313
 314         /* MSB of each alarm register is an enable bit */
 315 -       tm->tm_sec  = BCD2BIN(regs[ISL1208_REG_SCA-ISL1208_REG_SCA] & 0x7f);
 316 -       tm->tm_min  = BCD2BIN(regs[ISL1208_REG_MNA-ISL1208_REG_SCA] & 0x7f);
 317 -       tm->tm_hour = BCD2BIN(regs[ISL1208_REG_HRA-ISL1208_REG_SCA] & 0x3f);
 318 -       tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DTA-ISL1208_REG_SCA] & 0x3f);
 319 -       tm->tm_mon  = BCD2BIN(regs[ISL1208_REG_MOA-ISL1208_REG_SCA] & 0x1f)-1;
 320 -       tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DWA-ISL1208_REG_SCA] & 0x03);
 321 +       tm->tm_sec = BCD2BIN(regs[ISL1208_REG_SCA - ISL1208_REG_SCA] & 0x7f);
 322 +       tm->tm_min = BCD2BIN(regs[ISL1208_REG_MNA - ISL1208_REG_SCA] & 0x7f);
 323 +       tm->tm_hour = BCD2BIN(regs[ISL1208_REG_HRA - ISL1208_REG_SCA] & 0x3f);
 324 +       tm->tm_mday = BCD2BIN(regs[ISL1208_REG_DTA - ISL1208_REG_SCA] & 0x3f);
 325 +       tm->tm_mon =
 326 +               BCD2BIN(regs[ISL1208_REG_MOA - ISL1208_REG_SCA] & 0x1f) - 1;
 327 +       tm->tm_wday = BCD2BIN(regs[ISL1208_REG_DWA - ISL1208_REG_SCA] & 0x03);
 328
 329         return 0;
 330  }
 331
 332 -static int isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)
 333 +static int
 334 +isl1208_rtc_read_time(struct device *dev, struct rtc_time *tm)
 335  {
 336         return isl1208_i2c_read_time(to_i2c_client(dev), tm);
 337  }
 338
 339 -static int isl1208_i2c_set_time(struct i2c_client *client,
 340 -                               struct rtc_time const *tm)
 341 +static int
 342 +isl1208_i2c_set_time(struct i2c_client *client, struct rtc_time const *tm)
 343  {
 344         int sr;
 345         u8 regs[ISL1208_RTC_SECTION_LEN] = { 0, };
 346 @@ -353,7 +345,7 @@ static int isl1208_i2c_set_time(struct i
 347         }
 348
 349         /* set WRTC */
 350 -       sr = i2c_smbus_write_byte_data (client, ISL1208_REG_SR,
 351 +       sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 352                                        sr | ISL1208_REG_SR_WRTC);
 353         if (sr < 0) {
 354                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 355 @@ -369,7 +361,7 @@ static int isl1208_i2c_set_time(struct i
 356         }
 357
 358         /* clear WRTC again */
 359 -       sr = i2c_smbus_write_byte_data (client, ISL1208_REG_SR,
 360 +       sr = i2c_smbus_write_byte_data(client, ISL1208_REG_SR,
 361                                        sr & ~ISL1208_REG_SR_WRTC);
 362         if (sr < 0) {
 363                 dev_err(&client->dev, "%s: writing SR failed\n", __func__);
 364 @@ -380,70 +372,69 @@ static int isl1208_i2c_set_time(struct i
 365  }
 366
 367
 368 -static int isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)
 369 +static int
 370 +isl1208_rtc_set_time(struct device *dev, struct rtc_time *tm)
 371  {
 372         return isl1208_i2c_set_time(to_i2c_client(dev), tm);
 373  }
 374
 375 -static int isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 376 +static int
 377 +isl1208_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
 378  {
 379         return isl1208_i2c_read_alarm(to_i2c_client(dev), alarm);
 380  }
 381
 382  static const struct rtc_class_ops isl1208_rtc_ops = {
 383 -       .proc           = isl1208_rtc_proc,
 384 -       .read_time      = isl1208_rtc_read_time,
 385 -       .set_time       = isl1208_rtc_set_time,
 386 -       .read_alarm     = isl1208_rtc_read_alarm,
 387 -       //.set_alarm    = isl1208_rtc_set_alarm,
 388 +       .proc = isl1208_rtc_proc,
 389 +       .read_time = isl1208_rtc_read_time,
 390 +       .set_time = isl1208_rtc_set_time,
 391 +       .read_alarm = isl1208_rtc_read_alarm,
 392 +       /*.set_alarm    = isl1208_rtc_set_alarm, */
 393  };
 394
 395  /* sysfs interface */
 396
 397 -static ssize_t isl1208_sysfs_show_atrim(struct device *dev,
 398 -                                       struct device_attribute *attr,
 399 -                                       char *buf)
 400 +static ssize_t
 401 +isl1208_sysfs_show_atrim(struct device *dev,
 402 +                        struct device_attribute *attr, char *buf)
 403  {
 404 -       int atr;
 405 -
 406 -       atr = isl1208_i2c_get_atr(to_i2c_client(dev));
 407 +       int atr = isl1208_i2c_get_atr(to_i2c_client(dev));
 408         if (atr < 0)
 409                 return atr;
 410
 411 -       return sprintf(buf, "%d.%.2d pF\n", atr>>2, (atr&0x3)*25);
 412 +       return sprintf(buf, "%d.%.2d pF\n", atr >> 2, (atr & 0x3) * 25);
 413  }
 414 +
 415  static DEVICE_ATTR(atrim, S_IRUGO, isl1208_sysfs_show_atrim, NULL);
 416
 417 -static ssize_t isl1208_sysfs_show_dtrim(struct device *dev,
 418 -                                       struct device_attribute *attr,
 419 -                                       char *buf)
 420 +static ssize_t
 421 +isl1208_sysfs_show_dtrim(struct device *dev,
 422 +                        struct device_attribute *attr, char *buf)
 423  {
 424 -       int dtr;
 425 -
 426 -       dtr = isl1208_i2c_get_dtr(to_i2c_client(dev));
 427 +       int dtr = isl1208_i2c_get_dtr(to_i2c_client(dev));
 428         if (dtr < 0)
 429                 return dtr;
 430
 431         return sprintf(buf, "%d ppm\n", dtr);
 432  }
 433 +
 434  static DEVICE_ATTR(dtrim, S_IRUGO, isl1208_sysfs_show_dtrim, NULL);
 435
 436 -static ssize_t isl1208_sysfs_show_usr(struct device *dev,
 437 -                                      struct device_attribute *attr,
 438 -                                      char *buf)
 439 +static ssize_t
 440 +isl1208_sysfs_show_usr(struct device *dev,
 441 +                      struct device_attribute *attr, char *buf)
 442  {
 443 -       int usr;
 444 -
 445 -       usr = isl1208_i2c_get_usr(to_i2c_client(dev));
 446 +       int usr = isl1208_i2c_get_usr(to_i2c_client(dev));
 447         if (usr < 0)
 448                 return usr;
 449
 450         return sprintf(buf, "0x%.4x\n", usr);
 451  }
 452
 453 -static ssize_t isl1208_sysfs_store_usr(struct device *dev,
 454 -                                      struct device_attribute *attr,
 455 -                                      const char *buf, size_t count)
 456 +static ssize_t
 457 +isl1208_sysfs_store_usr(struct device *dev,
 458 +                       struct device_attribute *attr,
 459 +                       const char *buf, size_t count)
 460  {
 461         int usr = -1;
 462
 463 @@ -460,124 +451,116 @@ static ssize_t isl1208_sysfs_store_usr(s
 464
 465         return isl1208_i2c_set_usr(to_i2c_client(dev), usr) ? -EIO : count;
 466  }
 467 +
 468  static DEVICE_ATTR(usr, S_IRUGO | S_IWUSR, isl1208_sysfs_show_usr,
 469                    isl1208_sysfs_store_usr);
 470
 471  static int
 472 -isl1208_probe(struct i2c_adapter *adapter, int addr, int kind)
 473 +isl1208_sysfs_register(struct device *dev)
 474  {
 475 -       int rc = 0;
 476 -       struct i2c_client *new_client = NULL;
 477 -       struct rtc_device *rtc = NULL;
 478 +       int err;
 479 +
 480 +       err = device_create_file(dev, &dev_attr_atrim);
 481 +       if (err)
 482 +               return err;
 483
 484 -       if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {
 485 -               rc = -ENODEV;
 486 -               goto failout;
 487 +       err = device_create_file(dev, &dev_attr_dtrim);
 488 +       if (err) {
 489 +               device_remove_file(dev, &dev_attr_atrim);
 490 +               return err;
 491         }
 492
 493 -       new_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 494 -       if (new_client == NULL) {
 495 -               rc = -ENOMEM;
 496 -               goto failout;
 497 +       err = device_create_file(dev, &dev_attr_usr);
 498 +       if (err) {
 499 +               device_remove_file(dev, &dev_attr_atrim);
 500 +               device_remove_file(dev, &dev_attr_dtrim);
 501         }
 502
 503 -       new_client->addr = addr;
 504 -       new_client->adapter = adapter;
 505 -       new_client->driver = &isl1208_driver;
 506 -       new_client->flags = 0;
 507 -       strcpy(new_client->name, DRV_NAME);
 508 +       return 0;
 509 +}
 510
 511 -       if (kind < 0) {
 512 -               rc = isl1208_i2c_validate_client(new_client);
 513 -               if (rc < 0)
 514 -                       goto failout;
 515 -       }
 516 +static int
 517 +isl1208_sysfs_unregister(struct device *dev)
 518 +{
 519 +       device_remove_file(dev, &dev_attr_atrim);
 520 +       device_remove_file(dev, &dev_attr_atrim);
 521 +       device_remove_file(dev, &dev_attr_usr);
 522 +
 523 +       return 0;
 524 +}
 525 +
 526 +static int
 527 +isl1208_probe(struct i2c_client *client)
 528 +{
 529 +       int rc = 0;
 530 +       struct rtc_device *rtc;
 531
 532 -       rc = i2c_attach_client(new_client);
 533 -       if (rc < 0)
 534 -               goto failout;
 535 +       if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
 536 +               return -ENODEV;
 537
 538 -       dev_info(&new_client->dev,
 539 +       if (isl1208_i2c_validate_client(client) < 0)
 540 +               return -ENODEV;
 541 +
 542 +       dev_info(&client->dev,
 543                  "chip found, driver version " DRV_VERSION "\n");
 544
 545         rtc = rtc_device_register(isl1208_driver.driver.name,
 546 -                                 &new_client->dev,
 547 -                                 &isl1208_rtc_ops, THIS_MODULE);
 548 -
 549 -       if (IS_ERR(rtc)) {
 550 -               rc = PTR_ERR(rtc);
 551 -               goto failout_detach;
 552 -       }
 553 +                                 &client->dev, &isl1208_rtc_ops,
 554 +                                 THIS_MODULE);
 555 +       if (IS_ERR(rtc))
 556 +               return PTR_ERR(rtc);
 557
 558 -       i2c_set_clientdata(new_client, rtc);
 559 +       i2c_set_clientdata(client, rtc);
 560
 561 -       rc = isl1208_i2c_get_sr(new_client);
 562 +       rc = isl1208_i2c_get_sr(client);
 563         if (rc < 0) {
 564 -               dev_err(&new_client->dev, "reading status failed\n");
 565 -               goto failout_unregister;
 566 +               dev_err(&client->dev, "reading status failed\n");
 567 +               goto exit_unregister;
 568         }
 569
 570         if (rc & ISL1208_REG_SR_RTCF)
 571 -               dev_warn(&new_client->dev, "rtc power failure detected, "
 572 +               dev_warn(&client->dev, "rtc power failure detected, "
 573                          "please set clock.\n");
 574
 575 -       rc = device_create_file(&new_client->dev, &dev_attr_atrim);
 576 -       if (rc < 0)
 577 -               goto failout_unregister;
 578 -       rc = device_create_file(&new_client->dev, &dev_attr_dtrim);
 579 -       if (rc < 0)
 580 -               goto failout_atrim;
 581 -       rc = device_create_file(&new_client->dev, &dev_attr_usr);
 582 -       if (rc < 0)
 583 -               goto failout_dtrim;
 584 +       rc = isl1208_sysfs_register(&client->dev);
 585 +       if (rc)
 586 +               goto exit_unregister;
 587
 588         return 0;
 589
 590 - failout_dtrim:
 591 -       device_remove_file(&new_client->dev, &dev_attr_dtrim);
 592 - failout_atrim:
 593 -       device_remove_file(&new_client->dev, &dev_attr_atrim);
 594 - failout_unregister:
 595 +      exit_unregister:
 596         rtc_device_unregister(rtc);
 597 - failout_detach:
 598 -       i2c_detach_client(new_client);
 599 - failout:
 600 -       kfree(new_client);
 601 -       return rc;
 602 -}
 603
 604 -static int
 605 -isl1208_attach_adapter (struct i2c_adapter *adapter)
 606 -{
 607 -       return i2c_probe(adapter, &addr_data, isl1208_probe);
 608 +       return rc;
 609  }
 610
 611  static int
 612 -isl1208_detach_client(struct i2c_client *client)
 613 +isl1208_remove(struct i2c_client *client)
 614  {
 615 -       int rc;
 616 -       struct rtc_device *const rtc = i2c_get_clientdata(client);
 617 -
 618 -       if (rtc)
 619 -               rtc_device_unregister(rtc); /* do we need to kfree? */
 620 -
 621 -       rc = i2c_detach_client(client);
 622 -       if (rc)
 623 -               return rc;
 624 +       struct rtc_device *rtc = i2c_get_clientdata(client);
 625
 626 -       kfree(client);
 627 +       isl1208_sysfs_unregister(&client->dev);
 628 +       rtc_device_unregister(rtc);
 629
 630         return 0;
 631  }
 632
 633 -/* module management */
 634 +static struct i2c_driver isl1208_driver = {
 635 +       .driver = {
 636 +                  .name = "rtc-isl1208",
 637 +                  },
 638 +       .probe = isl1208_probe,
 639 +       .remove = isl1208_remove,
 640 +};
 641
 642 -static int __init isl1208_init(void)
 643 +static int __init
 644 +isl1208_init(void)
 645  {
 646         return i2c_add_driver(&isl1208_driver);
 647  }
 648
 649 -static void __exit isl1208_exit(void)
 650 +static void __exit
 651 +isl1208_exit(void)
 652  {
 653         i2c_del_driver(&isl1208_driver);
 654  }