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