diff options
Diffstat (limited to 'ANDROID_3.4.5/drivers/base/regmap')
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/Kconfig | 18 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/Makefile | 6 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/internal.h | 130 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/regcache-lzo.c | 379 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/regcache-rbtree.c | 430 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/regcache.c | 491 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/regmap-debugfs.c | 286 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/regmap-i2c.c | 131 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/regmap-irq.c | 303 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/regmap-spi.c | 90 | ||||
| -rw-r--r-- | ANDROID_3.4.5/drivers/base/regmap/regmap.c | 936 |
11 files changed, 0 insertions, 3200 deletions
diff --git a/ANDROID_3.4.5/drivers/base/regmap/Kconfig b/ANDROID_3.4.5/drivers/base/regmap/Kconfig deleted file mode 100644 index 0f6c7fb4..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/Kconfig +++ /dev/null @@ -1,18 +0,0 @@ -# Generic register map support. There are no user servicable options here, -# this is an API intended to be used by other kernel subsystems. These -# subsystems should select the appropriate symbols. - -config REGMAP - default y if (REGMAP_I2C || REGMAP_SPI) - select LZO_COMPRESS - select LZO_DECOMPRESS - bool - -config REGMAP_I2C - tristate - -config REGMAP_SPI - tristate - -config REGMAP_IRQ - bool diff --git a/ANDROID_3.4.5/drivers/base/regmap/Makefile b/ANDROID_3.4.5/drivers/base/regmap/Makefile deleted file mode 100644 index defd5796..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/Makefile +++ /dev/null @@ -1,6 +0,0 @@ -obj-$(CONFIG_REGMAP) += regmap.o regcache.o -obj-$(CONFIG_REGMAP) += regcache-rbtree.o regcache-lzo.o -obj-$(CONFIG_DEBUG_FS) += regmap-debugfs.o -obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o -obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o -obj-$(CONFIG_REGMAP_IRQ) += regmap-irq.o diff --git a/ANDROID_3.4.5/drivers/base/regmap/internal.h b/ANDROID_3.4.5/drivers/base/regmap/internal.h deleted file mode 100644 index fcafc5b2..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/internal.h +++ /dev/null @@ -1,130 +0,0 @@ -/* - * Register map access API internal header - * - * Copyright 2011 Wolfson Microelectronics plc - * - * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#ifndef _REGMAP_INTERNAL_H -#define _REGMAP_INTERNAL_H - -#include <linux/regmap.h> -#include <linux/fs.h> - -struct regmap; -struct regcache_ops; - -struct regmap_format { - size_t buf_size; - size_t reg_bytes; - size_t pad_bytes; - size_t val_bytes; - void (*format_write)(struct regmap *map, - unsigned int reg, unsigned int val); - void (*format_reg)(void *buf, unsigned int reg); - void (*format_val)(void *buf, unsigned int val); - unsigned int (*parse_val)(void *buf); -}; - -struct regmap { - struct mutex lock; - - struct device *dev; /* Device we do I/O on */ - void *work_buf; /* Scratch buffer used to format I/O */ - struct regmap_format format; /* Buffer format */ - const struct regmap_bus *bus; - -#ifdef CONFIG_DEBUG_FS - struct dentry *debugfs; -#endif - - unsigned int max_register; - bool (*writeable_reg)(struct device *dev, unsigned int reg); - bool (*readable_reg)(struct device *dev, unsigned int reg); - bool (*volatile_reg)(struct device *dev, unsigned int reg); - bool (*precious_reg)(struct device *dev, unsigned int reg); - - u8 read_flag_mask; - u8 write_flag_mask; - - /* regcache specific members */ - const struct regcache_ops *cache_ops; - enum regcache_type cache_type; - - /* number of bytes in reg_defaults_raw */ - unsigned int cache_size_raw; - /* number of bytes per word in reg_defaults_raw */ - unsigned int cache_word_size; - /* number of entries in reg_defaults */ - unsigned int num_reg_defaults; - /* number of entries in reg_defaults_raw */ - unsigned int num_reg_defaults_raw; - - /* if set, only the cache is modified not the HW */ - u32 cache_only; - /* if set, only the HW is modified not the cache */ - u32 cache_bypass; - /* if set, remember to free reg_defaults_raw */ - bool cache_free; - - struct reg_default *reg_defaults; - const void *reg_defaults_raw; - void *cache; - u32 cache_dirty; - - struct reg_default *patch; - int patch_regs; -}; - -struct regcache_ops { - const char *name; - enum regcache_type type; - int (*init)(struct regmap *map); - int (*exit)(struct regmap *map); - int (*read)(struct regmap *map, unsigned int reg, unsigned int *value); - int (*write)(struct regmap *map, unsigned int reg, unsigned int value); - int (*sync)(struct regmap *map, unsigned int min, unsigned int max); -}; - -bool regmap_writeable(struct regmap *map, unsigned int reg); -bool regmap_readable(struct regmap *map, unsigned int reg); -bool regmap_volatile(struct regmap *map, unsigned int reg); -bool regmap_precious(struct regmap *map, unsigned int reg); - -int _regmap_write(struct regmap *map, unsigned int reg, - unsigned int val); - -#ifdef CONFIG_DEBUG_FS -extern void regmap_debugfs_initcall(void); -extern void regmap_debugfs_init(struct regmap *map); -extern void regmap_debugfs_exit(struct regmap *map); -#else -static inline void regmap_debugfs_initcall(void) { } -static inline void regmap_debugfs_init(struct regmap *map) { } -static inline void regmap_debugfs_exit(struct regmap *map) { } -#endif - -/* regcache core declarations */ -int regcache_init(struct regmap *map, const struct regmap_config *config); -void regcache_exit(struct regmap *map); -int regcache_read(struct regmap *map, - unsigned int reg, unsigned int *value); -int regcache_write(struct regmap *map, - unsigned int reg, unsigned int value); -int regcache_sync(struct regmap *map); - -unsigned int regcache_get_val(const void *base, unsigned int idx, - unsigned int word_size); -bool regcache_set_val(void *base, unsigned int idx, - unsigned int val, unsigned int word_size); -int regcache_lookup_reg(struct regmap *map, unsigned int reg); - -extern struct regcache_ops regcache_rbtree_ops; -extern struct regcache_ops regcache_lzo_ops; - -#endif diff --git a/ANDROID_3.4.5/drivers/base/regmap/regcache-lzo.c b/ANDROID_3.4.5/drivers/base/regmap/regcache-lzo.c deleted file mode 100644 index 483b06d4..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/regcache-lzo.c +++ /dev/null @@ -1,379 +0,0 @@ -/* - * Register cache access API - LZO caching support - * - * Copyright 2011 Wolfson Microelectronics plc - * - * Author: Dimitris Papastamos <dp@opensource.wolfsonmicro.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include <linux/slab.h> -#include <linux/device.h> -#include <linux/lzo.h> - -#include "internal.h" - -static int regcache_lzo_exit(struct regmap *map); - -struct regcache_lzo_ctx { - void *wmem; - void *dst; - const void *src; - size_t src_len; - size_t dst_len; - size_t decompressed_size; - unsigned long *sync_bmp; - int sync_bmp_nbits; -}; - -#define LZO_BLOCK_NUM 8 -static int regcache_lzo_block_count(struct regmap *map) -{ - return LZO_BLOCK_NUM; -} - -static int regcache_lzo_prepare(struct regcache_lzo_ctx *lzo_ctx) -{ - lzo_ctx->wmem = kmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL); - if (!lzo_ctx->wmem) - return -ENOMEM; - return 0; -} - -static int regcache_lzo_compress(struct regcache_lzo_ctx *lzo_ctx) -{ - size_t compress_size; - int ret; - - ret = lzo1x_1_compress(lzo_ctx->src, lzo_ctx->src_len, - lzo_ctx->dst, &compress_size, lzo_ctx->wmem); - if (ret != LZO_E_OK || compress_size > lzo_ctx->dst_len) - return -EINVAL; - lzo_ctx->dst_len = compress_size; - return 0; -} - -static int regcache_lzo_decompress(struct regcache_lzo_ctx *lzo_ctx) -{ - size_t dst_len; - int ret; - - dst_len = lzo_ctx->dst_len; - ret = lzo1x_decompress_safe(lzo_ctx->src, lzo_ctx->src_len, - lzo_ctx->dst, &dst_len); - if (ret != LZO_E_OK || dst_len != lzo_ctx->dst_len) - return -EINVAL; - return 0; -} - -static int regcache_lzo_compress_cache_block(struct regmap *map, - struct regcache_lzo_ctx *lzo_ctx) -{ - int ret; - - lzo_ctx->dst_len = lzo1x_worst_compress(PAGE_SIZE); - lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL); - if (!lzo_ctx->dst) { - lzo_ctx->dst_len = 0; - return -ENOMEM; - } - - ret = regcache_lzo_compress(lzo_ctx); - if (ret < 0) - return ret; - return 0; -} - -static int regcache_lzo_decompress_cache_block(struct regmap *map, - struct regcache_lzo_ctx *lzo_ctx) -{ - int ret; - - lzo_ctx->dst_len = lzo_ctx->decompressed_size; - lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL); - if (!lzo_ctx->dst) { - lzo_ctx->dst_len = 0; - return -ENOMEM; - } - - ret = regcache_lzo_decompress(lzo_ctx); - if (ret < 0) - return ret; - return 0; -} - -static inline int regcache_lzo_get_blkindex(struct regmap *map, - unsigned int reg) -{ - return (reg * map->cache_word_size) / - DIV_ROUND_UP(map->cache_size_raw, - regcache_lzo_block_count(map)); -} - -static inline int regcache_lzo_get_blkpos(struct regmap *map, - unsigned int reg) -{ - return reg % (DIV_ROUND_UP(map->cache_size_raw, - regcache_lzo_block_count(map)) / - map->cache_word_size); -} - -static inline int regcache_lzo_get_blksize(struct regmap *map) -{ - return DIV_ROUND_UP(map->cache_size_raw, - regcache_lzo_block_count(map)); -} - -static int regcache_lzo_init(struct regmap *map) -{ - struct regcache_lzo_ctx **lzo_blocks; - size_t bmp_size; - int ret, i, blksize, blkcount; - const char *p, *end; - unsigned long *sync_bmp; - - ret = 0; - - blkcount = regcache_lzo_block_count(map); - map->cache = kzalloc(blkcount * sizeof *lzo_blocks, - GFP_KERNEL); - if (!map->cache) - return -ENOMEM; - lzo_blocks = map->cache; - - /* - * allocate a bitmap to be used when syncing the cache with - * the hardware. Each time a register is modified, the corresponding - * bit is set in the bitmap, so we know that we have to sync - * that register. - */ - bmp_size = map->num_reg_defaults_raw; - sync_bmp = kmalloc(BITS_TO_LONGS(bmp_size) * sizeof(long), - GFP_KERNEL); - if (!sync_bmp) { - ret = -ENOMEM; - goto err; - } - bitmap_zero(sync_bmp, bmp_size); - - /* allocate the lzo blocks and initialize them */ - for (i = 0; i < blkcount; i++) { - lzo_blocks[i] = kzalloc(sizeof **lzo_blocks, - GFP_KERNEL); - if (!lzo_blocks[i]) { - kfree(sync_bmp); - ret = -ENOMEM; - goto err; - } - lzo_blocks[i]->sync_bmp = sync_bmp; - lzo_blocks[i]->sync_bmp_nbits = bmp_size; - /* alloc the working space for the compressed block */ - ret = regcache_lzo_prepare(lzo_blocks[i]); - if (ret < 0) - goto err; - } - - blksize = regcache_lzo_get_blksize(map); - p = map->reg_defaults_raw; - end = map->reg_defaults_raw + map->cache_size_raw; - /* compress the register map and fill the lzo blocks */ - for (i = 0; i < blkcount; i++, p += blksize) { - lzo_blocks[i]->src = p; - if (p + blksize > end) - lzo_blocks[i]->src_len = end - p; - else - lzo_blocks[i]->src_len = blksize; - ret = regcache_lzo_compress_cache_block(map, - lzo_blocks[i]); - if (ret < 0) - goto err; - lzo_blocks[i]->decompressed_size = - lzo_blocks[i]->src_len; - } - - return 0; -err: - regcache_lzo_exit(map); - return ret; -} - -static int regcache_lzo_exit(struct regmap *map) -{ - struct regcache_lzo_ctx **lzo_blocks; - int i, blkcount; - - lzo_blocks = map->cache; - if (!lzo_blocks) - return 0; - - blkcount = regcache_lzo_block_count(map); - /* - * the pointer to the bitmap used for syncing the cache - * is shared amongst all lzo_blocks. Ensure it is freed - * only once. - */ - if (lzo_blocks[0]) - kfree(lzo_blocks[0]->sync_bmp); - for (i = 0; i < blkcount; i++) { - if (lzo_blocks[i]) { - kfree(lzo_blocks[i]->wmem); - kfree(lzo_blocks[i]->dst); - } - /* each lzo_block is a pointer returned by kmalloc or NULL */ - kfree(lzo_blocks[i]); - } - kfree(lzo_blocks); - map->cache = NULL; - return 0; -} - -static int regcache_lzo_read(struct regmap *map, - unsigned int reg, unsigned int *value) -{ - struct regcache_lzo_ctx *lzo_block, **lzo_blocks; - int ret, blkindex, blkpos; - size_t blksize, tmp_dst_len; - void *tmp_dst; - - /* index of the compressed lzo block */ - blkindex = regcache_lzo_get_blkindex(map, reg); - /* register index within the decompressed block */ - blkpos = regcache_lzo_get_blkpos(map, reg); - /* size of the compressed block */ - blksize = regcache_lzo_get_blksize(map); - lzo_blocks = map->cache; - lzo_block = lzo_blocks[blkindex]; - - /* save the pointer and length of the compressed block */ - tmp_dst = lzo_block->dst; - tmp_dst_len = lzo_block->dst_len; - - /* prepare the source to be the compressed block */ - lzo_block->src = lzo_block->dst; - lzo_block->src_len = lzo_block->dst_len; - - /* decompress the block */ - ret = regcache_lzo_decompress_cache_block(map, lzo_block); - if (ret >= 0) - /* fetch the value from the cache */ - *value = regcache_get_val(lzo_block->dst, blkpos, - map->cache_word_size); - - kfree(lzo_block->dst); - /* restore the pointer and length of the compressed block */ - lzo_block->dst = tmp_dst; - lzo_block->dst_len = tmp_dst_len; - - return ret; -} - -static int regcache_lzo_write(struct regmap *map, - unsigned int reg, unsigned int value) -{ - struct regcache_lzo_ctx *lzo_block, **lzo_blocks; - int ret, blkindex, blkpos; - size_t blksize, tmp_dst_len; - void *tmp_dst; - - /* index of the compressed lzo block */ - blkindex = regcache_lzo_get_blkindex(map, reg); - /* register index within the decompressed block */ - blkpos = regcache_lzo_get_blkpos(map, reg); - /* size of the compressed block */ - blksize = regcache_lzo_get_blksize(map); - lzo_blocks = map->cache; - lzo_block = lzo_blocks[blkindex]; - - /* save the pointer and length of the compressed block */ - tmp_dst = lzo_block->dst; - tmp_dst_len = lzo_block->dst_len; - - /* prepare the source to be the compressed block */ - lzo_block->src = lzo_block->dst; - lzo_block->src_len = lzo_block->dst_len; - - /* decompress the block */ - ret = regcache_lzo_decompress_cache_block(map, lzo_block); - if (ret < 0) { - kfree(lzo_block->dst); - goto out; - } - - /* write the new value to the cache */ - if (regcache_set_val(lzo_block->dst, blkpos, value, - map->cache_word_size)) { - kfree(lzo_block->dst); - goto out; - } - - /* prepare the source to be the decompressed block */ - lzo_block->src = lzo_block->dst; - lzo_block->src_len = lzo_block->dst_len; - - /* compress the block */ - ret = regcache_lzo_compress_cache_block(map, lzo_block); - if (ret < 0) { - kfree(lzo_block->dst); - kfree(lzo_block->src); - goto out; - } - - /* set the bit so we know we have to sync this register */ - set_bit(reg, lzo_block->sync_bmp); - kfree(tmp_dst); - kfree(lzo_block->src); - return 0; -out: - lzo_block->dst = tmp_dst; - lzo_block->dst_len = tmp_dst_len; - return ret; -} - -static int regcache_lzo_sync(struct regmap *map, unsigned int min, - unsigned int max) -{ - struct regcache_lzo_ctx **lzo_blocks; - unsigned int val; - int i; - int ret; - - lzo_blocks = map->cache; - i = min; - for_each_set_bit_from(i, lzo_blocks[0]->sync_bmp, - lzo_blocks[0]->sync_bmp_nbits) { - if (i > max) - continue; - - ret = regcache_read(map, i, &val); - if (ret) - return ret; - - /* Is this the hardware default? If so skip. */ - ret = regcache_lookup_reg(map, i); - if (ret > 0 && val == map->reg_defaults[ret].def) - continue; - - map->cache_bypass = 1; - ret = _regmap_write(map, i, val); - map->cache_bypass = 0; - if (ret) - return ret; - dev_dbg(map->dev, "Synced register %#x, value %#x\n", - i, val); - } - - return 0; -} - -struct regcache_ops regcache_lzo_ops = { - .type = REGCACHE_COMPRESSED, - .name = "lzo", - .init = regcache_lzo_init, - .exit = regcache_lzo_exit, - .read = regcache_lzo_read, - .write = regcache_lzo_write, - .sync = regcache_lzo_sync -}; diff --git a/ANDROID_3.4.5/drivers/base/regmap/regcache-rbtree.c b/ANDROID_3.4.5/drivers/base/regmap/regcache-rbtree.c deleted file mode 100644 index 92b779ee..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/regcache-rbtree.c +++ /dev/null @@ -1,430 +0,0 @@ -/* - * Register cache access API - rbtree caching support - * - * Copyright 2011 Wolfson Microelectronics plc - * - * Author: Dimitris Papastamos <dp@opensource.wolfsonmicro.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include <linux/slab.h> -#include <linux/device.h> -#include <linux/debugfs.h> -#include <linux/rbtree.h> -#include <linux/seq_file.h> - -#include "internal.h" - -static int regcache_rbtree_write(struct regmap *map, unsigned int reg, - unsigned int value); -static int regcache_rbtree_exit(struct regmap *map); - -struct regcache_rbtree_node { - /* the actual rbtree node holding this block */ - struct rb_node node; - /* base register handled by this block */ - unsigned int base_reg; - /* block of adjacent registers */ - void *block; - /* number of registers available in the block */ - unsigned int blklen; -} __attribute__ ((packed)); - -struct regcache_rbtree_ctx { - struct rb_root root; - struct regcache_rbtree_node *cached_rbnode; -}; - -static inline void regcache_rbtree_get_base_top_reg( - struct regcache_rbtree_node *rbnode, - unsigned int *base, unsigned int *top) -{ - *base = rbnode->base_reg; - *top = rbnode->base_reg + rbnode->blklen - 1; -} - -static unsigned int regcache_rbtree_get_register( - struct regcache_rbtree_node *rbnode, unsigned int idx, - unsigned int word_size) -{ - return regcache_get_val(rbnode->block, idx, word_size); -} - -static void regcache_rbtree_set_register(struct regcache_rbtree_node *rbnode, - unsigned int idx, unsigned int val, - unsigned int word_size) -{ - regcache_set_val(rbnode->block, idx, val, word_size); -} - -static struct regcache_rbtree_node *regcache_rbtree_lookup(struct regmap *map, - unsigned int reg) -{ - struct regcache_rbtree_ctx *rbtree_ctx = map->cache; - struct rb_node *node; - struct regcache_rbtree_node *rbnode; - unsigned int base_reg, top_reg; - - rbnode = rbtree_ctx->cached_rbnode; - if (rbnode) { - regcache_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg); - if (reg >= base_reg && reg <= top_reg) - return rbnode; - } - - node = rbtree_ctx->root.rb_node; - while (node) { - rbnode = container_of(node, struct regcache_rbtree_node, node); - regcache_rbtree_get_base_top_reg(rbnode, &base_reg, &top_reg); - if (reg >= base_reg && reg <= top_reg) { - rbtree_ctx->cached_rbnode = rbnode; - return rbnode; - } else if (reg > top_reg) { - node = node->rb_right; - } else if (reg < base_reg) { - node = node->rb_left; - } - } - - return NULL; -} - -static int regcache_rbtree_insert(struct rb_root *root, - struct regcache_rbtree_node *rbnode) -{ - struct rb_node **new, *parent; - struct regcache_rbtree_node *rbnode_tmp; - unsigned int base_reg_tmp, top_reg_tmp; - unsigned int base_reg; - - parent = NULL; - new = &root->rb_node; - while (*new) { - rbnode_tmp = container_of(*new, struct regcache_rbtree_node, - node); - /* base and top registers of the current rbnode */ - regcache_rbtree_get_base_top_reg(rbnode_tmp, &base_reg_tmp, - &top_reg_tmp); - /* base register of the rbnode to be added */ - base_reg = rbnode->base_reg; - parent = *new; - /* if this register has already been inserted, just return */ - if (base_reg >= base_reg_tmp && - base_reg <= top_reg_tmp) - return 0; - else if (base_reg > top_reg_tmp) - new = &((*new)->rb_right); - else if (base_reg < base_reg_tmp) - new = &((*new)->rb_left); - } - - /* insert the node into the rbtree */ - rb_link_node(&rbnode->node, parent, new); - rb_insert_color(&rbnode->node, root); - - return 1; -} - -#ifdef CONFIG_DEBUG_FS -static int rbtree_show(struct seq_file *s, void *ignored) -{ - struct regmap *map = s->private; - struct regcache_rbtree_ctx *rbtree_ctx = map->cache; - struct regcache_rbtree_node *n; - struct rb_node *node; - unsigned int base, top; - int nodes = 0; - int registers = 0; - int average; - - mutex_lock(&map->lock); - - for (node = rb_first(&rbtree_ctx->root); node != NULL; - node = rb_next(node)) { - n = container_of(node, struct regcache_rbtree_node, node); - - regcache_rbtree_get_base_top_reg(n, &base, &top); - seq_printf(s, "%x-%x (%d)\n", base, top, top - base + 1); - - nodes++; - registers += top - base + 1; - } - - if (nodes) - average = registers / nodes; - else - average = 0; - - seq_printf(s, "%d nodes, %d registers, average %d registers\n", - nodes, registers, average); - - mutex_unlock(&map->lock); - - return 0; -} - -static int rbtree_open(struct inode *inode, struct file *file) -{ - return single_open(file, rbtree_show, inode->i_private); -} - -static const struct file_operations rbtree_fops = { - .open = rbtree_open, - .read = seq_read, - .llseek = seq_lseek, - .release = single_release, -}; - -static void rbtree_debugfs_init(struct regmap *map) -{ - debugfs_create_file("rbtree", 0400, map->debugfs, map, &rbtree_fops); -} -#else -static void rbtree_debugfs_init(struct regmap *map) -{ -} -#endif - -static int regcache_rbtree_init(struct regmap *map) -{ - struct regcache_rbtree_ctx *rbtree_ctx; - int i; - int ret; - - map->cache = kmalloc(sizeof *rbtree_ctx, GFP_KERNEL); - if (!map->cache) - return -ENOMEM; - - rbtree_ctx = map->cache; - rbtree_ctx->root = RB_ROOT; - rbtree_ctx->cached_rbnode = NULL; - - for (i = 0; i < map->num_reg_defaults; i++) { - ret = regcache_rbtree_write(map, - map->reg_defaults[i].reg, - map->reg_defaults[i].def); - if (ret) - goto err; - } - - rbtree_debugfs_init(map); - - return 0; - -err: - regcache_rbtree_exit(map); - return ret; -} - -static int regcache_rbtree_exit(struct regmap *map) -{ - struct rb_node *next; - struct regcache_rbtree_ctx *rbtree_ctx; - struct regcache_rbtree_node *rbtree_node; - - /* if we've already been called then just return */ - rbtree_ctx = map->cache; - if (!rbtree_ctx) - return 0; - - /* free up the rbtree */ - next = rb_first(&rbtree_ctx->root); - while (next) { - rbtree_node = rb_entry(next, struct regcache_rbtree_node, node); - next = rb_next(&rbtree_node->node); - rb_erase(&rbtree_node->node, &rbtree_ctx->root); - kfree(rbtree_node->block); - kfree(rbtree_node); - } - - /* release the resources */ - kfree(map->cache); - map->cache = NULL; - - return 0; -} - -static int regcache_rbtree_read(struct regmap *map, - unsigned int reg, unsigned int *value) -{ - struct regcache_rbtree_node *rbnode; - unsigned int reg_tmp; - - rbnode = regcache_rbtree_lookup(map, reg); - if (rbnode) { - reg_tmp = reg - rbnode->base_reg; - *value = regcache_rbtree_get_register(rbnode, reg_tmp, - map->cache_word_size); - } else { - return -ENOENT; - } - - return 0; -} - - -static int regcache_rbtree_insert_to_block(struct regcache_rbtree_node *rbnode, - unsigned int pos, unsigned int reg, - unsigned int value, unsigned int word_size) -{ - u8 *blk; - - blk = krealloc(rbnode->block, - (rbnode->blklen + 1) * word_size, GFP_KERNEL); - if (!blk) - return -ENOMEM; - - /* insert the register value in the correct place in the rbnode block */ - memmove(blk + (pos + 1) * word_size, - blk + pos * word_size, - (rbnode->blklen - pos) * word_size); - - /* update the rbnode block, its size and the base register */ - rbnode->block = blk; - rbnode->blklen++; - if (!pos) - rbnode->base_reg = reg; - - regcache_rbtree_set_register(rbnode, pos, value, word_size); - return 0; -} - -static int regcache_rbtree_write(struct regmap *map, unsigned int reg, - unsigned int value) -{ - struct regcache_rbtree_ctx *rbtree_ctx; - struct regcache_rbtree_node *rbnode, *rbnode_tmp; - struct rb_node *node; - unsigned int val; - unsigned int reg_tmp; - unsigned int pos; - int i; - int ret; - - rbtree_ctx = map->cache; - /* if we can't locate it in the cached rbnode we'll have - * to traverse the rbtree looking for it. - */ - rbnode = regcache_rbtree_lookup(map, reg); - if (rbnode) { - reg_tmp = reg - rbnode->base_reg; - val = regcache_rbtree_get_register(rbnode, reg_tmp, - map->cache_word_size); - if (val == value) - return 0; - regcache_rbtree_set_register(rbnode, reg_tmp, value, - map->cache_word_size); - } else { - /* look for an adjacent register to the one we are about to add */ - for (node = rb_first(&rbtree_ctx->root); node; - node = rb_next(node)) { - rbnode_tmp = rb_entry(node, struct regcache_rbtree_node, node); - for (i = 0; i < rbnode_tmp->blklen; i++) { - reg_tmp = rbnode_tmp->base_reg + i; - if (abs(reg_tmp - reg) != 1) - continue; - /* decide where in the block to place our register */ - if (reg_tmp + 1 == reg) - pos = i + 1; - else - pos = i; - ret = regcache_rbtree_insert_to_block(rbnode_tmp, pos, - reg, value, - map->cache_word_size); - if (ret) - return ret; - rbtree_ctx->cached_rbnode = rbnode_tmp; - return 0; - } - } - /* we did not manage to find a place to insert it in an existing - * block so create a new rbnode with a single register in its block. - * This block will get populated further if any other adjacent - * registers get modified in the future. - */ - rbnode = kzalloc(sizeof *rbnode, GFP_KERNEL); - if (!rbnode) - return -ENOMEM; - rbnode->blklen = 1; - rbnode->base_reg = reg; - rbnode->block = kmalloc(rbnode->blklen * map->cache_word_size, - GFP_KERNEL); - if (!rbnode->block) { - kfree(rbnode); - return -ENOMEM; - } - regcache_rbtree_set_register(rbnode, 0, value, map->cache_word_size); - regcache_rbtree_insert(&rbtree_ctx->root, rbnode); - rbtree_ctx->cached_rbnode = rbnode; - } - - return 0; -} - -static int regcache_rbtree_sync(struct regmap *map, unsigned int min, - unsigned int max) -{ - struct regcache_rbtree_ctx *rbtree_ctx; - struct rb_node *node; - struct regcache_rbtree_node *rbnode; - unsigned int regtmp; - unsigned int val; - int ret; - int i, base, end; - - rbtree_ctx = map->cache; - for (node = rb_first(&rbtree_ctx->root); node; node = rb_next(node)) { - rbnode = rb_entry(node, struct regcache_rbtree_node, node); - - if (rbnode->base_reg < min) - continue; - if (rbnode->base_reg > max) - break; - if (rbnode->base_reg + rbnode->blklen < min) - continue; - - if (min > rbnode->base_reg) - base = min - rbnode->base_reg; - else - base = 0; - - if (max < rbnode->base_reg + rbnode->blklen) - end = rbnode->base_reg + rbnode->blklen - max; - else - end = rbnode->blklen; - - for (i = base; i < end; i++) { - regtmp = rbnode->base_reg + i; - val = regcache_rbtree_get_register(rbnode, i, - map->cache_word_size); - - /* Is this the hardware default? If so skip. */ - ret = regcache_lookup_reg(map, regtmp); - if (ret >= 0 && val == map->reg_defaults[ret].def) - continue; - - map->cache_bypass = 1; - ret = _regmap_write(map, regtmp, val); - map->cache_bypass = 0; - if (ret) - return ret; - dev_dbg(map->dev, "Synced register %#x, value %#x\n", - regtmp, val); - } - } - - return 0; -} - -struct regcache_ops regcache_rbtree_ops = { - .type = REGCACHE_RBTREE, - .name = "rbtree", - .init = regcache_rbtree_init, - .exit = regcache_rbtree_exit, - .read = regcache_rbtree_read, - .write = regcache_rbtree_write, - .sync = regcache_rbtree_sync -}; diff --git a/ANDROID_3.4.5/drivers/base/regmap/regcache.c b/ANDROID_3.4.5/drivers/base/regmap/regcache.c deleted file mode 100644 index 74b69095..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/regcache.c +++ /dev/null @@ -1,491 +0,0 @@ -/* - * Register cache access API - * - * Copyright 2011 Wolfson Microelectronics plc - * - * Author: Dimitris Papastamos <dp@opensource.wolfsonmicro.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include <linux/slab.h> -#include <linux/export.h> -#include <linux/device.h> -#include <trace/events/regmap.h> -#include <linux/bsearch.h> -#include <linux/sort.h> - -#include "internal.h" - -static const struct regcache_ops *cache_types[] = { - ®cache_rbtree_ops, - ®cache_lzo_ops, -}; - -static int regcache_hw_init(struct regmap *map) -{ - int i, j; - int ret; - int count; - unsigned int val; - void *tmp_buf; - - if (!map->num_reg_defaults_raw) - return -EINVAL; - - if (!map->reg_defaults_raw) { - u32 cache_bypass = map->cache_bypass; - dev_warn(map->dev, "No cache defaults, reading back from HW\n"); - - /* Bypass the cache access till data read from HW*/ - map->cache_bypass = 1; - tmp_buf = kmalloc(map->cache_size_raw, GFP_KERNEL); - if (!tmp_buf) - return -EINVAL; - ret = regmap_bulk_read(map, 0, tmp_buf, - map->num_reg_defaults_raw); - map->cache_bypass = cache_bypass; - if (ret < 0) { - kfree(tmp_buf); - return ret; - } - map->reg_defaults_raw = tmp_buf; - map->cache_free = 1; - } - - /* calculate the size of reg_defaults */ - for (count = 0, i = 0; i < map->num_reg_defaults_raw; i++) { - val = regcache_get_val(map->reg_defaults_raw, - i, map->cache_word_size); - if (regmap_volatile(map, i)) - continue; - count++; - } - - map->reg_defaults = kmalloc(count * sizeof(struct reg_default), - GFP_KERNEL); - if (!map->reg_defaults) { - ret = -ENOMEM; - goto err_free; - } - - /* fill the reg_defaults */ - map->num_reg_defaults = count; - for (i = 0, j = 0; i < map->num_reg_defaults_raw; i++) { - val = regcache_get_val(map->reg_defaults_raw, - i, map->cache_word_size); - if (regmap_volatile(map, i)) - continue; - map->reg_defaults[j].reg = i; - map->reg_defaults[j].def = val; - j++; - } - - return 0; - -err_free: - if (map->cache_free) - kfree(map->reg_defaults_raw); - - return ret; -} - -int regcache_init(struct regmap *map, const struct regmap_config *config) -{ - int ret; - int i; - void *tmp_buf; - - if (map->cache_type == REGCACHE_NONE) { - map->cache_bypass = true; - return 0; - } - - for (i = 0; i < ARRAY_SIZE(cache_types); i++) - if (cache_types[i]->type == map->cache_type) - break; - - if (i == ARRAY_SIZE(cache_types)) { - dev_err(map->dev, "Could not match compress type: %d\n", - map->cache_type); - return -EINVAL; - } - - map->num_reg_defaults = config->num_reg_defaults; - map->num_reg_defaults_raw = config->num_reg_defaults_raw; - map->reg_defaults_raw = config->reg_defaults_raw; - map->cache_word_size = DIV_ROUND_UP(config->val_bits, 8); - map->cache_size_raw = map->cache_word_size * config->num_reg_defaults_raw; - - map->cache = NULL; - map->cache_ops = cache_types[i]; - - if (!map->cache_ops->read || - !map->cache_ops->write || - !map->cache_ops->name) - return -EINVAL; - - /* We still need to ensure that the reg_defaults - * won't vanish from under us. We'll need to make - * a copy of it. - */ - if (config->reg_defaults) { - if (!map->num_reg_defaults) - return -EINVAL; - tmp_buf = kmemdup(config->reg_defaults, map->num_reg_defaults * - sizeof(struct reg_default), GFP_KERNEL); - if (!tmp_buf) - return -ENOMEM; - map->reg_defaults = tmp_buf; - } else if (map->num_reg_defaults_raw) { - /* Some devices such as PMICs don't have cache defaults, - * we cope with this by reading back the HW registers and - * crafting the cache defaults by hand. - */ - ret = regcache_hw_init(map); - if (ret < 0) - return ret; - } - - if (!map->max_register) - map->max_register = map->num_reg_defaults_raw; - - if (map->cache_ops->init) { - dev_dbg(map->dev, "Initializing %s cache\n", - map->cache_ops->name); - ret = map->cache_ops->init(map); - if (ret) - goto err_free; - } - return 0; - -err_free: - kfree(map->reg_defaults); - if (map->cache_free) - kfree(map->reg_defaults_raw); - - return ret; -} - -void regcache_exit(struct regmap *map) -{ - if (map->cache_type == REGCACHE_NONE) - return; - - BUG_ON(!map->cache_ops); - - kfree(map->reg_defaults); - if (map->cache_free) - kfree(map->reg_defaults_raw); - - if (map->cache_ops->exit) { - dev_dbg(map->dev, "Destroying %s cache\n", - map->cache_ops->name); - map->cache_ops->exit(map); - } -} - -/** - * regcache_read: Fetch the value of a given register from the cache. - * - * @map: map to configure. - * @reg: The register index. - * @value: The value to be returned. - * - * Return a negative value on failure, 0 on success. - */ -int regcache_read(struct regmap *map, - unsigned int reg, unsigned int *value) -{ - int ret; - - if (map->cache_type == REGCACHE_NONE) - return -ENOSYS; - - BUG_ON(!map->cache_ops); - - if (!regmap_volatile(map, reg)) { - ret = map->cache_ops->read(map, reg, value); - - if (ret == 0) - trace_regmap_reg_read_cache(map->dev, reg, *value); - - return ret; - } - - return -EINVAL; -} - -/** - * regcache_write: Set the value of a given register in the cache. - * - * @map: map to configure. - * @reg: The register index. - * @value: The new register value. - * - * Return a negative value on failure, 0 on success. - */ -int regcache_write(struct regmap *map, - unsigned int reg, unsigned int value) -{ - if (map->cache_type == REGCACHE_NONE) - return 0; - - BUG_ON(!map->cache_ops); - - if (!regmap_writeable(map, reg)) - return -EIO; - - if (!regmap_volatile(map, reg)) - return map->cache_ops->write(map, reg, value); - - return 0; -} - -/** - * regcache_sync: Sync the register cache with the hardware. - * - * @map: map to configure. - * - * Any registers that should not be synced should be marked as - * volatile. In general drivers can choose not to use the provided - * syncing functionality if they so require. - * - * Return a negative value on failure, 0 on success. - */ -int regcache_sync(struct regmap *map) -{ - int ret = 0; - unsigned int i; - const char *name; - unsigned int bypass; - - BUG_ON(!map->cache_ops || !map->cache_ops->sync); - - mutex_lock(&map->lock); - /* Remember the initial bypass state */ - bypass = map->cache_bypass; - dev_dbg(map->dev, "Syncing %s cache\n", - map->cache_ops->name); - name = map->cache_ops->name; - trace_regcache_sync(map->dev, name, "start"); - - if (!map->cache_dirty) - goto out; - - /* Apply any patch first */ - map->cache_bypass = 1; - for (i = 0; i < map->patch_regs; i++) { - ret = _regmap_write(map, map->patch[i].reg, map->patch[i].def); - if (ret != 0) { - dev_err(map->dev, "Failed to write %x = %x: %d\n", - map->patch[i].reg, map->patch[i].def, ret); - goto out; - } - } - map->cache_bypass = 0; - - ret = map->cache_ops->sync(map, 0, map->max_register); - - if (ret == 0) - map->cache_dirty = false; - -out: - trace_regcache_sync(map->dev, name, "stop"); - /* Restore the bypass state */ - map->cache_bypass = bypass; - mutex_unlock(&map->lock); - - return ret; -} -EXPORT_SYMBOL_GPL(regcache_sync); - -/** - * regcache_sync_region: Sync part of the register cache with the hardware. - * - * @map: map to sync. - * @min: first register to sync - * @max: last register to sync - * - * Write all non-default register values in the specified region to - * the hardware. - * - * Return a negative value on failure, 0 on success. - */ -int regcache_sync_region(struct regmap *map, unsigned int min, - unsigned int max) -{ - int ret = 0; - const char *name; - unsigned int bypass; - - BUG_ON(!map->cache_ops || !map->cache_ops->sync); - - mutex_lock(&map->lock); - - /* Remember the initial bypass state */ - bypass = map->cache_bypass; - - name = map->cache_ops->name; - dev_dbg(map->dev, "Syncing %s cache from %d-%d\n", name, min, max); - - trace_regcache_sync(map->dev, name, "start region"); - - if (!map->cache_dirty) - goto out; - - ret = map->cache_ops->sync(map, min, max); - -out: - trace_regcache_sync(map->dev, name, "stop region"); - /* Restore the bypass state */ - map->cache_bypass = bypass; - mutex_unlock(&map->lock); - - return ret; -} -EXPORT_SYMBOL_GPL(regcache_sync_region); - -/** - * regcache_cache_only: Put a register map into cache only mode - * - * @map: map to configure - * @cache_only: flag if changes should be written to the hardware - * - * When a register map is marked as cache only writes to the register - * map API will only update the register cache, they will not cause - * any hardware changes. This is useful for allowing portions of - * drivers to act as though the device were functioning as normal when - * it is disabled for power saving reasons. - */ -void regcache_cache_only(struct regmap *map, bool enable) -{ - mutex_lock(&map->lock); - WARN_ON(map->cache_bypass && enable); - map->cache_only = enable; - trace_regmap_cache_only(map->dev, enable); - mutex_unlock(&map->lock); -} -EXPORT_SYMBOL_GPL(regcache_cache_only); - -/** - * regcache_mark_dirty: Mark the register cache as dirty - * - * @map: map to mark - * - * Mark the register cache as dirty, for example due to the device - * having been powered down for suspend. If the cache is not marked - * as dirty then the cache sync will be suppressed. - */ -void regcache_mark_dirty(struct regmap *map) -{ - mutex_lock(&map->lock); - map->cache_dirty = true; - mutex_unlock(&map->lock); -} -EXPORT_SYMBOL_GPL(regcache_mark_dirty); - -/** - * regcache_cache_bypass: Put a register map into cache bypass mode - * - * @map: map to configure - * @cache_bypass: flag if changes should not be written to the hardware - * - * When a register map is marked with the cache bypass option, writes - * to the register map API will only update the hardware and not the - * the cache directly. This is useful when syncing the cache back to - * the hardware. - */ -void regcache_cache_bypass(struct regmap *map, bool enable) -{ - mutex_lock(&map->lock); - WARN_ON(map->cache_only && enable); - map->cache_bypass = enable; - trace_regmap_cache_bypass(map->dev, enable); - mutex_unlock(&map->lock); -} -EXPORT_SYMBOL_GPL(regcache_cache_bypass); - -bool regcache_set_val(void *base, unsigned int idx, - unsigned int val, unsigned int word_size) -{ - switch (word_size) { - case 1: { - u8 *cache = base; - if (cache[idx] == val) - return true; - cache[idx] = val; - break; - } - case 2: { - u16 *cache = base; - if (cache[idx] == val) - return true; - cache[idx] = val; - break; - } - case 4: { - u32 *cache = base; - if (cache[idx] == val) - return true; - cache[idx] = val; - break; - } - default: - BUG(); - } - return false; -} - -unsigned int regcache_get_val(const void *base, unsigned int idx, - unsigned int word_size) -{ - if (!base) - return -EINVAL; - - switch (word_size) { - case 1: { - const u8 *cache = base; - return cache[idx]; - } - case 2: { - const u16 *cache = base; - return cache[idx]; - } - case 4: { - const u32 *cache = base; - return cache[idx]; - } - default: - BUG(); - } - /* unreachable */ - return -1; -} - -static int regcache_default_cmp(const void *a, const void *b) -{ - const struct reg_default *_a = a; - const struct reg_default *_b = b; - - return _a->reg - _b->reg; -} - -int regcache_lookup_reg(struct regmap *map, unsigned int reg) -{ - struct reg_default key; - struct reg_default *r; - - key.reg = reg; - key.def = 0; - - r = bsearch(&key, map->reg_defaults, map->num_reg_defaults, - sizeof(struct reg_default), regcache_default_cmp); - - if (r) - return r - map->reg_defaults; - else - return -ENOENT; -} diff --git a/ANDROID_3.4.5/drivers/base/regmap/regmap-debugfs.c b/ANDROID_3.4.5/drivers/base/regmap/regmap-debugfs.c deleted file mode 100644 index 8ee03493..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/regmap-debugfs.c +++ /dev/null @@ -1,286 +0,0 @@ -/* - * Register map access API - debugfs - * - * Copyright 2011 Wolfson Microelectronics plc - * - * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include <linux/slab.h> -#include <linux/mutex.h> -#include <linux/debugfs.h> -#include <linux/uaccess.h> -#include <linux/device.h> - -#include "internal.h" - -static struct dentry *regmap_debugfs_root; - -/* Calculate the length of a fixed format */ -static size_t regmap_calc_reg_len(int max_val, char *buf, size_t buf_size) -{ - snprintf(buf, buf_size, "%x", max_val); - return strlen(buf); -} - -static ssize_t regmap_name_read_file(struct file *file, - char __user *user_buf, size_t count, - loff_t *ppos) -{ - struct regmap *map = file->private_data; - int ret; - char *buf; - - buf = kmalloc(PAGE_SIZE, GFP_KERNEL); - if (!buf) - return -ENOMEM; - - ret = snprintf(buf, PAGE_SIZE, "%s\n", map->dev->driver->name); - if (ret < 0) { - kfree(buf); - return ret; - } - - ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); - kfree(buf); - return ret; -} - -static const struct file_operations regmap_name_fops = { - .open = simple_open, - .read = regmap_name_read_file, - .llseek = default_llseek, -}; - -static ssize_t regmap_map_read_file(struct file *file, char __user *user_buf, - size_t count, loff_t *ppos) -{ - int reg_len, val_len, tot_len; - size_t buf_pos = 0; - loff_t p = 0; - ssize_t ret; - int i; - struct regmap *map = file->private_data; - char *buf; - unsigned int val; - - if (*ppos < 0 || !count) - return -EINVAL; - - buf = kmalloc(count, GFP_KERNEL); - if (!buf) - return -ENOMEM; - - /* Calculate the length of a fixed format */ - reg_len = regmap_calc_reg_len(map->max_register, buf, count); - val_len = 2 * map->format.val_bytes; - tot_len = reg_len + val_len + 3; /* : \n */ - - for (i = 0; i < map->max_register + 1; i++) { - if (!regmap_readable(map, i)) - continue; - - if (regmap_precious(map, i)) - continue; - - /* If we're in the region the user is trying to read */ - if (p >= *ppos) { - /* ...but not beyond it */ - if (buf_pos >= count - 1 - tot_len) - break; - - /* Format the register */ - snprintf(buf + buf_pos, count - buf_pos, "%.*x: ", - reg_len, i); - buf_pos += reg_len + 2; - - /* Format the value, write all X if we can't read */ - ret = regmap_read(map, i, &val); - if (ret == 0) - snprintf(buf + buf_pos, count - buf_pos, - "%.*x", val_len, val); - else - memset(buf + buf_pos, 'X', val_len); - buf_pos += 2 * map->format.val_bytes; - - buf[buf_pos++] = '\n'; - } - p += tot_len; - } - - ret = buf_pos; - - if (copy_to_user(user_buf, buf, buf_pos)) { - ret = -EFAULT; - goto out; - } - - *ppos += buf_pos; - -out: - kfree(buf); - return ret; -} - -#define REGMAP_ALLOW_WRITE_DEBUGFS -#ifdef REGMAP_ALLOW_WRITE_DEBUGFS -/* - * This can be dangerous especially when we have clients such as - * PMICs, therefore don't provide any real compile time configuration option - * for this feature, people who want to use this will need to modify - * the source code directly. - */ -static ssize_t regmap_map_write_file(struct file *file, - const char __user *user_buf, - size_t count, loff_t *ppos) -{ - char buf[32]; - size_t buf_size; - char *start = buf; - unsigned long reg, value; - struct regmap *map = file->private_data; - - buf_size = min(count, (sizeof(buf)-1)); - if (copy_from_user(buf, user_buf, buf_size)) - return -EFAULT; - buf[buf_size] = 0; - - while (*start == ' ') - start++; - reg = simple_strtoul(start, &start, 16); - while (*start == ' ') - start++; - if (strict_strtoul(start, 16, &value)) - return -EINVAL; - - /* Userspace has been fiddling around behind the kernel's back */ - add_taint(TAINT_USER); - - regmap_write(map, reg, value); - return buf_size; -} -#else -#define regmap_map_write_file NULL -#endif - -static const struct file_operations regmap_map_fops = { - .open = simple_open, - .read = regmap_map_read_file, - .write = regmap_map_write_file, - .llseek = default_llseek, -}; - -static ssize_t regmap_access_read_file(struct file *file, - char __user *user_buf, size_t count, - loff_t *ppos) -{ - int reg_len, tot_len; - size_t buf_pos = 0; - loff_t p = 0; - ssize_t ret; - int i; - struct regmap *map = file->private_data; - char *buf; - - if (*ppos < 0 || !count) - return -EINVAL; - - buf = kmalloc(count, GFP_KERNEL); - if (!buf) - return -ENOMEM; - - /* Calculate the length of a fixed format */ - reg_len = regmap_calc_reg_len(map->max_register, buf, count); - tot_len = reg_len + 10; /* ': R W V P\n' */ - - for (i = 0; i < map->max_register + 1; i++) { - /* Ignore registers which are neither readable nor writable */ - if (!regmap_readable(map, i) && !regmap_writeable(map, i)) - continue; - - /* If we're in the region the user is trying to read */ - if (p >= *ppos) { - /* ...but not beyond it */ - if (buf_pos >= count - 1 - tot_len) - break; - - /* Format the register */ - snprintf(buf + buf_pos, count - buf_pos, - "%.*x: %c %c %c %c\n", - reg_len, i, - regmap_readable(map, i) ? 'y' : 'n', - regmap_writeable(map, i) ? 'y' : 'n', - regmap_volatile(map, i) ? 'y' : 'n', - regmap_precious(map, i) ? 'y' : 'n'); - - buf_pos += tot_len; - } - p += tot_len; - } - - ret = buf_pos; - - if (copy_to_user(user_buf, buf, buf_pos)) { - ret = -EFAULT; - goto out; - } - - *ppos += buf_pos; - -out: - kfree(buf); - return ret; -} - -static const struct file_operations regmap_access_fops = { - .open = simple_open, - .read = regmap_access_read_file, - .llseek = default_llseek, -}; - -void regmap_debugfs_init(struct regmap *map) -{ - map->debugfs = debugfs_create_dir(dev_name(map->dev), - regmap_debugfs_root); - if (!map->debugfs) { - dev_warn(map->dev, "Failed to create debugfs directory\n"); - return; - } - - debugfs_create_file("name", 0400, map->debugfs, - map, ®map_name_fops); - - if (map->max_register) { - debugfs_create_file("registers", 0400, map->debugfs, - map, ®map_map_fops); - debugfs_create_file("access", 0400, map->debugfs, - map, ®map_access_fops); - } - - if (map->cache_type) { - debugfs_create_bool("cache_only", 0400, map->debugfs, - &map->cache_only); - debugfs_create_bool("cache_dirty", 0400, map->debugfs, - &map->cache_dirty); - debugfs_create_bool("cache_bypass", 0400, map->debugfs, - &map->cache_bypass); - } -} - -void regmap_debugfs_exit(struct regmap *map) -{ - debugfs_remove_recursive(map->debugfs); -} - -void regmap_debugfs_initcall(void) -{ - regmap_debugfs_root = debugfs_create_dir("regmap", NULL); - if (!regmap_debugfs_root) { - pr_warn("regmap: Failed to create debugfs root\n"); - return; - } -} diff --git a/ANDROID_3.4.5/drivers/base/regmap/regmap-i2c.c b/ANDROID_3.4.5/drivers/base/regmap/regmap-i2c.c deleted file mode 100644 index 9a3a8c56..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/regmap-i2c.c +++ /dev/null @@ -1,131 +0,0 @@ -/* - * Register map access API - I2C support - * - * Copyright 2011 Wolfson Microelectronics plc - * - * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include <linux/regmap.h> -#include <linux/i2c.h> -#include <linux/module.h> -#include <linux/init.h> - -static int regmap_i2c_write(struct device *dev, const void *data, size_t count) -{ - struct i2c_client *i2c = to_i2c_client(dev); - int ret; - - ret = i2c_master_send(i2c, data, count); - if (ret == count) - return 0; - else if (ret < 0) - return ret; - else - return -EIO; -} - -static int regmap_i2c_gather_write(struct device *dev, - const void *reg, size_t reg_size, - const void *val, size_t val_size) -{ - struct i2c_client *i2c = to_i2c_client(dev); - struct i2c_msg xfer[2]; - int ret; - - /* If the I2C controller can't do a gather tell the core, it - * will substitute in a linear write for us. - */ - if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_PROTOCOL_MANGLING)) - return -ENOTSUPP; - - xfer[0].addr = i2c->addr; - xfer[0].flags = 0; - xfer[0].len = reg_size; - xfer[0].buf = (void *)reg; - - xfer[1].addr = i2c->addr; - xfer[1].flags = I2C_M_NOSTART; - xfer[1].len = val_size; - xfer[1].buf = (void *)val; - - ret = i2c_transfer(i2c->adapter, xfer, 2); - if (ret == 2) - return 0; - if (ret < 0) - return ret; - else - return -EIO; -} - -static int regmap_i2c_read(struct device *dev, - const void *reg, size_t reg_size, - void *val, size_t val_size) -{ - struct i2c_client *i2c = to_i2c_client(dev); - struct i2c_msg xfer[2]; - int ret; - - xfer[0].addr = i2c->addr; - xfer[0].flags = 0; - xfer[0].len = reg_size; - xfer[0].buf = (void *)reg; - - xfer[1].addr = i2c->addr; - xfer[1].flags = I2C_M_RD; - xfer[1].len = val_size; - xfer[1].buf = val; - - ret = i2c_transfer(i2c->adapter, xfer, 2); - if (ret == 2) - return 0; - else if (ret < 0) - return ret; - else - return -EIO; -} - -static struct regmap_bus regmap_i2c = { - .write = regmap_i2c_write, - .gather_write = regmap_i2c_gather_write, - .read = regmap_i2c_read, -}; - -/** - * regmap_init_i2c(): Initialise register map - * - * @i2c: Device that will be interacted with - * @config: Configuration for register map - * - * The return value will be an ERR_PTR() on error or a valid pointer to - * a struct regmap. - */ -struct regmap *regmap_init_i2c(struct i2c_client *i2c, - const struct regmap_config *config) -{ - return regmap_init(&i2c->dev, ®map_i2c, config); -} -EXPORT_SYMBOL_GPL(regmap_init_i2c); - -/** - * devm_regmap_init_i2c(): Initialise managed register map - * - * @i2c: Device that will be interacted with - * @config: Configuration for register map - * - * The return value will be an ERR_PTR() on error or a valid pointer - * to a struct regmap. The regmap will be automatically freed by the - * device management code. - */ -struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, - const struct regmap_config *config) -{ - return devm_regmap_init(&i2c->dev, ®map_i2c, config); -} -EXPORT_SYMBOL_GPL(devm_regmap_init_i2c); - -MODULE_LICENSE("GPL"); diff --git a/ANDROID_3.4.5/drivers/base/regmap/regmap-irq.c b/ANDROID_3.4.5/drivers/base/regmap/regmap-irq.c deleted file mode 100644 index 1befaa7a..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/regmap-irq.c +++ /dev/null @@ -1,303 +0,0 @@ -/* - * regmap based irq_chip - * - * Copyright 2011 Wolfson Microelectronics plc - * - * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include <linux/export.h> -#include <linux/device.h> -#include <linux/regmap.h> -#include <linux/irq.h> -#include <linux/interrupt.h> -#include <linux/slab.h> - -#include "internal.h" - -struct regmap_irq_chip_data { - struct mutex lock; - - struct regmap *map; - struct regmap_irq_chip *chip; - - int irq_base; - - void *status_reg_buf; - unsigned int *status_buf; - unsigned int *mask_buf; - unsigned int *mask_buf_def; -}; - -static inline const -struct regmap_irq *irq_to_regmap_irq(struct regmap_irq_chip_data *data, - int irq) -{ - return &data->chip->irqs[irq - data->irq_base]; -} - -static void regmap_irq_lock(struct irq_data *data) -{ - struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); - - mutex_lock(&d->lock); -} - -static void regmap_irq_sync_unlock(struct irq_data *data) -{ - struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); - int i, ret; - - /* - * If there's been a change in the mask write it back to the - * hardware. We rely on the use of the regmap core cache to - * suppress pointless writes. - */ - for (i = 0; i < d->chip->num_regs; i++) { - ret = regmap_update_bits(d->map, d->chip->mask_base + i, - d->mask_buf_def[i], d->mask_buf[i]); - if (ret != 0) - dev_err(d->map->dev, "Failed to sync masks in %x\n", - d->chip->mask_base + i); - } - - mutex_unlock(&d->lock); -} - -static void regmap_irq_enable(struct irq_data *data) -{ - struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); - const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->irq); - - d->mask_buf[irq_data->reg_offset] &= ~irq_data->mask; -} - -static void regmap_irq_disable(struct irq_data *data) -{ - struct regmap_irq_chip_data *d = irq_data_get_irq_chip_data(data); - const struct regmap_irq *irq_data = irq_to_regmap_irq(d, data->irq); - - d->mask_buf[irq_data->reg_offset] |= irq_data->mask; -} - -static struct irq_chip regmap_irq_chip = { - .name = "regmap", - .irq_bus_lock = regmap_irq_lock, - .irq_bus_sync_unlock = regmap_irq_sync_unlock, - .irq_disable = regmap_irq_disable, - .irq_enable = regmap_irq_enable, -}; - -static irqreturn_t regmap_irq_thread(int irq, void *d) -{ - struct regmap_irq_chip_data *data = d; - struct regmap_irq_chip *chip = data->chip; - struct regmap *map = data->map; - int ret, i; - u8 *buf8 = data->status_reg_buf; - u16 *buf16 = data->status_reg_buf; - u32 *buf32 = data->status_reg_buf; - bool handled = false; - - ret = regmap_bulk_read(map, chip->status_base, data->status_reg_buf, - chip->num_regs); - if (ret != 0) { - dev_err(map->dev, "Failed to read IRQ status: %d\n", ret); - return IRQ_NONE; - } - - /* - * Ignore masked IRQs and ack if we need to; we ack early so - * there is no race between handling and acknowleding the - * interrupt. We assume that typically few of the interrupts - * will fire simultaneously so don't worry about overhead from - * doing a write per register. - */ - for (i = 0; i < data->chip->num_regs; i++) { - switch (map->format.val_bytes) { - case 1: - data->status_buf[i] = buf8[i]; - break; - case 2: - data->status_buf[i] = buf16[i]; - break; - case 4: - data->status_buf[i] = buf32[i]; - break; - default: - BUG(); - return IRQ_NONE; - } - - data->status_buf[i] &= ~data->mask_buf[i]; - - if (data->status_buf[i] && chip->ack_base) { - ret = regmap_write(map, chip->ack_base + i, - data->status_buf[i]); - if (ret != 0) - dev_err(map->dev, "Failed to ack 0x%x: %d\n", - chip->ack_base + i, ret); - } - } - - for (i = 0; i < chip->num_irqs; i++) { - if (data->status_buf[chip->irqs[i].reg_offset] & - chip->irqs[i].mask) { - handle_nested_irq(data->irq_base + i); - handled = true; - } - } - - if (handled) - return IRQ_HANDLED; - else - return IRQ_NONE; -} - -/** - * regmap_add_irq_chip(): Use standard regmap IRQ controller handling - * - * map: The regmap for the device. - * irq: The IRQ the device uses to signal interrupts - * irq_flags: The IRQF_ flags to use for the primary interrupt. - * chip: Configuration for the interrupt controller. - * data: Runtime data structure for the controller, allocated on success - * - * Returns 0 on success or an errno on failure. - * - * In order for this to be efficient the chip really should use a - * register cache. The chip driver is responsible for restoring the - * register values used by the IRQ controller over suspend and resume. - */ -int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags, - int irq_base, struct regmap_irq_chip *chip, - struct regmap_irq_chip_data **data) -{ - struct regmap_irq_chip_data *d; - int cur_irq, i; - int ret = -ENOMEM; - - irq_base = irq_alloc_descs(irq_base, 0, chip->num_irqs, 0); - if (irq_base < 0) { - dev_warn(map->dev, "Failed to allocate IRQs: %d\n", - irq_base); - return irq_base; - } - - d = kzalloc(sizeof(*d), GFP_KERNEL); - if (!d) - return -ENOMEM; - - d->status_buf = kzalloc(sizeof(unsigned int) * chip->num_regs, - GFP_KERNEL); - if (!d->status_buf) - goto err_alloc; - - d->status_reg_buf = kzalloc(map->format.val_bytes * chip->num_regs, - GFP_KERNEL); - if (!d->status_reg_buf) - goto err_alloc; - - d->mask_buf = kzalloc(sizeof(unsigned int) * chip->num_regs, - GFP_KERNEL); - if (!d->mask_buf) - goto err_alloc; - - d->mask_buf_def = kzalloc(sizeof(unsigned int) * chip->num_regs, - GFP_KERNEL); - if (!d->mask_buf_def) - goto err_alloc; - - d->map = map; - d->chip = chip; - d->irq_base = irq_base; - mutex_init(&d->lock); - - for (i = 0; i < chip->num_irqs; i++) - d->mask_buf_def[chip->irqs[i].reg_offset] - |= chip->irqs[i].mask; - - /* Mask all the interrupts by default */ - for (i = 0; i < chip->num_regs; i++) { - d->mask_buf[i] = d->mask_buf_def[i]; - ret = regmap_write(map, chip->mask_base + i, d->mask_buf[i]); - if (ret != 0) { - dev_err(map->dev, "Failed to set masks in 0x%x: %d\n", - chip->mask_base + i, ret); - goto err_alloc; - } - } - - /* Register them with genirq */ - for (cur_irq = irq_base; - cur_irq < chip->num_irqs + irq_base; - cur_irq++) { - irq_set_chip_data(cur_irq, d); - irq_set_chip_and_handler(cur_irq, ®map_irq_chip, - handle_edge_irq); - irq_set_nested_thread(cur_irq, 1); - - /* ARM needs us to explicitly flag the IRQ as valid - * and will set them noprobe when we do so. */ -#ifdef CONFIG_ARM - set_irq_flags(cur_irq, IRQF_VALID); -#else - irq_set_noprobe(cur_irq); -#endif - } - - ret = request_threaded_irq(irq, NULL, regmap_irq_thread, irq_flags, - chip->name, d); - if (ret != 0) { - dev_err(map->dev, "Failed to request IRQ %d: %d\n", irq, ret); - goto err_alloc; - } - - return 0; - -err_alloc: - kfree(d->mask_buf_def); - kfree(d->mask_buf); - kfree(d->status_reg_buf); - kfree(d->status_buf); - kfree(d); - return ret; -} -EXPORT_SYMBOL_GPL(regmap_add_irq_chip); - -/** - * regmap_del_irq_chip(): Stop interrupt handling for a regmap IRQ chip - * - * @irq: Primary IRQ for the device - * @d: regmap_irq_chip_data allocated by regmap_add_irq_chip() - */ -void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *d) -{ - if (!d) - return; - - free_irq(irq, d); - kfree(d->mask_buf_def); - kfree(d->mask_buf); - kfree(d->status_reg_buf); - kfree(d->status_buf); - kfree(d); -} -EXPORT_SYMBOL_GPL(regmap_del_irq_chip); - -/** - * regmap_irq_chip_get_base(): Retrieve interrupt base for a regmap IRQ chip - * - * Useful for drivers to request their own IRQs. - * - * @data: regmap_irq controller to operate on. - */ -int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data) -{ - return data->irq_base; -} -EXPORT_SYMBOL_GPL(regmap_irq_chip_get_base); diff --git a/ANDROID_3.4.5/drivers/base/regmap/regmap-spi.c b/ANDROID_3.4.5/drivers/base/regmap/regmap-spi.c deleted file mode 100644 index 7c0c35a3..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/regmap-spi.c +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Register map access API - SPI support - * - * Copyright 2011 Wolfson Microelectronics plc - * - * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include <linux/regmap.h> -#include <linux/spi/spi.h> -#include <linux/init.h> -#include <linux/module.h> - -static int regmap_spi_write(struct device *dev, const void *data, size_t count) -{ - struct spi_device *spi = to_spi_device(dev); - - return spi_write(spi, data, count); -} - -static int regmap_spi_gather_write(struct device *dev, - const void *reg, size_t reg_len, - const void *val, size_t val_len) -{ - struct spi_device *spi = to_spi_device(dev); - struct spi_message m; - struct spi_transfer t[2] = { { .tx_buf = reg, .len = reg_len, }, - { .tx_buf = val, .len = val_len, }, }; - - spi_message_init(&m); - spi_message_add_tail(&t[0], &m); - spi_message_add_tail(&t[1], &m); - - return spi_sync(spi, &m); -} - -static int regmap_spi_read(struct device *dev, - const void *reg, size_t reg_size, - void *val, size_t val_size) -{ - struct spi_device *spi = to_spi_device(dev); - - return spi_write_then_read(spi, reg, reg_size, val, val_size); -} - -static struct regmap_bus regmap_spi = { - .write = regmap_spi_write, - .gather_write = regmap_spi_gather_write, - .read = regmap_spi_read, - .read_flag_mask = 0x80, -}; - -/** - * regmap_init_spi(): Initialise register map - * - * @spi: Device that will be interacted with - * @config: Configuration for register map - * - * The return value will be an ERR_PTR() on error or a valid pointer to - * a struct regmap. - */ -struct regmap *regmap_init_spi(struct spi_device *spi, - const struct regmap_config *config) -{ - return regmap_init(&spi->dev, ®map_spi, config); -} -EXPORT_SYMBOL_GPL(regmap_init_spi); - -/** - * devm_regmap_init_spi(): Initialise register map - * - * @spi: Device that will be interacted with - * @config: Configuration for register map - * - * The return value will be an ERR_PTR() on error or a valid pointer - * to a struct regmap. The map will be automatically freed by the - * device management code. - */ -struct regmap *devm_regmap_init_spi(struct spi_device *spi, - const struct regmap_config *config) -{ - return devm_regmap_init(&spi->dev, ®map_spi, config); -} -EXPORT_SYMBOL_GPL(devm_regmap_init_spi); - -MODULE_LICENSE("GPL"); diff --git a/ANDROID_3.4.5/drivers/base/regmap/regmap.c b/ANDROID_3.4.5/drivers/base/regmap/regmap.c deleted file mode 100644 index bb80853f..00000000 --- a/ANDROID_3.4.5/drivers/base/regmap/regmap.c +++ /dev/null @@ -1,936 +0,0 @@ -/* - * Register map access API - * - * Copyright 2011 Wolfson Microelectronics plc - * - * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include <linux/device.h> -#include <linux/slab.h> -#include <linux/export.h> -#include <linux/mutex.h> -#include <linux/err.h> - -#define CREATE_TRACE_POINTS -#include <trace/events/regmap.h> - -#include "internal.h" - -bool regmap_writeable(struct regmap *map, unsigned int reg) -{ - if (map->max_register && reg > map->max_register) - return false; - - if (map->writeable_reg) - return map->writeable_reg(map->dev, reg); - - return true; -} - -bool regmap_readable(struct regmap *map, unsigned int reg) -{ - if (map->max_register && reg > map->max_register) - return false; - - if (map->format.format_write) - return false; - - if (map->readable_reg) - return map->readable_reg(map->dev, reg); - - return true; -} - -bool regmap_volatile(struct regmap *map, unsigned int reg) -{ - if (!regmap_readable(map, reg)) - return false; - - if (map->volatile_reg) - return map->volatile_reg(map->dev, reg); - - return true; -} - -bool regmap_precious(struct regmap *map, unsigned int reg) -{ - if (!regmap_readable(map, reg)) - return false; - - if (map->precious_reg) - return map->precious_reg(map->dev, reg); - - return false; -} - -static bool regmap_volatile_range(struct regmap *map, unsigned int reg, - unsigned int num) -{ - unsigned int i; - - for (i = 0; i < num; i++) - if (!regmap_volatile(map, reg + i)) - return false; - - return true; -} - -static void regmap_format_2_6_write(struct regmap *map, - unsigned int reg, unsigned int val) -{ - u8 *out = map->work_buf; - - *out = (reg << 6) | val; -} - -static void regmap_format_4_12_write(struct regmap *map, - unsigned int reg, unsigned int val) -{ - __be16 *out = map->work_buf; - *out = cpu_to_be16((reg << 12) | val); -} - -static void regmap_format_7_9_write(struct regmap *map, - unsigned int reg, unsigned int val) -{ - __be16 *out = map->work_buf; - *out = cpu_to_be16((reg << 9) | val); -} - -static void regmap_format_10_14_write(struct regmap *map, - unsigned int reg, unsigned int val) -{ - u8 *out = map->work_buf; - - out[2] = val; - out[1] = (val >> 8) | (reg << 6); - out[0] = reg >> 2; -} - -static void regmap_format_8(void *buf, unsigned int val) -{ - u8 *b = buf; - - b[0] = val; -} - -static void regmap_format_16(void *buf, unsigned int val) -{ - __be16 *b = buf; - - b[0] = cpu_to_be16(val); -} - -static void regmap_format_32(void *buf, unsigned int val) -{ - __be32 *b = buf; - - b[0] = cpu_to_be32(val); -} - -static unsigned int regmap_parse_8(void *buf) -{ - u8 *b = buf; - - return b[0]; -} - -static unsigned int regmap_parse_16(void *buf) -{ - __be16 *b = buf; - - b[0] = be16_to_cpu(b[0]); - - return b[0]; -} - -static unsigned int regmap_parse_32(void *buf) -{ - __be32 *b = buf; - - b[0] = be32_to_cpu(b[0]); - - return b[0]; -} - -/** - * regmap_init(): Initialise register map - * - * @dev: Device that will be interacted with - * @bus: Bus-specific callbacks to use with device - * @config: Configuration for register map - * - * The return value will be an ERR_PTR() on error or a valid pointer to - * a struct regmap. This function should generally not be called - * directly, it should be called by bus-specific init functions. - */ -struct regmap *regmap_init(struct device *dev, - const struct regmap_bus *bus, - const struct regmap_config *config) -{ - struct regmap *map; - int ret = -EINVAL; - - if (!bus || !config) - goto err; - - map = kzalloc(sizeof(*map), GFP_KERNEL); - if (map == NULL) { - ret = -ENOMEM; - goto err; - } - - mutex_init(&map->lock); - map->format.buf_size = (config->reg_bits + config->val_bits) / 8; - map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8); - map->format.pad_bytes = config->pad_bits / 8; - map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8); - map->format.buf_size += map->format.pad_bytes; - map->dev = dev; - map->bus = bus; - map->max_register = config->max_register; - map->writeable_reg = config->writeable_reg; - map->readable_reg = config->readable_reg; - map->volatile_reg = config->volatile_reg; - map->precious_reg = config->precious_reg; - map->cache_type = config->cache_type; - - if (config->read_flag_mask || config->write_flag_mask) { - map->read_flag_mask = config->read_flag_mask; - map->write_flag_mask = config->write_flag_mask; - } else { - map->read_flag_mask = bus->read_flag_mask; - } - - switch (config->reg_bits) { - case 2: - switch (config->val_bits) { - case 6: - map->format.format_write = regmap_format_2_6_write; - break; - default: - goto err_map; - } - break; - - case 4: - switch (config->val_bits) { - case 12: - map->format.format_write = regmap_format_4_12_write; - break; - default: - goto err_map; - } - break; - - case 7: - switch (config->val_bits) { - case 9: - map->format.format_write = regmap_format_7_9_write; - break; - default: - goto err_map; - } - break; - - case 10: - switch (config->val_bits) { - case 14: - map->format.format_write = regmap_format_10_14_write; - break; - default: - goto err_map; - } - break; - - case 8: - map->format.format_reg = regmap_format_8; - break; - - case 16: - map->format.format_reg = regmap_format_16; - break; - - case 32: - map->format.format_reg = regmap_format_32; - break; - - default: - goto err_map; - } - - switch (config->val_bits) { - case 8: - map->format.format_val = regmap_format_8; - map->format.parse_val = regmap_parse_8; - break; - case 16: - map->format.format_val = regmap_format_16; - map->format.parse_val = regmap_parse_16; - break; - case 32: - map->format.format_val = regmap_format_32; - map->format.parse_val = regmap_parse_32; - break; - } - - if (!map->format.format_write && - !(map->format.format_reg && map->format.format_val)) - goto err_map; - - map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL); - if (map->work_buf == NULL) { - ret = -ENOMEM; - goto err_map; - } - - regmap_debugfs_init(map); - - ret = regcache_init(map, config); - if (ret < 0) - goto err_free_workbuf; - - return map; - -err_free_workbuf: - kfree(map->work_buf); -err_map: - kfree(map); -err: - return ERR_PTR(ret); -} -EXPORT_SYMBOL_GPL(regmap_init); - -static void devm_regmap_release(struct device *dev, void *res) -{ - regmap_exit(*(struct regmap **)res); -} - -/** - * devm_regmap_init(): Initialise managed register map - * - * @dev: Device that will be interacted with - * @bus: Bus-specific callbacks to use with device - * @config: Configuration for register map - * - * The return value will be an ERR_PTR() on error or a valid pointer - * to a struct regmap. This function should generally not be called - * directly, it should be called by bus-specific init functions. The - * map will be automatically freed by the device management code. - */ -struct regmap *devm_regmap_init(struct device *dev, - const struct regmap_bus *bus, - const struct regmap_config *config) -{ - struct regmap **ptr, *regmap; - - ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL); - if (!ptr) - return ERR_PTR(-ENOMEM); - - regmap = regmap_init(dev, bus, config); - if (!IS_ERR(regmap)) { - *ptr = regmap; - devres_add(dev, ptr); - } else { - devres_free(ptr); - } - - return regmap; -} -EXPORT_SYMBOL_GPL(devm_regmap_init); - -/** - * regmap_reinit_cache(): Reinitialise the current register cache - * - * @map: Register map to operate on. - * @config: New configuration. Only the cache data will be used. - * - * Discard any existing register cache for the map and initialize a - * new cache. This can be used to restore the cache to defaults or to - * update the cache configuration to reflect runtime discovery of the - * hardware. - */ -int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config) -{ - int ret; - - mutex_lock(&map->lock); - - regcache_exit(map); - regmap_debugfs_exit(map); - - map->max_register = config->max_register; - map->writeable_reg = config->writeable_reg; - map->readable_reg = config->readable_reg; - map->volatile_reg = config->volatile_reg; - map->precious_reg = config->precious_reg; - map->cache_type = config->cache_type; - - regmap_debugfs_init(map); - - map->cache_bypass = false; - map->cache_only = false; - - ret = regcache_init(map, config); - - mutex_unlock(&map->lock); - - return ret; -} - -/** - * regmap_exit(): Free a previously allocated register map - */ -void regmap_exit(struct regmap *map) -{ - regcache_exit(map); - regmap_debugfs_exit(map); - kfree(map->work_buf); - kfree(map); -} -EXPORT_SYMBOL_GPL(regmap_exit); - -static int _regmap_raw_write(struct regmap *map, unsigned int reg, - const void *val, size_t val_len) -{ - u8 *u8 = map->work_buf; - void *buf; - int ret = -ENOTSUPP; - size_t len; - int i; - - /* Check for unwritable registers before we start */ - if (map->writeable_reg) - for (i = 0; i < val_len / map->format.val_bytes; i++) - if (!map->writeable_reg(map->dev, reg + i)) - return -EINVAL; - - if (!map->cache_bypass && map->format.parse_val) { - unsigned int ival; - int val_bytes = map->format.val_bytes; - for (i = 0; i < val_len / val_bytes; i++) { - memcpy(map->work_buf, val + (i * val_bytes), val_bytes); - ival = map->format.parse_val(map->work_buf); - ret = regcache_write(map, reg + i, ival); - if (ret) { - dev_err(map->dev, - "Error in caching of register: %u ret: %d\n", - reg + i, ret); - return ret; - } - } - if (map->cache_only) { - map->cache_dirty = true; - return 0; - } - } - - map->format.format_reg(map->work_buf, reg); - - u8[0] |= map->write_flag_mask; - - trace_regmap_hw_write_start(map->dev, reg, - val_len / map->format.val_bytes); - - /* If we're doing a single register write we can probably just - * send the work_buf directly, otherwise try to do a gather - * write. - */ - if (val == (map->work_buf + map->format.pad_bytes + - map->format.reg_bytes)) - ret = map->bus->write(map->dev, map->work_buf, - map->format.reg_bytes + - map->format.pad_bytes + - val_len); - else if (map->bus->gather_write) - ret = map->bus->gather_write(map->dev, map->work_buf, - map->format.reg_bytes + - map->format.pad_bytes, - val, val_len); - - /* If that didn't work fall back on linearising by hand. */ - if (ret == -ENOTSUPP) { - len = map->format.reg_bytes + map->format.pad_bytes + val_len; - buf = kzalloc(len, GFP_KERNEL); - if (!buf) - return -ENOMEM; - - memcpy(buf, map->work_buf, map->format.reg_bytes); - memcpy(buf + map->format.reg_bytes + map->format.pad_bytes, - val, val_len); - ret = map->bus->write(map->dev, buf, len); - - kfree(buf); - } - - trace_regmap_hw_write_done(map->dev, reg, - val_len / map->format.val_bytes); - - return ret; -} - -int _regmap_write(struct regmap *map, unsigned int reg, - unsigned int val) -{ - int ret; - BUG_ON(!map->format.format_write && !map->format.format_val); - - if (!map->cache_bypass && map->format.format_write) { - ret = regcache_write(map, reg, val); - if (ret != 0) - return ret; - if (map->cache_only) { - map->cache_dirty = true; - return 0; - } - } - - trace_regmap_reg_write(map->dev, reg, val); - - if (map->format.format_write) { - map->format.format_write(map, reg, val); - - trace_regmap_hw_write_start(map->dev, reg, 1); - - ret = map->bus->write(map->dev, map->work_buf, - map->format.buf_size); - - trace_regmap_hw_write_done(map->dev, reg, 1); - - return ret; - } else { - map->format.format_val(map->work_buf + map->format.reg_bytes - + map->format.pad_bytes, val); - return _regmap_raw_write(map, reg, - map->work_buf + - map->format.reg_bytes + - map->format.pad_bytes, - map->format.val_bytes); - } -} - -/** - * regmap_write(): Write a value to a single register - * - * @map: Register map to write to - * @reg: Register to write to - * @val: Value to be written - * - * A value of zero will be returned on success, a negative errno will - * be returned in error cases. - */ -int regmap_write(struct regmap *map, unsigned int reg, unsigned int val) -{ - int ret; - - mutex_lock(&map->lock); - - ret = _regmap_write(map, reg, val); - - mutex_unlock(&map->lock); - - return ret; -} -EXPORT_SYMBOL_GPL(regmap_write); - -/** - * regmap_raw_write(): Write raw values to one or more registers - * - * @map: Register map to write to - * @reg: Initial register to write to - * @val: Block of data to be written, laid out for direct transmission to the - * device - * @val_len: Length of data pointed to by val. - * - * This function is intended to be used for things like firmware - * download where a large block of data needs to be transferred to the - * device. No formatting will be done on the data provided. - * - * A value of zero will be returned on success, a negative errno will - * be returned in error cases. - */ -int regmap_raw_write(struct regmap *map, unsigned int reg, - const void *val, size_t val_len) -{ - int ret; - - mutex_lock(&map->lock); - - ret = _regmap_raw_write(map, reg, val, val_len); - - mutex_unlock(&map->lock); - - return ret; -} -EXPORT_SYMBOL_GPL(regmap_raw_write); - -/* - * regmap_bulk_write(): Write multiple registers to the device - * - * @map: Register map to write to - * @reg: First register to be write from - * @val: Block of data to be written, in native register size for device - * @val_count: Number of registers to write - * - * This function is intended to be used for writing a large block of - * data to be device either in single transfer or multiple transfer. - * - * A value of zero will be returned on success, a negative errno will - * be returned in error cases. - */ -int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val, - size_t val_count) -{ - int ret = 0, i; - size_t val_bytes = map->format.val_bytes; - void *wval; - - if (!map->format.parse_val) - return -EINVAL; - - mutex_lock(&map->lock); - - /* No formatting is require if val_byte is 1 */ - if (val_bytes == 1) { - wval = (void *)val; - } else { - wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL); - if (!wval) { - ret = -ENOMEM; - dev_err(map->dev, "Error in memory allocation\n"); - goto out; - } - for (i = 0; i < val_count * val_bytes; i += val_bytes) - map->format.parse_val(wval + i); - } - ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count); - - if (val_bytes != 1) - kfree(wval); - -out: - mutex_unlock(&map->lock); - return ret; -} -EXPORT_SYMBOL_GPL(regmap_bulk_write); - -static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val, - unsigned int val_len) -{ - u8 *u8 = map->work_buf; - int ret; - - map->format.format_reg(map->work_buf, reg); - - /* - * Some buses or devices flag reads by setting the high bits in the - * register addresss; since it's always the high bits for all - * current formats we can do this here rather than in - * formatting. This may break if we get interesting formats. - */ - u8[0] |= map->read_flag_mask; - - trace_regmap_hw_read_start(map->dev, reg, - val_len / map->format.val_bytes); - - ret = map->bus->read(map->dev, map->work_buf, - map->format.reg_bytes + map->format.pad_bytes, - val, val_len); - - trace_regmap_hw_read_done(map->dev, reg, - val_len / map->format.val_bytes); - - return ret; -} - -static int _regmap_read(struct regmap *map, unsigned int reg, - unsigned int *val) -{ - int ret; - - if (!map->cache_bypass) { - ret = regcache_read(map, reg, val); - if (ret == 0) - return 0; - } - - if (!map->format.parse_val) - return -EINVAL; - - if (map->cache_only) - return -EBUSY; - - ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes); - if (ret == 0) { - *val = map->format.parse_val(map->work_buf); - trace_regmap_reg_read(map->dev, reg, *val); - } - - return ret; -} - -/** - * regmap_read(): Read a value from a single register - * - * @map: Register map to write to - * @reg: Register to be read from - * @val: Pointer to store read value - * - * A value of zero will be returned on success, a negative errno will - * be returned in error cases. - */ -int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val) -{ - int ret; - - mutex_lock(&map->lock); - - ret = _regmap_read(map, reg, val); - - mutex_unlock(&map->lock); - - return ret; -} -EXPORT_SYMBOL_GPL(regmap_read); - -/** - * regmap_raw_read(): Read raw data from the device - * - * @map: Register map to write to - * @reg: First register to be read from - * @val: Pointer to store read value - * @val_len: Size of data to read - * - * A value of zero will be returned on success, a negative errno will - * be returned in error cases. - */ -int regmap_raw_read(struct regmap *map, unsigned int reg, void *val, - size_t val_len) -{ - size_t val_bytes = map->format.val_bytes; - size_t val_count = val_len / val_bytes; - unsigned int v; - int ret, i; - - mutex_lock(&map->lock); - - if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass || - map->cache_type == REGCACHE_NONE) { - /* Physical block read if there's no cache involved */ - ret = _regmap_raw_read(map, reg, val, val_len); - - } else { - /* Otherwise go word by word for the cache; should be low - * cost as we expect to hit the cache. - */ - for (i = 0; i < val_count; i++) { - ret = _regmap_read(map, reg + i, &v); - if (ret != 0) - goto out; - - map->format.format_val(val + (i * val_bytes), v); - } - } - - out: - mutex_unlock(&map->lock); - - return ret; -} -EXPORT_SYMBOL_GPL(regmap_raw_read); - -/** - * regmap_bulk_read(): Read multiple registers from the device - * - * @map: Register map to write to - * @reg: First register to be read from - * @val: Pointer to store read value, in native register size for device - * @val_count: Number of registers to read - * - * A value of zero will be returned on success, a negative errno will - * be returned in error cases. - */ -int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val, - size_t val_count) -{ - int ret, i; - size_t val_bytes = map->format.val_bytes; - bool vol = regmap_volatile_range(map, reg, val_count); - - if (!map->format.parse_val) - return -EINVAL; - - if (vol || map->cache_type == REGCACHE_NONE) { - ret = regmap_raw_read(map, reg, val, val_bytes * val_count); - if (ret != 0) - return ret; - - for (i = 0; i < val_count * val_bytes; i += val_bytes) - map->format.parse_val(val + i); - } else { - for (i = 0; i < val_count; i++) { - unsigned int ival; - ret = regmap_read(map, reg + i, &ival); - if (ret != 0) - return ret; - memcpy(val + (i * val_bytes), &ival, val_bytes); - } - } - - return 0; -} -EXPORT_SYMBOL_GPL(regmap_bulk_read); - -static int _regmap_update_bits(struct regmap *map, unsigned int reg, - unsigned int mask, unsigned int val, - bool *change) -{ - int ret; - unsigned int tmp, orig; - - mutex_lock(&map->lock); - - ret = _regmap_read(map, reg, &orig); - if (ret != 0) - goto out; - - tmp = orig & ~mask; - tmp |= val & mask; - - if (tmp != orig) { - ret = _regmap_write(map, reg, tmp); - *change = true; - } else { - *change = false; - } - -out: - mutex_unlock(&map->lock); - - return ret; -} - -/** - * regmap_update_bits: Perform a read/modify/write cycle on the register map - * - * @map: Register map to update - * @reg: Register to update - * @mask: Bitmask to change - * @val: New value for bitmask - * - * Returns zero for success, a negative number on error. - */ -int regmap_update_bits(struct regmap *map, unsigned int reg, - unsigned int mask, unsigned int val) -{ - bool change; - return _regmap_update_bits(map, reg, mask, val, &change); -} -EXPORT_SYMBOL_GPL(regmap_update_bits); - -/** - * regmap_update_bits_check: Perform a read/modify/write cycle on the - * register map and report if updated - * - * @map: Register map to update - * @reg: Register to update - * @mask: Bitmask to change - * @val: New value for bitmask - * @change: Boolean indicating if a write was done - * - * Returns zero for success, a negative number on error. - */ -int regmap_update_bits_check(struct regmap *map, unsigned int reg, - unsigned int mask, unsigned int val, - bool *change) -{ - return _regmap_update_bits(map, reg, mask, val, change); -} -EXPORT_SYMBOL_GPL(regmap_update_bits_check); - -/** - * regmap_register_patch: Register and apply register updates to be applied - * on device initialistion - * - * @map: Register map to apply updates to. - * @regs: Values to update. - * @num_regs: Number of entries in regs. - * - * Register a set of register updates to be applied to the device - * whenever the device registers are synchronised with the cache and - * apply them immediately. Typically this is used to apply - * corrections to be applied to the device defaults on startup, such - * as the updates some vendors provide to undocumented registers. - */ -int regmap_register_patch(struct regmap *map, const struct reg_default *regs, - int num_regs) -{ - int i, ret; - bool bypass; - - /* If needed the implementation can be extended to support this */ - if (map->patch) - return -EBUSY; - - mutex_lock(&map->lock); - - bypass = map->cache_bypass; - - map->cache_bypass = true; - - /* Write out first; it's useful to apply even if we fail later. */ - for (i = 0; i < num_regs; i++) { - ret = _regmap_write(map, regs[i].reg, regs[i].def); - if (ret != 0) { - dev_err(map->dev, "Failed to write %x = %x: %d\n", - regs[i].reg, regs[i].def, ret); - goto out; - } - } - - map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL); - if (map->patch != NULL) { - memcpy(map->patch, regs, - num_regs * sizeof(struct reg_default)); - map->patch_regs = num_regs; - } else { - ret = -ENOMEM; - } - -out: - map->cache_bypass = bypass; - - mutex_unlock(&map->lock); - - return ret; -} -EXPORT_SYMBOL_GPL(regmap_register_patch); - -/* - * regmap_get_val_bytes(): Report the size of a register value - * - * Report the size of a register value, mainly intended to for use by - * generic infrastructure built on top of regmap. - */ -int regmap_get_val_bytes(struct regmap *map) -{ - if (map->format.format_write) - return -EINVAL; - - return map->format.val_bytes; -} -EXPORT_SYMBOL_GPL(regmap_get_val_bytes); - -static int __init regmap_initcall(void) -{ - regmap_debugfs_initcall(); - - return 0; -} -postcore_initcall(regmap_initcall); |