1
2
3
4
5
6
7
8
9
10
11
12#include <linux/delay.h>
13#include <linux/errno.h>
14#include <linux/fs.h>
15#include <linux/init.h>
16#include <linux/kernel.h>
17#include <linux/major.h>
18#include <linux/module.h>
19#include <linux/mm.h>
20#include <linux/slab.h>
21
22
23#include <linux/videodev2.h>
24#include <linux/i2c.h>
25#include <media/v4l2-device.h>
26
27#include "indycam.h"
28
29#define INDYCAM_MODULE_VERSION "0.0.5"
30
31MODULE_DESCRIPTION("SGI IndyCam driver");
32MODULE_VERSION(INDYCAM_MODULE_VERSION);
33MODULE_AUTHOR("Mikael Nousiainen <tmnousia@cc.hut.fi>");
34MODULE_LICENSE("GPL");
35
36
37
38
39#ifdef INDYCAM_DEBUG
40#define dprintk(x...) printk("IndyCam: " x);
41#define indycam_regdump(client) indycam_regdump_debug(client)
42#else
43#define dprintk(x...)
44#define indycam_regdump(client)
45#endif
46
47struct indycam {
48 struct v4l2_subdev sd;
49 u8 version;
50};
51
52static inline struct indycam *to_indycam(struct v4l2_subdev *sd)
53{
54 return container_of(sd, struct indycam, sd);
55}
56
57static const u8 initseq[] = {
58 INDYCAM_CONTROL_AGCENA,
59 INDYCAM_SHUTTER_60,
60 INDYCAM_GAIN_DEFAULT,
61 0x00,
62 INDYCAM_RED_BALANCE_DEFAULT,
63 INDYCAM_BLUE_BALANCE_DEFAULT,
64 INDYCAM_RED_SATURATION_DEFAULT,
65 INDYCAM_BLUE_SATURATION_DEFAULT,
66};
67
68
69
70static int indycam_read_reg(struct v4l2_subdev *sd, u8 reg, u8 *value)
71{
72 struct i2c_client *client = v4l2_get_subdevdata(sd);
73 int ret;
74
75 if (reg == INDYCAM_REG_RESET) {
76 dprintk("indycam_read_reg(): "
77 "skipping write-only register %d\n", reg);
78 *value = 0;
79 return 0;
80 }
81
82 ret = i2c_smbus_read_byte_data(client, reg);
83
84 if (ret < 0) {
85 printk(KERN_ERR "IndyCam: indycam_read_reg(): read failed, "
86 "register = 0x%02x\n", reg);
87 return ret;
88 }
89
90 *value = (u8)ret;
91
92 return 0;
93}
94
95static int indycam_write_reg(struct v4l2_subdev *sd, u8 reg, u8 value)
96{
97 struct i2c_client *client = v4l2_get_subdevdata(sd);
98 int err;
99
100 if (reg == INDYCAM_REG_BRIGHTNESS || reg == INDYCAM_REG_VERSION) {
101 dprintk("indycam_write_reg(): "
102 "skipping read-only register %d\n", reg);
103 return 0;
104 }
105
106 dprintk("Writing Reg %d = 0x%02x\n", reg, value);
107 err = i2c_smbus_write_byte_data(client, reg, value);
108
109 if (err) {
110 printk(KERN_ERR "IndyCam: indycam_write_reg(): write failed, "
111 "register = 0x%02x, value = 0x%02x\n", reg, value);
112 }
113 return err;
114}
115
116static int indycam_write_block(struct v4l2_subdev *sd, u8 reg,
117 u8 length, u8 *data)
118{
119 int i, err;
120
121 for (i = 0; i < length; i++) {
122 err = indycam_write_reg(sd, reg + i, data[i]);
123 if (err)
124 return err;
125 }
126
127 return 0;
128}
129
130
131
132#ifdef INDYCAM_DEBUG
133static void indycam_regdump_debug(struct v4l2_subdev *sd)
134{
135 int i;
136 u8 val;
137
138 for (i = 0; i < 9; i++) {
139 indycam_read_reg(sd, i, &val);
140 dprintk("Reg %d = 0x%02x\n", i, val);
141 }
142}
143#endif
144
145static int indycam_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
146{
147 struct indycam *camera = to_indycam(sd);
148 u8 reg;
149 int ret = 0;
150
151 switch (ctrl->id) {
152 case V4L2_CID_AUTOGAIN:
153 case V4L2_CID_AUTO_WHITE_BALANCE:
154 ret = indycam_read_reg(sd, INDYCAM_REG_CONTROL, ®);
155 if (ret)
156 return -EIO;
157 if (ctrl->id == V4L2_CID_AUTOGAIN)
158 ctrl->value = (reg & INDYCAM_CONTROL_AGCENA)
159 ? 1 : 0;
160 else
161 ctrl->value = (reg & INDYCAM_CONTROL_AWBCTL)
162 ? 1 : 0;
163 break;
164 case V4L2_CID_EXPOSURE:
165 ret = indycam_read_reg(sd, INDYCAM_REG_SHUTTER, ®);
166 if (ret)
167 return -EIO;
168 ctrl->value = ((s32)reg == 0x00) ? 0xff : ((s32)reg - 1);
169 break;
170 case V4L2_CID_GAIN:
171 ret = indycam_read_reg(sd, INDYCAM_REG_GAIN, ®);
172 if (ret)
173 return -EIO;
174 ctrl->value = (s32)reg;
175 break;
176 case V4L2_CID_RED_BALANCE:
177 ret = indycam_read_reg(sd, INDYCAM_REG_RED_BALANCE, ®);
178 if (ret)
179 return -EIO;
180 ctrl->value = (s32)reg;
181 break;
182 case V4L2_CID_BLUE_BALANCE:
183 ret = indycam_read_reg(sd, INDYCAM_REG_BLUE_BALANCE, ®);
184 if (ret)
185 return -EIO;
186 ctrl->value = (s32)reg;
187 break;
188 case INDYCAM_CONTROL_RED_SATURATION:
189 ret = indycam_read_reg(sd,
190 INDYCAM_REG_RED_SATURATION, ®);
191 if (ret)
192 return -EIO;
193 ctrl->value = (s32)reg;
194 break;
195 case INDYCAM_CONTROL_BLUE_SATURATION:
196 ret = indycam_read_reg(sd,
197 INDYCAM_REG_BLUE_SATURATION, ®);
198 if (ret)
199 return -EIO;
200 ctrl->value = (s32)reg;
201 break;
202 case V4L2_CID_GAMMA:
203 if (camera->version == CAMERA_VERSION_MOOSE) {
204 ret = indycam_read_reg(sd,
205 INDYCAM_REG_GAMMA, ®);
206 if (ret)
207 return -EIO;
208 ctrl->value = (s32)reg;
209 } else {
210 ctrl->value = INDYCAM_GAMMA_DEFAULT;
211 }
212 break;
213 default:
214 ret = -EINVAL;
215 }
216
217 return ret;
218}
219
220static int indycam_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
221{
222 struct indycam *camera = to_indycam(sd);
223 u8 reg;
224 int ret = 0;
225
226 switch (ctrl->id) {
227 case V4L2_CID_AUTOGAIN:
228 case V4L2_CID_AUTO_WHITE_BALANCE:
229 ret = indycam_read_reg(sd, INDYCAM_REG_CONTROL, ®);
230 if (ret)
231 break;
232
233 if (ctrl->id == V4L2_CID_AUTOGAIN) {
234 if (ctrl->value)
235 reg |= INDYCAM_CONTROL_AGCENA;
236 else
237 reg &= ~INDYCAM_CONTROL_AGCENA;
238 } else {
239 if (ctrl->value)
240 reg |= INDYCAM_CONTROL_AWBCTL;
241 else
242 reg &= ~INDYCAM_CONTROL_AWBCTL;
243 }
244
245 ret = indycam_write_reg(sd, INDYCAM_REG_CONTROL, reg);
246 break;
247 case V4L2_CID_EXPOSURE:
248 reg = (ctrl->value == 0xff) ? 0x00 : (ctrl->value + 1);
249 ret = indycam_write_reg(sd, INDYCAM_REG_SHUTTER, reg);
250 break;
251 case V4L2_CID_GAIN:
252 ret = indycam_write_reg(sd, INDYCAM_REG_GAIN, ctrl->value);
253 break;
254 case V4L2_CID_RED_BALANCE:
255 ret = indycam_write_reg(sd, INDYCAM_REG_RED_BALANCE,
256 ctrl->value);
257 break;
258 case V4L2_CID_BLUE_BALANCE:
259 ret = indycam_write_reg(sd, INDYCAM_REG_BLUE_BALANCE,
260 ctrl->value);
261 break;
262 case INDYCAM_CONTROL_RED_SATURATION:
263 ret = indycam_write_reg(sd, INDYCAM_REG_RED_SATURATION,
264 ctrl->value);
265 break;
266 case INDYCAM_CONTROL_BLUE_SATURATION:
267 ret = indycam_write_reg(sd, INDYCAM_REG_BLUE_SATURATION,
268 ctrl->value);
269 break;
270 case V4L2_CID_GAMMA:
271 if (camera->version == CAMERA_VERSION_MOOSE) {
272 ret = indycam_write_reg(sd, INDYCAM_REG_GAMMA,
273 ctrl->value);
274 }
275 break;
276 default:
277 ret = -EINVAL;
278 }
279
280 return ret;
281}
282
283
284
285
286
287static const struct v4l2_subdev_core_ops indycam_core_ops = {
288 .g_ctrl = indycam_g_ctrl,
289 .s_ctrl = indycam_s_ctrl,
290};
291
292static const struct v4l2_subdev_ops indycam_ops = {
293 .core = &indycam_core_ops,
294};
295
296static int indycam_probe(struct i2c_client *client,
297 const struct i2c_device_id *id)
298{
299 int err = 0;
300 struct indycam *camera;
301 struct v4l2_subdev *sd;
302
303 v4l_info(client, "chip found @ 0x%x (%s)\n",
304 client->addr << 1, client->adapter->name);
305
306 camera = kzalloc(sizeof(struct indycam), GFP_KERNEL);
307 if (!camera)
308 return -ENOMEM;
309
310 sd = &camera->sd;
311 v4l2_i2c_subdev_init(sd, client, &indycam_ops);
312
313 camera->version = i2c_smbus_read_byte_data(client,
314 INDYCAM_REG_VERSION);
315 if (camera->version != CAMERA_VERSION_INDY &&
316 camera->version != CAMERA_VERSION_MOOSE) {
317 kfree(camera);
318 return -ENODEV;
319 }
320
321 printk(KERN_INFO "IndyCam v%d.%d detected\n",
322 INDYCAM_VERSION_MAJOR(camera->version),
323 INDYCAM_VERSION_MINOR(camera->version));
324
325 indycam_regdump(sd);
326
327
328 err = indycam_write_block(sd, 0, sizeof(initseq), (u8 *)&initseq);
329 if (err) {
330 printk(KERN_ERR "IndyCam initialization failed\n");
331 kfree(camera);
332 return -EIO;
333 }
334
335 indycam_regdump(sd);
336
337
338 err = indycam_write_reg(sd, INDYCAM_REG_CONTROL,
339 INDYCAM_CONTROL_AGCENA | INDYCAM_CONTROL_AWBCTL);
340 if (err) {
341 printk(KERN_ERR "IndyCam: White balancing camera failed\n");
342 kfree(camera);
343 return -EIO;
344 }
345
346 indycam_regdump(sd);
347
348 printk(KERN_INFO "IndyCam initialized\n");
349
350 return 0;
351}
352
353static int indycam_remove(struct i2c_client *client)
354{
355 struct v4l2_subdev *sd = i2c_get_clientdata(client);
356
357 v4l2_device_unregister_subdev(sd);
358 kfree(to_indycam(sd));
359 return 0;
360}
361
362static const struct i2c_device_id indycam_id[] = {
363 { "indycam", 0 },
364 { }
365};
366MODULE_DEVICE_TABLE(i2c, indycam_id);
367
368static struct i2c_driver indycam_driver = {
369 .driver = {
370 .owner = THIS_MODULE,
371 .name = "indycam",
372 },
373 .probe = indycam_probe,
374 .remove = indycam_remove,
375 .id_table = indycam_id,
376};
377
378module_i2c_driver(indycam_driver);
379
