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 23 struct si476x_property_range { 24 u16 low, high; 25 }; 26 27 static 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 40 static 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 53 static 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 94 static 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 115 static 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 141 typedef bool (*valid_property_pred_t) (struct si476x_core *, u16); 142 143 static 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 158 static 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 178 static 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 188 static 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 199 static 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 205 static 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 221 static 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 236 struct 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 } 241 EXPORT_SYMBOL_GPL(devm_regmap_init_si476x); 242