1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * MIPI Camera Control Interface (CCI) register access helpers. 4 * 5 * Copyright (C) 2023 Hans de Goede <hansg@kernel.org> 6 */ 7 8 #include <linux/bitfield.h> 9 #include <linux/delay.h> 10 #include <linux/dev_printk.h> 11 #include <linux/module.h> 12 #include <linux/regmap.h> 13 #include <linux/types.h> 14 15 #include <asm/unaligned.h> 16 17 #include <media/v4l2-cci.h> 18 19 int cci_read(struct regmap *map, u32 reg, u64 *val, int *err) 20 { 21 bool little_endian; 22 unsigned int len; 23 u8 buf[8]; 24 int ret; 25 26 /* 27 * TODO: Fix smatch. Assign *val to 0 here in order to avoid 28 * failing a smatch check on caller when the caller proceeds to 29 * read *val without initialising it on caller's side. *val is set 30 * to a valid value whenever this function returns 0 but smatch 31 * can't figure that out currently. 32 */ 33 *val = 0; 34 35 if (err && *err) 36 return *err; 37 38 little_endian = reg & CCI_REG_LE; 39 len = CCI_REG_WIDTH_BYTES(reg); 40 reg = CCI_REG_ADDR(reg); 41 42 ret = regmap_bulk_read(map, reg, buf, len); 43 if (ret) { 44 dev_err(regmap_get_device(map), "Error reading reg 0x%04x: %d\n", 45 reg, ret); 46 goto out; 47 } 48 49 switch (len) { 50 case 1: 51 *val = buf[0]; 52 break; 53 case 2: 54 if (little_endian) 55 *val = get_unaligned_le16(buf); 56 else 57 *val = get_unaligned_be16(buf); 58 break; 59 case 3: 60 if (little_endian) 61 *val = get_unaligned_le24(buf); 62 else 63 *val = get_unaligned_be24(buf); 64 break; 65 case 4: 66 if (little_endian) 67 *val = get_unaligned_le32(buf); 68 else 69 *val = get_unaligned_be32(buf); 70 break; 71 case 8: 72 if (little_endian) 73 *val = get_unaligned_le64(buf); 74 else 75 *val = get_unaligned_be64(buf); 76 break; 77 default: 78 dev_err(regmap_get_device(map), "Error invalid reg-width %u for reg 0x%04x\n", 79 len, reg); 80 ret = -EINVAL; 81 break; 82 } 83 84 out: 85 if (ret && err) 86 *err = ret; 87 88 return ret; 89 } 90 EXPORT_SYMBOL_GPL(cci_read); 91 92 int cci_write(struct regmap *map, u32 reg, u64 val, int *err) 93 { 94 bool little_endian; 95 unsigned int len; 96 u8 buf[8]; 97 int ret; 98 99 if (err && *err) 100 return *err; 101 102 little_endian = reg & CCI_REG_LE; 103 len = CCI_REG_WIDTH_BYTES(reg); 104 reg = CCI_REG_ADDR(reg); 105 106 switch (len) { 107 case 1: 108 buf[0] = val; 109 break; 110 case 2: 111 if (little_endian) 112 put_unaligned_le16(val, buf); 113 else 114 put_unaligned_be16(val, buf); 115 break; 116 case 3: 117 if (little_endian) 118 put_unaligned_le24(val, buf); 119 else 120 put_unaligned_be24(val, buf); 121 break; 122 case 4: 123 if (little_endian) 124 put_unaligned_le32(val, buf); 125 else 126 put_unaligned_be32(val, buf); 127 break; 128 case 8: 129 if (little_endian) 130 put_unaligned_le64(val, buf); 131 else 132 put_unaligned_be64(val, buf); 133 break; 134 default: 135 dev_err(regmap_get_device(map), "Error invalid reg-width %u for reg 0x%04x\n", 136 len, reg); 137 ret = -EINVAL; 138 goto out; 139 } 140 141 ret = regmap_bulk_write(map, reg, buf, len); 142 if (ret) 143 dev_err(regmap_get_device(map), "Error writing reg 0x%04x: %d\n", 144 reg, ret); 145 146 out: 147 if (ret && err) 148 *err = ret; 149 150 return ret; 151 } 152 EXPORT_SYMBOL_GPL(cci_write); 153 154 int cci_update_bits(struct regmap *map, u32 reg, u64 mask, u64 val, int *err) 155 { 156 u64 readval; 157 int ret; 158 159 ret = cci_read(map, reg, &readval, err); 160 if (ret) 161 return ret; 162 163 val = (readval & ~mask) | (val & mask); 164 165 return cci_write(map, reg, val, err); 166 } 167 EXPORT_SYMBOL_GPL(cci_update_bits); 168 169 int cci_multi_reg_write(struct regmap *map, const struct cci_reg_sequence *regs, 170 unsigned int num_regs, int *err) 171 { 172 unsigned int i; 173 int ret; 174 175 for (i = 0; i < num_regs; i++) { 176 ret = cci_write(map, regs[i].reg, regs[i].val, err); 177 if (ret) 178 return ret; 179 } 180 181 return 0; 182 } 183 EXPORT_SYMBOL_GPL(cci_multi_reg_write); 184 185 #if IS_ENABLED(CONFIG_V4L2_CCI_I2C) 186 struct regmap *devm_cci_regmap_init_i2c(struct i2c_client *client, 187 int reg_addr_bits) 188 { 189 struct regmap_config config = { 190 .reg_bits = reg_addr_bits, 191 .val_bits = 8, 192 .reg_format_endian = REGMAP_ENDIAN_BIG, 193 .disable_locking = true, 194 }; 195 196 return devm_regmap_init_i2c(client, &config); 197 } 198 EXPORT_SYMBOL_GPL(devm_cci_regmap_init_i2c); 199 #endif 200 201 MODULE_LICENSE("GPL"); 202 MODULE_AUTHOR("Hans de Goede <hansg@kernel.org>"); 203 MODULE_DESCRIPTION("MIPI Camera Control Interface (CCI) support"); 204