Automatic merge of rsync://rsync.kernel.org/pub/scm/linux/kernel/git/davem/sparc...
[linux-2.6] / drivers / media / video / zr36050.c
1 /*
2  * Zoran ZR36050 basic configuration functions
3  *
4  * Copyright (C) 2001 Wolfgang Scherr <scherr@net4you.at>
5  *
6  * $Id: zr36050.c,v 1.1.2.11 2003/08/03 14:54:53 rbultje Exp $
7  *
8  * ------------------------------------------------------------------------
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  *
24  * ------------------------------------------------------------------------
25  */
26
27 #define ZR050_VERSION "v0.7.1"
28
29 #include <linux/version.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/slab.h>
33 #include <linux/delay.h>
34
35 #include <linux/types.h>
36 #include <linux/wait.h>
37
38 /* includes for structures and defines regarding video 
39    #include<linux/videodev.h> */
40
41 /* I/O commands, error codes */
42 #include<asm/io.h>
43 //#include<errno.h>
44
45 /* headerfile of this module */
46 #include"zr36050.h"
47
48 /* codec io API */
49 #include"videocodec.h"
50
51 /* it doesn't make sense to have more than 20 or so,
52   just to prevent some unwanted loops */
53 #define MAX_CODECS 20
54
55 /* amount of chips attached via this driver */
56 static int zr36050_codecs = 0;
57
58 /* debugging is available via module parameter */
59
60 static int debug = 0;
61 module_param(debug, int, 0);
62 MODULE_PARM_DESC(debug, "Debug level (0-4)");
63
64 #define dprintk(num, format, args...) \
65         do { \
66                 if (debug >= num) \
67                         printk(format, ##args); \
68         } while (0)
69
70 /* =========================================================================
71    Local hardware I/O functions:
72
73    read/write via codec layer (registers are located in the master device)
74    ========================================================================= */
75
76 /* read and write functions */
77 static u8
78 zr36050_read (struct zr36050 *ptr,
79               u16             reg)
80 {
81         u8 value = 0;
82
83         // just in case something is wrong...
84         if (ptr->codec->master_data->readreg)
85                 value = (ptr->codec->master_data->readreg(ptr->codec,
86                                                           reg)) & 0xFF;
87         else
88                 dprintk(1,
89                         KERN_ERR "%s: invalid I/O setup, nothing read!\n",
90                         ptr->name);
91
92         dprintk(4, "%s: reading from 0x%04x: %02x\n", ptr->name, reg,
93                 value);
94
95         return value;
96 }
97
98 static void
99 zr36050_write (struct zr36050 *ptr,
100                u16             reg,
101                u8              value)
102 {
103         dprintk(4, "%s: writing 0x%02x to 0x%04x\n", ptr->name, value,
104                 reg);
105
106         // just in case something is wrong...
107         if (ptr->codec->master_data->writereg)
108                 ptr->codec->master_data->writereg(ptr->codec, reg, value);
109         else
110                 dprintk(1,
111                         KERN_ERR
112                         "%s: invalid I/O setup, nothing written!\n",
113                         ptr->name);
114 }
115
116 /* =========================================================================
117    Local helper function:
118
119    status read
120    ========================================================================= */
121
122 /* status is kept in datastructure */
123 static u8
124 zr36050_read_status1 (struct zr36050 *ptr)
125 {
126         ptr->status1 = zr36050_read(ptr, ZR050_STATUS_1);
127
128         zr36050_read(ptr, 0);
129         return ptr->status1;
130 }
131
132 /* =========================================================================
133    Local helper function:
134
135    scale factor read
136    ========================================================================= */
137
138 /* scale factor is kept in datastructure */
139 static u16
140 zr36050_read_scalefactor (struct zr36050 *ptr)
141 {
142         ptr->scalefact = (zr36050_read(ptr, ZR050_SF_HI) << 8) |
143                          (zr36050_read(ptr, ZR050_SF_LO) & 0xFF);
144
145         /* leave 0 selected for an eventually GO from master */
146         zr36050_read(ptr, 0);
147         return ptr->scalefact;
148 }
149
150 /* =========================================================================
151    Local helper function:
152
153    wait if codec is ready to proceed (end of processing) or time is over
154    ========================================================================= */
155
156 static void
157 zr36050_wait_end (struct zr36050 *ptr)
158 {
159         int i = 0;
160
161         while (!(zr36050_read_status1(ptr) & 0x4)) {
162                 udelay(1);
163                 if (i++ > 200000) {     // 200ms, there is for shure something wrong!!!
164                         dprintk(1,
165                                 "%s: timout at wait_end (last status: 0x%02x)\n",
166                                 ptr->name, ptr->status1);
167                         break;
168                 }
169         }
170 }
171
172 /* =========================================================================
173    Local helper function:
174
175    basic test of "connectivity", writes/reads to/from memory the SOF marker 
176    ========================================================================= */
177
178 static int
179 zr36050_basic_test (struct zr36050 *ptr)
180 {
181         zr36050_write(ptr, ZR050_SOF_IDX, 0x00);
182         zr36050_write(ptr, ZR050_SOF_IDX + 1, 0x00);
183         if ((zr36050_read(ptr, ZR050_SOF_IDX) |
184              zr36050_read(ptr, ZR050_SOF_IDX + 1)) != 0x0000) {
185                 dprintk(1,
186                         KERN_ERR
187                         "%s: attach failed, can't connect to jpeg processor!\n",
188                         ptr->name);
189                 return -ENXIO;
190         }
191         zr36050_write(ptr, ZR050_SOF_IDX, 0xff);
192         zr36050_write(ptr, ZR050_SOF_IDX + 1, 0xc0);
193         if (((zr36050_read(ptr, ZR050_SOF_IDX) << 8) |
194              zr36050_read(ptr, ZR050_SOF_IDX + 1)) != 0xffc0) {
195                 dprintk(1,
196                         KERN_ERR
197                         "%s: attach failed, can't connect to jpeg processor!\n",
198                         ptr->name);
199                 return -ENXIO;
200         }
201
202         zr36050_wait_end(ptr);
203         if ((ptr->status1 & 0x4) == 0) {
204                 dprintk(1,
205                         KERN_ERR
206                         "%s: attach failed, jpeg processor failed (end flag)!\n",
207                         ptr->name);
208                 return -EBUSY;
209         }
210
211         return 0;               /* looks good! */
212 }
213
214 /* =========================================================================
215    Local helper function:
216
217    simple loop for pushing the init datasets
218    ========================================================================= */
219
220 static int
221 zr36050_pushit (struct zr36050 *ptr,
222                 u16             startreg,
223                 u16             len,
224                 const char     *data)
225 {
226         int i = 0;
227
228         dprintk(4, "%s: write data block to 0x%04x (len=%d)\n", ptr->name,
229                 startreg, len);
230         while (i < len) {
231                 zr36050_write(ptr, startreg++, data[i++]);
232         }
233
234         return i;
235 }
236
237 /* =========================================================================
238    Basic datasets:
239
240    jpeg baseline setup data (you find it on lots places in internet, or just
241    extract it from any regular .jpg image...)
242
243    Could be variable, but until it's not needed it they are just fixed to save
244    memory. Otherwise expand zr36050 structure with arrays, push the values to
245    it and initalize from there, as e.g. the linux zr36057/60 driver does it.
246    ========================================================================= */
247
248 static const char zr36050_dqt[0x86] = {
249         0xff, 0xdb,             //Marker: DQT
250         0x00, 0x84,             //Length: 2*65+2
251         0x00,                   //Pq,Tq first table
252         0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e,
253         0x0d, 0x0e, 0x12, 0x11, 0x10, 0x13, 0x18, 0x28,
254         0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25,
255         0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33,
256         0x38, 0x37, 0x40, 0x48, 0x5c, 0x4e, 0x40, 0x44,
257         0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51, 0x57,
258         0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71,
259         0x79, 0x70, 0x64, 0x78, 0x5c, 0x65, 0x67, 0x63,
260         0x01,                   //Pq,Tq second table
261         0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a,
262         0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63,
263         0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
264         0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
265         0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
266         0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
267         0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
268         0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63
269 };
270
271 static const char zr36050_dht[0x1a4] = {
272         0xff, 0xc4,             //Marker: DHT
273         0x01, 0xa2,             //Length: 2*AC, 2*DC
274         0x00,                   //DC first table
275         0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
276         0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
277         0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
278         0x01,                   //DC second table
279         0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
280         0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
281         0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
282         0x10,                   //AC first table
283         0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03,
284         0x05, 0x05, 0x04, 0x04, 0x00, 0x00,
285         0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11,
286         0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
287         0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
288         0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24,
289         0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17,
290         0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34,
291         0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
292         0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56,
293         0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66,
294         0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
295         0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
296         0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
297         0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
298         0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9,
299         0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
300         0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
301         0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
302         0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
303         0xF8, 0xF9, 0xFA,
304         0x11,                   //AC second table
305         0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,
306         0x07, 0x05, 0x04, 0x04, 0x00, 0x01,
307         0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04,
308         0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
309         0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
310         0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62,
311         0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25,
312         0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A,
313         0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
314         0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56,
315         0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66,
316         0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
317         0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
318         0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
319         0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
320         0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
321         0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
322         0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
323         0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
324         0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
325         0xF9, 0xFA
326 };
327
328 /* jpeg baseline setup, this is just fixed in this driver (YUV pictures) */
329 #define NO_OF_COMPONENTS          0x3   //Y,U,V
330 #define BASELINE_PRECISION        0x8   //MCU size (?)
331 static const char zr36050_tq[8] = { 0, 1, 1, 0, 0, 0, 0, 0 };   //table idx's QT
332 static const char zr36050_td[8] = { 0, 1, 1, 0, 0, 0, 0, 0 };   //table idx's DC
333 static const char zr36050_ta[8] = { 0, 1, 1, 0, 0, 0, 0, 0 };   //table idx's AC
334
335 /* horizontal 422 decimation setup (maybe we support 411 or so later, too) */
336 static const char zr36050_decimation_h[8] = { 2, 1, 1, 0, 0, 0, 0, 0 };
337 static const char zr36050_decimation_v[8] = { 1, 1, 1, 0, 0, 0, 0, 0 };
338
339 /* =========================================================================
340    Local helper functions:
341
342    calculation and setup of parameter-dependent JPEG baseline segments
343    (needed for compression only)
344    ========================================================================= */
345
346 /* ------------------------------------------------------------------------- */
347
348 /* SOF (start of frame) segment depends on width, height and sampling ratio
349                          of each color component */
350
351 static int
352 zr36050_set_sof (struct zr36050 *ptr)
353 {
354         char sof_data[34];      // max. size of register set
355         int i;
356
357         dprintk(3, "%s: write SOF (%dx%d, %d components)\n", ptr->name,
358                 ptr->width, ptr->height, NO_OF_COMPONENTS);
359         sof_data[0] = 0xff;
360         sof_data[1] = 0xc0;
361         sof_data[2] = 0x00;
362         sof_data[3] = (3 * NO_OF_COMPONENTS) + 8;
363         sof_data[4] = BASELINE_PRECISION;       // only '8' possible with zr36050
364         sof_data[5] = (ptr->height) >> 8;
365         sof_data[6] = (ptr->height) & 0xff;
366         sof_data[7] = (ptr->width) >> 8;
367         sof_data[8] = (ptr->width) & 0xff;
368         sof_data[9] = NO_OF_COMPONENTS;
369         for (i = 0; i < NO_OF_COMPONENTS; i++) {
370                 sof_data[10 + (i * 3)] = i;     // index identifier
371                 sof_data[11 + (i * 3)] = (ptr->h_samp_ratio[i] << 4) | (ptr->v_samp_ratio[i]);  // sampling ratios
372                 sof_data[12 + (i * 3)] = zr36050_tq[i]; // Q table selection
373         }
374         return zr36050_pushit(ptr, ZR050_SOF_IDX,
375                               (3 * NO_OF_COMPONENTS) + 10, sof_data);
376 }
377
378 /* ------------------------------------------------------------------------- */
379
380 /* SOS (start of scan) segment depends on the used scan components 
381                         of each color component */
382
383 static int
384 zr36050_set_sos (struct zr36050 *ptr)
385 {
386         char sos_data[16];      // max. size of register set
387         int i;
388
389         dprintk(3, "%s: write SOS\n", ptr->name);
390         sos_data[0] = 0xff;
391         sos_data[1] = 0xda;
392         sos_data[2] = 0x00;
393         sos_data[3] = 2 + 1 + (2 * NO_OF_COMPONENTS) + 3;
394         sos_data[4] = NO_OF_COMPONENTS;
395         for (i = 0; i < NO_OF_COMPONENTS; i++) {
396                 sos_data[5 + (i * 2)] = i;      // index
397                 sos_data[6 + (i * 2)] = (zr36050_td[i] << 4) | zr36050_ta[i];   // AC/DC tbl.sel.
398         }
399         sos_data[2 + 1 + (2 * NO_OF_COMPONENTS) + 2] = 00;      // scan start
400         sos_data[2 + 1 + (2 * NO_OF_COMPONENTS) + 3] = 0x3F;
401         sos_data[2 + 1 + (2 * NO_OF_COMPONENTS) + 4] = 00;
402         return zr36050_pushit(ptr, ZR050_SOS1_IDX,
403                               4 + 1 + (2 * NO_OF_COMPONENTS) + 3,
404                               sos_data);
405 }
406
407 /* ------------------------------------------------------------------------- */
408
409 /* DRI (define restart interval) */
410
411 static int
412 zr36050_set_dri (struct zr36050 *ptr)
413 {
414         char dri_data[6];       // max. size of register set
415
416         dprintk(3, "%s: write DRI\n", ptr->name);
417         dri_data[0] = 0xff;
418         dri_data[1] = 0xdd;
419         dri_data[2] = 0x00;
420         dri_data[3] = 0x04;
421         dri_data[4] = ptr->dri >> 8;
422         dri_data[5] = ptr->dri & 0xff;
423         return zr36050_pushit(ptr, ZR050_DRI_IDX, 6, dri_data);
424 }
425
426 /* =========================================================================
427    Setup function:
428
429    Setup compression/decompression of Zoran's JPEG processor
430    ( see also zoran 36050 manual )
431
432    ... sorry for the spaghetti code ...
433    ========================================================================= */
434 static void
435 zr36050_init (struct zr36050 *ptr)
436 {
437         int sum = 0;
438         long bitcnt, tmp;
439
440         if (ptr->mode == CODEC_DO_COMPRESSION) {
441                 dprintk(2, "%s: COMPRESSION SETUP\n", ptr->name);
442
443                 /* 050 communicates with 057 in master mode */
444                 zr36050_write(ptr, ZR050_HARDWARE, ZR050_HW_MSTR);
445
446                 /* encoding table preload for compression */
447                 zr36050_write(ptr, ZR050_MODE,
448                               ZR050_MO_COMP | ZR050_MO_TLM);
449                 zr36050_write(ptr, ZR050_OPTIONS, 0);
450
451                 /* disable all IRQs */
452                 zr36050_write(ptr, ZR050_INT_REQ_0, 0);
453                 zr36050_write(ptr, ZR050_INT_REQ_1, 3); // low 2 bits always 1
454
455                 /* volume control settings */
456                 /*zr36050_write(ptr, ZR050_MBCV, ptr->max_block_vol);*/
457                 zr36050_write(ptr, ZR050_SF_HI, ptr->scalefact >> 8);
458                 zr36050_write(ptr, ZR050_SF_LO, ptr->scalefact & 0xff);
459
460                 zr36050_write(ptr, ZR050_AF_HI, 0xff);
461                 zr36050_write(ptr, ZR050_AF_M, 0xff);
462                 zr36050_write(ptr, ZR050_AF_LO, 0xff);
463
464                 /* setup the variable jpeg tables */
465                 sum += zr36050_set_sof(ptr);
466                 sum += zr36050_set_sos(ptr);
467                 sum += zr36050_set_dri(ptr);
468
469                 /* setup the fixed jpeg tables - maybe variable, though -
470                  * (see table init section above) */
471                 dprintk(3, "%s: write DQT, DHT, APP\n", ptr->name);
472                 sum += zr36050_pushit(ptr, ZR050_DQT_IDX,
473                                       sizeof(zr36050_dqt), zr36050_dqt);
474                 sum += zr36050_pushit(ptr, ZR050_DHT_IDX,
475                                       sizeof(zr36050_dht), zr36050_dht);
476                 zr36050_write(ptr, ZR050_APP_IDX, 0xff);
477                 zr36050_write(ptr, ZR050_APP_IDX + 1, 0xe0 + ptr->app.appn);
478                 zr36050_write(ptr, ZR050_APP_IDX + 2, 0x00);
479                 zr36050_write(ptr, ZR050_APP_IDX + 3, ptr->app.len + 2);
480                 sum += zr36050_pushit(ptr, ZR050_APP_IDX + 4, 60,
481                                       ptr->app.data) + 4;
482                 zr36050_write(ptr, ZR050_COM_IDX, 0xff);
483                 zr36050_write(ptr, ZR050_COM_IDX + 1, 0xfe);
484                 zr36050_write(ptr, ZR050_COM_IDX + 2, 0x00);
485                 zr36050_write(ptr, ZR050_COM_IDX + 3, ptr->com.len + 2);
486                 sum += zr36050_pushit(ptr, ZR050_COM_IDX + 4, 60,
487                                       ptr->com.data) + 4;
488
489                 /* do the internal huffman table preload */
490                 zr36050_write(ptr, ZR050_MARKERS_EN, ZR050_ME_DHTI);
491
492                 zr36050_write(ptr, ZR050_GO, 1);        // launch codec
493                 zr36050_wait_end(ptr);
494                 dprintk(2, "%s: Status after table preload: 0x%02x\n",
495                         ptr->name, ptr->status1);
496
497                 if ((ptr->status1 & 0x4) == 0) {
498                         dprintk(1, KERN_ERR "%s: init aborted!\n",
499                                 ptr->name);
500                         return; // something is wrong, its timed out!!!!
501                 }
502
503                 /* setup misc. data for compression (target code sizes) */
504
505                 /* size of compressed code to reach without header data */
506                 sum = ptr->real_code_vol - sum;
507                 bitcnt = sum << 3;      /* need the size in bits */
508
509                 tmp = bitcnt >> 16;
510                 dprintk(3,
511                         "%s: code: csize=%d, tot=%d, bit=%ld, highbits=%ld\n",
512                         ptr->name, sum, ptr->real_code_vol, bitcnt, tmp);
513                 zr36050_write(ptr, ZR050_TCV_NET_HI, tmp >> 8);
514                 zr36050_write(ptr, ZR050_TCV_NET_MH, tmp & 0xff);
515                 tmp = bitcnt & 0xffff;
516                 zr36050_write(ptr, ZR050_TCV_NET_ML, tmp >> 8);
517                 zr36050_write(ptr, ZR050_TCV_NET_LO, tmp & 0xff);
518
519                 bitcnt -= bitcnt >> 7;  // bits without stuffing
520                 bitcnt -= ((bitcnt * 5) >> 6);  // bits without eob
521
522                 tmp = bitcnt >> 16;
523                 dprintk(3, "%s: code: nettobit=%ld, highnettobits=%ld\n",
524                         ptr->name, bitcnt, tmp);
525                 zr36050_write(ptr, ZR050_TCV_DATA_HI, tmp >> 8);
526                 zr36050_write(ptr, ZR050_TCV_DATA_MH, tmp & 0xff);
527                 tmp = bitcnt & 0xffff;
528                 zr36050_write(ptr, ZR050_TCV_DATA_ML, tmp >> 8);
529                 zr36050_write(ptr, ZR050_TCV_DATA_LO, tmp & 0xff);
530
531                 /* compression setup with or without bitrate control */
532                 zr36050_write(ptr, ZR050_MODE,
533                               ZR050_MO_COMP | ZR050_MO_PASS2 |
534                               (ptr->bitrate_ctrl ? ZR050_MO_BRC : 0));
535
536                 /* this headers seem to deliver "valid AVI" jpeg frames */
537                 zr36050_write(ptr, ZR050_MARKERS_EN,
538                               ZR050_ME_DQT | ZR050_ME_DHT |
539                               ((ptr->app.len > 0) ? ZR050_ME_APP : 0) |
540                               ((ptr->com.len > 0) ? ZR050_ME_COM : 0));
541         } else {
542                 dprintk(2, "%s: EXPANSION SETUP\n", ptr->name);
543
544                 /* 050 communicates with 055 in master mode */
545                 zr36050_write(ptr, ZR050_HARDWARE,
546                               ZR050_HW_MSTR | ZR050_HW_CFIS_2_CLK);
547
548                 /* encoding table preload */
549                 zr36050_write(ptr, ZR050_MODE, ZR050_MO_TLM);
550
551                 /* disable all IRQs */
552                 zr36050_write(ptr, ZR050_INT_REQ_0, 0);
553                 zr36050_write(ptr, ZR050_INT_REQ_1, 3); // low 2 bits always 1
554
555                 dprintk(3, "%s: write DHT\n", ptr->name);
556                 zr36050_pushit(ptr, ZR050_DHT_IDX, sizeof(zr36050_dht),
557                                zr36050_dht);
558
559                 /* do the internal huffman table preload */
560                 zr36050_write(ptr, ZR050_MARKERS_EN, ZR050_ME_DHTI);
561
562                 zr36050_write(ptr, ZR050_GO, 1);        // launch codec
563                 zr36050_wait_end(ptr);
564                 dprintk(2, "%s: Status after table preload: 0x%02x\n",
565                         ptr->name, ptr->status1);
566
567                 if ((ptr->status1 & 0x4) == 0) {
568                         dprintk(1, KERN_ERR "%s: init aborted!\n",
569                                 ptr->name);
570                         return; // something is wrong, its timed out!!!!
571                 }
572
573                 /* setup misc. data for expansion */
574                 zr36050_write(ptr, ZR050_MODE, 0);
575                 zr36050_write(ptr, ZR050_MARKERS_EN, 0);
576         }
577
578         /* adr on selected, to allow GO from master */
579         zr36050_read(ptr, 0);
580 }
581
582 /* =========================================================================
583    CODEC API FUNCTIONS
584
585    this functions are accessed by the master via the API structure
586    ========================================================================= */
587
588 /* set compression/expansion mode and launches codec -
589    this should be the last call from the master before starting processing */
590 static int
591 zr36050_set_mode (struct videocodec *codec,
592                   int                mode)
593 {
594         struct zr36050 *ptr = (struct zr36050 *) codec->data;
595
596         dprintk(2, "%s: set_mode %d call\n", ptr->name, mode);
597
598         if ((mode != CODEC_DO_EXPANSION) && (mode != CODEC_DO_COMPRESSION))
599                 return -EINVAL;
600
601         ptr->mode = mode;
602         zr36050_init(ptr);
603
604         return 0;
605 }
606
607 /* set picture size (norm is ignored as the codec doesn't know about it) */
608 static int
609 zr36050_set_video (struct videocodec   *codec,
610                    struct tvnorm       *norm,
611                    struct vfe_settings *cap,
612                    struct vfe_polarity *pol)
613 {
614         struct zr36050 *ptr = (struct zr36050 *) codec->data;
615         int size;
616
617         dprintk(2, "%s: set_video %d.%d, %d/%d-%dx%d (0x%x) q%d call\n",
618                 ptr->name, norm->HStart, norm->VStart,
619                 cap->x, cap->y, cap->width, cap->height,
620                 cap->decimation, cap->quality);
621         /* if () return -EINVAL;
622          * trust the master driver that it knows what it does - so
623          * we allow invalid startx/y and norm for now ... */
624         ptr->width = cap->width / (cap->decimation & 0xff);
625         ptr->height = cap->height / ((cap->decimation >> 8) & 0xff);
626
627         /* (KM) JPEG quality */
628         size = ptr->width * ptr->height;
629         size *= 16; /* size in bits */
630         /* apply quality setting */
631         size = size * cap->quality / 200;
632
633         /* Minimum: 1kb */
634         if (size < 8192)
635                 size = 8192;
636         /* Maximum: 7/8 of code buffer */
637         if (size > ptr->total_code_vol * 7)
638                 size = ptr->total_code_vol * 7;
639
640         ptr->real_code_vol = size >> 3; /* in bytes */
641
642         /* Set max_block_vol here (previously in zr36050_init, moved
643          * here for consistency with zr36060 code */
644         zr36050_write(ptr, ZR050_MBCV, ptr->max_block_vol);
645
646         return 0;
647 }
648
649 /* additional control functions */
650 static int
651 zr36050_control (struct videocodec *codec,
652                  int                type,
653                  int                size,
654                  void              *data)
655 {
656         struct zr36050 *ptr = (struct zr36050 *) codec->data;
657         int *ival = (int *) data;
658
659         dprintk(2, "%s: control %d call with %d byte\n", ptr->name, type,
660                 size);
661
662         switch (type) {
663         case CODEC_G_STATUS:    /* get last status */
664                 if (size != sizeof(int))
665                         return -EFAULT;
666                 zr36050_read_status1(ptr);
667                 *ival = ptr->status1;
668                 break;
669
670         case CODEC_G_CODEC_MODE:
671                 if (size != sizeof(int))
672                         return -EFAULT;
673                 *ival = CODEC_MODE_BJPG;
674                 break;
675
676         case CODEC_S_CODEC_MODE:
677                 if (size != sizeof(int))
678                         return -EFAULT;
679                 if (*ival != CODEC_MODE_BJPG)
680                         return -EINVAL;
681                 /* not needed, do nothing */
682                 return 0;
683
684         case CODEC_G_VFE:
685         case CODEC_S_VFE:
686                 /* not needed, do nothing */
687                 return 0;
688
689         case CODEC_S_MMAP:
690                 /* not available, give an error */
691                 return -ENXIO;
692
693         case CODEC_G_JPEG_TDS_BYTE:     /* get target volume in byte */
694                 if (size != sizeof(int))
695                         return -EFAULT;
696                 *ival = ptr->total_code_vol;
697                 break;
698
699         case CODEC_S_JPEG_TDS_BYTE:     /* get target volume in byte */
700                 if (size != sizeof(int))
701                         return -EFAULT;
702                 ptr->total_code_vol = *ival;
703                 /* (Kieran Morrissey)
704                  * code copied from zr36060.c to ensure proper bitrate */
705                 ptr->real_code_vol = (ptr->total_code_vol * 6) >> 3;
706                 break;
707
708         case CODEC_G_JPEG_SCALE:        /* get scaling factor */
709                 if (size != sizeof(int))
710                         return -EFAULT;
711                 *ival = zr36050_read_scalefactor(ptr);
712                 break;
713
714         case CODEC_S_JPEG_SCALE:        /* set scaling factor */
715                 if (size != sizeof(int))
716                         return -EFAULT;
717                 ptr->scalefact = *ival;
718                 break;
719
720         case CODEC_G_JPEG_APP_DATA: {   /* get appn marker data */
721                 struct jpeg_app_marker *app = data;
722
723                 if (size != sizeof(struct jpeg_app_marker))
724                         return -EFAULT;
725
726                 *app = ptr->app;
727                 break;
728         }
729
730         case CODEC_S_JPEG_APP_DATA: {    /* set appn marker data */
731                 struct jpeg_app_marker *app = data;
732
733                 if (size != sizeof(struct jpeg_app_marker))
734                         return -EFAULT;
735
736                 ptr->app = *app;
737                 break;
738         }
739
740         case CODEC_G_JPEG_COM_DATA: {   /* get comment marker data */
741                 struct jpeg_com_marker *com = data;
742
743                 if (size != sizeof(struct jpeg_com_marker))
744                         return -EFAULT;
745
746                 *com = ptr->com;
747                 break;
748         }
749
750         case CODEC_S_JPEG_COM_DATA: {   /* set comment marker data */
751                 struct jpeg_com_marker *com = data;
752
753                 if (size != sizeof(struct jpeg_com_marker))
754                         return -EFAULT;
755
756                 ptr->com = *com;
757                 break;
758         }
759
760         default:
761                 return -EINVAL;
762         }
763
764         return size;
765 }
766
767 /* =========================================================================
768    Exit and unregister function:
769
770    Deinitializes Zoran's JPEG processor
771    ========================================================================= */
772
773 static int
774 zr36050_unset (struct videocodec *codec)
775 {
776         struct zr36050 *ptr = codec->data;
777
778         if (ptr) {
779                 /* do wee need some codec deinit here, too ???? */
780
781                 dprintk(1, "%s: finished codec #%d\n", ptr->name,
782                         ptr->num);
783                 kfree(ptr);
784                 codec->data = NULL;
785
786                 zr36050_codecs--;
787                 return 0;
788         }
789
790         return -EFAULT;
791 }
792
793 /* =========================================================================
794    Setup and registry function:
795
796    Initializes Zoran's JPEG processor
797
798    Also sets pixel size, average code size, mode (compr./decompr.)
799    (the given size is determined by the processor with the video interface)
800    ========================================================================= */
801
802 static int
803 zr36050_setup (struct videocodec *codec)
804 {
805         struct zr36050 *ptr;
806         int res;
807
808         dprintk(2, "zr36050: initializing MJPEG subsystem #%d.\n",
809                 zr36050_codecs);
810
811         if (zr36050_codecs == MAX_CODECS) {
812                 dprintk(1,
813                         KERN_ERR "zr36050: Can't attach more codecs!\n");
814                 return -ENOSPC;
815         }
816         //mem structure init
817         codec->data = ptr = kmalloc(sizeof(struct zr36050), GFP_KERNEL);
818         if (NULL == ptr) {
819                 dprintk(1, KERN_ERR "zr36050: Can't get enough memory!\n");
820                 return -ENOMEM;
821         }
822         memset(ptr, 0, sizeof(struct zr36050));
823
824         snprintf(ptr->name, sizeof(ptr->name), "zr36050[%d]",
825                  zr36050_codecs);
826         ptr->num = zr36050_codecs++;
827         ptr->codec = codec;
828
829         //testing
830         res = zr36050_basic_test(ptr);
831         if (res < 0) {
832                 zr36050_unset(codec);
833                 return res;
834         }
835         //final setup
836         memcpy(ptr->h_samp_ratio, zr36050_decimation_h, 8);
837         memcpy(ptr->v_samp_ratio, zr36050_decimation_v, 8);
838
839         ptr->bitrate_ctrl = 0;  /* 0 or 1 - fixed file size flag
840                                  * (what is the difference?) */
841         ptr->mode = CODEC_DO_COMPRESSION;
842         ptr->width = 384;
843         ptr->height = 288;
844         ptr->total_code_vol = 16000;
845         ptr->max_block_vol = 240;
846         ptr->scalefact = 0x100;
847         ptr->dri = 1;
848
849         /* no app/com marker by default */
850         ptr->app.appn = 0;
851         ptr->app.len = 0;
852         ptr->com.len = 0;
853
854         zr36050_init(ptr);
855
856         dprintk(1, KERN_INFO "%s: codec attached and running\n",
857                 ptr->name);
858
859         return 0;
860 }
861
862 static const struct videocodec zr36050_codec = {
863         .owner = THIS_MODULE,
864         .name = "zr36050",
865         .magic = 0L,            // magic not used
866         .flags =
867             CODEC_FLAG_JPEG | CODEC_FLAG_HARDWARE | CODEC_FLAG_ENCODER |
868             CODEC_FLAG_DECODER,
869         .type = CODEC_TYPE_ZR36050,
870         .setup = zr36050_setup, // functionality
871         .unset = zr36050_unset,
872         .set_mode = zr36050_set_mode,
873         .set_video = zr36050_set_video,
874         .control = zr36050_control,
875         // others are not used
876 };
877
878 /* =========================================================================
879    HOOK IN DRIVER AS KERNEL MODULE
880    ========================================================================= */
881
882 static int __init
883 zr36050_init_module (void)
884 {
885         //dprintk(1, "ZR36050 driver %s\n",ZR050_VERSION);
886         zr36050_codecs = 0;
887         return videocodec_register(&zr36050_codec);
888 }
889
890 static void __exit
891 zr36050_cleanup_module (void)
892 {
893         if (zr36050_codecs) {
894                 dprintk(1,
895                         "zr36050: something's wrong - %d codecs left somehow.\n",
896                         zr36050_codecs);
897         }
898         videocodec_unregister(&zr36050_codec);
899 }
900
901 module_init(zr36050_init_module);
902 module_exit(zr36050_cleanup_module);
903
904 MODULE_AUTHOR("Wolfgang Scherr <scherr@net4you.at>");
905 MODULE_DESCRIPTION("Driver module for ZR36050 jpeg processors "
906                    ZR050_VERSION);
907 MODULE_LICENSE("GPL");