?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / media / pci / zoran / zr36060.c
blob2c2e8130fc96c1d8efa07ea8fa39f0ea3e88cc93
1 /*
2 * Zoran ZR36060 basic configuration functions
3 *
4 * Copyright (C) 2002 Laurent Pinchart <laurent.pinchart@skynet.be>
5 *
6 * $Id: zr36060.c,v 1.1.2.22 2003/05/06 09:35:36 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 * ------------------------------------------------------------------------
21 */
22
23 #define ZR060_VERSION "v0.7"
24
25 #include <linux/module.h>
26 #include <linux/init.h>
27 #include <linux/slab.h>
28 #include <linux/delay.h>
29
30 #include <linux/types.h>
31 #include <linux/wait.h>
32
33 /* I/O commands, error codes */
34 #include <asm/io.h>
35
36 /* headerfile of this module */
37 #include "zr36060.h"
38
39 /* codec io API */
40 #include "videocodec.h"
41
42 /* it doesn't make sense to have more than 20 or so,
43 just to prevent some unwanted loops */
44 #define MAX_CODECS 20
45
46 /* amount of chips attached via this driver */
47 static int zr36060_codecs;
48
49 static bool low_bitrate;
50 module_param(low_bitrate, bool, 0);
51 MODULE_PARM_DESC(low_bitrate, "Buz compatibility option, halves bitrate");
52
53 /* debugging is available via module parameter */
54 static int debug;
55 module_param(debug, int, 0);
56 MODULE_PARM_DESC(debug, "Debug level (0-4)");
57
58 #define dprintk(num, format, args...) \
59 do { \
60 if (debug >= num) \
61 printk(format, ##args); \
62 } while (0)
63
64 /* =========================================================================
65 Local hardware I/O functions:
66
67 read/write via codec layer (registers are located in the master device)
68 ========================================================================= */
69
70 /* read and write functions */
71 static u8
72 zr36060_read (struct zr36060 *ptr,
73 u16 reg)
74 {
75 u8 value = 0;
76
77 // just in case something is wrong...
78 if (ptr->codec->master_data->readreg)
79 value = (ptr->codec->master_data->readreg(ptr->codec,
80 reg)) & 0xff;
81 else
82 dprintk(1,
83 KERN_ERR "%s: invalid I/O setup, nothing read!\n",
84 ptr->name);
85
86 //dprintk(4, "%s: reading from 0x%04x: %02x\n",ptr->name,reg,value);
87
88 return value;
89 }
90
91 static void
92 zr36060_write(struct zr36060 *ptr,
93 u16 reg,
94 u8 value)
95 {
96 //dprintk(4, "%s: writing 0x%02x to 0x%04x\n",ptr->name,value,reg);
97 dprintk(4, "0x%02x @0x%04x\n", value, reg);
98
99 // just in case something is wrong...
100 if (ptr->codec->master_data->writereg)
101 ptr->codec->master_data->writereg(ptr->codec, reg, value);
102 else
103 dprintk(1,
104 KERN_ERR
105 "%s: invalid I/O setup, nothing written!\n",
106 ptr->name);
107 }
108
109 /* =========================================================================
110 Local helper function:
111
112 status read
113 ========================================================================= */
114
115 /* status is kept in datastructure */
116 static u8
117 zr36060_read_status (struct zr36060 *ptr)
118 {
119 ptr->status = zr36060_read(ptr, ZR060_CFSR);
120
121 zr36060_read(ptr, 0);
122 return ptr->status;
123 }
124
125 /* =========================================================================
126 Local helper function:
127
128 scale factor read
129 ========================================================================= */
130
131 /* scale factor is kept in datastructure */
132 static u16
133 zr36060_read_scalefactor (struct zr36060 *ptr)
134 {
135 ptr->scalefact = (zr36060_read(ptr, ZR060_SF_HI) << 8) |
136 (zr36060_read(ptr, ZR060_SF_LO) & 0xFF);
137
138 /* leave 0 selected for an eventually GO from master */
139 zr36060_read(ptr, 0);
140 return ptr->scalefact;
141 }
142
143 /* =========================================================================
144 Local helper function:
145
146 wait if codec is ready to proceed (end of processing) or time is over
147 ========================================================================= */
148
149 static void
150 zr36060_wait_end (struct zr36060 *ptr)
151 {
152 int i = 0;
153
154 while (zr36060_read_status(ptr) & ZR060_CFSR_Busy) {
155 udelay(1);
156 if (i++ > 200000) { // 200ms, there is for sure something wrong!!!
157 dprintk(1,
158 "%s: timeout at wait_end (last status: 0x%02x)\n",
159 ptr->name, ptr->status);
160 break;
161 }
162 }
163 }
164
165 /* =========================================================================
166 Local helper function:
167
168 basic test of "connectivity", writes/reads to/from memory the SOF marker
169 ========================================================================= */
170
171 static int
172 zr36060_basic_test (struct zr36060 *ptr)
173 {
174 if ((zr36060_read(ptr, ZR060_IDR_DEV) != 0x33) &&
175 (zr36060_read(ptr, ZR060_IDR_REV) != 0x01)) {
176 dprintk(1,
177 KERN_ERR
178 "%s: attach failed, can't connect to jpeg processor!\n",
179 ptr->name);
180 return -ENXIO;
181 }
182
183 zr36060_wait_end(ptr);
184 if (ptr->status & ZR060_CFSR_Busy) {
185 dprintk(1,
186 KERN_ERR
187 "%s: attach failed, jpeg processor failed (end flag)!\n",
188 ptr->name);
189 return -EBUSY;
190 }
191
192 return 0; /* looks good! */
193 }
194
195 /* =========================================================================
196 Local helper function:
197
198 simple loop for pushing the init datasets
199 ========================================================================= */
200
201 static int
202 zr36060_pushit (struct zr36060 *ptr,
203 u16 startreg,
204 u16 len,
205 const char *data)
206 {
207 int i = 0;
208
209 dprintk(4, "%s: write data block to 0x%04x (len=%d)\n", ptr->name,
210 startreg, len);
211 while (i < len) {
212 zr36060_write(ptr, startreg++, data[i++]);
213 }
214
215 return i;
216 }
217
218 /* =========================================================================
219 Basic datasets:
220
221 jpeg baseline setup data (you find it on lots places in internet, or just
222 extract it from any regular .jpg image...)
223
224 Could be variable, but until it's not needed it they are just fixed to save
225 memory. Otherwise expand zr36060 structure with arrays, push the values to
226 it and initialize from there, as e.g. the linux zr36057/60 driver does it.
227 ========================================================================= */
228
229 static const char zr36060_dqt[0x86] = {
230 0xff, 0xdb, //Marker: DQT
231 0x00, 0x84, //Length: 2*65+2
232 0x00, //Pq,Tq first table
233 0x10, 0x0b, 0x0c, 0x0e, 0x0c, 0x0a, 0x10, 0x0e,
234 0x0d, 0x0e, 0x12, 0x11, 0x10, 0x13, 0x18, 0x28,
235 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25,
236 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33,
237 0x38, 0x37, 0x40, 0x48, 0x5c, 0x4e, 0x40, 0x44,
238 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51, 0x57,
239 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71,
240 0x79, 0x70, 0x64, 0x78, 0x5c, 0x65, 0x67, 0x63,
241 0x01, //Pq,Tq second table
242 0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a,
243 0x1a, 0x2f, 0x63, 0x42, 0x38, 0x42, 0x63, 0x63,
244 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
245 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
246 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
247 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
248 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63,
249 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63
250 };
251
252 static const char zr36060_dht[0x1a4] = {
253 0xff, 0xc4, //Marker: DHT
254 0x01, 0xa2, //Length: 2*AC, 2*DC
255 0x00, //DC first table
256 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01,
257 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
258 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
259 0x01, //DC second table
260 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
261 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
262 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
263 0x10, //AC first table
264 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 0x04, 0x03,
265 0x05, 0x05, 0x04, 0x04, 0x00, 0x00,
266 0x01, 0x7D, 0x01, 0x02, 0x03, 0x00, 0x04, 0x11,
267 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61,
268 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
269 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24,
270 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17,
271 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34,
272 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
273 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56,
274 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66,
275 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
276 0x79, 0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88,
277 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
278 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
279 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9,
280 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8,
281 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9,
282 0xDA, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
283 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
284 0xF8, 0xF9, 0xFA,
285 0x11, //AC second table
286 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04,
287 0x07, 0x05, 0x04, 0x04, 0x00, 0x01,
288 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 0x04,
289 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
290 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
291 0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62,
292 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34, 0xE1, 0x25,
293 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 0x28, 0x29, 0x2A,
294 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
295 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56,
296 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66,
297 0x67, 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
298 0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
299 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
300 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
301 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
302 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
303 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8,
304 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7,
305 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
306 0xF9, 0xFA
307 };
308
309 /* jpeg baseline setup, this is just fixed in this driver (YUV pictures) */
310 #define NO_OF_COMPONENTS 0x3 //Y,U,V
311 #define BASELINE_PRECISION 0x8 //MCU size (?)
312 static const char zr36060_tq[8] = { 0, 1, 1, 0, 0, 0, 0, 0 }; //table idx's QT
313 static const char zr36060_td[8] = { 0, 1, 1, 0, 0, 0, 0, 0 }; //table idx's DC
314 static const char zr36060_ta[8] = { 0, 1, 1, 0, 0, 0, 0, 0 }; //table idx's AC
315
316 /* horizontal 422 decimation setup (maybe we support 411 or so later, too) */
317 static const char zr36060_decimation_h[8] = { 2, 1, 1, 0, 0, 0, 0, 0 };
318 static const char zr36060_decimation_v[8] = { 1, 1, 1, 0, 0, 0, 0, 0 };
319
320 /* =========================================================================
321 Local helper functions:
322
323 calculation and setup of parameter-dependent JPEG baseline segments
324 (needed for compression only)
325 ========================================================================= */
326
327 /* ------------------------------------------------------------------------- */
328
329 /* SOF (start of frame) segment depends on width, height and sampling ratio
330 of each color component */
331
332 static int
333 zr36060_set_sof (struct zr36060 *ptr)
334 {
335 char sof_data[34]; // max. size of register set
336 int i;
337
338 dprintk(3, "%s: write SOF (%dx%d, %d components)\n", ptr->name,
339 ptr->width, ptr->height, NO_OF_COMPONENTS);
340 sof_data[0] = 0xff;
341 sof_data[1] = 0xc0;
342 sof_data[2] = 0x00;
343 sof_data[3] = (3 * NO_OF_COMPONENTS) + 8;
344 sof_data[4] = BASELINE_PRECISION; // only '8' possible with zr36060
345 sof_data[5] = (ptr->height) >> 8;
346 sof_data[6] = (ptr->height) & 0xff;
347 sof_data[7] = (ptr->width) >> 8;
348 sof_data[8] = (ptr->width) & 0xff;
349 sof_data[9] = NO_OF_COMPONENTS;
350 for (i = 0; i < NO_OF_COMPONENTS; i++) {
351 sof_data[10 + (i * 3)] = i; // index identifier
352 sof_data[11 + (i * 3)] = (ptr->h_samp_ratio[i] << 4) |
353 (ptr->v_samp_ratio[i]); // sampling ratios
354 sof_data[12 + (i * 3)] = zr36060_tq[i]; // Q table selection
355 }
356 return zr36060_pushit(ptr, ZR060_SOF_IDX,
357 (3 * NO_OF_COMPONENTS) + 10, sof_data);
358 }
359
360 /* ------------------------------------------------------------------------- */
361
362 /* SOS (start of scan) segment depends on the used scan components
363 of each color component */
364
365 static int
366 zr36060_set_sos (struct zr36060 *ptr)
367 {
368 char sos_data[16]; // max. size of register set
369 int i;
370
371 dprintk(3, "%s: write SOS\n", ptr->name);
372 sos_data[0] = 0xff;
373 sos_data[1] = 0xda;
374 sos_data[2] = 0x00;
375 sos_data[3] = 2 + 1 + (2 * NO_OF_COMPONENTS) + 3;
376 sos_data[4] = NO_OF_COMPONENTS;
377 for (i = 0; i < NO_OF_COMPONENTS; i++) {
378 sos_data[5 + (i * 2)] = i; // index
379 sos_data[6 + (i * 2)] = (zr36060_td[i] << 4) |
380 zr36060_ta[i]; // AC/DC tbl.sel.
381 }
382 sos_data[2 + 1 + (2 * NO_OF_COMPONENTS) + 2] = 00; // scan start
383 sos_data[2 + 1 + (2 * NO_OF_COMPONENTS) + 3] = 0x3f;
384 sos_data[2 + 1 + (2 * NO_OF_COMPONENTS) + 4] = 00;
385 return zr36060_pushit(ptr, ZR060_SOS_IDX,
386 4 + 1 + (2 * NO_OF_COMPONENTS) + 3,
387 sos_data);
388 }
389
390 /* ------------------------------------------------------------------------- */
391
392 /* DRI (define restart interval) */
393
394 static int
395 zr36060_set_dri (struct zr36060 *ptr)
396 {
397 char dri_data[6]; // max. size of register set
398
399 dprintk(3, "%s: write DRI\n", ptr->name);
400 dri_data[0] = 0xff;
401 dri_data[1] = 0xdd;
402 dri_data[2] = 0x00;
403 dri_data[3] = 0x04;
404 dri_data[4] = (ptr->dri) >> 8;
405 dri_data[5] = (ptr->dri) & 0xff;
406 return zr36060_pushit(ptr, ZR060_DRI_IDX, 6, dri_data);
407 }
408
409 /* =========================================================================
410 Setup function:
411
412 Setup compression/decompression of Zoran's JPEG processor
413 ( see also zoran 36060 manual )
414
415 ... sorry for the spaghetti code ...
416 ========================================================================= */
417 static void
418 zr36060_init (struct zr36060 *ptr)
419 {
420 int sum = 0;
421 long bitcnt, tmp;
422
423 if (ptr->mode == CODEC_DO_COMPRESSION) {
424 dprintk(2, "%s: COMPRESSION SETUP\n", ptr->name);
425
426 zr36060_write(ptr, ZR060_LOAD, ZR060_LOAD_SyncRst);
427
428 /* 060 communicates with 067 in master mode */
429 zr36060_write(ptr, ZR060_CIR, ZR060_CIR_CodeMstr);
430
431 /* Compression with or without variable scale factor */
432 /*FIXME: What about ptr->bitrate_ctrl? */
433 zr36060_write(ptr, ZR060_CMR,
434 ZR060_CMR_Comp | ZR060_CMR_Pass2 |
435 ZR060_CMR_BRB);
436
437 /* Must be zero */
438 zr36060_write(ptr, ZR060_MBZ, 0x00);
439 zr36060_write(ptr, ZR060_TCR_HI, 0x00);
440 zr36060_write(ptr, ZR060_TCR_LO, 0x00);
441
442 /* Disable all IRQs - no DataErr means autoreset */
443 zr36060_write(ptr, ZR060_IMR, 0);
444
445 /* volume control settings */
446 zr36060_write(ptr, ZR060_SF_HI, ptr->scalefact >> 8);
447 zr36060_write(ptr, ZR060_SF_LO, ptr->scalefact & 0xff);
448
449 zr36060_write(ptr, ZR060_AF_HI, 0xff);
450 zr36060_write(ptr, ZR060_AF_M, 0xff);
451 zr36060_write(ptr, ZR060_AF_LO, 0xff);
452
453 /* setup the variable jpeg tables */
454 sum += zr36060_set_sof(ptr);
455 sum += zr36060_set_sos(ptr);
456 sum += zr36060_set_dri(ptr);
457
458 /* setup the fixed jpeg tables - maybe variable, though -
459 * (see table init section above) */
460 sum +=
461 zr36060_pushit(ptr, ZR060_DQT_IDX, sizeof(zr36060_dqt),
462 zr36060_dqt);
463 sum +=
464 zr36060_pushit(ptr, ZR060_DHT_IDX, sizeof(zr36060_dht),
465 zr36060_dht);
466 zr36060_write(ptr, ZR060_APP_IDX, 0xff);
467 zr36060_write(ptr, ZR060_APP_IDX + 1, 0xe0 + ptr->app.appn);
468 zr36060_write(ptr, ZR060_APP_IDX + 2, 0x00);
469 zr36060_write(ptr, ZR060_APP_IDX + 3, ptr->app.len + 2);
470 sum += zr36060_pushit(ptr, ZR060_APP_IDX + 4, 60,
471 ptr->app.data) + 4;
472 zr36060_write(ptr, ZR060_COM_IDX, 0xff);
473 zr36060_write(ptr, ZR060_COM_IDX + 1, 0xfe);
474 zr36060_write(ptr, ZR060_COM_IDX + 2, 0x00);
475 zr36060_write(ptr, ZR060_COM_IDX + 3, ptr->com.len + 2);
476 sum += zr36060_pushit(ptr, ZR060_COM_IDX + 4, 60,
477 ptr->com.data) + 4;
478
479 /* setup misc. data for compression (target code sizes) */
480
481 /* size of compressed code to reach without header data */
482 sum = ptr->real_code_vol - sum;
483 bitcnt = sum << 3; /* need the size in bits */
484
485 tmp = bitcnt >> 16;
486 dprintk(3,
487 "%s: code: csize=%d, tot=%d, bit=%ld, highbits=%ld\n",
488 ptr->name, sum, ptr->real_code_vol, bitcnt, tmp);
489 zr36060_write(ptr, ZR060_TCV_NET_HI, tmp >> 8);
490 zr36060_write(ptr, ZR060_TCV_NET_MH, tmp & 0xff);
491 tmp = bitcnt & 0xffff;
492 zr36060_write(ptr, ZR060_TCV_NET_ML, tmp >> 8);
493 zr36060_write(ptr, ZR060_TCV_NET_LO, tmp & 0xff);
494
495 bitcnt -= bitcnt >> 7; // bits without stuffing
496 bitcnt -= ((bitcnt * 5) >> 6); // bits without eob
497
498 tmp = bitcnt >> 16;
499 dprintk(3, "%s: code: nettobit=%ld, highnettobits=%ld\n",
500 ptr->name, bitcnt, tmp);
501 zr36060_write(ptr, ZR060_TCV_DATA_HI, tmp >> 8);
502 zr36060_write(ptr, ZR060_TCV_DATA_MH, tmp & 0xff);
503 tmp = bitcnt & 0xffff;
504 zr36060_write(ptr, ZR060_TCV_DATA_ML, tmp >> 8);
505 zr36060_write(ptr, ZR060_TCV_DATA_LO, tmp & 0xff);
506
507 /* JPEG markers to be included in the compressed stream */
508 zr36060_write(ptr, ZR060_MER,
509 ZR060_MER_DQT | ZR060_MER_DHT |
510 ((ptr->com.len > 0) ? ZR060_MER_Com : 0) |
511 ((ptr->app.len > 0) ? ZR060_MER_App : 0));
512
513 /* Setup the Video Frontend */
514 /* Limit pixel range to 16..235 as per CCIR-601 */
515 zr36060_write(ptr, ZR060_VCR, ZR060_VCR_Range);
516
517 } else {
518 dprintk(2, "%s: EXPANSION SETUP\n", ptr->name);
519
520 zr36060_write(ptr, ZR060_LOAD, ZR060_LOAD_SyncRst);
521
522 /* 060 communicates with 067 in master mode */
523 zr36060_write(ptr, ZR060_CIR, ZR060_CIR_CodeMstr);
524
525 /* Decompression */
526 zr36060_write(ptr, ZR060_CMR, 0);
527
528 /* Must be zero */
529 zr36060_write(ptr, ZR060_MBZ, 0x00);
530 zr36060_write(ptr, ZR060_TCR_HI, 0x00);
531 zr36060_write(ptr, ZR060_TCR_LO, 0x00);
532
533 /* Disable all IRQs - no DataErr means autoreset */
534 zr36060_write(ptr, ZR060_IMR, 0);
535
536 /* setup misc. data for expansion */
537 zr36060_write(ptr, ZR060_MER, 0);
538
539 /* setup the fixed jpeg tables - maybe variable, though -
540 * (see table init section above) */
541 zr36060_pushit(ptr, ZR060_DHT_IDX, sizeof(zr36060_dht),
542 zr36060_dht);
543
544 /* Setup the Video Frontend */
545 //zr36060_write(ptr, ZR060_VCR, ZR060_VCR_FIExt);
546 //this doesn't seem right and doesn't work...
547 zr36060_write(ptr, ZR060_VCR, ZR060_VCR_Range);
548 }
549
550 /* Load the tables */
551 zr36060_write(ptr, ZR060_LOAD,
552 ZR060_LOAD_SyncRst | ZR060_LOAD_Load);
553 zr36060_wait_end(ptr);
554 dprintk(2, "%s: Status after table preload: 0x%02x\n", ptr->name,
555 ptr->status);
556
557 if (ptr->status & ZR060_CFSR_Busy) {
558 dprintk(1, KERN_ERR "%s: init aborted!\n", ptr->name);
559 return; // something is wrong, its timed out!!!!
560 }
561 }
562
563 /* =========================================================================
564 CODEC API FUNCTIONS
565
566 this functions are accessed by the master via the API structure
567 ========================================================================= */
568
569 /* set compression/expansion mode and launches codec -
570 this should be the last call from the master before starting processing */
571 static int
572 zr36060_set_mode (struct videocodec *codec,
573 int mode)
574 {
575 struct zr36060 *ptr = (struct zr36060 *) codec->data;
576
577 dprintk(2, "%s: set_mode %d call\n", ptr->name, mode);
578
579 if ((mode != CODEC_DO_EXPANSION) && (mode != CODEC_DO_COMPRESSION))
580 return -EINVAL;
581
582 ptr->mode = mode;
583 zr36060_init(ptr);
584
585 return 0;
586 }
587
588 /* set picture size (norm is ignored as the codec doesn't know about it) */
589 static int
590 zr36060_set_video (struct videocodec *codec,
591 struct tvnorm *norm,
592 struct vfe_settings *cap,
593 struct vfe_polarity *pol)
594 {
595 struct zr36060 *ptr = (struct zr36060 *) codec->data;
596 u32 reg;
597 int size;
598
599 dprintk(2, "%s: set_video %d/%d-%dx%d (%%%d) call\n", ptr->name,
600 cap->x, cap->y, cap->width, cap->height, cap->decimation);
601
602 /* if () return -EINVAL;
603 * trust the master driver that it knows what it does - so
604 * we allow invalid startx/y and norm for now ... */
605 ptr->width = cap->width / (cap->decimation & 0xff);
606 ptr->height = cap->height / (cap->decimation >> 8);
607
608 zr36060_write(ptr, ZR060_LOAD, ZR060_LOAD_SyncRst);
609
610 /* Note that VSPol/HSPol bits in zr36060 have the opposite
611 * meaning of their zr360x7 counterparts with the same names
612 * N.b. for VSPol this is only true if FIVEdge = 0 (default,
613 * left unchanged here - in accordance with datasheet).
614 */
615 reg = (!pol->vsync_pol ? ZR060_VPR_VSPol : 0)
616 | (!pol->hsync_pol ? ZR060_VPR_HSPol : 0)
617 | (pol->field_pol ? ZR060_VPR_FIPol : 0)
618 | (pol->blank_pol ? ZR060_VPR_BLPol : 0)
619 | (pol->subimg_pol ? ZR060_VPR_SImgPol : 0)
620 | (pol->poe_pol ? ZR060_VPR_PoePol : 0)
621 | (pol->pvalid_pol ? ZR060_VPR_PValPol : 0)
622 | (pol->vclk_pol ? ZR060_VPR_VCLKPol : 0);
623 zr36060_write(ptr, ZR060_VPR, reg);
624
625 reg = 0;
626 switch (cap->decimation & 0xff) {
627 default:
628 case 1:
629 break;
630
631 case 2:
632 reg |= ZR060_SR_HScale2;
633 break;
634
635 case 4:
636 reg |= ZR060_SR_HScale4;
637 break;
638 }
639
640 switch (cap->decimation >> 8) {
641 default:
642 case 1:
643 break;
644
645 case 2:
646 reg |= ZR060_SR_VScale;
647 break;
648 }
649 zr36060_write(ptr, ZR060_SR, reg);
650
651 zr36060_write(ptr, ZR060_BCR_Y, 0x00);
652 zr36060_write(ptr, ZR060_BCR_U, 0x80);
653 zr36060_write(ptr, ZR060_BCR_V, 0x80);
654
655 /* sync generator */
656
657 reg = norm->Ht - 1; /* Vtotal */
658 zr36060_write(ptr, ZR060_SGR_VTOTAL_HI, (reg >> 8) & 0xff);
659 zr36060_write(ptr, ZR060_SGR_VTOTAL_LO, (reg >> 0) & 0xff);
660
661 reg = norm->Wt - 1; /* Htotal */
662 zr36060_write(ptr, ZR060_SGR_HTOTAL_HI, (reg >> 8) & 0xff);
663 zr36060_write(ptr, ZR060_SGR_HTOTAL_LO, (reg >> 0) & 0xff);
664
665 reg = 6 - 1; /* VsyncSize */
666 zr36060_write(ptr, ZR060_SGR_VSYNC, reg);
667
668 //reg = 30 - 1; /* HsyncSize */
669 ///*CP*/ reg = (zr->params.norm == 1 ? 57 : 68);
670 reg = 68;
671 zr36060_write(ptr, ZR060_SGR_HSYNC, reg);
672
673 reg = norm->VStart - 1; /* BVstart */
674 zr36060_write(ptr, ZR060_SGR_BVSTART, reg);
675
676 reg += norm->Ha / 2; /* BVend */
677 zr36060_write(ptr, ZR060_SGR_BVEND_HI, (reg >> 8) & 0xff);
678 zr36060_write(ptr, ZR060_SGR_BVEND_LO, (reg >> 0) & 0xff);
679
680 reg = norm->HStart - 1; /* BHstart */
681 zr36060_write(ptr, ZR060_SGR_BHSTART, reg);
682
683 reg += norm->Wa; /* BHend */
684 zr36060_write(ptr, ZR060_SGR_BHEND_HI, (reg >> 8) & 0xff);
685 zr36060_write(ptr, ZR060_SGR_BHEND_LO, (reg >> 0) & 0xff);
686
687 /* active area */
688 reg = cap->y + norm->VStart; /* Vstart */
689 zr36060_write(ptr, ZR060_AAR_VSTART_HI, (reg >> 8) & 0xff);
690 zr36060_write(ptr, ZR060_AAR_VSTART_LO, (reg >> 0) & 0xff);
691
692 reg += cap->height; /* Vend */
693 zr36060_write(ptr, ZR060_AAR_VEND_HI, (reg >> 8) & 0xff);
694 zr36060_write(ptr, ZR060_AAR_VEND_LO, (reg >> 0) & 0xff);
695
696 reg = cap->x + norm->HStart; /* Hstart */
697 zr36060_write(ptr, ZR060_AAR_HSTART_HI, (reg >> 8) & 0xff);
698 zr36060_write(ptr, ZR060_AAR_HSTART_LO, (reg >> 0) & 0xff);
699
700 reg += cap->width; /* Hend */
701 zr36060_write(ptr, ZR060_AAR_HEND_HI, (reg >> 8) & 0xff);
702 zr36060_write(ptr, ZR060_AAR_HEND_LO, (reg >> 0) & 0xff);
703
704 /* subimage area */
705 reg = norm->VStart - 4; /* SVstart */
706 zr36060_write(ptr, ZR060_SWR_VSTART_HI, (reg >> 8) & 0xff);
707 zr36060_write(ptr, ZR060_SWR_VSTART_LO, (reg >> 0) & 0xff);
708
709 reg += norm->Ha / 2 + 8; /* SVend */
710 zr36060_write(ptr, ZR060_SWR_VEND_HI, (reg >> 8) & 0xff);
711 zr36060_write(ptr, ZR060_SWR_VEND_LO, (reg >> 0) & 0xff);
712
713 reg = norm->HStart /*+ 64 */ - 4; /* SHstart */
714 zr36060_write(ptr, ZR060_SWR_HSTART_HI, (reg >> 8) & 0xff);
715 zr36060_write(ptr, ZR060_SWR_HSTART_LO, (reg >> 0) & 0xff);
716
717 reg += norm->Wa + 8; /* SHend */
718 zr36060_write(ptr, ZR060_SWR_HEND_HI, (reg >> 8) & 0xff);
719 zr36060_write(ptr, ZR060_SWR_HEND_LO, (reg >> 0) & 0xff);
720
721 size = ptr->width * ptr->height;
722 /* Target compressed field size in bits: */
723 size = size * 16; /* uncompressed size in bits */
724 /* (Ronald) by default, quality = 100 is a compression
725 * ratio 1:2. Setting low_bitrate (insmod option) sets
726 * it to 1:4 (instead of 1:2, zr36060 max) as limit because the
727 * buz can't handle more at decimation=1... Use low_bitrate if
728 * you have a Buz, unless you know what you're doing */
729 size = size * cap->quality / (low_bitrate ? 400 : 200);
730 /* Lower limit (arbitrary, 1 KB) */
731 if (size < 8192)
732 size = 8192;
733 /* Upper limit: 7/8 of the code buffers */
734 if (size > ptr->total_code_vol * 7)
735 size = ptr->total_code_vol * 7;
736
737 ptr->real_code_vol = size >> 3; /* in bytes */
738
739 /* the MBCVR is the *maximum* block volume, according to the
740 * JPEG ISO specs, this shouldn't be used, since that allows
741 * for the best encoding quality. So set it to it's max value */
742 reg = ptr->max_block_vol;
743 zr36060_write(ptr, ZR060_MBCVR, reg);
744
745 return 0;
746 }
747
748 /* additional control functions */
749 static int
750 zr36060_control (struct videocodec *codec,
751 int type,
752 int size,
753 void *data)
754 {
755 struct zr36060 *ptr = (struct zr36060 *) codec->data;
756 int *ival = (int *) data;
757
758 dprintk(2, "%s: control %d call with %d byte\n", ptr->name, type,
759 size);
760
761 switch (type) {
762 case CODEC_G_STATUS: /* get last status */
763 if (size != sizeof(int))
764 return -EFAULT;
765 zr36060_read_status(ptr);
766 *ival = ptr->status;
767 break;
768
769 case CODEC_G_CODEC_MODE:
770 if (size != sizeof(int))
771 return -EFAULT;
772 *ival = CODEC_MODE_BJPG;
773 break;
774
775 case CODEC_S_CODEC_MODE:
776 if (size != sizeof(int))
777 return -EFAULT;
778 if (*ival != CODEC_MODE_BJPG)
779 return -EINVAL;
780 /* not needed, do nothing */
781 return 0;
782
783 case CODEC_G_VFE:
784 case CODEC_S_VFE:
785 /* not needed, do nothing */
786 return 0;
787
788 case CODEC_S_MMAP:
789 /* not available, give an error */
790 return -ENXIO;
791
792 case CODEC_G_JPEG_TDS_BYTE: /* get target volume in byte */
793 if (size != sizeof(int))
794 return -EFAULT;
795 *ival = ptr->total_code_vol;
796 break;
797
798 case CODEC_S_JPEG_TDS_BYTE: /* get target volume in byte */
799 if (size != sizeof(int))
800 return -EFAULT;
801 ptr->total_code_vol = *ival;
802 ptr->real_code_vol = (ptr->total_code_vol * 6) >> 3;
803 break;
804
805 case CODEC_G_JPEG_SCALE: /* get scaling factor */
806 if (size != sizeof(int))
807 return -EFAULT;
808 *ival = zr36060_read_scalefactor(ptr);
809 break;
810
811 case CODEC_S_JPEG_SCALE: /* set scaling factor */
812 if (size != sizeof(int))
813 return -EFAULT;
814 ptr->scalefact = *ival;
815 break;
816
817 case CODEC_G_JPEG_APP_DATA: { /* get appn marker data */
818 struct jpeg_app_marker *app = data;
819
820 if (size != sizeof(struct jpeg_app_marker))
821 return -EFAULT;
822
823 *app = ptr->app;
824 break;
825 }
826
827 case CODEC_S_JPEG_APP_DATA: { /* set appn marker data */
828 struct jpeg_app_marker *app = data;
829
830 if (size != sizeof(struct jpeg_app_marker))
831 return -EFAULT;
832
833 ptr->app = *app;
834 break;
835 }
836
837 case CODEC_G_JPEG_COM_DATA: { /* get comment marker data */
838 struct jpeg_com_marker *com = data;
839
840 if (size != sizeof(struct jpeg_com_marker))
841 return -EFAULT;
842
843 *com = ptr->com;
844 break;
845 }
846
847 case CODEC_S_JPEG_COM_DATA: { /* set comment marker data */
848 struct jpeg_com_marker *com = data;
849
850 if (size != sizeof(struct jpeg_com_marker))
851 return -EFAULT;
852
853 ptr->com = *com;
854 break;
855 }
856
857 default:
858 return -EINVAL;
859 }
860
861 return size;
862 }
863
864 /* =========================================================================
865 Exit and unregister function:
866
867 Deinitializes Zoran's JPEG processor
868 ========================================================================= */
869
870 static int
871 zr36060_unset (struct videocodec *codec)
872 {
873 struct zr36060 *ptr = codec->data;
874
875 if (ptr) {
876 /* do wee need some codec deinit here, too ???? */
877
878 dprintk(1, "%s: finished codec #%d\n", ptr->name,
879 ptr->num);
880 kfree(ptr);
881 codec->data = NULL;
882
883 zr36060_codecs--;
884 return 0;
885 }
886
887 return -EFAULT;
888 }
889
890 /* =========================================================================
891 Setup and registry function:
892
893 Initializes Zoran's JPEG processor
894
895 Also sets pixel size, average code size, mode (compr./decompr.)
896 (the given size is determined by the processor with the video interface)
897 ========================================================================= */
898
899 static int
900 zr36060_setup (struct videocodec *codec)
901 {
902 struct zr36060 *ptr;
903 int res;
904
905 dprintk(2, "zr36060: initializing MJPEG subsystem #%d.\n",
906 zr36060_codecs);
907
908 if (zr36060_codecs == MAX_CODECS) {
909 dprintk(1,
910 KERN_ERR "zr36060: Can't attach more codecs!\n");
911 return -ENOSPC;
912 }
913 //mem structure init
914 codec->data = ptr = kzalloc(sizeof(struct zr36060), GFP_KERNEL);
915 if (NULL == ptr) {
916 dprintk(1, KERN_ERR "zr36060: Can't get enough memory!\n");
917 return -ENOMEM;
918 }
919
920 snprintf(ptr->name, sizeof(ptr->name), "zr36060[%d]",
921 zr36060_codecs);
922 ptr->num = zr36060_codecs++;
923 ptr->codec = codec;
924
925 //testing
926 res = zr36060_basic_test(ptr);
927 if (res < 0) {
928 zr36060_unset(codec);
929 return res;
930 }
931 //final setup
932 memcpy(ptr->h_samp_ratio, zr36060_decimation_h, 8);
933 memcpy(ptr->v_samp_ratio, zr36060_decimation_v, 8);
934
935 ptr->bitrate_ctrl = 0; /* 0 or 1 - fixed file size flag
936 * (what is the difference?) */
937 ptr->mode = CODEC_DO_COMPRESSION;
938 ptr->width = 384;
939 ptr->height = 288;
940 ptr->total_code_vol = 16000; /* CHECKME */
941 ptr->real_code_vol = (ptr->total_code_vol * 6) >> 3;
942 ptr->max_block_vol = 240; /* CHECKME, was 120 is 240 */
943 ptr->scalefact = 0x100;
944 ptr->dri = 1; /* CHECKME, was 8 is 1 */
945
946 /* by default, no COM or APP markers - app should set those */
947 ptr->com.len = 0;
948 ptr->app.appn = 0;
949 ptr->app.len = 0;
950
951 zr36060_init(ptr);
952
953 dprintk(1, KERN_INFO "%s: codec attached and running\n",
954 ptr->name);
955
956 return 0;
957 }
958
959 static const struct videocodec zr36060_codec = {
960 .owner = THIS_MODULE,
961 .name = "zr36060",
962 .magic = 0L, // magic not used
963 .flags =
964 CODEC_FLAG_JPEG | CODEC_FLAG_HARDWARE | CODEC_FLAG_ENCODER |
965 CODEC_FLAG_DECODER | CODEC_FLAG_VFE,
966 .type = CODEC_TYPE_ZR36060,
967 .setup = zr36060_setup, // functionality
968 .unset = zr36060_unset,
969 .set_mode = zr36060_set_mode,
970 .set_video = zr36060_set_video,
971 .control = zr36060_control,
972 // others are not used
973 };
974
975 /* =========================================================================
976 HOOK IN DRIVER AS KERNEL MODULE
977 ========================================================================= */
978
979 static int __init
980 zr36060_init_module (void)
981 {
982 //dprintk(1, "zr36060 driver %s\n",ZR060_VERSION);
983 zr36060_codecs = 0;
984 return videocodec_register(&zr36060_codec);
985 }
986
987 static void __exit
988 zr36060_cleanup_module (void)
989 {
990 if (zr36060_codecs) {
991 dprintk(1,
992 "zr36060: something's wrong - %d codecs left somehow.\n",
993 zr36060_codecs);
994 }
995
996 /* however, we can't just stay alive */
997 videocodec_unregister(&zr36060_codec);
998 }
999
1000 module_init(zr36060_init_module);
1001 module_exit(zr36060_cleanup_module);
1002
1003 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@skynet.be>");
1004 MODULE_DESCRIPTION("Driver module for ZR36060 jpeg processors "
1005 ZR060_VERSION);
1006 MODULE_LICENSE("GPL");
CRIS linux kernel tree