1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Analog Devices Generic AXI ADC IP core 4 * Link: https://wiki.analog.com/resources/fpga/docs/axi_adc_ip 5 * 6 * Copyright 2012-2020 Analog Devices Inc. 7 */ 8 9 #include <linux/bitfield.h> 10 #include <linux/clk.h> 11 #include <linux/err.h> 12 #include <linux/io.h> 13 #include <linux/delay.h> 14 #include <linux/module.h> 15 #include <linux/of.h> 16 #include <linux/platform_device.h> 17 #include <linux/property.h> 18 #include <linux/regmap.h> 19 #include <linux/slab.h> 20 21 #include <linux/fpga/adi-axi-common.h> 22 23 #include <linux/iio/backend.h> 24 #include <linux/iio/buffer-dmaengine.h> 25 #include <linux/iio/buffer.h> 26 #include <linux/iio/iio.h> 27 28 /* 29 * Register definitions: 30 * https://wiki.analog.com/resources/fpga/docs/axi_adc_ip#register_map 31 */ 32 33 /* ADC controls */ 34 35 #define ADI_AXI_REG_RSTN 0x0040 36 #define ADI_AXI_REG_RSTN_CE_N BIT(2) 37 #define ADI_AXI_REG_RSTN_MMCM_RSTN BIT(1) 38 #define ADI_AXI_REG_RSTN_RSTN BIT(0) 39 40 /* ADC Channel controls */ 41 42 #define ADI_AXI_REG_CHAN_CTRL(c) (0x0400 + (c) * 0x40) 43 #define ADI_AXI_REG_CHAN_CTRL_LB_OWR BIT(11) 44 #define ADI_AXI_REG_CHAN_CTRL_PN_SEL_OWR BIT(10) 45 #define ADI_AXI_REG_CHAN_CTRL_IQCOR_EN BIT(9) 46 #define ADI_AXI_REG_CHAN_CTRL_DCFILT_EN BIT(8) 47 #define ADI_AXI_REG_CHAN_CTRL_FMT_MASK GENMASK(6, 4) 48 #define ADI_AXI_REG_CHAN_CTRL_FMT_SIGNEXT BIT(6) 49 #define ADI_AXI_REG_CHAN_CTRL_FMT_TYPE BIT(5) 50 #define ADI_AXI_REG_CHAN_CTRL_FMT_EN BIT(4) 51 #define ADI_AXI_REG_CHAN_CTRL_PN_TYPE_OWR BIT(1) 52 #define ADI_AXI_REG_CHAN_CTRL_ENABLE BIT(0) 53 54 #define ADI_AXI_REG_CHAN_CTRL_DEFAULTS \ 55 (ADI_AXI_REG_CHAN_CTRL_FMT_SIGNEXT | \ 56 ADI_AXI_REG_CHAN_CTRL_FMT_EN | \ 57 ADI_AXI_REG_CHAN_CTRL_ENABLE) 58 59 struct adi_axi_adc_state { 60 struct regmap *regmap; 61 struct device *dev; 62 }; 63 64 static int axi_adc_enable(struct iio_backend *back) 65 { 66 struct adi_axi_adc_state *st = iio_backend_get_priv(back); 67 int ret; 68 69 ret = regmap_set_bits(st->regmap, ADI_AXI_REG_RSTN, 70 ADI_AXI_REG_RSTN_MMCM_RSTN); 71 if (ret) 72 return ret; 73 74 fsleep(10000); 75 return regmap_set_bits(st->regmap, ADI_AXI_REG_RSTN, 76 ADI_AXI_REG_RSTN_RSTN | ADI_AXI_REG_RSTN_MMCM_RSTN); 77 } 78 79 static void axi_adc_disable(struct iio_backend *back) 80 { 81 struct adi_axi_adc_state *st = iio_backend_get_priv(back); 82 83 regmap_write(st->regmap, ADI_AXI_REG_RSTN, 0); 84 } 85 86 static int axi_adc_data_format_set(struct iio_backend *back, unsigned int chan, 87 const struct iio_backend_data_fmt *data) 88 { 89 struct adi_axi_adc_state *st = iio_backend_get_priv(back); 90 u32 val; 91 92 if (!data->enable) 93 return regmap_clear_bits(st->regmap, 94 ADI_AXI_REG_CHAN_CTRL(chan), 95 ADI_AXI_REG_CHAN_CTRL_FMT_EN); 96 97 val = FIELD_PREP(ADI_AXI_REG_CHAN_CTRL_FMT_EN, true); 98 if (data->sign_extend) 99 val |= FIELD_PREP(ADI_AXI_REG_CHAN_CTRL_FMT_SIGNEXT, true); 100 if (data->type == IIO_BACKEND_OFFSET_BINARY) 101 val |= FIELD_PREP(ADI_AXI_REG_CHAN_CTRL_FMT_TYPE, true); 102 103 return regmap_update_bits(st->regmap, ADI_AXI_REG_CHAN_CTRL(chan), 104 ADI_AXI_REG_CHAN_CTRL_FMT_MASK, val); 105 } 106 107 static int axi_adc_chan_enable(struct iio_backend *back, unsigned int chan) 108 { 109 struct adi_axi_adc_state *st = iio_backend_get_priv(back); 110 111 return regmap_set_bits(st->regmap, ADI_AXI_REG_CHAN_CTRL(chan), 112 ADI_AXI_REG_CHAN_CTRL_ENABLE); 113 } 114 115 static int axi_adc_chan_disable(struct iio_backend *back, unsigned int chan) 116 { 117 struct adi_axi_adc_state *st = iio_backend_get_priv(back); 118 119 return regmap_clear_bits(st->regmap, ADI_AXI_REG_CHAN_CTRL(chan), 120 ADI_AXI_REG_CHAN_CTRL_ENABLE); 121 } 122 123 static struct iio_buffer *axi_adc_request_buffer(struct iio_backend *back, 124 struct iio_dev *indio_dev) 125 { 126 struct adi_axi_adc_state *st = iio_backend_get_priv(back); 127 const char *dma_name; 128 129 if (device_property_read_string(st->dev, "dma-names", &dma_name)) 130 dma_name = "rx"; 131 132 return iio_dmaengine_buffer_setup(st->dev, indio_dev, dma_name); 133 } 134 135 static void axi_adc_free_buffer(struct iio_backend *back, 136 struct iio_buffer *buffer) 137 { 138 iio_dmaengine_buffer_free(buffer); 139 } 140 141 static const struct regmap_config axi_adc_regmap_config = { 142 .val_bits = 32, 143 .reg_bits = 32, 144 .reg_stride = 4, 145 .max_register = 0x0800, 146 }; 147 148 static const struct iio_backend_ops adi_axi_adc_generic = { 149 .enable = axi_adc_enable, 150 .disable = axi_adc_disable, 151 .data_format_set = axi_adc_data_format_set, 152 .chan_enable = axi_adc_chan_enable, 153 .chan_disable = axi_adc_chan_disable, 154 .request_buffer = axi_adc_request_buffer, 155 .free_buffer = axi_adc_free_buffer, 156 }; 157 158 static int adi_axi_adc_probe(struct platform_device *pdev) 159 { 160 const unsigned int *expected_ver; 161 struct adi_axi_adc_state *st; 162 void __iomem *base; 163 unsigned int ver; 164 int ret; 165 166 st = devm_kzalloc(&pdev->dev, sizeof(*st), GFP_KERNEL); 167 if (!st) 168 return -ENOMEM; 169 170 base = devm_platform_ioremap_resource(pdev, 0); 171 if (IS_ERR(base)) 172 return PTR_ERR(base); 173 174 st->dev = &pdev->dev; 175 st->regmap = devm_regmap_init_mmio(&pdev->dev, base, 176 &axi_adc_regmap_config); 177 if (IS_ERR(st->regmap)) 178 return PTR_ERR(st->regmap); 179 180 expected_ver = device_get_match_data(&pdev->dev); 181 if (!expected_ver) 182 return -ENODEV; 183 184 /* 185 * Force disable the core. Up to the frontend to enable us. And we can 186 * still read/write registers... 187 */ 188 ret = regmap_write(st->regmap, ADI_AXI_REG_RSTN, 0); 189 if (ret) 190 return ret; 191 192 ret = regmap_read(st->regmap, ADI_AXI_REG_VERSION, &ver); 193 if (ret) 194 return ret; 195 196 if (ADI_AXI_PCORE_VER_MAJOR(ver) != ADI_AXI_PCORE_VER_MAJOR(*expected_ver)) { 197 dev_err(&pdev->dev, 198 "Major version mismatch. Expected %d.%.2d.%c, Reported %d.%.2d.%c\n", 199 ADI_AXI_PCORE_VER_MAJOR(*expected_ver), 200 ADI_AXI_PCORE_VER_MINOR(*expected_ver), 201 ADI_AXI_PCORE_VER_PATCH(*expected_ver), 202 ADI_AXI_PCORE_VER_MAJOR(ver), 203 ADI_AXI_PCORE_VER_MINOR(ver), 204 ADI_AXI_PCORE_VER_PATCH(ver)); 205 return -ENODEV; 206 } 207 208 ret = devm_iio_backend_register(&pdev->dev, &adi_axi_adc_generic, st); 209 if (ret) 210 return ret; 211 212 dev_info(&pdev->dev, "AXI ADC IP core (%d.%.2d.%c) probed\n", 213 ADI_AXI_PCORE_VER_MAJOR(ver), 214 ADI_AXI_PCORE_VER_MINOR(ver), 215 ADI_AXI_PCORE_VER_PATCH(ver)); 216 217 return 0; 218 } 219 220 static unsigned int adi_axi_adc_10_0_a_info = ADI_AXI_PCORE_VER(10, 0, 'a'); 221 222 /* Match table for of_platform binding */ 223 static const struct of_device_id adi_axi_adc_of_match[] = { 224 { .compatible = "adi,axi-adc-10.0.a", .data = &adi_axi_adc_10_0_a_info }, 225 { /* end of list */ } 226 }; 227 MODULE_DEVICE_TABLE(of, adi_axi_adc_of_match); 228 229 static struct platform_driver adi_axi_adc_driver = { 230 .driver = { 231 .name = KBUILD_MODNAME, 232 .of_match_table = adi_axi_adc_of_match, 233 }, 234 .probe = adi_axi_adc_probe, 235 }; 236 module_platform_driver(adi_axi_adc_driver); 237 238 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>"); 239 MODULE_DESCRIPTION("Analog Devices Generic AXI ADC IP core driver"); 240 MODULE_LICENSE("GPL v2"); 241 MODULE_IMPORT_NS(IIO_DMAENGINE_BUFFER); 242 MODULE_IMPORT_NS(IIO_BACKEND); 243