drivers/media/dvb/ttpci/av7110_hw.c

   1 /*
   2  * av7110_hw.c: av7110 low level hardware access and firmware interface
   3  *
   4  * Copyright (C) 1999-2002 Ralph  Metzler
   5  *                       & Marcus Metzler for convergence integrated media GmbH
   6  *
   7  * originally based on code by:
   8  * Copyright (C) 1998,1999 Christian Theiss <mistert@rz.fh-augsburg.de>
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
  24  *
  25  * the project's page is at http://www.linuxtv.org/dvb/
  26  */
  27
  28 /* for debugging ARM communication: */
  29 //#define COM_DEBUG
  30
  31 #include <stdarg.h>
  32 #include <linux/types.h>
  33 #include <linux/kernel.h>
  34 #include <linux/string.h>
  35 #include <linux/sched.h>
  36 #include <linux/delay.h>
  37 #include <linux/byteorder/swabb.h>
  38 #include <linux/smp_lock.h>
  39 #include <linux/fs.h>
  40
  41 #include "av7110.h"
  42 #include "av7110_hw.h"
  43
  44 #define _NOHANDSHAKE
  45
  46 /****************************************************************************
  47  * DEBI functions
  48  ****************************************************************************/
  49
  50 /* This DEBI code is based on the Stradis driver
  51    by Nathan Laredo <laredo@gnu.org> */
  52
  53 int av7110_debiwrite(struct av7110 *av7110, u32 config,
  54                      int addr, u32 val, int count)
  55 {
  56         struct saa7146_dev *dev = av7110->dev;
  57
  58         if (count <= 0 || count > 32764) {
  59                 printk("%s: invalid count %d\n", __FUNCTION__, count);
  60                 return -1;
  61         }
  62         if (saa7146_wait_for_debi_done(av7110->dev, 0) < 0) {
  63                 printk("%s: wait_for_debi_done failed\n", __FUNCTION__);
  64                 return -1;
  65         }
  66         saa7146_write(dev, DEBI_CONFIG, config);
  67         if (count <= 4)         /* immediate transfer */
  68                 saa7146_write(dev, DEBI_AD, val);
  69         else                    /* block transfer */
  70                 saa7146_write(dev, DEBI_AD, av7110->debi_bus);
  71         saa7146_write(dev, DEBI_COMMAND, (count << 17) | (addr & 0xffff));
  72         saa7146_write(dev, MC2, (2 << 16) | 2);
  73         return 0;
  74 }
  75
  76 u32 av7110_debiread(struct av7110 *av7110, u32 config, int addr, int count)
  77 {
  78         struct saa7146_dev *dev = av7110->dev;
  79         u32 result = 0;
  80
  81         if (count > 32764 || count <= 0) {
  82                 printk("%s: invalid count %d\n", __FUNCTION__, count);
  83                 return 0;
  84         }
  85         if (saa7146_wait_for_debi_done(av7110->dev, 0) < 0) {
  86                 printk("%s: wait_for_debi_done #1 failed\n", __FUNCTION__);
  87                 return 0;
  88         }
  89         saa7146_write(dev, DEBI_AD, av7110->debi_bus);
  90         saa7146_write(dev, DEBI_COMMAND, (count << 17) | 0x10000 | (addr & 0xffff));
  91
  92         saa7146_write(dev, DEBI_CONFIG, config);
  93         saa7146_write(dev, MC2, (2 << 16) | 2);
  94         if (count > 4)
  95                 return count;
  96         if (saa7146_wait_for_debi_done(av7110->dev, 0) < 0) {
  97                 printk("%s: wait_for_debi_done #2 failed\n", __FUNCTION__);
  98                 return 0;
  99         }
 100
 101         result = saa7146_read(dev, DEBI_AD);
 102         result &= (0xffffffffUL >> ((4 - count) * 8));
 103         return result;
 104 }
 105
 106
 107
 108 /* av7110 ARM core boot stuff */
 109 #if 0
 110 void av7110_reset_arm(struct av7110 *av7110)
 111 {
 112         saa7146_setgpio(av7110->dev, RESET_LINE, SAA7146_GPIO_OUTLO);
 113
 114         /* Disable DEBI and GPIO irq */
 115         SAA7146_IER_DISABLE(av7110->dev, MASK_19 | MASK_03);
 116         SAA7146_ISR_CLEAR(av7110->dev, MASK_19 | MASK_03);
 117
 118         saa7146_setgpio(av7110->dev, RESET_LINE, SAA7146_GPIO_OUTHI);
 119         msleep(30);     /* the firmware needs some time to initialize */
 120
 121         ARM_ResetMailBox(av7110);
 122
 123         SAA7146_ISR_CLEAR(av7110->dev, MASK_19 | MASK_03);
 124         SAA7146_IER_ENABLE(av7110->dev, MASK_03);
 125
 126         av7110->arm_ready = 1;
 127         dprintk(1, "reset ARM\n");
 128 }
 129 #endif  /*  0  */
 130
 131 static int waitdebi(struct av7110 *av7110, int adr, int state)
 132 {
 133         int k;
 134
 135         dprintk(4, "%p\n", av7110);
 136
 137         for (k = 0; k < 100; k++) {
 138                 if (irdebi(av7110, DEBINOSWAP, adr, 0, 2) == state)
 139                         return 0;
 140                 udelay(5);
 141         }
 142         return -ETIMEDOUT;
 143 }
 144
 145 static int load_dram(struct av7110 *av7110, u32 *data, int len)
 146 {
 147         int i;
 148         int blocks, rest;
 149         u32 base, bootblock = AV7110_BOOT_BLOCK;
 150
 151         dprintk(4, "%p\n", av7110);
 152
 153         blocks = len / AV7110_BOOT_MAX_SIZE;
 154         rest = len % AV7110_BOOT_MAX_SIZE;
 155         base = DRAM_START_CODE;
 156
 157         for (i = 0; i < blocks; i++) {
 158                 if (waitdebi(av7110, AV7110_BOOT_STATE, BOOTSTATE_BUFFER_EMPTY) < 0) {
 159                         printk(KERN_ERR "dvb-ttpci: load_dram(): timeout at block %d\n", i);
 160                         return -ETIMEDOUT;
 161                 }
 162                 dprintk(4, "writing DRAM block %d\n", i);
 163                 mwdebi(av7110, DEBISWAB, bootblock,
 164                        ((char*)data) + i * AV7110_BOOT_MAX_SIZE, AV7110_BOOT_MAX_SIZE);
 165                 bootblock ^= 0x1400;
 166                 iwdebi(av7110, DEBISWAB, AV7110_BOOT_BASE, swab32(base), 4);
 167                 iwdebi(av7110, DEBINOSWAP, AV7110_BOOT_SIZE, AV7110_BOOT_MAX_SIZE, 2);
 168                 iwdebi(av7110, DEBINOSWAP, AV7110_BOOT_STATE, BOOTSTATE_BUFFER_FULL, 2);
 169                 base += AV7110_BOOT_MAX_SIZE;
 170         }
 171
 172         if (rest > 0) {
 173                 if (waitdebi(av7110, AV7110_BOOT_STATE, BOOTSTATE_BUFFER_EMPTY) < 0) {
 174                         printk(KERN_ERR "dvb-ttpci: load_dram(): timeout at last block\n");
 175                         return -ETIMEDOUT;
 176                 }
 177                 if (rest > 4)
 178                         mwdebi(av7110, DEBISWAB, bootblock,
 179                                ((char*)data) + i * AV7110_BOOT_MAX_SIZE, rest);
 180                 else
 181                         mwdebi(av7110, DEBISWAB, bootblock,
 182                                ((char*)data) + i * AV7110_BOOT_MAX_SIZE - 4, rest + 4);
 183
 184                 iwdebi(av7110, DEBISWAB, AV7110_BOOT_BASE, swab32(base), 4);
 185                 iwdebi(av7110, DEBINOSWAP, AV7110_BOOT_SIZE, rest, 2);
 186                 iwdebi(av7110, DEBINOSWAP, AV7110_BOOT_STATE, BOOTSTATE_BUFFER_FULL, 2);
 187         }
 188         if (waitdebi(av7110, AV7110_BOOT_STATE, BOOTSTATE_BUFFER_EMPTY) < 0) {
 189                 printk(KERN_ERR "dvb-ttpci: load_dram(): timeout after last block\n");
 190                 return -ETIMEDOUT;
 191         }
 192         iwdebi(av7110, DEBINOSWAP, AV7110_BOOT_SIZE, 0, 2);
 193         iwdebi(av7110, DEBINOSWAP, AV7110_BOOT_STATE, BOOTSTATE_BUFFER_FULL, 2);
 194         if (waitdebi(av7110, AV7110_BOOT_STATE, BOOTSTATE_AV7110_BOOT_COMPLETE) < 0) {
 195                 printk(KERN_ERR "dvb-ttpci: load_dram(): final handshake timeout\n");
 196                 return -ETIMEDOUT;
 197         }
 198         return 0;
 199 }
 200
 201
 202 /* we cannot write av7110 DRAM directly, so load a bootloader into
 203  * the DPRAM which implements a simple boot protocol */
 204 static u8 bootcode[] = {
 205   0xea, 0x00, 0x00, 0x0e, 0xe1, 0xb0, 0xf0, 0x0e, 0xe2, 0x5e, 0xf0, 0x04,
 206   0xe2, 0x5e, 0xf0, 0x04, 0xe2, 0x5e, 0xf0, 0x08, 0xe2, 0x5e, 0xf0, 0x04,
 207   0xe2, 0x5e, 0xf0, 0x04, 0xe2, 0x5e, 0xf0, 0x04, 0x2c, 0x00, 0x00, 0x24,
 208   0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x34,
 209   0x00, 0x00, 0x00, 0x00, 0xa5, 0xa5, 0x5a, 0x5a, 0x00, 0x1f, 0x15, 0x55,
 210   0x00, 0x00, 0x00, 0x09, 0xe5, 0x9f, 0xd0, 0x7c, 0xe5, 0x9f, 0x40, 0x74,
 211   0xe3, 0xa0, 0x00, 0x00, 0xe5, 0x84, 0x00, 0x00, 0xe5, 0x84, 0x00, 0x04,
 212   0xe5, 0x9f, 0x10, 0x70, 0xe5, 0x9f, 0x20, 0x70, 0xe5, 0x9f, 0x30, 0x64,
 213   0xe8, 0xb1, 0x1f, 0xe0, 0xe8, 0xa3, 0x1f, 0xe0, 0xe1, 0x51, 0x00, 0x02,
 214   0xda, 0xff, 0xff, 0xfb, 0xe5, 0x9f, 0xf0, 0x50, 0xe1, 0xd4, 0x10, 0xb0,
 215   0xe3, 0x51, 0x00, 0x00, 0x0a, 0xff, 0xff, 0xfc, 0xe1, 0xa0, 0x10, 0x0d,
 216   0xe5, 0x94, 0x30, 0x04, 0xe1, 0xd4, 0x20, 0xb2, 0xe2, 0x82, 0x20, 0x3f,
 217   0xe1, 0xb0, 0x23, 0x22, 0x03, 0xa0, 0x00, 0x02, 0xe1, 0xc4, 0x00, 0xb0,
 218   0x0a, 0xff, 0xff, 0xf4, 0xe8, 0xb1, 0x1f, 0xe0, 0xe8, 0xa3, 0x1f, 0xe0,
 219   0xe8, 0xb1, 0x1f, 0xe0, 0xe8, 0xa3, 0x1f, 0xe0, 0xe2, 0x52, 0x20, 0x01,
 220   0x1a, 0xff, 0xff, 0xf9, 0xe2, 0x2d, 0xdb, 0x05, 0xea, 0xff, 0xff, 0xec,
 221   0x2c, 0x00, 0x03, 0xf8, 0x2c, 0x00, 0x04, 0x00, 0x9e, 0x00, 0x08, 0x00,
 222   0x2c, 0x00, 0x00, 0x74, 0x2c, 0x00, 0x00, 0xc0
 223 };
 224
 225 int av7110_bootarm(struct av7110 *av7110)
 226 {
 227         struct saa7146_dev *dev = av7110->dev;
 228         u32 ret;
 229         int i;
 230
 231         dprintk(4, "%p\n", av7110);
 232
 233         av7110->arm_ready = 0;
 234
 235         saa7146_setgpio(dev, RESET_LINE, SAA7146_GPIO_OUTLO);
 236
 237         /* Disable DEBI and GPIO irq */
 238         SAA7146_IER_DISABLE(av7110->dev, MASK_03 | MASK_19);
 239         SAA7146_ISR_CLEAR(av7110->dev, MASK_19 | MASK_03);
 240
 241         /* enable DEBI */
 242         saa7146_write(av7110->dev, MC1, 0x08800880);
 243         saa7146_write(av7110->dev, DD1_STREAM_B, 0x00000000);
 244         saa7146_write(av7110->dev, MC2, (MASK_09 | MASK_25 | MASK_10 | MASK_26));
 245
 246         /* test DEBI */
 247         iwdebi(av7110, DEBISWAP, DPRAM_BASE, 0x76543210, 4);
 248         /* FIXME: Why does Nexus CA require 2x iwdebi for first init? */
 249         iwdebi(av7110, DEBISWAP, DPRAM_BASE, 0x76543210, 4);
 250
 251         if ((ret=irdebi(av7110, DEBINOSWAP, DPRAM_BASE, 0, 4)) != 0x10325476) {
 252                 printk(KERN_ERR "dvb-ttpci: debi test in av7110_bootarm() failed: "
 253                        "%08x != %08x (check your BIOS 'Plug&Play OS' settings)\n",
 254                        ret, 0x10325476);
 255                 return -1;
 256         }
 257         for (i = 0; i < 8192; i += 4)
 258                 iwdebi(av7110, DEBISWAP, DPRAM_BASE + i, 0x00, 4);
 259         dprintk(2, "debi test OK\n");
 260
 261         /* boot */
 262         dprintk(1, "load boot code\n");
 263         saa7146_setgpio(dev, ARM_IRQ_LINE, SAA7146_GPIO_IRQLO);
 264         //saa7146_setgpio(dev, DEBI_DONE_LINE, SAA7146_GPIO_INPUT);
 265         //saa7146_setgpio(dev, 3, SAA7146_GPIO_INPUT);
 266
 267         mwdebi(av7110, DEBISWAB, DPRAM_BASE, bootcode, sizeof(bootcode));
 268         iwdebi(av7110, DEBINOSWAP, AV7110_BOOT_STATE, BOOTSTATE_BUFFER_FULL, 2);
 269
 270         if (saa7146_wait_for_debi_done(av7110->dev, 1)) {
 271                 printk(KERN_ERR "dvb-ttpci: av7110_bootarm(): "
 272                        "saa7146_wait_for_debi_done() timed out\n");
 273                 return -ETIMEDOUT;
 274         }
 275         saa7146_setgpio(dev, RESET_LINE, SAA7146_GPIO_OUTHI);
 276         mdelay(1);
 277
 278         dprintk(1, "load dram code\n");
 279         if (load_dram(av7110, (u32 *)av7110->bin_root, av7110->size_root) < 0) {
 280                 printk(KERN_ERR "dvb-ttpci: av7110_bootarm(): "
 281                        "load_dram() failed\n");
 282                 return -1;
 283         }
 284
 285         saa7146_setgpio(dev, RESET_LINE, SAA7146_GPIO_OUTLO);
 286         mdelay(1);
 287
 288         dprintk(1, "load dpram code\n");
 289         mwdebi(av7110, DEBISWAB, DPRAM_BASE, av7110->bin_dpram, av7110->size_dpram);
 290
 291         if (saa7146_wait_for_debi_done(av7110->dev, 1)) {
 292                 printk(KERN_ERR "dvb-ttpci: av7110_bootarm(): "
 293                        "saa7146_wait_for_debi_done() timed out after loading DRAM\n");
 294                 return -ETIMEDOUT;
 295         }
 296         saa7146_setgpio(dev, RESET_LINE, SAA7146_GPIO_OUTHI);
 297         msleep(30);     /* the firmware needs some time to initialize */
 298
 299         //ARM_ClearIrq(av7110);
 300         ARM_ResetMailBox(av7110);
 301         SAA7146_ISR_CLEAR(av7110->dev, MASK_19 | MASK_03);
 302         SAA7146_IER_ENABLE(av7110->dev, MASK_03);
 303
 304         av7110->arm_errors = 0;
 305         av7110->arm_ready = 1;
 306         return 0;
 307 }
 308
 309
 310 /****************************************************************************
 311  * DEBI command polling
 312  ****************************************************************************/
 313
 314 int av7110_wait_msgstate(struct av7110 *av7110, u16 flags)
 315 {
 316         unsigned long start;
 317         u32 stat;
 318         int err;
 319
 320         if (FW_VERSION(av7110->arm_app) <= 0x261c) {
 321                 /* not supported by old firmware */
 322                 msleep(50);
 323                 return 0;
 324         }
 325
 326         /* new firmware */
 327         start = jiffies;
 328         for (;;) {
 329                 err = time_after(jiffies, start + ARM_WAIT_FREE);
 330                 if (down_interruptible(&av7110->dcomlock))
 331                         return -ERESTARTSYS;
 332                 stat = rdebi(av7110, DEBINOSWAP, MSGSTATE, 0, 2);
 333                 up(&av7110->dcomlock);
 334                 if ((stat & flags) == 0)
 335                         break;
 336                 if (err) {
 337                         printk(KERN_ERR "%s: timeout waiting for MSGSTATE %04x\n",
 338                                 __FUNCTION__, stat & flags);
 339                         return -ETIMEDOUT;
 340                 }
 341                 msleep(1);
 342         }
 343         return 0;
 344 }
 345
 346 static int __av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
 347 {
 348         int i;
 349         unsigned long start;
 350         char *type = NULL;
 351         u16 flags[2] = {0, 0};
 352         u32 stat;
 353         int err;
 354
 355 //      dprintk(4, "%p\n", av7110);
 356
 357         if (!av7110->arm_ready) {
 358                 dprintk(1, "arm not ready.\n");
 359                 return -ENXIO;
 360         }
 361
 362         start = jiffies;
 363         while (1) {
 364                 err = time_after(jiffies, start + ARM_WAIT_FREE);
 365                 if (rdebi(av7110, DEBINOSWAP, COMMAND, 0, 2) == 0)
 366                         break;
 367                 if (err) {
 368                         printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for COMMAND idle\n", __FUNCTION__);
 369                         av7110->arm_errors++;
 370                         return -ETIMEDOUT;
 371                 }
 372                 msleep(1);
 373         }
 374
 375         if (FW_VERSION(av7110->arm_app) <= 0x261f)
 376                 wdebi(av7110, DEBINOSWAP, COM_IF_LOCK, 0xffff, 2);
 377
 378 #ifndef _NOHANDSHAKE
 379         start = jiffies;
 380         while (1) {
 381                 err = time_after(jiffies, start + ARM_WAIT_SHAKE);
 382                 if (rdebi(av7110, DEBINOSWAP, HANDSHAKE_REG, 0, 2) == 0)
 383                         break;
 384                 if (err) {
 385                         printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for HANDSHAKE_REG\n", __FUNCTION__);
 386                         return -ETIMEDOUT;
 387                 }
 388                 msleep(1);
 389         }
 390 #endif
 391
 392         switch ((buf[0] >> 8) & 0xff) {
 393         case COMTYPE_PIDFILTER:
 394         case COMTYPE_ENCODER:
 395         case COMTYPE_REC_PLAY:
 396         case COMTYPE_MPEGDECODER:
 397                 type = "MSG";
 398                 flags[0] = GPMQOver;
 399                 flags[1] = GPMQFull;
 400                 break;
 401         case COMTYPE_OSD:
 402                 type = "OSD";
 403                 flags[0] = OSDQOver;
 404                 flags[1] = OSDQFull;
 405                 break;
 406         case COMTYPE_MISC:
 407                 if (FW_VERSION(av7110->arm_app) >= 0x261d) {
 408                         type = "MSG";
 409                         flags[0] = GPMQOver;
 410                         flags[1] = GPMQBusy;
 411                 }
 412                 break;
 413         default:
 414                 break;
 415         }
 416
 417         if (type != NULL) {
 418                 /* non-immediate COMMAND type */
 419                 start = jiffies;
 420                 for (;;) {
 421                         err = time_after(jiffies, start + ARM_WAIT_FREE);
 422                         stat = rdebi(av7110, DEBINOSWAP, MSGSTATE, 0, 2);
 423                         if (stat & flags[0]) {
 424                                 printk(KERN_ERR "%s: %s QUEUE overflow\n",
 425                                         __FUNCTION__, type);
 426                                 return -1;
 427                         }
 428                         if ((stat & flags[1]) == 0)
 429                                 break;
 430                         if (err) {
 431                                 printk(KERN_ERR "%s: timeout waiting on busy %s QUEUE\n",
 432                                         __FUNCTION__, type);
 433                                 return -ETIMEDOUT;
 434                         }
 435                         msleep(1);
 436                 }
 437         }
 438
 439         for (i = 2; i < length; i++)
 440                 wdebi(av7110, DEBINOSWAP, COMMAND + 2 * i, (u32) buf[i], 2);
 441
 442         if (length)
 443                 wdebi(av7110, DEBINOSWAP, COMMAND + 2, (u32) buf[1], 2);
 444         else
 445                 wdebi(av7110, DEBINOSWAP, COMMAND + 2, 0, 2);
 446
 447         wdebi(av7110, DEBINOSWAP, COMMAND, (u32) buf[0], 2);
 448
 449         if (FW_VERSION(av7110->arm_app) <= 0x261f)
 450                 wdebi(av7110, DEBINOSWAP, COM_IF_LOCK, 0x0000, 2);
 451
 452 #ifdef COM_DEBUG
 453         start = jiffies;
 454         while (1) {
 455                 err = time_after(jiffies, start + ARM_WAIT_FREE);
 456                 if (rdebi(av7110, DEBINOSWAP, COMMAND, 0, 2) == 0)
 457                         break;
 458                 if (err) {
 459                         printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for COMMAND %d to complete\n",
 460                                __FUNCTION__, (buf[0] >> 8) & 0xff);
 461                         return -ETIMEDOUT;
 462                 }
 463                 msleep(1);
 464         }
 465
 466         stat = rdebi(av7110, DEBINOSWAP, MSGSTATE, 0, 2);
 467         if (stat & GPMQOver) {
 468                 printk(KERN_ERR "dvb-ttpci: %s(): GPMQOver\n", __FUNCTION__);
 469                 return -ENOSPC;
 470         }
 471         else if (stat & OSDQOver) {
 472                 printk(KERN_ERR "dvb-ttpci: %s(): OSDQOver\n", __FUNCTION__);
 473                 return -ENOSPC;
 474         }
 475 #endif
 476
 477         return 0;
 478 }
 479
 480 static int av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
 481 {
 482         int ret;
 483
 484 //      dprintk(4, "%p\n", av7110);
 485
 486         if (!av7110->arm_ready) {
 487                 dprintk(1, "arm not ready.\n");
 488                 return -1;
 489         }
 490         if (down_interruptible(&av7110->dcomlock))
 491                 return -ERESTARTSYS;
 492
 493         ret = __av7110_send_fw_cmd(av7110, buf, length);
 494         up(&av7110->dcomlock);
 495         if (ret && ret!=-ERESTARTSYS)
 496                 printk(KERN_ERR "dvb-ttpci: %s(): av7110_send_fw_cmd error %d\n",
 497                        __FUNCTION__, ret);
 498         return ret;
 499 }
 500
 501 int av7110_fw_cmd(struct av7110 *av7110, int type, int com, int num, ...)
 502 {
 503         va_list args;
 504         u16 buf[num + 2];
 505         int i, ret;
 506
 507 //      dprintk(4, "%p\n", av7110);
 508
 509         buf[0] = ((type << 8) | com);
 510         buf[1] = num;
 511
 512         if (num) {
 513                 va_start(args, num);
 514                 for (i = 0; i < num; i++)
 515                         buf[i + 2] = va_arg(args, u32);
 516                 va_end(args);
 517         }
 518
 519         ret = av7110_send_fw_cmd(av7110, buf, num + 2);
 520         if (ret && ret != -ERESTARTSYS)
 521                 printk(KERN_ERR "dvb-ttpci: av7110_fw_cmd error %d\n", ret);
 522         return ret;
 523 }
 524
 525 #if 0
 526 int av7110_send_ci_cmd(struct av7110 *av7110, u8 subcom, u8 *buf, u8 len)
 527 {
 528         int i, ret;
 529         u16 cmd[18] = { ((COMTYPE_COMMON_IF << 8) + subcom),
 530                 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 531
 532         dprintk(4, "%p\n", av7110);
 533
 534         for(i = 0; i < len && i < 32; i++)
 535         {
 536                 if(i % 2 == 0)
 537                         cmd[(i / 2) + 2] = (u16)(buf[i]) << 8;
 538                 else
 539                         cmd[(i / 2) + 2] |= buf[i];
 540         }
 541
 542         ret = av7110_send_fw_cmd(av7110, cmd, 18);
 543         if (ret && ret != -ERESTARTSYS)
 544                 printk(KERN_ERR "dvb-ttpci: av7110_send_ci_cmd error %d\n", ret);
 545         return ret;
 546 }
 547 #endif  /*  0  */
 548
 549 int av7110_fw_request(struct av7110 *av7110, u16 *request_buf,
 550                       int request_buf_len, u16 *reply_buf, int reply_buf_len)
 551 {
 552         int err;
 553         s16 i;
 554         unsigned long start;
 555 #ifdef COM_DEBUG
 556         u32 stat;
 557 #endif
 558
 559         dprintk(4, "%p\n", av7110);
 560
 561         if (!av7110->arm_ready) {
 562                 dprintk(1, "arm not ready.\n");
 563                 return -1;
 564         }
 565
 566         if (down_interruptible(&av7110->dcomlock))
 567                 return -ERESTARTSYS;
 568
 569         if ((err = __av7110_send_fw_cmd(av7110, request_buf, request_buf_len)) < 0) {
 570                 up(&av7110->dcomlock);
 571                 printk(KERN_ERR "dvb-ttpci: av7110_fw_request error %d\n", err);
 572                 return err;
 573         }
 574
 575         start = jiffies;
 576         while (1) {
 577                 err = time_after(jiffies, start + ARM_WAIT_FREE);
 578                 if (rdebi(av7110, DEBINOSWAP, COMMAND, 0, 2) == 0)
 579                         break;
 580                 if (err) {
 581                         printk(KERN_ERR "%s: timeout waiting for COMMAND to complete\n", __FUNCTION__);
 582                         up(&av7110->dcomlock);
 583                         return -ETIMEDOUT;
 584                 }
 585 #ifdef _NOHANDSHAKE
 586                 msleep(1);
 587 #endif
 588         }
 589
 590 #ifndef _NOHANDSHAKE
 591         start = jiffies;
 592         while (1) {
 593                 err = time_after(jiffies, start + ARM_WAIT_SHAKE);
 594                 if (rdebi(av7110, DEBINOSWAP, HANDSHAKE_REG, 0, 2) == 0)
 595                         break;
 596                 if (err) {
 597                         printk(KERN_ERR "%s: timeout waiting for HANDSHAKE_REG\n", __FUNCTION__);
 598                         up(&av7110->dcomlock);
 599                         return -ETIMEDOUT;
 600                 }
 601                 msleep(1);
 602         }
 603 #endif
 604
 605 #ifdef COM_DEBUG
 606         stat = rdebi(av7110, DEBINOSWAP, MSGSTATE, 0, 2);
 607         if (stat & GPMQOver) {
 608                 printk(KERN_ERR "%s: GPMQOver\n", __FUNCTION__);
 609                 up(&av7110->dcomlock);
 610                 return -1;
 611         }
 612         else if (stat & OSDQOver) {
 613                 printk(KERN_ERR "%s: OSDQOver\n", __FUNCTION__);
 614                 up(&av7110->dcomlock);
 615                 return -1;
 616         }
 617 #endif
 618
 619         for (i = 0; i < reply_buf_len; i++)
 620                 reply_buf[i] = rdebi(av7110, DEBINOSWAP, COM_BUFF + 2 * i, 0, 2);
 621
 622         up(&av7110->dcomlock);
 623         return 0;
 624 }
 625
 626 static int av7110_fw_query(struct av7110 *av7110, u16 tag, u16* buf, s16 length)
 627 {
 628         int ret;
 629         ret = av7110_fw_request(av7110, &tag, 0, buf, length);
 630         if (ret)
 631                 printk(KERN_ERR "dvb-ttpci: av7110_fw_query error %d\n", ret);
 632         return ret;
 633 }
 634
 635
 636 /****************************************************************************
 637  * Firmware commands
 638  ****************************************************************************/
 639
 640 /* get version of the firmware ROM, RTSL, video ucode and ARM application  */
 641 int av7110_firmversion(struct av7110 *av7110)
 642 {
 643         u16 buf[20];
 644         u16 tag = ((COMTYPE_REQUEST << 8) + ReqVersion);
 645
 646         dprintk(4, "%p\n", av7110);
 647
 648         if (av7110_fw_query(av7110, tag, buf, 16)) {
 649                 printk("dvb-ttpci: failed to boot firmware @ card %d\n",
 650                        av7110->dvb_adapter.num);
 651                 return -EIO;
 652         }
 653
 654         av7110->arm_fw = (buf[0] << 16) + buf[1];
 655         av7110->arm_rtsl = (buf[2] << 16) + buf[3];
 656         av7110->arm_vid = (buf[4] << 16) + buf[5];
 657         av7110->arm_app = (buf[6] << 16) + buf[7];
 658         av7110->avtype = (buf[8] << 16) + buf[9];
 659
 660         printk("dvb-ttpci: info @ card %d: firm %08x, rtsl %08x, vid %08x, app %08x\n",
 661                av7110->dvb_adapter.num, av7110->arm_fw,
 662                av7110->arm_rtsl, av7110->arm_vid, av7110->arm_app);
 663
 664         /* print firmware capabilities */
 665         if (FW_CI_LL_SUPPORT(av7110->arm_app))
 666                 printk("dvb-ttpci: firmware @ card %d supports CI link layer interface\n",
 667                        av7110->dvb_adapter.num);
 668         else
 669                 printk("dvb-ttpci: no firmware support for CI link layer interface @ card %d\n",
 670                        av7110->dvb_adapter.num);
 671
 672         return 0;
 673 }
 674
 675
 676 int av7110_diseqc_send(struct av7110 *av7110, int len, u8 *msg, unsigned long burst)
 677 {
 678         int i, ret;
 679         u16 buf[18] = { ((COMTYPE_AUDIODAC << 8) + SendDiSEqC),
 680                         16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 681
 682         dprintk(4, "%p\n", av7110);
 683
 684         if (len > 10)
 685                 len = 10;
 686
 687         buf[1] = len + 2;
 688         buf[2] = len;
 689
 690         if (burst != -1)
 691                 buf[3] = burst ? 0x01 : 0x00;
 692         else
 693                 buf[3] = 0xffff;
 694
 695         for (i = 0; i < len; i++)
 696                 buf[i + 4] = msg[i];
 697
 698         ret = av7110_send_fw_cmd(av7110, buf, 18);
 699         if (ret && ret!=-ERESTARTSYS)
 700                 printk(KERN_ERR "dvb-ttpci: av7110_diseqc_send error %d\n", ret);
 701         return ret;
 702 }
 703
 704
 705 #ifdef CONFIG_DVB_AV7110_OSD
 706
 707 static inline int SetColorBlend(struct av7110 *av7110, u8 windownr)
 708 {
 709         return av7110_fw_cmd(av7110, COMTYPE_OSD, SetCBlend, 1, windownr);
 710 }
 711
 712 static inline int SetBlend_(struct av7110 *av7110, u8 windownr,
 713                      enum av7110_osd_palette_type colordepth, u16 index, u8 blending)
 714 {
 715         return av7110_fw_cmd(av7110, COMTYPE_OSD, SetBlend, 4,
 716                              windownr, colordepth, index, blending);
 717 }
 718
 719 static inline int SetColor_(struct av7110 *av7110, u8 windownr,
 720                      enum av7110_osd_palette_type colordepth, u16 index, u16 colorhi, u16 colorlo)
 721 {
 722         return av7110_fw_cmd(av7110, COMTYPE_OSD, SetColor, 5,
 723                              windownr, colordepth, index, colorhi, colorlo);
 724 }
 725
 726 static inline int SetFont(struct av7110 *av7110, u8 windownr, u8 fontsize,
 727                           u16 colorfg, u16 colorbg)
 728 {
 729         return av7110_fw_cmd(av7110, COMTYPE_OSD, Set_Font, 4,
 730                              windownr, fontsize, colorfg, colorbg);
 731 }
 732
 733 static int FlushText(struct av7110 *av7110)
 734 {
 735         unsigned long start;
 736         int err;
 737
 738         if (down_interruptible(&av7110->dcomlock))
 739                 return -ERESTARTSYS;
 740         start = jiffies;
 741         while (1) {
 742                 err = time_after(jiffies, start + ARM_WAIT_OSD);
 743                 if (rdebi(av7110, DEBINOSWAP, BUFF1_BASE, 0, 2) == 0)
 744                         break;
 745                 if (err) {
 746                         printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for BUFF1_BASE == 0\n",
 747                                __FUNCTION__);
 748                         up(&av7110->dcomlock);
 749                         return -ETIMEDOUT;
 750                 }
 751                 msleep(1);
 752         }
 753         up(&av7110->dcomlock);
 754         return 0;
 755 }
 756
 757 static int WriteText(struct av7110 *av7110, u8 win, u16 x, u16 y, u8* buf)
 758 {
 759         int i, ret;
 760         unsigned long start;
 761         int length = strlen(buf) + 1;
 762         u16 cbuf[5] = { (COMTYPE_OSD << 8) + DText, 3, win, x, y };
 763
 764         if (down_interruptible(&av7110->dcomlock))
 765                 return -ERESTARTSYS;
 766
 767         start = jiffies;
 768         while (1) {
 769                 ret = time_after(jiffies, start + ARM_WAIT_OSD);
 770                 if (rdebi(av7110, DEBINOSWAP, BUFF1_BASE, 0, 2) == 0)
 771                         break;
 772                 if (ret) {
 773                         printk(KERN_ERR "dvb-ttpci: %s: timeout waiting for BUFF1_BASE == 0\n",
 774                                __FUNCTION__);
 775                         up(&av7110->dcomlock);
 776                         return -ETIMEDOUT;
 777                 }
 778                 msleep(1);
 779         }
 780 #ifndef _NOHANDSHAKE
 781         start = jiffies;
 782         while (1) {
 783                 ret = time_after(jiffies, start + ARM_WAIT_SHAKE);
 784                 if (rdebi(av7110, DEBINOSWAP, HANDSHAKE_REG, 0, 2) == 0)
 785                         break;
 786                 if (ret) {
 787                         printk(KERN_ERR "dvb-ttpci: %s: timeout waiting for HANDSHAKE_REG\n",
 788                                __FUNCTION__);
 789                         up(&av7110->dcomlock);
 790                         return -ETIMEDOUT;
 791                 }
 792                 msleep(1);
 793         }
 794 #endif
 795         for (i = 0; i < length / 2; i++)
 796                 wdebi(av7110, DEBINOSWAP, BUFF1_BASE + i * 2,
 797                       swab16(*(u16 *)(buf + 2 * i)), 2);
 798         if (length & 1)
 799                 wdebi(av7110, DEBINOSWAP, BUFF1_BASE + i * 2, 0, 2);
 800         ret = __av7110_send_fw_cmd(av7110, cbuf, 5);
 801         up(&av7110->dcomlock);
 802         if (ret && ret!=-ERESTARTSYS)
 803                 printk(KERN_ERR "dvb-ttpci: WriteText error %d\n", ret);
 804         return ret;
 805 }
 806
 807 static inline int DrawLine(struct av7110 *av7110, u8 windownr,
 808                            u16 x, u16 y, u16 dx, u16 dy, u16 color)
 809 {
 810         return av7110_fw_cmd(av7110, COMTYPE_OSD, DLine, 6,
 811                              windownr, x, y, dx, dy, color);
 812 }
 813
 814 static inline int DrawBlock(struct av7110 *av7110, u8 windownr,
 815                             u16 x, u16 y, u16 dx, u16 dy, u16 color)
 816 {
 817         return av7110_fw_cmd(av7110, COMTYPE_OSD, DBox, 6,
 818                              windownr, x, y, dx, dy, color);
 819 }
 820
 821 static inline int HideWindow(struct av7110 *av7110, u8 windownr)
 822 {
 823         return av7110_fw_cmd(av7110, COMTYPE_OSD, WHide, 1, windownr);
 824 }
 825
 826 static inline int MoveWindowRel(struct av7110 *av7110, u8 windownr, u16 x, u16 y)
 827 {
 828         return av7110_fw_cmd(av7110, COMTYPE_OSD, WMoveD, 3, windownr, x, y);
 829 }
 830
 831 static inline int MoveWindowAbs(struct av7110 *av7110, u8 windownr, u16 x, u16 y)
 832 {
 833         return av7110_fw_cmd(av7110, COMTYPE_OSD, WMoveA, 3, windownr, x, y);
 834 }
 835
 836 static inline int DestroyOSDWindow(struct av7110 *av7110, u8 windownr)
 837 {
 838         return av7110_fw_cmd(av7110, COMTYPE_OSD, WDestroy, 1, windownr);
 839 }
 840
 841 static inline int CreateOSDWindow(struct av7110 *av7110, u8 windownr,
 842                                   osd_raw_window_t disptype,
 843                                   u16 width, u16 height)
 844 {
 845         return av7110_fw_cmd(av7110, COMTYPE_OSD, WCreate, 4,
 846                              windownr, disptype, width, height);
 847 }
 848
 849
 850 static enum av7110_osd_palette_type bpp2pal[8] = {
 851         Pal1Bit, Pal2Bit, 0, Pal4Bit, 0, 0, 0, Pal8Bit
 852 };
 853 static osd_raw_window_t bpp2bit[8] = {
 854         OSD_BITMAP1, OSD_BITMAP2, 0, OSD_BITMAP4, 0, 0, 0, OSD_BITMAP8
 855 };
 856
 857 static inline int WaitUntilBmpLoaded(struct av7110 *av7110)
 858 {
 859         int ret = wait_event_interruptible_timeout(av7110->bmpq,
 860                                 av7110->bmp_state != BMP_LOADING, 10*HZ);
 861         if (ret == -ERESTARTSYS)
 862                 return ret;
 863         if (ret == 0) {
 864                 printk("dvb-ttpci: warning: timeout waiting in LoadBitmap: %d, %d\n",
 865                        ret, av7110->bmp_state);
 866                 av7110->bmp_state = BMP_NONE;
 867                 return -ETIMEDOUT;
 868         }
 869         return 0;
 870 }
 871
 872 static inline int LoadBitmap(struct av7110 *av7110,
 873                              u16 dx, u16 dy, int inc, u8 __user * data)
 874 {
 875         u16 format;
 876         int bpp;
 877         int i;
 878         int d, delta;
 879         u8 c;
 880         int ret;
 881
 882         dprintk(4, "%p\n", av7110);
 883
 884         format = bpp2bit[av7110->osdbpp[av7110->osdwin]];
 885
 886         av7110->bmp_state = BMP_LOADING;
 887         if      (format == OSD_BITMAP8) {
 888                 bpp=8; delta = 1;
 889         } else if (format == OSD_BITMAP4) {
 890                 bpp=4; delta = 2;
 891         } else if (format == OSD_BITMAP2) {
 892                 bpp=2; delta = 4;
 893         } else if (format == OSD_BITMAP1) {
 894                 bpp=1; delta = 8;
 895         } else {
 896                 av7110->bmp_state = BMP_NONE;
 897                 return -EINVAL;
 898         }
 899         av7110->bmplen = ((dx * dy * bpp + 7) & ~7) / 8;
 900         av7110->bmpp = 0;
 901         if (av7110->bmplen > 32768) {
 902                 av7110->bmp_state = BMP_NONE;
 903                 return -EINVAL;
 904         }
 905         for (i = 0; i < dy; i++) {
 906                 if (copy_from_user(av7110->bmpbuf + 1024 + i * dx, data + i * inc, dx)) {
 907                         av7110->bmp_state = BMP_NONE;
 908                         return -EINVAL;
 909                 }
 910         }
 911         if (format != OSD_BITMAP8) {
 912                 for (i = 0; i < dx * dy / delta; i++) {
 913                         c = ((u8 *)av7110->bmpbuf)[1024 + i * delta + delta - 1];
 914                         for (d = delta - 2; d >= 0; d--) {
 915                                 c |= (((u8 *)av7110->bmpbuf)[1024 + i * delta + d]
 916                                       << ((delta - d - 1) * bpp));
 917                                 ((u8 *)av7110->bmpbuf)[1024 + i] = c;
 918                         }
 919                 }
 920         }
 921         av7110->bmplen += 1024;
 922         dprintk(4, "av7110_fw_cmd: LoadBmp size %d\n", av7110->bmplen);
 923         ret = av7110_fw_cmd(av7110, COMTYPE_OSD, LoadBmp, 3, format, dx, dy);
 924         if (!ret)
 925                 ret = WaitUntilBmpLoaded(av7110);
 926         return ret;
 927 }
 928
 929 static int BlitBitmap(struct av7110 *av7110, u16 x, u16 y)
 930 {
 931         dprintk(4, "%p\n", av7110);
 932
 933         return av7110_fw_cmd(av7110, COMTYPE_OSD, BlitBmp, 4, av7110->osdwin, x, y, 0);
 934 }
 935
 936 static inline int ReleaseBitmap(struct av7110 *av7110)
 937 {
 938         dprintk(4, "%p\n", av7110);
 939
 940         if (av7110->bmp_state != BMP_LOADED && FW_VERSION(av7110->arm_app) < 0x261e)
 941                 return -1;
 942         if (av7110->bmp_state == BMP_LOADING)
 943                 dprintk(1,"ReleaseBitmap called while BMP_LOADING\n");
 944         av7110->bmp_state = BMP_NONE;
 945         return av7110_fw_cmd(av7110, COMTYPE_OSD, ReleaseBmp, 0);
 946 }
 947
 948 static u32 RGB2YUV(u16 R, u16 G, u16 B)
 949 {
 950         u16 y, u, v;
 951         u16 Y, Cr, Cb;
 952
 953         y = R * 77 + G * 150 + B * 29;  /* Luma=0.299R+0.587G+0.114B 0..65535 */
 954         u = 2048 + B * 8 -(y >> 5);     /* Cr 0..4095 */
 955         v = 2048 + R * 8 -(y >> 5);     /* Cb 0..4095 */
 956
 957         Y = y / 256;
 958         Cb = u / 16;
 959         Cr = v / 16;
 960
 961         return Cr | (Cb << 16) | (Y << 8);
 962 }
 963
 964 static int OSDSetColor(struct av7110 *av7110, u8 color, u8 r, u8 g, u8 b, u8 blend)
 965 {
 966         int ret;
 967
 968         u16 ch, cl;
 969         u32 yuv;
 970
 971         yuv = blend ? RGB2YUV(r,g,b) : 0;
 972         cl = (yuv & 0xffff);
 973         ch = ((yuv >> 16) & 0xffff);
 974         ret = SetColor_(av7110, av7110->osdwin, bpp2pal[av7110->osdbpp[av7110->osdwin]],
 975                         color, ch, cl);
 976         if (!ret)
 977                 ret = SetBlend_(av7110, av7110->osdwin, bpp2pal[av7110->osdbpp[av7110->osdwin]],
 978                                 color, ((blend >> 4) & 0x0f));
 979         return ret;
 980 }
 981
 982 static int OSDSetPalette(struct av7110 *av7110, u32 __user * colors, u8 first, u8 last)
 983 {
 984        int i;
 985        int length = last - first + 1;
 986
 987        if (length * 4 > DATA_BUFF3_SIZE)
 988                return -EINVAL;
 989
 990        for (i = 0; i < length; i++) {
 991                u32 color, blend, yuv;
 992
 993                if (get_user(color, colors + i))
 994                        return -EFAULT;
 995                blend = (color & 0xF0000000) >> 4;
 996                yuv = blend ? RGB2YUV(color & 0xFF, (color >> 8) & 0xFF,
 997                                      (color >> 16) & 0xFF) | blend : 0;
 998                yuv = ((yuv & 0xFFFF0000) >> 16) | ((yuv & 0x0000FFFF) << 16);
 999                wdebi(av7110, DEBINOSWAP, DATA_BUFF3_BASE + i * 4, yuv, 4);
1000        }
1001        return av7110_fw_cmd(av7110, COMTYPE_OSD, Set_Palette, 4,
1002                             av7110->osdwin,
1003                             bpp2pal[av7110->osdbpp[av7110->osdwin]],
1004                             first, last);
1005 }
1006
1007 static int OSDSetBlock(struct av7110 *av7110, int x0, int y0,
1008                        int x1, int y1, int inc, u8 __user * data)
1009 {
1010         uint w, h, bpp, bpl, size, lpb, bnum, brest;
1011         int i;
1012         int rc,release_rc;
1013
1014         w = x1 - x0 + 1;
1015         h = y1 - y0 + 1;
1016         if (inc <= 0)
1017                 inc = w;
1018         if (w <= 0 || w > 720 || h <= 0 || h > 576)
1019                 return -EINVAL;
1020         bpp = av7110->osdbpp[av7110->osdwin] + 1;
1021         bpl = ((w * bpp + 7) & ~7) / 8;
1022         size = h * bpl;
1023         lpb = (32 * 1024) / bpl;
1024         bnum = size / (lpb * bpl);
1025         brest = size - bnum * lpb * bpl;
1026
1027         if (av7110->bmp_state == BMP_LOADING) {
1028                 /* possible if syscall is repeated by -ERESTARTSYS and if firmware cannot abort */
1029                 BUG_ON (FW_VERSION(av7110->arm_app) >= 0x261e);
1030                 rc = WaitUntilBmpLoaded(av7110);
1031                 if (rc)
1032                         return rc;
1033                 /* just continue. This should work for all fw versions
1034                  * if bnum==1 && !brest && LoadBitmap was successful
1035                  */
1036         }
1037
1038         rc = 0;
1039         for (i = 0; i < bnum; i++) {
1040                 rc = LoadBitmap(av7110, w, lpb, inc, data);
1041                 if (rc)
1042                         break;
1043                 rc = BlitBitmap(av7110, x0, y0 + i * lpb);
1044                 if (rc)
1045                         break;
1046                 data += lpb * inc;
1047         }
1048         if (!rc && brest) {
1049                 rc = LoadBitmap(av7110, w, brest / bpl, inc, data);
1050                 if (!rc)
1051                         rc = BlitBitmap(av7110, x0, y0 + bnum * lpb);
1052         }
1053         release_rc = ReleaseBitmap(av7110);
1054         if (!rc)
1055                 rc = release_rc;
1056         if (rc)
1057                 dprintk(1,"returns %d\n",rc);
1058         return rc;
1059 }
1060
1061 int av7110_osd_cmd(struct av7110 *av7110, osd_cmd_t *dc)
1062 {
1063         int ret;
1064
1065         if (down_interruptible(&av7110->osd_sema))
1066                 return -ERESTARTSYS;
1067
1068         switch (dc->cmd) {
1069         case OSD_Close:
1070                 ret = DestroyOSDWindow(av7110, av7110->osdwin);
1071                 break;
1072         case OSD_Open:
1073                 av7110->osdbpp[av7110->osdwin] = (dc->color - 1) & 7;
1074                 ret = CreateOSDWindow(av7110, av7110->osdwin,
1075                                 bpp2bit[av7110->osdbpp[av7110->osdwin]],
1076                                 dc->x1 - dc->x0 + 1, dc->y1 - dc->y0 + 1);
1077                 if (ret)
1078                         break;
1079                 if (!dc->data) {
1080                         ret = MoveWindowAbs(av7110, av7110->osdwin, dc->x0, dc->y0);
1081                         if (ret)
1082                                 break;
1083                         ret = SetColorBlend(av7110, av7110->osdwin);
1084                 }
1085                 break;
1086         case OSD_Show:
1087                 ret = MoveWindowRel(av7110, av7110->osdwin, 0, 0);
1088                 break;
1089         case OSD_Hide:
1090                 ret = HideWindow(av7110, av7110->osdwin);
1091                 break;
1092         case OSD_Clear:
1093                 ret = DrawBlock(av7110, av7110->osdwin, 0, 0, 720, 576, 0);
1094                 break;
1095         case OSD_Fill:
1096                 ret = DrawBlock(av7110, av7110->osdwin, 0, 0, 720, 576, dc->color);
1097                 break;
1098         case OSD_SetColor:
1099                 ret = OSDSetColor(av7110, dc->color, dc->x0, dc->y0, dc->x1, dc->y1);
1100                 break;
1101         case OSD_SetPalette:
1102                 if (FW_VERSION(av7110->arm_app) >= 0x2618)
1103                         ret = OSDSetPalette(av7110, dc->data, dc->color, dc->x0);
1104                 else {
1105                         int i, len = dc->x0-dc->color+1;
1106                         u8 __user *colors = (u8 __user *)dc->data;
1107                         u8 r, g, b, blend;
1108                         ret = 0;
1109                         for (i = 0; i<len; i++) {
1110                                 if (get_user(r, colors + i * 4) ||
1111                                     get_user(g, colors + i * 4 + 1) ||
1112                                     get_user(b, colors + i * 4 + 2) ||
1113                                     get_user(blend, colors + i * 4 + 3)) {
1114                                         ret = -EFAULT;
1115                                         break;
1116                                     }
1117                                 ret = OSDSetColor(av7110, dc->color + i, r, g, b, blend);
1118                                 if (ret)
1119                                         break;
1120                         }
1121                 }
1122                 break;
1123         case OSD_SetPixel:
1124                 ret = DrawLine(av7110, av7110->osdwin,
1125                          dc->x0, dc->y0, 0, 0, dc->color);
1126                 break;
1127         case OSD_SetRow:
1128                 dc->y1 = dc->y0;
1129                 /* fall through */
1130         case OSD_SetBlock:
1131                 ret = OSDSetBlock(av7110, dc->x0, dc->y0, dc->x1, dc->y1, dc->color, dc->data);
1132                 break;
1133         case OSD_FillRow:
1134                 ret = DrawBlock(av7110, av7110->osdwin, dc->x0, dc->y0,
1135                           dc->x1-dc->x0+1, dc->y1, dc->color);
1136                 break;
1137         case OSD_FillBlock:
1138                 ret = DrawBlock(av7110, av7110->osdwin, dc->x0, dc->y0,
1139                           dc->x1 - dc->x0 + 1, dc->y1 - dc->y0 + 1, dc->color);
1140                 break;
1141         case OSD_Line:
1142                 ret = DrawLine(av7110, av7110->osdwin,
1143                          dc->x0, dc->y0, dc->x1 - dc->x0, dc->y1 - dc->y0, dc->color);
1144                 break;
1145         case OSD_Text:
1146         {
1147                 char textbuf[240];
1148
1149                 if (strncpy_from_user(textbuf, dc->data, 240) < 0) {
1150                         ret = -EFAULT;
1151                         break;
1152                 }
1153                 textbuf[239] = 0;
1154                 if (dc->x1 > 3)
1155                         dc->x1 = 3;
1156                 ret = SetFont(av7110, av7110->osdwin, dc->x1,
1157                         (u16) (dc->color & 0xffff), (u16) (dc->color >> 16));
1158                 if (!ret)
1159                         ret = FlushText(av7110);
1160                 if (!ret)
1161                         ret = WriteText(av7110, av7110->osdwin, dc->x0, dc->y0, textbuf);
1162                 break;
1163         }
1164         case OSD_SetWindow:
1165                 if (dc->x0 < 1 || dc->x0 > 7)
1166                         ret = -EINVAL;
1167                 else {
1168                         av7110->osdwin = dc->x0;
1169                         ret = 0;
1170                 }
1171                 break;
1172         case OSD_MoveWindow:
1173                 ret = MoveWindowAbs(av7110, av7110->osdwin, dc->x0, dc->y0);
1174                 if (!ret)
1175                         ret = SetColorBlend(av7110, av7110->osdwin);
1176                 break;
1177         case OSD_OpenRaw:
1178                 if (dc->color < OSD_BITMAP1 || dc->color > OSD_CURSOR) {
1179                         ret = -EINVAL;
1180                         break;
1181                 }
1182                 if (dc->color >= OSD_BITMAP1 && dc->color <= OSD_BITMAP8HR)
1183                         av7110->osdbpp[av7110->osdwin] = (1 << (dc->color & 3)) - 1;
1184                 else
1185                         av7110->osdbpp[av7110->osdwin] = 0;
1186                 ret = CreateOSDWindow(av7110, av7110->osdwin, (osd_raw_window_t)dc->color,
1187                                 dc->x1 - dc->x0 + 1, dc->y1 - dc->y0 + 1);
1188                 if (ret)
1189                         break;
1190                 if (!dc->data) {
1191                         ret = MoveWindowAbs(av7110, av7110->osdwin, dc->x0, dc->y0);
1192                         if (!ret)
1193                                 ret = SetColorBlend(av7110, av7110->osdwin);
1194                 }
1195                 break;
1196         default:
1197                 ret = -EINVAL;
1198                 break;
1199         }
1200
1201         up(&av7110->osd_sema);
1202         if (ret==-ERESTARTSYS)
1203                 dprintk(1, "av7110_osd_cmd(%d) returns with -ERESTARTSYS\n",dc->cmd);
1204         else if (ret)
1205                 dprintk(1, "av7110_osd_cmd(%d) returns with %d\n",dc->cmd,ret);
1206
1207         return ret;
1208 }
1209
1210 int av7110_osd_capability(struct av7110 *av7110, osd_cap_t *cap)
1211 {
1212         switch (cap->cmd) {
1213         case OSD_CAP_MEMSIZE:
1214                 if (FW_4M_SDRAM(av7110->arm_app))
1215                         cap->val = 1000000;
1216                 else
1217                         cap->val = 92000;
1218                 return 0;
1219         default:
1220                 return -EINVAL;
1221         }
1222 }
1223 #endif /* CONFIG_DVB_AV7110_OSD */