i2c/ccs/ccs-reg-access.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * drivers/media/i2c/ccs/ccs-reg-access.c
0004  *
0005  * Generic driver for MIPI CCS/SMIA/SMIA++ compliant camera sensors
0006  *
0007  * Copyright (C) 2020 Intel Corporation
0008  * Copyright (C) 2011--2012 Nokia Corporation
0009  * Contact: Sakari Ailus <sakari.ailus@linux.intel.com>
0010  */
0011
0012 #include <asm/unaligned.h>
0013
0014 #include <linux/delay.h>
0015 #include <linux/i2c.h>
0016
0017 #include "ccs.h"
0018 #include "ccs-limits.h"
0019
0020 static u32 float_to_u32_mul_1000000(struct i2c_client *client, u32 phloat)
0021 {
0022     s32 exp;
0023     u64 man;
0024
0025     if (phloat >= 0x80000000) {
0026         dev_err(&client->dev, "this is a negative number\n");
0027         return 0;
0028     }
0029
0030     if (phloat == 0x7f800000)
0031         return ~0; /* Inf. */
0032
0033     if ((phloat & 0x7f800000) == 0x7f800000) {
0034         dev_err(&client->dev, "NaN or other special number\n");
0035         return 0;
0036     }
0037
0038     /* Valid cases begin here */
0039     if (phloat == 0)
0040         return 0; /* Valid zero */
0041
0042     if (phloat > 0x4f800000)
0043         return ~0; /* larger than 4294967295 */
0044
0045     /*
0046      * Unbias exponent (note how phloat is now guaranteed to
0047      * have 0 in the high bit)
0048      */
0049     exp = ((int32_t)phloat >> 23) - 127;
0050
0051     /* Extract mantissa, add missing '1' bit and it's in MHz */
0052     man = ((phloat & 0x7fffff) | 0x800000) * 1000000ULL;
0053
0054     if (exp < 0)
0055         man >>= -exp;
0056     else
0057         man <<= exp;
0058
0059     man >>= 23; /* Remove mantissa bias */
0060
0061     return man & 0xffffffff;
0062 }
0063
0064
0065 /*
0066  * Read a 8/16/32-bit i2c register.  The value is returned in 'val'.
0067  * Returns zero if successful, or non-zero otherwise.
0068  */
0069 static int ____ccs_read_addr(struct ccs_sensor *sensor, u16 reg, u16 len,
0070                  u32 *val)
0071 {
0072     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0073     struct i2c_msg msg;
0074     unsigned char data_buf[sizeof(u32)] = { 0 };
0075     unsigned char offset_buf[sizeof(u16)];
0076     int r;
0077
0078     if (len > sizeof(data_buf))
0079         return -EINVAL;
0080
0081     msg.addr = client->addr;
0082     msg.flags = 0;
0083     msg.len = sizeof(offset_buf);
0084     msg.buf = offset_buf;
0085     put_unaligned_be16(reg, offset_buf);
0086
0087     r = i2c_transfer(client->adapter, &msg, 1);
0088     if (r != 1) {
0089         if (r >= 0)
0090             r = -EBUSY;
0091         goto err;
0092     }
0093
0094     msg.len = len;
0095     msg.flags = I2C_M_RD;
0096     msg.buf = &data_buf[sizeof(data_buf) - len];
0097
0098     r = i2c_transfer(client->adapter, &msg, 1);
0099     if (r != 1) {
0100         if (r >= 0)
0101             r = -EBUSY;
0102         goto err;
0103     }
0104
0105     *val = get_unaligned_be32(data_buf);
0106
0107     return 0;
0108
0109 err:
0110     dev_err(&client->dev, "read from offset 0x%x error %d\n", reg, r);
0111
0112     return r;
0113 }
0114
0115 /* Read a register using 8-bit access only. */
0116 static int ____ccs_read_addr_8only(struct ccs_sensor *sensor, u16 reg,
0117                    u16 len, u32 *val)
0118 {
0119     unsigned int i;
0120     int rval;
0121
0122     *val = 0;
0123
0124     for (i = 0; i < len; i++) {
0125         u32 val8;
0126
0127         rval = ____ccs_read_addr(sensor, reg + i, 1, &val8);
0128         if (rval < 0)
0129             return rval;
0130         *val |= val8 << ((len - i - 1) << 3);
0131     }
0132
0133     return 0;
0134 }
0135
0136 unsigned int ccs_reg_width(u32 reg)
0137 {
0138     if (reg & CCS_FL_16BIT)
0139         return sizeof(u16);
0140     if (reg & CCS_FL_32BIT)
0141         return sizeof(u32);
0142
0143     return sizeof(u8);
0144 }
0145
0146 static u32 ireal32_to_u32_mul_1000000(struct i2c_client *client, u32 val)
0147 {
0148     if (val >> 10 > U32_MAX / 15625) {
0149         dev_warn(&client->dev, "value %u overflows!\n", val);
0150         return U32_MAX;
0151     }
0152
0153     return ((val >> 10) * 15625) +
0154         (val & GENMASK(9, 0)) * 15625 / 1024;
0155 }
0156
0157 u32 ccs_reg_conv(struct ccs_sensor *sensor, u32 reg, u32 val)
0158 {
0159     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0160
0161     if (reg & CCS_FL_FLOAT_IREAL) {
0162         if (CCS_LIM(sensor, CLOCK_CAPA_TYPE_CAPABILITY) &
0163             CCS_CLOCK_CAPA_TYPE_CAPABILITY_IREAL)
0164             val = ireal32_to_u32_mul_1000000(client, val);
0165         else
0166             val = float_to_u32_mul_1000000(client, val);
0167     } else if (reg & CCS_FL_IREAL) {
0168         val = ireal32_to_u32_mul_1000000(client, val);
0169     }
0170
0171     return val;
0172 }
0173
0174 /*
0175  * Read a 8/16/32-bit i2c register.  The value is returned in 'val'.
0176  * Returns zero if successful, or non-zero otherwise.
0177  */
0178 static int __ccs_read_addr(struct ccs_sensor *sensor, u32 reg, u32 *val,
0179                bool only8, bool conv)
0180 {
0181     unsigned int len = ccs_reg_width(reg);
0182     int rval;
0183
0184     if (!only8)
0185         rval = ____ccs_read_addr(sensor, CCS_REG_ADDR(reg), len, val);
0186     else
0187         rval = ____ccs_read_addr_8only(sensor, CCS_REG_ADDR(reg), len,
0188                            val);
0189     if (rval < 0)
0190         return rval;
0191
0192     if (!conv)
0193         return 0;
0194
0195     *val = ccs_reg_conv(sensor, reg, *val);
0196
0197     return 0;
0198 }
0199
0200 static int __ccs_read_data(struct ccs_reg *regs, size_t num_regs,
0201                u32 reg, u32 *val)
0202 {
0203     unsigned int width = ccs_reg_width(reg);
0204     size_t i;
0205
0206     for (i = 0; i < num_regs; i++, regs++) {
0207         u8 *data;
0208
0209         if (regs->addr + regs->len < CCS_REG_ADDR(reg) + width)
0210             continue;
0211
0212         if (regs->addr > CCS_REG_ADDR(reg))
0213             break;
0214
0215         data = &regs->value[CCS_REG_ADDR(reg) - regs->addr];
0216
0217         switch (width) {
0218         case sizeof(u8):
0219             *val = *data;
0220             break;
0221         case sizeof(u16):
0222             *val = get_unaligned_be16(data);
0223             break;
0224         case sizeof(u32):
0225             *val = get_unaligned_be32(data);
0226             break;
0227         default:
0228             WARN_ON(1);
0229             return -EINVAL;
0230         }
0231
0232         return 0;
0233     }
0234
0235     return -ENOENT;
0236 }
0237
0238 static int ccs_read_data(struct ccs_sensor *sensor, u32 reg, u32 *val)
0239 {
0240     if (!__ccs_read_data(sensor->sdata.sensor_read_only_regs,
0241                  sensor->sdata.num_sensor_read_only_regs,
0242                  reg, val))
0243         return 0;
0244
0245     return __ccs_read_data(sensor->mdata.module_read_only_regs,
0246                    sensor->mdata.num_module_read_only_regs,
0247                    reg, val);
0248 }
0249
0250 static int ccs_read_addr_raw(struct ccs_sensor *sensor, u32 reg, u32 *val,
0251                  bool force8, bool quirk, bool conv, bool data)
0252 {
0253     int rval;
0254
0255     if (data) {
0256         rval = ccs_read_data(sensor, reg, val);
0257         if (!rval)
0258             return 0;
0259     }
0260
0261     if (quirk) {
0262         *val = 0;
0263         rval = ccs_call_quirk(sensor, reg_access, false, &reg, val);
0264         if (rval == -ENOIOCTLCMD)
0265             return 0;
0266         if (rval < 0)
0267             return rval;
0268
0269         if (force8)
0270             return __ccs_read_addr(sensor, reg, val, true, conv);
0271     }
0272
0273     return __ccs_read_addr(sensor, reg, val,
0274                    ccs_needs_quirk(sensor,
0275                            CCS_QUIRK_FLAG_8BIT_READ_ONLY),
0276                    conv);
0277 }
0278
0279 int ccs_read_addr(struct ccs_sensor *sensor, u32 reg, u32 *val)
0280 {
0281     return ccs_read_addr_raw(sensor, reg, val, false, true, true, true);
0282 }
0283
0284 int ccs_read_addr_8only(struct ccs_sensor *sensor, u32 reg, u32 *val)
0285 {
0286     return ccs_read_addr_raw(sensor, reg, val, true, true, true, true);
0287 }
0288
0289 int ccs_read_addr_noconv(struct ccs_sensor *sensor, u32 reg, u32 *val)
0290 {
0291     return ccs_read_addr_raw(sensor, reg, val, false, true, false, true);
0292 }
0293
0294 static int ccs_write_retry(struct i2c_client *client, struct i2c_msg *msg)
0295 {
0296     unsigned int retries;
0297     int r;
0298
0299     for (retries = 0; retries < 10; retries++) {
0300         /*
0301          * Due to unknown reason sensor stops responding. This
0302          * loop is a temporaty solution until the root cause
0303          * is found.
0304          */
0305         r = i2c_transfer(client->adapter, msg, 1);
0306         if (r != 1) {
0307             usleep_range(1000, 2000);
0308             continue;
0309         }
0310
0311         if (retries)
0312             dev_err(&client->dev,
0313                 "sensor i2c stall encountered. retries: %d\n",
0314                 retries);
0315         return 0;
0316     }
0317
0318     return r;
0319 }
0320
0321 int ccs_write_addr_no_quirk(struct ccs_sensor *sensor, u32 reg, u32 val)
0322 {
0323     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0324     struct i2c_msg msg;
0325     unsigned char data[6];
0326     unsigned int len = ccs_reg_width(reg);
0327     int r;
0328
0329     if (len > sizeof(data) - 2)
0330         return -EINVAL;
0331
0332     msg.addr = client->addr;
0333     msg.flags = 0; /* Write */
0334     msg.len = 2 + len;
0335     msg.buf = data;
0336
0337     put_unaligned_be16(CCS_REG_ADDR(reg), data);
0338     put_unaligned_be32(val << (8 * (sizeof(val) - len)), data + 2);
0339
0340     dev_dbg(&client->dev, "writing reg 0x%4.4x value 0x%*.*x (%u)\n",
0341         CCS_REG_ADDR(reg), ccs_reg_width(reg) << 1,
0342         ccs_reg_width(reg) << 1, val, val);
0343
0344     r = ccs_write_retry(client, &msg);
0345     if (r)
0346         dev_err(&client->dev,
0347             "wrote 0x%x to offset 0x%x error %d\n", val,
0348             CCS_REG_ADDR(reg), r);
0349
0350     return r;
0351 }
0352
0353 /*
0354  * Write to a 8/16-bit register.
0355  * Returns zero if successful, or non-zero otherwise.
0356  */
0357 int ccs_write_addr(struct ccs_sensor *sensor, u32 reg, u32 val)
0358 {
0359     int rval;
0360
0361     rval = ccs_call_quirk(sensor, reg_access, true, &reg, &val);
0362     if (rval == -ENOIOCTLCMD)
0363         return 0;
0364     if (rval < 0)
0365         return rval;
0366
0367     return ccs_write_addr_no_quirk(sensor, reg, val);
0368 }
0369
0370 #define MAX_WRITE_LEN   32U
0371
0372 int ccs_write_data_regs(struct ccs_sensor *sensor, struct ccs_reg *regs,
0373             size_t num_regs)
0374 {
0375     struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
0376     unsigned char buf[2 + MAX_WRITE_LEN];
0377     struct i2c_msg msg = {
0378         .addr = client->addr,
0379         .buf = buf,
0380     };
0381     size_t i;
0382
0383     for (i = 0; i < num_regs; i++, regs++) {
0384         unsigned char *regdata = regs->value;
0385         unsigned int j;
0386
0387         for (j = 0; j < regs->len;
0388              j += msg.len - 2, regdata += msg.len - 2) {
0389             char printbuf[(MAX_WRITE_LEN << 1) +
0390                       1 /* \0 */] = { 0 };
0391             int rval;
0392
0393             msg.len = min(regs->len - j, MAX_WRITE_LEN);
0394
0395             bin2hex(printbuf, regdata, msg.len);
0396             dev_dbg(&client->dev,
0397                 "writing msr reg 0x%4.4x value 0x%s\n",
0398                 regs->addr + j, printbuf);
0399
0400             put_unaligned_be16(regs->addr + j, buf);
0401             memcpy(buf + 2, regdata, msg.len);
0402
0403             msg.len += 2;
0404
0405             rval = ccs_write_retry(client, &msg);
0406             if (rval) {
0407                 dev_err(&client->dev,
0408                     "error writing %u octets to address 0x%4.4x\n",
0409                     msg.len, regs->addr + j);
0410                 return rval;
0411             }
0412         }
0413     }
0414
0415     return 0;
0416 }