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