1/* 2 * drivers/media/i2c/smiapp/smiapp-regs.c 3 * 4 * Generic driver for SMIA/SMIA++ compliant camera modules 5 * 6 * Copyright (C) 2011--2012 Nokia Corporation 7 * Contact: Sakari Ailus <sakari.ailus@iki.fi> 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License 11 * version 2 as published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 21 * 02110-1301 USA 22 * 23 */ 24 25#include <linux/delay.h> 26#include <linux/i2c.h> 27 28#include "smiapp.h" 29#include "smiapp-regs.h" 30 31static uint32_t float_to_u32_mul_1000000(struct i2c_client *client, 32 uint32_t phloat) 33{ 34 int32_t exp; 35 uint64_t man; 36 37 if (phloat >= 0x80000000) { 38 dev_err(&client->dev, "this is a negative number\n"); 39 return 0; 40 } 41 42 if (phloat == 0x7f800000) 43 return ~0; /* Inf. */ 44 45 if ((phloat & 0x7f800000) == 0x7f800000) { 46 dev_err(&client->dev, "NaN or other special number\n"); 47 return 0; 48 } 49 50 /* Valid cases begin here */ 51 if (phloat == 0) 52 return 0; /* Valid zero */ 53 54 if (phloat > 0x4f800000) 55 return ~0; /* larger than 4294967295 */ 56 57 /* 58 * Unbias exponent (note how phloat is now guaranteed to 59 * have 0 in the high bit) 60 */ 61 exp = ((int32_t)phloat >> 23) - 127; 62 63 /* Extract mantissa, add missing '1' bit and it's in MHz */ 64 man = ((phloat & 0x7fffff) | 0x800000) * 1000000ULL; 65 66 if (exp < 0) 67 man >>= -exp; 68 else 69 man <<= exp; 70 71 man >>= 23; /* Remove mantissa bias */ 72 73 return man & 0xffffffff; 74} 75 76 77/* 78 * Read a 8/16/32-bit i2c register. The value is returned in 'val'. 79 * Returns zero if successful, or non-zero otherwise. 80 */ 81static int ____smiapp_read(struct smiapp_sensor *sensor, u16 reg, 82 u16 len, u32 *val) 83{ 84 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 85 struct i2c_msg msg; 86 unsigned char data[4]; 87 u16 offset = reg; 88 int r; 89 90 msg.addr = client->addr; 91 msg.flags = 0; 92 msg.len = 2; 93 msg.buf = data; 94 95 /* high byte goes out first */ 96 data[0] = (u8) (offset >> 8); 97 data[1] = (u8) offset; 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 msg.len = len; 106 msg.flags = I2C_M_RD; 107 r = i2c_transfer(client->adapter, &msg, 1); 108 if (r != 1) { 109 if (r >= 0) 110 r = -EBUSY; 111 goto err; 112 } 113 114 *val = 0; 115 /* high byte comes first */ 116 switch (len) { 117 case SMIAPP_REG_32BIT: 118 *val = (data[0] << 24) + (data[1] << 16) + (data[2] << 8) + 119 data[3]; 120 break; 121 case SMIAPP_REG_16BIT: 122 *val = (data[0] << 8) + data[1]; 123 break; 124 case SMIAPP_REG_8BIT: 125 *val = data[0]; 126 break; 127 default: 128 BUG(); 129 } 130 131 return 0; 132 133err: 134 dev_err(&client->dev, "read from offset 0x%x error %d\n", offset, r); 135 136 return r; 137} 138 139/* Read a register using 8-bit access only. */ 140static int ____smiapp_read_8only(struct smiapp_sensor *sensor, u16 reg, 141 u16 len, u32 *val) 142{ 143 unsigned int i; 144 int rval; 145 146 *val = 0; 147 148 for (i = 0; i < len; i++) { 149 u32 val8; 150 151 rval = ____smiapp_read(sensor, reg + i, 1, &val8); 152 if (rval < 0) 153 return rval; 154 *val |= val8 << ((len - i - 1) << 3); 155 } 156 157 return 0; 158} 159 160/* 161 * Read a 8/16/32-bit i2c register. The value is returned in 'val'. 162 * Returns zero if successful, or non-zero otherwise. 163 */ 164static int __smiapp_read(struct smiapp_sensor *sensor, u32 reg, u32 *val, 165 bool only8) 166{ 167 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 168 u8 len = SMIAPP_REG_WIDTH(reg); 169 int rval; 170 171 if (len != SMIAPP_REG_8BIT && len != SMIAPP_REG_16BIT 172 && len != SMIAPP_REG_32BIT) 173 return -EINVAL; 174 175 if (len == SMIAPP_REG_8BIT || !only8) 176 rval = ____smiapp_read(sensor, SMIAPP_REG_ADDR(reg), len, val); 177 else 178 rval = ____smiapp_read_8only(sensor, SMIAPP_REG_ADDR(reg), len, 179 val); 180 if (rval < 0) 181 return rval; 182 183 if (reg & SMIAPP_REG_FLAG_FLOAT) 184 *val = float_to_u32_mul_1000000(client, *val); 185 186 return 0; 187} 188 189int smiapp_read_no_quirk(struct smiapp_sensor *sensor, u32 reg, u32 *val) 190{ 191 return __smiapp_read( 192 sensor, reg, val, 193 smiapp_needs_quirk(sensor, 194 SMIAPP_QUIRK_FLAG_8BIT_READ_ONLY)); 195} 196 197int smiapp_read(struct smiapp_sensor *sensor, u32 reg, u32 *val) 198{ 199 int rval; 200 201 *val = 0; 202 rval = smiapp_call_quirk(sensor, reg_access, false, ®, val); 203 if (rval == -ENOIOCTLCMD) 204 return 0; 205 if (rval < 0) 206 return rval; 207 208 return smiapp_read_no_quirk(sensor, reg, val); 209} 210 211int smiapp_read_8only(struct smiapp_sensor *sensor, u32 reg, u32 *val) 212{ 213 int rval; 214 215 *val = 0; 216 rval = smiapp_call_quirk(sensor, reg_access, false, ®, val); 217 if (rval == -ENOIOCTLCMD) 218 return 0; 219 if (rval < 0) 220 return rval; 221 222 return __smiapp_read(sensor, reg, val, true); 223} 224 225int smiapp_write_no_quirk(struct smiapp_sensor *sensor, u32 reg, u32 val) 226{ 227 struct i2c_client *client = v4l2_get_subdevdata(&sensor->src->sd); 228 struct i2c_msg msg; 229 unsigned char data[6]; 230 unsigned int retries; 231 u8 flags = SMIAPP_REG_FLAGS(reg); 232 u8 len = SMIAPP_REG_WIDTH(reg); 233 u16 offset = SMIAPP_REG_ADDR(reg); 234 int r; 235 236 if ((len != SMIAPP_REG_8BIT && len != SMIAPP_REG_16BIT && 237 len != SMIAPP_REG_32BIT) || flags) 238 return -EINVAL; 239 240 msg.addr = client->addr; 241 msg.flags = 0; /* Write */ 242 msg.len = 2 + len; 243 msg.buf = data; 244 245 /* high byte goes out first */ 246 data[0] = (u8) (reg >> 8); 247 data[1] = (u8) (reg & 0xff); 248 249 switch (len) { 250 case SMIAPP_REG_8BIT: 251 data[2] = val; 252 break; 253 case SMIAPP_REG_16BIT: 254 data[2] = val >> 8; 255 data[3] = val; 256 break; 257 case SMIAPP_REG_32BIT: 258 data[2] = val >> 24; 259 data[3] = val >> 16; 260 data[4] = val >> 8; 261 data[5] = val; 262 break; 263 default: 264 BUG(); 265 } 266 267 for (retries = 0; retries < 5; retries++) { 268 /* 269 * Due to unknown reason sensor stops responding. This 270 * loop is a temporaty solution until the root cause 271 * is found. 272 */ 273 r = i2c_transfer(client->adapter, &msg, 1); 274 if (r == 1) { 275 if (retries) 276 dev_err(&client->dev, 277 "sensor i2c stall encountered. " 278 "retries: %d\n", retries); 279 return 0; 280 } 281 282 usleep_range(2000, 2000); 283 } 284 285 dev_err(&client->dev, 286 "wrote 0x%x to offset 0x%x error %d\n", val, offset, r); 287 288 return r; 289} 290 291/* 292 * Write to a 8/16-bit register. 293 * Returns zero if successful, or non-zero otherwise. 294 */ 295int smiapp_write(struct smiapp_sensor *sensor, u32 reg, u32 val) 296{ 297 int rval; 298 299 rval = smiapp_call_quirk(sensor, reg_access, true, ®, &val); 300 if (rval == -ENOIOCTLCMD) 301 return 0; 302 if (rval < 0) 303 return rval; 304 305 return smiapp_write_no_quirk(sensor, reg, val); 306} 307