1 /* 2 * Samsung S5K6A3 image sensor driver 3 * 4 * Copyright (C) 2013 Samsung Electronics Co., Ltd. 5 * Author: Sylwester Nawrocki <s.nawrocki@samsung.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 12 #include <linux/clk.h> 13 #include <linux/delay.h> 14 #include <linux/device.h> 15 #include <linux/errno.h> 16 #include <linux/gpio.h> 17 #include <linux/i2c.h> 18 #include <linux/kernel.h> 19 #include <linux/module.h> 20 #include <linux/of_gpio.h> 21 #include <linux/pm_runtime.h> 22 #include <linux/regulator/consumer.h> 23 #include <linux/slab.h> 24 #include <linux/videodev2.h> 25 #include <media/v4l2-async.h> 26 #include <media/v4l2-subdev.h> 27 28 #define S5K6A3_SENSOR_MAX_WIDTH 1412 29 #define S5K6A3_SENSOR_MAX_HEIGHT 1412 30 #define S5K6A3_SENSOR_MIN_WIDTH 32 31 #define S5K6A3_SENSOR_MIN_HEIGHT 32 32 33 #define S5K6A3_DEFAULT_WIDTH 1296 34 #define S5K6A3_DEFAULT_HEIGHT 732 35 36 #define S5K6A3_DRV_NAME "S5K6A3" 37 #define S5K6A3_CLK_NAME "extclk" 38 #define S5K6A3_DEFAULT_CLK_FREQ 24000000U 39 40 enum { 41 S5K6A3_SUPP_VDDA, 42 S5K6A3_SUPP_VDDIO, 43 S5K6A3_SUPP_AFVDD, 44 S5K6A3_NUM_SUPPLIES, 45 }; 46 47 /** 48 * struct s5k6a3 - fimc-is sensor data structure 49 * @dev: pointer to this I2C client device structure 50 * @subdev: the image sensor's v4l2 subdev 51 * @pad: subdev media source pad 52 * @supplies: image sensor's voltage regulator supplies 53 * @gpio_reset: GPIO connected to the sensor's reset pin 54 * @lock: mutex protecting the structure's members below 55 * @format: media bus format at the sensor's source pad 56 * @clock: pointer to &struct clk. 57 * @clock_frequency: clock frequency 58 * @power_count: stores state if device is powered 59 */ 60 struct s5k6a3 { 61 struct device *dev; 62 struct v4l2_subdev subdev; 63 struct media_pad pad; 64 struct regulator_bulk_data supplies[S5K6A3_NUM_SUPPLIES]; 65 int gpio_reset; 66 struct mutex lock; 67 struct v4l2_mbus_framefmt format; 68 struct clk *clock; 69 u32 clock_frequency; 70 int power_count; 71 }; 72 73 static const char * const s5k6a3_supply_names[] = { 74 [S5K6A3_SUPP_VDDA] = "svdda", 75 [S5K6A3_SUPP_VDDIO] = "svddio", 76 [S5K6A3_SUPP_AFVDD] = "afvdd", 77 }; 78 79 static inline struct s5k6a3 *sd_to_s5k6a3(struct v4l2_subdev *sd) 80 { 81 return container_of(sd, struct s5k6a3, subdev); 82 } 83 84 static const struct v4l2_mbus_framefmt s5k6a3_formats[] = { 85 { 86 .code = MEDIA_BUS_FMT_SGRBG10_1X10, 87 .colorspace = V4L2_COLORSPACE_SRGB, 88 .field = V4L2_FIELD_NONE, 89 } 90 }; 91 92 static const struct v4l2_mbus_framefmt *find_sensor_format( 93 struct v4l2_mbus_framefmt *mf) 94 { 95 int i; 96 97 for (i = 0; i < ARRAY_SIZE(s5k6a3_formats); i++) 98 if (mf->code == s5k6a3_formats[i].code) 99 return &s5k6a3_formats[i]; 100 101 return &s5k6a3_formats[0]; 102 } 103 104 static int s5k6a3_enum_mbus_code(struct v4l2_subdev *sd, 105 struct v4l2_subdev_pad_config *cfg, 106 struct v4l2_subdev_mbus_code_enum *code) 107 { 108 if (code->index >= ARRAY_SIZE(s5k6a3_formats)) 109 return -EINVAL; 110 111 code->code = s5k6a3_formats[code->index].code; 112 return 0; 113 } 114 115 static void s5k6a3_try_format(struct v4l2_mbus_framefmt *mf) 116 { 117 const struct v4l2_mbus_framefmt *fmt; 118 119 fmt = find_sensor_format(mf); 120 mf->code = fmt->code; 121 mf->field = V4L2_FIELD_NONE; 122 v4l_bound_align_image(&mf->width, S5K6A3_SENSOR_MIN_WIDTH, 123 S5K6A3_SENSOR_MAX_WIDTH, 0, 124 &mf->height, S5K6A3_SENSOR_MIN_HEIGHT, 125 S5K6A3_SENSOR_MAX_HEIGHT, 0, 0); 126 } 127 128 static struct v4l2_mbus_framefmt *__s5k6a3_get_format( 129 struct s5k6a3 *sensor, struct v4l2_subdev_pad_config *cfg, 130 u32 pad, enum v4l2_subdev_format_whence which) 131 { 132 if (which == V4L2_SUBDEV_FORMAT_TRY) 133 return cfg ? v4l2_subdev_get_try_format(&sensor->subdev, cfg, pad) : NULL; 134 135 return &sensor->format; 136 } 137 138 static int s5k6a3_set_fmt(struct v4l2_subdev *sd, 139 struct v4l2_subdev_pad_config *cfg, 140 struct v4l2_subdev_format *fmt) 141 { 142 struct s5k6a3 *sensor = sd_to_s5k6a3(sd); 143 struct v4l2_mbus_framefmt *mf; 144 145 s5k6a3_try_format(&fmt->format); 146 147 mf = __s5k6a3_get_format(sensor, cfg, fmt->pad, fmt->which); 148 if (mf) { 149 mutex_lock(&sensor->lock); 150 *mf = fmt->format; 151 mutex_unlock(&sensor->lock); 152 } 153 return 0; 154 } 155 156 static int s5k6a3_get_fmt(struct v4l2_subdev *sd, 157 struct v4l2_subdev_pad_config *cfg, 158 struct v4l2_subdev_format *fmt) 159 { 160 struct s5k6a3 *sensor = sd_to_s5k6a3(sd); 161 struct v4l2_mbus_framefmt *mf; 162 163 mf = __s5k6a3_get_format(sensor, cfg, fmt->pad, fmt->which); 164 165 mutex_lock(&sensor->lock); 166 fmt->format = *mf; 167 mutex_unlock(&sensor->lock); 168 return 0; 169 } 170 171 static const struct v4l2_subdev_pad_ops s5k6a3_pad_ops = { 172 .enum_mbus_code = s5k6a3_enum_mbus_code, 173 .get_fmt = s5k6a3_get_fmt, 174 .set_fmt = s5k6a3_set_fmt, 175 }; 176 177 static int s5k6a3_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) 178 { 179 struct v4l2_mbus_framefmt *format = v4l2_subdev_get_try_format(sd, fh->pad, 0); 180 181 *format = s5k6a3_formats[0]; 182 format->width = S5K6A3_DEFAULT_WIDTH; 183 format->height = S5K6A3_DEFAULT_HEIGHT; 184 185 return 0; 186 } 187 188 static const struct v4l2_subdev_internal_ops s5k6a3_sd_internal_ops = { 189 .open = s5k6a3_open, 190 }; 191 192 static int __s5k6a3_power_on(struct s5k6a3 *sensor) 193 { 194 int i = S5K6A3_SUPP_VDDA; 195 int ret; 196 197 ret = clk_set_rate(sensor->clock, sensor->clock_frequency); 198 if (ret < 0) 199 return ret; 200 201 ret = pm_runtime_get(sensor->dev); 202 if (ret < 0) 203 return ret; 204 205 ret = regulator_enable(sensor->supplies[i].consumer); 206 if (ret < 0) 207 goto error_rpm_put; 208 209 ret = clk_prepare_enable(sensor->clock); 210 if (ret < 0) 211 goto error_reg_dis; 212 213 for (i++; i < S5K6A3_NUM_SUPPLIES; i++) { 214 ret = regulator_enable(sensor->supplies[i].consumer); 215 if (ret < 0) 216 goto error_reg_dis; 217 } 218 219 gpio_set_value(sensor->gpio_reset, 1); 220 usleep_range(600, 800); 221 gpio_set_value(sensor->gpio_reset, 0); 222 usleep_range(600, 800); 223 gpio_set_value(sensor->gpio_reset, 1); 224 225 /* Delay needed for the sensor initialization */ 226 msleep(20); 227 return 0; 228 229 error_reg_dis: 230 for (--i; i >= 0; --i) 231 regulator_disable(sensor->supplies[i].consumer); 232 error_rpm_put: 233 pm_runtime_put(sensor->dev); 234 return ret; 235 } 236 237 static int __s5k6a3_power_off(struct s5k6a3 *sensor) 238 { 239 int i; 240 241 gpio_set_value(sensor->gpio_reset, 0); 242 243 for (i = S5K6A3_NUM_SUPPLIES - 1; i >= 0; i--) 244 regulator_disable(sensor->supplies[i].consumer); 245 246 clk_disable_unprepare(sensor->clock); 247 pm_runtime_put(sensor->dev); 248 return 0; 249 } 250 251 static int s5k6a3_s_power(struct v4l2_subdev *sd, int on) 252 { 253 struct s5k6a3 *sensor = sd_to_s5k6a3(sd); 254 int ret = 0; 255 256 mutex_lock(&sensor->lock); 257 258 if (sensor->power_count == !on) { 259 if (on) 260 ret = __s5k6a3_power_on(sensor); 261 else 262 ret = __s5k6a3_power_off(sensor); 263 264 if (ret == 0) 265 sensor->power_count += on ? 1 : -1; 266 } 267 268 mutex_unlock(&sensor->lock); 269 return ret; 270 } 271 272 static const struct v4l2_subdev_core_ops s5k6a3_core_ops = { 273 .s_power = s5k6a3_s_power, 274 }; 275 276 static const struct v4l2_subdev_ops s5k6a3_subdev_ops = { 277 .core = &s5k6a3_core_ops, 278 .pad = &s5k6a3_pad_ops, 279 }; 280 281 static int s5k6a3_probe(struct i2c_client *client, 282 const struct i2c_device_id *id) 283 { 284 struct device *dev = &client->dev; 285 struct s5k6a3 *sensor; 286 struct v4l2_subdev *sd; 287 int gpio, i, ret; 288 289 sensor = devm_kzalloc(dev, sizeof(*sensor), GFP_KERNEL); 290 if (!sensor) 291 return -ENOMEM; 292 293 mutex_init(&sensor->lock); 294 sensor->gpio_reset = -EINVAL; 295 sensor->clock = ERR_PTR(-EINVAL); 296 sensor->dev = dev; 297 298 sensor->clock = devm_clk_get(sensor->dev, S5K6A3_CLK_NAME); 299 if (IS_ERR(sensor->clock)) 300 return PTR_ERR(sensor->clock); 301 302 gpio = of_get_gpio_flags(dev->of_node, 0, NULL); 303 if (!gpio_is_valid(gpio)) 304 return gpio; 305 306 ret = devm_gpio_request_one(dev, gpio, GPIOF_OUT_INIT_LOW, 307 S5K6A3_DRV_NAME); 308 if (ret < 0) 309 return ret; 310 311 sensor->gpio_reset = gpio; 312 313 if (of_property_read_u32(dev->of_node, "clock-frequency", 314 &sensor->clock_frequency)) { 315 sensor->clock_frequency = S5K6A3_DEFAULT_CLK_FREQ; 316 dev_info(dev, "using default %u Hz clock frequency\n", 317 sensor->clock_frequency); 318 } 319 320 for (i = 0; i < S5K6A3_NUM_SUPPLIES; i++) 321 sensor->supplies[i].supply = s5k6a3_supply_names[i]; 322 323 ret = devm_regulator_bulk_get(&client->dev, S5K6A3_NUM_SUPPLIES, 324 sensor->supplies); 325 if (ret < 0) 326 return ret; 327 328 sd = &sensor->subdev; 329 v4l2_i2c_subdev_init(sd, client, &s5k6a3_subdev_ops); 330 sensor->subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 331 sd->internal_ops = &s5k6a3_sd_internal_ops; 332 333 sensor->format.code = s5k6a3_formats[0].code; 334 sensor->format.width = S5K6A3_DEFAULT_WIDTH; 335 sensor->format.height = S5K6A3_DEFAULT_HEIGHT; 336 337 sd->entity.function = MEDIA_ENT_F_CAM_SENSOR; 338 sensor->pad.flags = MEDIA_PAD_FL_SOURCE; 339 ret = media_entity_pads_init(&sd->entity, 1, &sensor->pad); 340 if (ret < 0) 341 return ret; 342 343 pm_runtime_no_callbacks(dev); 344 pm_runtime_enable(dev); 345 346 ret = v4l2_async_register_subdev(sd); 347 348 if (ret < 0) { 349 pm_runtime_disable(&client->dev); 350 media_entity_cleanup(&sd->entity); 351 } 352 353 return ret; 354 } 355 356 static int s5k6a3_remove(struct i2c_client *client) 357 { 358 struct v4l2_subdev *sd = i2c_get_clientdata(client); 359 360 pm_runtime_disable(&client->dev); 361 v4l2_async_unregister_subdev(sd); 362 media_entity_cleanup(&sd->entity); 363 return 0; 364 } 365 366 static const struct i2c_device_id s5k6a3_ids[] = { 367 { } 368 }; 369 MODULE_DEVICE_TABLE(i2c, s5k6a3_ids); 370 371 #ifdef CONFIG_OF 372 static const struct of_device_id s5k6a3_of_match[] = { 373 { .compatible = "samsung,s5k6a3" }, 374 { /* sentinel */ } 375 }; 376 MODULE_DEVICE_TABLE(of, s5k6a3_of_match); 377 #endif 378 379 static struct i2c_driver s5k6a3_driver = { 380 .driver = { 381 .of_match_table = of_match_ptr(s5k6a3_of_match), 382 .name = S5K6A3_DRV_NAME, 383 }, 384 .probe = s5k6a3_probe, 385 .remove = s5k6a3_remove, 386 .id_table = s5k6a3_ids, 387 }; 388 389 module_i2c_driver(s5k6a3_driver); 390 391 MODULE_DESCRIPTION("S5K6A3 image sensor subdev driver"); 392 MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>"); 393 MODULE_LICENSE("GPL v2"); 394