tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

ALSA: echoaudio: cleanup of unnecessary messages

commit "b5b4a41b392960010fccf1f9ccf8334d612bd450" was dereferencing
chip after it has been freed. This patch fixes that and at the same
time removes some debugging messages, which are unnecessary, as they
are just printing information about entry and exit from a function,
and which switch-case it is executing.
we can easily get from ftrace the information about the entry and exit
from a function.

Reported-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Sudip Mukherjee <sudip@vectorindia.org>
Signed-off-by: Takashi Iwai <tiwai@suse.de>

authored by

Sudip Mukherjee and committed by
Takashi Iwai 9161bd0d c009b7ef

-110
-2
sound/pci/echoaudio/darla20_dsp.c
··· 33 33 { 34 34 int err; 35 35 36 - dev_dbg(chip->card->dev, "init_hw() - Darla20\n"); 37 36 if (snd_BUG_ON((subdevice_id & 0xfff0) != DARLA20)) 38 37 return -ENODEV; 39 38 ··· 57 58 return err; 58 59 chip->bad_board = FALSE; 59 60 60 - dev_dbg(chip->card->dev, "init_hw: done\n"); 61 61 return err; 62 62 } 63 63
-2
sound/pci/echoaudio/darla24_dsp.c
··· 33 33 { 34 34 int err; 35 35 36 - dev_dbg(chip->card->dev, "init_hw() - Darla24\n"); 37 36 if (snd_BUG_ON((subdevice_id & 0xfff0) != DARLA24)) 38 37 return -ENODEV; 39 38 ··· 56 57 return err; 57 58 chip->bad_board = FALSE; 58 59 59 - dev_dbg(chip->card->dev, "init_hw: done\n"); 60 60 return err; 61 61 } 62 62
-2
sound/pci/echoaudio/echo3g_dsp.c
··· 46 46 int err; 47 47 48 48 local_irq_enable(); 49 - dev_dbg(chip->card->dev, "init_hw() - Echo3G\n"); 50 49 if (snd_BUG_ON((subdevice_id & 0xfff0) != ECHO3G)) 51 50 return -ENODEV; 52 51 ··· 98 99 ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_OPTICAL | 99 100 ECHOCAPS_HAS_DIGITAL_MODE_ADAT; 100 101 101 - dev_dbg(chip->card->dev, "init_hw done\n"); 102 102 return err; 103 103 } 104 104
-31
sound/pci/echoaudio/echoaudio.c
··· 79 79 dev_dbg(chip->card->dev, "firmware not released (kept in cache)\n"); 80 80 #else 81 81 release_firmware(fw_entry); 82 - dev_dbg(chip->card->dev, "firmware released\n"); 83 82 #endif 84 83 } 85 84 ··· 95 96 dev_dbg(chip->card->dev, "release_firmware(%d)\n", i); 96 97 } 97 98 98 - dev_dbg(chip->card->dev, "firmware_cache released\n"); 99 99 #endif 100 100 } 101 101 ··· 352 354 struct echoaudio *chip = snd_pcm_substream_chip(substream); 353 355 int err; 354 356 355 - dev_dbg(chip->card->dev, "pcm_analog_in_open\n"); 356 357 if ((err = pcm_open(substream, num_analog_busses_in(chip) - 357 358 substream->number)) < 0) 358 359 return err; ··· 386 389 #else 387 390 max_channels = num_analog_busses_out(chip); 388 391 #endif 389 - dev_dbg(chip->card->dev, "pcm_analog_out_open\n"); 390 392 if ((err = pcm_open(substream, max_channels - substream->number)) < 0) 391 393 return err; 392 394 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0, ··· 418 422 struct echoaudio *chip = snd_pcm_substream_chip(substream); 419 423 int err, max_channels; 420 424 421 - dev_dbg(chip->card->dev, "pcm_digital_in_open\n"); 422 425 max_channels = num_digital_busses_in(chip) - substream->number; 423 426 mutex_lock(&chip->mode_mutex); 424 427 if (chip->digital_mode == DIGITAL_MODE_ADAT) ··· 459 464 struct echoaudio *chip = snd_pcm_substream_chip(substream); 460 465 int err, max_channels; 461 466 462 - dev_dbg(chip->card->dev, "pcm_digital_out_open\n"); 463 467 max_channels = num_digital_busses_out(chip) - substream->number; 464 468 mutex_lock(&chip->mode_mutex); 465 469 if (chip->digital_mode == DIGITAL_MODE_ADAT) ··· 505 511 /* Nothing to do here. Audio is already off and pipe will be 506 512 * freed by its callback 507 513 */ 508 - dev_dbg(chip->card->dev, "pcm_close\n"); 509 514 510 515 atomic_dec(&chip->opencount); 511 516 oc = atomic_read(&chip->opencount); ··· 613 620 spin_lock_irq(&chip->lock); 614 621 set_sample_rate(chip, hw_params->rate_num / hw_params->rate_den); 615 622 spin_unlock_irq(&chip->lock); 616 - dev_dbg(chip->card->dev, "pcm_hw_params ok\n"); 617 623 return 0; 618 624 } 619 625 ··· 683 691 } 684 692 spin_unlock_irq(&chip->lock); 685 693 686 - dev_dbg(chip->card->dev, "pcm_hw_freed\n"); 687 694 snd_pcm_lib_free_pages(substream); 688 695 return 0; 689 696 } ··· 754 763 spin_lock(&chip->lock); 755 764 switch (cmd) { 756 765 case SNDRV_PCM_TRIGGER_RESUME: 757 - dev_dbg(chip->card->dev, "pcm_trigger resume\n"); 758 766 case SNDRV_PCM_TRIGGER_START: 759 767 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 760 - dev_dbg(chip->card->dev, "pcm_trigger start\n"); 761 768 for (i = 0; i < DSP_MAXPIPES; i++) { 762 769 if (channelmask & (1 << i)) { 763 770 pipe = chip->substream[i]->runtime->private_data; ··· 777 788 chip->pipe_cyclic_mask); 778 789 break; 779 790 case SNDRV_PCM_TRIGGER_SUSPEND: 780 - dev_dbg(chip->card->dev, "pcm_trigger suspend\n"); 781 791 case SNDRV_PCM_TRIGGER_STOP: 782 - dev_dbg(chip->card->dev, "pcm_trigger stop\n"); 783 792 for (i = 0; i < DSP_MAXPIPES; i++) { 784 793 if (channelmask & (1 << i)) { 785 794 pipe = chip->substream[i]->runtime->private_data; ··· 787 800 err = stop_transport(chip, channelmask); 788 801 break; 789 802 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 790 - dev_dbg(chip->card->dev, "pcm_trigger pause\n"); 791 803 for (i = 0; i < DSP_MAXPIPES; i++) { 792 804 if (channelmask & (1 << i)) { 793 805 pipe = chip->substream[i]->runtime->private_data; ··· 923 937 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops); 924 938 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0) 925 939 return err; 926 - dev_dbg(chip->card->dev, "Analog PCM ok\n"); 927 940 928 941 #ifdef ECHOCARD_HAS_DIGITAL_IO 929 942 /* PCM#1 Digital inputs, no outputs */ ··· 935 950 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops); 936 951 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0) 937 952 return err; 938 - dev_dbg(chip->card->dev, "Digital PCM ok\n"); 939 953 #endif /* ECHOCARD_HAS_DIGITAL_IO */ 940 954 941 955 #else /* ECHOCARD_HAS_VMIXER */ ··· 956 972 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops); 957 973 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0) 958 974 return err; 959 - dev_dbg(chip->card->dev, "Analog PCM ok\n"); 960 975 961 976 #ifdef ECHOCARD_HAS_DIGITAL_IO 962 977 /* PCM#1 Digital i/o */ ··· 970 987 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops); 971 988 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0) 972 989 return err; 973 - dev_dbg(chip->card->dev, "Digital PCM ok\n"); 974 990 #endif /* ECHOCARD_HAS_DIGITAL_IO */ 975 991 976 992 #endif /* ECHOCARD_HAS_VMIXER */ ··· 1863 1881 1864 1882 static int snd_echo_free(struct echoaudio *chip) 1865 1883 { 1866 - dev_dbg(chip->card->dev, "Stop DSP...\n"); 1867 1884 if (chip->comm_page) 1868 1885 rest_in_peace(chip); 1869 - dev_dbg(chip->card->dev, "Stopped.\n"); 1870 1886 1871 1887 if (chip->irq >= 0) 1872 1888 free_irq(chip->irq, chip); ··· 1878 1898 if (chip->iores) 1879 1899 release_and_free_resource(chip->iores); 1880 1900 1881 - dev_dbg(chip->card->dev, "MMIO freed.\n"); 1882 1901 1883 1902 pci_disable_device(chip->pci); 1884 1903 1885 1904 /* release chip data */ 1886 1905 free_firmware_cache(chip); 1887 1906 kfree(chip); 1888 - dev_dbg(chip->card->dev, "Chip freed.\n"); 1889 1907 return 0; 1890 1908 } 1891 1909 ··· 1893 1915 { 1894 1916 struct echoaudio *chip = device->device_data; 1895 1917 1896 - dev_dbg(chip->card->dev, "snd_echo_dev_free()...\n"); 1897 1918 return snd_echo_free(chip); 1898 1919 } 1899 1920 ··· 1985 2008 snd_echo_free(chip); 1986 2009 return err; 1987 2010 } 1988 - dev_dbg(card->dev, "Card init OK\n"); 1989 2011 1990 2012 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { 1991 2013 snd_echo_free(chip); ··· 2014 2038 return -ENOENT; 2015 2039 } 2016 2040 2017 - dev_dbg(&pci->dev, "Echoaudio driver starting...\n"); 2018 2041 i = 0; 2019 2042 err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, 2020 2043 0, &card); ··· 2166 2191 struct pci_dev *pci = to_pci_dev(dev); 2167 2192 struct echoaudio *chip = dev_get_drvdata(dev); 2168 2193 2169 - dev_dbg(dev, "suspend start\n"); 2170 2194 snd_pcm_suspend_all(chip->analog_pcm); 2171 2195 snd_pcm_suspend_all(chip->digital_pcm); 2172 2196 ··· 2192 2218 pci_save_state(pci); 2193 2219 pci_disable_device(pci); 2194 2220 2195 - dev_dbg(dev, "suspend done\n"); 2196 2221 return 0; 2197 2222 } 2198 2223 ··· 2205 2232 u32 pipe_alloc_mask; 2206 2233 int err; 2207 2234 2208 - dev_dbg(dev, "resume start\n"); 2209 2235 pci_restore_state(pci); 2210 2236 commpage_bak = kmalloc(sizeof(struct echoaudio), GFP_KERNEL); 2211 2237 if (commpage_bak == NULL) ··· 2219 2247 snd_echo_free(chip); 2220 2248 return err; 2221 2249 } 2222 - dev_dbg(dev, "resume init OK\n"); 2223 2250 2224 2251 /* Temporarily set chip->pipe_alloc_mask=0 otherwise 2225 2252 * restore_dsp_settings() fails. ··· 2231 2260 kfree(commpage_bak); 2232 2261 return err; 2233 2262 } 2234 - dev_dbg(dev, "resume restore OK\n"); 2235 2263 2236 2264 memcpy(&commpage->audio_format, &commpage_bak->audio_format, 2237 2265 sizeof(commpage->audio_format)); ··· 2256 2286 snd_echo_midi_output_trigger(chip->midi_out, 1); 2257 2287 #endif 2258 2288 2259 - dev_dbg(dev, "resume done\n"); 2260 2289 return 0; 2261 2290 } 2262 2291
-5
sound/pci/echoaudio/echoaudio_3g.c
··· 328 328 { 329 329 u32 control_reg, clocks_from_dsp; 330 330 331 - dev_dbg(chip->card->dev, "set_input_clock:\n"); 332 331 333 332 /* Mask off the clock select bits */ 334 333 control_reg = le32_to_cpu(chip->comm_page->control_register) & ··· 336 337 337 338 switch (clock) { 338 339 case ECHO_CLOCK_INTERNAL: 339 - dev_dbg(chip->card->dev, "Set Echo3G clock to INTERNAL\n"); 340 340 chip->input_clock = ECHO_CLOCK_INTERNAL; 341 341 return set_sample_rate(chip, chip->sample_rate); 342 342 case ECHO_CLOCK_SPDIF: 343 343 if (chip->digital_mode == DIGITAL_MODE_ADAT) 344 344 return -EAGAIN; 345 - dev_dbg(chip->card->dev, "Set Echo3G clock to SPDIF\n"); 346 345 control_reg |= E3G_SPDIF_CLOCK; 347 346 if (clocks_from_dsp & E3G_CLOCK_DETECT_BIT_SPDIF96) 348 347 control_reg |= E3G_DOUBLE_SPEED_MODE; ··· 350 353 case ECHO_CLOCK_ADAT: 351 354 if (chip->digital_mode != DIGITAL_MODE_ADAT) 352 355 return -EAGAIN; 353 - dev_dbg(chip->card->dev, "Set Echo3G clock to ADAT\n"); 354 356 control_reg |= E3G_ADAT_CLOCK; 355 357 control_reg &= ~E3G_DOUBLE_SPEED_MODE; 356 358 break; 357 359 case ECHO_CLOCK_WORD: 358 - dev_dbg(chip->card->dev, "Set Echo3G clock to WORD\n"); 359 360 control_reg |= E3G_WORD_CLOCK; 360 361 if (clocks_from_dsp & E3G_CLOCK_DETECT_BIT_WORD96) 361 362 control_reg |= E3G_DOUBLE_SPEED_MODE;
-12
sound/pci/echoaudio/echoaudio_dsp.c
··· 206 206 goto la_error; 207 207 } 208 208 209 - dev_dbg(chip->card->dev, "ASIC loaded\n"); 210 209 free_firmware(fw, chip); 211 210 return 0; 212 211 ··· 472 473 473 474 chip->dsp_code = code; /* Show which DSP code loaded */ 474 475 chip->bad_board = FALSE; /* DSP OK */ 475 - dev_dbg(chip->card->dev, "load_dsp: OK!\n"); 476 476 return 0; 477 477 } 478 478 udelay(100); ··· 672 674 static int restore_dsp_rettings(struct echoaudio *chip) 673 675 { 674 676 int i, o, err; 675 - dev_dbg(chip->card->dev, "restore_dsp_settings\n"); 676 677 677 678 if ((err = check_asic_status(chip)) < 0) 678 679 return err; ··· 768 771 if (send_vector(chip, DSP_VC_UPDATE_FLAGS) < 0) 769 772 return -EIO; 770 773 771 - dev_dbg(chip->card->dev, "restore_dsp_rettings done\n"); 772 774 return 0; 773 775 } 774 776 ··· 861 865 static int start_transport(struct echoaudio *chip, u32 channel_mask, 862 866 u32 cyclic_mask) 863 867 { 864 - dev_dbg(chip->card->dev, "start_transport %x\n", channel_mask); 865 868 866 869 if (wait_handshake(chip)) 867 870 return -EIO; ··· 886 891 887 892 static int pause_transport(struct echoaudio *chip, u32 channel_mask) 888 893 { 889 - dev_dbg(chip->card->dev, "pause_transport %x\n", channel_mask); 890 894 891 895 if (wait_handshake(chip)) 892 896 return -EIO; ··· 912 918 913 919 static int stop_transport(struct echoaudio *chip, u32 channel_mask) 914 920 { 915 - dev_dbg(chip->card->dev, "stop_transport %x\n", channel_mask); 916 921 917 922 if (wait_handshake(chip)) 918 923 return -EIO; ··· 947 954 stopped and unallocated. */ 948 955 static int rest_in_peace(struct echoaudio *chip) 949 956 { 950 - dev_dbg(chip->card->dev, 951 - "rest_in_peace() open=%x\n", chip->pipe_alloc_mask); 952 957 953 958 /* Stops all active pipes (just to be sure) */ 954 959 stop_transport(chip, chip->active_mask); ··· 1009 1018 */ 1010 1019 static int init_line_levels(struct echoaudio *chip) 1011 1020 { 1012 - dev_dbg(chip->card->dev, "init_line_levels\n"); 1013 1021 memset(chip->output_gain, ECHOGAIN_MUTED, sizeof(chip->output_gain)); 1014 1022 memset(chip->input_gain, ECHOGAIN_MUTED, sizeof(chip->input_gain)); 1015 1023 memset(chip->monitor_gain, ECHOGAIN_MUTED, sizeof(chip->monitor_gain)); ··· 1089 1099 it moves data. The DMA counter is in units of bytes, not samples. */ 1090 1100 pipe->dma_counter = &chip->comm_page->position[pipe_index]; 1091 1101 *pipe->dma_counter = 0; 1092 - dev_dbg(chip->card->dev, "allocate_pipes: ok\n"); 1093 1102 return pipe_index; 1094 1103 } 1095 1104 ··· 1099 1110 u32 channel_mask; 1100 1111 int i; 1101 1112 1102 - dev_dbg(chip->card->dev, "free_pipes: Pipe %d\n", pipe->index); 1103 1113 if (snd_BUG_ON(!is_pipe_allocated(chip, pipe->index))) 1104 1114 return -EINVAL; 1105 1115 if (snd_BUG_ON(pipe->state != PIPE_STATE_STOPPED))
-6
sound/pci/echoaudio/gina20_dsp.c
··· 37 37 { 38 38 int err; 39 39 40 - dev_dbg(chip->card->dev, "init_hw() - Gina20\n"); 41 40 if (snd_BUG_ON((subdevice_id & 0xfff0) != GINA20)) 42 41 return -ENODEV; 43 42 ··· 62 63 return err; 63 64 chip->bad_board = FALSE; 64 65 65 - dev_dbg(chip->card->dev, "init_hw done\n"); 66 66 return err; 67 67 } 68 68 ··· 148 150 149 151 static int set_input_clock(struct echoaudio *chip, u16 clock) 150 152 { 151 - dev_dbg(chip->card->dev, "set_input_clock:\n"); 152 153 153 154 switch (clock) { 154 155 case ECHO_CLOCK_INTERNAL: ··· 156 159 chip->spdif_status = GD_SPDIF_STATUS_UNDEF; 157 160 set_sample_rate(chip, chip->sample_rate); 158 161 chip->input_clock = clock; 159 - dev_dbg(chip->card->dev, "Set Gina clock to INTERNAL\n"); 160 162 break; 161 163 case ECHO_CLOCK_SPDIF: 162 164 chip->comm_page->gd_clock_state = GD_CLOCK_SPDIFIN; ··· 163 167 clear_handshake(chip); 164 168 send_vector(chip, DSP_VC_SET_GD_AUDIO_STATE); 165 169 chip->clock_state = GD_CLOCK_SPDIFIN; 166 - dev_dbg(chip->card->dev, "Set Gina20 clock to SPDIF\n"); 167 170 chip->input_clock = clock; 168 171 break; 169 172 default: ··· 204 209 205 210 static int set_professional_spdif(struct echoaudio *chip, char prof) 206 211 { 207 - dev_dbg(chip->card->dev, "set_professional_spdif %d\n", prof); 208 212 if (prof) 209 213 chip->comm_page->flags |= 210 214 cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
-9
sound/pci/echoaudio/gina24_dsp.c
··· 41 41 { 42 42 int err; 43 43 44 - dev_dbg(chip->card->dev, "init_hw() - Gina24\n"); 45 44 if (snd_BUG_ON((subdevice_id & 0xfff0) != GINA24)) 46 45 return -ENODEV; 47 46 ··· 78 79 return err; 79 80 chip->bad_board = FALSE; 80 81 81 - dev_dbg(chip->card->dev, "init_hw done\n"); 82 82 return err; 83 83 } 84 84 ··· 154 156 control_reg = GML_CONVERTER_ENABLE | GML_48KHZ; 155 157 err = write_control_reg(chip, control_reg, TRUE); 156 158 } 157 - dev_dbg(chip->card->dev, "load_asic() done\n"); 158 159 return err; 159 160 } 160 161 ··· 235 238 { 236 239 u32 control_reg, clocks_from_dsp; 237 240 238 - dev_dbg(chip->card->dev, "set_input_clock:\n"); 239 241 240 242 /* Mask off the clock select bits */ 241 243 control_reg = le32_to_cpu(chip->comm_page->control_register) & ··· 243 247 244 248 switch (clock) { 245 249 case ECHO_CLOCK_INTERNAL: 246 - dev_dbg(chip->card->dev, "Set Gina24 clock to INTERNAL\n"); 247 250 chip->input_clock = ECHO_CLOCK_INTERNAL; 248 251 return set_sample_rate(chip, chip->sample_rate); 249 252 case ECHO_CLOCK_SPDIF: 250 253 if (chip->digital_mode == DIGITAL_MODE_ADAT) 251 254 return -EAGAIN; 252 - dev_dbg(chip->card->dev, "Set Gina24 clock to SPDIF\n"); 253 255 control_reg |= GML_SPDIF_CLOCK; 254 256 if (clocks_from_dsp & GML_CLOCK_DETECT_BIT_SPDIF96) 255 257 control_reg |= GML_DOUBLE_SPEED_MODE; ··· 257 263 case ECHO_CLOCK_ADAT: 258 264 if (chip->digital_mode != DIGITAL_MODE_ADAT) 259 265 return -EAGAIN; 260 - dev_dbg(chip->card->dev, "Set Gina24 clock to ADAT\n"); 261 266 control_reg |= GML_ADAT_CLOCK; 262 267 control_reg &= ~GML_DOUBLE_SPEED_MODE; 263 268 break; 264 269 case ECHO_CLOCK_ESYNC: 265 - dev_dbg(chip->card->dev, "Set Gina24 clock to ESYNC\n"); 266 270 control_reg |= GML_ESYNC_CLOCK; 267 271 control_reg &= ~GML_DOUBLE_SPEED_MODE; 268 272 break; 269 273 case ECHO_CLOCK_ESYNC96: 270 - dev_dbg(chip->card->dev, "Set Gina24 clock to ESYNC96\n"); 271 274 control_reg |= GML_ESYNC_CLOCK | GML_DOUBLE_SPEED_MODE; 272 275 break; 273 276 default:
-2
sound/pci/echoaudio/indigo_dsp.c
··· 38 38 { 39 39 int err; 40 40 41 - dev_dbg(chip->card->dev, "init_hw() - Indigo\n"); 42 41 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO)) 43 42 return -ENODEV; 44 43 ··· 60 61 return err; 61 62 chip->bad_board = FALSE; 62 63 63 - dev_dbg(chip->card->dev, "init_hw done\n"); 64 64 return err; 65 65 } 66 66
-2
sound/pci/echoaudio/indigodj_dsp.c
··· 38 38 { 39 39 int err; 40 40 41 - dev_dbg(chip->card->dev, "init_hw() - Indigo DJ\n"); 42 41 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_DJ)) 43 42 return -ENODEV; 44 43 ··· 60 61 return err; 61 62 chip->bad_board = FALSE; 62 63 63 - dev_dbg(chip->card->dev, "init_hw done\n"); 64 64 return err; 65 65 } 66 66
-2
sound/pci/echoaudio/indigodjx_dsp.c
··· 35 35 { 36 36 int err; 37 37 38 - dev_dbg(chip->card->dev, "init_hw() - Indigo DJx\n"); 39 38 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_DJX)) 40 39 return -ENODEV; 41 40 ··· 59 60 return err; 60 61 chip->bad_board = FALSE; 61 62 62 - dev_dbg(chip->card->dev, "init_hw done\n"); 63 63 return err; 64 64 } 65 65
-2
sound/pci/echoaudio/indigoio_dsp.c
··· 38 38 { 39 39 int err; 40 40 41 - dev_dbg(chip->card->dev, "init_hw() - Indigo IO\n"); 42 41 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_IO)) 43 42 return -ENODEV; 44 43 ··· 60 61 return err; 61 62 chip->bad_board = FALSE; 62 63 63 - dev_dbg(chip->card->dev, "init_hw done\n"); 64 64 return err; 65 65 } 66 66
-2
sound/pci/echoaudio/indigoiox_dsp.c
··· 35 35 { 36 36 int err; 37 37 38 - dev_dbg(chip->card->dev, "init_hw() - Indigo IOx\n"); 39 38 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_IOX)) 40 39 return -ENODEV; 41 40 ··· 59 60 return err; 60 61 chip->bad_board = FALSE; 61 62 62 - dev_dbg(chip->card->dev, "init_hw done\n"); 63 63 return err; 64 64 } 65 65
-9
sound/pci/echoaudio/layla20_dsp.c
··· 40 40 { 41 41 int err; 42 42 43 - dev_dbg(chip->card->dev, "init_hw() - Layla20\n"); 44 43 if (snd_BUG_ON((subdevice_id & 0xfff0) != LAYLA20)) 45 44 return -ENODEV; 46 45 ··· 64 65 return err; 65 66 chip->bad_board = FALSE; 66 67 67 - dev_dbg(chip->card->dev, "init_hw done\n"); 68 68 return err; 69 69 } 70 70 ··· 188 190 u16 clock; 189 191 u32 rate; 190 192 191 - dev_dbg(chip->card->dev, "set_input_clock:\n"); 192 193 rate = 0; 193 194 switch (clock_source) { 194 195 case ECHO_CLOCK_INTERNAL: 195 - dev_dbg(chip->card->dev, "Set Layla20 clock to INTERNAL\n"); 196 196 rate = chip->sample_rate; 197 197 clock = LAYLA20_CLOCK_INTERNAL; 198 198 break; 199 199 case ECHO_CLOCK_SPDIF: 200 - dev_dbg(chip->card->dev, "Set Layla20 clock to SPDIF\n"); 201 200 clock = LAYLA20_CLOCK_SPDIF; 202 201 break; 203 202 case ECHO_CLOCK_WORD: 204 - dev_dbg(chip->card->dev, "Set Layla20 clock to WORD\n"); 205 203 clock = LAYLA20_CLOCK_WORD; 206 204 break; 207 205 case ECHO_CLOCK_SUPER: 208 - dev_dbg(chip->card->dev, "Set Layla20 clock to SUPER\n"); 209 206 clock = LAYLA20_CLOCK_SUPER; 210 207 break; 211 208 default: ··· 225 232 226 233 static int set_output_clock(struct echoaudio *chip, u16 clock) 227 234 { 228 - dev_dbg(chip->card->dev, "set_output_clock: %d\n", clock); 229 235 switch (clock) { 230 236 case ECHO_CLOCK_SUPER: 231 237 clock = LAYLA20_OUTPUT_CLOCK_SUPER; ··· 278 286 279 287 static int set_professional_spdif(struct echoaudio *chip, char prof) 280 288 { 281 - dev_dbg(chip->card->dev, "set_professional_spdif %d\n", prof); 282 289 if (prof) 283 290 chip->comm_page->flags |= 284 291 cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
-8
sound/pci/echoaudio/layla24_dsp.c
··· 40 40 { 41 41 int err; 42 42 43 - dev_dbg(chip->card->dev, "init_hw() - Layla24\n"); 44 43 if (snd_BUG_ON((subdevice_id & 0xfff0) != LAYLA24)) 45 44 return -ENODEV; 46 45 ··· 69 70 if ((err = init_line_levels(chip)) < 0) 70 71 return err; 71 72 72 - dev_dbg(chip->card->dev, "init_hw done\n"); 73 73 return err; 74 74 } 75 75 ··· 116 118 if (chip->asic_loaded) 117 119 return 1; 118 120 119 - dev_dbg(chip->card->dev, "load_asic\n"); 120 121 121 122 /* Give the DSP a few milliseconds to settle down */ 122 123 mdelay(10); ··· 149 152 err = write_control_reg(chip, GML_CONVERTER_ENABLE | GML_48KHZ, 150 153 TRUE); 151 154 152 - dev_dbg(chip->card->dev, "load_asic() done\n"); 153 155 return err; 154 156 } 155 157 ··· 258 262 /* Pick the new clock */ 259 263 switch (clock) { 260 264 case ECHO_CLOCK_INTERNAL: 261 - dev_dbg(chip->card->dev, "Set Layla24 clock to INTERNAL\n"); 262 265 chip->input_clock = ECHO_CLOCK_INTERNAL; 263 266 return set_sample_rate(chip, chip->sample_rate); 264 267 case ECHO_CLOCK_SPDIF: ··· 266 271 control_reg |= GML_SPDIF_CLOCK; 267 272 /* Layla24 doesn't support 96KHz S/PDIF */ 268 273 control_reg &= ~GML_DOUBLE_SPEED_MODE; 269 - dev_dbg(chip->card->dev, "Set Layla24 clock to SPDIF\n"); 270 274 break; 271 275 case ECHO_CLOCK_WORD: 272 276 control_reg |= GML_WORD_CLOCK; ··· 273 279 control_reg |= GML_DOUBLE_SPEED_MODE; 274 280 else 275 281 control_reg &= ~GML_DOUBLE_SPEED_MODE; 276 - dev_dbg(chip->card->dev, "Set Layla24 clock to WORD\n"); 277 282 break; 278 283 case ECHO_CLOCK_ADAT: 279 284 if (chip->digital_mode != DIGITAL_MODE_ADAT) 280 285 return -EAGAIN; 281 286 control_reg |= GML_ADAT_CLOCK; 282 287 control_reg &= ~GML_DOUBLE_SPEED_MODE; 283 - dev_dbg(chip->card->dev, "Set Layla24 clock to ADAT\n"); 284 288 break; 285 289 default: 286 290 dev_err(chip->card->dev,
-2
sound/pci/echoaudio/mia_dsp.c
··· 41 41 { 42 42 int err; 43 43 44 - dev_dbg(chip->card->dev, "init_hw() - Mia\n"); 45 44 if (snd_BUG_ON((subdevice_id & 0xfff0) != MIA)) 46 45 return -ENODEV; 47 46 ··· 66 67 return err; 67 68 chip->bad_board = FALSE; 68 69 69 - dev_dbg(chip->card->dev, "init_hw done\n"); 70 70 return err; 71 71 } 72 72
-6
sound/pci/echoaudio/midi.c
··· 157 157 struct echoaudio *chip = substream->rmidi->private_data; 158 158 159 159 chip->midi_in = substream; 160 - dev_dbg(chip->card->dev, "rawmidi_iopen\n"); 161 160 return 0; 162 161 } 163 162 ··· 182 183 struct echoaudio *chip = substream->rmidi->private_data; 183 184 184 185 chip->midi_in = NULL; 185 - dev_dbg(chip->card->dev, "rawmidi_iclose\n"); 186 186 return 0; 187 187 } 188 188 ··· 194 196 chip->tinuse = 0; 195 197 chip->midi_full = 0; 196 198 chip->midi_out = substream; 197 - dev_dbg(chip->card->dev, "rawmidi_open\n"); 198 199 return 0; 199 200 } 200 201 ··· 206 209 int bytes, sent, time; 207 210 unsigned char buf[MIDI_OUT_BUFFER_SIZE - 1]; 208 211 209 - dev_dbg(chip->card->dev, "snd_echo_midi_output_write\n"); 210 212 /* No interrupts are involved: we have to check at regular intervals 211 213 if the card's output buffer has room for new data. */ 212 214 sent = bytes = 0; ··· 284 288 struct echoaudio *chip = substream->rmidi->private_data; 285 289 286 290 chip->midi_out = NULL; 287 - dev_dbg(chip->card->dev, "rawmidi_oclose\n"); 288 291 return 0; 289 292 } 290 293 ··· 323 328 324 329 chip->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | 325 330 SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; 326 - dev_dbg(chip->card->dev, "MIDI ok\n"); 327 331 return 0; 328 332 }
-6
sound/pci/echoaudio/mona_dsp.c
··· 41 41 { 42 42 int err; 43 43 44 - dev_dbg(chip->card->dev, "init_hw() - Mona\n"); 45 44 if (snd_BUG_ON((subdevice_id & 0xfff0) != MONA)) 46 45 return -ENODEV; 47 46 ··· 71 72 return err; 72 73 chip->bad_board = FALSE; 73 74 74 - dev_dbg(chip->card->dev, "init_hw done\n"); 75 75 return err; 76 76 } 77 77 ··· 300 302 u32 control_reg, clocks_from_dsp; 301 303 int err; 302 304 303 - dev_dbg(chip->card->dev, "set_input_clock:\n"); 304 305 305 306 /* Prevent two simultaneous calls to switch_asic() */ 306 307 if (atomic_read(&chip->opencount)) ··· 312 315 313 316 switch (clock) { 314 317 case ECHO_CLOCK_INTERNAL: 315 - dev_dbg(chip->card->dev, "Set Mona clock to INTERNAL\n"); 316 318 chip->input_clock = ECHO_CLOCK_INTERNAL; 317 319 return set_sample_rate(chip, chip->sample_rate); 318 320 case ECHO_CLOCK_SPDIF: ··· 323 327 spin_lock_irq(&chip->lock); 324 328 if (err < 0) 325 329 return err; 326 - dev_dbg(chip->card->dev, "Set Mona clock to SPDIF\n"); 327 330 control_reg |= GML_SPDIF_CLOCK; 328 331 if (clocks_from_dsp & GML_CLOCK_DETECT_BIT_SPDIF96) 329 332 control_reg |= GML_DOUBLE_SPEED_MODE; ··· 330 335 control_reg &= ~GML_DOUBLE_SPEED_MODE; 331 336 break; 332 337 case ECHO_CLOCK_WORD: 333 - dev_dbg(chip->card->dev, "Set Mona clock to WORD\n"); 334 338 spin_unlock_irq(&chip->lock); 335 339 err = switch_asic(chip, clocks_from_dsp & 336 340 GML_CLOCK_DETECT_BIT_WORD96);