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 rk28_send_wakeup_key(void);
 536 static int gNumInt = 0;
 537
 538 static void wm831x_irq_worker(struct work_struct *work)
 539 {
 540         struct wm831x *wm831x = container_of(work, struct wm831x, irq_work);
 541         wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1, 0xffff);//clear all intterupt
 542
 543         if(++ gNumInt >= 2)
 544         {
 545                 rk28_send_wakeup_key();
 546                 //wake_lock_timeout(&wm831x->irq_wake,msecs_to_jiffies(2000));
 547                 gNumInt = 0;
 548         }
 549         enable_irq(wm831x->irq);
 550         wake_unlock(&wm831x->irq_wake);
 551         //printk("%s,irq=%d\n",__FUNCTION__,wm831x->irq);
 552 }
 553
 554 static irqreturn_t wm831x_irq_thread(int irq, void *data)
 555 {
 556         struct wm831x *wm831x = data;
 557
 558         disable_irq_nosync(irq);
 559         wake_lock(&wm831x->irq_wake);
 560         queue_work(wm831x->irq_wq, &wm831x->irq_work);
 561
 562         return IRQ_HANDLED;
 563 }
 564
 565 static int __devinit wm831x_spi_probe(struct spi_device *spi)
 566 {
 567         struct wm831x *wm831x;
 568         enum wm831x_parent type;
 569         int ret,gpio,irq;
 570
 571         /* Currently SPI support for ID tables is unmerged, we're faking it */
 572         if (strcmp(spi->modalias, "wm8310") == 0)
 573                 type = WM8310;
 574         else if (strcmp(spi->modalias, "wm8311") == 0)
 575                 type = WM8311;
 576         else if (strcmp(spi->modalias, "wm8312") == 0)
 577                 type = WM8312;
 578         else if (strcmp(spi->modalias, "wm8320") == 0)
 579                 type = WM8320;
 580         else if (strcmp(spi->modalias, "wm8321") == 0)
 581                 type = WM8321;
 582         else if (strcmp(spi->modalias, "wm8325") == 0)
 583                 type = WM8325;
 584         else {
 585                 dev_err(&spi->dev, "Unknown device type\n");
 586                 return -EINVAL;
 587         }
 588
 589         wm831x = kzalloc(sizeof(struct wm831x), GFP_KERNEL);
 590         if (wm831x == NULL)
 591                 return -ENOMEM;
 592
 593         spi->bits_per_word = 16;
 594         spi->mode = SPI_MODE_0;
 595
 596         gpio = spi->irq;
 597         ret = gpio_request(gpio, "wm831x");
 598         if (ret) {
 599                 printk( "failed to request rk gpio irq for wm831x \n");
 600                 return ret;
 601         }
 602         gpio_pull_updown(gpio, GPIOPullUp);
 603         if (ret) {
 604             printk("failed to pull up gpio irq for wm831x \n");
 605                 return ret;
 606         }
 607         irq = gpio_to_irq(gpio);
 608
 609         dev_set_drvdata(&spi->dev, wm831x);
 610         wm831x->dev = &spi->dev;
 611         wm831x->control_data = spi;
 612         wm831x->read_dev = wm831x_spi_read_device;
 613         wm831x->write_dev = wm831x_spi_write_device;
 614
 615         mutex_init(&wm831x->io_lock);
 616
 617         wm831x_init(wm831x);
 618
 619         wm831x->irq_wq = create_singlethread_workqueue("wm831x-irq");
 620         if (!wm831x->irq_wq) {
 621                 dev_err(wm831x->dev, "Failed to allocate IRQ worker\n");
 622                 return -ESRCH;
 623         }
 624
 625         INIT_WORK(&wm831x->irq_work, wm831x_irq_worker);
 626         wake_lock_init(&wm831x->irq_wake, WAKE_LOCK_SUSPEND, "wm831x_irq_wake");
 627
 628         ret = request_threaded_irq(irq, wm831x_irq_thread, NULL,
 629                                  IRQF_TRIGGER_LOW,
 630                                    "wm831x", wm831x);
 631         if (ret != 0) {
 632                 dev_err(wm831x->dev, "Failed to request IRQ %d: %d\n",
 633                         wm831x->irq, ret);
 634                 return ret;
 635         }
 636         wm831x->irq = irq;
 637         enable_irq_wake(irq); // so wm831x irq can wake up system
 638         /* only support on intterupt */
 639         wm831x_reg_write(wm831x, WM831X_SYSTEM_INTERRUPTS_MASK, 0xefff);
 640         wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1_MASK, 0xefff);
 641
 642         return 0;
 643         //return wm831x_device_init(wm831x, type, irq);
 644 }
 645
 646 static int __devexit wm831x_spi_remove(struct spi_device *spi)
 647 {
 648         struct wm831x *wm831x = dev_get_drvdata(&spi->dev);
 649
 650         //wm831x_device_exit(wm831x);
 651
 652         return 0;
 653 }
 654
 655 static int wm831x_spi_suspend(struct spi_device *spi, pm_message_t m)
 656 {
 657         struct wm831x *wm831x = dev_get_drvdata(&spi->dev);
 658         return 0;
 659         //return wm831x_device_suspend(wm831x);
 660 }
 661
 662 static int wm831x_spi_resume(struct spi_device *spi)
 663 {
 664         return 0;
 665 }
 666
 667 static struct spi_driver wm8310_spi_driver = {
 668         .driver = {
 669                 .name   = "wm8310",
 670                 .bus    = &spi_bus_type,
 671                 .owner  = THIS_MODULE,
 672         },
 673         .probe          = wm831x_spi_probe,
 674         .remove         = __devexit_p(wm831x_spi_remove),
 675         .suspend        = wm831x_spi_suspend,
 676         .resume = wm831x_spi_resume,
 677 };
 678
 679 static struct spi_driver wm8311_spi_driver = {
 680         .driver = {
 681                 .name   = "wm8311",
 682                 .bus    = &spi_bus_type,
 683                 .owner  = THIS_MODULE,
 684         },
 685         .probe          = wm831x_spi_probe,
 686         .remove         = __devexit_p(wm831x_spi_remove),
 687         .suspend        = wm831x_spi_suspend,
 688 };
 689
 690 static struct spi_driver wm8312_spi_driver = {
 691         .driver = {
 692                 .name   = "wm8312",
 693                 .bus    = &spi_bus_type,
 694                 .owner  = THIS_MODULE,
 695         },
 696         .probe          = wm831x_spi_probe,
 697         .remove         = __devexit_p(wm831x_spi_remove),
 698         .suspend        = wm831x_spi_suspend,
 699 };
 700
 701 static struct spi_driver wm8320_spi_driver = {
 702         .driver = {
 703                 .name   = "wm8320",
 704                 .bus    = &spi_bus_type,
 705                 .owner  = THIS_MODULE,
 706         },
 707         .probe          = wm831x_spi_probe,
 708         .remove         = __devexit_p(wm831x_spi_remove),
 709         .suspend        = wm831x_spi_suspend,
 710 };
 711
 712 static struct spi_driver wm8321_spi_driver = {
 713         .driver = {
 714                 .name   = "wm8321",
 715                 .bus    = &spi_bus_type,
 716                 .owner  = THIS_MODULE,
 717         },
 718         .probe          = wm831x_spi_probe,
 719         .remove         = __devexit_p(wm831x_spi_remove),
 720         .suspend        = wm831x_spi_suspend,
 721 };
 722
 723 static struct spi_driver wm8325_spi_driver = {
 724         .driver = {
 725                 .name   = "wm8325",
 726                 .bus    = &spi_bus_type,
 727                 .owner  = THIS_MODULE,
 728         },
 729         .probe          = wm831x_spi_probe,
 730         .remove         = __devexit_p(wm831x_spi_remove),
 731         .suspend        = wm831x_spi_suspend,
 732 };
 733
 734 static int __init wm831x_spi_init(void)
 735 {
 736         int ret;
 737
 738         ret = spi_register_driver(&wm8310_spi_driver);
 739         if (ret != 0)
 740                 pr_err("Failed to register WM8310 SPI driver: %d\n", ret);
 741
 742         ret = spi_register_driver(&wm8311_spi_driver);
 743         if (ret != 0)
 744                 pr_err("Failed to register WM8311 SPI driver: %d\n", ret);
 745
 746         ret = spi_register_driver(&wm8312_spi_driver);
 747         if (ret != 0)
 748                 pr_err("Failed to register WM8312 SPI driver: %d\n", ret);
 749
 750         ret = spi_register_driver(&wm8320_spi_driver);
 751         if (ret != 0)
 752                 pr_err("Failed to register WM8320 SPI driver: %d\n", ret);
 753
 754         ret = spi_register_driver(&wm8321_spi_driver);
 755         if (ret != 0)
 756                 pr_err("Failed to register WM8321 SPI driver: %d\n", ret);
 757
 758         ret = spi_register_driver(&wm8325_spi_driver);
 759         if (ret != 0)
 760                 pr_err("Failed to register WM8325 SPI driver: %d\n", ret);
 761
 762         return 0;
 763 }
 764 subsys_initcall(wm831x_spi_init);
 765
 766 static void __exit wm831x_spi_exit(void)
 767 {
 768         spi_unregister_driver(&wm8325_spi_driver);
 769         spi_unregister_driver(&wm8321_spi_driver);
 770         spi_unregister_driver(&wm8320_spi_driver);
 771         spi_unregister_driver(&wm8312_spi_driver);
 772         spi_unregister_driver(&wm8311_spi_driver);
 773         spi_unregister_driver(&wm8310_spi_driver);
 774 }
 775 module_exit(wm831x_spi_exit);
 776
 777 MODULE_DESCRIPTION("SPI support for WM831x/2x AudioPlus PMICs");
 778 MODULE_LICENSE("GPL");
 779 MODULE_AUTHOR("Mark Brown");