OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [tvmixer.c] - Blame information for rev 78

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl 
/*
2 
 */
3 
 
4 
#include <linux/module.h>
5 
#include <linux/kernel.h>
6 
#include <linux/string.h>
7 
#include <linux/timer.h>
8 
#include <linux/delay.h>
9 
#include <linux/errno.h>
10 
#include <linux/slab.h>
11 
#include <linux/i2c.h>
12 
#include <linux/videodev.h>
13 
#include <linux/init.h>
14 
#include <linux/kdev_t.h>
15 
#include <linux/sound.h>
16 
#include <linux/soundcard.h>
17 
 
18 
#include <asm/semaphore.h>
19 
#include <asm/uaccess.h>
20 
 
21 
 
22 
#define DEV_MAX  4
23 
 
24 
static int devnr = -1;
25 
module_param(devnr, int, 0644);
26 
 
27 
MODULE_AUTHOR("Gerd Knorr");
28 
MODULE_LICENSE("GPL");
29 
 
30 
/* ----------------------------------------------------------------------- */
31 
 
32 
struct TVMIXER {
33 
        struct i2c_client *dev;
34 
        int minor;
35 
        int count;
36 
};
37 
 
38 
static struct TVMIXER devices[DEV_MAX];
39 
 
40 
static int tvmixer_adapters(struct i2c_adapter *adap);
41 
static int tvmixer_clients(struct i2c_client *client);
42 
 
43 
/* ----------------------------------------------------------------------- */
44 
 
45 
static int mix_to_v4l(int i)
46 
{
47 
        int r;
48 
 
49 
        r = ((i & 0xff) * 65536 + 50) / 100;
50 
        if (r > 65535) r = 65535;
51 
        if (r <     0) r =     0;
52 
        return r;
53 
}
54 
 
55 
static int v4l_to_mix(int i)
56 
{
57 
        int r;
58 
 
59 
        r = (i * 100 + 32768) / 65536;
60 
        if (r > 100) r = 100;
61 
        if (r <   0) r =   0;
62 
        return r | (r << 8);
63 
}
64 
 
65 
static int v4l_to_mix2(int l, int r)
66 
{
67 
        r = (r * 100 + 32768) / 65536;
68 
        if (r > 100) r = 100;
69 
        if (r <   0) r =   0;
70 
        l = (l * 100 + 32768) / 65536;
71 
        if (l > 100) l = 100;
72 
        if (l <   0) l =   0;
73 
        return (r << 8) | l;
74 
}
75 
 
76 
static int tvmixer_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
77 
{
78 
        struct video_audio va;
79 
        int left,right,ret,val = 0;
80 
        struct TVMIXER *mix = file->private_data;
81 
        struct i2c_client *client = mix->dev;
82 
        void __user *argp = (void __user *)arg;
83 
        int __user *p = argp;
84 
 
85 
        if (NULL == client)
86 
                return -ENODEV;
87 
 
88 
        if (cmd == SOUND_MIXER_INFO) {
89 
                mixer_info info;
90 
                strlcpy(info.id, "tv card", sizeof(info.id));
91 
                strlcpy(info.name, client->name, sizeof(info.name));
92 
                info.modify_counter = 42 /* FIXME */;
93 
                if (copy_to_user(argp, &info, sizeof(info)))
94 
                        return -EFAULT;
95 
                return 0;
96 
        }
97 
        if (cmd == SOUND_OLD_MIXER_INFO) {
98 
                _old_mixer_info info;
99 
                strlcpy(info.id, "tv card", sizeof(info.id));
100 
                strlcpy(info.name, client->name, sizeof(info.name));
101 
                if (copy_to_user(argp, &info, sizeof(info)))
102 
                        return -EFAULT;
103 
                return 0;
104 
        }
105 
        if (cmd == OSS_GETVERSION)
106 
                return put_user(SOUND_VERSION, p);
107 
 
108 
        if (_SIOC_DIR(cmd) & _SIOC_WRITE)
109 
                if (get_user(val, p))
110 
                        return -EFAULT;
111 
 
112 
        /* read state */
113 
        memset(&va,0,sizeof(va));
114 
        client->driver->command(client,VIDIOCGAUDIO,&va);
115 
 
116 
        switch (cmd) {
117 
        case MIXER_READ(SOUND_MIXER_RECMASK):
118 
        case MIXER_READ(SOUND_MIXER_CAPS):
119 
        case MIXER_READ(SOUND_MIXER_RECSRC):
120 
        case MIXER_WRITE(SOUND_MIXER_RECSRC):
121 
                ret = 0;
122 
                break;
123 
 
124 
        case MIXER_READ(SOUND_MIXER_STEREODEVS):
125 
                ret = SOUND_MASK_VOLUME;
126 
                break;
127 
        case MIXER_READ(SOUND_MIXER_DEVMASK):
128 
                ret = SOUND_MASK_VOLUME;
129 
                if (va.flags & VIDEO_AUDIO_BASS)
130 
                        ret |= SOUND_MASK_BASS;
131 
                if (va.flags & VIDEO_AUDIO_TREBLE)
132 
                        ret |= SOUND_MASK_TREBLE;
133 
                break;
134 
 
135 
        case MIXER_WRITE(SOUND_MIXER_VOLUME):
136 
                left  = mix_to_v4l(val);
137 
                right = mix_to_v4l(val >> 8);
138 
                va.volume  = max(left,right);
139 
                va.balance = (32768*min(left,right)) / (va.volume ? va.volume : 1);
140 
                va.balance = (left<right) ? (65535-va.balance) : va.balance;
141 
                if (va.volume)
142 
                        va.flags &= ~VIDEO_AUDIO_MUTE;
143 
                client->driver->command(client,VIDIOCSAUDIO,&va);
144 
                client->driver->command(client,VIDIOCGAUDIO,&va);
145 
                /* fall throuth */
146 
        case MIXER_READ(SOUND_MIXER_VOLUME):
147 
                left  = (min(65536 - va.balance,32768) *
148 
                         va.volume) / 32768;
149 
                right = (min(va.balance,(u16)32768) *
150 
                         va.volume) / 32768;
151 
                ret = v4l_to_mix2(left,right);
152 
                break;
153 
 
154 
        case MIXER_WRITE(SOUND_MIXER_BASS):
155 
                va.bass = mix_to_v4l(val);
156 
                client->driver->command(client,VIDIOCSAUDIO,&va);
157 
                client->driver->command(client,VIDIOCGAUDIO,&va);
158 
                /* fall throuth  */
159 
        case MIXER_READ(SOUND_MIXER_BASS):
160 
                ret = v4l_to_mix(va.bass);
161 
                break;
162 
 
163 
        case MIXER_WRITE(SOUND_MIXER_TREBLE):
164 
                va.treble = mix_to_v4l(val);
165 
                client->driver->command(client,VIDIOCSAUDIO,&va);
166 
                client->driver->command(client,VIDIOCGAUDIO,&va);
167 
                /* fall throuth */
168 
        case MIXER_READ(SOUND_MIXER_TREBLE):
169 
                ret = v4l_to_mix(va.treble);
170 
                break;
171 
 
172 
        default:
173 
                return -EINVAL;
174 
        }
175 
        if (put_user(ret, p))
176 
                return -EFAULT;
177 
        return 0;
178 
}
179 
 
180 
static int tvmixer_open(struct inode *inode, struct file *file)
181 
{
182 
        int i, minor = iminor(inode);
183 
        struct TVMIXER *mix = NULL;
184 
        struct i2c_client *client = NULL;
185 
 
186 
        for (i = 0; i < DEV_MAX; i++) {
187 
                if (devices[i].minor == minor) {
188 
                        mix = devices+i;
189 
                        client = mix->dev;
190 
                        break;
191 
                }
192 
        }
193 
 
194 
        if (NULL == client)
195 
                return -ENODEV;
196 
 
197 
        /* lock bttv in memory while the mixer is in use  */
198 
        file->private_data = mix;
199 
        if (client->adapter->owner)
200 
                try_module_get(client->adapter->owner);
201 
        return 0;
202 
}
203 
 
204 
static int tvmixer_release(struct inode *inode, struct file *file)
205 
{
206 
        struct TVMIXER *mix = file->private_data;
207 
        struct i2c_client *client;
208 
 
209 
        client = mix->dev;
210 
        if (NULL == client) {
211 
                return -ENODEV;
212 
        }
213 
 
214 
        module_put(client->adapter->owner);
215 
        return 0;
216 
}
217 
 
218 
static struct i2c_driver driver = {
219 
        .driver = {
220 
                .name    = "tvmixer",
221 
        },
222 
        .id              = I2C_DRIVERID_TVMIXER,
223 
        .detach_adapter  = tvmixer_adapters,
224 
        .attach_adapter  = tvmixer_adapters,
225 
        .detach_client   = tvmixer_clients,
226 
};
227 
 
228 
static const struct file_operations tvmixer_fops = {
229 
        .owner          = THIS_MODULE,
230 
        .llseek         = no_llseek,
231 
        .ioctl          = tvmixer_ioctl,
232 
        .open           = tvmixer_open,
233 
        .release        = tvmixer_release,
234 
};
235 
 
236 
/* ----------------------------------------------------------------------- */
237 
 
238 
static int tvmixer_adapters(struct i2c_adapter *adap)
239 
{
240 
        struct i2c_client *client;
241 
 
242 
        list_for_each_entry(client, &adap->clients, list)
243 
                tvmixer_clients(client);
244 
        return 0;
245 
}
246 
 
247 
static int tvmixer_clients(struct i2c_client *client)
248 
{
249 
        struct video_audio va;
250 
        int i,minor;
251 
 
252 
        if (!(client->adapter->class & I2C_CLASS_TV_ANALOG))
253 
                return -1;
254 
 
255 
        /* unregister ?? */
256 
        for (i = 0; i < DEV_MAX; i++) {
257 
                if (devices[i].dev == client) {
258 
                        /* unregister */
259 
                        unregister_sound_mixer(devices[i].minor);
260 
                        devices[i].dev = NULL;
261 
                        devices[i].minor = -1;
262 
                        printk("tvmixer: %s unregistered (#1)\n",
263 
                               client->name);
264 
                        return 0;
265 
                }
266 
        }
267 
 
268 
        /* look for a free slot */
269 
        for (i = 0; i < DEV_MAX; i++)
270 
                if (NULL == devices[i].dev)
271 
                        break;
272 
        if (i == DEV_MAX) {
273 
                printk(KERN_WARNING "tvmixer: DEV_MAX too small\n");
274 
                return -1;
275 
        }
276 
 
277 
        /* audio chip with mixer ??? */
278 
        if (NULL == client->driver->command)
279 
                return -1;
280 
        memset(&va,0,sizeof(va));
281 
        if (0 != client->driver->command(client,VIDIOCGAUDIO,&va))
282 
                return -1;
283 
        if (0 == (va.flags & VIDEO_AUDIO_VOLUME))
284 
                return -1;
285 
 
286 
        /* everything is fine, register */
287 
        if ((minor = register_sound_mixer(&tvmixer_fops,devnr)) < 0) {
288 
                printk(KERN_ERR "tvmixer: cannot allocate mixer device\n");
289 
                return -1;
290 
        }
291 
 
292 
        devices[i].minor = minor;
293 
        devices[i].count = 0;
294 
        devices[i].dev   = client;
295 
        printk("tvmixer: %s (%s) registered with minor %d\n",
296 
               client->name,client->adapter->name,minor);
297 
 
298 
        return 0;
299 
}
300 
 
301 
/* ----------------------------------------------------------------------- */
302 
 
303 
static int __init tvmixer_init_module(void)
304 
{
305 
        int i;
306 
 
307 
        for (i = 0; i < DEV_MAX; i++)
308 
                devices[i].minor = -1;
309 
 
310 
        return i2c_add_driver(&driver);
311 
}
312 
 
313 
static void __exit tvmixer_cleanup_module(void)
314 
{
315 
        int i;
316 
 
317 
        i2c_del_driver(&driver);
318 
        for (i = 0; i < DEV_MAX; i++) {
319 
                if (devices[i].minor != -1) {
320 
                        unregister_sound_mixer(devices[i].minor);
321 
                        printk("tvmixer: %s unregistered (#2)\n",
322 
                               devices[i].dev->name);
323 
                }
324 
        }
325 
}
326 
 
327 
module_init(tvmixer_init_module);
328 
module_exit(tvmixer_cleanup_module);
329 
 
330 
/*
331 
 * Overrides for Emacs so that we follow Linus's tabbing style.
332 
 * ---------------------------------------------------------------------------
333 
 * Local variables:
334 
 * c-basic-offset: 8
335 
 * End:
336 
 */

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.