drivers/mfd/wm831x-spi.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/pm.h>
  18 #include <linux/spi/spi.h>
  19 #include <linux/gpio.h>
  20
  21 #include <linux/mfd/wm831x/core.h>
  22
  23 static int wm831x_spi_read_device(struct wm831x *wm831x, unsigned short reg,
  24                                   int bytes, void *dest)
  25 {
  26         u16 tx_val;
  27         u16 *d = dest;
  28         int r, ret;
  29
  30         /* Go register at a time */
  31         for (r = reg; r < reg + (bytes / 2); r++) {
  32                 tx_val = cpu_to_be16(r | 0x8000);
  33                 //printk("read:reg=0x%x,",reg);
  34                 ret = spi_write_then_read(wm831x->control_data,
  35                                           (u8 *)&tx_val, 2, (u8 *)d, 2);
  36                 if (ret != 0)
  37                         return ret;
  38                 //printk("rec=0x%x\n",be16_to_cpu(*d));
  39                 //*d = be16_to_cpu(*d);
  40
  41                 d++;
  42         }
  43
  44         return 0;
  45 }
  46
  47 static int wm831x_spi_write_device(struct wm831x *wm831x, unsigned short reg,
  48                                    int bytes, void *src)
  49 {
  50         struct spi_device *spi = wm831x->control_data;
  51         u16 *s = src;
  52         u16 data[2];
  53         int ret, r;
  54
  55         /* Go register at a time */
  56         for (r = reg; r < reg + (bytes / 2); r++) {
  57                 data[0] = cpu_to_be16(r);
  58                 data[1] = *s++;
  59                 //printk("write:reg=0x%x,send=0x%x\n",reg, data[0]);
  60                 ret = spi_write(spi, (char *)&data, sizeof(data));
  61                 if (ret != 0)
  62                         return ret;
  63         }
  64
  65         return 0;
  66 }
  67
  68 static int __devinit wm831x_spi_probe(struct spi_device *spi)
  69 {
  70         struct wm831x *wm831x;
  71         enum wm831x_parent type;
  72         int ret,gpio,irq;
  73
  74         /* Currently SPI support for ID tables is unmerged, we're faking it */
  75         if (strcmp(spi->modalias, "wm8310") == 0)
  76                 type = WM8310;
  77         else if (strcmp(spi->modalias, "wm8311") == 0)
  78                 type = WM8311;
  79         else if (strcmp(spi->modalias, "wm8312") == 0)
  80                 type = WM8312;
  81         else if (strcmp(spi->modalias, "wm8320") == 0)
  82                 type = WM8320;
  83         else if (strcmp(spi->modalias, "wm8321") == 0)
  84                 type = WM8321;
  85         else if (strcmp(spi->modalias, "wm8325") == 0)
  86                 type = WM8325;
  87         else if (strcmp(spi->modalias, "wm8326") == 0)
  88                 type = WM8326;
  89         else {
  90                 dev_err(&spi->dev, "Unknown device type\n");
  91                 return -EINVAL;
  92         }
  93
  94         wm831x = kzalloc(sizeof(struct wm831x), GFP_KERNEL);
  95         if (wm831x == NULL)
  96                 return -ENOMEM;
  97
  98         spi->bits_per_word = 16;
  99         spi->mode = SPI_MODE_0;
 100
 101         gpio = spi->irq;
 102         ret = gpio_request(gpio, "wm831x");
 103         if (ret) {
 104                 printk( "failed to request rk gpio irq for wm831x \n");
 105                 return ret;
 106         }
 107         gpio_pull_updown(gpio, GPIOPullUp);
 108         if (ret) {
 109             printk("failed to pull up gpio irq for wm831x \n");
 110                 return ret;
 111         }
 112         irq = gpio_to_irq(gpio);
 113
 114         dev_set_drvdata(&spi->dev, wm831x);
 115         wm831x->dev = &spi->dev;
 116         wm831x->control_data = spi;
 117         wm831x->read_dev = wm831x_spi_read_device;
 118         wm831x->write_dev = wm831x_spi_write_device;
 119
 120         return wm831x_device_init(wm831x, type, irq);
 121 }
 122
 123 static int __devexit wm831x_spi_remove(struct spi_device *spi)
 124 {
 125         struct wm831x *wm831x = dev_get_drvdata(&spi->dev);
 126
 127         wm831x_device_exit(wm831x);
 128
 129         return 0;
 130 }
 131
 132 static int wm831x_spi_suspend(struct device *dev)
 133 {
 134         struct wm831x *wm831x = dev_get_drvdata(dev);
 135
 136         spin_lock(&wm831x->flag_lock);
 137         wm831x->flag_suspend = 1;
 138         spin_unlock(&wm831x->flag_lock);
 139         return wm831x_device_suspend(wm831x);
 140 }
 141
 142 static const struct dev_pm_ops wm831x_spi_pm = {
 143         .freeze = wm831x_spi_suspend,
 144         .suspend = wm831x_spi_suspend,
 145 };
 146
 147 static struct spi_driver wm8310_spi_driver = {
 148         .driver = {
 149                 .name   = "wm8310",
 150                 .bus    = &spi_bus_type,
 151                 .owner  = THIS_MODULE,
 152                 .pm     = &wm831x_spi_pm,
 153         },
 154         .probe          = wm831x_spi_probe,
 155         .remove         = __devexit_p(wm831x_spi_remove),
 156 };
 157
 158 static struct spi_driver wm8311_spi_driver = {
 159         .driver = {
 160                 .name   = "wm8311",
 161                 .bus    = &spi_bus_type,
 162                 .owner  = THIS_MODULE,
 163                 .pm     = &wm831x_spi_pm,
 164         },
 165         .probe          = wm831x_spi_probe,
 166         .remove         = __devexit_p(wm831x_spi_remove),
 167 };
 168
 169 static struct spi_driver wm8312_spi_driver = {
 170         .driver = {
 171                 .name   = "wm8312",
 172                 .bus    = &spi_bus_type,
 173                 .owner  = THIS_MODULE,
 174                 .pm     = &wm831x_spi_pm,
 175         },
 176         .probe          = wm831x_spi_probe,
 177         .remove         = __devexit_p(wm831x_spi_remove),
 178 };
 179
 180 static struct spi_driver wm8320_spi_driver = {
 181         .driver = {
 182                 .name   = "wm8320",
 183                 .bus    = &spi_bus_type,
 184                 .owner  = THIS_MODULE,
 185                 .pm     = &wm831x_spi_pm,
 186         },
 187         .probe          = wm831x_spi_probe,
 188         .remove         = __devexit_p(wm831x_spi_remove),
 189 };
 190
 191 static struct spi_driver wm8321_spi_driver = {
 192         .driver = {
 193                 .name   = "wm8321",
 194                 .bus    = &spi_bus_type,
 195                 .owner  = THIS_MODULE,
 196                 .pm     = &wm831x_spi_pm,
 197         },
 198         .probe          = wm831x_spi_probe,
 199         .remove         = __devexit_p(wm831x_spi_remove),
 200 };
 201
 202 static struct spi_driver wm8325_spi_driver = {
 203         .driver = {
 204                 .name   = "wm8325",
 205                 .bus    = &spi_bus_type,
 206                 .owner  = THIS_MODULE,
 207                 .pm     = &wm831x_spi_pm,
 208         },
 209         .probe          = wm831x_spi_probe,
 210         .remove         = __devexit_p(wm831x_spi_remove),
 211 };
 212
 213 static struct spi_driver wm8326_spi_driver = {
 214         .driver = {
 215                 .name   = "wm8326",
 216                 .bus    = &spi_bus_type,
 217                 .owner  = THIS_MODULE,
 218                 .pm     = &wm831x_spi_pm,
 219         },
 220         .probe          = wm831x_spi_probe,
 221         .remove         = __devexit_p(wm831x_spi_remove),
 222 };
 223
 224 static int __init wm831x_spi_init(void)
 225 {
 226         int ret;
 227
 228         ret = spi_register_driver(&wm8310_spi_driver);
 229         if (ret != 0)
 230                 pr_err("Failed to register WM8310 SPI driver: %d\n", ret);
 231
 232         ret = spi_register_driver(&wm8311_spi_driver);
 233         if (ret != 0)
 234                 pr_err("Failed to register WM8311 SPI driver: %d\n", ret);
 235
 236         ret = spi_register_driver(&wm8312_spi_driver);
 237         if (ret != 0)
 238                 pr_err("Failed to register WM8312 SPI driver: %d\n", ret);
 239
 240         ret = spi_register_driver(&wm8320_spi_driver);
 241         if (ret != 0)
 242                 pr_err("Failed to register WM8320 SPI driver: %d\n", ret);
 243
 244         ret = spi_register_driver(&wm8321_spi_driver);
 245         if (ret != 0)
 246                 pr_err("Failed to register WM8321 SPI driver: %d\n", ret);
 247
 248         ret = spi_register_driver(&wm8325_spi_driver);
 249         if (ret != 0)
 250                 pr_err("Failed to register WM8325 SPI driver: %d\n", ret);
 251
 252         ret = spi_register_driver(&wm8326_spi_driver);
 253         if (ret != 0)
 254                 pr_err("Failed to register WM8326 SPI driver: %d\n", ret);
 255
 256         return 0;
 257 }
 258 subsys_initcall(wm831x_spi_init);
 259
 260 static void __exit wm831x_spi_exit(void)
 261 {
 262         spi_unregister_driver(&wm8326_spi_driver);
 263         spi_unregister_driver(&wm8325_spi_driver);
 264         spi_unregister_driver(&wm8321_spi_driver);
 265         spi_unregister_driver(&wm8320_spi_driver);
 266         spi_unregister_driver(&wm8312_spi_driver);
 267         spi_unregister_driver(&wm8311_spi_driver);
 268         spi_unregister_driver(&wm8310_spi_driver);
 269 }
 270 module_exit(wm831x_spi_exit);
 271
 272 MODULE_DESCRIPTION("SPI support for WM831x/2x AudioPlus PMICs");
 273 MODULE_LICENSE("GPL");
 274 MODULE_AUTHOR("Mark Brown");