1 /* 2 * Register map access API - SPI support 3 * 4 * Copyright 2011 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 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13 #include <linux/regmap.h> 14 #include <linux/spi/spi.h> 15 #include <linux/module.h> 16 17 #include "internal.h" 18 19 struct regmap_async_spi { 20 struct regmap_async core; 21 struct spi_message m; 22 struct spi_transfer t[2]; 23 }; 24 25 static void regmap_spi_complete(void *data) 26 { 27 struct regmap_async_spi *async = data; 28 29 regmap_async_complete_cb(&async->core, async->m.status); 30 } 31 32 static int regmap_spi_write(void *context, const void *data, size_t count) 33 { 34 struct device *dev = context; 35 struct spi_device *spi = to_spi_device(dev); 36 37 return spi_write(spi, data, count); 38 } 39 40 static int regmap_spi_gather_write(void *context, 41 const void *reg, size_t reg_len, 42 const void *val, size_t val_len) 43 { 44 struct device *dev = context; 45 struct spi_device *spi = to_spi_device(dev); 46 struct spi_message m; 47 struct spi_transfer t[2] = { { .tx_buf = reg, .len = reg_len, }, 48 { .tx_buf = val, .len = val_len, }, }; 49 50 spi_message_init(&m); 51 spi_message_add_tail(&t[0], &m); 52 spi_message_add_tail(&t[1], &m); 53 54 return spi_sync(spi, &m); 55 } 56 57 static int regmap_spi_async_write(void *context, 58 const void *reg, size_t reg_len, 59 const void *val, size_t val_len, 60 struct regmap_async *a) 61 { 62 struct regmap_async_spi *async = container_of(a, 63 struct regmap_async_spi, 64 core); 65 struct device *dev = context; 66 struct spi_device *spi = to_spi_device(dev); 67 68 async->t[0].tx_buf = reg; 69 async->t[0].len = reg_len; 70 async->t[1].tx_buf = val; 71 async->t[1].len = val_len; 72 73 spi_message_init(&async->m); 74 spi_message_add_tail(&async->t[0], &async->m); 75 if (val) 76 spi_message_add_tail(&async->t[1], &async->m); 77 78 async->m.complete = regmap_spi_complete; 79 async->m.context = async; 80 81 return spi_async(spi, &async->m); 82 } 83 84 static struct regmap_async *regmap_spi_async_alloc(void) 85 { 86 struct regmap_async_spi *async_spi; 87 88 async_spi = kzalloc(sizeof(*async_spi), GFP_KERNEL); 89 if (!async_spi) 90 return NULL; 91 92 return &async_spi->core; 93 } 94 95 static int regmap_spi_read(void *context, 96 const void *reg, size_t reg_size, 97 void *val, size_t val_size) 98 { 99 struct device *dev = context; 100 struct spi_device *spi = to_spi_device(dev); 101 102 return spi_write_then_read(spi, reg, reg_size, val, val_size); 103 } 104 105 static const struct regmap_bus regmap_spi = { 106 .write = regmap_spi_write, 107 .gather_write = regmap_spi_gather_write, 108 .async_write = regmap_spi_async_write, 109 .async_alloc = regmap_spi_async_alloc, 110 .read = regmap_spi_read, 111 .read_flag_mask = 0x80, 112 .reg_format_endian_default = REGMAP_ENDIAN_BIG, 113 .val_format_endian_default = REGMAP_ENDIAN_BIG, 114 }; 115 116 struct regmap *__regmap_init_spi(struct spi_device *spi, 117 const struct regmap_config *config, 118 struct lock_class_key *lock_key, 119 const char *lock_name) 120 { 121 return __regmap_init(&spi->dev, ®map_spi, &spi->dev, config, 122 lock_key, lock_name); 123 } 124 EXPORT_SYMBOL_GPL(__regmap_init_spi); 125 126 struct regmap *__devm_regmap_init_spi(struct spi_device *spi, 127 const struct regmap_config *config, 128 struct lock_class_key *lock_key, 129 const char *lock_name) 130 { 131 return __devm_regmap_init(&spi->dev, ®map_spi, &spi->dev, config, 132 lock_key, lock_name); 133 } 134 EXPORT_SYMBOL_GPL(__devm_regmap_init_spi); 135 136 MODULE_LICENSE("GPL"); 137