git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/zr36050.c

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