]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | ||
1da177e4 LT |
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 | ||
d56410e0 | 37 | /* includes for structures and defines regarding video |
1da177e4 LT |
38 | #include<linux/videodev.h> */ |
39 | ||
40 | /* I/O commands, error codes */ | |
5634f2ec | 41 | #include <asm/io.h> |
1da177e4 LT |
42 | //#include<errno.h> |
43 | ||
44 | /* headerfile of this module */ | |
5634f2ec | 45 | #include "zr36060.h" |
1da177e4 LT |
46 | |
47 | /* codec io API */ | |
5634f2ec | 48 | #include "videocodec.h" |
1da177e4 LT |
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 */ | |
ff699e6b | 55 | static int zr36060_codecs; |
1da177e4 | 56 | |
ff699e6b | 57 | static int low_bitrate; |
1da177e4 LT |
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 */ | |
ff699e6b | 62 | static int debug; |
1da177e4 LT |
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); | |
8a59822f | 164 | if (i++ > 200000) { // 200ms, there is for sure something wrong!!! |
1da177e4 | 165 | dprintk(1, |
c84e6036 | 166 | "%s: timeout at wait_end (last status: 0x%02x)\n", |
1da177e4 LT |
167 | ptr->name, ptr->status); |
168 | break; | |
169 | } | |
170 | } | |
171 | } | |
172 | ||
173 | /* ========================================================================= | |
174 | Local helper function: | |
175 | ||
d56410e0 | 176 | basic test of "connectivity", writes/reads to/from memory the SOF marker |
1da177e4 LT |
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, | |
d56410e0 MCC |
211 | u16 startreg, |
212 | u16 len, | |
213 | const char *data) | |
1da177e4 LT |
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 | |
d56410e0 | 338 | of each color component */ |
1da177e4 LT |
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 | ||
d56410e0 MCC |
370 | /* SOS (start of scan) segment depends on the used scan components |
371 | of each color component */ | |
1da177e4 LT |
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) | | |
d56410e0 | 388 | zr36060_ta[i]; // AC/DC tbl.sel. |
1da177e4 LT |
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 | |
7408187d | 922 | codec->data = ptr = kzalloc(sizeof(struct zr36060), GFP_KERNEL); |
1da177e4 LT |
923 | if (NULL == ptr) { |
924 | dprintk(1, KERN_ERR "zr36060: Can't get enough memory!\n"); | |
925 | return -ENOMEM; | |
926 | } | |
1da177e4 LT |
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); | |
d56410e0 | 1002 | } |
1da177e4 LT |
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"); |