// SPDX-License-Identifier: GPL-2.0-only
/*
 * drivers/media/i2c/smiapp/smiapp-regs.c
 *
 * Generic driver for SMIA/SMIA++ compliant camera modules
 *
 * Copyright (C) 2011--2012 Nokia Corporation
 * Contact: Sakari Ailus <sakari.ailus@iki.fi>
 */

#include <linux/delay.h>
#include <linux/i2c.h>

#include "smiapp.h"
#include "smiapp-regs.h"

static uint32_t float_to_u32_mul_1000000(struct i2c_client *client,
                                         uint32_t phloat)
{
        int32_t exp;
        uint64_t man;

        if (phloat >= 0x80000000) {
                dev_err(&client->dev, "this is a negative number\n");
                return 0;
        }

        if (phloat == 0x7f800000)
                return ~0; /* Inf. */

        if ((phloat & 0x7f800000) == 0x7f800000) {
                dev_err(&client->dev, "NaN or other special number\n");
                return 0;
        }

        /* Valid cases begin here */
        if (phloat == 0)
                return 0; /* Valid zero */

        if (phloat > 0x4f800000)
                return ~0; /* larger than 4294967295 */

        /*
         * Unbias exponent (note how phloat is now guaranteed to
         * have 0 in the high bit)
         */
        exp = ((int32_t)phloat >> 23) - 127;

        /* Extract mantissa, add missing '1' bit and it's in MHz */
        man = ((phloat & 0x7fffff) | 0x800000) * 1000000ULL;

        if (exp < 0)
                man >>= -exp;
        else
                man <<= exp;

        man >>= 23; /* Remove mantissa bias */

        return man & 0xffffffff;
}


/*
 * Read a 8/16/32-bit i2c register.  The value is returned in 'val'.
 * Returns zero if successful, or non-zero otherwise.
 */
static int ____smiapp_read(struct smiapp_sensor *sensor, u16 reg,
                           u16 len, u32 *val)
{
        struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
        struct i2c_msg msg;
        unsigned char data[4];
        u16 offset = reg;
        int r;

        msg.addr = client->addr;
        msg.flags = 0;
        msg.len = 2;
        msg.buf = data;

        /* high byte goes out first */
        data[0] = (u8) (offset >> 8);
        data[1] = (u8) offset;
        r = i2c_transfer(client->adapter, &msg, 1);
        if (r != 1) {
                if (r >= 0)
                        r = -EBUSY;
                goto err;
        }

        msg.len = len;
        msg.flags = I2C_M_RD;
        r = i2c_transfer(client->adapter, &msg, 1);
        if (r != 1) {
                if (r >= 0)
                        r = -EBUSY;
                goto err;
        }

        *val = 0;
        /* high byte comes first */
        switch (len) {
        case SMIAPP_REG_32BIT:
                *val = (data[0] << 24) + (data[1] << 16) + (data[2] << 8) +
                        data[3];
                break;
        case SMIAPP_REG_16BIT:
                *val = (data[0] << 8) + data[1];
                break;
        case SMIAPP_REG_8BIT:
                *val = data[0];
                break;
        default:
                BUG();
        }

        return 0;

err:
        dev_err(&client->dev, "read from offset 0x%x error %d\n", offset, r);

        return r;
}

/* Read a register using 8-bit access only. */
static int ____smiapp_read_8only(struct smiapp_sensor *sensor, u16 reg,
                                 u16 len, u32 *val)
{
        unsigned int i;
        int rval;

        *val = 0;

        for (i = 0; i < len; i++) {
                u32 val8;

                rval = ____smiapp_read(sensor, reg + i, 1, &val8);
                if (rval < 0)
                        return rval;
                *val |= val8 << ((len - i - 1) << 3);
        }

        return 0;
}

/*
 * Read a 8/16/32-bit i2c register.  The value is returned in 'val'.
 * Returns zero if successful, or non-zero otherwise.
 */
static int __smiapp_read(struct smiapp_sensor *sensor, u32 reg, u32 *val,
                         bool only8)
{
        struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
        u8 len = SMIAPP_REG_WIDTH(reg);
        int rval;

        if (len != SMIAPP_REG_8BIT && len != SMIAPP_REG_16BIT
            && len != SMIAPP_REG_32BIT)
                return -EINVAL;

        if (len == SMIAPP_REG_8BIT || !only8)
                rval = ____smiapp_read(sensor, SMIAPP_REG_ADDR(reg), len, val);
        else
                rval = ____smiapp_read_8only(sensor, SMIAPP_REG_ADDR(reg), len,
                                             val);
        if (rval < 0)
                return rval;

        if (reg & SMIAPP_REG_FLAG_FLOAT)
                *val = float_to_u32_mul_1000000(client, *val);

        return 0;
}

int smiapp_read_no_quirk(struct smiapp_sensor *sensor, u32 reg, u32 *val)
{
        return __smiapp_read(
                sensor, reg, val,
                smiapp_needs_quirk(sensor,
                                   SMIAPP_QUIRK_FLAG_8BIT_READ_ONLY));
}

static int smiapp_read_quirk(struct smiapp_sensor *sensor, u32 reg, u32 *val,
                             bool force8)
{
        int rval;

        *val = 0;
        rval = smiapp_call_quirk(sensor, reg_access, false, &reg, val);
        if (rval == -ENOIOCTLCMD)
                return 0;
        if (rval < 0)
                return rval;

        if (force8)
                return __smiapp_read(sensor, reg, val, true);

        return smiapp_read_no_quirk(sensor, reg, val);
}

int smiapp_read(struct smiapp_sensor *sensor, u32 reg, u32 *val)
{
        return smiapp_read_quirk(sensor, reg, val, false);
}

int smiapp_read_8only(struct smiapp_sensor *sensor, u32 reg, u32 *val)
{
        return smiapp_read_quirk(sensor, reg, val, true);
}

int smiapp_write_no_quirk(struct smiapp_sensor *sensor, u32 reg, u32 val)
{
        struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd);
        struct i2c_msg msg;
        unsigned char data[6];
        unsigned int retries;
        u8 flags = SMIAPP_REG_FLAGS(reg);
        u8 len = SMIAPP_REG_WIDTH(reg);
        u16 offset = SMIAPP_REG_ADDR(reg);
        int r;

        if ((len != SMIAPP_REG_8BIT && len != SMIAPP_REG_16BIT &&
             len != SMIAPP_REG_32BIT) || flags)
                return -EINVAL;

        if (!sensor->active)
                return 0;

        msg.addr = client->addr;
        msg.flags = 0; /* Write */
        msg.len = 2 + len;
        msg.buf = data;

        /* high byte goes out first */
        data[0] = (u8) (reg >> 8);
        data[1] = (u8) (reg & 0xff);

        switch (len) {
        case SMIAPP_REG_8BIT:
                data[2] = val;
                break;
        case SMIAPP_REG_16BIT:
                data[2] = val >> 8;
                data[3] = val;
                break;
        case SMIAPP_REG_32BIT:
                data[2] = val >> 24;
                data[3] = val >> 16;
                data[4] = val >> 8;
                data[5] = val;
                break;
        default:
                BUG();
        }

        for (retries = 0; retries < 5; retries++) {
                /*
                 * Due to unknown reason sensor stops responding. This
                 * loop is a temporaty solution until the root cause
                 * is found.
                 */
                r = i2c_transfer(client->adapter, &msg, 1);
                if (r == 1) {
                        if (retries)
                                dev_err(&client->dev,
                                        "sensor i2c stall encountered. retries: %d\n",
                                        retries);
                        return 0;
                }

                usleep_range(2000, 2000);
        }

        dev_err(&client->dev,
                "wrote 0x%x to offset 0x%x error %d\n", val, offset, r);

        return r;
}

/*
 * Write to a 8/16-bit register.
 * Returns zero if successful, or non-zero otherwise.
 */
int smiapp_write(struct smiapp_sensor *sensor, u32 reg, u32 val)
{
        int rval;

        rval = smiapp_call_quirk(sensor, reg_access, true, &reg, &val);
        if (rval == -ENOIOCTLCMD)
                return 0;
        if (rval < 0)
                return rval;

        return smiapp_write_no_quirk(sensor, reg, val);
}