echoaudio.c (b8f1f5983fbe751aa3d07d9ce7ebb0c23bf4b7e4) echoaudio.c (b721e68bdc5b39c51bf6a1469f8d3663fbe03243)
1/*
2 * ALSA driver for Echoaudio soundcards.
3 * Copyright (C) 2003-2004 Giuliano Pochini <pochini@shiny.it>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
8 *

--- 22 unchanged lines hidden (view full) ---

31module_param_array(id, charp, NULL, 0444);
32MODULE_PARM_DESC(id, "ID string for " ECHOCARD_NAME " soundcard.");
33module_param_array(enable, bool, NULL, 0444);
34MODULE_PARM_DESC(enable, "Enable " ECHOCARD_NAME " soundcard.");
35
36static unsigned int channels_list[10] = {1, 2, 4, 6, 8, 10, 12, 14, 16, 999999};
37static const DECLARE_TLV_DB_SCALE(db_scale_output_gain, -12800, 100, 1);
38
1/*
2 * ALSA driver for Echoaudio soundcards.
3 * Copyright (C) 2003-2004 Giuliano Pochini <pochini@shiny.it>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; version 2 of the License.
8 *

--- 22 unchanged lines hidden (view full) ---

31module_param_array(id, charp, NULL, 0444);
32MODULE_PARM_DESC(id, "ID string for " ECHOCARD_NAME " soundcard.");
33module_param_array(enable, bool, NULL, 0444);
34MODULE_PARM_DESC(enable, "Enable " ECHOCARD_NAME " soundcard.");
35
36static unsigned int channels_list[10] = {1, 2, 4, 6, 8, 10, 12, 14, 16, 999999};
37static const DECLARE_TLV_DB_SCALE(db_scale_output_gain, -12800, 100, 1);
38
39
40
41static int get_firmware(const struct firmware **fw_entry,
39static int get_firmware(const struct firmware **fw_entry,
42 struct echoaudio *chip, const short fw_index)
40 const struct firmware *frm, struct echoaudio *chip)
43{
44 int err;
45 char name[30];
41{
42 int err;
43 char name[30];
46
47#ifdef CONFIG_PM
48 if (chip->fw_cache[fw_index]) {
49 DE_ACT(("firmware requested: %s is cached\n", card_fw[fw_index].data));
50 *fw_entry = chip->fw_cache[fw_index];
51 return 0;
52 }
53#endif
54
55 DE_ACT(("firmware requested: %s\n", card_fw[fw_index].data));
56 snprintf(name, sizeof(name), "ea/%s", card_fw[fw_index].data);
57 err = request_firmware(fw_entry, name, pci_device(chip));
58 if (err < 0)
44 DE_ACT(("firmware requested: %s\n", frm->data));
45 snprintf(name, sizeof(name), "ea/%s", frm->data);
46 if ((err = request_firmware(fw_entry, name, pci_device(chip))) < 0)
59 snd_printk(KERN_ERR "get_firmware(): Firmware not available (%d)\n", err);
47 snd_printk(KERN_ERR "get_firmware(): Firmware not available (%d)\n", err);
60#ifdef CONFIG_PM
61 else
62 chip->fw_cache[fw_index] = *fw_entry;
63#endif
64 return err;
65}
66
48 return err;
49}
50
67
68
69static void free_firmware(const struct firmware *fw_entry)
70{
51static void free_firmware(const struct firmware *fw_entry)
52{
71#ifdef CONFIG_PM
72 DE_ACT(("firmware not released (kept in cache)\n"));
73#else
74 release_firmware(fw_entry);
75 DE_ACT(("firmware released\n"));
53 release_firmware(fw_entry);
54 DE_ACT(("firmware released\n"));
76#endif
77}
78
79
80
55}
56
57
58
81static void free_firmware_cache(struct echoaudio *chip)
82{
83#ifdef CONFIG_PM
84 int i;
85
86 for (i = 0; i < 8 ; i++)
87 if (chip->fw_cache[i]) {
88 release_firmware(chip->fw_cache[i]);
89 DE_ACT(("release_firmware(%d)\n", i));
90 }
91
92 DE_ACT(("firmware_cache released\n"));
93#endif
94}
95
96
97
98/******************************************************************************
99 PCM interface
100******************************************************************************/
101
102static void audiopipe_free(struct snd_pcm_runtime *runtime)
103{
104 struct audiopipe *pipe = runtime->private_data;
105

--- 642 unchanged lines hidden (view full) ---

748 channelmask |= 1 << i;
749 snd_pcm_trigger_done(s, substream);
750 }
751 }
752 }
753
754 spin_lock(&chip->lock);
755 switch (cmd) {
59/******************************************************************************
60 PCM interface
61******************************************************************************/
62
63static void audiopipe_free(struct snd_pcm_runtime *runtime)
64{
65 struct audiopipe *pipe = runtime->private_data;
66

--- 642 unchanged lines hidden (view full) ---

709 channelmask |= 1 << i;
710 snd_pcm_trigger_done(s, substream);
711 }
712 }
713 }
714
715 spin_lock(&chip->lock);
716 switch (cmd) {
756 case SNDRV_PCM_TRIGGER_RESUME:
757 DE_ACT(("pcm_trigger resume\n"));
758 case SNDRV_PCM_TRIGGER_START:
759 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
760 DE_ACT(("pcm_trigger start\n"));
761 for (i = 0; i < DSP_MAXPIPES; i++) {
762 if (channelmask & (1 << i)) {
763 pipe = chip->substream[i]->runtime->private_data;
764 switch (pipe->state) {
765 case PIPE_STATE_STOPPED:

--- 7 unchanged lines hidden (view full) ---

773 case PIPE_STATE_STARTED:
774 break;
775 }
776 }
777 }
778 err = start_transport(chip, channelmask,
779 chip->pipe_cyclic_mask);
780 break;
717 case SNDRV_PCM_TRIGGER_START:
718 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
719 DE_ACT(("pcm_trigger start\n"));
720 for (i = 0; i < DSP_MAXPIPES; i++) {
721 if (channelmask & (1 << i)) {
722 pipe = chip->substream[i]->runtime->private_data;
723 switch (pipe->state) {
724 case PIPE_STATE_STOPPED:

--- 7 unchanged lines hidden (view full) ---

732 case PIPE_STATE_STARTED:
733 break;
734 }
735 }
736 }
737 err = start_transport(chip, channelmask,
738 chip->pipe_cyclic_mask);
739 break;
781 case SNDRV_PCM_TRIGGER_SUSPEND:
782 DE_ACT(("pcm_trigger suspend\n"));
783 case SNDRV_PCM_TRIGGER_STOP:
784 DE_ACT(("pcm_trigger stop\n"));
785 for (i = 0; i < DSP_MAXPIPES; i++) {
786 if (channelmask & (1 << i)) {
787 pipe = chip->substream[i]->runtime->private_data;
788 pipe->state = PIPE_STATE_STOPPED;
789 }
790 }

--- 1068 unchanged lines hidden (view full) ---

1859 st = service_irq(chip);
1860 if (st < 0) {
1861 spin_unlock(&chip->lock);
1862 return IRQ_NONE;
1863 }
1864 /* The hardware doesn't tell us which substream caused the irq,
1865 thus we have to check all running substreams. */
1866 for (ss = 0; ss < DSP_MAXPIPES; ss++) {
740 case SNDRV_PCM_TRIGGER_STOP:
741 DE_ACT(("pcm_trigger stop\n"));
742 for (i = 0; i < DSP_MAXPIPES; i++) {
743 if (channelmask & (1 << i)) {
744 pipe = chip->substream[i]->runtime->private_data;
745 pipe->state = PIPE_STATE_STOPPED;
746 }
747 }

--- 1068 unchanged lines hidden (view full) ---

1816 st = service_irq(chip);
1817 if (st < 0) {
1818 spin_unlock(&chip->lock);
1819 return IRQ_NONE;
1820 }
1821 /* The hardware doesn't tell us which substream caused the irq,
1822 thus we have to check all running substreams. */
1823 for (ss = 0; ss < DSP_MAXPIPES; ss++) {
1867 if ((substream = chip->substream[ss])) {
1824 substream = chip->substream[ss];
1825 if (substream && ((struct audiopipe *)substream->runtime->
1826 private_data)->state == PIPE_STATE_STARTED) {
1868 period = pcm_pointer(substream) /
1869 substream->runtime->period_size;
1870 if (period != chip->last_period[ss]) {
1871 chip->last_period[ss] = period;
1872 spin_unlock(&chip->lock);
1873 snd_pcm_period_elapsed(substream);
1874 spin_lock(&chip->lock);
1875 }

--- 36 unchanged lines hidden (view full) ---

1912 if (chip->iores)
1913 release_and_free_resource(chip->iores);
1914
1915 DE_INIT(("MMIO freed.\n"));
1916
1917 pci_disable_device(chip->pci);
1918
1919 /* release chip data */
1827 period = pcm_pointer(substream) /
1828 substream->runtime->period_size;
1829 if (period != chip->last_period[ss]) {
1830 chip->last_period[ss] = period;
1831 spin_unlock(&chip->lock);
1832 snd_pcm_period_elapsed(substream);
1833 spin_lock(&chip->lock);
1834 }

--- 36 unchanged lines hidden (view full) ---

1871 if (chip->iores)
1872 release_and_free_resource(chip->iores);
1873
1874 DE_INIT(("MMIO freed.\n"));
1875
1876 pci_disable_device(chip->pci);
1877
1878 /* release chip data */
1920 free_firmware_cache(chip);
1921 kfree(chip);
1922 DE_INIT(("Chip freed.\n"));
1923 return 0;
1924}
1925
1926
1927
1928static int snd_echo_dev_free(struct snd_device *device)

--- 21 unchanged lines hidden (view full) ---

1950 *rchip = NULL;
1951
1952 pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1953
1954 if ((err = pci_enable_device(pci)) < 0)
1955 return err;
1956 pci_set_master(pci);
1957
1879 kfree(chip);
1880 DE_INIT(("Chip freed.\n"));
1881 return 0;
1882}
1883
1884
1885
1886static int snd_echo_dev_free(struct snd_device *device)

--- 21 unchanged lines hidden (view full) ---

1908 *rchip = NULL;
1909
1910 pci_write_config_byte(pci, PCI_LATENCY_TIMER, 0xC0);
1911
1912 if ((err = pci_enable_device(pci)) < 0)
1913 return err;
1914 pci_set_master(pci);
1915
1958 /* Allocate chip if needed */
1959 if (!*rchip) {
1960 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1961 if (!chip) {
1962 pci_disable_device(pci);
1963 return -ENOMEM;
1964 }
1965 DE_INIT(("chip=%p\n", chip));
1966 spin_lock_init(&chip->lock);
1967 chip->card = card;
1968 chip->pci = pci;
1969 chip->irq = -1;
1970 atomic_set(&chip->opencount, 0);
1971 mutex_init(&chip->mode_mutex);
1972 chip->can_set_rate = 1;
1973 } else {
1974 /* If this was called from the resume function, chip is
1975 * already allocated and it contains current card settings.
1976 */
1977 chip = *rchip;
1916 /* allocate a chip-specific data */
1917 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1918 if (!chip) {
1919 pci_disable_device(pci);
1920 return -ENOMEM;
1978 }
1921 }
1922 DE_INIT(("chip=%p\n", chip));
1979
1923
1924 spin_lock_init(&chip->lock);
1925 chip->card = card;
1926 chip->pci = pci;
1927 chip->irq = -1;
1928
1980 /* PCI resource allocation */
1981 chip->dsp_registers_phys = pci_resource_start(pci, 0);
1982 sz = pci_resource_len(pci, 0);
1983 if (sz > PAGE_SIZE)
1984 sz = PAGE_SIZE; /* We map only the required part */
1985
1986 if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1987 ECHOCARD_NAME)) == NULL) {

--- 22 unchanged lines hidden (view full) ---

2010 snd_echo_free(chip);
2011 snd_printk(KERN_ERR "cannot allocate the comm page\n");
2012 return -ENOMEM;
2013 }
2014 chip->comm_page_phys = chip->commpage_dma_buf.addr;
2015 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
2016
2017 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
1929 /* PCI resource allocation */
1930 chip->dsp_registers_phys = pci_resource_start(pci, 0);
1931 sz = pci_resource_len(pci, 0);
1932 if (sz > PAGE_SIZE)
1933 sz = PAGE_SIZE; /* We map only the required part */
1934
1935 if ((chip->iores = request_mem_region(chip->dsp_registers_phys, sz,
1936 ECHOCARD_NAME)) == NULL) {

--- 22 unchanged lines hidden (view full) ---

1959 snd_echo_free(chip);
1960 snd_printk(KERN_ERR "cannot allocate the comm page\n");
1961 return -ENOMEM;
1962 }
1963 chip->comm_page_phys = chip->commpage_dma_buf.addr;
1964 chip->comm_page = (struct comm_page *)chip->commpage_dma_buf.area;
1965
1966 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
2018 if (err >= 0)
2019 err = set_mixer_defaults(chip);
2020 if (err < 0) {
1967 if (err) {
2021 DE_INIT(("init_hw err=%d\n", err));
2022 snd_echo_free(chip);
2023 return err;
2024 }
2025 DE_INIT(("Card init OK\n"));
2026
2027 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
2028 snd_echo_free(chip);
2029 return err;
2030 }
1968 DE_INIT(("init_hw err=%d\n", err));
1969 snd_echo_free(chip);
1970 return err;
1971 }
1972 DE_INIT(("Card init OK\n"));
1973
1974 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1975 snd_echo_free(chip);
1976 return err;
1977 }
1978 atomic_set(&chip->opencount, 0);
1979 mutex_init(&chip->mode_mutex);
1980 chip->can_set_rate = 1;
2031 *rchip = chip;
2032 /* Init done ! */
2033 return 0;
2034}
2035
2036
2037
2038/* constructor */

--- 16 unchanged lines hidden (view full) ---

2055 DE_INIT(("Echoaudio driver starting...\n"));
2056 i = 0;
2057 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
2058 if (err < 0)
2059 return err;
2060
2061 snd_card_set_dev(card, &pci->dev);
2062
1981 *rchip = chip;
1982 /* Init done ! */
1983 return 0;
1984}
1985
1986
1987
1988/* constructor */

--- 16 unchanged lines hidden (view full) ---

2005 DE_INIT(("Echoaudio driver starting...\n"));
2006 i = 0;
2007 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
2008 if (err < 0)
2009 return err;
2010
2011 snd_card_set_dev(card, &pci->dev);
2012
2063 chip = NULL; /* Tells snd_echo_create to allocate chip */
2064 if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2065 snd_card_free(card);
2066 return err;
2067 }
2068
2069 strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2070 strcpy(card->shortname, chip->card_name);
2071

--- 123 unchanged lines hidden (view full) ---

2195ctl_error:
2196 snd_printk(KERN_ERR "new control error %d\n", err);
2197 snd_card_free(card);
2198 return err;
2199}
2200
2201
2202
2013 if ((err = snd_echo_create(card, pci, &chip)) < 0) {
2014 snd_card_free(card);
2015 return err;
2016 }
2017
2018 strcpy(card->driver, "Echo_" ECHOCARD_NAME);
2019 strcpy(card->shortname, chip->card_name);
2020

--- 123 unchanged lines hidden (view full) ---

2144ctl_error:
2145 snd_printk(KERN_ERR "new control error %d\n", err);
2146 snd_card_free(card);
2147 return err;
2148}
2149
2150
2151
2203#if defined(CONFIG_PM)
2204
2205static int snd_echo_suspend(struct pci_dev *pci, pm_message_t state)
2206{
2207 struct echoaudio *chip = pci_get_drvdata(pci);
2208
2209 DE_INIT(("suspend start\n"));
2210 snd_pcm_suspend_all(chip->analog_pcm);
2211 snd_pcm_suspend_all(chip->digital_pcm);
2212
2213#ifdef ECHOCARD_HAS_MIDI
2214 /* This call can sleep */
2215 if (chip->midi_out)
2216 snd_echo_midi_output_trigger(chip->midi_out, 0);
2217#endif
2218 spin_lock_irq(&chip->lock);
2219 if (wait_handshake(chip)) {
2220 spin_unlock_irq(&chip->lock);
2221 return -EIO;
2222 }
2223 clear_handshake(chip);
2224 if (send_vector(chip, DSP_VC_GO_COMATOSE) < 0) {
2225 spin_unlock_irq(&chip->lock);
2226 return -EIO;
2227 }
2228 spin_unlock_irq(&chip->lock);
2229
2230 chip->dsp_code = NULL;
2231 free_irq(chip->irq, chip);
2232 chip->irq = -1;
2233 pci_save_state(pci);
2234 pci_disable_device(pci);
2235
2236 DE_INIT(("suspend done\n"));
2237 return 0;
2238}
2239
2240
2241
2242static int snd_echo_resume(struct pci_dev *pci)
2243{
2244 struct echoaudio *chip = pci_get_drvdata(pci);
2245 struct comm_page *commpage, *commpage_bak;
2246 u32 pipe_alloc_mask;
2247 int err;
2248
2249 DE_INIT(("resume start\n"));
2250 pci_restore_state(pci);
2251 commpage_bak = kmalloc(sizeof(struct echoaudio), GFP_KERNEL);
2252 commpage = chip->comm_page;
2253 memcpy(commpage_bak, commpage, sizeof(struct comm_page));
2254
2255 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device);
2256 if (err < 0) {
2257 kfree(commpage_bak);
2258 DE_INIT(("resume init_hw err=%d\n", err));
2259 snd_echo_free(chip);
2260 return err;
2261 }
2262 DE_INIT(("resume init OK\n"));
2263
2264 /* Temporarily set chip->pipe_alloc_mask=0 otherwise
2265 * restore_dsp_settings() fails.
2266 */
2267 pipe_alloc_mask = chip->pipe_alloc_mask;
2268 chip->pipe_alloc_mask = 0;
2269 err = restore_dsp_rettings(chip);
2270 chip->pipe_alloc_mask = pipe_alloc_mask;
2271 if (err < 0) {
2272 kfree(commpage_bak);
2273 return err;
2274 }
2275 DE_INIT(("resume restore OK\n"));
2276
2277 memcpy(&commpage->audio_format, &commpage_bak->audio_format,
2278 sizeof(commpage->audio_format));
2279 memcpy(&commpage->sglist_addr, &commpage_bak->sglist_addr,
2280 sizeof(commpage->sglist_addr));
2281 memcpy(&commpage->midi_output, &commpage_bak->midi_output,
2282 sizeof(commpage->midi_output));
2283 kfree(commpage_bak);
2284
2285 if (request_irq(pci->irq, snd_echo_interrupt, IRQF_SHARED,
2286 ECHOCARD_NAME, chip)) {
2287 snd_echo_free(chip);
2288 snd_printk(KERN_ERR "cannot grab irq\n");
2289 return -EBUSY;
2290 }
2291 chip->irq = pci->irq;
2292 DE_INIT(("resume irq=%d\n", chip->irq));
2293
2294#ifdef ECHOCARD_HAS_MIDI
2295 if (chip->midi_input_enabled)
2296 enable_midi_input(chip, TRUE);
2297 if (chip->midi_out)
2298 snd_echo_midi_output_trigger(chip->midi_out, 1);
2299#endif
2300
2301 DE_INIT(("resume done\n"));
2302 return 0;
2303}
2304
2305#endif /* CONFIG_PM */
2306
2307
2308
2309static void __devexit snd_echo_remove(struct pci_dev *pci)
2310{
2311 struct echoaudio *chip;
2312
2313 chip = pci_get_drvdata(pci);
2314 if (chip)
2315 snd_card_free(chip->card);
2316 pci_set_drvdata(pci, NULL);

--- 6 unchanged lines hidden (view full) ---

2323******************************************************************************/
2324
2325/* pci_driver definition */
2326static struct pci_driver driver = {
2327 .name = "Echoaudio " ECHOCARD_NAME,
2328 .id_table = snd_echo_ids,
2329 .probe = snd_echo_probe,
2330 .remove = __devexit_p(snd_echo_remove),
2152static void __devexit snd_echo_remove(struct pci_dev *pci)
2153{
2154 struct echoaudio *chip;
2155
2156 chip = pci_get_drvdata(pci);
2157 if (chip)
2158 snd_card_free(chip->card);
2159 pci_set_drvdata(pci, NULL);

--- 6 unchanged lines hidden (view full) ---

2166******************************************************************************/
2167
2168/* pci_driver definition */
2169static struct pci_driver driver = {
2170 .name = "Echoaudio " ECHOCARD_NAME,
2171 .id_table = snd_echo_ids,
2172 .probe = snd_echo_probe,
2173 .remove = __devexit_p(snd_echo_remove),
2331#ifdef CONFIG_PM
2332 .suspend = snd_echo_suspend,
2333 .resume = snd_echo_resume,
2334#endif /* CONFIG_PM */
2335};
2336
2337
2338
2339/* initialization of the module */
2340static int __init alsa_card_echo_init(void)
2341{
2342 return pci_register_driver(&driver);

--- 13 unchanged lines hidden --- 		2174};
2175
2176
2177
2178/* initialization of the module */
2179static int __init alsa_card_echo_init(void)
2180{
2181 return pci_register_driver(&driver);

--- 13 unchanged lines hidden ---