Lines Matching +full:esync +full:- +full:control
1 // SPDX-License-Identifier: GPL-2.0-only
4 * Copyright (C) 2003-2004 Giuliano Pochini <pochini@shiny.it>
28 static const DECLARE_TLV_DB_SCALE(db_scale_output_gain, -12800, 100, 1);
38 if (chip->fw_cache[fw_index]) {
39 dev_dbg(chip->card->dev,
42 *fw_entry = chip->fw_cache[fw_index];
46 dev_dbg(chip->card->dev,
49 err = request_firmware(fw_entry, name, &chip->pci->dev);
51 dev_err(chip->card->dev,
54 chip->fw_cache[fw_index] = *fw_entry;
63 dev_dbg(chip->card->dev, "firmware not released (kept in cache)\n");
73 if (chip->fw_cache[i]) {
74 release_firmware(chip->fw_cache[i]);
75 dev_dbg(chip->card->dev, "release_firmware(%d)\n", i);
87 struct audiopipe *pipe = runtime->private_data;
89 if (pipe->sgpage.area)
90 snd_dma_free_pages(&pipe->sgpage);
108 if (c->min == 2) {
114 if (c->min > 2) {
135 if (f->bits[0] == SNDRV_PCM_FMTBIT_S32_BE) {
146 if (f->bits[0] == SNDRV_PCM_FMTBIT_U8) {
171 if (c->min > 2) {
176 } else if (c->max == 1)
180 else if (c->min == 2 && c->max == 2)
204 fmask = f->bits[0] + ((u64)f->bits[1] << 32);
236 struct echoaudio *chip = rule->private;
240 guard(mutex)(&chip->mode_mutex);
242 if (chip->can_set_rate) {
246 fixed.min = fixed.max = chip->sample_rate;
263 return -EAGAIN;
266 runtime = substream->runtime;
270 return -ENOMEM;
271 pipe->index = -1; /* Not configured yet */
274 memcpy(&pipe->hw, &pcm_hardware_skel, sizeof(struct snd_pcm_hardware));
275 dev_dbg(chip->card->dev, "max_channels=%d\n", max_channels);
276 pipe->constr.list = channels_list;
277 pipe->constr.mask = 0;
279 pipe->constr.count = i;
280 if (pipe->hw.channels_max > max_channels)
281 pipe->hw.channels_max = max_channels;
282 if (chip->digital_mode == DIGITAL_MODE_ADAT) {
283 pipe->hw.rate_max = 48000;
284 pipe->hw.rates &= SNDRV_PCM_RATE_8000_48000;
287 runtime->hw = pipe->hw;
288 runtime->private_data = pipe;
289 runtime->private_free = audiopipe_free;
295 &pipe->constr);
306 32-bytes-aligned. It's not a requirement, but it seems that IRQs are
317 err = snd_pcm_hw_rule_add(substream->runtime, 0,
320 SNDRV_PCM_HW_PARAM_RATE, -1);
324 /* Allocate a page for the scatter-gather list */
326 &chip->pci->dev,
327 PAGE_SIZE, &pipe->sgpage);
329 dev_err(chip->card->dev, "s-g list allocation failed\n");
337 dev_dbg(chip->card->dev, "pcm_open opencount=%d can_set_rate=%d, rate_set=%d",
338 chip->opencount, chip->can_set_rate, chip->rate_set);
340 chip->opencount++;
341 if (chip->opencount > 1 && chip->rate_set)
342 chip->can_set_rate = 0;
355 num_analog_busses_in(chip) - substream->number);
358 err = snd_pcm_hw_rule_add(substream->runtime, 0,
361 SNDRV_PCM_HW_PARAM_FORMAT, -1);
364 err = snd_pcm_hw_rule_add(substream->runtime, 0,
367 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
386 err = pcm_open(substream, max_channels - substream->number);
389 err = snd_pcm_hw_rule_add(substream->runtime, 0,
393 SNDRV_PCM_HW_PARAM_FORMAT, -1);
396 err = snd_pcm_hw_rule_add(substream->runtime, 0,
400 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
416 max_channels = num_digital_busses_in(chip) - substream->number;
417 guard(mutex)(&chip->mode_mutex);
418 if (chip->digital_mode == DIGITAL_MODE_ADAT)
423 err = pcm_open(substream, max_channels - ECHOCARD_HAS_ADAT);
428 err = snd_pcm_hw_rule_add(substream->runtime, 0,
431 SNDRV_PCM_HW_PARAM_FORMAT, -1);
434 err = snd_pcm_hw_rule_add(substream->runtime, 0,
437 SNDRV_PCM_HW_PARAM_CHANNELS, -1);
453 max_channels = num_digital_busses_out(chip) - substream->number;
454 guard(mutex)(&chip->mode_mutex);
455 if (chip->digital_mode == DIGITAL_MODE_ADAT)
460 err = pcm_open(substream, max_channels - ECHOCARD_HAS_ADAT);
465 err = snd_pcm_hw_rule_add(substream->runtime, 0,
469 -1);
472 err = snd_pcm_hw_rule_add(substream->runtime, 0,
476 -1);
497 guard(mutex)(&chip->mode_mutex);
499 dev_dbg(chip->card->dev, "pcm_open opencount=%d can_set_rate=%d, rate_set=%d",
500 chip->opencount, chip->can_set_rate, chip->rate_set);
502 chip->opencount--;
504 switch (chip->opencount) {
506 chip->can_set_rate = 1;
510 chip->rate_set = 0;
519 /* Channel allocation and scatter-gather list setup */
529 pipe = (struct audiopipe *) substream->runtime->private_data;
534 scoped_guard(spinlock_irq, &chip->lock) {
535 if (pipe->index >= 0) {
536 dev_dbg(chip->card->dev, "hwp_ie free(%d)\n", pipe->index);
539 chip->substream[pipe->index] = NULL;
544 dev_err(chip->card->dev, "allocate_pipes(%d) err=%d\n",
549 dev_dbg(chip->card->dev, "allocate_pipes()=%d\n", pipe_index);
551 dev_dbg(chip->card->dev,
562 rest = params_buffer_bytes(hw_params) - offs;
566 if (rest <= edge - offs) {
573 edge - offs);
574 rest -= edge - offs;
588 * initialized before chip->substream
590 pipe->last_period = 0;
591 pipe->last_counter = 0;
592 pipe->position = 0;
594 chip->substream[pipe_index] = substream;
595 chip->rate_set = 1;
596 guard(spinlock_irq)(&chip->lock);
597 set_sample_rate(chip, hw_params->rate_num / hw_params->rate_den);
609 substream->number, params_channels(hw_params));
617 return init_engine(substream, hw_params, substream->number,
631 substream->number, params_channels(hw_params));
643 substream->number, params_channels(hw_params));
657 pipe = (struct audiopipe *) substream->runtime->private_data;
659 guard(spinlock_irq)(&chip->lock);
660 if (pipe->index >= 0) {
661 dev_dbg(chip->card->dev, "pcm_hw_free(%d)\n", pipe->index);
663 chip->substream[pipe->index] = NULL;
664 pipe->index = -1;
675 struct snd_pcm_runtime *runtime = substream->runtime;
677 int pipe_index = ((struct audiopipe *)runtime->private_data)->index;
679 dev_dbg(chip->card->dev, "Prepare rate=%d format=%d channels=%d\n",
680 runtime->rate, runtime->format, runtime->channels);
681 format.interleave = runtime->channels;
684 switch (runtime->format) {
701 dev_err(chip->card->dev,
703 runtime->format);
704 return -EINVAL;
708 return -EINVAL;
712 * exclusive control
715 guard(spinlock_irq)(&chip->lock);
718 return -EINVAL;
737 if (s == chip->substream[i]) {
744 guard(spinlock)(&chip->lock);
751 pipe = chip->substream[i]->runtime->private_data;
752 switch (pipe->state) {
754 pipe->last_period = 0;
755 pipe->last_counter = 0;
756 pipe->position = 0;
757 *pipe->dma_counter = 0;
760 pipe->state = PIPE_STATE_STARTED;
768 chip->pipe_cyclic_mask);
774 pipe = chip->substream[i]->runtime->private_data;
775 pipe->state = PIPE_STATE_STOPPED;
783 pipe = chip->substream[i]->runtime->private_data;
784 pipe->state = PIPE_STATE_PAUSED;
790 err = -EINVAL;
799 struct snd_pcm_runtime *runtime = substream->runtime;
800 struct audiopipe *pipe = runtime->private_data;
808 counter = le32_to_cpu(*pipe->dma_counter); /* presumed atomic */
810 step = counter - pipe->last_counter; /* handles wrapping */
811 pipe->last_counter = counter;
817 pipe->position += step;
818 pipe->position %= frames_to_bytes(runtime, runtime->buffer_size); /* wrap */
820 return bytes_to_frames(runtime, pipe->position);
878 for (ss = pcm->streams[stream].substream; ss; ss = ss->next)
881 ss->number ? 0 : 128<<10,
887 /*<--snd_echo_probe() */
896 via control interface and it's possible to send any stream to any
901 err = snd_pcm_new(chip->card, "PCM", 0, num_pipes_out(chip),
905 pcm->private_data = chip;
906 chip->analog_pcm = pcm;
907 strscpy(pcm->name, chip->card->shortname);
910 snd_echo_preallocate_pages(pcm, &chip->pci->dev);
914 err = snd_pcm_new(chip->card, "Digital PCM", 1, 0,
918 pcm->private_data = chip;
919 chip->digital_pcm = pcm;
920 strscpy(pcm->name, chip->card->shortname);
922 snd_echo_preallocate_pages(pcm, &chip->pci->dev);
933 err = snd_pcm_new(chip->card, "Analog PCM", 0,
938 pcm->private_data = chip;
939 chip->analog_pcm = pcm;
940 strscpy(pcm->name, chip->card->shortname);
943 snd_echo_preallocate_pages(pcm, &chip->pci->dev);
947 err = snd_pcm_new(chip->card, "Digital PCM", 1,
952 pcm->private_data = chip;
953 chip->digital_pcm = pcm;
954 strscpy(pcm->name, chip->card->shortname);
957 snd_echo_preallocate_pages(pcm, &chip->pci->dev);
969 Control interface
981 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
982 uinfo->count = num_busses_out(chip);
983 uinfo->value.integer.min = ECHOGAIN_MINOUT;
984 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
996 ucontrol->value.integer.value[c] = chip->output_gain[c];
1008 guard(spinlock_irq)(&chip->lock);
1010 gain = ucontrol->value.integer.value[c];
1014 if (chip->output_gain[c] != gain) {
1025 /* On the Mia this one controls the line-out volume */
1061 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1062 uinfo->count = num_analog_busses_in(chip);
1063 uinfo->value.integer.min = ECHOGAIN_MININP;
1064 uinfo->value.integer.max = ECHOGAIN_MAXINP;
1076 ucontrol->value.integer.value[c] = chip->input_gain[c];
1088 guard(spinlock_irq)(&chip->lock);
1090 gain = ucontrol->value.integer.value[c];
1094 if (chip->input_gain[c] != gain) {
1104 static const DECLARE_TLV_DB_SCALE(db_scale_input_gain, -2500, 50, 0);
1122 /************ Analog output nominal level (+4dBu / -10dBV) ***************/
1129 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1130 uinfo->count = num_analog_busses_out(chip);
1131 uinfo->value.integer.min = 0;
1132 uinfo->value.integer.max = 1;
1144 ucontrol->value.integer.value[c] = chip->nominal_level[c];
1156 guard(spinlock_irq)(&chip->lock);
1158 if (chip->nominal_level[c] != ucontrol->value.integer.value[c]) {
1160 ucontrol->value.integer.value[c]);
1170 .name = "Line Playback Switch (-10dBV)",
1183 /*************** Analog input nominal level (+4dBu / -10dBV) ***************/
1190 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1191 uinfo->count = num_analog_busses_in(chip);
1192 uinfo->value.integer.min = 0;
1193 uinfo->value.integer.max = 1;
1205 ucontrol->value.integer.value[c] =
1206 chip->nominal_level[bx_analog_in(chip) + c];
1218 guard(spinlock_irq)(&chip->lock);
1220 if (chip->nominal_level[bx_analog_in(chip) + c] !=
1221 ucontrol->value.integer.value[c]) {
1223 ucontrol->value.integer.value[c]);
1235 .name = "Line Capture Switch (-10dBV)",
1252 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1253 uinfo->count = 1;
1254 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1255 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1263 unsigned int out = ucontrol->id.index / num_busses_in(chip);
1264 unsigned int in = ucontrol->id.index % num_busses_in(chip);
1267 return -EINVAL;
1269 ucontrol->value.integer.value[0] = chip->monitor_gain[out][in];
1282 out = ucontrol->id.index / num_busses_in(chip);
1283 in = ucontrol->id.index % num_busses_in(chip);
1285 return -EINVAL;
1286 gain = ucontrol->value.integer.value[0];
1288 return -EINVAL;
1289 if (chip->monitor_gain[out][in] != gain) {
1290 guard(spinlock_irq)(&chip->lock);
1318 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1319 uinfo->count = 1;
1320 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1321 uinfo->value.integer.max = ECHOGAIN_MAXOUT;
1331 ucontrol->value.integer.value[0] =
1332 chip->vmixer_gain[ucontrol->id.index / num_pipes_out(chip)]
1333 [ucontrol->id.index % num_pipes_out(chip)];
1346 out = ucontrol->id.index / num_pipes_out(chip);
1347 vch = ucontrol->id.index % num_pipes_out(chip);
1348 gain = ucontrol->value.integer.value[0];
1350 return -EINVAL;
1351 if (chip->vmixer_gain[out][vch] != ucontrol->value.integer.value[0]) {
1352 guard(spinlock_irq)(&chip->lock);
1353 set_vmixer_gain(chip, out, vch, ucontrol->value.integer.value[0]);
1387 return snd_ctl_enum_info(uinfo, 1, chip->num_digital_modes, names);
1397 mode = chip->digital_mode;
1398 for (i = chip->num_digital_modes - 1; i >= 0; i--)
1399 if (mode == chip->digital_mode_list[i]) {
1400 ucontrol->value.enumerated.item[0] = i;
1416 emode = ucontrol->value.enumerated.item[0];
1417 if (emode >= chip->num_digital_modes)
1418 return -EINVAL;
1419 dmode = chip->digital_mode_list[emode];
1421 if (dmode != chip->digital_mode) {
1424 guard(mutex)(&chip->mode_mutex);
1429 if (chip->opencount) {
1430 changed = -EAGAIN;
1434 if (changed > 0 && chip->clock_src_ctl) {
1435 snd_ctl_notify(chip->card,
1437 &chip->clock_src_ctl->id);
1438 dev_dbg(chip->card->dev,
1477 ucontrol->value.enumerated.item[0] = !!chip->professional_spdif;
1488 mode = !!ucontrol->value.enumerated.item[0];
1489 if (mode != chip->professional_spdif) {
1490 guard(spinlock_irq)(&chip->lock);
1516 "Internal", "Word", "Super", "S/PDIF", "ADAT", "ESync",
1522 return snd_ctl_enum_info(uinfo, 1, chip->num_clock_sources, names);
1532 clock = chip->input_clock;
1534 for (i = 0; i < chip->num_clock_sources; i++)
1535 if (clock == chip->clock_source_list[i])
1536 ucontrol->value.enumerated.item[0] = i;
1550 eclock = ucontrol->value.enumerated.item[0];
1551 if (eclock >= chip->input_clock_types)
1552 return -EINVAL;
1553 dclock = chip->clock_source_list[eclock];
1554 if (chip->input_clock != dclock) {
1555 guard(mutex)(&chip->mode_mutex);
1556 guard(spinlock_irq)(&chip->lock);
1563 dev_dbg(chip->card->dev,
1591 ucontrol->value.integer.value[0] = chip->phantom_power;
1601 power = !!ucontrol->value.integer.value[0];
1602 if (chip->phantom_power != power) {
1603 guard(spinlock_irq)(&chip->lock);
1633 ucontrol->value.integer.value[0] = chip->digital_in_automute;
1643 automute = !!ucontrol->value.integer.value[0];
1644 if (chip->digital_in_automute != automute) {
1645 guard(spinlock_irq)(&chip->lock);
1665 /******************* VU-meters switch *******************/
1674 guard(spinlock_irq)(&chip->lock);
1675 set_meters_on(chip, ucontrol->value.integer.value[0]);
1680 .name = "VU-meters Switch",
1689 /***** Read VU-meters (input, output, analog and digital together) *****/
1693 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1694 uinfo->count = 96;
1695 uinfo->value.integer.min = ECHOGAIN_MINOUT;
1696 uinfo->value.integer.max = 0;
1706 get_audio_meters(chip, ucontrol->value.integer.value);
1711 .name = "VU-meters",
1723 /*** Channels info - it exports informations about the number of channels ***/
1727 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1728 uinfo->count = 6;
1729 uinfo->value.integer.min = 0;
1730 uinfo->value.integer.max = 1 << ECHO_CLOCK_NUMBER;
1741 ucontrol->value.integer.value[0] = num_busses_in(chip);
1742 ucontrol->value.integer.value[1] = num_analog_busses_in(chip);
1743 ucontrol->value.integer.value[2] = num_busses_out(chip);
1744 ucontrol->value.integer.value[3] = num_analog_busses_out(chip);
1745 ucontrol->value.integer.value[4] = num_pipes_out(chip);
1750 src = chip->num_clock_sources - 1;
1751 for (bit = ECHO_CLOCK_NUMBER - 1; bit >= 0; bit--)
1753 for (; src >= 0; src--)
1754 if (bit == chip->clock_source_list[src]) {
1758 ucontrol->value.integer.value[5] = clocks;
1786 struct snd_pcm_runtime *runtime = substream->runtime;
1787 struct audiopipe *pipe = runtime->private_data;
1791 if (pipe->state != PIPE_STATE_STARTED)
1794 period_bytes = frames_to_bytes(runtime, runtime->period_size);
1796 counter = le32_to_cpu(*pipe->dma_counter); /* presumed atomic */
1798 step = counter - pipe->last_period; /* handles wrapping */
1799 step -= step % period_bytes; /* acknowledge whole periods only */
1804 pipe->last_period += step; /* used exclusively by us */
1813 spin_lock(&chip->lock);
1816 spin_unlock(&chip->lock);
1824 substream = chip->substream[ss];
1826 spin_unlock(&chip->lock);
1828 spin_lock(&chip->lock);
1831 spin_unlock(&chip->lock);
1834 if (st > 0 && chip->midi_in) {
1835 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st);
1836 dev_dbg(chip->card->dev, "rawmidi_iread=%d\n", st);
1851 struct echoaudio *chip = card->private_data;
1853 if (chip->comm_page)
1856 if (chip->irq >= 0)
1857 free_irq(chip->irq, chip);
1863 /* <--snd_echo_probe() */
1867 struct echoaudio *chip = card->private_data;
1879 spin_lock_init(&chip->lock);
1880 chip->card = card;
1881 chip->pci = pci;
1882 chip->irq = -1;
1883 chip->opencount = 0;
1884 mutex_init(&chip->mode_mutex);
1885 chip->can_set_rate = 1;
1892 chip->dsp_registers_phys = pci_resource_start(pci, 0);
1897 chip->dsp_registers = devm_ioremap(&pci->dev, chip->dsp_registers_phys, sz);
1898 if (!chip->dsp_registers) {
1899 dev_err(chip->card->dev, "ioremap failed\n");
1900 return -ENOMEM;
1903 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
1905 dev_err(chip->card->dev, "cannot grab irq\n");
1906 return -EBUSY;
1908 chip->irq = pci->irq;
1909 card->sync_irq = chip->irq;
1910 dev_dbg(card->dev, "pci=%p irq=%d subdev=%04x Init hardware...\n",
1911 chip->pci, chip->irq, chip->pci->subsystem_device);
1913 card->private_free = snd_echo_free;
1915 /* Create the DSP comm page - this is the area of memory used for most
1917 chip->commpage_dma_buf =
1918 snd_devm_alloc_pages(&pci->dev, SNDRV_DMA_TYPE_DEV,
1920 if (!chip->commpage_dma_buf)
1921 return -ENOMEM;
1922 chip->comm_page_phys = chip->commpage_dma_buf->addr;
1923 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf->area;
1925 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1929 dev_err(card->dev, "init_hw err=%d\n", err);
1947 return -ENODEV;
1950 return -ENOENT;
1953 err = snd_devm_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
1957 chip = card->private_data;
1963 strscpy(card->driver, "Echo_" ECHOCARD_NAME);
1964 strscpy(card->shortname, chip->card_name);
1967 if (pci_id->device == 0x3410)
1970 sprintf(card->longname, "%s rev.%d (DSP%s) at 0x%lx irq %i",
1971 card->shortname, pci_id->subdevice & 0x000f, dsp,
1972 chip->dsp_registers_phys, chip->irq);
1976 dev_err(chip->card->dev, "new pcm error %d\n", err);
1981 if (chip->has_midi) { /* Some Mia's do not have midi */
1984 dev_err(chip->card->dev, "new midi error %d\n", err);
1992 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vmixer, chip));
1996 err = snd_ctl_add(chip->card,
2002 err = snd_ctl_add(chip->card,
2009 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_line_input_gain, chip));
2015 if (!chip->hasnt_input_nominal_level) {
2016 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_intput_nominal_level, chip));
2023 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_output_nominal_level, chip));
2028 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters_switch, chip));
2032 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_vumeters, chip));
2038 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_monitor_mixer, chip));
2044 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_automute_switch, chip));
2049 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_channels_info, chip));
2055 chip->num_digital_modes = 0;
2057 if (chip->digital_modes & (1 << i))
2058 chip->digital_mode_list[chip->num_digital_modes++] = i;
2060 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_digital_mode_switch, chip));
2067 chip->num_clock_sources = 0;
2069 if (chip->input_clock_types & (1 << i))
2070 chip->clock_source_list[chip->num_clock_sources++] = i;
2072 if (chip->num_clock_sources > 1) {
2073 chip->clock_src_ctl = snd_ctl_new1(&snd_echo_clock_source_switch, chip);
2074 err = snd_ctl_add(chip->card, chip->clock_src_ctl);
2081 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_spdif_mode_switch, chip));
2087 if (chip->has_phantom_power) {
2088 err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_echo_phantom_power_switch, chip));
2097 dev_info(card->dev, "Card registered: %s\n", card->longname);
2107 return snd_card_free_on_error(&pci->dev, __snd_echo_probe(pci, pci_id));
2117 if (chip->midi_out)
2118 snd_echo_midi_output_trigger(chip->midi_out, 0);
2120 scoped_guard(spinlock_irq, &chip->lock) {
2122 return -EIO;
2125 return -EIO;
2128 chip->dsp_code = NULL;
2129 free_irq(chip->irq, chip);
2130 chip->irq = -1;
2131 chip->card->sync_irq = -1;
2145 commpage = chip->comm_page;
2148 return -ENOMEM;
2150 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
2157 /* Temporarily set chip->pipe_alloc_mask=0 otherwise
2160 pipe_alloc_mask = chip->pipe_alloc_mask;
2161 chip->pipe_alloc_mask = 0;
2163 chip->pipe_alloc_mask = pipe_alloc_mask;
2169 memcpy(&commpage->audio_format, &commpage_bak->audio_format,
2170 sizeof(commpage->audio_format));
2171 memcpy(&commpage->sglist_addr, &commpage_bak->sglist_addr,
2172 sizeof(commpage->sglist_addr));
2173 memcpy(&commpage->midi_output, &commpage_bak->midi_output,
2174 sizeof(commpage->midi_output));
2177 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
2179 dev_err(chip->card->dev, "cannot grab irq\n");
2180 return -EBUSY;
2182 chip->irq = pci->irq;
2183 chip->card->sync_irq = chip->irq;
2184 dev_dbg(dev, "resume irq=%d\n", chip->irq);
2187 if (chip->midi_input_enabled)
2189 if (chip->midi_out)
2190 snd_echo_midi_output_trigger(chip->midi_out, 1);