drivers/staging/iio/dds/ad9951.c

   1 /*
   2  * Driver for ADI Direct Digital Synthesis ad9951
   3  *
   4  * Copyright (c) 2010 Analog Devices Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  */
  11 #include <linux/types.h>
  12 #include <linux/mutex.h>
  13 #include <linux/device.h>
  14 #include <linux/spi/spi.h>
  15 #include <linux/slab.h>
  16 #include <linux/sysfs.h>
  17
  18 #include "../iio.h"
  19 #include "../sysfs.h"
  20
  21 #define DRV_NAME "ad9951"
  22
  23 #define CFR1 0x0
  24 #define CFR2 0x1
  25
  26 #define AUTO_OSK        (1)
  27 #define OSKEN           (1 << 1)
  28 #define LOAD_ARR        (1 << 2)
  29
  30 #define AUTO_SYNC       (1 << 7)
  31
  32 #define LSB_FST         (1)
  33 #define SDIO_IPT        (1 << 1)
  34 #define CLR_PHA         (1 << 2)
  35 #define SINE_OPT        (1 << 4)
  36 #define ACLR_PHA        (1 << 5)
  37
  38 #define VCO_RANGE       (1 << 2)
  39
  40 #define CRS_OPT         (1 << 1)
  41 #define HMANU_SYNC      (1 << 2)
  42 #define HSPD_SYNC       (1 << 3)
  43
  44 /* Register format: 1 byte addr + value */
  45 struct ad9951_config {
  46         u8 asf[3];
  47         u8 arr[2];
  48         u8 ftw0[5];
  49         u8 ftw1[3];
  50 };
  51
  52 struct ad9951_state {
  53         struct mutex lock;
  54         struct iio_dev *idev;
  55         struct spi_device *sdev;
  56 };
  57
  58 static ssize_t ad9951_set_parameter(struct device *dev,
  59                                         struct device_attribute *attr,
  60                                         const char *buf,
  61                                         size_t len)
  62 {
  63         struct spi_message msg;
  64         struct spi_transfer xfer;
  65         int ret;
  66         struct ad9951_config *config = (struct ad9951_config *)buf;
  67         struct iio_dev *idev = dev_get_drvdata(dev);
  68         struct ad9951_state *st = idev->dev_data;
  69
  70         xfer.len = 3;
  71         xfer.tx_buf = &config->asf[0];
  72         mutex_lock(&st->lock);
  73
  74         spi_message_init(&msg);
  75         spi_message_add_tail(&xfer, &msg);
  76         ret = spi_sync(st->sdev, &msg);
  77         if (ret)
  78                 goto error_ret;
  79
  80         xfer.len = 2;
  81         xfer.tx_buf = &config->arr[0];
  82
  83         spi_message_init(&msg);
  84         spi_message_add_tail(&xfer, &msg);
  85         ret = spi_sync(st->sdev, &msg);
  86         if (ret)
  87                 goto error_ret;
  88
  89         xfer.len = 5;
  90         xfer.tx_buf = &config->ftw0[0];
  91
  92         spi_message_init(&msg);
  93         spi_message_add_tail(&xfer, &msg);
  94         ret = spi_sync(st->sdev, &msg);
  95         if (ret)
  96                 goto error_ret;
  97
  98         xfer.len = 3;
  99         xfer.tx_buf = &config->ftw1[0];
 100
 101         spi_message_init(&msg);
 102         spi_message_add_tail(&xfer, &msg);
 103         ret = spi_sync(st->sdev, &msg);
 104         if (ret)
 105                 goto error_ret;
 106 error_ret:
 107         mutex_unlock(&st->lock);
 108
 109         return ret ? ret : len;
 110 }
 111
 112 static IIO_DEVICE_ATTR(dds, S_IWUSR, NULL, ad9951_set_parameter, 0);
 113
 114 static void ad9951_init(struct ad9951_state *st)
 115 {
 116         struct spi_message msg;
 117         struct spi_transfer xfer;
 118         int ret;
 119         u8 cfr[5];
 120
 121         cfr[0] = CFR1;
 122         cfr[1] = 0;
 123         cfr[2] = LSB_FST | CLR_PHA | SINE_OPT | ACLR_PHA;
 124         cfr[3] = AUTO_OSK | OSKEN | LOAD_ARR;
 125         cfr[4] = 0;
 126
 127         mutex_lock(&st->lock);
 128
 129         xfer.len = 5;
 130         xfer.tx_buf = &cfr;
 131
 132         spi_message_init(&msg);
 133         spi_message_add_tail(&xfer, &msg);
 134         ret = spi_sync(st->sdev, &msg);
 135         if (ret)
 136                 goto error_ret;
 137
 138         cfr[0] = CFR2;
 139         cfr[1] = VCO_RANGE;
 140         cfr[2] = HSPD_SYNC;
 141         cfr[3] = 0;
 142
 143         xfer.len = 4;
 144         xfer.tx_buf = &cfr;
 145
 146         spi_message_init(&msg);
 147         spi_message_add_tail(&xfer, &msg);
 148         ret = spi_sync(st->sdev, &msg);
 149         if (ret)
 150                 goto error_ret;
 151
 152 error_ret:
 153         mutex_unlock(&st->lock);
 154
 155
 156
 157 }
 158
 159 static struct attribute *ad9951_attributes[] = {
 160         &iio_dev_attr_dds.dev_attr.attr,
 161         NULL,
 162 };
 163
 164 static const struct attribute_group ad9951_attribute_group = {
 165         .name = DRV_NAME,
 166         .attrs = ad9951_attributes,
 167 };
 168
 169 static int __devinit ad9951_probe(struct spi_device *spi)
 170 {
 171         struct ad9951_state *st;
 172         int ret = 0;
 173
 174         st = kzalloc(sizeof(*st), GFP_KERNEL);
 175         if (st == NULL) {
 176                 ret = -ENOMEM;
 177                 goto error_ret;
 178         }
 179         spi_set_drvdata(spi, st);
 180
 181         mutex_init(&st->lock);
 182         st->sdev = spi;
 183
 184         st->idev = iio_allocate_device();
 185         if (st->idev == NULL) {
 186                 ret = -ENOMEM;
 187                 goto error_free_st;
 188         }
 189         st->idev->dev.parent = &spi->dev;
 190         st->idev->num_interrupt_lines = 0;
 191         st->idev->event_attrs = NULL;
 192
 193         st->idev->attrs = &ad9951_attribute_group;
 194         st->idev->dev_data = (void *)(st);
 195         st->idev->driver_module = THIS_MODULE;
 196         st->idev->modes = INDIO_DIRECT_MODE;
 197
 198         ret = iio_device_register(st->idev);
 199         if (ret)
 200                 goto error_free_dev;
 201         spi->max_speed_hz = 2000000;
 202         spi->mode = SPI_MODE_3;
 203         spi->bits_per_word = 8;
 204         spi_setup(spi);
 205         ad9951_init(st);
 206         return 0;
 207
 208 error_free_dev:
 209         iio_free_device(st->idev);
 210 error_free_st:
 211         kfree(st);
 212 error_ret:
 213         return ret;
 214 }
 215
 216 static int __devexit ad9951_remove(struct spi_device *spi)
 217 {
 218         struct ad9951_state *st = spi_get_drvdata(spi);
 219
 220         iio_device_unregister(st->idev);
 221         kfree(st);
 222
 223         return 0;
 224 }
 225
 226 static struct spi_driver ad9951_driver = {
 227         .driver = {
 228                 .name = DRV_NAME,
 229                 .owner = THIS_MODULE,
 230         },
 231         .probe = ad9951_probe,
 232         .remove = __devexit_p(ad9951_remove),
 233 };
 234
 235 static __init int ad9951_spi_init(void)
 236 {
 237         return spi_register_driver(&ad9951_driver);
 238 }
 239 module_init(ad9951_spi_init);
 240
 241 static __exit void ad9951_spi_exit(void)
 242 {
 243         spi_unregister_driver(&ad9951_driver);
 244 }
 245 module_exit(ad9951_spi_exit);
 246
 247 MODULE_AUTHOR("Cliff Cai");
 248 MODULE_DESCRIPTION("Analog Devices ad9951 driver");
 249 MODULE_LICENSE("GPL v2");