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/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");