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 <asm/unaligned.h>
13
14 #include <linux/delay.h>
15 #include <linux/i2c.h>
16
17 #include "ccs.h"
18 #include "ccs-limits.h"
19
float_to_u32_mul_1000000(struct i2c_client * client,u32 phloat)20 static u32 float_to_u32_mul_1000000(struct i2c_client *client, u32 phloat)
21 {
22 s32 exp;
23 u64 man;
24
25 if (phloat >= 0x80000000) {
26 dev_err(&client->dev, "this is a negative number\n");
27 return 0;
28 }
29
30 if (phloat == 0x7f800000)
31 return ~0; /* Inf. */
32
33 if ((phloat & 0x7f800000) == 0x7f800000) {
34 dev_err(&client->dev, "NaN or other special number\n");
35 return 0;
36 }
37
38 /* Valid cases begin here */
39 if (phloat == 0)
40 return 0; /* Valid zero */
41
42 if (phloat > 0x4f800000)
43 return ~0; /* larger than 4294967295 */
44
45 /*
46 * Unbias exponent (note how phloat is now guaranteed to
47 * have 0 in the high bit)
48 */
49 exp = ((int32_t)phloat >> 23) - 127;
50
51 /* Extract mantissa, add missing '1' bit and it's in MHz */
52 man = ((phloat & 0x7fffff) | 0x800000) * 1000000ULL;
53
54 if (exp < 0)
55 man >>= -exp;
56 else
57 man <<= exp;
58
59 man >>= 23; /* Remove mantissa bias */
60
61 return man & 0xffffffff;
62 }
63
64
65 /*
66 * Read a 8/16/32-bit i2c register. The value is returned in 'val'.
67 * Returns zero if successful, or non-zero otherwise.
68 */
____ccs_read_addr(struct ccs_sensor * sensor,u16 reg,u16 len,u32 * val)69 static int ____ccs_read_addr(struct ccs_sensor *sensor, u16 reg, u16 len,
70 u32 *val)
71 {
72 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
73 struct i2c_msg msg;
74 unsigned char data_buf[sizeof(u32)] = { 0 };
75 unsigned char offset_buf[sizeof(u16)];
76 int r;
77
78 if (len > sizeof(data_buf))
79 return -EINVAL;
80
81 msg.addr = client->addr;
82 msg.flags = 0;
83 msg.len = sizeof(offset_buf);
84 msg.buf = offset_buf;
85 put_unaligned_be16(reg, offset_buf);
86
87 r = i2c_transfer(client->adapter, &msg, 1);
88 if (r != 1) {
89 if (r >= 0)
90 r = -EBUSY;
91 goto err;
92 }
93
94 msg.len = len;
95 msg.flags = I2C_M_RD;
96 msg.buf = &data_buf[sizeof(data_buf) - len];
97
98 r = i2c_transfer(client->adapter, &msg, 1);
99 if (r != 1) {
100 if (r >= 0)
101 r = -EBUSY;
102 goto err;
103 }
104
105 *val = get_unaligned_be32(data_buf);
106
107 return 0;
108
109 err:
110 dev_err(&client->dev, "read from offset 0x%x error %d\n", reg, r);
111
112 return r;
113 }
114
115 /* Read a register using 8-bit access only. */
____ccs_read_addr_8only(struct ccs_sensor * sensor,u16 reg,u16 len,u32 * val)116 static int ____ccs_read_addr_8only(struct ccs_sensor *sensor, u16 reg,
117 u16 len, u32 *val)
118 {
119 unsigned int i;
120 int rval;
121
122 *val = 0;
123
124 for (i = 0; i < len; i++) {
125 u32 val8;
126
127 rval = ____ccs_read_addr(sensor, reg + i, 1, &val8);
128 if (rval < 0)
129 return rval;
130 *val |= val8 << ((len - i - 1) << 3);
131 }
132
133 return 0;
134 }
135
ccs_reg_width(u32 reg)136 unsigned int ccs_reg_width(u32 reg)
137 {
138 if (reg & CCS_FL_16BIT)
139 return sizeof(u16);
140 if (reg & CCS_FL_32BIT)
141 return sizeof(u32);
142
143 return sizeof(u8);
144 }
145
ireal32_to_u32_mul_1000000(struct i2c_client * client,u32 val)146 static u32 ireal32_to_u32_mul_1000000(struct i2c_client *client, u32 val)
147 {
148 if (val >> 10 > U32_MAX / 15625) {
149 dev_warn(&client->dev, "value %u overflows!\n", val);
150 return U32_MAX;
151 }
152
153 return ((val >> 10) * 15625) +
154 (val & GENMASK(9, 0)) * 15625 / 1024;
155 }
156
ccs_reg_conv(struct ccs_sensor * sensor,u32 reg,u32 val)157 u32 ccs_reg_conv(struct ccs_sensor *sensor, u32 reg, u32 val)
158 {
159 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
160
161 if (reg & CCS_FL_FLOAT_IREAL) {
162 if (CCS_LIM(sensor, CLOCK_CAPA_TYPE_CAPABILITY) &
163 CCS_CLOCK_CAPA_TYPE_CAPABILITY_IREAL)
164 val = ireal32_to_u32_mul_1000000(client, val);
165 else
166 val = float_to_u32_mul_1000000(client, val);
167 } else if (reg & CCS_FL_IREAL) {
168 val = ireal32_to_u32_mul_1000000(client, val);
169 }
170
171 return val;
172 }
173
174 /*
175 * Read a 8/16/32-bit i2c register. The value is returned in 'val'.
176 * Returns zero if successful, or non-zero otherwise.
177 */
__ccs_read_addr(struct ccs_sensor * sensor,u32 reg,u32 * val,bool only8,bool conv)178 static int __ccs_read_addr(struct ccs_sensor *sensor, u32 reg, u32 *val,
179 bool only8, bool conv)
180 {
181 unsigned int len = ccs_reg_width(reg);
182 int rval;
183
184 if (!only8)
185 rval = ____ccs_read_addr(sensor, CCS_REG_ADDR(reg), len, val);
186 else
187 rval = ____ccs_read_addr_8only(sensor, CCS_REG_ADDR(reg), len,
188 val);
189 if (rval < 0)
190 return rval;
191
192 if (!conv)
193 return 0;
194
195 *val = ccs_reg_conv(sensor, reg, *val);
196
197 return 0;
198 }
199
__ccs_read_data(struct ccs_reg * regs,size_t num_regs,u32 reg,u32 * val)200 static int __ccs_read_data(struct ccs_reg *regs, size_t num_regs,
201 u32 reg, u32 *val)
202 {
203 unsigned int width = ccs_reg_width(reg);
204 size_t i;
205
206 for (i = 0; i < num_regs; i++, regs++) {
207 u8 *data;
208
209 if (regs->addr + regs->len < CCS_REG_ADDR(reg) + width)
210 continue;
211
212 if (regs->addr > CCS_REG_ADDR(reg))
213 break;
214
215 data = ®s->value[CCS_REG_ADDR(reg) - regs->addr];
216
217 switch (width) {
218 case sizeof(u8):
219 *val = *data;
220 break;
221 case sizeof(u16):
222 *val = get_unaligned_be16(data);
223 break;
224 case sizeof(u32):
225 *val = get_unaligned_be32(data);
226 break;
227 default:
228 WARN_ON(1);
229 return -EINVAL;
230 }
231
232 return 0;
233 }
234
235 return -ENOENT;
236 }
237
ccs_read_data(struct ccs_sensor * sensor,u32 reg,u32 * val)238 static int ccs_read_data(struct ccs_sensor *sensor, u32 reg, u32 *val)
239 {
240 if (!__ccs_read_data(sensor->sdata.sensor_read_only_regs,
241 sensor->sdata.num_sensor_read_only_regs,
242 reg, val))
243 return 0;
244
245 return __ccs_read_data(sensor->mdata.module_read_only_regs,
246 sensor->mdata.num_module_read_only_regs,
247 reg, val);
248 }
249
ccs_read_addr_raw(struct ccs_sensor * sensor,u32 reg,u32 * val,bool force8,bool quirk,bool conv,bool data)250 static int ccs_read_addr_raw(struct ccs_sensor *sensor, u32 reg, u32 *val,
251 bool force8, bool quirk, bool conv, bool data)
252 {
253 int rval;
254
255 if (data) {
256 rval = ccs_read_data(sensor, reg, val);
257 if (!rval)
258 return 0;
259 }
260
261 if (quirk) {
262 *val = 0;
263 rval = ccs_call_quirk(sensor, reg_access, false, ®, val);
264 if (rval == -ENOIOCTLCMD)
265 return 0;
266 if (rval < 0)
267 return rval;
268
269 if (force8)
270 return __ccs_read_addr(sensor, reg, val, true, conv);
271 }
272
273 return __ccs_read_addr(sensor, reg, val,
274 ccs_needs_quirk(sensor,
275 CCS_QUIRK_FLAG_8BIT_READ_ONLY),
276 conv);
277 }
278
ccs_read_addr(struct ccs_sensor * sensor,u32 reg,u32 * val)279 int ccs_read_addr(struct ccs_sensor *sensor, u32 reg, u32 *val)
280 {
281 return ccs_read_addr_raw(sensor, reg, val, false, true, true, true);
282 }
283
ccs_read_addr_8only(struct ccs_sensor * sensor,u32 reg,u32 * val)284 int ccs_read_addr_8only(struct ccs_sensor *sensor, u32 reg, u32 *val)
285 {
286 return ccs_read_addr_raw(sensor, reg, val, true, true, true, true);
287 }
288
ccs_read_addr_noconv(struct ccs_sensor * sensor,u32 reg,u32 * val)289 int ccs_read_addr_noconv(struct ccs_sensor *sensor, u32 reg, u32 *val)
290 {
291 return ccs_read_addr_raw(sensor, reg, val, false, true, false, true);
292 }
293
ccs_write_retry(struct i2c_client * client,struct i2c_msg * msg)294 static int ccs_write_retry(struct i2c_client *client, struct i2c_msg *msg)
295 {
296 unsigned int retries;
297 int r;
298
299 for (retries = 0; retries < 10; retries++) {
300 /*
301 * Due to unknown reason sensor stops responding. This
302 * loop is a temporaty solution until the root cause
303 * is found.
304 */
305 r = i2c_transfer(client->adapter, msg, 1);
306 if (r != 1) {
307 usleep_range(1000, 2000);
308 continue;
309 }
310
311 if (retries)
312 dev_err(&client->dev,
313 "sensor i2c stall encountered. retries: %d\n",
314 retries);
315 return 0;
316 }
317
318 return r;
319 }
320
ccs_write_addr_no_quirk(struct ccs_sensor * sensor,u32 reg,u32 val)321 int ccs_write_addr_no_quirk(struct ccs_sensor *sensor, u32 reg, u32 val)
322 {
323 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
324 struct i2c_msg msg;
325 unsigned char data[6];
326 unsigned int len = ccs_reg_width(reg);
327 int r;
328
329 if (len > sizeof(data) - 2)
330 return -EINVAL;
331
332 msg.addr = client->addr;
333 msg.flags = 0; /* Write */
334 msg.len = 2 + len;
335 msg.buf = data;
336
337 put_unaligned_be16(CCS_REG_ADDR(reg), data);
338 put_unaligned_be32(val << (8 * (sizeof(val) - len)), data + 2);
339
340 dev_dbg(&client->dev, "writing reg 0x%4.4x value 0x%*.*x (%u)\n",
341 CCS_REG_ADDR(reg), ccs_reg_width(reg) << 1,
342 ccs_reg_width(reg) << 1, val, val);
343
344 r = ccs_write_retry(client, &msg);
345 if (r)
346 dev_err(&client->dev,
347 "wrote 0x%x to offset 0x%x error %d\n", val,
348 CCS_REG_ADDR(reg), r);
349
350 return r;
351 }
352
353 /*
354 * Write to a 8/16-bit register.
355 * Returns zero if successful, or non-zero otherwise.
356 */
ccs_write_addr(struct ccs_sensor * sensor,u32 reg,u32 val)357 int ccs_write_addr(struct ccs_sensor *sensor, u32 reg, u32 val)
358 {
359 int rval;
360
361 rval = ccs_call_quirk(sensor, reg_access, true, ®, &val);
362 if (rval == -ENOIOCTLCMD)
363 return 0;
364 if (rval < 0)
365 return rval;
366
367 return ccs_write_addr_no_quirk(sensor, reg, val);
368 }
369
370 #define MAX_WRITE_LEN 32U
371
ccs_write_data_regs(struct ccs_sensor * sensor,struct ccs_reg * regs,size_t num_regs)372 int ccs_write_data_regs(struct ccs_sensor *sensor, struct ccs_reg *regs,
373 size_t num_regs)
374 {
375 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
376 unsigned char buf[2 + MAX_WRITE_LEN];
377 struct i2c_msg msg = {
378 .addr = client->addr,
379 .buf = buf,
380 };
381 size_t i;
382
383 for (i = 0; i < num_regs; i++, regs++) {
384 unsigned char *regdata = regs->value;
385 unsigned int j;
386
387 for (j = 0; j < regs->len;
388 j += msg.len - 2, regdata += msg.len - 2) {
389 char printbuf[(MAX_WRITE_LEN << 1) +
390 1 /* \0 */] = { 0 };
391 int rval;
392
393 msg.len = min(regs->len - j, MAX_WRITE_LEN);
394
395 bin2hex(printbuf, regdata, msg.len);
396 dev_dbg(&client->dev,
397 "writing msr reg 0x%4.4x value 0x%s\n",
398 regs->addr + j, printbuf);
399
400 put_unaligned_be16(regs->addr + j, buf);
401 memcpy(buf + 2, regdata, msg.len);
402
403 msg.len += 2;
404
405 rval = ccs_write_retry(client, &msg);
406 if (rval) {
407 dev_err(&client->dev,
408 "error writing %u octets to address 0x%4.4x\n",
409 msg.len, regs->addr + j);
410 return rval;
411 }
412 }
413 }
414
415 return 0;
416 }
417