Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *   Low-level ALSA driver for the ENSONIQ SoundScape
0004  *   Copyright (c) by Chris Rankin
0005  *
0006  *   This driver was written in part using information obtained from
0007  *   the OSS/Free SoundScape driver, written by Hannu Savolainen.
0008  */
0009 
0010 #include <linux/init.h>
0011 #include <linux/err.h>
0012 #include <linux/io.h>
0013 #include <linux/isa.h>
0014 #include <linux/delay.h>
0015 #include <linux/firmware.h>
0016 #include <linux/pnp.h>
0017 #include <linux/spinlock.h>
0018 #include <linux/module.h>
0019 #include <asm/dma.h>
0020 #include <sound/core.h>
0021 #include <sound/wss.h>
0022 #include <sound/mpu401.h>
0023 #include <sound/initval.h>
0024 
0025 
0026 MODULE_AUTHOR("Chris Rankin");
0027 MODULE_DESCRIPTION("ENSONIQ SoundScape driver");
0028 MODULE_LICENSE("GPL");
0029 MODULE_FIRMWARE("sndscape.co0");
0030 MODULE_FIRMWARE("sndscape.co1");
0031 MODULE_FIRMWARE("sndscape.co2");
0032 MODULE_FIRMWARE("sndscape.co3");
0033 MODULE_FIRMWARE("sndscape.co4");
0034 MODULE_FIRMWARE("scope.cod");
0035 
0036 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
0037 static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
0038 static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
0039 static long wss_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT;
0040 static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
0041 static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ;
0042 static int dma[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
0043 static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA;
0044 static bool joystick[SNDRV_CARDS];
0045 
0046 module_param_array(index, int, NULL, 0444);
0047 MODULE_PARM_DESC(index, "Index number for SoundScape soundcard");
0048 
0049 module_param_array(id, charp, NULL, 0444);
0050 MODULE_PARM_DESC(id, "Description for SoundScape card");
0051 
0052 module_param_hw_array(port, long, ioport, NULL, 0444);
0053 MODULE_PARM_DESC(port, "Port # for SoundScape driver.");
0054 
0055 module_param_hw_array(wss_port, long, ioport, NULL, 0444);
0056 MODULE_PARM_DESC(wss_port, "WSS Port # for SoundScape driver.");
0057 
0058 module_param_hw_array(irq, int, irq, NULL, 0444);
0059 MODULE_PARM_DESC(irq, "IRQ # for SoundScape driver.");
0060 
0061 module_param_hw_array(mpu_irq, int, irq, NULL, 0444);
0062 MODULE_PARM_DESC(mpu_irq, "MPU401 IRQ # for SoundScape driver.");
0063 
0064 module_param_hw_array(dma, int, dma, NULL, 0444);
0065 MODULE_PARM_DESC(dma, "DMA # for SoundScape driver.");
0066 
0067 module_param_hw_array(dma2, int, dma, NULL, 0444);
0068 MODULE_PARM_DESC(dma2, "DMA2 # for SoundScape driver.");
0069 
0070 module_param_array(joystick, bool, NULL, 0444);
0071 MODULE_PARM_DESC(joystick, "Enable gameport.");
0072 
0073 #ifdef CONFIG_PNP
0074 static int isa_registered;
0075 static int pnp_registered;
0076 
0077 static const struct pnp_card_device_id sscape_pnpids[] = {
0078     { .id = "ENS3081", .devs = { { "ENS0000" } } }, /* Soundscape PnP */
0079     { .id = "ENS4081", .devs = { { "ENS1011" } } }, /* VIVO90 */
0080     { .id = "" }    /* end */
0081 };
0082 
0083 MODULE_DEVICE_TABLE(pnp_card, sscape_pnpids);
0084 #endif
0085 
0086 
0087 #define HOST_CTRL_IO(i)  ((i) + 2)
0088 #define HOST_DATA_IO(i)  ((i) + 3)
0089 #define ODIE_ADDR_IO(i)  ((i) + 4)
0090 #define ODIE_DATA_IO(i)  ((i) + 5)
0091 #define CODEC_IO(i)      ((i) + 8)
0092 
0093 #define IC_ODIE  1
0094 #define IC_OPUS  2
0095 
0096 #define RX_READY 0x01
0097 #define TX_READY 0x02
0098 
0099 #define CMD_ACK         0x80
0100 #define CMD_SET_MIDI_VOL    0x84
0101 #define CMD_GET_MIDI_VOL    0x85
0102 #define CMD_XXX_MIDI_VOL    0x86
0103 #define CMD_SET_EXTMIDI     0x8a
0104 #define CMD_GET_EXTMIDI     0x8b
0105 #define CMD_SET_MT32        0x8c
0106 #define CMD_GET_MT32        0x8d
0107 
0108 enum GA_REG {
0109     GA_INTSTAT_REG = 0,
0110     GA_INTENA_REG,
0111     GA_DMAA_REG,
0112     GA_DMAB_REG,
0113     GA_INTCFG_REG,
0114     GA_DMACFG_REG,
0115     GA_CDCFG_REG,
0116     GA_SMCFGA_REG,
0117     GA_SMCFGB_REG,
0118     GA_HMCTL_REG
0119 };
0120 
0121 #define DMA_8BIT  0x80
0122 
0123 
0124 enum card_type {
0125     MEDIA_FX,   /* Sequoia S-1000 */
0126     SSCAPE,     /* Sequoia S-2000 */
0127     SSCAPE_PNP,
0128     SSCAPE_VIVO,
0129 };
0130 
0131 struct soundscape {
0132     spinlock_t lock;
0133     unsigned io_base;
0134     int ic_type;
0135     enum card_type type;
0136     struct resource *io_res;
0137     struct resource *wss_res;
0138     struct snd_wss *chip;
0139 
0140     unsigned char midi_vol;
0141 };
0142 
0143 #define INVALID_IRQ  ((unsigned)-1)
0144 
0145 
0146 static inline struct soundscape *get_card_soundscape(struct snd_card *c)
0147 {
0148     return (struct soundscape *) (c->private_data);
0149 }
0150 
0151 /*
0152  * Allocates some kernel memory that we can use for DMA.
0153  * I think this means that the memory has to map to
0154  * contiguous pages of physical memory.
0155  */
0156 static struct snd_dma_buffer *get_dmabuf(struct soundscape *s,
0157                      struct snd_dma_buffer *buf,
0158                      unsigned long size)
0159 {
0160     if (buf) {
0161         if (snd_dma_alloc_pages_fallback(SNDRV_DMA_TYPE_DEV,
0162                          s->chip->card->dev,
0163                          size, buf) < 0) {
0164             snd_printk(KERN_ERR "sscape: Failed to allocate "
0165                         "%lu bytes for DMA\n",
0166                         size);
0167             return NULL;
0168         }
0169     }
0170 
0171     return buf;
0172 }
0173 
0174 /*
0175  * Release the DMA-able kernel memory ...
0176  */
0177 static void free_dmabuf(struct snd_dma_buffer *buf)
0178 {
0179     if (buf && buf->area)
0180         snd_dma_free_pages(buf);
0181 }
0182 
0183 /*
0184  * This function writes to the SoundScape's control registers,
0185  * but doesn't do any locking. It's up to the caller to do that.
0186  * This is why this function is "unsafe" ...
0187  */
0188 static inline void sscape_write_unsafe(unsigned io_base, enum GA_REG reg,
0189                        unsigned char val)
0190 {
0191     outb(reg, ODIE_ADDR_IO(io_base));
0192     outb(val, ODIE_DATA_IO(io_base));
0193 }
0194 
0195 /*
0196  * Write to the SoundScape's control registers, and do the
0197  * necessary locking ...
0198  */
0199 static void sscape_write(struct soundscape *s, enum GA_REG reg,
0200              unsigned char val)
0201 {
0202     unsigned long flags;
0203 
0204     spin_lock_irqsave(&s->lock, flags);
0205     sscape_write_unsafe(s->io_base, reg, val);
0206     spin_unlock_irqrestore(&s->lock, flags);
0207 }
0208 
0209 /*
0210  * Read from the SoundScape's control registers, but leave any
0211  * locking to the caller. This is why the function is "unsafe" ...
0212  */
0213 static inline unsigned char sscape_read_unsafe(unsigned io_base,
0214                            enum GA_REG reg)
0215 {
0216     outb(reg, ODIE_ADDR_IO(io_base));
0217     return inb(ODIE_DATA_IO(io_base));
0218 }
0219 
0220 /*
0221  * Puts the SoundScape into "host" mode, as compared to "MIDI" mode
0222  */
0223 static inline void set_host_mode_unsafe(unsigned io_base)
0224 {
0225     outb(0x0, HOST_CTRL_IO(io_base));
0226 }
0227 
0228 /*
0229  * Puts the SoundScape into "MIDI" mode, as compared to "host" mode
0230  */
0231 static inline void set_midi_mode_unsafe(unsigned io_base)
0232 {
0233     outb(0x3, HOST_CTRL_IO(io_base));
0234 }
0235 
0236 /*
0237  * Read the SoundScape's host-mode control register, but leave
0238  * any locking issues to the caller ...
0239  */
0240 static inline int host_read_unsafe(unsigned io_base)
0241 {
0242     int data = -1;
0243     if ((inb(HOST_CTRL_IO(io_base)) & RX_READY) != 0)
0244         data = inb(HOST_DATA_IO(io_base));
0245 
0246     return data;
0247 }
0248 
0249 /*
0250  * Read the SoundScape's host-mode control register, performing
0251  * a limited amount of busy-waiting if the register isn't ready.
0252  * Also leaves all locking-issues to the caller ...
0253  */
0254 static int host_read_ctrl_unsafe(unsigned io_base, unsigned timeout)
0255 {
0256     int data;
0257 
0258     while (((data = host_read_unsafe(io_base)) < 0) && (timeout != 0)) {
0259         udelay(100);
0260         --timeout;
0261     } /* while */
0262 
0263     return data;
0264 }
0265 
0266 /*
0267  * Write to the SoundScape's host-mode control registers, but
0268  * leave any locking issues to the caller ...
0269  */
0270 static inline int host_write_unsafe(unsigned io_base, unsigned char data)
0271 {
0272     if ((inb(HOST_CTRL_IO(io_base)) & TX_READY) != 0) {
0273         outb(data, HOST_DATA_IO(io_base));
0274         return 1;
0275     }
0276 
0277     return 0;
0278 }
0279 
0280 /*
0281  * Write to the SoundScape's host-mode control registers, performing
0282  * a limited amount of busy-waiting if the register isn't ready.
0283  * Also leaves all locking-issues to the caller ...
0284  */
0285 static int host_write_ctrl_unsafe(unsigned io_base, unsigned char data,
0286                   unsigned timeout)
0287 {
0288     int err;
0289 
0290     while (!(err = host_write_unsafe(io_base, data)) && (timeout != 0)) {
0291         udelay(100);
0292         --timeout;
0293     } /* while */
0294 
0295     return err;
0296 }
0297 
0298 
0299 /*
0300  * Check that the MIDI subsystem is operational. If it isn't,
0301  * then we will hang the computer if we try to use it ...
0302  *
0303  * NOTE: This check is based upon observation, not documentation.
0304  */
0305 static inline int verify_mpu401(const struct snd_mpu401 *mpu)
0306 {
0307     return ((inb(MPU401C(mpu)) & 0xc0) == 0x80);
0308 }
0309 
0310 /*
0311  * This is apparently the standard way to initialise an MPU-401
0312  */
0313 static inline void initialise_mpu401(const struct snd_mpu401 *mpu)
0314 {
0315     outb(0, MPU401D(mpu));
0316 }
0317 
0318 /*
0319  * Tell the SoundScape to activate the AD1845 chip (I think).
0320  * The AD1845 detection fails if we *don't* do this, so I
0321  * think that this is a good idea ...
0322  */
0323 static void activate_ad1845_unsafe(unsigned io_base)
0324 {
0325     unsigned char val = sscape_read_unsafe(io_base, GA_HMCTL_REG);
0326     sscape_write_unsafe(io_base, GA_HMCTL_REG, (val & 0xcf) | 0x10);
0327     sscape_write_unsafe(io_base, GA_CDCFG_REG, 0x80);
0328 }
0329 
0330 /*
0331  * Tell the SoundScape to begin a DMA transfer using the given channel.
0332  * All locking issues are left to the caller.
0333  */
0334 static void sscape_start_dma_unsafe(unsigned io_base, enum GA_REG reg)
0335 {
0336     sscape_write_unsafe(io_base, reg,
0337                 sscape_read_unsafe(io_base, reg) | 0x01);
0338     sscape_write_unsafe(io_base, reg,
0339                 sscape_read_unsafe(io_base, reg) & 0xfe);
0340 }
0341 
0342 /*
0343  * Wait for a DMA transfer to complete. This is a "limited busy-wait",
0344  * and all locking issues are left to the caller.
0345  */
0346 static int sscape_wait_dma_unsafe(unsigned io_base, enum GA_REG reg,
0347                   unsigned timeout)
0348 {
0349     while (!(sscape_read_unsafe(io_base, reg) & 0x01) && (timeout != 0)) {
0350         udelay(100);
0351         --timeout;
0352     } /* while */
0353 
0354     return sscape_read_unsafe(io_base, reg) & 0x01;
0355 }
0356 
0357 /*
0358  * Wait for the On-Board Processor to return its start-up
0359  * acknowledgement sequence. This wait is too long for
0360  * us to perform "busy-waiting", and so we must sleep.
0361  * This in turn means that we must not be holding any
0362  * spinlocks when we call this function.
0363  */
0364 static int obp_startup_ack(struct soundscape *s, unsigned timeout)
0365 {
0366     unsigned long end_time = jiffies + msecs_to_jiffies(timeout);
0367 
0368     do {
0369         unsigned long flags;
0370         int x;
0371 
0372         spin_lock_irqsave(&s->lock, flags);
0373         x = host_read_unsafe(s->io_base);
0374         spin_unlock_irqrestore(&s->lock, flags);
0375         if (x == 0xfe || x == 0xff)
0376             return 1;
0377 
0378         msleep(10);
0379     } while (time_before(jiffies, end_time));
0380 
0381     return 0;
0382 }
0383 
0384 /*
0385  * Wait for the host to return its start-up acknowledgement
0386  * sequence. This wait is too long for us to perform
0387  * "busy-waiting", and so we must sleep. This in turn means
0388  * that we must not be holding any spinlocks when we call
0389  * this function.
0390  */
0391 static int host_startup_ack(struct soundscape *s, unsigned timeout)
0392 {
0393     unsigned long end_time = jiffies + msecs_to_jiffies(timeout);
0394 
0395     do {
0396         unsigned long flags;
0397         int x;
0398 
0399         spin_lock_irqsave(&s->lock, flags);
0400         x = host_read_unsafe(s->io_base);
0401         spin_unlock_irqrestore(&s->lock, flags);
0402         if (x == 0xfe)
0403             return 1;
0404 
0405         msleep(10);
0406     } while (time_before(jiffies, end_time));
0407 
0408     return 0;
0409 }
0410 
0411 /*
0412  * Upload a byte-stream into the SoundScape using DMA channel A.
0413  */
0414 static int upload_dma_data(struct soundscape *s, const unsigned char *data,
0415                size_t size)
0416 {
0417     unsigned long flags;
0418     struct snd_dma_buffer dma;
0419     int ret;
0420     unsigned char val;
0421 
0422     if (!get_dmabuf(s, &dma, PAGE_ALIGN(32 * 1024)))
0423         return -ENOMEM;
0424 
0425     spin_lock_irqsave(&s->lock, flags);
0426 
0427     /*
0428      * Reset the board ...
0429      */
0430     val = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
0431     sscape_write_unsafe(s->io_base, GA_HMCTL_REG, val & 0x3f);
0432 
0433     /*
0434      * Enable the DMA channels and configure them ...
0435      */
0436     val = (s->chip->dma1 << 4) | DMA_8BIT;
0437     sscape_write_unsafe(s->io_base, GA_DMAA_REG, val);
0438     sscape_write_unsafe(s->io_base, GA_DMAB_REG, 0x20);
0439 
0440     /*
0441      * Take the board out of reset ...
0442      */
0443     val = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
0444     sscape_write_unsafe(s->io_base, GA_HMCTL_REG, val | 0x80);
0445 
0446     /*
0447      * Upload the firmware to the SoundScape
0448      * board through the DMA channel ...
0449      */
0450     while (size != 0) {
0451         unsigned long len;
0452 
0453         len = min(size, dma.bytes);
0454         memcpy(dma.area, data, len);
0455         data += len;
0456         size -= len;
0457 
0458         snd_dma_program(s->chip->dma1, dma.addr, len, DMA_MODE_WRITE);
0459         sscape_start_dma_unsafe(s->io_base, GA_DMAA_REG);
0460         if (!sscape_wait_dma_unsafe(s->io_base, GA_DMAA_REG, 5000)) {
0461             /*
0462              * Don't forget to release this spinlock we're holding
0463              */
0464             spin_unlock_irqrestore(&s->lock, flags);
0465 
0466             snd_printk(KERN_ERR
0467                     "sscape: DMA upload has timed out\n");
0468             ret = -EAGAIN;
0469             goto _release_dma;
0470         }
0471     } /* while */
0472 
0473     set_host_mode_unsafe(s->io_base);
0474     outb(0x0, s->io_base);
0475 
0476     /*
0477      * Boot the board ... (I think)
0478      */
0479     val = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
0480     sscape_write_unsafe(s->io_base, GA_HMCTL_REG, val | 0x40);
0481     spin_unlock_irqrestore(&s->lock, flags);
0482 
0483     /*
0484      * If all has gone well, then the board should acknowledge
0485      * the new upload and tell us that it has rebooted OK. We
0486      * give it 5 seconds (max) ...
0487      */
0488     ret = 0;
0489     if (!obp_startup_ack(s, 5000)) {
0490         snd_printk(KERN_ERR "sscape: No response "
0491                     "from on-board processor after upload\n");
0492         ret = -EAGAIN;
0493     } else if (!host_startup_ack(s, 5000)) {
0494         snd_printk(KERN_ERR
0495                 "sscape: SoundScape failed to initialise\n");
0496         ret = -EAGAIN;
0497     }
0498 
0499 _release_dma:
0500     /*
0501      * NOTE!!! We are NOT holding any spinlocks at this point !!!
0502      */
0503     sscape_write(s, GA_DMAA_REG, (s->ic_type == IC_OPUS ? 0x40 : 0x70));
0504     free_dmabuf(&dma);
0505 
0506     return ret;
0507 }
0508 
0509 /*
0510  * Upload the bootblock(?) into the SoundScape. The only
0511  * purpose of this block of code seems to be to tell
0512  * us which version of the microcode we should be using.
0513  */
0514 static int sscape_upload_bootblock(struct snd_card *card)
0515 {
0516     struct soundscape *sscape = get_card_soundscape(card);
0517     unsigned long flags;
0518     const struct firmware *init_fw = NULL;
0519     int data = 0;
0520     int ret;
0521 
0522     ret = request_firmware(&init_fw, "scope.cod", card->dev);
0523     if (ret < 0) {
0524         snd_printk(KERN_ERR "sscape: Error loading scope.cod");
0525         return ret;
0526     }
0527     ret = upload_dma_data(sscape, init_fw->data, init_fw->size);
0528 
0529     release_firmware(init_fw);
0530 
0531     spin_lock_irqsave(&sscape->lock, flags);
0532     if (ret == 0)
0533         data = host_read_ctrl_unsafe(sscape->io_base, 100);
0534 
0535     if (data & 0x10)
0536         sscape_write_unsafe(sscape->io_base, GA_SMCFGA_REG, 0x2f);
0537 
0538     spin_unlock_irqrestore(&sscape->lock, flags);
0539 
0540     data &= 0xf;
0541     if (ret == 0 && data > 7) {
0542         snd_printk(KERN_ERR
0543                 "sscape: timeout reading firmware version\n");
0544         ret = -EAGAIN;
0545     }
0546 
0547     return (ret == 0) ? data : ret;
0548 }
0549 
0550 /*
0551  * Upload the microcode into the SoundScape.
0552  */
0553 static int sscape_upload_microcode(struct snd_card *card, int version)
0554 {
0555     struct soundscape *sscape = get_card_soundscape(card);
0556     const struct firmware *init_fw = NULL;
0557     char name[14];
0558     int err;
0559 
0560     snprintf(name, sizeof(name), "sndscape.co%d", version);
0561 
0562     err = request_firmware(&init_fw, name, card->dev);
0563     if (err < 0) {
0564         snd_printk(KERN_ERR "sscape: Error loading sndscape.co%d",
0565                 version);
0566         return err;
0567     }
0568     err = upload_dma_data(sscape, init_fw->data, init_fw->size);
0569     if (err == 0)
0570         snd_printk(KERN_INFO "sscape: MIDI firmware loaded %zu KBs\n",
0571                 init_fw->size >> 10);
0572 
0573     release_firmware(init_fw);
0574 
0575     return err;
0576 }
0577 
0578 /*
0579  * Mixer control for the SoundScape's MIDI device.
0580  */
0581 static int sscape_midi_info(struct snd_kcontrol *ctl,
0582                 struct snd_ctl_elem_info *uinfo)
0583 {
0584     uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0585     uinfo->count = 1;
0586     uinfo->value.integer.min = 0;
0587     uinfo->value.integer.max = 127;
0588     return 0;
0589 }
0590 
0591 static int sscape_midi_get(struct snd_kcontrol *kctl,
0592                struct snd_ctl_elem_value *uctl)
0593 {
0594     struct snd_wss *chip = snd_kcontrol_chip(kctl);
0595     struct snd_card *card = chip->card;
0596     register struct soundscape *s = get_card_soundscape(card);
0597     unsigned long flags;
0598 
0599     spin_lock_irqsave(&s->lock, flags);
0600     uctl->value.integer.value[0] = s->midi_vol;
0601     spin_unlock_irqrestore(&s->lock, flags);
0602     return 0;
0603 }
0604 
0605 static int sscape_midi_put(struct snd_kcontrol *kctl,
0606                struct snd_ctl_elem_value *uctl)
0607 {
0608     struct snd_wss *chip = snd_kcontrol_chip(kctl);
0609     struct snd_card *card = chip->card;
0610     struct soundscape *s = get_card_soundscape(card);
0611     unsigned long flags;
0612     int change;
0613     unsigned char new_val;
0614 
0615     spin_lock_irqsave(&s->lock, flags);
0616 
0617     new_val = uctl->value.integer.value[0] & 127;
0618     /*
0619      * We need to put the board into HOST mode before we
0620      * can send any volume-changing HOST commands ...
0621      */
0622     set_host_mode_unsafe(s->io_base);
0623 
0624     /*
0625      * To successfully change the MIDI volume setting, you seem to
0626      * have to write a volume command, write the new volume value,
0627      * and then perform another volume-related command. Perhaps the
0628      * first command is an "open" and the second command is a "close"?
0629      */
0630     if (s->midi_vol == new_val) {
0631         change = 0;
0632         goto __skip_change;
0633     }
0634     change = host_write_ctrl_unsafe(s->io_base, CMD_SET_MIDI_VOL, 100)
0635          && host_write_ctrl_unsafe(s->io_base, new_val, 100)
0636          && host_write_ctrl_unsafe(s->io_base, CMD_XXX_MIDI_VOL, 100)
0637          && host_write_ctrl_unsafe(s->io_base, new_val, 100);
0638     s->midi_vol = new_val;
0639 __skip_change:
0640 
0641     /*
0642      * Take the board out of HOST mode and back into MIDI mode ...
0643      */
0644     set_midi_mode_unsafe(s->io_base);
0645 
0646     spin_unlock_irqrestore(&s->lock, flags);
0647     return change;
0648 }
0649 
0650 static const struct snd_kcontrol_new midi_mixer_ctl = {
0651     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0652     .name = "MIDI",
0653     .info = sscape_midi_info,
0654     .get = sscape_midi_get,
0655     .put = sscape_midi_put
0656 };
0657 
0658 /*
0659  * The SoundScape can use two IRQs from a possible set of four.
0660  * These IRQs are encoded as bit patterns so that they can be
0661  * written to the control registers.
0662  */
0663 static unsigned get_irq_config(int sscape_type, int irq)
0664 {
0665     static const int valid_irq[] = { 9, 5, 7, 10 };
0666     static const int old_irq[] = { 9, 7, 5, 15 };
0667     unsigned cfg;
0668 
0669     if (sscape_type == MEDIA_FX) {
0670         for (cfg = 0; cfg < ARRAY_SIZE(old_irq); ++cfg)
0671             if (irq == old_irq[cfg])
0672                 return cfg;
0673     } else {
0674         for (cfg = 0; cfg < ARRAY_SIZE(valid_irq); ++cfg)
0675             if (irq == valid_irq[cfg])
0676                 return cfg;
0677     }
0678 
0679     return INVALID_IRQ;
0680 }
0681 
0682 /*
0683  * Perform certain arcane port-checks to see whether there
0684  * is a SoundScape board lurking behind the given ports.
0685  */
0686 static int detect_sscape(struct soundscape *s, long wss_io)
0687 {
0688     unsigned long flags;
0689     unsigned d;
0690     int retval = 0;
0691 
0692     spin_lock_irqsave(&s->lock, flags);
0693 
0694     /*
0695      * The following code is lifted from the original OSS driver,
0696      * and as I don't have a datasheet I cannot really comment
0697      * on what it is doing...
0698      */
0699     if ((inb(HOST_CTRL_IO(s->io_base)) & 0x78) != 0)
0700         goto _done;
0701 
0702     d = inb(ODIE_ADDR_IO(s->io_base)) & 0xf0;
0703     if ((d & 0x80) != 0)
0704         goto _done;
0705 
0706     if (d == 0)
0707         s->ic_type = IC_ODIE;
0708     else if ((d & 0x60) != 0)
0709         s->ic_type = IC_OPUS;
0710     else
0711         goto _done;
0712 
0713     outb(0xfa, ODIE_ADDR_IO(s->io_base));
0714     if ((inb(ODIE_ADDR_IO(s->io_base)) & 0x9f) != 0x0a)
0715         goto _done;
0716 
0717     outb(0xfe, ODIE_ADDR_IO(s->io_base));
0718     if ((inb(ODIE_ADDR_IO(s->io_base)) & 0x9f) != 0x0e)
0719         goto _done;
0720 
0721     outb(0xfe, ODIE_ADDR_IO(s->io_base));
0722     d = inb(ODIE_DATA_IO(s->io_base));
0723     if (s->type != SSCAPE_VIVO && (d & 0x9f) != 0x0e)
0724         goto _done;
0725 
0726     if (s->ic_type == IC_OPUS)
0727         activate_ad1845_unsafe(s->io_base);
0728 
0729     if (s->type == SSCAPE_VIVO)
0730         wss_io += 4;
0731 
0732     d  = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
0733     sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0);
0734 
0735     /* wait for WSS codec */
0736     for (d = 0; d < 500; d++) {
0737         if ((inb(wss_io) & 0x80) == 0)
0738             break;
0739         spin_unlock_irqrestore(&s->lock, flags);
0740         msleep(1);
0741         spin_lock_irqsave(&s->lock, flags);
0742     }
0743 
0744     if ((inb(wss_io) & 0x80) != 0)
0745         goto _done;
0746 
0747     if (inb(wss_io + 2) == 0xff)
0748         goto _done;
0749 
0750     d  = sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f;
0751     sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d);
0752 
0753     if ((inb(wss_io) & 0x80) != 0)
0754         s->type = MEDIA_FX;
0755 
0756     d = sscape_read_unsafe(s->io_base, GA_HMCTL_REG);
0757     sscape_write_unsafe(s->io_base, GA_HMCTL_REG, d | 0xc0);
0758     /* wait for WSS codec */
0759     for (d = 0; d < 500; d++) {
0760         if ((inb(wss_io) & 0x80) == 0)
0761             break;
0762         spin_unlock_irqrestore(&s->lock, flags);
0763         msleep(1);
0764         spin_lock_irqsave(&s->lock, flags);
0765     }
0766 
0767     /*
0768      * SoundScape successfully detected!
0769      */
0770     retval = 1;
0771 
0772 _done:
0773     spin_unlock_irqrestore(&s->lock, flags);
0774     return retval;
0775 }
0776 
0777 /*
0778  * ALSA callback function, called when attempting to open the MIDI device.
0779  * Check that the MIDI firmware has been loaded, because we don't want
0780  * to crash the machine. Also check that someone isn't using the hardware
0781  * IOCTL device.
0782  */
0783 static int mpu401_open(struct snd_mpu401 *mpu)
0784 {
0785     if (!verify_mpu401(mpu)) {
0786         snd_printk(KERN_ERR "sscape: MIDI disabled, "
0787                     "please load firmware\n");
0788         return -ENODEV;
0789     }
0790 
0791     return 0;
0792 }
0793 
0794 /*
0795  * Initialise an MPU-401 subdevice for MIDI support on the SoundScape.
0796  */
0797 static int create_mpu401(struct snd_card *card, int devnum,
0798              unsigned long port, int irq)
0799 {
0800     struct soundscape *sscape = get_card_soundscape(card);
0801     struct snd_rawmidi *rawmidi;
0802     int err;
0803 
0804     err = snd_mpu401_uart_new(card, devnum, MPU401_HW_MPU401, port,
0805                   MPU401_INFO_INTEGRATED, irq, &rawmidi);
0806     if (err == 0) {
0807         struct snd_mpu401 *mpu = rawmidi->private_data;
0808         mpu->open_input = mpu401_open;
0809         mpu->open_output = mpu401_open;
0810         mpu->private_data = sscape;
0811 
0812         initialise_mpu401(mpu);
0813     }
0814 
0815     return err;
0816 }
0817 
0818 
0819 /*
0820  * Create an AD1845 PCM subdevice on the SoundScape. The AD1845
0821  * is very much like a CS4231, with a few extra bits. We will
0822  * try to support at least some of the extra bits by overriding
0823  * some of the CS4231 callback.
0824  */
0825 static int create_ad1845(struct snd_card *card, unsigned port,
0826              int irq, int dma1, int dma2)
0827 {
0828     register struct soundscape *sscape = get_card_soundscape(card);
0829     struct snd_wss *chip;
0830     int err;
0831     int codec_type = WSS_HW_DETECT;
0832 
0833     switch (sscape->type) {
0834     case MEDIA_FX:
0835     case SSCAPE:
0836         /*
0837          * There are some freak examples of early Soundscape cards
0838          * with CS4231 instead of AD1848/CS4248. Unfortunately, the
0839          * CS4231 works only in CS4248 compatibility mode on
0840          * these cards so force it.
0841          */
0842         if (sscape->ic_type != IC_OPUS)
0843             codec_type = WSS_HW_AD1848;
0844         break;
0845 
0846     case SSCAPE_VIVO:
0847         port += 4;
0848         break;
0849     default:
0850         break;
0851     }
0852 
0853     err = snd_wss_create(card, port, -1, irq, dma1, dma2,
0854                  codec_type, WSS_HWSHARE_DMA1, &chip);
0855     if (!err) {
0856         unsigned long flags;
0857 
0858         if (sscape->type != SSCAPE_VIVO) {
0859             /*
0860              * The input clock frequency on the SoundScape must
0861              * be 14.31818 MHz, because we must set this register
0862              * to get the playback to sound correct ...
0863              */
0864             snd_wss_mce_up(chip);
0865             spin_lock_irqsave(&chip->reg_lock, flags);
0866             snd_wss_out(chip, AD1845_CLOCK, 0x20);
0867             spin_unlock_irqrestore(&chip->reg_lock, flags);
0868             snd_wss_mce_down(chip);
0869 
0870         }
0871 
0872         err = snd_wss_pcm(chip, 0);
0873         if (err < 0) {
0874             snd_printk(KERN_ERR "sscape: No PCM device "
0875                         "for AD1845 chip\n");
0876             goto _error;
0877         }
0878 
0879         err = snd_wss_mixer(chip);
0880         if (err < 0) {
0881             snd_printk(KERN_ERR "sscape: No mixer device "
0882                         "for AD1845 chip\n");
0883             goto _error;
0884         }
0885         if (chip->hardware != WSS_HW_AD1848) {
0886             err = snd_wss_timer(chip, 0);
0887             if (err < 0) {
0888                 snd_printk(KERN_ERR "sscape: No timer device "
0889                             "for AD1845 chip\n");
0890                 goto _error;
0891             }
0892         }
0893 
0894         if (sscape->type != SSCAPE_VIVO) {
0895             err = snd_ctl_add(card,
0896                       snd_ctl_new1(&midi_mixer_ctl, chip));
0897             if (err < 0) {
0898                 snd_printk(KERN_ERR "sscape: Could not create "
0899                             "MIDI mixer control\n");
0900                 goto _error;
0901             }
0902         }
0903 
0904         sscape->chip = chip;
0905     }
0906 
0907 _error:
0908     return err;
0909 }
0910 
0911 
0912 /*
0913  * Create an ALSA soundcard entry for the SoundScape, using
0914  * the given list of port, IRQ and DMA resources.
0915  */
0916 static int create_sscape(int dev, struct snd_card *card)
0917 {
0918     struct soundscape *sscape = get_card_soundscape(card);
0919     unsigned dma_cfg;
0920     unsigned irq_cfg;
0921     unsigned mpu_irq_cfg;
0922     struct resource *io_res;
0923     struct resource *wss_res;
0924     unsigned long flags;
0925     int err;
0926     int val;
0927     const char *name;
0928 
0929     /*
0930      * Grab IO ports that we will need to probe so that we
0931      * can detect and control this hardware ...
0932      */
0933     io_res = devm_request_region(card->dev, port[dev], 8, "SoundScape");
0934     if (!io_res) {
0935         snd_printk(KERN_ERR
0936                "sscape: can't grab port 0x%lx\n", port[dev]);
0937         return -EBUSY;
0938     }
0939     wss_res = NULL;
0940     if (sscape->type == SSCAPE_VIVO) {
0941         wss_res = devm_request_region(card->dev, wss_port[dev], 4,
0942                           "SoundScape");
0943         if (!wss_res) {
0944             snd_printk(KERN_ERR "sscape: can't grab port 0x%lx\n",
0945                         wss_port[dev]);
0946             return -EBUSY;
0947         }
0948     }
0949 
0950     /*
0951      * Grab one DMA channel ...
0952      */
0953     err = snd_devm_request_dma(card->dev, dma[dev], "SoundScape");
0954     if (err < 0) {
0955         snd_printk(KERN_ERR "sscape: can't grab DMA %d\n", dma[dev]);
0956         return err;
0957     }
0958 
0959     spin_lock_init(&sscape->lock);
0960     sscape->io_res = io_res;
0961     sscape->wss_res = wss_res;
0962     sscape->io_base = port[dev];
0963 
0964     if (!detect_sscape(sscape, wss_port[dev])) {
0965         printk(KERN_ERR "sscape: hardware not detected at 0x%x\n",
0966             sscape->io_base);
0967         return -ENODEV;
0968     }
0969 
0970     switch (sscape->type) {
0971     case MEDIA_FX:
0972         name = "MediaFX/SoundFX";
0973         break;
0974     case SSCAPE:
0975         name = "Soundscape";
0976         break;
0977     case SSCAPE_PNP:
0978         name = "Soundscape PnP";
0979         break;
0980     case SSCAPE_VIVO:
0981         name = "Soundscape VIVO";
0982         break;
0983     default:
0984         name = "unknown Soundscape";
0985         break;
0986     }
0987 
0988     printk(KERN_INFO "sscape: %s card detected at 0x%x, using IRQ %d, DMA %d\n",
0989              name, sscape->io_base, irq[dev], dma[dev]);
0990 
0991     /*
0992      * Check that the user didn't pass us garbage data ...
0993      */
0994     irq_cfg = get_irq_config(sscape->type, irq[dev]);
0995     if (irq_cfg == INVALID_IRQ) {
0996         snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", irq[dev]);
0997         return -ENXIO;
0998     }
0999 
1000     mpu_irq_cfg = get_irq_config(sscape->type, mpu_irq[dev]);
1001     if (mpu_irq_cfg == INVALID_IRQ) {
1002         snd_printk(KERN_ERR "sscape: Invalid IRQ %d\n", mpu_irq[dev]);
1003         return -ENXIO;
1004     }
1005 
1006     /*
1007      * Tell the on-board devices where their resources are (I think -
1008      * I can't be sure without a datasheet ... So many magic values!)
1009      */
1010     spin_lock_irqsave(&sscape->lock, flags);
1011 
1012     sscape_write_unsafe(sscape->io_base, GA_SMCFGA_REG, 0x2e);
1013     sscape_write_unsafe(sscape->io_base, GA_SMCFGB_REG, 0x00);
1014 
1015     /*
1016      * Enable and configure the DMA channels ...
1017      */
1018     sscape_write_unsafe(sscape->io_base, GA_DMACFG_REG, 0x50);
1019     dma_cfg = (sscape->ic_type == IC_OPUS ? 0x40 : 0x70);
1020     sscape_write_unsafe(sscape->io_base, GA_DMAA_REG, dma_cfg);
1021     sscape_write_unsafe(sscape->io_base, GA_DMAB_REG, 0x20);
1022 
1023     mpu_irq_cfg |= mpu_irq_cfg << 2;
1024     val = sscape_read_unsafe(sscape->io_base, GA_HMCTL_REG) & 0xF7;
1025     if (joystick[dev])
1026         val |= 8;
1027     sscape_write_unsafe(sscape->io_base, GA_HMCTL_REG, val | 0x10);
1028     sscape_write_unsafe(sscape->io_base, GA_INTCFG_REG, 0xf0 | mpu_irq_cfg);
1029     sscape_write_unsafe(sscape->io_base,
1030                 GA_CDCFG_REG, 0x09 | DMA_8BIT
1031                 | (dma[dev] << 4) | (irq_cfg << 1));
1032     /*
1033      * Enable the master IRQ ...
1034      */
1035     sscape_write_unsafe(sscape->io_base, GA_INTENA_REG, 0x80);
1036 
1037     spin_unlock_irqrestore(&sscape->lock, flags);
1038 
1039     /*
1040      * We have now enabled the codec chip, and so we should
1041      * detect the AD1845 device ...
1042      */
1043     err = create_ad1845(card, wss_port[dev], irq[dev],
1044                 dma[dev], dma2[dev]);
1045     if (err < 0) {
1046         snd_printk(KERN_ERR
1047                 "sscape: No AD1845 device at 0x%lx, IRQ %d\n",
1048                 wss_port[dev], irq[dev]);
1049         return err;
1050     }
1051     strcpy(card->driver, "SoundScape");
1052     strcpy(card->shortname, name);
1053     snprintf(card->longname, sizeof(card->longname),
1054          "%s at 0x%lx, IRQ %d, DMA1 %d, DMA2 %d\n",
1055          name, sscape->chip->port, sscape->chip->irq,
1056          sscape->chip->dma1, sscape->chip->dma2);
1057 
1058 #define MIDI_DEVNUM  0
1059     if (sscape->type != SSCAPE_VIVO) {
1060         err = sscape_upload_bootblock(card);
1061         if (err >= 0)
1062             err = sscape_upload_microcode(card, err);
1063 
1064         if (err == 0) {
1065             err = create_mpu401(card, MIDI_DEVNUM, port[dev],
1066                         mpu_irq[dev]);
1067             if (err < 0) {
1068                 snd_printk(KERN_ERR "sscape: Failed to create "
1069                         "MPU-401 device at 0x%lx\n",
1070                         port[dev]);
1071                 return err;
1072             }
1073 
1074             /*
1075              * Initialize mixer
1076              */
1077             spin_lock_irqsave(&sscape->lock, flags);
1078             sscape->midi_vol = 0;
1079             host_write_ctrl_unsafe(sscape->io_base,
1080                         CMD_SET_MIDI_VOL, 100);
1081             host_write_ctrl_unsafe(sscape->io_base,
1082                         sscape->midi_vol, 100);
1083             host_write_ctrl_unsafe(sscape->io_base,
1084                         CMD_XXX_MIDI_VOL, 100);
1085             host_write_ctrl_unsafe(sscape->io_base,
1086                         sscape->midi_vol, 100);
1087             host_write_ctrl_unsafe(sscape->io_base,
1088                         CMD_SET_EXTMIDI, 100);
1089             host_write_ctrl_unsafe(sscape->io_base,
1090                         0, 100);
1091             host_write_ctrl_unsafe(sscape->io_base, CMD_ACK, 100);
1092 
1093             set_midi_mode_unsafe(sscape->io_base);
1094             spin_unlock_irqrestore(&sscape->lock, flags);
1095         }
1096     }
1097 
1098     return 0;
1099 }
1100 
1101 
1102 static int snd_sscape_match(struct device *pdev, unsigned int i)
1103 {
1104     /*
1105      * Make sure we were given ALL of the other parameters.
1106      */
1107     if (port[i] == SNDRV_AUTO_PORT)
1108         return 0;
1109 
1110     if (irq[i] == SNDRV_AUTO_IRQ ||
1111         mpu_irq[i] == SNDRV_AUTO_IRQ ||
1112         dma[i] == SNDRV_AUTO_DMA) {
1113         printk(KERN_INFO
1114                "sscape: insufficient parameters, "
1115                "need IO, IRQ, MPU-IRQ and DMA\n");
1116         return 0;
1117     }
1118 
1119     return 1;
1120 }
1121 
1122 static int snd_sscape_probe(struct device *pdev, unsigned int dev)
1123 {
1124     struct snd_card *card;
1125     struct soundscape *sscape;
1126     int ret;
1127 
1128     ret = snd_devm_card_new(pdev, index[dev], id[dev], THIS_MODULE,
1129                 sizeof(struct soundscape), &card);
1130     if (ret < 0)
1131         return ret;
1132 
1133     sscape = get_card_soundscape(card);
1134     sscape->type = SSCAPE;
1135 
1136     dma[dev] &= 0x03;
1137 
1138     ret = create_sscape(dev, card);
1139     if (ret < 0)
1140         return ret;
1141 
1142     ret = snd_card_register(card);
1143     if (ret < 0) {
1144         snd_printk(KERN_ERR "sscape: Failed to register sound card\n");
1145         return ret;
1146     }
1147     dev_set_drvdata(pdev, card);
1148     return 0;
1149 }
1150 
1151 #define DEV_NAME "sscape"
1152 
1153 static struct isa_driver snd_sscape_driver = {
1154     .match      = snd_sscape_match,
1155     .probe      = snd_sscape_probe,
1156     /* FIXME: suspend/resume */
1157     .driver     = {
1158         .name   = DEV_NAME
1159     },
1160 };
1161 
1162 #ifdef CONFIG_PNP
1163 static inline int get_next_autoindex(int i)
1164 {
1165     while (i < SNDRV_CARDS && port[i] != SNDRV_AUTO_PORT)
1166         ++i;
1167     return i;
1168 }
1169 
1170 
1171 static int sscape_pnp_detect(struct pnp_card_link *pcard,
1172                  const struct pnp_card_device_id *pid)
1173 {
1174     static int idx = 0;
1175     struct pnp_dev *dev;
1176     struct snd_card *card;
1177     struct soundscape *sscape;
1178     int ret;
1179 
1180     /*
1181      * Allow this function to fail *quietly* if all the ISA PnP
1182      * devices were configured using module parameters instead.
1183      */
1184     idx = get_next_autoindex(idx);
1185     if (idx >= SNDRV_CARDS)
1186         return -ENOSPC;
1187 
1188     /*
1189      * Check that we still have room for another sound card ...
1190      */
1191     dev = pnp_request_card_device(pcard, pid->devs[0].id, NULL);
1192     if (!dev)
1193         return -ENODEV;
1194 
1195     if (!pnp_is_active(dev)) {
1196         if (pnp_activate_dev(dev) < 0) {
1197             snd_printk(KERN_INFO "sscape: device is inactive\n");
1198             return -EBUSY;
1199         }
1200     }
1201 
1202     /*
1203      * Create a new ALSA sound card entry, in anticipation
1204      * of detecting our hardware ...
1205      */
1206     ret = snd_devm_card_new(&pcard->card->dev,
1207                 index[idx], id[idx], THIS_MODULE,
1208                 sizeof(struct soundscape), &card);
1209     if (ret < 0)
1210         return ret;
1211 
1212     sscape = get_card_soundscape(card);
1213 
1214     /*
1215      * Identify card model ...
1216      */
1217     if (!strncmp("ENS4081", pid->id, 7))
1218         sscape->type = SSCAPE_VIVO;
1219     else
1220         sscape->type = SSCAPE_PNP;
1221 
1222     /*
1223      * Read the correct parameters off the ISA PnP bus ...
1224      */
1225     port[idx] = pnp_port_start(dev, 0);
1226     irq[idx] = pnp_irq(dev, 0);
1227     mpu_irq[idx] = pnp_irq(dev, 1);
1228     dma[idx] = pnp_dma(dev, 0) & 0x03;
1229     if (sscape->type == SSCAPE_PNP) {
1230         dma2[idx] = dma[idx];
1231         wss_port[idx] = CODEC_IO(port[idx]);
1232     } else {
1233         wss_port[idx] = pnp_port_start(dev, 1);
1234         dma2[idx] = pnp_dma(dev, 1);
1235     }
1236 
1237     ret = create_sscape(idx, card);
1238     if (ret < 0)
1239         return ret;
1240 
1241     ret = snd_card_register(card);
1242     if (ret < 0) {
1243         snd_printk(KERN_ERR "sscape: Failed to register sound card\n");
1244         return ret;
1245     }
1246 
1247     pnp_set_card_drvdata(pcard, card);
1248     ++idx;
1249     return 0;
1250 }
1251 
1252 static struct pnp_card_driver sscape_pnpc_driver = {
1253     .flags = PNP_DRIVER_RES_DO_NOT_CHANGE,
1254     .name = "sscape",
1255     .id_table = sscape_pnpids,
1256     .probe = sscape_pnp_detect,
1257 };
1258 
1259 #endif /* CONFIG_PNP */
1260 
1261 static int __init sscape_init(void)
1262 {
1263     int err;
1264 
1265     err = isa_register_driver(&snd_sscape_driver, SNDRV_CARDS);
1266 #ifdef CONFIG_PNP
1267     if (!err)
1268         isa_registered = 1;
1269 
1270     err = pnp_register_card_driver(&sscape_pnpc_driver);
1271     if (!err)
1272         pnp_registered = 1;
1273 
1274     if (isa_registered)
1275         err = 0;
1276 #endif
1277     return err;
1278 }
1279 
1280 static void __exit sscape_exit(void)
1281 {
1282 #ifdef CONFIG_PNP
1283     if (pnp_registered)
1284         pnp_unregister_card_driver(&sscape_pnpc_driver);
1285     if (isa_registered)
1286 #endif
1287         isa_unregister_driver(&snd_sscape_driver);
1288 }
1289 
1290 module_init(sscape_init);
1291 module_exit(sscape_exit);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!