static int sscape_midi_get(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *uctl) { struct snd_cs4231 *chip = snd_kcontrol_chip(kctl); struct snd_card *card = chip->card; register struct soundscape *s = get_card_soundscape(card); unsigned long flags; spin_lock_irqsave(&s->lock, flags); set_host_mode_unsafe(s->io_base); if (host_write_ctrl_unsafe(s->io_base, CMD_GET_MIDI_VOL, 100)) { uctl->value.integer.value[0] = host_read_ctrl_unsafe(s->io_base, 100); } set_midi_mode_unsafe(s->io_base); spin_unlock_irqrestore(&s->lock, flags); return 0; }
static int sscape_midi_put(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *uctl) { struct snd_wss *chip = snd_kcontrol_chip(kctl); struct snd_card *card = chip->card; register struct soundscape *s = get_card_soundscape(card); unsigned long flags; int change; spin_lock_irqsave(&s->lock, flags); /* * We need to put the board into HOST mode before we * can send any volume-changing HOST commands ... */ set_host_mode_unsafe(s->io_base); /* * To successfully change the MIDI volume setting, you seem to * have to write a volume command, write the new volume value, * and then perform another volume-related command. Perhaps the * first command is an "open" and the second command is a "close"? */ if (s->midi_vol == ((unsigned char) uctl->value.integer. value[0] & 127)) { change = 0; goto __skip_change; } change = (host_write_ctrl_unsafe(s->io_base, CMD_SET_MIDI_VOL, 100) && host_write_ctrl_unsafe(s->io_base, ((unsigned char) uctl->value.integer. value[0]) & 127, 100) && host_write_ctrl_unsafe(s->io_base, CMD_XXX_MIDI_VOL, 100)); s->midi_vol = (unsigned char) uctl->value.integer.value[0] & 127; __skip_change: /* * Take the board out of HOST mode and back into MIDI mode ... */ set_midi_mode_unsafe(s->io_base); spin_unlock_irqrestore(&s->lock, flags); return change; }
/* * Upload a byte-stream into the SoundScape using DMA channel A. */ static int upload_dma_data(struct soundscape *s, const unsigned char __user *data, size_t size) { unsigned long flags; struct snd_dma_buffer dma; int ret; if (!get_dmabuf(&dma, PAGE_ALIGN(size))) return -ENOMEM; spin_lock_irqsave(&s->lock, flags); /* * Reset the board ... */ sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) & 0x3f); /* * Enable the DMA channels and configure them ... */ sscape_write_unsafe(s->io_base, GA_DMACFG_REG, 0x50); sscape_write_unsafe(s->io_base, GA_DMAA_REG, (s->chip->dma1 << 4) | DMA_8BIT); sscape_write_unsafe(s->io_base, GA_DMAB_REG, 0x20); /* * Take the board out of reset ... */ sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) | 0x80); /* * Upload the user's data (firmware?) to the SoundScape * board through the DMA channel ... */ while (size != 0) { unsigned long len; /* * Apparently, copying to/from userspace can sleep. * We are therefore forbidden from holding any * spinlocks while we copy ... */ spin_unlock_irqrestore(&s->lock, flags); /* * Remember that the data that we want to DMA * comes from USERSPACE. We have already verified * the userspace pointer ... */ len = min(size, dma.bytes); len -= __copy_from_user(dma.area, data, len); data += len; size -= len; /* * Grab that spinlock again, now that we've * finished copying! */ spin_lock_irqsave(&s->lock, flags); snd_dma_program(s->chip->dma1, dma.addr, len, DMA_MODE_WRITE); sscape_start_dma_unsafe(s->io_base, GA_DMAA_REG); if (!sscape_wait_dma_unsafe(s->io_base, GA_DMAA_REG, 5000)) { /* * Don't forget to release this spinlock we're holding ... */ spin_unlock_irqrestore(&s->lock, flags); snd_printk(KERN_ERR "sscape: DMA upload has timed out\n"); ret = -EAGAIN; goto _release_dma; } } /* while */ set_host_mode_unsafe(s->io_base); /* * Boot the board ... (I think) */ sscape_write_unsafe(s->io_base, GA_HMCTL_REG, sscape_read_unsafe(s->io_base, GA_HMCTL_REG) | 0x40); spin_unlock_irqrestore(&s->lock, flags); /* * If all has gone well, then the board should acknowledge * the new upload and tell us that it has rebooted OK. We * give it 5 seconds (max) ... */ ret = 0; if (!obp_startup_ack(s, 5)) { snd_printk(KERN_ERR "sscape: No response from on-board processor after upload\n"); ret = -EAGAIN; } else if (!host_startup_ack(s, 5)) { snd_printk(KERN_ERR "sscape: SoundScape failed to initialise\n"); ret = -EAGAIN; } _release_dma: /* * NOTE!!! We are NOT holding any spinlocks at this point !!! */ sscape_write(s, GA_DMAA_REG, (s->ic_type == IC_ODIE ? 0x70 : 0x40)); free_dmabuf(&dma); return ret; }