1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * GPIO library for the ACCES IDIO-16 family 4 * Copyright (C) 2022 William Breathitt Gray 5 */ 6 #include <linux/bitmap.h> 7 #include <linux/device.h> 8 #include <linux/err.h> 9 #include <linux/export.h> 10 #include <linux/gpio/regmap.h> 11 #include <linux/io.h> 12 #include <linux/module.h> 13 #include <linux/regmap.h> 14 #include <linux/spinlock.h> 15 #include <linux/types.h> 16 17 #include "gpio-idio-16.h" 18 19 #define DEFAULT_SYMBOL_NAMESPACE GPIO_IDIO_16 20 21 #define IDIO_16_DAT_BASE 0x0 22 #define IDIO_16_OUT_BASE IDIO_16_DAT_BASE 23 #define IDIO_16_IN_BASE (IDIO_16_DAT_BASE + 1) 24 #define IDIO_16_CLEAR_INTERRUPT 0x1 25 #define IDIO_16_ENABLE_IRQ 0x2 26 #define IDIO_16_DEACTIVATE_INPUT_FILTERS 0x3 27 #define IDIO_16_DISABLE_IRQ IDIO_16_ENABLE_IRQ 28 #define IDIO_16_INTERRUPT_STATUS 0x6 29 30 #define IDIO_16_NGPIO 32 31 #define IDIO_16_NGPIO_PER_REG 8 32 #define IDIO_16_REG_STRIDE 4 33 34 struct idio_16_data { 35 struct regmap *map; 36 unsigned int irq_mask; 37 }; 38 39 static int idio_16_handle_mask_sync(const int index, const unsigned int mask_buf_def, 40 const unsigned int mask_buf, void *const irq_drv_data) 41 { 42 struct idio_16_data *const data = irq_drv_data; 43 const unsigned int prev_mask = data->irq_mask; 44 int err; 45 unsigned int val; 46 47 /* exit early if no change since the previous mask */ 48 if (mask_buf == prev_mask) 49 return 0; 50 51 /* remember the current mask for the next mask sync */ 52 data->irq_mask = mask_buf; 53 54 /* if all previously masked, enable interrupts when unmasking */ 55 if (prev_mask == mask_buf_def) { 56 err = regmap_write(data->map, IDIO_16_CLEAR_INTERRUPT, 0x00); 57 if (err) 58 return err; 59 return regmap_read(data->map, IDIO_16_ENABLE_IRQ, &val); 60 } 61 62 /* if all are currently masked, disable interrupts */ 63 if (mask_buf == mask_buf_def) 64 return regmap_write(data->map, IDIO_16_DISABLE_IRQ, 0x00); 65 66 return 0; 67 } 68 69 static int idio_16_reg_mask_xlate(struct gpio_regmap *const gpio, const unsigned int base, 70 const unsigned int offset, unsigned int *const reg, 71 unsigned int *const mask) 72 { 73 unsigned int stride; 74 75 /* Input lines start at GPIO 16 */ 76 if (offset < 16) { 77 stride = offset / IDIO_16_NGPIO_PER_REG; 78 *reg = IDIO_16_OUT_BASE + stride * IDIO_16_REG_STRIDE; 79 } else { 80 stride = (offset - 16) / IDIO_16_NGPIO_PER_REG; 81 *reg = IDIO_16_IN_BASE + stride * IDIO_16_REG_STRIDE; 82 } 83 84 *mask = BIT(offset % IDIO_16_NGPIO_PER_REG); 85 86 return 0; 87 } 88 89 static const char *idio_16_names[IDIO_16_NGPIO] = { 90 "OUT0", "OUT1", "OUT2", "OUT3", "OUT4", "OUT5", "OUT6", "OUT7", 91 "OUT8", "OUT9", "OUT10", "OUT11", "OUT12", "OUT13", "OUT14", "OUT15", 92 "IIN0", "IIN1", "IIN2", "IIN3", "IIN4", "IIN5", "IIN6", "IIN7", 93 "IIN8", "IIN9", "IIN10", "IIN11", "IIN12", "IIN13", "IIN14", "IIN15", 94 }; 95 96 /** 97 * devm_idio_16_regmap_register - Register an IDIO-16 GPIO device 98 * @dev: device that is registering this IDIO-16 GPIO device 99 * @config: configuration for idio_16_regmap_config 100 * 101 * Registers an IDIO-16 GPIO device. Returns 0 on success and negative error number on failure. 102 */ 103 int devm_idio_16_regmap_register(struct device *const dev, 104 const struct idio_16_regmap_config *const config) 105 { 106 struct gpio_regmap_config gpio_config = {}; 107 int err; 108 struct idio_16_data *data; 109 struct regmap_irq_chip *chip; 110 struct regmap_irq_chip_data *chip_data; 111 112 if (!config->parent) 113 return -EINVAL; 114 115 if (!config->map) 116 return -EINVAL; 117 118 if (!config->regmap_irqs) 119 return -EINVAL; 120 121 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 122 if (!data) 123 return -ENOMEM; 124 data->map = config->map; 125 126 chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL); 127 if (!chip) 128 return -ENOMEM; 129 130 chip->name = dev_name(dev); 131 chip->status_base = IDIO_16_INTERRUPT_STATUS; 132 chip->mask_base = IDIO_16_ENABLE_IRQ; 133 chip->ack_base = IDIO_16_CLEAR_INTERRUPT; 134 chip->no_status = config->no_status; 135 chip->num_regs = 1; 136 chip->irqs = config->regmap_irqs; 137 chip->num_irqs = config->num_regmap_irqs; 138 chip->handle_mask_sync = idio_16_handle_mask_sync; 139 chip->irq_drv_data = data; 140 141 /* Disable IRQ to prevent spurious interrupts before we're ready */ 142 err = regmap_write(data->map, IDIO_16_DISABLE_IRQ, 0x00); 143 if (err) 144 return err; 145 146 err = devm_regmap_add_irq_chip(dev, data->map, config->irq, 0, 0, chip, &chip_data); 147 if (err) 148 return dev_err_probe(dev, err, "IRQ registration failed\n"); 149 150 if (config->filters) { 151 /* Deactivate input filters */ 152 err = regmap_write(data->map, IDIO_16_DEACTIVATE_INPUT_FILTERS, 0x00); 153 if (err) 154 return err; 155 } 156 157 gpio_config.parent = config->parent; 158 gpio_config.regmap = data->map; 159 gpio_config.ngpio = IDIO_16_NGPIO; 160 gpio_config.names = idio_16_names; 161 gpio_config.reg_dat_base = GPIO_REGMAP_ADDR(IDIO_16_DAT_BASE); 162 gpio_config.reg_set_base = GPIO_REGMAP_ADDR(IDIO_16_DAT_BASE); 163 gpio_config.ngpio_per_reg = IDIO_16_NGPIO_PER_REG; 164 gpio_config.reg_stride = IDIO_16_REG_STRIDE; 165 gpio_config.irq_domain = regmap_irq_get_domain(chip_data); 166 gpio_config.reg_mask_xlate = idio_16_reg_mask_xlate; 167 168 return PTR_ERR_OR_ZERO(devm_gpio_regmap_register(dev, &gpio_config)); 169 } 170 EXPORT_SYMBOL_GPL(devm_idio_16_regmap_register); 171 172 /** 173 * idio_16_get - get signal value at signal offset 174 * @reg: ACCES IDIO-16 device registers 175 * @state: ACCES IDIO-16 device state 176 * @offset: offset of signal to get 177 * 178 * Returns the signal value (0=low, 1=high) for the signal at @offset. 179 */ 180 int idio_16_get(struct idio_16 __iomem *const reg, 181 struct idio_16_state *const state, const unsigned long offset) 182 { 183 const unsigned long mask = BIT(offset); 184 185 if (offset < IDIO_16_NOUT) 186 return test_bit(offset, state->out_state); 187 188 if (offset < 24) 189 return !!(ioread8(®->in0_7) & (mask >> IDIO_16_NOUT)); 190 191 if (offset < 32) 192 return !!(ioread8(®->in8_15) & (mask >> 24)); 193 194 return -EINVAL; 195 } 196 EXPORT_SYMBOL_GPL(idio_16_get); 197 198 /** 199 * idio_16_get_multiple - get multiple signal values at multiple signal offsets 200 * @reg: ACCES IDIO-16 device registers 201 * @state: ACCES IDIO-16 device state 202 * @mask: mask of signals to get 203 * @bits: bitmap to store signal values 204 * 205 * Stores in @bits the values (0=low, 1=high) for the signals defined by @mask. 206 */ 207 void idio_16_get_multiple(struct idio_16 __iomem *const reg, 208 struct idio_16_state *const state, 209 const unsigned long *const mask, 210 unsigned long *const bits) 211 { 212 unsigned long flags; 213 const unsigned long out_mask = GENMASK(IDIO_16_NOUT - 1, 0); 214 215 spin_lock_irqsave(&state->lock, flags); 216 217 bitmap_replace(bits, bits, state->out_state, &out_mask, IDIO_16_NOUT); 218 if (*mask & GENMASK(23, 16)) 219 bitmap_set_value8(bits, ioread8(®->in0_7), 16); 220 if (*mask & GENMASK(31, 24)) 221 bitmap_set_value8(bits, ioread8(®->in8_15), 24); 222 223 spin_unlock_irqrestore(&state->lock, flags); 224 } 225 EXPORT_SYMBOL_GPL(idio_16_get_multiple); 226 227 /** 228 * idio_16_set - set signal value at signal offset 229 * @reg: ACCES IDIO-16 device registers 230 * @state: ACCES IDIO-16 device state 231 * @offset: offset of signal to set 232 * @value: value of signal to set 233 * 234 * Assigns output @value for the signal at @offset. 235 */ 236 void idio_16_set(struct idio_16 __iomem *const reg, 237 struct idio_16_state *const state, const unsigned long offset, 238 const unsigned long value) 239 { 240 unsigned long flags; 241 242 if (offset >= IDIO_16_NOUT) 243 return; 244 245 spin_lock_irqsave(&state->lock, flags); 246 247 __assign_bit(offset, state->out_state, value); 248 if (offset < 8) 249 iowrite8(bitmap_get_value8(state->out_state, 0), ®->out0_7); 250 else 251 iowrite8(bitmap_get_value8(state->out_state, 8), ®->out8_15); 252 253 spin_unlock_irqrestore(&state->lock, flags); 254 } 255 EXPORT_SYMBOL_GPL(idio_16_set); 256 257 /** 258 * idio_16_set_multiple - set signal values at multiple signal offsets 259 * @reg: ACCES IDIO-16 device registers 260 * @state: ACCES IDIO-16 device state 261 * @mask: mask of signals to set 262 * @bits: bitmap of signal output values 263 * 264 * Assigns output values defined by @bits for the signals defined by @mask. 265 */ 266 void idio_16_set_multiple(struct idio_16 __iomem *const reg, 267 struct idio_16_state *const state, 268 const unsigned long *const mask, 269 const unsigned long *const bits) 270 { 271 unsigned long flags; 272 273 spin_lock_irqsave(&state->lock, flags); 274 275 bitmap_replace(state->out_state, state->out_state, bits, mask, 276 IDIO_16_NOUT); 277 if (*mask & GENMASK(7, 0)) 278 iowrite8(bitmap_get_value8(state->out_state, 0), ®->out0_7); 279 if (*mask & GENMASK(15, 8)) 280 iowrite8(bitmap_get_value8(state->out_state, 8), ®->out8_15); 281 282 spin_unlock_irqrestore(&state->lock, flags); 283 } 284 EXPORT_SYMBOL_GPL(idio_16_set_multiple); 285 286 /** 287 * idio_16_state_init - initialize idio_16_state structure 288 * @state: ACCES IDIO-16 device state 289 * 290 * Initializes the ACCES IDIO-16 device @state for use in idio-16 library 291 * functions. 292 */ 293 void idio_16_state_init(struct idio_16_state *const state) 294 { 295 spin_lock_init(&state->lock); 296 } 297 EXPORT_SYMBOL_GPL(idio_16_state_init); 298 299 MODULE_AUTHOR("William Breathitt Gray"); 300 MODULE_DESCRIPTION("ACCES IDIO-16 GPIO Library"); 301 MODULE_LICENSE("GPL"); 302