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