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