linux/drivers/mfd/si476x-prop.c
<<
>>
Prefs
   1/*
   2 * drivers/mfd/si476x-prop.c -- Subroutines to access
   3 * properties of si476x chips
   4 *
   5 * Copyright (C) 2012 Innovative Converged Devices(ICD)
   6 * Copyright (C) 2013 Andrey Smirnov
   7 *
   8 * Author: Andrey Smirnov <andrew.smirnov@gmail.com>
   9 *
  10 * This program is free software; you can redistribute it and/or modify
  11 * it under the terms of the GNU General Public License as published by
  12 * the Free Software Foundation; version 2 of the License.
  13 *
  14 * This program is distributed in the hope that it will be useful, but
  15 * WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 * General Public License for more details.
  18 */
  19#include <linux/module.h>
  20
  21#include <linux/mfd/si476x-core.h>
  22
  23struct si476x_property_range {
  24        u16 low, high;
  25};
  26
  27static bool si476x_core_element_is_in_array(u16 element,
  28                                            const u16 array[],
  29                                            size_t size)
  30{
  31        int i;
  32
  33        for (i = 0; i < size; i++)
  34                if (element == array[i])
  35                        return true;
  36
  37        return false;
  38}
  39
  40static bool si476x_core_element_is_in_range(u16 element,
  41                                            const struct si476x_property_range range[],
  42                                            size_t size)
  43{
  44        int i;
  45
  46        for (i = 0; i < size; i++)
  47                if (element <= range[i].high && element >= range[i].low)
  48                        return true;
  49
  50        return false;
  51}
  52
  53static bool si476x_core_is_valid_property_a10(struct si476x_core *core,
  54                                              u16 property)
  55{
  56        static const u16 valid_properties[] = {
  57                0x0000,
  58                0x0500, 0x0501,
  59                0x0600,
  60                0x0709, 0x070C, 0x070D, 0x70E, 0x710,
  61                0x0718,
  62                0x1207, 0x1208,
  63                0x2007,
  64                0x2300,
  65        };
  66
  67        static const struct si476x_property_range valid_ranges[] = {
  68                { 0x0200, 0x0203 },
  69                { 0x0300, 0x0303 },
  70                { 0x0400, 0x0404 },
  71                { 0x0700, 0x0707 },
  72                { 0x1100, 0x1102 },
  73                { 0x1200, 0x1204 },
  74                { 0x1300, 0x1306 },
  75                { 0x2000, 0x2005 },
  76                { 0x2100, 0x2104 },
  77                { 0x2106, 0x2106 },
  78                { 0x2200, 0x220E },
  79                { 0x3100, 0x3104 },
  80                { 0x3207, 0x320F },
  81                { 0x3300, 0x3304 },
  82                { 0x3500, 0x3517 },
  83                { 0x3600, 0x3617 },
  84                { 0x3700, 0x3717 },
  85                { 0x4000, 0x4003 },
  86        };
  87
  88        return  si476x_core_element_is_in_range(property, valid_ranges,
  89                                                ARRAY_SIZE(valid_ranges)) ||
  90                si476x_core_element_is_in_array(property, valid_properties,
  91                                                ARRAY_SIZE(valid_properties));
  92}
  93
  94static bool si476x_core_is_valid_property_a20(struct si476x_core *core,
  95                                              u16 property)
  96{
  97        static const u16 valid_properties[] = {
  98                0x071B,
  99                0x1006,
 100                0x2210,
 101                0x3401,
 102        };
 103
 104        static const struct si476x_property_range valid_ranges[] = {
 105                { 0x2215, 0x2219 },
 106        };
 107
 108        return  si476x_core_is_valid_property_a10(core, property) ||
 109                si476x_core_element_is_in_range(property, valid_ranges,
 110                                                ARRAY_SIZE(valid_ranges))  ||
 111                si476x_core_element_is_in_array(property, valid_properties,
 112                                                ARRAY_SIZE(valid_properties));
 113}
 114
 115static bool si476x_core_is_valid_property_a30(struct si476x_core *core,
 116                                              u16 property)
 117{
 118        static const u16 valid_properties[] = {
 119                0x071C, 0x071D,
 120                0x1007, 0x1008,
 121                0x220F, 0x2214,
 122                0x2301,
 123                0x3105, 0x3106,
 124                0x3402,
 125        };
 126
 127        static const struct si476x_property_range valid_ranges[] = {
 128                { 0x0405, 0x0411 },
 129                { 0x2008, 0x200B },
 130                { 0x2220, 0x2223 },
 131                { 0x3100, 0x3106 },
 132        };
 133
 134        return  si476x_core_is_valid_property_a20(core, property) ||
 135                si476x_core_element_is_in_range(property, valid_ranges,
 136                                                ARRAY_SIZE(valid_ranges)) ||
 137                si476x_core_element_is_in_array(property, valid_properties,
 138                                                ARRAY_SIZE(valid_properties));
 139}
 140
 141typedef bool (*valid_property_pred_t) (struct si476x_core *, u16);
 142
 143static bool si476x_core_is_valid_property(struct si476x_core *core,
 144                                          u16 property)
 145{
 146        static const valid_property_pred_t is_valid_property[] = {
 147                [SI476X_REVISION_A10] = si476x_core_is_valid_property_a10,
 148                [SI476X_REVISION_A20] = si476x_core_is_valid_property_a20,
 149                [SI476X_REVISION_A30] = si476x_core_is_valid_property_a30,
 150        };
 151
 152        BUG_ON(core->revision > SI476X_REVISION_A30 ||
 153               core->revision == -1);
 154        return is_valid_property[core->revision](core, property);
 155}
 156
 157
 158static bool si476x_core_is_readonly_property(struct si476x_core *core,
 159                                             u16 property)
 160{
 161        BUG_ON(core->revision > SI476X_REVISION_A30 ||
 162               core->revision == -1);
 163
 164        switch (core->revision) {
 165        case SI476X_REVISION_A10:
 166                return (property == 0x3200);
 167        case SI476X_REVISION_A20:
 168                return (property == 0x1006 ||
 169                        property == 0x2210 ||
 170                        property == 0x3200);
 171        case SI476X_REVISION_A30:
 172                return false;
 173        }
 174
 175        return false;
 176}
 177
 178static bool si476x_core_regmap_readable_register(struct device *dev,
 179                                                 unsigned int reg)
 180{
 181        struct i2c_client *client = to_i2c_client(dev);
 182        struct si476x_core *core = i2c_get_clientdata(client);
 183
 184        return si476x_core_is_valid_property(core, (u16) reg);
 185
 186}
 187
 188static bool si476x_core_regmap_writable_register(struct device *dev,
 189                                                 unsigned int reg)
 190{
 191        struct i2c_client *client = to_i2c_client(dev);
 192        struct si476x_core *core = i2c_get_clientdata(client);
 193
 194        return si476x_core_is_valid_property(core, (u16) reg) &&
 195                !si476x_core_is_readonly_property(core, (u16) reg);
 196}
 197
 198
 199static int si476x_core_regmap_write(void *context, unsigned int reg,
 200                                    unsigned int val)
 201{
 202        return si476x_core_cmd_set_property(context, reg, val);
 203}
 204
 205static int si476x_core_regmap_read(void *context, unsigned int reg,
 206                                   unsigned *val)
 207{
 208        struct si476x_core *core = context;
 209        int err;
 210
 211        err = si476x_core_cmd_get_property(core, reg);
 212        if (err < 0)
 213                return err;
 214
 215        *val = err;
 216
 217        return 0;
 218}
 219
 220
 221static const struct regmap_config si476x_regmap_config = {
 222        .reg_bits = 16,
 223        .val_bits = 16,
 224
 225        .max_register = 0x4003,
 226
 227        .writeable_reg = si476x_core_regmap_writable_register,
 228        .readable_reg = si476x_core_regmap_readable_register,
 229
 230        .reg_read = si476x_core_regmap_read,
 231        .reg_write = si476x_core_regmap_write,
 232
 233        .cache_type = REGCACHE_RBTREE,
 234};
 235
 236struct regmap *devm_regmap_init_si476x(struct si476x_core *core)
 237{
 238        return devm_regmap_init(&core->client->dev, NULL,
 239                                core, &si476x_regmap_config);
 240}
 241EXPORT_SYMBOL_GPL(devm_regmap_init_si476x);
 242
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.