Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / drivers / media / video / cs53l32a.c
1 /*
2  * cs53l32a (Adaptec AVC-2010 and AVC-2410) i2c ivtv driver.
3  * Copyright (C) 2005  Martin Vaughan
4  *
5  * Audio source switching for Adaptec AVC-2410 added by Trev Jackson
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 as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22
23 #include <linux/module.h>
24 #include <linux/types.h>
25 #include <linux/ioctl.h>
26 #include <asm/uaccess.h>
27 #include <linux/i2c.h>
28 #include <linux/i2c-id.h>
29 #include <linux/videodev2.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-chip-ident.h>
32 #include <media/v4l2-i2c-drv.h>
33
34 MODULE_DESCRIPTION("i2c device driver for cs53l32a Audio ADC");
35 MODULE_AUTHOR("Martin Vaughan");
36 MODULE_LICENSE("GPL");
37
38 static int debug;
39
40 module_param(debug, bool, 0644);
41
42 MODULE_PARM_DESC(debug, "Debugging messages, 0=Off (default), 1=On");
43
44
45 /* ----------------------------------------------------------------------- */
46
47 static int cs53l32a_write(struct v4l2_subdev *sd, u8 reg, u8 value)
48 {
49         struct i2c_client *client = v4l2_get_subdevdata(sd);
50
51         return i2c_smbus_write_byte_data(client, reg, value);
52 }
53
54 static int cs53l32a_read(struct v4l2_subdev *sd, u8 reg)
55 {
56         struct i2c_client *client = v4l2_get_subdevdata(sd);
57
58         return i2c_smbus_read_byte_data(client, reg);
59 }
60
61 static int cs53l32a_s_routing(struct v4l2_subdev *sd, const struct v4l2_routing *route)
62 {
63         /* There are 2 physical inputs, but the second input can be
64            placed in two modes, the first mode bypasses the PGA (gain),
65            the second goes through the PGA. Hence there are three
66            possible inputs to choose from. */
67         if (route->input > 2) {
68                 v4l2_err(sd, "Invalid input %d.\n", route->input);
69                 return -EINVAL;
70         }
71         cs53l32a_write(sd, 0x01, 0x01 + (route->input << 4));
72         return 0;
73 }
74
75 static int cs53l32a_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
76 {
77         if (ctrl->id == V4L2_CID_AUDIO_MUTE) {
78                 ctrl->value = (cs53l32a_read(sd, 0x03) & 0xc0) != 0;
79                 return 0;
80         }
81         if (ctrl->id != V4L2_CID_AUDIO_VOLUME)
82                 return -EINVAL;
83         ctrl->value = (s8)cs53l32a_read(sd, 0x04);
84         return 0;
85 }
86
87 static int cs53l32a_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
88 {
89         if (ctrl->id == V4L2_CID_AUDIO_MUTE) {
90                 cs53l32a_write(sd, 0x03, ctrl->value ? 0xf0 : 0x30);
91                 return 0;
92         }
93         if (ctrl->id != V4L2_CID_AUDIO_VOLUME)
94                 return -EINVAL;
95         if (ctrl->value > 12 || ctrl->value < -96)
96                 return -EINVAL;
97         cs53l32a_write(sd, 0x04, (u8) ctrl->value);
98         cs53l32a_write(sd, 0x05, (u8) ctrl->value);
99         return 0;
100 }
101
102 static int cs53l32a_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *chip)
103 {
104         struct i2c_client *client = v4l2_get_subdevdata(sd);
105
106         return v4l2_chip_ident_i2c_client(client,
107                         chip, V4L2_IDENT_CS53l32A, 0);
108 }
109
110 static int cs53l32a_log_status(struct v4l2_subdev *sd)
111 {
112         u8 v = cs53l32a_read(sd, 0x01);
113         u8 m = cs53l32a_read(sd, 0x03);
114         s8 vol = cs53l32a_read(sd, 0x04);
115
116         v4l2_info(sd, "Input:  %d%s\n", (v >> 4) & 3,
117                         (m & 0xC0) ? " (muted)" : "");
118         v4l2_info(sd, "Volume: %d dB\n", vol);
119         return 0;
120 }
121
122 /* ----------------------------------------------------------------------- */
123
124 static const struct v4l2_subdev_core_ops cs53l32a_core_ops = {
125         .log_status = cs53l32a_log_status,
126         .g_chip_ident = cs53l32a_g_chip_ident,
127         .g_ctrl = cs53l32a_g_ctrl,
128         .s_ctrl = cs53l32a_s_ctrl,
129 };
130
131 static const struct v4l2_subdev_audio_ops cs53l32a_audio_ops = {
132         .s_routing = cs53l32a_s_routing,
133 };
134
135 static const struct v4l2_subdev_ops cs53l32a_ops = {
136         .core = &cs53l32a_core_ops,
137         .audio = &cs53l32a_audio_ops,
138 };
139
140 /* ----------------------------------------------------------------------- */
141
142 /* i2c implementation */
143
144 /*
145  * Generic i2c probe
146  * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
147  */
148
149 static int cs53l32a_probe(struct i2c_client *client,
150                           const struct i2c_device_id *id)
151 {
152         struct v4l2_subdev *sd;
153         int i;
154
155         /* Check if the adapter supports the needed features */
156         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
157                 return -EIO;
158
159         if (!id)
160                 strlcpy(client->name, "cs53l32a", sizeof(client->name));
161
162         v4l_info(client, "chip found @ 0x%x (%s)\n",
163                         client->addr << 1, client->adapter->name);
164
165         sd = kmalloc(sizeof(struct v4l2_subdev), GFP_KERNEL);
166         if (sd == NULL)
167                 return -ENOMEM;
168         v4l2_i2c_subdev_init(sd, client, &cs53l32a_ops);
169
170         for (i = 1; i <= 7; i++) {
171                 u8 v = cs53l32a_read(sd, i);
172
173                 v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v);
174         }
175
176         /* Set cs53l32a internal register for Adaptec 2010/2410 setup */
177
178         cs53l32a_write(sd, 0x01, (u8) 0x21);
179         cs53l32a_write(sd, 0x02, (u8) 0x29);
180         cs53l32a_write(sd, 0x03, (u8) 0x30);
181         cs53l32a_write(sd, 0x04, (u8) 0x00);
182         cs53l32a_write(sd, 0x05, (u8) 0x00);
183         cs53l32a_write(sd, 0x06, (u8) 0x00);
184         cs53l32a_write(sd, 0x07, (u8) 0x00);
185
186         /* Display results, should be 0x21,0x29,0x30,0x00,0x00,0x00,0x00 */
187
188         for (i = 1; i <= 7; i++) {
189                 u8 v = cs53l32a_read(sd, i);
190
191                 v4l2_dbg(1, debug, sd, "Read Reg %d %02x\n", i, v);
192         }
193         return 0;
194 }
195
196 static int cs53l32a_remove(struct i2c_client *client)
197 {
198         struct v4l2_subdev *sd = i2c_get_clientdata(client);
199
200         v4l2_device_unregister_subdev(sd);
201         kfree(sd);
202         return 0;
203 }
204
205 static const struct i2c_device_id cs53l32a_id[] = {
206         { "cs53l32a", 0 },
207         { }
208 };
209 MODULE_DEVICE_TABLE(i2c, cs53l32a_id);
210
211 static struct v4l2_i2c_driver_data v4l2_i2c_data = {
212         .name = "cs53l32a",
213         .remove = cs53l32a_remove,
214         .probe = cs53l32a_probe,
215         .id_table = cs53l32a_id,
216 };