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