?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (3870): Convert dib3000* to refactored tuner code
[linux-2.6/btrfs-unstable.git] / drivers / media / video / stradis.c
blob07476c71174a70d05a77164c6f4aa39afd7d59fa
1 /*
2 * stradis.c - stradis 4:2:2 mpeg decoder driver
3 *
4 * Stradis 4:2:2 MPEG-2 Decoder Driver
5 * Copyright (C) 1999 Nathan Laredo <laredo@gnu.org>
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 #include <linux/module.h>
23 #include <linux/delay.h>
24 #include <linux/errno.h>
25 #include <linux/fs.h>
26 #include <linux/kernel.h>
27 #include <linux/major.h>
28 #include <linux/slab.h>
29 #include <linux/mm.h>
30 #include <linux/init.h>
31 #include <linux/poll.h>
32 #include <linux/pci.h>
33 #include <linux/signal.h>
34 #include <asm/io.h>
35 #include <linux/ioport.h>
36 #include <asm/pgtable.h>
37 #include <asm/page.h>
38 #include <linux/sched.h>
39 #include <asm/types.h>
40 #include <linux/types.h>
41 #include <linux/interrupt.h>
42 #include <asm/uaccess.h>
43 #include <linux/vmalloc.h>
44 #include <linux/videodev.h>
45
46 #include "saa7146.h"
47 #include "saa7146reg.h"
48 #include "ibmmpeg2.h"
49 #include "saa7121.h"
50 #include "cs8420.h"
51
52 #define DEBUG(x) /* debug driver */
53 #undef IDEBUG /* debug irq handler */
54 #undef MDEBUG /* debug memory management */
55
56 #define SAA7146_MAX 6
57
58 static struct saa7146 saa7146s[SAA7146_MAX];
59
60 static int saa_num = 0; /* number of SAA7146s in use */
61
62 static int video_nr = -1;
63 module_param(video_nr, int, 0);
64 MODULE_LICENSE("GPL");
65
66 #define nDebNormal 0x00480000
67 #define nDebNoInc 0x00480000
68 #define nDebVideo 0xd0480000
69 #define nDebAudio 0xd0400000
70 #define nDebDMA 0x02c80000
71
72 #define oDebNormal 0x13c80000
73 #define oDebNoInc 0x13c80000
74 #define oDebVideo 0xd1080000
75 #define oDebAudio 0xd1080000
76 #define oDebDMA 0x03080000
77
78 #define NewCard (saa->boardcfg[3])
79 #define ChipControl (saa->boardcfg[1])
80 #define NTSCFirstActive (saa->boardcfg[4])
81 #define PALFirstActive (saa->boardcfg[5])
82 #define NTSCLastActive (saa->boardcfg[54])
83 #define PALLastActive (saa->boardcfg[55])
84 #define Have2MB (saa->boardcfg[18] & 0x40)
85 #define HaveCS8420 (saa->boardcfg[18] & 0x04)
86 #define IBMMPEGCD20 (saa->boardcfg[18] & 0x20)
87 #define HaveCS3310 (saa->boardcfg[18] & 0x01)
88 #define CS3310MaxLvl ((saa->boardcfg[30] << 8) | saa->boardcfg[31])
89 #define HaveCS4341 (saa->boardcfg[40] == 2)
90 #define SDIType (saa->boardcfg[27])
91 #define CurrentMode (saa->boardcfg[2])
92
93 #define debNormal (NewCard ? nDebNormal : oDebNormal)
94 #define debNoInc (NewCard ? nDebNoInc : oDebNoInc)
95 #define debVideo (NewCard ? nDebVideo : oDebVideo)
96 #define debAudio (NewCard ? nDebAudio : oDebAudio)
97 #define debDMA (NewCard ? nDebDMA : oDebDMA)
98
99 #ifdef USE_RESCUE_EEPROM_SDM275
100 static unsigned char rescue_eeprom[64] = {
101 0x00, 0x01, 0x04, 0x13, 0x26, 0x0f, 0x10, 0x00, 0x00, 0x00, 0x43, 0x63,
102 0x22, 0x01, 0x29, 0x15, 0x73, 0x00, 0x1f, 'd', 'e', 'c', 'x', 'l',
103 'd', 'v', 'a', 0x02, 0x00, 0x01, 0x00, 0xcc, 0xa4, 0x63, 0x09, 0xe2,
104 0x10, 0x00, 0x0a, 0x00, 0x02, 0x02, 'd', 'e', 'c', 'x', 'l', 'a',
105 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
106 0x00, 0x00, 0x00, 0x00,
107 };
108 #endif
109
110 /* ----------------------------------------------------------------------- */
111 /* Hardware I2C functions */
112 static void I2CWipe(struct saa7146 *saa)
113 {
114 int i;
115 /* set i2c to ~=100kHz, abort transfer, clear busy */
116 saawrite(0x600 | SAA7146_I2C_ABORT, SAA7146_I2C_STATUS);
117 saawrite((SAA7146_MC2_UPLD_I2C << 16) |
118 SAA7146_MC2_UPLD_I2C, SAA7146_MC2);
119 /* wait for i2c registers to be programmed */
120 for (i = 0; i < 1000 &&
121 !(saaread(SAA7146_MC2) & SAA7146_MC2_UPLD_I2C); i++)
122 schedule();
123 saawrite(0x600, SAA7146_I2C_STATUS);
124 saawrite((SAA7146_MC2_UPLD_I2C << 16) |
125 SAA7146_MC2_UPLD_I2C, SAA7146_MC2);
126 /* wait for i2c registers to be programmed */
127 for (i = 0; i < 1000 &&
128 !(saaread(SAA7146_MC2) & SAA7146_MC2_UPLD_I2C); i++)
129 schedule();
130 saawrite(0x600, SAA7146_I2C_STATUS);
131 saawrite((SAA7146_MC2_UPLD_I2C << 16) |
132 SAA7146_MC2_UPLD_I2C, SAA7146_MC2);
133 /* wait for i2c registers to be programmed */
134 for (i = 0; i < 1000 &&
135 !(saaread(SAA7146_MC2) & SAA7146_MC2_UPLD_I2C); i++)
136 schedule();
137 }
138
139 /* read I2C */
140 static int I2CRead(struct saa7146 *saa, unsigned char addr,
141 unsigned char subaddr, int dosub)
142 {
143 int i;
144
145 if (saaread(SAA7146_I2C_STATUS) & 0x3c)
146 I2CWipe(saa);
147 for (i = 0;
148 i < 1000 && (saaread(SAA7146_I2C_STATUS) & SAA7146_I2C_BUSY);
149 i++)
150 schedule();
151 if (i == 1000)
152 I2CWipe(saa);
153 if (dosub)
154 saawrite(((addr & 0xfe) << 24) | (((addr | 1) & 0xff) << 8) |
155 ((subaddr & 0xff) << 16) | 0xed, SAA7146_I2C_TRANSFER);
156 else
157 saawrite(((addr & 0xfe) << 24) | (((addr | 1) & 0xff) << 16) |
158 0xf1, SAA7146_I2C_TRANSFER);
159 saawrite((SAA7146_MC2_UPLD_I2C << 16) |
160 SAA7146_MC2_UPLD_I2C, SAA7146_MC2);
161 /* wait for i2c registers to be programmed */
162 for (i = 0; i < 1000 &&
163 !(saaread(SAA7146_MC2) & SAA7146_MC2_UPLD_I2C); i++)
164 schedule();
165 /* wait for valid data */
166 for (i = 0; i < 1000 &&
167 (saaread(SAA7146_I2C_STATUS) & SAA7146_I2C_BUSY); i++)
168 schedule();
169 if (saaread(SAA7146_I2C_STATUS) & SAA7146_I2C_ERR)
170 return -1;
171 if (i == 1000)
172 printk("i2c setup read timeout\n");
173 saawrite(0x41, SAA7146_I2C_TRANSFER);
174 saawrite((SAA7146_MC2_UPLD_I2C << 16) |
175 SAA7146_MC2_UPLD_I2C, SAA7146_MC2);
176 /* wait for i2c registers to be programmed */
177 for (i = 0; i < 1000 &&
178 !(saaread(SAA7146_MC2) & SAA7146_MC2_UPLD_I2C); i++)
179 schedule();
180 /* wait for valid data */
181 for (i = 0; i < 1000 &&
182 (saaread(SAA7146_I2C_TRANSFER) & SAA7146_I2C_BUSY); i++)
183 schedule();
184 if (saaread(SAA7146_I2C_TRANSFER) & SAA7146_I2C_ERR)
185 return -1;
186 if (i == 1000)
187 printk("i2c read timeout\n");
188 return ((saaread(SAA7146_I2C_TRANSFER) >> 24) & 0xff);
189 }
190
191 /* set both to write both bytes, reset it to write only b1 */
192
193 static int I2CWrite(struct saa7146 *saa, unsigned char addr, unsigned char b1,
194 unsigned char b2, int both)
195 {
196 int i;
197 u32 data;
198
199 if (saaread(SAA7146_I2C_STATUS) & 0x3c)
200 I2CWipe(saa);
201 for (i = 0; i < 1000 &&
202 (saaread(SAA7146_I2C_STATUS) & SAA7146_I2C_BUSY); i++)
203 schedule();
204 if (i == 1000)
205 I2CWipe(saa);
206 data = ((addr & 0xfe) << 24) | ((b1 & 0xff) << 16);
207 if (both)
208 data |= ((b2 & 0xff) << 8) | 0xe5;
209 else
210 data |= 0xd1;
211 saawrite(data, SAA7146_I2C_TRANSFER);
212 saawrite((SAA7146_MC2_UPLD_I2C << 16) | SAA7146_MC2_UPLD_I2C,
213 SAA7146_MC2);
214 return 0;
215 }
216
217 static void attach_inform(struct saa7146 *saa, int id)
218 {
219 int i;
220
221 DEBUG(printk(KERN_DEBUG "stradis%d: i2c: device found=%02x\n", saa->nr,
222 id));
223 if (id == 0xa0) { /* we have rev2 or later board, fill in info */
224 for (i = 0; i < 64; i++)
225 saa->boardcfg[i] = I2CRead(saa, 0xa0, i, 1);
226 #ifdef USE_RESCUE_EEPROM_SDM275
227 if (saa->boardcfg[0] != 0) {
228 printk("stradis%d: WARNING: EEPROM STORED VALUES HAVE "
229 "BEEN IGNORED\n", saa->nr);
230 for (i = 0; i < 64; i++)
231 saa->boardcfg[i] = rescue_eeprom[i];
232 }
233 #endif
234 printk("stradis%d: config =", saa->nr);
235 for (i = 0; i < 51; i++) {
236 printk(" %02x", saa->boardcfg[i]);
237 }
238 printk("\n");
239 }
240 }
241
242 static void I2CBusScan(struct saa7146 *saa)
243 {
244 int i;
245 for (i = 0; i < 0xff; i += 2)
246 if ((I2CRead(saa, i, 0, 0)) >= 0)
247 attach_inform(saa, i);
248 }
249
250 static int debiwait_maxwait = 0;
251
252 static int wait_for_debi_done(struct saa7146 *saa)
253 {
254 int i;
255
256 /* wait for registers to be programmed */
257 for (i = 0; i < 100000 &&
258 !(saaread(SAA7146_MC2) & SAA7146_MC2_UPLD_DEBI); i++)
259 saaread(SAA7146_MC2);
260 /* wait for transfer to complete */
261 for (i = 0; i < 500000 &&
262 (saaread(SAA7146_PSR) & SAA7146_PSR_DEBI_S); i++)
263 saaread(SAA7146_MC2);
264
265 if (i > debiwait_maxwait)
266 printk("wait-for-debi-done maxwait: %d\n",
267 debiwait_maxwait = i);
268
269 if (i == 500000)
270 return -1;
271
272 return 0;
273 }
274
275 static int debiwrite(struct saa7146 *saa, u32 config, int addr,
276 u32 val, int count)
277 {
278 u32 cmd;
279 if (count <= 0 || count > 32764)
280 return -1;
281 if (wait_for_debi_done(saa) < 0)
282 return -1;
283 saawrite(config, SAA7146_DEBI_CONFIG);
284 if (count <= 4) /* immediate transfer */
285 saawrite(val, SAA7146_DEBI_AD);
286 else /* block transfer */
287 saawrite(virt_to_bus(saa->dmadebi), SAA7146_DEBI_AD);
288 saawrite((cmd = (count << 17) | (addr & 0xffff)), SAA7146_DEBI_COMMAND);
289 saawrite((SAA7146_MC2_UPLD_DEBI << 16) | SAA7146_MC2_UPLD_DEBI,
290 SAA7146_MC2);
291 return 0;
292 }
293
294 static u32 debiread(struct saa7146 *saa, u32 config, int addr, int count)
295 {
296 u32 result = 0;
297
298 if (count > 32764 || count <= 0)
299 return 0;
300 if (wait_for_debi_done(saa) < 0)
301 return 0;
302 saawrite(virt_to_bus(saa->dmadebi), SAA7146_DEBI_AD);
303 saawrite((count << 17) | 0x10000 | (addr & 0xffff),
304 SAA7146_DEBI_COMMAND);
305 saawrite(config, SAA7146_DEBI_CONFIG);
306 saawrite((SAA7146_MC2_UPLD_DEBI << 16) | SAA7146_MC2_UPLD_DEBI,
307 SAA7146_MC2);
308 if (count > 4) /* not an immediate transfer */
309 return count;
310 wait_for_debi_done(saa);
311 result = saaread(SAA7146_DEBI_AD);
312 if (count == 1)
313 result &= 0xff;
314 if (count == 2)
315 result &= 0xffff;
316 if (count == 3)
317 result &= 0xffffff;
318 return result;
319 }
320
321 static void do_irq_send_data(struct saa7146 *saa)
322 {
323 int split, audbytes, vidbytes;
324
325 saawrite(SAA7146_PSR_PIN1, SAA7146_IER);
326 /* if special feature mode in effect, disable audio sending */
327 if (saa->playmode != VID_PLAY_NORMAL)
328 saa->audtail = saa->audhead = 0;
329 if (saa->audhead <= saa->audtail)
330 audbytes = saa->audtail - saa->audhead;
331 else
332 audbytes = 65536 - (saa->audhead - saa->audtail);
333 if (saa->vidhead <= saa->vidtail)
334 vidbytes = saa->vidtail - saa->vidhead;
335 else
336 vidbytes = 524288 - (saa->vidhead - saa->vidtail);
337 if (audbytes == 0 && vidbytes == 0 && saa->osdtail == saa->osdhead) {
338 saawrite(0, SAA7146_IER);
339 return;
340 }
341 /* if at least 1 block audio waiting and audio fifo isn't full */
342 if (audbytes >= 2048 && (debiread(saa, debNormal, IBM_MP2_AUD_FIFO, 2)
343 & 0xff) < 60) {
344 if (saa->audhead > saa->audtail)
345 split = 65536 - saa->audhead;
346 else
347 split = 0;
348 audbytes = 2048;
349 if (split > 0 && split < 2048) {
350 memcpy(saa->dmadebi, saa->audbuf + saa->audhead, split);
351 saa->audhead = 0;
352 audbytes -= split;
353 } else
354 split = 0;
355 memcpy(saa->dmadebi + split, saa->audbuf + saa->audhead,
356 audbytes);
357 saa->audhead += audbytes;
358 saa->audhead &= 0xffff;
359 debiwrite(saa, debAudio, (NewCard ? IBM_MP2_AUD_FIFO :
360 IBM_MP2_AUD_FIFOW), 0, 2048);
361 wake_up_interruptible(&saa->audq);
362 /* if at least 1 block video waiting and video fifo isn't full */
363 } else if (vidbytes >= 30720 && (debiread(saa, debNormal,
364 IBM_MP2_FIFO, 2)) < 16384) {
365 if (saa->vidhead > saa->vidtail)
366 split = 524288 - saa->vidhead;
367 else
368 split = 0;
369 vidbytes = 30720;
370 if (split > 0 && split < 30720) {
371 memcpy(saa->dmadebi, saa->vidbuf + saa->vidhead, split);
372 saa->vidhead = 0;
373 vidbytes -= split;
374 } else
375 split = 0;
376 memcpy(saa->dmadebi + split, saa->vidbuf + saa->vidhead,
377 vidbytes);
378 saa->vidhead += vidbytes;
379 saa->vidhead &= 0x7ffff;
380 debiwrite(saa, debVideo, (NewCard ? IBM_MP2_FIFO :
381 IBM_MP2_FIFOW), 0, 30720);
382 wake_up_interruptible(&saa->vidq);
383 }
384 saawrite(SAA7146_PSR_DEBI_S | SAA7146_PSR_PIN1, SAA7146_IER);
385 }
386
387 static void send_osd_data(struct saa7146 *saa)
388 {
389 int size = saa->osdtail - saa->osdhead;
390 if (size > 30720)
391 size = 30720;
392 /* ensure some multiple of 8 bytes is transferred */
393 size = 8 * ((size + 8) >> 3);
394 if (size) {
395 debiwrite(saa, debNormal, IBM_MP2_OSD_ADDR,
396 (saa->osdhead >> 3), 2);
397 memcpy(saa->dmadebi, &saa->osdbuf[saa->osdhead], size);
398 saa->osdhead += size;
399 /* block transfer of next 8 bytes to ~32k bytes */
400 debiwrite(saa, debNormal, IBM_MP2_OSD_DATA, 0, size);
401 }
402 if (saa->osdhead >= saa->osdtail) {
403 saa->osdhead = saa->osdtail = 0;
404 debiwrite(saa, debNormal, IBM_MP2_MASK0, 0xc00c, 2);
405 }
406 }
407
408 static irqreturn_t saa7146_irq(int irq, void *dev_id, struct pt_regs *regs)
409 {
410 struct saa7146 *saa = dev_id;
411 u32 stat, astat;
412 int count;
413 int handled = 0;
414
415 count = 0;
416 while (1) {
417 /* get/clear interrupt status bits */
418 stat = saaread(SAA7146_ISR);
419 astat = stat & saaread(SAA7146_IER);
420 if (!astat)
421 break;
422 handled = 1;
423 saawrite(astat, SAA7146_ISR);
424 if (astat & SAA7146_PSR_DEBI_S) {
425 do_irq_send_data(saa);
426 }
427 if (astat & SAA7146_PSR_PIN1) {
428 int istat;
429 /* the following read will trigger DEBI_S */
430 istat = debiread(saa, debNormal, IBM_MP2_HOST_INT, 2);
431 if (istat & 1) {
432 saawrite(0, SAA7146_IER);
433 send_osd_data(saa);
434 saawrite(SAA7146_PSR_DEBI_S |
435 SAA7146_PSR_PIN1, SAA7146_IER);
436 }
437 if (istat & 0x20) { /* Video Start */
438 saa->vidinfo.frame_count++;
439 }
440 if (istat & 0x400) { /* Picture Start */
441 /* update temporal reference */
442 }
443 if (istat & 0x200) { /* Picture Resolution Change */
444 /* read new resolution */
445 }
446 if (istat & 0x100) { /* New User Data found */
447 /* read new user data */
448 }
449 if (istat & 0x1000) { /* new GOP/SMPTE */
450 /* read new SMPTE */
451 }
452 if (istat & 0x8000) { /* Sequence Start Code */
453 /* reset frame counter, load sizes */
454 saa->vidinfo.frame_count = 0;
455 saa->vidinfo.h_size = 704;
456 saa->vidinfo.v_size = 480;
457 #if 0
458 if (saa->endmarkhead != saa->endmarktail) {
459 saa->audhead =
460 saa->endmark[saa->endmarkhead];
461 saa->endmarkhead++;
462 if (saa->endmarkhead >= MAX_MARKS)
463 saa->endmarkhead = 0;
464 }
465 #endif
466 }
467 if (istat & 0x4000) { /* Sequence Error Code */
468 if (saa->endmarkhead != saa->endmarktail) {
469 saa->audhead =
470 saa->endmark[saa->endmarkhead];
471 saa->endmarkhead++;
472 if (saa->endmarkhead >= MAX_MARKS)
473 saa->endmarkhead = 0;
474 }
475 }
476 }
477 #ifdef IDEBUG
478 if (astat & SAA7146_PSR_PPEF) {
479 IDEBUG(printk("stradis%d irq: PPEF\n", saa->nr));
480 }
481 if (astat & SAA7146_PSR_PABO) {
482 IDEBUG(printk("stradis%d irq: PABO\n", saa->nr));
483 }
484 if (astat & SAA7146_PSR_PPED) {
485 IDEBUG(printk("stradis%d irq: PPED\n", saa->nr));
486 }
487 if (astat & SAA7146_PSR_RPS_I1) {
488 IDEBUG(printk("stradis%d irq: RPS_I1\n", saa->nr));
489 }
490 if (astat & SAA7146_PSR_RPS_I0) {
491 IDEBUG(printk("stradis%d irq: RPS_I0\n", saa->nr));
492 }
493 if (astat & SAA7146_PSR_RPS_LATE1) {
494 IDEBUG(printk("stradis%d irq: RPS_LATE1\n", saa->nr));
495 }
496 if (astat & SAA7146_PSR_RPS_LATE0) {
497 IDEBUG(printk("stradis%d irq: RPS_LATE0\n", saa->nr));
498 }
499 if (astat & SAA7146_PSR_RPS_E1) {
500 IDEBUG(printk("stradis%d irq: RPS_E1\n", saa->nr));
501 }
502 if (astat & SAA7146_PSR_RPS_E0) {
503 IDEBUG(printk("stradis%d irq: RPS_E0\n", saa->nr));
504 }
505 if (astat & SAA7146_PSR_RPS_TO1) {
506 IDEBUG(printk("stradis%d irq: RPS_TO1\n", saa->nr));
507 }
508 if (astat & SAA7146_PSR_RPS_TO0) {
509 IDEBUG(printk("stradis%d irq: RPS_TO0\n", saa->nr));
510 }
511 if (astat & SAA7146_PSR_UPLD) {
512 IDEBUG(printk("stradis%d irq: UPLD\n", saa->nr));
513 }
514 if (astat & SAA7146_PSR_DEBI_E) {
515 IDEBUG(printk("stradis%d irq: DEBI_E\n", saa->nr));
516 }
517 if (astat & SAA7146_PSR_I2C_S) {
518 IDEBUG(printk("stradis%d irq: I2C_S\n", saa->nr));
519 }
520 if (astat & SAA7146_PSR_I2C_E) {
521 IDEBUG(printk("stradis%d irq: I2C_E\n", saa->nr));
522 }
523 if (astat & SAA7146_PSR_A2_IN) {
524 IDEBUG(printk("stradis%d irq: A2_IN\n", saa->nr));
525 }
526 if (astat & SAA7146_PSR_A2_OUT) {
527 IDEBUG(printk("stradis%d irq: A2_OUT\n", saa->nr));
528 }
529 if (astat & SAA7146_PSR_A1_IN) {
530 IDEBUG(printk("stradis%d irq: A1_IN\n", saa->nr));
531 }
532 if (astat & SAA7146_PSR_A1_OUT) {
533 IDEBUG(printk("stradis%d irq: A1_OUT\n", saa->nr));
534 }
535 if (astat & SAA7146_PSR_AFOU) {
536 IDEBUG(printk("stradis%d irq: AFOU\n", saa->nr));
537 }
538 if (astat & SAA7146_PSR_V_PE) {
539 IDEBUG(printk("stradis%d irq: V_PE\n", saa->nr));
540 }
541 if (astat & SAA7146_PSR_VFOU) {
542 IDEBUG(printk("stradis%d irq: VFOU\n", saa->nr));
543 }
544 if (astat & SAA7146_PSR_FIDA) {
545 IDEBUG(printk("stradis%d irq: FIDA\n", saa->nr));
546 }
547 if (astat & SAA7146_PSR_FIDB) {
548 IDEBUG(printk("stradis%d irq: FIDB\n", saa->nr));
549 }
550 if (astat & SAA7146_PSR_PIN3) {
551 IDEBUG(printk("stradis%d irq: PIN3\n", saa->nr));
552 }
553 if (astat & SAA7146_PSR_PIN2) {
554 IDEBUG(printk("stradis%d irq: PIN2\n", saa->nr));
555 }
556 if (astat & SAA7146_PSR_PIN0) {
557 IDEBUG(printk("stradis%d irq: PIN0\n", saa->nr));
558 }
559 if (astat & SAA7146_PSR_ECS) {
560 IDEBUG(printk("stradis%d irq: ECS\n", saa->nr));
561 }
562 if (astat & SAA7146_PSR_EC3S) {
563 IDEBUG(printk("stradis%d irq: EC3S\n", saa->nr));
564 }
565 if (astat & SAA7146_PSR_EC0S) {
566 IDEBUG(printk("stradis%d irq: EC0S\n", saa->nr));
567 }
568 #endif
569 count++;
570 if (count > 15)
571 printk(KERN_WARNING "stradis%d: irq loop %d\n",
572 saa->nr, count);
573 if (count > 20) {
574 saawrite(0, SAA7146_IER);
575 printk(KERN_ERR
576 "stradis%d: IRQ loop cleared\n", saa->nr);
577 }
578 }
579 return IRQ_RETVAL(handled);
580 }
581
582 static int ibm_send_command(struct saa7146 *saa,
583 int command, int data, int chain)
584 {
585 int i;
586
587 if (chain)
588 debiwrite(saa, debNormal, IBM_MP2_COMMAND, (command << 1)| 1,2);
589 else
590 debiwrite(saa, debNormal, IBM_MP2_COMMAND, command << 1, 2);
591 debiwrite(saa, debNormal, IBM_MP2_CMD_DATA, data, 2);
592 debiwrite(saa, debNormal, IBM_MP2_CMD_STAT, 1, 2);
593 for (i = 0; i < 100 &&
594 (debiread(saa, debNormal, IBM_MP2_CMD_STAT, 2) & 1); i++)
595 schedule();
596 if (i == 100)
597 return -1;
598 return 0;
599 }
600
601 static void cs4341_setlevel(struct saa7146 *saa, int left, int right)
602 {
603 I2CWrite(saa, 0x22, 0x03, left > 94 ? 94 : left, 2);
604 I2CWrite(saa, 0x22, 0x04, right > 94 ? 94 : right, 2);
605 }
606
607 static void initialize_cs4341(struct saa7146 *saa)
608 {
609 int i;
610 for (i = 0; i < 200; i++) {
611 /* auto mute off, power on, no de-emphasis */
612 /* I2S data up to 24-bit 64xFs internal SCLK */
613 I2CWrite(saa, 0x22, 0x01, 0x11, 2);
614 /* ATAPI mixer settings */
615 I2CWrite(saa, 0x22, 0x02, 0x49, 2);
616 /* attenuation left 3db */
617 I2CWrite(saa, 0x22, 0x03, 0x00, 2);
618 /* attenuation right 3db */
619 I2CWrite(saa, 0x22, 0x04, 0x00, 2);
620 I2CWrite(saa, 0x22, 0x01, 0x10, 2);
621 if (I2CRead(saa, 0x22, 0x02, 1) == 0x49)
622 break;
623 schedule();
624 }
625 printk("stradis%d: CS4341 initialized (%d)\n", saa->nr, i);
626 return;
627 }
628
629 static void initialize_cs8420(struct saa7146 *saa, int pro)
630 {
631 int i;
632 u8 *sequence;
633 if (pro)
634 sequence = mode8420pro;
635 else
636 sequence = mode8420con;
637 for (i = 0; i < INIT8420LEN; i++)
638 I2CWrite(saa, 0x20, init8420[i * 2], init8420[i * 2 + 1], 2);
639 for (i = 0; i < MODE8420LEN; i++)
640 I2CWrite(saa, 0x20, sequence[i * 2], sequence[i * 2 + 1], 2);
641 printk("stradis%d: CS8420 initialized\n", saa->nr);
642 }
643
644 static void initialize_saa7121(struct saa7146 *saa, int dopal)
645 {
646 int i, mod;
647 u8 *sequence;
648 if (dopal)
649 sequence = init7121pal;
650 else
651 sequence = init7121ntsc;
652 mod = saaread(SAA7146_PSR) & 0x08;
653 /* initialize PAL/NTSC video encoder */
654 for (i = 0; i < INIT7121LEN; i++) {
655 if (NewCard) { /* handle new card encoder differences */
656 if (sequence[i * 2] == 0x3a)
657 I2CWrite(saa, 0x88, 0x3a, 0x13, 2);
658 else if (sequence[i * 2] == 0x6b)
659 I2CWrite(saa, 0x88, 0x6b, 0x20, 2);
660 else if (sequence[i * 2] == 0x6c)
661 I2CWrite(saa, 0x88, 0x6c,
662 dopal ? 0x09 : 0xf5, 2);
663 else if (sequence[i * 2] == 0x6d)
664 I2CWrite(saa, 0x88, 0x6d,
665 dopal ? 0x20 : 0x00, 2);
666 else if (sequence[i * 2] == 0x7a)
667 I2CWrite(saa, 0x88, 0x7a,
668 dopal ? (PALFirstActive - 1) :
669 (NTSCFirstActive - 4), 2);
670 else if (sequence[i * 2] == 0x7b)
671 I2CWrite(saa, 0x88, 0x7b,
672 dopal ? PALLastActive :
673 NTSCLastActive, 2);
674 else
675 I2CWrite(saa, 0x88, sequence[i * 2],
676 sequence[i * 2 + 1], 2);
677 } else {
678 if (sequence[i * 2] == 0x6b && mod)
679 I2CWrite(saa, 0x88, 0x6b,
680 (sequence[i * 2 + 1] ^ 0x09), 2);
681 else if (sequence[i * 2] == 0x7a)
682 I2CWrite(saa, 0x88, 0x7a,
683 dopal ? (PALFirstActive - 1) :
684 (NTSCFirstActive - 4), 2);
685 else if (sequence[i * 2] == 0x7b)
686 I2CWrite(saa, 0x88, 0x7b,
687 dopal ? PALLastActive :
688 NTSCLastActive, 2);
689 else
690 I2CWrite(saa, 0x88, sequence[i * 2],
691 sequence[i * 2 + 1], 2);
692 }
693 }
694 }
695
696 static void set_genlock_offset(struct saa7146 *saa, int noffset)
697 {
698 int nCode;
699 int PixelsPerLine = 858;
700 if (CurrentMode == VIDEO_MODE_PAL)
701 PixelsPerLine = 864;
702 if (noffset > 500)
703 noffset = 500;
704 else if (noffset < -500)
705 noffset = -500;
706 nCode = noffset + 0x100;
707 if (nCode == 1)
708 nCode = 0x401;
709 else if (nCode < 1)
710 nCode = 0x400 + PixelsPerLine + nCode;
711 debiwrite(saa, debNormal, XILINX_GLDELAY, nCode, 2);
712 }
713
714 static void set_out_format(struct saa7146 *saa, int mode)
715 {
716 initialize_saa7121(saa, (mode == VIDEO_MODE_NTSC ? 0 : 1));
717 saa->boardcfg[2] = mode;
718 /* do not adjust analog video parameters here, use saa7121 init */
719 /* you will affect the SDI output on the new card */
720 if (mode == VIDEO_MODE_PAL) { /* PAL */
721 debiwrite(saa, debNormal, XILINX_CTL0, 0x0808, 2);
722 mdelay(50);
723 saawrite(0x012002c0, SAA7146_NUM_LINE_BYTE1);
724 if (NewCard) {
725 debiwrite(saa, debNormal, IBM_MP2_DISP_MODE, 0xe100, 2);
726 mdelay(50);
727 }
728 debiwrite(saa, debNormal, IBM_MP2_DISP_MODE,
729 NewCard ? 0xe500 : 0x6500, 2);
730 debiwrite(saa, debNormal, IBM_MP2_DISP_DLY,
731 (1 << 8) |
732 (NewCard ? PALFirstActive : PALFirstActive - 6), 2);
733 } else { /* NTSC */
734 debiwrite(saa, debNormal, XILINX_CTL0, 0x0800, 2);
735 mdelay(50);
736 saawrite(0x00f002c0, SAA7146_NUM_LINE_BYTE1);
737 debiwrite(saa, debNormal, IBM_MP2_DISP_MODE,
738 NewCard ? 0xe100 : 0x6100, 2);
739 debiwrite(saa, debNormal, IBM_MP2_DISP_DLY,
740 (1 << 8) |
741 (NewCard ? NTSCFirstActive : NTSCFirstActive - 6), 2);
742 }
743 }
744
745 /* Intialize bitmangler to map from a byte value to the mangled word that
746 * must be output to program the Xilinx part through the DEBI port.
747 * Xilinx Data Bit->DEBI Bit: 0->15 1->7 2->6 3->12 4->11 5->2 6->1 7->0
748 * transfer FPGA code, init IBM chip, transfer IBM microcode
749 * rev2 card mangles: 0->7 1->6 2->5 3->4 4->3 5->2 6->1 7->0
750 */
751 static u16 bitmangler[256];
752
753 static int initialize_fpga(struct video_code *bitdata)
754 {
755 int i, num, startindex, failure = 0, loadtwo, loadfile = 0;
756 u16 *dmabuf;
757 u8 *newdma;
758 struct saa7146 *saa;
759
760 /* verify fpga code */
761 for (startindex = 0; startindex < bitdata->datasize; startindex++)
762 if (bitdata->data[startindex] == 255)
763 break;
764 if (startindex == bitdata->datasize) {
765 printk(KERN_INFO "stradis: bad fpga code\n");
766 return -1;
767 }
768 /* initialize all detected cards */
769 for (num = 0; num < saa_num; num++) {
770 saa = &saa7146s[num];
771 if (saa->boardcfg[0] > 20)
772 continue; /* card was programmed */
773 loadtwo = (saa->boardcfg[18] & 0x10);
774 if (!NewCard) /* we have an old board */
775 for (i = 0; i < 256; i++)
776 bitmangler[i] = ((i & 0x01) << 15) |
777 ((i & 0x02) << 6) | ((i & 0x04) << 4) |
778 ((i & 0x08) << 9) | ((i & 0x10) << 7) |
779 ((i & 0x20) >> 3) | ((i & 0x40) >> 5) |
780 ((i & 0x80) >> 7);
781 else /* else we have a new board */
782 for (i = 0; i < 256; i++)
783 bitmangler[i] = ((i & 0x01) << 7) |
784 ((i & 0x02) << 5) | ((i & 0x04) << 3) |
785 ((i & 0x08) << 1) | ((i & 0x10) >> 1) |
786 ((i & 0x20) >> 3) | ((i & 0x40) >> 5) |
787 ((i & 0x80) >> 7);
788
789 dmabuf = (u16 *) saa->dmadebi;
790 newdma = (u8 *) saa->dmadebi;
791 if (NewCard) { /* SDM2xxx */
792 if (!strncmp(bitdata->loadwhat, "decoder2", 8))
793 continue; /* fpga not for this card */
794 if (!strncmp(&saa->boardcfg[42], bitdata->loadwhat, 8))
795 loadfile = 1;
796 else if (loadtwo && !strncmp(&saa->boardcfg[19],
797 bitdata->loadwhat, 8))
798 loadfile = 2;
799 else if (!saa->boardcfg[42] && !strncmp("decxl",
800 bitdata->loadwhat, 8))
801 loadfile = 1; /* special */
802 else
803 continue; /* fpga not for this card */
804 if (loadfile != 1 && loadfile != 2)
805 continue; /* skip to next card */
806 if (saa->boardcfg[0] && loadfile == 1)
807 continue; /* skip to next card */
808 if (saa->boardcfg[0] != 1 && loadfile == 2)
809 continue; /* skip to next card */
810 saa->boardcfg[0]++; /* mark fpga handled */
811 printk("stradis%d: loading %s\n", saa->nr,
812 bitdata->loadwhat);
813 if (loadtwo && loadfile == 2)
814 goto send_fpga_stuff;
815 /* turn on the Audio interface to set PROG low */
816 saawrite(0x00400040, SAA7146_GPIO_CTRL);
817 saaread(SAA7146_PSR); /* ensure posted write */
818 /* wait for everyone to reset */
819 mdelay(10);
820 saawrite(0x00400000, SAA7146_GPIO_CTRL);
821 } else { /* original card */
822 if (strncmp(bitdata->loadwhat, "decoder2", 8))
823 continue; /* fpga not for this card */
824 /* Pull the Xilinx PROG signal WS3 low */
825 saawrite(0x02000200, SAA7146_MC1);
826 /* Turn on the Audio interface so can set PROG low */
827 saawrite(0x000000c0, SAA7146_ACON1);
828 /* Pull the Xilinx INIT signal (GPIO2) low */
829 saawrite(0x00400000, SAA7146_GPIO_CTRL);
830 /* Make sure everybody resets */
831 saaread(SAA7146_PSR); /* ensure posted write */
832 mdelay(10);
833 /* Release the Xilinx PROG signal */
834 saawrite(0x00000000, SAA7146_ACON1);
835 /* Turn off the Audio interface */
836 saawrite(0x02000000, SAA7146_MC1);
837 }
838 /* Release Xilinx INIT signal (WS2) */
839 saawrite(0x00000000, SAA7146_GPIO_CTRL);
840 /* Wait for the INIT to go High */
841 for (i = 0;
842 i < 10000 && !(saaread(SAA7146_PSR) & SAA7146_PSR_PIN2);
843 i++)
844 schedule();
845 if (i == 1000) {
846 printk(KERN_INFO "stradis%d: no fpga INIT\n", saa->nr);
847 return -1;
848 }
849 send_fpga_stuff:
850 if (NewCard) {
851 for (i = startindex; i < bitdata->datasize; i++)
852 newdma[i - startindex] =
853 bitmangler[bitdata->data[i]];
854 debiwrite(saa, 0x01420000, 0, 0,
855 ((bitdata->datasize - startindex) + 5));
856 if (loadtwo && loadfile == 1) {
857 printk("stradis%d: awaiting 2nd FPGA bitfile\n",
858 saa->nr);
859 continue; /* skip to next card */
860 }
861 } else {
862 for (i = startindex; i < bitdata->datasize; i++)
863 dmabuf[i - startindex] =
864 bitmangler[bitdata->data[i]];
865 debiwrite(saa, 0x014a0000, 0, 0,
866 ((bitdata->datasize - startindex) + 5) * 2);
867 }
868 for (i = 0;
869 i < 1000 && !(saaread(SAA7146_PSR) & SAA7146_PSR_PIN2);
870 i++)
871 schedule();
872 if (i == 1000) {
873 printk(KERN_INFO "stradis%d: FPGA load failed\n",
874 saa->nr);
875 failure++;
876 continue;
877 }
878 if (!NewCard) {
879 /* Pull the Xilinx INIT signal (GPIO2) low */
880 saawrite(0x00400000, SAA7146_GPIO_CTRL);
881 saaread(SAA7146_PSR); /* ensure posted write */
882 mdelay(2);
883 saawrite(0x00000000, SAA7146_GPIO_CTRL);
884 mdelay(2);
885 }
886 printk(KERN_INFO "stradis%d: FPGA Loaded\n", saa->nr);
887 saa->boardcfg[0] = 26; /* mark fpga programmed */
888 /* set VXCO to its lowest frequency */
889 debiwrite(saa, debNormal, XILINX_PWM, 0, 2);
890 if (NewCard) {
891 /* mute CS3310 */
892 if (HaveCS3310)
893 debiwrite(saa, debNormal, XILINX_CS3310_CMPLT,
894 0, 2);
895 /* set VXCO to PWM mode, release reset, blank on */
896 debiwrite(saa, debNormal, XILINX_CTL0, 0xffc4, 2);
897 mdelay(10);
898 /* unmute CS3310 */
899 if (HaveCS3310)
900 debiwrite(saa, debNormal, XILINX_CTL0,
901 0x2020, 2);
902 }
903 /* set source Black */
904 debiwrite(saa, debNormal, XILINX_CTL0, 0x1707, 2);
905 saa->boardcfg[4] = 22; /* set NTSC First Active Line */
906 saa->boardcfg[5] = 23; /* set PAL First Active Line */
907 saa->boardcfg[54] = 2; /* set NTSC Last Active Line - 256 */
908 saa->boardcfg[55] = 54; /* set PAL Last Active Line - 256 */
909 set_out_format(saa, VIDEO_MODE_NTSC);
910 mdelay(50);
911 /* begin IBM chip init */
912 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, 4, 2);
913 saaread(SAA7146_PSR); /* wait for reset */
914 mdelay(5);
915 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, 0, 2);
916 debiread(saa, debNormal, IBM_MP2_CHIP_CONTROL, 2);
917 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, 0x10, 2);
918 debiwrite(saa, debNormal, IBM_MP2_CMD_ADDR, 0, 2);
919 debiwrite(saa, debNormal, IBM_MP2_CHIP_MODE, 0x2e, 2);
920 if (NewCard) {
921 mdelay(5);
922 /* set i2s rate converter to 48KHz */
923 debiwrite(saa, debNormal, 0x80c0, 6, 2);
924 /* we must init CS8420 first since rev b pulls i2s */
925 /* master clock low and CS4341 needs i2s master to */
926 /* run the i2c port. */
927 if (HaveCS8420)
928 /* 0=consumer, 1=pro */
929 initialize_cs8420(saa, 0);
930
931 mdelay(5);
932 if (HaveCS4341)
933 initialize_cs4341(saa);
934 }
935 debiwrite(saa, debNormal, IBM_MP2_INFC_CTL, 0x48, 2);
936 debiwrite(saa, debNormal, IBM_MP2_BEEP_CTL, 0xa000, 2);
937 debiwrite(saa, debNormal, IBM_MP2_DISP_LBOR, 0, 2);
938 debiwrite(saa, debNormal, IBM_MP2_DISP_TBOR, 0, 2);
939 if (NewCard)
940 set_genlock_offset(saa, 0);
941 debiwrite(saa, debNormal, IBM_MP2_FRNT_ATTEN, 0, 2);
942 #if 0
943 /* enable genlock */
944 debiwrite(saa, debNormal, XILINX_CTL0, 0x8000, 2);
945 #else
946 /* disable genlock */
947 debiwrite(saa, debNormal, XILINX_CTL0, 0x8080, 2);
948 #endif
949 }
950
951 return failure;
952 }
953
954 static int do_ibm_reset(struct saa7146 *saa)
955 {
956 /* failure if decoder not previously programmed */
957 if (saa->boardcfg[0] < 37)
958 return -EIO;
959 /* mute CS3310 */
960 if (HaveCS3310)
961 debiwrite(saa, debNormal, XILINX_CS3310_CMPLT, 0, 2);
962 /* disable interrupts */
963 saawrite(0, SAA7146_IER);
964 saa->audhead = saa->audtail = 0;
965 saa->vidhead = saa->vidtail = 0;
966 /* tristate debi bus, disable debi transfers */
967 saawrite(0x00880000, SAA7146_MC1);
968 /* ensure posted write */
969 saaread(SAA7146_MC1);
970 mdelay(50);
971 /* re-enable debi transfers */
972 saawrite(0x00880088, SAA7146_MC1);
973 /* set source Black */
974 debiwrite(saa, debNormal, XILINX_CTL0, 0x1707, 2);
975 /* begin IBM chip init */
976 set_out_format(saa, CurrentMode);
977 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, 4, 2);
978 saaread(SAA7146_PSR); /* wait for reset */
979 mdelay(5);
980 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, 0, 2);
981 debiread(saa, debNormal, IBM_MP2_CHIP_CONTROL, 2);
982 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, ChipControl, 2);
983 debiwrite(saa, debNormal, IBM_MP2_CHIP_MODE, 0x2e, 2);
984 if (NewCard) {
985 mdelay(5);
986 /* set i2s rate converter to 48KHz */
987 debiwrite(saa, debNormal, 0x80c0, 6, 2);
988 /* we must init CS8420 first since rev b pulls i2s */
989 /* master clock low and CS4341 needs i2s master to */
990 /* run the i2c port. */
991 if (HaveCS8420)
992 /* 0=consumer, 1=pro */
993 initialize_cs8420(saa, 1);
994
995 mdelay(5);
996 if (HaveCS4341)
997 initialize_cs4341(saa);
998 }
999 debiwrite(saa, debNormal, IBM_MP2_INFC_CTL, 0x48, 2);
1000 debiwrite(saa, debNormal, IBM_MP2_BEEP_CTL, 0xa000, 2);
1001 debiwrite(saa, debNormal, IBM_MP2_DISP_LBOR, 0, 2);
1002 debiwrite(saa, debNormal, IBM_MP2_DISP_TBOR, 0, 2);
1003 if (NewCard)
1004 set_genlock_offset(saa, 0);
1005 debiwrite(saa, debNormal, IBM_MP2_FRNT_ATTEN, 0, 2);
1006 debiwrite(saa, debNormal, IBM_MP2_OSD_SIZE, 0x2000, 2);
1007 debiwrite(saa, debNormal, IBM_MP2_AUD_CTL, 0x4552, 2);
1008 if (ibm_send_command(saa, IBM_MP2_CONFIG_DECODER,
1009 (ChipControl == 0x43 ? 0xe800 : 0xe000), 1)) {
1010 printk(KERN_ERR "stradis%d: IBM config failed\n", saa->nr);
1011 }
1012 if (HaveCS3310) {
1013 int i = CS3310MaxLvl;
1014 debiwrite(saa, debNormal, XILINX_CS3310_CMPLT, ((i << 8)| i),2);
1015 }
1016 /* start video decoder */
1017 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL, ChipControl, 2);
1018 /* 256k vid, 3520 bytes aud */
1019 debiwrite(saa, debNormal, IBM_MP2_RB_THRESHOLD, 0x4037, 2);
1020 debiwrite(saa, debNormal, IBM_MP2_AUD_CTL, 0x4573, 2);
1021 ibm_send_command(saa, IBM_MP2_PLAY, 0, 0);
1022 /* enable buffer threshold irq */
1023 debiwrite(saa, debNormal, IBM_MP2_MASK0, 0xc00c, 2);
1024 /* clear pending interrupts */
1025 debiread(saa, debNormal, IBM_MP2_HOST_INT, 2);
1026 debiwrite(saa, debNormal, XILINX_CTL0, 0x1711, 2);
1027
1028 return 0;
1029 }
1030
1031 /* load the decoder microcode */
1032 static int initialize_ibmmpeg2(struct video_code *microcode)
1033 {
1034 int i, num;
1035 struct saa7146 *saa;
1036
1037 for (num = 0; num < saa_num; num++) {
1038 saa = &saa7146s[num];
1039 /* check that FPGA is loaded */
1040 debiwrite(saa, debNormal, IBM_MP2_OSD_SIZE, 0xa55a, 2);
1041 i = debiread(saa, debNormal, IBM_MP2_OSD_SIZE, 2);
1042 if (i != 0xa55a) {
1043 printk(KERN_INFO "stradis%d: %04x != 0xa55a\n",
1044 saa->nr, i);
1045 #if 0
1046 return -1;
1047 #endif
1048 }
1049 if (!strncmp(microcode->loadwhat, "decoder.vid", 11)) {
1050 if (saa->boardcfg[0] > 27)
1051 continue; /* skip to next card */
1052 /* load video control store */
1053 saa->boardcfg[1] = 0x13; /* no-sync default */
1054 debiwrite(saa, debNormal, IBM_MP2_WR_PROT, 1, 2);
1055 debiwrite(saa, debNormal, IBM_MP2_PROC_IADDR, 0, 2);
1056 for (i = 0; i < microcode->datasize / 2; i++)
1057 debiwrite(saa, debNormal, IBM_MP2_PROC_IDATA,
1058 (microcode->data[i * 2] << 8) |
1059 microcode->data[i * 2 + 1], 2);
1060 debiwrite(saa, debNormal, IBM_MP2_PROC_IADDR, 0, 2);
1061 debiwrite(saa, debNormal, IBM_MP2_WR_PROT, 0, 2);
1062 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL,
1063 ChipControl, 2);
1064 saa->boardcfg[0] = 28;
1065 }
1066 if (!strncmp(microcode->loadwhat, "decoder.aud", 11)) {
1067 if (saa->boardcfg[0] > 35)
1068 continue; /* skip to next card */
1069 /* load audio control store */
1070 debiwrite(saa, debNormal, IBM_MP2_WR_PROT, 1, 2);
1071 debiwrite(saa, debNormal, IBM_MP2_AUD_IADDR, 0, 2);
1072 for (i = 0; i < microcode->datasize; i++)
1073 debiwrite(saa, debNormal, IBM_MP2_AUD_IDATA,
1074 microcode->data[i], 1);
1075 debiwrite(saa, debNormal, IBM_MP2_AUD_IADDR, 0, 2);
1076 debiwrite(saa, debNormal, IBM_MP2_WR_PROT, 0, 2);
1077 debiwrite(saa, debNormal, IBM_MP2_OSD_SIZE, 0x2000, 2);
1078 debiwrite(saa, debNormal, IBM_MP2_AUD_CTL, 0x4552, 2);
1079 if (ibm_send_command(saa, IBM_MP2_CONFIG_DECODER,
1080 0xe000, 1)) {
1081 printk(KERN_ERR "stradis%d: IBM config "
1082 "failed\n", saa->nr);
1083 return -1;
1084 }
1085 /* set PWM to center value */
1086 if (NewCard) {
1087 debiwrite(saa, debNormal, XILINX_PWM,
1088 saa->boardcfg[14] +
1089 (saa->boardcfg[13] << 8), 2);
1090 } else
1091 debiwrite(saa, debNormal, XILINX_PWM, 0x46, 2);
1092
1093 if (HaveCS3310) {
1094 i = CS3310MaxLvl;
1095 debiwrite(saa, debNormal, XILINX_CS3310_CMPLT,
1096 (i << 8) | i, 2);
1097 }
1098 printk(KERN_INFO "stradis%d: IBM MPEGCD%d Inited\n",
1099 saa->nr, 18 + (debiread(saa, debNormal,
1100 IBM_MP2_CHIP_CONTROL, 2) >> 12));
1101 /* start video decoder */
1102 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL,
1103 ChipControl, 2);
1104 debiwrite(saa, debNormal, IBM_MP2_RB_THRESHOLD, 0x4037,
1105 2); /* 256k vid, 3520 bytes aud */
1106 debiwrite(saa, debNormal, IBM_MP2_AUD_CTL, 0x4573, 2);
1107 ibm_send_command(saa, IBM_MP2_PLAY, 0, 0);
1108 /* enable buffer threshold irq */
1109 debiwrite(saa, debNormal, IBM_MP2_MASK0, 0xc00c, 2);
1110 debiread(saa, debNormal, IBM_MP2_HOST_INT, 2);
1111 /* enable gpio irq */
1112 saawrite(0x00002000, SAA7146_GPIO_CTRL);
1113 /* enable decoder output to HPS */
1114 debiwrite(saa, debNormal, XILINX_CTL0, 0x1711, 2);
1115 saa->boardcfg[0] = 37;
1116 }
1117 }
1118
1119 return 0;
1120 }
1121
1122 static u32 palette2fmt[] = { /* some of these YUV translations are wrong */
1123 0xffffffff, 0x86000000, 0x87000000, 0x80000000, 0x8100000, 0x82000000,
1124 0x83000000, 0x00000000, 0x03000000, 0x03000000, 0x0a00000, 0x03000000,
1125 0x06000000, 0x00000000, 0x03000000, 0x0a000000, 0x0300000
1126 };
1127 static int bpp2fmt[4] = {
1128 VIDEO_PALETTE_HI240, VIDEO_PALETTE_RGB565, VIDEO_PALETTE_RGB24,
1129 VIDEO_PALETTE_RGB32
1130 };
1131
1132 /* I wish I could find a formula to calculate these... */
1133 static u32 h_prescale[64] = {
1134 0x10000000, 0x18040202, 0x18080000, 0x380c0606, 0x38100204, 0x38140808,
1135 0x38180000, 0x381c0000, 0x3820161c, 0x38242a3b, 0x38281230, 0x382c4460,
1136 0x38301040, 0x38340080, 0x38380000, 0x383c0000, 0x3840fefe, 0x3844ee9f,
1137 0x3848ee9f, 0x384cee9f, 0x3850ee9f, 0x38542a3b, 0x38581230, 0x385c0000,
1138 0x38600000, 0x38640000, 0x38680000, 0x386c0000, 0x38700000, 0x38740000,
1139 0x38780000, 0x387c0000, 0x30800000, 0x38840000, 0x38880000, 0x388c0000,
1140 0x38900000, 0x38940000, 0x38980000, 0x389c0000, 0x38a00000, 0x38a40000,
1141 0x38a80000, 0x38ac0000, 0x38b00000, 0x38b40000, 0x38b80000, 0x38bc0000,
1142 0x38c00000, 0x38c40000, 0x38c80000, 0x38cc0000, 0x38d00000, 0x38d40000,
1143 0x38d80000, 0x38dc0000, 0x38e00000, 0x38e40000, 0x38e80000, 0x38ec0000,
1144 0x38f00000, 0x38f40000, 0x38f80000, 0x38fc0000,
1145 };
1146 static u32 v_gain[64] = {
1147 0x016000ff, 0x016100ff, 0x016100ff, 0x016200ff, 0x016200ff, 0x016200ff,
1148 0x016200ff, 0x016300ff, 0x016300ff, 0x016300ff, 0x016300ff, 0x016300ff,
1149 0x016300ff, 0x016300ff, 0x016300ff, 0x016400ff, 0x016400ff, 0x016400ff,
1150 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff,
1151 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff,
1152 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff,
1153 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff,
1154 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff,
1155 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff,
1156 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff,
1157 0x016400ff, 0x016400ff, 0x016400ff, 0x016400ff,
1158 };
1159
1160 static void saa7146_set_winsize(struct saa7146 *saa)
1161 {
1162 u32 format;
1163 int offset, yacl, ysci;
1164 saa->win.color_fmt = format =
1165 (saa->win.depth == 15) ? palette2fmt[VIDEO_PALETTE_RGB555] :
1166 palette2fmt[bpp2fmt[(saa->win.bpp - 1) & 3]];
1167 offset = saa->win.x * saa->win.bpp + saa->win.y * saa->win.bpl;
1168 saawrite(saa->win.vidadr + offset, SAA7146_BASE_EVEN1);
1169 saawrite(saa->win.vidadr + offset + saa->win.bpl, SAA7146_BASE_ODD1);
1170 saawrite(saa->win.bpl * 2, SAA7146_PITCH1);
1171 saawrite(saa->win.vidadr + saa->win.bpl * saa->win.sheight,
1172 SAA7146_PROT_ADDR1);
1173 saawrite(0, SAA7146_PAGE1);
1174 saawrite(format | 0x60, SAA7146_CLIP_FORMAT_CTRL);
1175 offset = (704 / (saa->win.width - 1)) & 0x3f;
1176 saawrite(h_prescale[offset], SAA7146_HPS_H_PRESCALE);
1177 offset = (720896 / saa->win.width) / (offset + 1);
1178 saawrite((offset << 12) | 0x0c, SAA7146_HPS_H_SCALE);
1179 if (CurrentMode == VIDEO_MODE_NTSC) {
1180 yacl = /*(480 / saa->win.height - 1) & 0x3f */ 0;
1181 ysci = 1024 - (saa->win.height * 1024 / 480);
1182 } else {
1183 yacl = /*(576 / saa->win.height - 1) & 0x3f */ 0;
1184 ysci = 1024 - (saa->win.height * 1024 / 576);
1185 }
1186 saawrite((1 << 31) | (ysci << 21) | (yacl << 15), SAA7146_HPS_V_SCALE);
1187 saawrite(v_gain[yacl], SAA7146_HPS_V_GAIN);
1188 saawrite(((SAA7146_MC2_UPLD_DMA1 | SAA7146_MC2_UPLD_HPS_V |
1189 SAA7146_MC2_UPLD_HPS_H) << 16) | (SAA7146_MC2_UPLD_DMA1 |
1190 SAA7146_MC2_UPLD_HPS_V | SAA7146_MC2_UPLD_HPS_H), SAA7146_MC2);
1191 }
1192
1193 /* clip_draw_rectangle(cm,x,y,w,h) -- handle clipping an area
1194 * bitmap is fixed width, 128 bytes (1024 pixels represented)
1195 * arranged most-sigificant-bit-left in 32-bit words
1196 * based on saa7146 clipping hardware, it swaps bytes if LE
1197 * much of this makes up for egcs brain damage -- so if you
1198 * are wondering "why did he do this?" it is because the C
1199 * was adjusted to generate the optimal asm output without
1200 * writing non-portable __asm__ directives.
1201 */
1202
1203 static void clip_draw_rectangle(u32 *clipmap, int x, int y, int w, int h)
1204 {
1205 register int startword, endword;
1206 register u32 bitsleft, bitsright;
1207 u32 *temp;
1208 if (x < 0) {
1209 w += x;
1210 x = 0;
1211 }
1212 if (y < 0) {
1213 h += y;
1214 y = 0;
1215 }
1216 if (w <= 0 || h <= 0 || x > 1023 || y > 639)
1217 return; /* throw away bad clips */
1218 if (x + w > 1024)
1219 w = 1024 - x;
1220 if (y + h > 640)
1221 h = 640 - y;
1222 startword = (x >> 5);
1223 endword = ((x + w) >> 5);
1224 bitsleft = (0xffffffff >> (x & 31));
1225 bitsright = (0xffffffff << (~((x + w) - (endword << 5))));
1226 temp = &clipmap[(y << 5) + startword];
1227 w = endword - startword;
1228 if (!w) {
1229 bitsleft |= bitsright;
1230 for (y = 0; y < h; y++) {
1231 *temp |= bitsleft;
1232 temp += 32;
1233 }
1234 } else {
1235 for (y = 0; y < h; y++) {
1236 *temp++ |= bitsleft;
1237 for (x = 1; x < w; x++)
1238 *temp++ = 0xffffffff;
1239 *temp |= bitsright;
1240 temp += (32 - w);
1241 }
1242 }
1243 }
1244
1245 static void make_clip_tab(struct saa7146 *saa, struct video_clip *cr, int ncr)
1246 {
1247 int i, width, height;
1248 u32 *clipmap;
1249
1250 clipmap = saa->dmavid2;
1251 if ((width = saa->win.width) > 1023)
1252 width = 1023; /* sanity check */
1253 if ((height = saa->win.height) > 640)
1254 height = 639; /* sanity check */
1255 if (ncr > 0) { /* rectangles pased */
1256 /* convert rectangular clips to a bitmap */
1257 memset(clipmap, 0, VIDEO_CLIPMAP_SIZE); /* clear map */
1258 for (i = 0; i < ncr; i++)
1259 clip_draw_rectangle(clipmap, cr[i].x, cr[i].y,
1260 cr[i].width, cr[i].height);
1261 }
1262 /* clip against viewing window AND screen
1263 so we do not have to rely on the user program
1264 */
1265 clip_draw_rectangle(clipmap, (saa->win.x + width > saa->win.swidth) ?
1266 (saa->win.swidth - saa->win.x) : width, 0, 1024, 768);
1267 clip_draw_rectangle(clipmap, 0,
1268 (saa->win.y + height > saa->win.sheight) ?
1269 (saa->win.sheight - saa->win.y) : height, 1024, 768);
1270 if (saa->win.x < 0)
1271 clip_draw_rectangle(clipmap, 0, 0, -saa->win.x, 768);
1272 if (saa->win.y < 0)
1273 clip_draw_rectangle(clipmap, 0, 0, 1024, -saa->win.y);
1274 }
1275
1276 static int saa_ioctl(struct inode *inode, struct file *file,
1277 unsigned int cmd, unsigned long argl)
1278 {
1279 struct saa7146 *saa = file->private_data;
1280 void __user *arg = (void __user *)argl;
1281
1282 switch (cmd) {
1283 case VIDIOCGCAP:
1284 {
1285 struct video_capability b;
1286 strcpy(b.name, saa->video_dev.name);
1287 b.type = VID_TYPE_CAPTURE | VID_TYPE_OVERLAY |
1288 VID_TYPE_CLIPPING | VID_TYPE_FRAMERAM |
1289 VID_TYPE_SCALES;
1290 b.channels = 1;
1291 b.audios = 1;
1292 b.maxwidth = 768;
1293 b.maxheight = 576;
1294 b.minwidth = 32;
1295 b.minheight = 32;
1296 if (copy_to_user(arg, &b, sizeof(b)))
1297 return -EFAULT;
1298 return 0;
1299 }
1300 case VIDIOCGPICT:
1301 {
1302 struct video_picture p = saa->picture;
1303 if (saa->win.depth == 8)
1304 p.palette = VIDEO_PALETTE_HI240;
1305 if (saa->win.depth == 15)
1306 p.palette = VIDEO_PALETTE_RGB555;
1307 if (saa->win.depth == 16)
1308 p.palette = VIDEO_PALETTE_RGB565;
1309 if (saa->win.depth == 24)
1310 p.palette = VIDEO_PALETTE_RGB24;
1311 if (saa->win.depth == 32)
1312 p.palette = VIDEO_PALETTE_RGB32;
1313 if (copy_to_user(arg, &p, sizeof(p)))
1314 return -EFAULT;
1315 return 0;
1316 }
1317 case VIDIOCSPICT:
1318 {
1319 struct video_picture p;
1320 u32 format;
1321 if (copy_from_user(&p, arg, sizeof(p)))
1322 return -EFAULT;
1323 if (p.palette < sizeof(palette2fmt) / sizeof(u32)) {
1324 format = palette2fmt[p.palette];
1325 saa->win.color_fmt = format;
1326 saawrite(format | 0x60,
1327 SAA7146_CLIP_FORMAT_CTRL);
1328 }
1329 saawrite(((p.brightness & 0xff00) << 16) |
1330 ((p.contrast & 0xfe00) << 7) |
1331 ((p.colour & 0xfe00) >> 9), SAA7146_BCS_CTRL);
1332 saa->picture = p;
1333 /* upload changed registers */
1334 saawrite(((SAA7146_MC2_UPLD_HPS_H |
1335 SAA7146_MC2_UPLD_HPS_V) << 16) |
1336 SAA7146_MC2_UPLD_HPS_H |
1337 SAA7146_MC2_UPLD_HPS_V, SAA7146_MC2);
1338 return 0;
1339 }
1340 case VIDIOCSWIN:
1341 {
1342 struct video_window vw;
1343 struct video_clip *vcp = NULL;
1344
1345 if (copy_from_user(&vw, arg, sizeof(vw)))
1346 return -EFAULT;
1347
1348 /* stop capture */
1349 if (vw.flags || vw.width < 16 || vw.height < 16) {
1350 saawrite((SAA7146_MC1_TR_E_1 << 16),
1351 SAA7146_MC1);
1352 return -EINVAL;
1353 }
1354 /* 32-bit align start and adjust width */
1355 if (saa->win.bpp < 4) {
1356 int i = vw.x;
1357 vw.x = (vw.x + 3) & ~3;
1358 i = vw.x - i;
1359 vw.width -= i;
1360 }
1361 saa->win.x = vw.x;
1362 saa->win.y = vw.y;
1363 saa->win.width = vw.width;
1364 if (saa->win.width > 768)
1365 saa->win.width = 768;
1366 saa->win.height = vw.height;
1367 if (CurrentMode == VIDEO_MODE_NTSC) {
1368 if (saa->win.height > 480)
1369 saa->win.height = 480;
1370 } else {
1371 if (saa->win.height > 576)
1372 saa->win.height = 576;
1373 }
1374
1375 /* stop capture */
1376 saawrite((SAA7146_MC1_TR_E_1 << 16), SAA7146_MC1);
1377 saa7146_set_winsize(saa);
1378
1379 /*
1380 * Do any clips.
1381 */
1382 if (vw.clipcount < 0) {
1383 if (copy_from_user(saa->dmavid2, vw.clips,
1384 VIDEO_CLIPMAP_SIZE))
1385 return -EFAULT;
1386 } else if (vw.clipcount > 16384) {
1387 return -EINVAL;
1388 } else if (vw.clipcount > 0) {
1389 vcp = vmalloc(sizeof(struct video_clip) *
1390 vw.clipcount);
1391 if (vcp == NULL)
1392 return -ENOMEM;
1393 if (copy_from_user(vcp, vw.clips,
1394 sizeof(struct video_clip) *
1395 vw.clipcount)) {
1396 vfree(vcp);
1397 return -EFAULT;
1398 }
1399 } else /* nothing clipped */
1400 memset(saa->dmavid2, 0, VIDEO_CLIPMAP_SIZE);
1401
1402 make_clip_tab(saa, vcp, vw.clipcount);
1403 if (vw.clipcount > 0)
1404 vfree(vcp);
1405
1406 /* start capture & clip dma if we have an address */
1407 if ((saa->cap & 3) && saa->win.vidadr != 0)
1408 saawrite(((SAA7146_MC1_TR_E_1 |
1409 SAA7146_MC1_TR_E_2) << 16) | 0xffff,
1410 SAA7146_MC1);
1411 return 0;
1412 }
1413 case VIDIOCGWIN:
1414 {
1415 struct video_window vw;
1416 vw.x = saa->win.x;
1417 vw.y = saa->win.y;
1418 vw.width = saa->win.width;
1419 vw.height = saa->win.height;
1420 vw.chromakey = 0;
1421 vw.flags = 0;
1422 if (copy_to_user(arg, &vw, sizeof(vw)))
1423 return -EFAULT;
1424 return 0;
1425 }
1426 case VIDIOCCAPTURE:
1427 {
1428 int v;
1429 if (copy_from_user(&v, arg, sizeof(v)))
1430 return -EFAULT;
1431 if (v == 0) {
1432 saa->cap &= ~1;
1433 saawrite((SAA7146_MC1_TR_E_1 << 16),
1434 SAA7146_MC1);
1435 } else {
1436 if (saa->win.vidadr == 0 || saa->win.width == 0
1437 || saa->win.height == 0)
1438 return -EINVAL;
1439 saa->cap |= 1;
1440 saawrite((SAA7146_MC1_TR_E_1 << 16) | 0xffff,
1441 SAA7146_MC1);
1442 }
1443 return 0;
1444 }
1445 case VIDIOCGFBUF:
1446 {
1447 struct video_buffer v;
1448 v.base = (void *)saa->win.vidadr;
1449 v.height = saa->win.sheight;
1450 v.width = saa->win.swidth;
1451 v.depth = saa->win.depth;
1452 v.bytesperline = saa->win.bpl;
1453 if (copy_to_user(arg, &v, sizeof(v)))
1454 return -EFAULT;
1455 return 0;
1456
1457 }
1458 case VIDIOCSFBUF:
1459 {
1460 struct video_buffer v;
1461 if (!capable(CAP_SYS_ADMIN))
1462 return -EPERM;
1463 if (copy_from_user(&v, arg, sizeof(v)))
1464 return -EFAULT;
1465 if (v.depth != 8 && v.depth != 15 && v.depth != 16 &&
1466 v.depth != 24 && v.depth != 32 && v.width > 16 &&
1467 v.height > 16 && v.bytesperline > 16)
1468 return -EINVAL;
1469 if (v.base)
1470 saa->win.vidadr = (unsigned long)v.base;
1471 saa->win.sheight = v.height;
1472 saa->win.swidth = v.width;
1473 saa->win.bpp = ((v.depth + 7) & 0x38) / 8;
1474 saa->win.depth = v.depth;
1475 saa->win.bpl = v.bytesperline;
1476
1477 DEBUG(printk("Display at %p is %d by %d, bytedepth %d, "
1478 "bpl %d\n", v.base, v.width, v.height,
1479 saa->win.bpp, saa->win.bpl));
1480 saa7146_set_winsize(saa);
1481 return 0;
1482 }
1483 case VIDIOCKEY:
1484 {
1485 /* Will be handled higher up .. */
1486 return 0;
1487 }
1488
1489 case VIDIOCGAUDIO:
1490 {
1491 struct video_audio v;
1492 v = saa->audio_dev;
1493 v.flags &= ~(VIDEO_AUDIO_MUTE | VIDEO_AUDIO_MUTABLE);
1494 v.flags |= VIDEO_AUDIO_MUTABLE | VIDEO_AUDIO_VOLUME;
1495 strcpy(v.name, "MPEG");
1496 v.mode = VIDEO_SOUND_STEREO;
1497 if (copy_to_user(arg, &v, sizeof(v)))
1498 return -EFAULT;
1499 return 0;
1500 }
1501 case VIDIOCSAUDIO:
1502 {
1503 struct video_audio v;
1504 int i;
1505 if (copy_from_user(&v, arg, sizeof(v)))
1506 return -EFAULT;
1507 i = (~(v.volume >> 8)) & 0xff;
1508 if (!HaveCS4341) {
1509 if (v.flags & VIDEO_AUDIO_MUTE)
1510 debiwrite(saa, debNormal,
1511 IBM_MP2_FRNT_ATTEN, 0xffff, 2);
1512 if (!(v.flags & VIDEO_AUDIO_MUTE))
1513 debiwrite(saa, debNormal,
1514 IBM_MP2_FRNT_ATTEN, 0x0000, 2);
1515 if (v.flags & VIDEO_AUDIO_VOLUME)
1516 debiwrite(saa, debNormal,
1517 IBM_MP2_FRNT_ATTEN,
1518 (i << 8) | i, 2);
1519 } else {
1520 if (v.flags & VIDEO_AUDIO_MUTE)
1521 cs4341_setlevel(saa, 0xff, 0xff);
1522 if (!(v.flags & VIDEO_AUDIO_MUTE))
1523 cs4341_setlevel(saa, 0, 0);
1524 if (v.flags & VIDEO_AUDIO_VOLUME)
1525 cs4341_setlevel(saa, i, i);
1526 }
1527 saa->audio_dev = v;
1528 return 0;
1529 }
1530
1531 case VIDIOCGUNIT:
1532 {
1533 struct video_unit vu;
1534 vu.video = saa->video_dev.minor;
1535 vu.vbi = VIDEO_NO_UNIT;
1536 vu.radio = VIDEO_NO_UNIT;
1537 vu.audio = VIDEO_NO_UNIT;
1538 vu.teletext = VIDEO_NO_UNIT;
1539 if (copy_to_user(arg, &vu, sizeof(vu)))
1540 return -EFAULT;
1541 return 0;
1542 }
1543 case VIDIOCSPLAYMODE:
1544 {
1545 struct video_play_mode pmode;
1546 if (copy_from_user((void *)&pmode, arg,
1547 sizeof(struct video_play_mode)))
1548 return -EFAULT;
1549 switch (pmode.mode) {
1550 case VID_PLAY_VID_OUT_MODE:
1551 if (pmode.p1 != VIDEO_MODE_NTSC &&
1552 pmode.p1 != VIDEO_MODE_PAL)
1553 return -EINVAL;
1554 set_out_format(saa, pmode.p1);
1555 return 0;
1556 case VID_PLAY_GENLOCK:
1557 debiwrite(saa, debNormal, XILINX_CTL0,
1558 pmode.p1 ? 0x8000 : 0x8080, 2);
1559 if (NewCard)
1560 set_genlock_offset(saa, pmode.p2);
1561 return 0;
1562 case VID_PLAY_NORMAL:
1563 debiwrite(saa, debNormal,
1564 IBM_MP2_CHIP_CONTROL, ChipControl, 2);
1565 ibm_send_command(saa, IBM_MP2_PLAY, 0, 0);
1566 saa->playmode = pmode.mode;
1567 return 0;
1568 case VID_PLAY_PAUSE:
1569 /* IBM removed the PAUSE command */
1570 /* they say use SINGLE_FRAME now */
1571 case VID_PLAY_SINGLE_FRAME:
1572 ibm_send_command(saa, IBM_MP2_SINGLE_FRAME,0,0);
1573 if (saa->playmode == pmode.mode) {
1574 debiwrite(saa, debNormal,
1575 IBM_MP2_CHIP_CONTROL,
1576 ChipControl, 2);
1577 }
1578 saa->playmode = pmode.mode;
1579 return 0;
1580 case VID_PLAY_FAST_FORWARD:
1581 ibm_send_command(saa, IBM_MP2_FAST_FORWARD,0,0);
1582 saa->playmode = pmode.mode;
1583 return 0;
1584 case VID_PLAY_SLOW_MOTION:
1585 ibm_send_command(saa, IBM_MP2_SLOW_MOTION,
1586 pmode.p1, 0);
1587 saa->playmode = pmode.mode;
1588 return 0;
1589 case VID_PLAY_IMMEDIATE_NORMAL:
1590 /* ensure transfers resume */
1591 debiwrite(saa, debNormal,
1592 IBM_MP2_CHIP_CONTROL, ChipControl, 2);
1593 ibm_send_command(saa, IBM_MP2_IMED_NORM_PLAY,
1594 0, 0);
1595 saa->playmode = VID_PLAY_NORMAL;
1596 return 0;
1597 case VID_PLAY_SWITCH_CHANNELS:
1598 saa->audhead = saa->audtail = 0;
1599 saa->vidhead = saa->vidtail = 0;
1600 ibm_send_command(saa, IBM_MP2_FREEZE_FRAME,0,1);
1601 ibm_send_command(saa, IBM_MP2_RESET_AUD_RATE,
1602 0, 1);
1603 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL,
1604 0, 2);
1605 ibm_send_command(saa, IBM_MP2_CHANNEL_SWITCH,
1606 0, 1);
1607 debiwrite(saa, debNormal, IBM_MP2_CHIP_CONTROL,
1608 ChipControl, 2);
1609 ibm_send_command(saa, IBM_MP2_PLAY, 0, 0);
1610 saa->playmode = VID_PLAY_NORMAL;
1611 return 0;
1612 case VID_PLAY_FREEZE_FRAME:
1613 ibm_send_command(saa, IBM_MP2_FREEZE_FRAME,0,0);
1614 saa->playmode = pmode.mode;
1615 return 0;
1616 case VID_PLAY_STILL_MODE:
1617 ibm_send_command(saa, IBM_MP2_SET_STILL_MODE,
1618 0, 0);
1619 saa->playmode = pmode.mode;
1620 return 0;
1621 case VID_PLAY_MASTER_MODE:
1622 if (pmode.p1 == VID_PLAY_MASTER_NONE)
1623 saa->boardcfg[1] = 0x13;
1624 else if (pmode.p1 == VID_PLAY_MASTER_VIDEO)
1625 saa->boardcfg[1] = 0x23;
1626 else if (pmode.p1 == VID_PLAY_MASTER_AUDIO)
1627 saa->boardcfg[1] = 0x43;
1628 else
1629 return -EINVAL;
1630 debiwrite(saa, debNormal,
1631 IBM_MP2_CHIP_CONTROL, ChipControl, 2);
1632 return 0;
1633 case VID_PLAY_ACTIVE_SCANLINES:
1634 if (CurrentMode == VIDEO_MODE_PAL) {
1635 if (pmode.p1 < 1 || pmode.p2 > 625)
1636 return -EINVAL;
1637 saa->boardcfg[5] = pmode.p1;
1638 saa->boardcfg[55] = (pmode.p1 +
1639 (pmode.p2 / 2) - 1) & 0xff;
1640 } else {
1641 if (pmode.p1 < 4 || pmode.p2 > 525)
1642 return -EINVAL;
1643 saa->boardcfg[4] = pmode.p1;
1644 saa->boardcfg[54] = (pmode.p1 +
1645 (pmode.p2 / 2) - 4) & 0xff;
1646 }
1647 set_out_format(saa, CurrentMode);
1648 case VID_PLAY_RESET:
1649 return do_ibm_reset(saa);
1650 case VID_PLAY_END_MARK:
1651 if (saa->endmarktail < saa->endmarkhead) {
1652 if (saa->endmarkhead -
1653 saa->endmarktail < 2)
1654 return -ENOSPC;
1655 } else if (saa->endmarkhead <=saa->endmarktail){
1656 if (saa->endmarktail - saa->endmarkhead
1657 > (MAX_MARKS - 2))
1658 return -ENOSPC;
1659 } else
1660 return -ENOSPC;
1661 saa->endmark[saa->endmarktail] = saa->audtail;
1662 saa->endmarktail++;
1663 if (saa->endmarktail >= MAX_MARKS)
1664 saa->endmarktail = 0;
1665 }
1666 return -EINVAL;
1667 }
1668 case VIDIOCSWRITEMODE:
1669 {
1670 int mode;
1671 if (copy_from_user((void *)&mode, arg, sizeof(int)))
1672 return -EFAULT;
1673 if (mode == VID_WRITE_MPEG_AUD ||
1674 mode == VID_WRITE_MPEG_VID ||
1675 mode == VID_WRITE_CC ||
1676 mode == VID_WRITE_TTX ||
1677 mode == VID_WRITE_OSD) {
1678 saa->writemode = mode;
1679 return 0;
1680 }
1681 return -EINVAL;
1682 }
1683 case VIDIOCSMICROCODE:
1684 {
1685 struct video_code ucode;
1686 __u8 *udata;
1687 int i;
1688 if (copy_from_user(&ucode, arg, sizeof(ucode)))
1689 return -EFAULT;
1690 if (ucode.datasize > 65536 || ucode.datasize < 1024 ||
1691 strncmp(ucode.loadwhat, "dec", 3))
1692 return -EINVAL;
1693 if ((udata = vmalloc(ucode.datasize)) == NULL)
1694 return -ENOMEM;
1695 if (copy_from_user(udata, ucode.data, ucode.datasize)) {
1696 vfree(udata);
1697 return -EFAULT;
1698 }
1699 ucode.data = udata;
1700 if (!strncmp(ucode.loadwhat, "decoder.aud", 11) ||
1701 !strncmp(ucode.loadwhat, "decoder.vid", 11))
1702 i = initialize_ibmmpeg2(&ucode);
1703 else
1704 i = initialize_fpga(&ucode);
1705 vfree(udata);
1706 if (i)
1707 return -EINVAL;
1708 return 0;
1709
1710 }
1711 case VIDIOCGCHAN: /* this makes xawtv happy */
1712 {
1713 struct video_channel v;
1714 if (copy_from_user(&v, arg, sizeof(v)))
1715 return -EFAULT;
1716 v.flags = VIDEO_VC_AUDIO;
1717 v.tuners = 0;
1718 v.type = VID_TYPE_MPEG_DECODER;
1719 v.norm = CurrentMode;
1720 strcpy(v.name, "MPEG2");
1721 if (copy_to_user(arg, &v, sizeof(v)))
1722 return -EFAULT;
1723 return 0;
1724 }
1725 case VIDIOCSCHAN: /* this makes xawtv happy */
1726 {
1727 struct video_channel v;
1728 if (copy_from_user(&v, arg, sizeof(v)))
1729 return -EFAULT;
1730 /* do nothing */
1731 return 0;
1732 }
1733 default:
1734 return -ENOIOCTLCMD;
1735 }
1736 return 0;
1737 }
1738
1739 static int saa_mmap(struct file *file, struct vm_area_struct *vma)
1740 {
1741 struct saa7146 *saa = file->private_data;
1742 printk(KERN_DEBUG "stradis%d: saa_mmap called\n", saa->nr);
1743 return -EINVAL;
1744 }
1745
1746 static ssize_t saa_read(struct file *file, char __user * buf,
1747 size_t count, loff_t * ppos)
1748 {
1749 return -EINVAL;
1750 }
1751
1752 static ssize_t saa_write(struct file *file, const char __user * buf,
1753 size_t count, loff_t * ppos)
1754 {
1755 struct saa7146 *saa = file->private_data;
1756 unsigned long todo = count;
1757 int blocksize, split;
1758 unsigned long flags;
1759
1760 while (todo > 0) {
1761 if (saa->writemode == VID_WRITE_MPEG_AUD) {
1762 spin_lock_irqsave(&saa->lock, flags);
1763 if (saa->audhead <= saa->audtail)
1764 blocksize = 65536 -
1765 (saa->audtail - saa->audhead);
1766 else
1767 blocksize = saa->audhead - saa->audtail;
1768 spin_unlock_irqrestore(&saa->lock, flags);
1769 if (blocksize < 16384) {
1770 saawrite(SAA7146_PSR_DEBI_S |
1771 SAA7146_PSR_PIN1, SAA7146_IER);
1772 saawrite(SAA7146_PSR_PIN1, SAA7146_PSR);
1773 /* wait for buffer space to open */
1774 interruptible_sleep_on(&saa->audq);
1775 }
1776 spin_lock_irqsave(&saa->lock, flags);
1777 if (saa->audhead <= saa->audtail) {
1778 blocksize = 65536 -
1779 (saa->audtail - saa->audhead);
1780 split = 65536 - saa->audtail;
1781 } else {
1782 blocksize = saa->audhead - saa->audtail;
1783 split = 65536;
1784 }
1785 spin_unlock_irqrestore(&saa->lock, flags);
1786 blocksize--;
1787 if (blocksize > todo)
1788 blocksize = todo;
1789 /* double check that we really have space */
1790 if (!blocksize)
1791 return -ENOSPC;
1792 if (split < blocksize) {
1793 if (copy_from_user(saa->audbuf +
1794 saa->audtail, buf, split))
1795 return -EFAULT;
1796 buf += split;
1797 todo -= split;
1798 blocksize -= split;
1799 saa->audtail = 0;
1800 }
1801 if (copy_from_user(saa->audbuf + saa->audtail, buf,
1802 blocksize))
1803 return -EFAULT;
1804 saa->audtail += blocksize;
1805 todo -= blocksize;
1806 buf += blocksize;
1807 saa->audtail &= 0xffff;
1808 } else if (saa->writemode == VID_WRITE_MPEG_VID) {
1809 spin_lock_irqsave(&saa->lock, flags);
1810 if (saa->vidhead <= saa->vidtail)
1811 blocksize = 524288 -
1812 (saa->vidtail - saa->vidhead);
1813 else
1814 blocksize = saa->vidhead - saa->vidtail;
1815 spin_unlock_irqrestore(&saa->lock, flags);
1816 if (blocksize < 65536) {
1817 saawrite(SAA7146_PSR_DEBI_S |
1818 SAA7146_PSR_PIN1, SAA7146_IER);
1819 saawrite(SAA7146_PSR_PIN1, SAA7146_PSR);
1820 /* wait for buffer space to open */
1821 interruptible_sleep_on(&saa->vidq);
1822 }
1823 spin_lock_irqsave(&saa->lock, flags);
1824 if (saa->vidhead <= saa->vidtail) {
1825 blocksize = 524288 -
1826 (saa->vidtail - saa->vidhead);
1827 split = 524288 - saa->vidtail;
1828 } else {
1829 blocksize = saa->vidhead - saa->vidtail;
1830 split = 524288;
1831 }
1832 spin_unlock_irqrestore(&saa->lock, flags);
1833 blocksize--;
1834 if (blocksize > todo)
1835 blocksize = todo;
1836 /* double check that we really have space */
1837 if (!blocksize)
1838 return -ENOSPC;
1839 if (split < blocksize) {
1840 if (copy_from_user(saa->vidbuf +
1841 saa->vidtail, buf, split))
1842 return -EFAULT;
1843 buf += split;
1844 todo -= split;
1845 blocksize -= split;
1846 saa->vidtail = 0;
1847 }
1848 if (copy_from_user(saa->vidbuf + saa->vidtail, buf,
1849 blocksize))
1850 return -EFAULT;
1851 saa->vidtail += blocksize;
1852 todo -= blocksize;
1853 buf += blocksize;
1854 saa->vidtail &= 0x7ffff;
1855 } else if (saa->writemode == VID_WRITE_OSD) {
1856 if (count > 131072)
1857 return -ENOSPC;
1858 if (copy_from_user(saa->osdbuf, buf, count))
1859 return -EFAULT;
1860 buf += count;
1861 saa->osdhead = 0;
1862 saa->osdtail = count;
1863 debiwrite(saa, debNormal, IBM_MP2_OSD_ADDR, 0, 2);
1864 debiwrite(saa, debNormal, IBM_MP2_OSD_LINK_ADDR, 0, 2);
1865 debiwrite(saa, debNormal, IBM_MP2_MASK0, 0xc00d, 2);
1866 debiwrite(saa, debNormal, IBM_MP2_DISP_MODE,
1867 debiread(saa, debNormal,
1868 IBM_MP2_DISP_MODE, 2) | 1, 2);
1869 /* trigger osd data transfer */
1870 saawrite(SAA7146_PSR_DEBI_S |
1871 SAA7146_PSR_PIN1, SAA7146_IER);
1872 saawrite(SAA7146_PSR_PIN1, SAA7146_PSR);
1873 }
1874 }
1875 return count;
1876 }
1877
1878 static int saa_open(struct inode *inode, struct file *file)
1879 {
1880 struct video_device *vdev = video_devdata(file);
1881 struct saa7146 *saa = container_of(vdev, struct saa7146, video_dev);
1882
1883 file->private_data = saa;
1884
1885 saa->user++;
1886 if (saa->user > 1)
1887 return 0; /* device open already, don't reset */
1888 saa->writemode = VID_WRITE_MPEG_VID; /* default to video */
1889 return 0;
1890 }
1891
1892 static int saa_release(struct inode *inode, struct file *file)
1893 {
1894 struct saa7146 *saa = file->private_data;
1895 saa->user--;
1896
1897 if (saa->user > 0) /* still someone using device */
1898 return 0;
1899 saawrite(0x007f0000, SAA7146_MC1); /* stop all overlay dma */
1900 return 0;
1901 }
1902
1903 static struct file_operations saa_fops = {
1904 .owner = THIS_MODULE,
1905 .open = saa_open,
1906 .release = saa_release,
1907 .ioctl = saa_ioctl,
1908 .compat_ioctl = v4l_compat_ioctl32,
1909 .read = saa_read,
1910 .llseek = no_llseek,
1911 .write = saa_write,
1912 .mmap = saa_mmap,
1913 };
1914
1915 /* template for video_device-structure */
1916 static struct video_device saa_template = {
1917 .name = "SAA7146A",
1918 .type = VID_TYPE_CAPTURE | VID_TYPE_OVERLAY,
1919 .hardware = VID_HARDWARE_SAA7146,
1920 .fops = &saa_fops,
1921 .minor = -1,
1922 };
1923
1924 static int __devinit configure_saa7146(struct pci_dev *pdev, int num)
1925 {
1926 int retval;
1927 struct saa7146 *saa = pci_get_drvdata(pdev);
1928
1929 saa->endmarkhead = saa->endmarktail = 0;
1930 saa->win.x = saa->win.y = 0;
1931 saa->win.width = saa->win.cropwidth = 720;
1932 saa->win.height = saa->win.cropheight = 480;
1933 saa->win.cropx = saa->win.cropy = 0;
1934 saa->win.bpp = 2;
1935 saa->win.depth = 16;
1936 saa->win.color_fmt = palette2fmt[VIDEO_PALETTE_RGB565];
1937 saa->win.bpl = 1024 * saa->win.bpp;
1938 saa->win.swidth = 1024;
1939 saa->win.sheight = 768;
1940 saa->picture.brightness = 32768;
1941 saa->picture.contrast = 38768;
1942 saa->picture.colour = 32768;
1943 saa->cap = 0;
1944 saa->nr = num;
1945 saa->playmode = VID_PLAY_NORMAL;
1946 memset(saa->boardcfg, 0, 64); /* clear board config area */
1947 saa->saa7146_mem = NULL;
1948 saa->dmavid1 = saa->dmavid2 = saa->dmavid3 = saa->dmaa1in =
1949 saa->dmaa1out = saa->dmaa2in = saa->dmaa2out =
1950 saa->pagevid1 = saa->pagevid2 = saa->pagevid3 = saa->pagea1in =
1951 saa->pagea1out = saa->pagea2in = saa->pagea2out =
1952 saa->pagedebi = saa->dmaRPS1 = saa->dmaRPS2 = saa->pageRPS1 =
1953 saa->pageRPS2 = NULL;
1954 saa->audbuf = saa->vidbuf = saa->osdbuf = saa->dmadebi = NULL;
1955 saa->audhead = saa->vidtail = 0;
1956
1957 init_waitqueue_head(&saa->i2cq);
1958 init_waitqueue_head(&saa->audq);
1959 init_waitqueue_head(&saa->debiq);
1960 init_waitqueue_head(&saa->vidq);
1961 spin_lock_init(&saa->lock);
1962
1963 retval = pci_enable_device(pdev);
1964 if (retval) {
1965 dev_err(&pdev->dev, "%d: pci_enable_device failed!\n", num);
1966 goto err;
1967 }
1968
1969 saa->id = pdev->device;
1970 saa->irq = pdev->irq;
1971 saa->video_dev.minor = -1;
1972 saa->saa7146_adr = pci_resource_start(pdev, 0);
1973 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &saa->revision);
1974
1975 saa->saa7146_mem = ioremap(saa->saa7146_adr, 0x200);
1976 if (saa->saa7146_mem == NULL) {
1977 dev_err(&pdev->dev, "%d: ioremap failed!\n", num);
1978 retval = -EIO;
1979 goto err;
1980 }
1981
1982 memcpy(&saa->video_dev, &saa_template, sizeof(saa_template));
1983 saawrite(0, SAA7146_IER); /* turn off all interrupts */
1984
1985 retval = request_irq(saa->irq, saa7146_irq, SA_SHIRQ | SA_INTERRUPT,
1986 "stradis", saa);
1987 if (retval == -EINVAL)
1988 dev_err(&pdev->dev, "%d: Bad irq number or handler\n", num);
1989 else if (retval == -EBUSY)
1990 dev_err(&pdev->dev, "%d: IRQ %ld busy, change your PnP config "
1991 "in BIOS\n", num, saa->irq);
1992 if (retval < 0)
1993 goto errio;
1994
1995 pci_set_master(pdev);
1996 retval = video_register_device(&saa->video_dev, VFL_TYPE_GRABBER,
1997 video_nr);
1998 if (retval < 0) {
1999 dev_err(&pdev->dev, "%d: error in registering video device!\n",
2000 num);
2001 goto errio;
2002 }
2003
2004 return 0;
2005 errio:
2006 iounmap(saa->saa7146_mem);
2007 err:
2008 return retval;
2009 }
2010
2011 static int __devinit init_saa7146(struct pci_dev *pdev)
2012 {
2013 struct saa7146 *saa = pci_get_drvdata(pdev);
2014
2015 saa->user = 0;
2016 /* reset the saa7146 */
2017 saawrite(0xffff0000, SAA7146_MC1);
2018 mdelay(5);
2019 /* enable debi and i2c transfers and pins */
2020 saawrite(((SAA7146_MC1_EDP | SAA7146_MC1_EI2C |
2021 SAA7146_MC1_TR_E_DEBI) << 16) | 0xffff, SAA7146_MC1);
2022 /* ensure proper state of chip */
2023 saawrite(0x00000000, SAA7146_PAGE1);
2024 saawrite(0x00f302c0, SAA7146_NUM_LINE_BYTE1);
2025 saawrite(0x00000000, SAA7146_PAGE2);
2026 saawrite(0x01400080, SAA7146_NUM_LINE_BYTE2);
2027 saawrite(0x00000000, SAA7146_DD1_INIT);
2028 saawrite(0x00000000, SAA7146_DD1_STREAM_B);
2029 saawrite(0x00000000, SAA7146_DD1_STREAM_A);
2030 saawrite(0x00000000, SAA7146_BRS_CTRL);
2031 saawrite(0x80400040, SAA7146_BCS_CTRL);
2032 saawrite(0x0000e000 /*| (1<<29) */ , SAA7146_HPS_CTRL);
2033 saawrite(0x00000060, SAA7146_CLIP_FORMAT_CTRL);
2034 saawrite(0x00000000, SAA7146_ACON1);
2035 saawrite(0x00000000, SAA7146_ACON2);
2036 saawrite(0x00000600, SAA7146_I2C_STATUS);
2037 saawrite(((SAA7146_MC2_UPLD_D1_B | SAA7146_MC2_UPLD_D1_A |
2038 SAA7146_MC2_UPLD_BRS | SAA7146_MC2_UPLD_HPS_H |
2039 SAA7146_MC2_UPLD_HPS_V | SAA7146_MC2_UPLD_DMA2 |
2040 SAA7146_MC2_UPLD_DMA1 | SAA7146_MC2_UPLD_I2C) << 16) | 0xffff,
2041 SAA7146_MC2);
2042 /* setup arbitration control registers */
2043 saawrite(0x1412121a, SAA7146_PCI_BT_V1);
2044
2045 /* allocate 32k dma buffer + 4k for page table */
2046 if ((saa->dmadebi = kmalloc(32768 + 4096, GFP_KERNEL)) == NULL) {
2047 dev_err(&pdev->dev, "%d: debi kmalloc failed\n", saa->nr);
2048 goto err;
2049 }
2050 #if 0
2051 saa->pagedebi = saa->dmadebi + 32768; /* top 4k is for mmu */
2052 saawrite(virt_to_bus(saa->pagedebi) /*|0x800 */ , SAA7146_DEBI_PAGE);
2053 for (i = 0; i < 12; i++) /* setup mmu page table */
2054 saa->pagedebi[i] = virt_to_bus((saa->dmadebi + i * 4096));
2055 #endif
2056 saa->audhead = saa->vidhead = saa->osdhead = 0;
2057 saa->audtail = saa->vidtail = saa->osdtail = 0;
2058 if (saa->vidbuf == NULL && (saa->vidbuf = vmalloc(524288)) == NULL) {
2059 dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr);
2060 goto err;
2061 }
2062 if (saa->audbuf == NULL && (saa->audbuf = vmalloc(65536)) == NULL) {
2063 dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr);
2064 goto errfree;
2065 }
2066 if (saa->osdbuf == NULL && (saa->osdbuf = vmalloc(131072)) == NULL) {
2067 dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr);
2068 goto errfree;
2069 }
2070 /* allocate 81920 byte buffer for clipping */
2071 if ((saa->dmavid2 = kzalloc(VIDEO_CLIPMAP_SIZE, GFP_KERNEL)) == NULL) {
2072 dev_err(&pdev->dev, "%d: clip kmalloc failed\n", saa->nr);
2073 goto errfree;
2074 }
2075 /* setup clipping registers */
2076 saawrite(virt_to_bus(saa->dmavid2), SAA7146_BASE_EVEN2);
2077 saawrite(virt_to_bus(saa->dmavid2) + 128, SAA7146_BASE_ODD2);
2078 saawrite(virt_to_bus(saa->dmavid2) + VIDEO_CLIPMAP_SIZE,
2079 SAA7146_PROT_ADDR2);
2080 saawrite(256, SAA7146_PITCH2);
2081 saawrite(4, SAA7146_PAGE2); /* dma direction: read, no byteswap */
2082 saawrite(((SAA7146_MC2_UPLD_DMA2) << 16) | SAA7146_MC2_UPLD_DMA2,
2083 SAA7146_MC2);
2084 I2CBusScan(saa);
2085
2086 return 0;
2087 errfree:
2088 vfree(saa->osdbuf);
2089 vfree(saa->audbuf);
2090 vfree(saa->vidbuf);
2091 saa->audbuf = saa->osdbuf = saa->vidbuf = NULL;
2092 err:
2093 return -ENOMEM;
2094 }
2095
2096 static void stradis_release_saa(struct pci_dev *pdev)
2097 {
2098 u8 command;
2099 struct saa7146 *saa = pci_get_drvdata(pdev);
2100
2101 /* turn off all capturing, DMA and IRQs */
2102 saawrite(0xffff0000, SAA7146_MC1); /* reset chip */
2103 saawrite(0, SAA7146_MC2);
2104 saawrite(0, SAA7146_IER);
2105 saawrite(0xffffffffUL, SAA7146_ISR);
2106
2107 /* disable PCI bus-mastering */
2108 pci_read_config_byte(pdev, PCI_COMMAND, &command);
2109 command &= ~PCI_COMMAND_MASTER;
2110 pci_write_config_byte(pdev, PCI_COMMAND, command);
2111
2112 /* unmap and free memory */
2113 saa->audhead = saa->audtail = saa->osdhead = 0;
2114 saa->vidhead = saa->vidtail = saa->osdtail = 0;
2115 vfree(saa->vidbuf);
2116 vfree(saa->audbuf);
2117 vfree(saa->osdbuf);
2118 kfree(saa->dmavid2);
2119 saa->audbuf = saa->vidbuf = saa->osdbuf = NULL;
2120 saa->dmavid2 = NULL;
2121 kfree(saa->dmadebi);
2122 kfree(saa->dmavid1);
2123 kfree(saa->dmavid3);
2124 kfree(saa->dmaa1in);
2125 kfree(saa->dmaa1out);
2126 kfree(saa->dmaa2in);
2127 kfree(saa->dmaa2out);
2128 kfree(saa->dmaRPS1);
2129 kfree(saa->dmaRPS2);
2130 free_irq(saa->irq, saa);
2131 if (saa->saa7146_mem)
2132 iounmap(saa->saa7146_mem);
2133 if (saa->video_dev.minor != -1)
2134 video_unregister_device(&saa->video_dev);
2135 }
2136
2137 static int __devinit stradis_probe(struct pci_dev *pdev,
2138 const struct pci_device_id *ent)
2139 {
2140 int retval = -EINVAL;
2141
2142 if (saa_num >= SAA7146_MAX)
2143 goto err;
2144
2145 if (!pdev->subsystem_vendor)
2146 dev_info(&pdev->dev, "%d: rev1 decoder\n", saa_num);
2147 else
2148 dev_info(&pdev->dev, "%d: SDM2xx found\n", saa_num);
2149
2150 pci_set_drvdata(pdev, &saa7146s[saa_num]);
2151
2152 retval = configure_saa7146(pdev, saa_num);
2153 if (retval) {
2154 dev_err(&pdev->dev, "%d: error in configuring\n", saa_num);
2155 goto err;
2156 }
2157
2158 if (init_saa7146(pdev) < 0) {
2159 dev_err(&pdev->dev, "%d: error in initialization\n", saa_num);
2160 retval = -EIO;
2161 goto errrel;
2162 }
2163
2164 saa_num++;
2165
2166 return 0;
2167 errrel:
2168 stradis_release_saa(pdev);
2169 err:
2170 return retval;
2171 }
2172
2173 static void __devexit stradis_remove(struct pci_dev *pdev)
2174 {
2175 stradis_release_saa(pdev);
2176 }
2177
2178 static struct pci_device_id stradis_pci_tbl[] = {
2179 { PCI_DEVICE(PCI_VENDOR_ID_PHILIPS, PCI_DEVICE_ID_PHILIPS_SAA7146) },
2180 { 0 }
2181 };
2182
2183 MODULE_DEVICE_TABLE(pci, stradis_pci_tbl);
2184
2185 static struct pci_driver stradis_driver = {
2186 .name = "stradis",
2187 .id_table = stradis_pci_tbl,
2188 .probe = stradis_probe,
2189 .remove = __devexit_p(stradis_remove)
2190 };
2191
2192 int __init stradis_init(void)
2193 {
2194 int retval;
2195
2196 saa_num = 0;
2197
2198 retval = pci_register_driver(&stradis_driver);
2199 if (retval)
2200 printk(KERN_ERR "stradis: Unable to register pci driver.\n");
2201
2202 return retval;
2203 }
2204
2205 void __exit stradis_exit(void)
2206 {
2207 pci_unregister_driver(&stradis_driver);
2208 printk(KERN_INFO "stradis: module cleanup complete\n");
2209 }
2210
2211 module_init(stradis_init);
2212 module_exit(stradis_exit);
(deprecated) Btrfs devel tree