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/spi/spi.h>
  18 #include <linux/gpio.h>
  19
  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 {
  88                 dev_err(&spi->dev, "Unknown device type\n");
  89                 return -EINVAL;
  90         }
  91
  92         wm831x = kzalloc(sizeof(struct wm831x), GFP_KERNEL);
  93         if (wm831x == NULL)
  94                 return -ENOMEM;
  95
  96         spi->bits_per_word = 16;
  97         spi->mode = SPI_MODE_0;
  98
  99         gpio = spi->irq;
 100         ret = gpio_request(gpio, "wm831x");
 101         if (ret) {
 102                 printk( "failed to request rk gpio irq for wm831x \n");
 103                 return ret;
 104         }
 105         gpio_pull_updown(gpio, GPIOPullUp);
 106         if (ret) {
 107             printk("failed to pull up gpio irq for wm831x \n");
 108                 return ret;
 109         }
 110         irq = gpio_to_irq(gpio);
 111
 112         dev_set_drvdata(&spi->dev, wm831x);
 113         wm831x->dev = &spi->dev;
 114         wm831x->control_data = spi;
 115         wm831x->read_dev = wm831x_spi_read_device;
 116         wm831x->write_dev = wm831x_spi_write_device;
 117
 118         return wm831x_device_init(wm831x, type, irq);
 119 }
 120
 121 static int __devexit wm831x_spi_remove(struct spi_device *spi)
 122 {
 123         struct wm831x *wm831x = dev_get_drvdata(&spi->dev);
 124
 125         wm831x_device_exit(wm831x);
 126
 127         return 0;
 128 }
 129
 130 static int wm831x_spi_suspend(struct spi_device *spi, pm_message_t m)
 131 {
 132         struct wm831x *wm831x = dev_get_drvdata(&spi->dev);
 133         spin_lock(&wm831x->flag_lock);
 134         wm831x->flag_suspend = 1;
 135         spin_unlock(&wm831x->flag_lock);
 136         return wm831x_device_suspend(wm831x);
 137 }
 138
 139 static struct spi_driver wm8310_spi_driver = {
 140         .driver = {
 141                 .name   = "wm8310",
 142                 .bus    = &spi_bus_type,
 143                 .owner  = THIS_MODULE,
 144         },
 145         .probe          = wm831x_spi_probe,
 146         .remove         = __devexit_p(wm831x_spi_remove),
 147         .suspend        = wm831x_spi_suspend,
 148 };
 149
 150 static struct spi_driver wm8311_spi_driver = {
 151         .driver = {
 152                 .name   = "wm8311",
 153                 .bus    = &spi_bus_type,
 154                 .owner  = THIS_MODULE,
 155         },
 156         .probe          = wm831x_spi_probe,
 157         .remove         = __devexit_p(wm831x_spi_remove),
 158         .suspend        = wm831x_spi_suspend,
 159 };
 160
 161 static struct spi_driver wm8312_spi_driver = {
 162         .driver = {
 163                 .name   = "wm8312",
 164                 .bus    = &spi_bus_type,
 165                 .owner  = THIS_MODULE,
 166         },
 167         .probe          = wm831x_spi_probe,
 168         .remove         = __devexit_p(wm831x_spi_remove),
 169         .suspend        = wm831x_spi_suspend,
 170 };
 171
 172 static struct spi_driver wm8320_spi_driver = {
 173         .driver = {
 174                 .name   = "wm8320",
 175                 .bus    = &spi_bus_type,
 176                 .owner  = THIS_MODULE,
 177         },
 178         .probe          = wm831x_spi_probe,
 179         .remove         = __devexit_p(wm831x_spi_remove),
 180         .suspend        = wm831x_spi_suspend,
 181 };
 182
 183 static struct spi_driver wm8321_spi_driver = {
 184         .driver = {
 185                 .name   = "wm8321",
 186                 .bus    = &spi_bus_type,
 187                 .owner  = THIS_MODULE,
 188         },
 189         .probe          = wm831x_spi_probe,
 190         .remove         = __devexit_p(wm831x_spi_remove),
 191         .suspend        = wm831x_spi_suspend,
 192 };
 193
 194 static struct spi_driver wm8325_spi_driver = {
 195         .driver = {
 196                 .name   = "wm8325",
 197                 .bus    = &spi_bus_type,
 198                 .owner  = THIS_MODULE,
 199         },
 200         .probe          = wm831x_spi_probe,
 201         .remove         = __devexit_p(wm831x_spi_remove),
 202         .suspend        = wm831x_spi_suspend,
 203 };
 204
 205 static int __init wm831x_spi_init(void)
 206 {
 207         int ret;
 208
 209         ret = spi_register_driver(&wm8310_spi_driver);
 210         if (ret != 0)
 211                 pr_err("Failed to register WM8310 SPI driver: %d\n", ret);
 212
 213         ret = spi_register_driver(&wm8311_spi_driver);
 214         if (ret != 0)
 215                 pr_err("Failed to register WM8311 SPI driver: %d\n", ret);
 216
 217         ret = spi_register_driver(&wm8312_spi_driver);
 218         if (ret != 0)
 219                 pr_err("Failed to register WM8312 SPI driver: %d\n", ret);
 220
 221         ret = spi_register_driver(&wm8320_spi_driver);
 222         if (ret != 0)
 223                 pr_err("Failed to register WM8320 SPI driver: %d\n", ret);
 224
 225         ret = spi_register_driver(&wm8321_spi_driver);
 226         if (ret != 0)
 227                 pr_err("Failed to register WM8321 SPI driver: %d\n", ret);
 228
 229         ret = spi_register_driver(&wm8325_spi_driver);
 230         if (ret != 0)
 231                 pr_err("Failed to register WM8325 SPI driver: %d\n", ret);
 232
 233         return 0;
 234 }
 235 subsys_initcall(wm831x_spi_init);
 236
 237 static void __exit wm831x_spi_exit(void)
 238 {
 239         spi_unregister_driver(&wm8325_spi_driver);
 240         spi_unregister_driver(&wm8321_spi_driver);
 241         spi_unregister_driver(&wm8320_spi_driver);
 242         spi_unregister_driver(&wm8312_spi_driver);
 243         spi_unregister_driver(&wm8311_spi_driver);
 244         spi_unregister_driver(&wm8310_spi_driver);
 245 }
 246 module_exit(wm831x_spi_exit);
 247
 248 MODULE_DESCRIPTION("SPI support for WM831x/2x AudioPlus PMICs");
 249 MODULE_LICENSE("GPL");
 250 MODULE_AUTHOR("Mark Brown");