sound/oss/maui.c

   1 /*
   2  * sound/maui.c
   3  *
   4  * The low level driver for Turtle Beach Maui and Tropez.
   5  *
   6  *
   7  * Copyright (C) by Hannu Savolainen 1993-1997
   8  *
   9  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11  * for more info.
  12  *
  13  *      Changes:
  14  *              Alan Cox                General clean up, use kernel IRQ
  15  *                                      system
  16  *              Christoph Hellwig       Adapted to module_init/module_exit
  17  *              Bartlomiej Zolnierkiewicz
  18  *                                      Added __init to download_code()
  19  *
  20  *      Status:
  21  *              Andrew J. Kroll         Tested 06/01/1999 with:
  22  *                                      * OSWF.MOT File Version: 1.15
  23  *                                      * OSWF.MOT File Dated: 09/12/94
  24  *                                      * Older versions will cause problems.
  25  */
  26
  27 #include <linux/interrupt.h>
  28 #include <linux/config.h>
  29 #include <linux/module.h>
  30 #include <linux/init.h>
  31
  32 #define USE_SEQ_MACROS
  33 #define USE_SIMPLE_MACROS
  34
  35 #include "sound_config.h"
  36 #include "sound_firmware.h"
  37
  38 #include "mpu401.h"
  39
  40 static int      maui_base = 0x330;
  41
  42 static volatile int irq_ok;
  43 static int     *maui_osp;
  44
  45 #define HOST_DATA_PORT  (maui_base + 2)
  46 #define HOST_STAT_PORT  (maui_base + 3)
  47 #define HOST_CTRL_PORT  (maui_base + 3)
  48
  49 #define STAT_TX_INTR    0x40
  50 #define STAT_TX_AVAIL   0x20
  51 #define STAT_TX_IENA    0x10
  52 #define STAT_RX_INTR    0x04
  53 #define STAT_RX_AVAIL   0x02
  54 #define STAT_RX_IENA    0x01
  55
  56 static int      (*orig_load_patch)(int dev, int format, const char __user *addr,
  57                               int offs, int count, int pmgr_flag) = NULL;
  58
  59 #include "maui_boot.h"
  60
  61 static int maui_wait(int mask)
  62 {
  63         int i;
  64
  65         /*
  66          * Perform a short initial wait without sleeping
  67          */
  68
  69         for (i = 0; i < 100; i++)
  70                 if (inb(HOST_STAT_PORT) & mask)
  71                         return 1;
  72
  73         /*
  74          * Wait up to 15 seconds with sleeping
  75          */
  76
  77         for (i = 0; i < 150; i++) {
  78                 if (inb(HOST_STAT_PORT) & mask)
  79                         return 1;
  80                 current->state = TASK_INTERRUPTIBLE;
  81                 schedule_timeout(HZ / 10);
  82                 if (signal_pending(current))
  83                         return 0;
  84         }
  85         return 0;
  86 }
  87
  88 static int maui_read(void)
  89 {
  90         if (maui_wait(STAT_RX_AVAIL))
  91                 return inb(HOST_DATA_PORT);
  92         return -1;
  93 }
  94
  95 static int maui_write(unsigned char data)
  96 {
  97         if (maui_wait(STAT_TX_AVAIL)) {
  98                 outb((data), HOST_DATA_PORT);
  99                 return 1;
 100         }
 101         printk(KERN_WARNING "Maui: Write timeout\n");
 102         return 0;
 103 }
 104
 105 static irqreturn_t mauiintr(int irq, void *dev_id, struct pt_regs *dummy)
 106 {
 107         irq_ok = 1;
 108         return IRQ_HANDLED;
 109 }
 110
 111 static int __init download_code(void)
 112 {
 113         int i, lines = 0;
 114         int eol_seen = 0, done = 0;
 115         int skip = 1;
 116
 117         printk(KERN_INFO "Code download (%d bytes): ", maui_osLen);
 118
 119         for (i = 0; i < maui_osLen; i++) {
 120                 if (maui_os[i] != '\r') {
 121                         if (!skip || (maui_os[i] == 'S' && (i == 0 || maui_os[i - 1] == '\n'))) {
 122                                 skip = 0;
 123
 124                                 if (maui_os[i] == '\n')
 125                                         eol_seen = skip = 1;
 126                                 else if (maui_os[i] == 'S') {
 127                                         if (maui_os[i + 1] == '8')
 128                                                 done = 1;
 129                                         if (!maui_write(0xF1))
 130                                                 goto failure;
 131                                         if (!maui_write('S'))
 132                                                 goto failure;
 133                                 } else {
 134                                         if (!maui_write(maui_os[i]))
 135                                                 goto failure;
 136                                 }
 137
 138                                 if (eol_seen) {
 139                                         int c = 0;
 140                                         int n;
 141
 142                                         eol_seen = 0;
 143
 144                                         for (n = 0; n < 2; n++) {
 145                                                 if (maui_wait(STAT_RX_AVAIL)) {
 146                                                         c = inb(HOST_DATA_PORT);
 147                                                         break;
 148                                                 }
 149                                         }
 150                                         if (c != 0x80) {
 151                                                 printk("Download not acknowledged\n");
 152                                                 return 0;
 153                                         }
 154                                         else if (!(lines++ % 10))
 155                                                 printk(".");
 156
 157                                         if (done) {
 158                                                 printk("\n");
 159                                                 printk(KERN_INFO "Download complete\n");
 160                                                 return 1;
 161                                         }
 162                                 }
 163                         }
 164                 }
 165         }
 166
 167 failure:
 168         printk("\n");
 169         printk(KERN_ERR "Download failed!!!\n");
 170         return 0;
 171 }
 172
 173 static int __init maui_init(int irq)
 174 {
 175         unsigned char bits;
 176
 177         switch (irq) {
 178                 case 9:
 179                         bits = 0x00;
 180                         break;
 181                 case 5:
 182                         bits = 0x08;
 183                         break;
 184                 case 12:
 185                         bits = 0x10;
 186                         break;
 187                 case 15:
 188                         bits = 0x18;
 189                         break;
 190
 191                 default:
 192                         printk(KERN_ERR "Maui: Invalid IRQ %d\n", irq);
 193                         return 0;
 194         }
 195         outb((0x00), HOST_CTRL_PORT);   /* Reset */
 196         outb((bits), HOST_DATA_PORT);   /* Set the IRQ bits */
 197         outb((bits | 0x80), HOST_DATA_PORT);    /* Set the IRQ bits again? */
 198         outb((0x80), HOST_CTRL_PORT);   /* Leave reset */
 199         outb((0x80), HOST_CTRL_PORT);   /* Leave reset */
 200         outb((0xD0), HOST_CTRL_PORT);   /* Cause interrupt */
 201
 202 #ifdef CONFIG_SMP
 203         {
 204                 int i;
 205                 for (i = 0; i < 1000000 && !irq_ok; i++)
 206                         ;
 207                 if (!irq_ok)
 208                         return 0;
 209         }
 210 #endif
 211         outb((0x80), HOST_CTRL_PORT);   /* Leave reset */
 212
 213         printk(KERN_INFO "Turtle Beach Maui initialization\n");
 214
 215         if (!download_code())
 216                 return 0;
 217
 218         outb((0xE0), HOST_CTRL_PORT);   /* Normal operation */
 219
 220         /* Select mpu401 mode */
 221
 222         maui_write(0xf0);
 223         maui_write(1);
 224         if (maui_read() != 0x80) {
 225                 maui_write(0xf0);
 226                 maui_write(1);
 227                 if (maui_read() != 0x80)
 228                         printk(KERN_ERR "Maui didn't acknowledge set HW mode command\n");
 229         }
 230         printk(KERN_INFO "Maui initialized OK\n");
 231         return 1;
 232 }
 233
 234 static int maui_short_wait(int mask) {
 235         int i;
 236
 237         for (i = 0; i < 1000; i++) {
 238                 if (inb(HOST_STAT_PORT) & mask) {
 239                         return 1;
 240                 }
 241         }
 242         return 0;
 243 }
 244
 245 static int maui_load_patch(int dev, int format, const char __user *addr,
 246                 int offs, int count, int pmgr_flag)
 247 {
 248
 249         struct sysex_info header;
 250         unsigned long left, src_offs;
 251         int hdr_size = (unsigned long) &header.data[0] - (unsigned long) &header;
 252         int i;
 253
 254         if (format == SYSEX_PATCH)      /* Handled by midi_synth.c */
 255                 return orig_load_patch(dev, format, addr, offs, count, pmgr_flag);
 256
 257         if (format != MAUI_PATCH)
 258         {
 259                   printk(KERN_WARNING "Maui: Unknown patch format\n");
 260         }
 261         if (count < hdr_size) {
 262 /*                printk("Maui error: Patch header too short\n");*/
 263                   return -EINVAL;
 264         }
 265         count -= hdr_size;
 266
 267         /*
 268          * Copy the header from user space but ignore the first bytes which have
 269          * been transferred already.
 270          */
 271
 272         if(copy_from_user(&((char *) &header)[offs], &(addr)[offs], hdr_size - offs))
 273                 return -EFAULT;
 274
 275         if (count < header.len) {
 276                   printk(KERN_ERR "Maui warning: Host command record too short (%d<%d)\n", count, (int) header.len);
 277                   header.len = count;
 278         }
 279         left = header.len;
 280         src_offs = 0;
 281
 282         for (i = 0; i < left; i++) {
 283                 unsigned char   data;
 284
 285                 if(get_user(*(unsigned char *) &data, (unsigned char __user *) &((addr)[hdr_size + i])))
 286                         return -EFAULT;
 287                 if (i == 0 && !(data & 0x80))
 288                         return -EINVAL;
 289
 290                 if (maui_write(data) == -1)
 291                         return -EIO;
 292         }
 293
 294         if ((i = maui_read()) != 0x80) {
 295                 if (i != -1)
 296                         printk("Maui: Error status %02x\n", i);
 297                 return -EIO;
 298         }
 299         return 0;
 300 }
 301
 302 static int __init probe_maui(struct address_info *hw_config)
 303 {
 304         struct resource *ports;
 305         int this_dev;
 306         int i;
 307         int tmp1, tmp2, ret;
 308
 309         ports = request_region(hw_config->io_base, 2, "mpu401");
 310         if (!ports)
 311                 return 0;
 312
 313         if (!request_region(hw_config->io_base + 2, 6, "Maui"))
 314                 goto out;
 315
 316         maui_base = hw_config->io_base;
 317         maui_osp = hw_config->osp;
 318
 319         if (request_irq(hw_config->irq, mauiintr, 0, "Maui", NULL) < 0)
 320                 goto out2;
 321
 322         /*
 323          * Initialize the processor if necessary
 324          */
 325
 326         if (maui_osLen > 0) {
 327                 if (!(inb(HOST_STAT_PORT) & STAT_TX_AVAIL) ||
 328                         !maui_write(0x9F) ||    /* Report firmware version */
 329                         !maui_short_wait(STAT_RX_AVAIL) ||
 330                         maui_read() == -1 || maui_read() == -1)
 331                         if (!maui_init(hw_config->irq))
 332                                 goto out3;
 333         }
 334         if (!maui_write(0xCF))  /* Report hardware version */ {
 335                 printk(KERN_ERR "No WaveFront firmware detected (card uninitialized?)\n");
 336                 goto out3;
 337         }
 338         if ((tmp1 = maui_read()) == -1 || (tmp2 = maui_read()) == -1) {
 339                 printk(KERN_ERR "No WaveFront firmware detected (card uninitialized?)\n");
 340                 goto out3;
 341         }
 342         if (tmp1 == 0xff || tmp2 == 0xff)
 343                 goto out3;
 344         printk(KERN_DEBUG "WaveFront hardware version %d.%d\n", tmp1, tmp2);
 345
 346         if (!maui_write(0x9F))  /* Report firmware version */
 347                 goto out3;
 348         if ((tmp1 = maui_read()) == -1 || (tmp2 = maui_read()) == -1)
 349                 goto out3;
 350
 351         printk(KERN_DEBUG "WaveFront firmware version %d.%d\n", tmp1, tmp2);
 352
 353         if (!maui_write(0x85))  /* Report free DRAM */
 354                 goto out3;
 355         tmp1 = 0;
 356         for (i = 0; i < 4; i++) {
 357                 tmp1 |= maui_read() << (7 * i);
 358         }
 359         printk(KERN_DEBUG "Available DRAM %dk\n", tmp1 / 1024);
 360
 361         for (i = 0; i < 1000; i++)
 362                 if (probe_mpu401(hw_config, ports))
 363                         break;
 364
 365         ret = probe_mpu401(hw_config, ports);
 366         if (!ret)
 367                 goto out3;
 368
 369         conf_printf("Maui", hw_config);
 370
 371         hw_config->irq *= -1;
 372         hw_config->name = "Maui";
 373         attach_mpu401(hw_config, THIS_MODULE);
 374
 375         if (hw_config->slots[1] != -1)  /* The MPU401 driver installed itself */ {
 376                 struct synth_operations *synth;
 377
 378                 this_dev = hw_config->slots[1];
 379
 380                 /*
 381                  * Intercept patch loading calls so that they can be handled
 382                  * by the Maui driver.
 383                  */
 384
 385                 synth = midi_devs[this_dev]->converter;
 386                 if (synth != NULL) {
 387                         synth->id = "MAUI";
 388                         orig_load_patch = synth->load_patch;
 389                         synth->load_patch = &maui_load_patch;
 390                 } else
 391                         printk(KERN_ERR "Maui: Can't install patch loader\n");
 392         }
 393         return 1;
 394
 395 out3:
 396         free_irq(hw_config->irq, NULL);
 397 out2:
 398         release_region(hw_config->io_base + 2, 6);
 399 out:
 400         release_region(hw_config->io_base, 2);
 401         return 0;
 402 }
 403
 404 static void __exit unload_maui(struct address_info *hw_config)
 405 {
 406         int irq = hw_config->irq;
 407         release_region(hw_config->io_base + 2, 6);
 408         unload_mpu401(hw_config);
 409
 410         if (irq < 0)
 411                 irq = -irq;
 412         if (irq > 0)
 413                 free_irq(irq, NULL);
 414 }
 415
 416 static int fw_load;
 417
 418 static struct address_info cfg;
 419
 420 static int __initdata io = -1;
 421 static int __initdata irq = -1;
 422
 423 module_param(io, int, 0);
 424 module_param(irq, int, 0);
 425
 426 /*
 427  *      Install a Maui card. Needs mpu401 loaded already.
 428  */
 429
 430 static int __init init_maui(void)
 431 {
 432         printk(KERN_INFO "Turtle beach Maui and Tropez driver, Copyright (C) by Hannu Savolainen 1993-1996\n");
 433
 434         cfg.io_base = io;
 435         cfg.irq = irq;
 436
 437         if (cfg.io_base == -1 || cfg.irq == -1) {
 438                 printk(KERN_INFO "maui: irq and io must be set.\n");
 439                 return -EINVAL;
 440         }
 441
 442         if (maui_os == NULL) {
 443                 fw_load = 1;
 444                 maui_osLen = mod_firmware_load("/etc/sound/oswf.mot", (char **) &maui_os);
 445         }
 446         if (probe_maui(&cfg) == 0)
 447                 return -ENODEV;
 448
 449         return 0;
 450 }
 451
 452 static void __exit cleanup_maui(void)
 453 {
 454         if (fw_load && maui_os)
 455                 vfree(maui_os);
 456         unload_maui(&cfg);
 457 }
 458
 459 module_init(init_maui);
 460 module_exit(cleanup_maui);
 461
 462 #ifndef MODULE
 463 static int __init setup_maui(char *str)
 464 {
 465         /* io, irq */
 466         int ints[3];
 467
 468         str = get_options(str, ARRAY_SIZE(ints), ints);
 469
 470         io = ints[1];
 471         irq = ints[2];
 472
 473         return 1;
 474 }
 475
 476 __setup("maui=", setup_maui);
 477 #endif
 478 MODULE_LICENSE("GPL");