1/*
2 * Zoran ZR36016 basic configuration functions
3 *
4 * Copyright (C) 2001 Wolfgang Scherr <scherr@net4you.at>
5 *
6 * $Id: zr36016.c,v 1.1.2.14 2003/08/20 19:46:55 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 ZR016_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/* v4l  API */
41
42/* headerfile of this module */
43#include "zr36016.h"
44
45/* codec io API */
46#include "videocodec.h"
47
48/* it doesn't make sense to have more than 20 or so,
49  just to prevent some unwanted loops */
50#define MAX_CODECS 20
51
52/* amount of chips attached via this driver */
53static int zr36016_codecs;
54
55/* debugging is available via module parameter */
56static int debug;
57module_param(debug, int, 0);
58MODULE_PARM_DESC(debug, "Debug level (0-4)");
59
60#define dprintk(num, format, args...) \
61	do { \
62		if (debug >= num) \
63			printk(format, ##args); \
64	} while (0)
65
66/* =========================================================================
67   Local hardware I/O functions:
68
69   read/write via codec layer (registers are located in the master device)
70   ========================================================================= */
71
72/* read and write functions */
73static u8
74zr36016_read (struct zr36016 *ptr,
75	      u16             reg)
76{
77	u8 value = 0;
78
79	// just in case something is wrong...
80	if (ptr->codec->master_data->readreg)
81		value =
82		    (ptr->codec->master_data->
83		     readreg(ptr->codec, reg)) & 0xFF;
84	else
85		dprintk(1,
86			KERN_ERR "%s: invalid I/O setup, nothing read!\n",
87			ptr->name);
88
89	dprintk(4, "%s: reading from 0x%04x: %02x\n", ptr->name, reg,
90		value);
91
92	return value;
93}
94
95static void
96zr36016_write (struct zr36016 *ptr,
97	       u16             reg,
98	       u8              value)
99{
100	dprintk(4, "%s: writing 0x%02x to 0x%04x\n", ptr->name, value,
101		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/* indirect read and write functions */
114/* the 016 supports auto-addr-increment, but
115 * writing it all time cost not much and is safer... */
116static u8
117zr36016_readi (struct zr36016 *ptr,
118	       u16             reg)
119{
120	u8 value = 0;
121
122	// just in case something is wrong...
123	if ((ptr->codec->master_data->writereg) &&
124	    (ptr->codec->master_data->readreg)) {
125		ptr->codec->master_data->writereg(ptr->codec, ZR016_IADDR, reg & 0x0F);	// ADDR
126		value = (ptr->codec->master_data->readreg(ptr->codec, ZR016_IDATA)) & 0xFF;	// DATA
127	} else
128		dprintk(1,
129			KERN_ERR
130			"%s: invalid I/O setup, nothing read (i)!\n",
131			ptr->name);
132
133	dprintk(4, "%s: reading indirect from 0x%04x: %02x\n", ptr->name,
134		reg, value);
135	return value;
136}
137
138static void
139zr36016_writei (struct zr36016 *ptr,
140		u16             reg,
141		u8              value)
142{
143	dprintk(4, "%s: writing indirect 0x%02x to 0x%04x\n", ptr->name,
144		value, reg);
145
146	// just in case something is wrong...
147	if (ptr->codec->master_data->writereg) {
148		ptr->codec->master_data->writereg(ptr->codec, ZR016_IADDR, reg & 0x0F);	// ADDR
149		ptr->codec->master_data->writereg(ptr->codec, ZR016_IDATA, value & 0x0FF);	// DATA
150	} else
151		dprintk(1,
152			KERN_ERR
153			"%s: invalid I/O setup, nothing written (i)!\n",
154			ptr->name);
155}
156
157/* =========================================================================
158   Local helper function:
159
160   version read
161   ========================================================================= */
162
163/* version kept in datastructure */
164static u8
165zr36016_read_version (struct zr36016 *ptr)
166{
167	ptr->version = zr36016_read(ptr, 0) >> 4;
168	return ptr->version;
169}
170
171/* =========================================================================
172   Local helper function:
173
174   basic test of "connectivity", writes/reads to/from PAX-Lo register
175   ========================================================================= */
176
177static int
178zr36016_basic_test (struct zr36016 *ptr)
179{
180	if (debug) {
181		int i;
182		zr36016_writei(ptr, ZR016I_PAX_LO, 0x55);
183		dprintk(1, KERN_INFO "%s: registers: ", ptr->name);
184		for (i = 0; i <= 0x0b; i++)
185			dprintk(1, "%02x ", zr36016_readi(ptr, i));
186		dprintk(1, "\n");
187	}
188	// for testing just write 0, then the default value to a register and read
189	// it back in both cases
190	zr36016_writei(ptr, ZR016I_PAX_LO, 0x00);
191	if (zr36016_readi(ptr, ZR016I_PAX_LO) != 0x0) {
192		dprintk(1,
193			KERN_ERR
194			"%s: attach failed, can't connect to vfe processor!\n",
195			ptr->name);
196		return -ENXIO;
197	}
198	zr36016_writei(ptr, ZR016I_PAX_LO, 0x0d0);
199	if (zr36016_readi(ptr, ZR016I_PAX_LO) != 0x0d0) {
200		dprintk(1,
201			KERN_ERR
202			"%s: attach failed, can't connect to vfe processor!\n",
203			ptr->name);
204		return -ENXIO;
205	}
206	// we allow version numbers from 0-3, should be enough, though
207	zr36016_read_version(ptr);
208	if (ptr->version & 0x0c) {
209		dprintk(1,
210			KERN_ERR
211			"%s: attach failed, suspicious version %d found...\n",
212			ptr->name, ptr->version);
213		return -ENXIO;
214	}
215
216	return 0;		/* looks good! */
217}
218
219/* =========================================================================
220   Local helper function:
221
222   simple loop for pushing the init datasets - NO USE --
223   ========================================================================= */
224
225#if 0
226static int zr36016_pushit (struct zr36016 *ptr,
227			   u16             startreg,
228			   u16             len,
229			   const char     *data)
230{
231	int i=0;
232
233	dprintk(4, "%s: write data block to 0x%04x (len=%d)\n",
234		ptr->name, startreg,len);
235	while (i<len) {
236		zr36016_writei(ptr, startreg++,  data[i++]);
237	}
238
239	return i;
240}
241#endif
242
243/* =========================================================================
244   Basic datasets & init:
245
246   //TODO//
247   ========================================================================= */
248
249// needed offset values          PAL NTSC SECAM
250static const int zr016_xoff[] = { 20, 20, 20 };
251static const int zr016_yoff[] = { 8, 9, 7 };
252
253static void
254zr36016_init (struct zr36016 *ptr)
255{
256	// stop any processing
257	zr36016_write(ptr, ZR016_GOSTOP, 0);
258
259	// mode setup (yuv422 in and out, compression/expansuon due to mode)
260	zr36016_write(ptr, ZR016_MODE,
261		      ZR016_YUV422 | ZR016_YUV422_YUV422 |
262		      (ptr->mode == CODEC_DO_COMPRESSION ?
263		       ZR016_COMPRESSION : ZR016_EXPANSION));
264
265	// misc setup
266	zr36016_writei(ptr, ZR016I_SETUP1,
267		       (ptr->xdec ? (ZR016_HRFL | ZR016_HORZ) : 0) |
268		       (ptr->ydec ? ZR016_VERT : 0) | ZR016_CNTI);
269	zr36016_writei(ptr, ZR016I_SETUP2, ZR016_CCIR);
270
271	// Window setup
272	// (no extra offset for now, norm defines offset, default width height)
273	zr36016_writei(ptr, ZR016I_PAX_HI, ptr->width >> 8);
274	zr36016_writei(ptr, ZR016I_PAX_LO, ptr->width & 0xFF);
275	zr36016_writei(ptr, ZR016I_PAY_HI, ptr->height >> 8);
276	zr36016_writei(ptr, ZR016I_PAY_LO, ptr->height & 0xFF);
277	zr36016_writei(ptr, ZR016I_NAX_HI, ptr->xoff >> 8);
278	zr36016_writei(ptr, ZR016I_NAX_LO, ptr->xoff & 0xFF);
279	zr36016_writei(ptr, ZR016I_NAY_HI, ptr->yoff >> 8);
280	zr36016_writei(ptr, ZR016I_NAY_LO, ptr->yoff & 0xFF);
281
282	/* shall we continue now, please? */
283	zr36016_write(ptr, ZR016_GOSTOP, 1);
284}
285
286/* =========================================================================
287   CODEC API FUNCTIONS
288
289   this functions are accessed by the master via the API structure
290   ========================================================================= */
291
292/* set compression/expansion mode and launches codec -
293   this should be the last call from the master before starting processing */
294static int
295zr36016_set_mode (struct videocodec *codec,
296		  int                mode)
297{
298	struct zr36016 *ptr = (struct zr36016 *) codec->data;
299
300	dprintk(2, "%s: set_mode %d call\n", ptr->name, mode);
301
302	if ((mode != CODEC_DO_EXPANSION) && (mode != CODEC_DO_COMPRESSION))
303		return -EINVAL;
304
305	ptr->mode = mode;
306	zr36016_init(ptr);
307
308	return 0;
309}
310
311/* set picture size */
312static int
313zr36016_set_video (struct videocodec   *codec,
314		   struct tvnorm       *norm,
315		   struct vfe_settings *cap,
316		   struct vfe_polarity *pol)
317{
318	struct zr36016 *ptr = (struct zr36016 *) codec->data;
319
320	dprintk(2, "%s: set_video %d.%d, %d/%d-%dx%d (0x%x) call\n",
321		ptr->name, norm->HStart, norm->VStart,
322		cap->x, cap->y, cap->width, cap->height,
323		cap->decimation);
324
325	/* if () return -EINVAL;
326	 * trust the master driver that it knows what it does - so
327	 * we allow invalid startx/y for now ... */
328	ptr->width = cap->width;
329	ptr->height = cap->height;
330	/* (Ronald) This is ugly. zoran_device.c, line 387
331	 * already mentions what happens if HStart is even
332	 * (blue faces, etc., cr/cb inversed). There's probably
333	 * some good reason why HStart is 0 instead of 1, so I'm
334	 * leaving it to this for now, but really... This can be
335	 * done a lot simpler */
336	ptr->xoff = (norm->HStart ? norm->HStart : 1) + cap->x;
337	/* Something to note here (I don't understand it), setting
338	 * VStart too high will cause the codec to 'not work'. I
339	 * really don't get it. values of 16 (VStart) already break
340	 * it here. Just '0' seems to work. More testing needed! */
341	ptr->yoff = norm->VStart + cap->y;
342	/* (Ronald) dzjeeh, can't this thing do hor_decimation = 4? */
343	ptr->xdec = ((cap->decimation & 0xff) == 1) ? 0 : 1;
344	ptr->ydec = (((cap->decimation >> 8) & 0xff) == 1) ? 0 : 1;
345
346	return 0;
347}
348
349/* additional control functions */
350static int
351zr36016_control (struct videocodec *codec,
352		 int                type,
353		 int                size,
354		 void              *data)
355{
356	struct zr36016 *ptr = (struct zr36016 *) codec->data;
357	int *ival = (int *) data;
358
359	dprintk(2, "%s: control %d call with %d byte\n", ptr->name, type,
360		size);
361
362	switch (type) {
363	case CODEC_G_STATUS:	/* get last status - we don't know it ... */
364		if (size != sizeof(int))
365			return -EFAULT;
366		*ival = 0;
367		break;
368
369	case CODEC_G_CODEC_MODE:
370		if (size != sizeof(int))
371			return -EFAULT;
372		*ival = 0;
373		break;
374
375	case CODEC_S_CODEC_MODE:
376		if (size != sizeof(int))
377			return -EFAULT;
378		if (*ival != 0)
379			return -EINVAL;
380		/* not needed, do nothing */
381		return 0;
382
383	case CODEC_G_VFE:
384	case CODEC_S_VFE:
385		return 0;
386
387	case CODEC_S_MMAP:
388		/* not available, give an error */
389		return -ENXIO;
390
391	default:
392		return -EINVAL;
393	}
394
395	return size;
396}
397
398/* =========================================================================
399   Exit and unregister function:
400
401   Deinitializes Zoran's JPEG processor
402   ========================================================================= */
403
404static int
405zr36016_unset (struct videocodec *codec)
406{
407	struct zr36016 *ptr = codec->data;
408
409	if (ptr) {
410		/* do wee need some codec deinit here, too ???? */
411
412		dprintk(1, "%s: finished codec #%d\n", ptr->name,
413			ptr->num);
414		kfree(ptr);
415		codec->data = NULL;
416
417		zr36016_codecs--;
418		return 0;
419	}
420
421	return -EFAULT;
422}
423
424/* =========================================================================
425   Setup and registry function:
426
427   Initializes Zoran's JPEG processor
428
429   Also sets pixel size, average code size, mode (compr./decompr.)
430   (the given size is determined by the processor with the video interface)
431   ========================================================================= */
432
433static int
434zr36016_setup (struct videocodec *codec)
435{
436	struct zr36016 *ptr;
437	int res;
438
439	dprintk(2, "zr36016: initializing VFE subsystem #%d.\n",
440		zr36016_codecs);
441
442	if (zr36016_codecs == MAX_CODECS) {
443		dprintk(1,
444			KERN_ERR "zr36016: Can't attach more codecs!\n");
445		return -ENOSPC;
446	}
447	//mem structure init
448	codec->data = ptr = kzalloc(sizeof(struct zr36016), GFP_KERNEL);
449	if (NULL == ptr) {
450		dprintk(1, KERN_ERR "zr36016: Can't get enough memory!\n");
451		return -ENOMEM;
452	}
453
454	snprintf(ptr->name, sizeof(ptr->name), "zr36016[%d]",
455		 zr36016_codecs);
456	ptr->num = zr36016_codecs++;
457	ptr->codec = codec;
458
459	//testing
460	res = zr36016_basic_test(ptr);
461	if (res < 0) {
462		zr36016_unset(codec);
463		return res;
464	}
465	//final setup
466	ptr->mode = CODEC_DO_COMPRESSION;
467	ptr->width = 768;
468	ptr->height = 288;
469	ptr->xdec = 1;
470	ptr->ydec = 0;
471	zr36016_init(ptr);
472
473	dprintk(1, KERN_INFO "%s: codec v%d attached and running\n",
474		ptr->name, ptr->version);
475
476	return 0;
477}
478
479static const struct videocodec zr36016_codec = {
480	.owner = THIS_MODULE,
481	.name = "zr36016",
482	.magic = 0L,		// magic not used
483	.flags =
484	    CODEC_FLAG_HARDWARE | CODEC_FLAG_VFE | CODEC_FLAG_ENCODER |
485	    CODEC_FLAG_DECODER,
486	.type = CODEC_TYPE_ZR36016,
487	.setup = zr36016_setup,	// functionality
488	.unset = zr36016_unset,
489	.set_mode = zr36016_set_mode,
490	.set_video = zr36016_set_video,
491	.control = zr36016_control,
492	// others are not used
493};
494
495/* =========================================================================
496   HOOK IN DRIVER AS KERNEL MODULE
497   ========================================================================= */
498
499static int __init
500zr36016_init_module (void)
501{
502	//dprintk(1, "ZR36016 driver %s\n",ZR016_VERSION);
503	zr36016_codecs = 0;
504	return videocodec_register(&zr36016_codec);
505}
506
507static void __exit
508zr36016_cleanup_module (void)
509{
510	if (zr36016_codecs) {
511		dprintk(1,
512			"zr36016: something's wrong - %d codecs left somehow.\n",
513			zr36016_codecs);
514	}
515	videocodec_unregister(&zr36016_codec);
516}
517
518module_init(zr36016_init_module);
519module_exit(zr36016_cleanup_module);
520
521MODULE_AUTHOR("Wolfgang Scherr <scherr@net4you.at>");
522MODULE_DESCRIPTION("Driver module for ZR36016 video frontends "
523		   ZR016_VERSION);
524MODULE_LICENSE("GPL");
525