1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * drivers/media/i2c/ccs/ccs-reg-access.c 4 * 5 * Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors 6 * 7 * Copyright (C) 2020 Intel Corporation 8 * Copyright (C) 2011--2012 Nokia Corporation 9 * Contact: Sakari Ailus <sakari.ailus@linux.intel.com> 10 */ 11 12 #include <linux/unaligned.h> 13 14 #include <linux/delay.h> 15 #include <linux/hex.h> 16 #include <linux/i2c.h> 17 18 #include "ccs.h" 19 #include "ccs-limits.h" 20 21 static u32 float_to_u32_mul_1000000(struct i2c_client *client, u32 phloat) 22 { 23 s32 exp; 24 u64 man; 25 26 if (phloat >= 0x80000000) { 27 dev_err(&client->dev, "this is a negative number\n"); 28 return 0; 29 } 30 31 if (phloat == 0x7f800000) 32 return ~0; /* Inf. */ 33 34 if ((phloat & 0x7f800000) == 0x7f800000) { 35 dev_err(&client->dev, "NaN or other special number\n"); 36 return 0; 37 } 38 39 /* Valid cases begin here */ 40 if (phloat == 0) 41 return 0; /* Valid zero */ 42 43 if (phloat > 0x4f800000) 44 return ~0; /* larger than 4294967295 */ 45 46 /* 47 * Unbias exponent (note how phloat is now guaranteed to 48 * have 0 in the high bit) 49 */ 50 exp = ((int32_t)phloat >> 23) - 127; 51 52 /* Extract mantissa, add missing '1' bit and it's in MHz */ 53 man = ((phloat & 0x7fffff) | 0x800000) * 1000000ULL; 54 55 if (exp < 0) 56 man >>= -exp; 57 else 58 man <<= exp; 59 60 man >>= 23; /* Remove mantissa bias */ 61 62 return man & 0xffffffff; 63 } 64 65 66 static u32 ireal32_to_u32_mul_1000000(struct i2c_client *client, u32 val) 67 { 68 if (val >> 10 > U32_MAX / 15625) { 69 dev_warn(&client->dev, "value %u overflows!\n", val); 70 return U32_MAX; 71 } 72 73 return ((val >> 10) * 15625) + 74 (val & GENMASK(9, 0)) * 15625 / 1024; 75 } 76 77 u32 ccs_reg_conv(struct ccs_sensor *sensor, u32 reg, u32 val) 78 { 79 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 80 81 if (reg & CCS_FL_FLOAT_IREAL) { 82 if (CCS_LIM(sensor, CLOCK_CAPA_TYPE_CAPABILITY) & 83 CCS_CLOCK_CAPA_TYPE_CAPABILITY_IREAL) 84 val = ireal32_to_u32_mul_1000000(client, val); 85 else 86 val = float_to_u32_mul_1000000(client, val); 87 } else if (reg & CCS_FL_IREAL) { 88 val = ireal32_to_u32_mul_1000000(client, val); 89 } 90 91 return val; 92 } 93 94 /* 95 * Read a 8/16/32-bit i2c register. The value is returned in 'val'. 96 * Returns zero if successful, or non-zero otherwise. 97 */ 98 static int __ccs_read_addr(struct ccs_sensor *sensor, u32 reg, u32 *val, 99 bool only8, bool conv) 100 { 101 u64 __val; 102 int rval; 103 104 rval = cci_read(sensor->regmap, reg, &__val, NULL); 105 if (rval < 0) 106 return rval; 107 108 *val = conv ? ccs_reg_conv(sensor, reg, __val) : __val; 109 110 return 0; 111 } 112 113 static int __ccs_static_data_read_ro_reg(struct ccs_reg *regs, size_t num_regs, 114 u32 reg, u32 *val) 115 { 116 unsigned int width = CCI_REG_WIDTH_BYTES(reg); 117 size_t i; 118 119 for (i = 0; i < num_regs; i++, regs++) { 120 u8 *data; 121 122 if (regs->addr + regs->len < CCS_REG_ADDR(reg) + width) 123 continue; 124 125 if (regs->addr > CCS_REG_ADDR(reg)) 126 break; 127 128 data = ®s->value[CCS_REG_ADDR(reg) - regs->addr]; 129 130 switch (width) { 131 case sizeof(u8): 132 *val = *data; 133 break; 134 case sizeof(u16): 135 *val = get_unaligned_be16(data); 136 break; 137 case sizeof(u32): 138 *val = get_unaligned_be32(data); 139 break; 140 default: 141 WARN_ON(1); 142 return -EINVAL; 143 } 144 145 return 0; 146 } 147 148 return -ENOENT; 149 } 150 151 static int 152 ccs_static_data_read_ro_reg(struct ccs_sensor *sensor, u32 reg, u32 *val) 153 { 154 if (!__ccs_static_data_read_ro_reg(sensor->sdata.sensor_read_only_regs, 155 sensor->sdata.num_sensor_read_only_regs, 156 reg, val)) 157 return 0; 158 159 return __ccs_static_data_read_ro_reg(sensor->mdata.module_read_only_regs, 160 sensor->mdata.num_module_read_only_regs, 161 reg, val); 162 } 163 164 static int ccs_read_addr_raw(struct ccs_sensor *sensor, u32 reg, u32 *val, 165 bool force8, bool quirk, bool conv, bool data) 166 { 167 int rval; 168 169 if (data) { 170 rval = ccs_static_data_read_ro_reg(sensor, reg, val); 171 if (!rval) 172 return 0; 173 } 174 175 if (quirk) { 176 *val = 0; 177 rval = ccs_call_quirk(sensor, reg_access, false, ®, val); 178 if (rval == -ENOIOCTLCMD) 179 return 0; 180 if (rval < 0) 181 return rval; 182 183 if (force8) 184 return __ccs_read_addr(sensor, reg, val, true, conv); 185 } 186 187 return __ccs_read_addr(sensor, reg, val, 188 ccs_needs_quirk(sensor, 189 CCS_QUIRK_FLAG_8BIT_READ_ONLY), 190 conv); 191 } 192 193 int ccs_read_addr(struct ccs_sensor *sensor, u32 reg, u32 *val) 194 { 195 return ccs_read_addr_raw(sensor, reg, val, false, true, true, true); 196 } 197 198 int ccs_read_addr_8only(struct ccs_sensor *sensor, u32 reg, u32 *val) 199 { 200 return ccs_read_addr_raw(sensor, reg, val, true, true, true, true); 201 } 202 203 int ccs_read_addr_noconv(struct ccs_sensor *sensor, u32 reg, u32 *val) 204 { 205 return ccs_read_addr_raw(sensor, reg, val, false, true, false, true); 206 } 207 208 /* 209 * Write to a 8/16-bit register. 210 * Returns zero if successful, or non-zero otherwise. 211 */ 212 int ccs_write_addr(struct ccs_sensor *sensor, u32 reg, u32 val) 213 { 214 int rval; 215 216 rval = ccs_call_quirk(sensor, reg_access, true, ®, &val); 217 if (rval == -ENOIOCTLCMD) 218 return 0; 219 if (rval < 0) 220 return rval; 221 222 return cci_write(sensor->regmap, reg, val, NULL); 223 } 224 225 #define MAX_WRITE_LEN 32U 226 227 int ccs_write_data_regs(struct ccs_sensor *sensor, struct ccs_reg *regs, 228 size_t num_regs) 229 { 230 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 231 size_t i; 232 233 for (i = 0; i < num_regs; i++, regs++) { 234 unsigned char *regdata = regs->value; 235 unsigned int j; 236 int len; 237 238 for (j = 0; j < regs->len; j += len, regdata += len) { 239 char printbuf[(MAX_WRITE_LEN << 1) + 240 1 /* \0 */] = { 0 }; 241 unsigned int retries = 10; 242 int rval; 243 244 len = min(regs->len - j, MAX_WRITE_LEN); 245 246 bin2hex(printbuf, regdata, len); 247 dev_dbg(&client->dev, 248 "writing msr reg 0x%4.4x value 0x%s\n", 249 regs->addr + j, printbuf); 250 251 do { 252 rval = regmap_bulk_write(sensor->regmap, 253 regs->addr + j, 254 regdata, len); 255 if (rval) 256 fsleep(1000); 257 } while (rval && --retries); 258 259 if (rval) { 260 dev_err(&client->dev, 261 "error writing %u octets to address 0x%4.4x\n", 262 len, regs->addr + j); 263 return rval; 264 } 265 } 266 } 267 268 return 0; 269 } 270