drivers/mfd/wm831x-spi-a22.c

   1 /*
   2  * wm831x-spi.c  --  SPI access for Wolfson WM831x PMICs
   3  *
   4  * Copyright 2009,2010 Wolfson Microelectronics PLC.
   5  *
   6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   7  *
   8  *  This program is free software; you can redistribute  it and/or modify it
   9  *  under  the terms of  the GNU General  Public License as published by the
  10  *  Free Software Foundation;  either version 2 of the  License, or (at your
  11  *  option) any later version.
  12  *
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/spi/spi.h>
  18 #include <linux/gpio.h>
  19 #include <linux/input.h>
  20 #include <linux/platform_device.h>
  21
  22 #include <linux/mfd/wm831x/core.h>
  23 #include <linux/mfd/wm831x/pdata.h>
  24 #include <linux/mfd/wm831x/irq.h>
  25 #include <linux/mfd/wm831x/auxadc.h>
  26 #include <linux/mfd/wm831x/otp.h>
  27 #include <linux/mfd/wm831x/regulator.h>
  28 #include <linux/mfd/wm831x/pmu.h>
  29
  30
  31
  32 /* DC-DC*/
  33 #define WM831X_BUCKV_MAX_SELECTOR 0x68
  34 #define WM831X_BUCKP_MAX_SELECTOR 0x66
  35
  36 #define WM831X_DCDC_MODE_FAST    0
  37 #define WM831X_DCDC_MODE_NORMAL  1
  38 #define WM831X_DCDC_MODE_IDLE    2
  39 #define WM831X_DCDC_MODE_STANDBY 3
  40
  41 //#define WM831X_DCDC_MAX_NAME 6
  42
  43 /* Register offsets in control block */
  44 #define WM831X_DCDC_CONTROL_1     0
  45 #define WM831X_DCDC_CONTROL_2     1
  46 #define WM831X_DCDC_ON_CONFIG     2
  47 #define WM831X_DCDC_SLEEP_CONTROL 3
  48 #define WM831X_DCDC_DVS_CONTROL   4
  49
  50 /* LDO*/
  51 #define WM831X_LDO_CONTROL       0
  52 #define WM831X_LDO_ON_CONTROL    1
  53 #define WM831X_LDO_SLEEP_CONTROL 2
  54
  55 #define WM831X_ALIVE_LDO_ON_CONTROL    0
  56 #define WM831X_ALIVE_LDO_SLEEP_CONTROL 1
  57
  58 static int wm831x_spi_read_device(struct wm831x *wm831x, unsigned short reg,
  59                                   int bytes, void *dest)
  60 {
  61         u16 tx_val;
  62         u16 *d = dest;
  63         int r, ret;
  64
  65         /* Go register at a time */
  66         for (r = reg; r < reg + (bytes / 2); r++) {
  67                 tx_val = cpu_to_be16(r | 0x8000);
  68
  69                 ret = spi_write_then_read(wm831x->control_data,
  70                                           (u8 *)&tx_val, 2, (u8 *)d, 2);
  71                 if (ret != 0)
  72                         return ret;
  73
  74                 //*d = be16_to_cpu(*d);
  75
  76                 d++;
  77         }
  78
  79         return 0;
  80 }
  81
  82 static int wm831x_spi_write_device(struct wm831x *wm831x, unsigned short reg,
  83                                    int bytes, void *src)
  84 {
  85         struct spi_device *spi = wm831x->control_data;
  86         u16 *s = src;
  87         u16 data[2];
  88         int ret, r;
  89
  90         /* Go register at a time */
  91         for (r = reg; r < reg + (bytes / 2); r++) {
  92                 data[0] = cpu_to_be16(r);
  93                 data[1] = *s++;
  94                 //printk("%s:reg=0x%x,data=0x%x\n",__FUNCTION__,be16_to_cpu(data[0]),be16_to_cpu(data[1]));
  95                 ret = spi_write(spi, (char *)&data, sizeof(data));
  96                 if (ret != 0)
  97                         return ret;
  98         }
  99
 100         return 0;
 101 }
 102
 103
 104 int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL + 1] = {
 105         2,
 106         2,
 107         3,
 108         3,
 109         4,
 110         5,
 111         6,
 112         7,
 113         8,
 114         10,
 115         11,
 116         13,
 117         16,
 118         19,
 119         23,
 120         27,
 121         32,
 122         38,
 123         45,
 124         54,
 125         64,
 126         76,
 127         91,
 128         108,
 129         128,
 130         152,
 131         181,
 132         215,
 133         256,
 134         304,
 135         362,
 136         431,
 137         512,
 138         609,
 139         724,
 140         861,
 141         1024,
 142         1218,
 143         1448,
 144         1722,
 145         2048,
 146         2435,
 147         2896,
 148         3444,
 149         4096,
 150         4871,
 151         5793,
 152         6889,
 153         8192,
 154         9742,
 155         11585,
 156         13777,
 157         16384,
 158         19484,
 159         23170,
 160         27554,
 161 };
 162 EXPORT_SYMBOL_GPL(wm831x_isinkv_values);
 163
 164 static int wm831x_reg_locked(struct wm831x *wm831x, unsigned short reg)
 165 {
 166         if (!wm831x->locked)
 167                 return 0;
 168
 169         switch (reg) {
 170         case WM831X_WATCHDOG:
 171         case WM831X_DC4_CONTROL:
 172         case WM831X_ON_PIN_CONTROL:
 173         case WM831X_BACKUP_CHARGER_CONTROL:
 174         case WM831X_CHARGER_CONTROL_1:
 175         case WM831X_CHARGER_CONTROL_2:
 176                 return 1;
 177
 178         default:
 179                 return 0;
 180         }
 181 }
 182
 183 /**
 184  * wm831x_reg_unlock: Unlock user keyed registers
 185  *
 186  * The WM831x has a user key preventing writes to particularly
 187  * critical registers.  This function locks those registers,
 188  * allowing writes to them.
 189  */
 190 void wm831x_reg_lock(struct wm831x *wm831x)
 191 {
 192         int ret;
 193
 194         ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0);
 195         if (ret == 0) {
 196                 dev_vdbg(wm831x->dev, "Registers locked\n");
 197
 198                 mutex_lock(&wm831x->io_lock);
 199                 WARN_ON(wm831x->locked);
 200                 wm831x->locked = 1;
 201                 mutex_unlock(&wm831x->io_lock);
 202         } else {
 203                 dev_err(wm831x->dev, "Failed to lock registers: %d\n", ret);
 204         }
 205
 206 }
 207 EXPORT_SYMBOL_GPL(wm831x_reg_lock);
 208
 209 /**
 210  * wm831x_reg_unlock: Unlock user keyed registers
 211  *
 212  * The WM831x has a user key preventing writes to particularly
 213  * critical registers.  This function locks those registers,
 214  * preventing spurious writes.
 215  */
 216 int wm831x_reg_unlock(struct wm831x *wm831x)
 217 {
 218         int ret;
 219
 220         /* 0x9716 is the value required to unlock the registers */
 221         ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0x9716);
 222         if (ret == 0) {
 223                 dev_vdbg(wm831x->dev, "Registers unlocked\n");
 224
 225                 mutex_lock(&wm831x->io_lock);
 226                 WARN_ON(!wm831x->locked);
 227                 wm831x->locked = 0;
 228                 mutex_unlock(&wm831x->io_lock);
 229         }
 230
 231         return ret;
 232 }
 233 EXPORT_SYMBOL_GPL(wm831x_reg_unlock);
 234
 235 static int wm831x_read(struct wm831x *wm831x, unsigned short reg,
 236                        int bytes, void *dest)
 237 {
 238         int ret, i;
 239         u16 *buf = dest;
 240
 241         BUG_ON(bytes % 2);
 242         BUG_ON(bytes <= 0);
 243
 244         ret = wm831x->read_dev(wm831x, reg, bytes, dest);
 245         if (ret < 0)
 246                 return ret;
 247
 248         for (i = 0; i < bytes / 2; i++) {
 249                 buf[i] = be16_to_cpu(buf[i]);
 250
 251                 dev_vdbg(wm831x->dev, "Read %04x from R%d(0x%x)\n",
 252                          buf[i], reg + i, reg + i);
 253         }
 254
 255         return 0;
 256 }
 257
 258 /**
 259  * wm831x_reg_read: Read a single WM831x register.
 260  *
 261  * @wm831x: Device to read from.
 262  * @reg: Register to read.
 263  */
 264 int wm831x_reg_read(struct wm831x *wm831x, unsigned short reg)
 265 {
 266         unsigned short val;
 267         int ret;
 268
 269         mutex_lock(&wm831x->io_lock);
 270
 271         ret = wm831x_read(wm831x, reg, 2, &val);
 272
 273         mutex_unlock(&wm831x->io_lock);
 274
 275         if (ret < 0)
 276                 return ret;
 277         else
 278                 return val;
 279 }
 280 EXPORT_SYMBOL_GPL(wm831x_reg_read);
 281
 282 /**
 283  * wm831x_bulk_read: Read multiple WM831x registers
 284  *
 285  * @wm831x: Device to read from
 286  * @reg: First register
 287  * @count: Number of registers
 288  * @buf: Buffer to fill.
 289  */
 290 int wm831x_bulk_read(struct wm831x *wm831x, unsigned short reg,
 291                      int count, u16 *buf)
 292 {
 293         int ret;
 294
 295         mutex_lock(&wm831x->io_lock);
 296
 297         ret = wm831x_read(wm831x, reg, count * 2, buf);
 298
 299         mutex_unlock(&wm831x->io_lock);
 300
 301         return ret;
 302 }
 303 EXPORT_SYMBOL_GPL(wm831x_bulk_read);
 304
 305 static int wm831x_write(struct wm831x *wm831x, unsigned short reg,
 306                         int bytes, void *src)
 307 {
 308         u16 *buf = src;
 309         int i;
 310
 311         BUG_ON(bytes % 2);
 312         BUG_ON(bytes <= 0);
 313
 314         for (i = 0; i < bytes / 2; i++) {
 315                 if (wm831x_reg_locked(wm831x, reg))
 316                         return -EPERM;
 317
 318                 dev_vdbg(wm831x->dev, "Write %04x to R%d(0x%x)\n",
 319                          buf[i], reg + i, reg + i);
 320
 321                 buf[i] = cpu_to_be16(buf[i]);
 322         }
 323
 324         return wm831x->write_dev(wm831x, reg, bytes, src);
 325 }
 326
 327 /**
 328  * wm831x_reg_write: Write a single WM831x register.
 329  *
 330  * @wm831x: Device to write to.
 331  * @reg: Register to write to.
 332  * @val: Value to write.
 333  */
 334 int wm831x_reg_write(struct wm831x *wm831x, unsigned short reg,
 335                      unsigned short val)
 336 {
 337         int ret;
 338
 339         mutex_lock(&wm831x->io_lock);
 340
 341         ret = wm831x_write(wm831x, reg, 2, &val);
 342
 343         mutex_unlock(&wm831x->io_lock);
 344
 345         return ret;
 346 }
 347 EXPORT_SYMBOL_GPL(wm831x_reg_write);
 348
 349
 350 static int wm831x_init(struct wm831x *wm831x)
 351 {
 352
 353 /*wm831x_pre_init*/
 354         wm831x_reg_write(wm831x, WM831X_POWER_STATE, 0x8804);   //900ma
 355
 356 /*wm831x_irq_init:irq=252,180 mask irq*/
 357         wm831x_reg_write(wm831x, 0x4019, 0xffff);
 358         wm831x_reg_write(wm831x, 0x401a, 0xffff);
 359         wm831x_reg_write(wm831x, 0x401b, 0xffff);
 360         wm831x_reg_write(wm831x, 0x401c, 0xffff);
 361         wm831x_reg_write(wm831x, 0x401d, 0xffff);
 362         wm831x_reg_write(wm831x, 0x4018, 0xffff);//wm831x_reg_write(wm831x, 0x4018, 0x0);
 363         wm831x_reg_write(wm831x, 0x4019, 0xffff);
 364
 365 /*regulator: DCDC1: 600 <--> 1800 mV */
 366         //wm831x_reg_write(wm831x, 0x401c, 0xfffe);
 367         //wm831x_reg_write(wm831x, 0x401c, 0xfefe);
 368
 369 /*regulator: DCDC2: 600 <--> 1800 mV*/
 370         //wm831x_reg_write(wm831x, 0x401c, 0xfefc);
 371         //wm831x_reg_write(wm831x, 0x401c, 0xfcfc);
 372
 373 /* regulator: DCDC3: 850 <--> 3400 mV */
 374         //wm831x_reg_write(wm831x, 0x401c, 0xfcf8);
 375
 376 /*regulator: DCDC4: 0 <--> 30000 mV */
 377         //wm831x_reg_write(wm831x, 0x401c, 0xfcf0);
 378
 379 /*wm831x_isink_enable*/
 380         wm831x_reg_write(wm831x, 0x404e, 0x8500);
 381         wm831x_reg_write(wm831x, 0x404e, 0xc500);
 382
 383 /*wm831x_isink_probe:line=203,irq=220*/
 384         //wm831x_reg_write(wm831x, 0x401a, 0xffbf);
 385         //wm831x_reg_write(wm831x, 0x401a, 0xff3f);
 386
 387
 388 /*regulator: LDO1: 900 <--> 3300 mV */
 389         //wm831x_reg_write(wm831x, 0x401b, 0xfffe);
 390
 391 /*regulator: LDO2: 900 <--> 3300 mV*/
 392         //wm831x_reg_write(wm831x, 0x401b, 0xfffc);
 393
 394 /*regulator: LDO3: 900 <--> 3300 mV */
 395         //wm831x_reg_write(wm831x, 0x401b, 0xfff8);
 396
 397 /*regulator: LDO4: 900 <--> 3300 mV */
 398         //wm831x_reg_write(wm831x, 0x401b, 0xfff0);
 399
 400 /* regulator: LDO5: 900 <--> 3300 mV */
 401         //wm831x_reg_write(wm831x, 0x401b, 0xffe0);
 402
 403 /*regulator: LDO6: 900 <--> 3300 mV */
 404         //wm831x_reg_write(wm831x, 0x401b, 0xffc0);
 405
 406 /*regulator: LDO7: 1000 <--> 3500 mV */
 407         //wm831x_reg_write(wm831x, 0x401b, 0xff80);
 408
 409 /*regulator: LDO8: 1000 <--> 3500 mV */
 410         //wm831x_reg_write(wm831x, 0x401b, 0xff00);
 411
 412 /*regulator: LDO9: 1000 <--> 3500 mV */
 413         //wm831x_reg_write(wm831x, 0x401b, 0xfe00);
 414
 415 /*regulator: LDO10: 1000 <--> 3500 mV */
 416         //wm831x_reg_write(wm831x, 0x401b, 0xfc00);
 417
 418 /*regulator: LDO11: 1200 <--> 1550 mV */
 419         wm831x_reg_write(wm831x, 0x4008, 0x9716);
 420         wm831x_reg_write(wm831x, 0x4006, 0x8463);
 421
 422 /*wm831x_post_init set dcdc3=3000000mV end*/
 423         wm831x_reg_write(wm831x, 0x4051, 0xfa49);
 424         wm831x_reg_write(wm831x, 0x4062, 0x2156);
 425
 426
 427 /*wm831x_post_init set ldo10=3000000mV end*/
 428         wm831x_reg_write(wm831x, 0x4084, 0x201a);
 429
 430 /*wm831x_post_init set dcdc2=1300000mV end8*/
 431         wm831x_reg_write(wm831x, 0x405d, 0x4140);
 432
 433 /* wm831x_post_init set dcdc1=1800000mV end*/
 434         wm831x_reg_write(wm831x, 0x4058, 0x6168);
 435
 436 /*wm831x_post_init set ldo1=1800000mV end*/
 437         wm831x_reg_write(wm831x, 0x4069, 0x6010);
 438
 439 /*wm831x_post_init set ldo4=2500000mV end*/
 440         wm831x_reg_write(wm831x, 0x4072, 0x8017);
 441
 442 /*wm831x_post_init set ldo7=3300000mV end*/
 443         wm831x_reg_write(wm831x, 0x407b, 0xa01d);
 444
 445 /*wm831x_post_init set dcdc4=-22mV end*/
 446         wm831x_reg_write(wm831x, 0x4050, 0xf);
 447
 448 /*wm831x_post_init set ldo2=3000000mV end*/
 449         wm831x_reg_write(wm831x, 0x406c, 0x1c);
 450         wm831x_reg_write(wm831x, 0x4051, 0x24b);
 451
 452 /*wm831x_post_init set ldo3=1800000mV end*/
 453         wm831x_reg_write(wm831x, 0x406f, 0x10);
 454         wm831x_reg_write(wm831x, 0x4051, 0x24f);
 455
 456 /*wm831x_post_init set ldo5=3000000mV end*/
 457         wm831x_reg_write(wm831x, 0x4075, 0x1c);
 458         wm831x_reg_write(wm831x, 0x4051, 0x25f);
 459
 460 /*wm831x_post_init set ldo6=2800000mV end*/
 461         wm831x_reg_write(wm831x, 0x4078, 0x1a);
 462         wm831x_reg_write(wm831x, 0x4051, 0x27f);
 463
 464 /*wm831x_post_init set ldo8=1200000mV end*/
 465         wm831x_reg_write(wm831x, 0x407e, 0x4);
 466         wm831x_reg_write(wm831x, 0x4051, 0x2ff);
 467
 468 /*wm831x_post_init set ldo9=3000000mV end*/
 469         wm831x_reg_write(wm831x, 0x4081, 0x1a);
 470         wm831x_reg_write(wm831x, 0x4051, 0x3ff);
 471
 472         wm831x_reg_write(wm831x, 0x4008, 0x0);
 473
 474         wm831x_reg_write(wm831x, 0x4008, 0x9716);
 475         wm831x_reg_write(wm831x, 0x4064, 0x104);
 476         wm831x_reg_write(wm831x, 0x4008, 0x0);
 477         wm831x_reg_write(wm831x, 0x4050, 0x7);
 478
 479 /* backlight brightness=255*/
 480         wm831x_reg_write(wm831x, 0x404e, 0xc500);
 481         wm831x_reg_write(wm831x, 0x4050, 0xf);
 482         wm831x_reg_write(wm831x, 0x404e, 0xc535);
 483         wm831x_reg_write(wm831x, 0x404e, 0xc535);
 484
 485
 486 /*wm831x-rtc wm831x-rtc: rtc core: registered wm831x as rtc0*/
 487         //wm831x_reg_write(wm831x, 0x4019, 0xeef7);
 488         //wm831x_reg_write(wm831x, 0x4019, 0xeef3);
 489
 490 /*wm831x_power_probe:wm831x_power initialized*/
 491         wm831x_reg_write(wm831x, 0x4008, 0x9716);
 492         wm831x_reg_write(wm831x, 0x404b, 0x8812);
 493
 494         wm831x_reg_write(wm831x, 0x4008, 0x0);
 495         wm831x_reg_write(wm831x, 0x4008, 0x9716);
 496         wm831x_reg_write(wm831x, 0x4048, 0x9c21);
 497
 498         wm831x_reg_write(wm831x, 0x4048, 0x9c21);
 499
 500         wm831x_reg_write(wm831x, 0x4049, 0x44ff);
 501         wm831x_reg_write(wm831x, 0x4001, 0x57);
 502         wm831x_reg_write(wm831x, 0x4008, 0x0);
 503         //wm831x_reg_write(wm831x, 0x4019, 0x6ef3);
 504         //wm831x_reg_write(wm831x, 0x4019, 0x2ef3);
 505
 506 /*device-mapper: uevent: version 1.0.3*/
 507         wm831x_reg_write(wm831x, 0x402e, 0x8000);
 508         wm831x_reg_write(wm831x, 0x4014, 0x8);
 509         wm831x_reg_write(wm831x, 0x402f, 0x400);
 510         wm831x_reg_write(wm831x, 0x402e, 0xc000);
 511
 512 /*gpu: power on... done!*/
 513         wm831x_reg_write(wm831x, 0x402e, 0x0);
 514         wm831x_reg_write(wm831x, 0x4011, 0x2100);
 515         wm831x_reg_write(wm831x, 0x402e, 0x8000);
 516         wm831x_reg_write(wm831x, 0x402f, 0x200);
 517         wm831x_reg_write(wm831x, 0x402e, 0xc000);
 518
 519
 520 /*wm831x_isink_is_enabled:line=85*/
 521 /*wm831x-rtc wm831x-rtc: setting system clock to 1970-01-02 04:18:35 UTC (101915)*/
 522         wm831x_reg_write(wm831x, 0x402e, 0x0);
 523         wm831x_reg_write(wm831x, 0x4011, 0x100);
 524
 525         wm831x_reg_write(wm831x, 0x402e, 0x8000);
 526         wm831x_reg_write(wm831x, 0x402f, 0x100);
 527         wm831x_reg_write(wm831x, 0x402e, 0xc000);
 528         wm831x_reg_write(wm831x, 0x4011, 0x100);
 529         wm831x_reg_write(wm831x, 0x402e, 0x0);
 530
 531         printk("%s\n",__FUNCTION__);
 532
 533 }
 534
 535 extern void rk29_send_power_key(int state);
 536 static int gNumInt = 0, gNumTimer = 0;
 537 static struct timer_list        irq_timer;
 538 static struct wm831x *gwm831x;
 539
 540 void wm831x_power_off(void)
 541 {
 542         wm831x_reg_write(gwm831x, WM831X_POWER_STATE, 0);//power off
 543 }
 544
 545 static void wm831x_irq_timer(unsigned long data)
 546 {
 547         struct wm831x *wm831x = (struct wm831x *)data;
 548         int pin = irq_to_gpio(wm831x->irq);
 549
 550         if(gNumInt >0)
 551         {
 552                 if(gpio_get_value(pin) > 0)
 553                 gNumTimer++;
 554                 else
 555                 gNumTimer = 0;
 556
 557                 if(gNumTimer >20)
 558                 {
 559                         rk29_send_power_key(0);
 560                         gNumTimer = 0;
 561                         gNumInt = 0;
 562                 }
 563         }
 564
 565         irq_timer.expires  = jiffies + msecs_to_jiffies(20);
 566         add_timer(&irq_timer);
 567
 568 }
 569
 570 static void wm831x_irq_worker(struct work_struct *work)
 571 {
 572         struct wm831x *wm831x = container_of(work, struct wm831x, irq_work);
 573         wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1, 0xffff);//clear all intterupt
 574         gNumInt++;
 575         rk29_send_power_key(1);
 576         enable_irq(wm831x->irq);
 577         wake_unlock(&wm831x->irq_wake);
 578         //printk("%s,irq=%d\n",__FUNCTION__,wm831x->irq);
 579 }
 580
 581 static irqreturn_t wm831x_irq_thread(int irq, void *data)
 582 {
 583         struct wm831x *wm831x = data;
 584
 585         disable_irq_nosync(irq);
 586         wake_lock(&wm831x->irq_wake);
 587         queue_work(wm831x->irq_wq, &wm831x->irq_work);
 588
 589         return IRQ_HANDLED;
 590 }
 591
 592 static int __devinit wm831x_spi_probe(struct spi_device *spi)
 593 {
 594         struct wm831x *wm831x;
 595         enum wm831x_parent type;
 596         int ret,gpio,irq;
 597
 598         /* Currently SPI support for ID tables is unmerged, we're faking it */
 599         if (strcmp(spi->modalias, "wm8310") == 0)
 600                 type = WM8310;
 601         else if (strcmp(spi->modalias, "wm8311") == 0)
 602                 type = WM8311;
 603         else if (strcmp(spi->modalias, "wm8312") == 0)
 604                 type = WM8312;
 605         else if (strcmp(spi->modalias, "wm8320") == 0)
 606                 type = WM8320;
 607         else if (strcmp(spi->modalias, "wm8321") == 0)
 608                 type = WM8321;
 609         else if (strcmp(spi->modalias, "wm8325") == 0)
 610                 type = WM8325;
 611         else {
 612                 dev_err(&spi->dev, "Unknown device type\n");
 613                 return -EINVAL;
 614         }
 615
 616         wm831x = kzalloc(sizeof(struct wm831x), GFP_KERNEL);
 617         if (wm831x == NULL)
 618                 return -ENOMEM;
 619
 620         spi->bits_per_word = 16;
 621         spi->mode = SPI_MODE_0;
 622
 623         gpio = spi->irq;
 624         ret = gpio_request(gpio, "wm831x");
 625         if (ret) {
 626                 printk( "failed to request rk gpio irq for wm831x \n");
 627                 return ret;
 628         }
 629         gpio_pull_updown(gpio, GPIOPullUp);
 630         if (ret) {
 631             printk("failed to pull up gpio irq for wm831x \n");
 632                 return ret;
 633         }
 634         irq = gpio_to_irq(gpio);
 635
 636         dev_set_drvdata(&spi->dev, wm831x);
 637         wm831x->dev = &spi->dev;
 638         wm831x->control_data = spi;
 639         wm831x->read_dev = wm831x_spi_read_device;
 640         wm831x->write_dev = wm831x_spi_write_device;
 641         gwm831x = wm831x;
 642         mutex_init(&wm831x->io_lock);
 643
 644         wm831x_init(wm831x);
 645
 646         wm831x->irq_wq = create_singlethread_workqueue("wm831x-irq");
 647         if (!wm831x->irq_wq) {
 648                 dev_err(wm831x->dev, "Failed to allocate IRQ worker\n");
 649                 return -ESRCH;
 650         }
 651
 652         INIT_WORK(&wm831x->irq_work, wm831x_irq_worker);
 653         wake_lock_init(&wm831x->irq_wake, WAKE_LOCK_SUSPEND, "wm831x_irq_wake");
 654
 655         ret = request_threaded_irq(irq, wm831x_irq_thread, NULL,
 656                                  IRQF_TRIGGER_LOW,
 657                                    "wm831x", wm831x);
 658         if (ret != 0) {
 659                 dev_err(wm831x->dev, "Failed to request IRQ %d: %d\n",
 660                         wm831x->irq, ret);
 661                 return ret;
 662         }
 663         wm831x->irq = irq;
 664         enable_irq_wake(irq); // so wm831x irq can wake up system
 665         /* only support on intterupt */
 666         wm831x_reg_write(wm831x, WM831X_SYSTEM_INTERRUPTS_MASK, 0xefff);
 667         wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1_MASK, 0xefff);
 668
 669         setup_timer(&irq_timer, wm831x_irq_timer, (unsigned long)wm831x);
 670         irq_timer.expires  = jiffies+2000;
 671         add_timer(&irq_timer);
 672
 673         return 0;
 674         //return wm831x_device_init(wm831x, type, irq);
 675 }
 676
 677 static int __devexit wm831x_spi_remove(struct spi_device *spi)
 678 {
 679         struct wm831x *wm831x = dev_get_drvdata(&spi->dev);
 680
 681         //wm831x_device_exit(wm831x);
 682
 683         return 0;
 684 }
 685
 686 static int wm831x_spi_suspend(struct spi_device *spi, pm_message_t m)
 687 {
 688         struct wm831x *wm831x = dev_get_drvdata(&spi->dev);
 689         return 0;
 690         //return wm831x_device_suspend(wm831x);
 691 }
 692
 693 static int wm831x_spi_resume(struct spi_device *spi)
 694 {
 695         return 0;
 696 }
 697
 698 static struct spi_driver wm8310_spi_driver = {
 699         .driver = {
 700                 .name   = "wm8310",
 701                 .bus    = &spi_bus_type,
 702                 .owner  = THIS_MODULE,
 703         },
 704         .probe          = wm831x_spi_probe,
 705         .remove         = __devexit_p(wm831x_spi_remove),
 706         .suspend        = wm831x_spi_suspend,
 707         .resume = wm831x_spi_resume,
 708 };
 709
 710 static struct spi_driver wm8311_spi_driver = {
 711         .driver = {
 712                 .name   = "wm8311",
 713                 .bus    = &spi_bus_type,
 714                 .owner  = THIS_MODULE,
 715         },
 716         .probe          = wm831x_spi_probe,
 717         .remove         = __devexit_p(wm831x_spi_remove),
 718         .suspend        = wm831x_spi_suspend,
 719 };
 720
 721 static struct spi_driver wm8312_spi_driver = {
 722         .driver = {
 723                 .name   = "wm8312",
 724                 .bus    = &spi_bus_type,
 725                 .owner  = THIS_MODULE,
 726         },
 727         .probe          = wm831x_spi_probe,
 728         .remove         = __devexit_p(wm831x_spi_remove),
 729         .suspend        = wm831x_spi_suspend,
 730 };
 731
 732 static struct spi_driver wm8320_spi_driver = {
 733         .driver = {
 734                 .name   = "wm8320",
 735                 .bus    = &spi_bus_type,
 736                 .owner  = THIS_MODULE,
 737         },
 738         .probe          = wm831x_spi_probe,
 739         .remove         = __devexit_p(wm831x_spi_remove),
 740         .suspend        = wm831x_spi_suspend,
 741 };
 742
 743 static struct spi_driver wm8321_spi_driver = {
 744         .driver = {
 745                 .name   = "wm8321",
 746                 .bus    = &spi_bus_type,
 747                 .owner  = THIS_MODULE,
 748         },
 749         .probe          = wm831x_spi_probe,
 750         .remove         = __devexit_p(wm831x_spi_remove),
 751         .suspend        = wm831x_spi_suspend,
 752 };
 753
 754 static struct spi_driver wm8325_spi_driver = {
 755         .driver = {
 756                 .name   = "wm8325",
 757                 .bus    = &spi_bus_type,
 758                 .owner  = THIS_MODULE,
 759         },
 760         .probe          = wm831x_spi_probe,
 761         .remove         = __devexit_p(wm831x_spi_remove),
 762         .suspend        = wm831x_spi_suspend,
 763 };
 764
 765 static int __init wm831x_spi_init(void)
 766 {
 767         int ret;
 768
 769         ret = spi_register_driver(&wm8310_spi_driver);
 770         if (ret != 0)
 771                 pr_err("Failed to register WM8310 SPI driver: %d\n", ret);
 772
 773         ret = spi_register_driver(&wm8311_spi_driver);
 774         if (ret != 0)
 775                 pr_err("Failed to register WM8311 SPI driver: %d\n", ret);
 776
 777         ret = spi_register_driver(&wm8312_spi_driver);
 778         if (ret != 0)
 779                 pr_err("Failed to register WM8312 SPI driver: %d\n", ret);
 780
 781         ret = spi_register_driver(&wm8320_spi_driver);
 782         if (ret != 0)
 783                 pr_err("Failed to register WM8320 SPI driver: %d\n", ret);
 784
 785         ret = spi_register_driver(&wm8321_spi_driver);
 786         if (ret != 0)
 787                 pr_err("Failed to register WM8321 SPI driver: %d\n", ret);
 788
 789         ret = spi_register_driver(&wm8325_spi_driver);
 790         if (ret != 0)
 791                 pr_err("Failed to register WM8325 SPI driver: %d\n", ret);
 792
 793         return 0;
 794 }
 795 subsys_initcall(wm831x_spi_init);
 796
 797 static void __exit wm831x_spi_exit(void)
 798 {
 799         spi_unregister_driver(&wm8325_spi_driver);
 800         spi_unregister_driver(&wm8321_spi_driver);
 801         spi_unregister_driver(&wm8320_spi_driver);
 802         spi_unregister_driver(&wm8312_spi_driver);
 803         spi_unregister_driver(&wm8311_spi_driver);
 804         spi_unregister_driver(&wm8310_spi_driver);
 805 }
 806 module_exit(wm831x_spi_exit);
 807
 808 MODULE_DESCRIPTION("SPI support for WM831x/2x AudioPlus PMICs");
 809 MODULE_LICENSE("GPL");
 810 MODULE_AUTHOR("Mark Brown");