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

ALSA: echoaudio: remove all snd_printk

removed all references of snd_printk with the standard dev_* macro.

[a few places degraded to dev_dbg(), too -- tiwai]

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
b5b4a41b e3690869

+327 -283
+4 -3
sound/pci/echoaudio/darla20_dsp.c
··· 33 33 { 34 34 int err; 35 35 36 - DE_INIT(("init_hw() - Darla20\n")); 36 + dev_dbg(chip->card->dev, "init_hw() - Darla20\n"); 37 37 if (snd_BUG_ON((subdevice_id & 0xfff0) != DARLA20)) 38 38 return -ENODEV; 39 39 40 40 if ((err = init_dsp_comm_page(chip))) { 41 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 41 + dev_err(chip->card->dev, 42 + "init_hw: could not initialize DSP comm page\n"); 42 43 return err; 43 44 } 44 45 ··· 58 57 return err; 59 58 chip->bad_board = FALSE; 60 59 61 - DE_INIT(("init_hw done\n")); 60 + dev_dbg(chip->card->dev, "init_hw: done\n"); 62 61 return err; 63 62 } 64 63
+9 -6
sound/pci/echoaudio/darla24_dsp.c
··· 33 33 { 34 34 int err; 35 35 36 - DE_INIT(("init_hw() - Darla24\n")); 36 + dev_dbg(chip->card->dev, "init_hw() - Darla24\n"); 37 37 if (snd_BUG_ON((subdevice_id & 0xfff0) != DARLA24)) 38 38 return -ENODEV; 39 39 40 40 if ((err = init_dsp_comm_page(chip))) { 41 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 41 + dev_err(chip->card->dev, 42 + "init_hw: could not initialize DSP comm page\n"); 42 43 return err; 43 44 } 44 45 ··· 57 56 return err; 58 57 chip->bad_board = FALSE; 59 58 60 - DE_INIT(("init_hw done\n")); 59 + dev_dbg(chip->card->dev, "init_hw: done\n"); 61 60 return err; 62 61 } 63 62 ··· 129 128 clock = GD24_8000; 130 129 break; 131 130 default: 132 - DE_ACT(("set_sample_rate: Error, invalid sample rate %d\n", 133 - rate)); 131 + dev_err(chip->card->dev, 132 + "set_sample_rate: Error, invalid sample rate %d\n", 133 + rate); 134 134 return -EINVAL; 135 135 } 136 136 137 137 if (wait_handshake(chip)) 138 138 return -EIO; 139 139 140 - DE_ACT(("set_sample_rate: %d clock %d\n", rate, clock)); 140 + dev_dbg(chip->card->dev, 141 + "set_sample_rate: %d clock %d\n", rate, clock); 141 142 chip->sample_rate = rate; 142 143 143 144 /* Override the sample rate if this card is set to Echo sync. */
+4 -3
sound/pci/echoaudio/echo3g_dsp.c
··· 46 46 int err; 47 47 48 48 local_irq_enable(); 49 - DE_INIT(("init_hw() - Echo3G\n")); 49 + dev_dbg(chip->card->dev, "init_hw() - Echo3G\n"); 50 50 if (snd_BUG_ON((subdevice_id & 0xfff0) != ECHO3G)) 51 51 return -ENODEV; 52 52 53 53 if ((err = init_dsp_comm_page(chip))) { 54 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 54 + dev_err(chip->card->dev, 55 + "init_hw - could not initialize DSP comm page\n"); 55 56 return err; 56 57 } 57 58 ··· 99 98 ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_OPTICAL | 100 99 ECHOCAPS_HAS_DIGITAL_MODE_ADAT; 101 100 102 - DE_INIT(("init_hw done\n")); 101 + dev_dbg(chip->card->dev, "init_hw done\n"); 103 102 return err; 104 103 } 105 104
+72 -65
sound/pci/echoaudio/echoaudio.c
··· 48 48 49 49 #ifdef CONFIG_PM_SLEEP 50 50 if (chip->fw_cache[fw_index]) { 51 - DE_ACT(("firmware requested: %s is cached\n", card_fw[fw_index].data)); 51 + dev_dbg(chip->card->dev, 52 + "firmware requested: %s is cached\n", 53 + card_fw[fw_index].data); 52 54 *fw_entry = chip->fw_cache[fw_index]; 53 55 return 0; 54 56 } 55 57 #endif 56 58 57 - DE_ACT(("firmware requested: %s\n", card_fw[fw_index].data)); 59 + dev_dbg(chip->card->dev, 60 + "firmware requested: %s\n", card_fw[fw_index].data); 58 61 snprintf(name, sizeof(name), "ea/%s", card_fw[fw_index].data); 59 62 err = request_firmware(fw_entry, name, pci_device(chip)); 60 63 if (err < 0) ··· 76 73 struct echoaudio *chip) 77 74 { 78 75 #ifdef CONFIG_PM_SLEEP 79 - DE_ACT(("firmware not released (kept in cache)\n")); 76 + dev_dbg(chip->card->dev, "firmware not released (kept in cache)\n"); 80 77 #else 81 78 release_firmware(fw_entry); 82 - DE_ACT(("firmware released\n")); 79 + dev_dbg(chip->card->dev, "firmware released\n"); 83 80 #endif 84 81 } 85 82 ··· 93 90 for (i = 0; i < 8 ; i++) 94 91 if (chip->fw_cache[i]) { 95 92 release_firmware(chip->fw_cache[i]); 96 - DE_ACT(("release_firmware(%d)\n", i)); 93 + dev_dbg(chip->card->dev, "release_firmware(%d)\n", i); 97 94 } 98 95 99 - DE_ACT(("firmware_cache released\n")); 96 + dev_dbg(chip->card->dev, "firmware_cache released\n"); 100 97 #endif 101 98 } 102 99 ··· 290 287 291 288 /* Set up hw capabilities and contraints */ 292 289 memcpy(&pipe->hw, &pcm_hardware_skel, sizeof(struct snd_pcm_hardware)); 293 - DE_HWP(("max_channels=%d\n", max_channels)); 290 + dev_dbg(chip->card->dev, "max_channels=%d\n", max_channels); 294 291 pipe->constr.list = channels_list; 295 292 pipe->constr.mask = 0; 296 293 for (i = 0; channels_list[i] <= max_channels; i++); ··· 340 337 if ((err = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, 341 338 snd_dma_pci_data(chip->pci), 342 339 PAGE_SIZE, &pipe->sgpage)) < 0) { 343 - DE_HWP(("s-g list allocation failed\n")); 340 + dev_err(chip->card->dev, "s-g list allocation failed\n"); 344 341 return err; 345 342 } 346 343 ··· 354 351 struct echoaudio *chip = snd_pcm_substream_chip(substream); 355 352 int err; 356 353 357 - DE_ACT(("pcm_analog_in_open\n")); 354 + dev_dbg(chip->card->dev, "pcm_analog_in_open\n"); 358 355 if ((err = pcm_open(substream, num_analog_busses_in(chip) - 359 356 substream->number)) < 0) 360 357 return err; ··· 371 368 atomic_inc(&chip->opencount); 372 369 if (atomic_read(&chip->opencount) > 1 && chip->rate_set) 373 370 chip->can_set_rate=0; 374 - DE_HWP(("pcm_analog_in_open cs=%d oc=%d r=%d\n", 371 + dev_dbg(chip->card->dev, "pcm_analog_in_open cs=%d oc=%d r=%d\n", 375 372 chip->can_set_rate, atomic_read(&chip->opencount), 376 - chip->sample_rate)); 373 + chip->sample_rate); 377 374 return 0; 378 375 } 379 376 ··· 389 386 #else 390 387 max_channels = num_analog_busses_out(chip); 391 388 #endif 392 - DE_ACT(("pcm_analog_out_open\n")); 389 + dev_dbg(chip->card->dev, "pcm_analog_out_open\n"); 393 390 if ((err = pcm_open(substream, max_channels - substream->number)) < 0) 394 391 return err; 395 392 if ((err = snd_pcm_hw_rule_add(substream->runtime, 0, ··· 407 404 atomic_inc(&chip->opencount); 408 405 if (atomic_read(&chip->opencount) > 1 && chip->rate_set) 409 406 chip->can_set_rate=0; 410 - DE_HWP(("pcm_analog_out_open cs=%d oc=%d r=%d\n", 407 + dev_dbg(chip->card->dev, "pcm_analog_out_open cs=%d oc=%d r=%d\n", 411 408 chip->can_set_rate, atomic_read(&chip->opencount), 412 - chip->sample_rate)); 409 + chip->sample_rate); 413 410 return 0; 414 411 } 415 412 ··· 422 419 struct echoaudio *chip = snd_pcm_substream_chip(substream); 423 420 int err, max_channels; 424 421 425 - DE_ACT(("pcm_digital_in_open\n")); 422 + dev_dbg(chip->card->dev, "pcm_digital_in_open\n"); 426 423 max_channels = num_digital_busses_in(chip) - substream->number; 427 424 mutex_lock(&chip->mode_mutex); 428 425 if (chip->digital_mode == DIGITAL_MODE_ADAT) ··· 464 461 struct echoaudio *chip = snd_pcm_substream_chip(substream); 465 462 int err, max_channels; 466 463 467 - DE_ACT(("pcm_digital_out_open\n")); 464 + dev_dbg(chip->card->dev, "pcm_digital_out_open\n"); 468 465 max_channels = num_digital_busses_out(chip) - substream->number; 469 466 mutex_lock(&chip->mode_mutex); 470 467 if (chip->digital_mode == DIGITAL_MODE_ADAT) ··· 511 508 /* Nothing to do here. Audio is already off and pipe will be 512 509 * freed by its callback 513 510 */ 514 - DE_ACT(("pcm_close\n")); 511 + dev_dbg(chip->card->dev, "pcm_close\n"); 515 512 516 513 atomic_dec(&chip->opencount); 517 514 oc = atomic_read(&chip->opencount); 518 - DE_ACT(("pcm_close oc=%d cs=%d rs=%d\n", oc, 519 - chip->can_set_rate, chip->rate_set)); 515 + dev_dbg(chip->card->dev, "pcm_close oc=%d cs=%d rs=%d\n", oc, 516 + chip->can_set_rate, chip->rate_set); 520 517 if (oc < 2) 521 518 chip->can_set_rate = 1; 522 519 if (oc == 0) 523 520 chip->rate_set = 0; 524 - DE_ACT(("pcm_close2 oc=%d cs=%d rs=%d\n", oc, 525 - chip->can_set_rate,chip->rate_set)); 521 + dev_dbg(chip->card->dev, "pcm_close2 oc=%d cs=%d rs=%d\n", oc, 522 + chip->can_set_rate, chip->rate_set); 526 523 527 524 return 0; 528 525 } ··· 546 543 */ 547 544 spin_lock_irq(&chip->lock); 548 545 if (pipe->index >= 0) { 549 - DE_HWP(("hwp_ie free(%d)\n", pipe->index)); 546 + dev_dbg(chip->card->dev, "hwp_ie free(%d)\n", pipe->index); 550 547 err = free_pipes(chip, pipe); 551 548 snd_BUG_ON(err); 552 549 chip->substream[pipe->index] = NULL; ··· 555 552 err = allocate_pipes(chip, pipe, pipe_index, interleave); 556 553 if (err < 0) { 557 554 spin_unlock_irq(&chip->lock); 558 - DE_ACT((KERN_NOTICE "allocate_pipes(%d) err=%d\n", 559 - pipe_index, err)); 555 + dev_err(chip->card->dev, "allocate_pipes(%d) err=%d\n", 556 + pipe_index, err); 560 557 return err; 561 558 } 562 559 spin_unlock_irq(&chip->lock); 563 - DE_ACT((KERN_NOTICE "allocate_pipes()=%d\n", pipe_index)); 560 + dev_dbg(chip->card->dev, "allocate_pipes()=%d\n", pipe_index); 564 561 565 - DE_HWP(("pcm_hw_params (bufsize=%dB periods=%d persize=%dB)\n", 562 + dev_dbg(chip->card->dev, 563 + "pcm_hw_params (bufsize=%dB periods=%d persize=%dB)\n", 566 564 params_buffer_bytes(hw_params), params_periods(hw_params), 567 - params_period_bytes(hw_params))); 565 + params_period_bytes(hw_params)); 568 566 err = snd_pcm_lib_malloc_pages(substream, 569 567 params_buffer_bytes(hw_params)); 570 568 if (err < 0) { ··· 620 616 spin_lock_irq(&chip->lock); 621 617 set_sample_rate(chip, hw_params->rate_num / hw_params->rate_den); 622 618 spin_unlock_irq(&chip->lock); 623 - DE_HWP(("pcm_hw_params ok\n")); 619 + dev_dbg(chip->card->dev, "pcm_hw_params ok\n"); 624 620 return 0; 625 621 } 626 622 ··· 684 680 685 681 spin_lock_irq(&chip->lock); 686 682 if (pipe->index >= 0) { 687 - DE_HWP(("pcm_hw_free(%d)\n", pipe->index)); 683 + dev_dbg(chip->card->dev, "pcm_hw_free(%d)\n", pipe->index); 688 684 free_pipes(chip, pipe); 689 685 chip->substream[pipe->index] = NULL; 690 686 pipe->index = -1; 691 687 } 692 688 spin_unlock_irq(&chip->lock); 693 689 694 - DE_HWP(("pcm_hw_freed\n")); 690 + dev_dbg(chip->card->dev, "pcm_hw_freed\n"); 695 691 snd_pcm_lib_free_pages(substream); 696 692 return 0; 697 693 } ··· 705 701 struct audioformat format; 706 702 int pipe_index = ((struct audiopipe *)runtime->private_data)->index; 707 703 708 - DE_HWP(("Prepare rate=%d format=%d channels=%d\n", 709 - runtime->rate, runtime->format, runtime->channels)); 704 + dev_dbg(chip->card->dev, "Prepare rate=%d format=%d channels=%d\n", 705 + runtime->rate, runtime->format, runtime->channels); 710 706 format.interleave = runtime->channels; 711 707 format.data_are_bigendian = 0; 712 708 format.mono_to_stereo = 0; ··· 726 722 format.bits_per_sample = 32; 727 723 break; 728 724 default: 729 - DE_HWP(("Prepare error: unsupported format %d\n", 730 - runtime->format)); 725 + dev_err(chip->card->dev, 726 + "Prepare error: unsupported format %d\n", 727 + runtime->format); 731 728 return -EINVAL; 732 729 } 733 730 ··· 763 758 spin_lock(&chip->lock); 764 759 switch (cmd) { 765 760 case SNDRV_PCM_TRIGGER_RESUME: 766 - DE_ACT(("pcm_trigger resume\n")); 761 + dev_dbg(chip->card->dev, "pcm_trigger resume\n"); 767 762 case SNDRV_PCM_TRIGGER_START: 768 763 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 769 - DE_ACT(("pcm_trigger start\n")); 764 + dev_dbg(chip->card->dev, "pcm_trigger start\n"); 770 765 for (i = 0; i < DSP_MAXPIPES; i++) { 771 766 if (channelmask & (1 << i)) { 772 767 pipe = chip->substream[i]->runtime->private_data; ··· 788 783 chip->pipe_cyclic_mask); 789 784 break; 790 785 case SNDRV_PCM_TRIGGER_SUSPEND: 791 - DE_ACT(("pcm_trigger suspend\n")); 786 + dev_dbg(chip->card->dev, "pcm_trigger suspend\n"); 792 787 case SNDRV_PCM_TRIGGER_STOP: 793 - DE_ACT(("pcm_trigger stop\n")); 788 + dev_dbg(chip->card->dev, "pcm_trigger stop\n"); 794 789 for (i = 0; i < DSP_MAXPIPES; i++) { 795 790 if (channelmask & (1 << i)) { 796 791 pipe = chip->substream[i]->runtime->private_data; ··· 800 795 err = stop_transport(chip, channelmask); 801 796 break; 802 797 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 803 - DE_ACT(("pcm_trigger pause\n")); 798 + dev_dbg(chip->card->dev, "pcm_trigger pause\n"); 804 799 for (i = 0; i < DSP_MAXPIPES; i++) { 805 800 if (channelmask & (1 << i)) { 806 801 pipe = chip->substream[i]->runtime->private_data; ··· 937 932 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops); 938 933 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0) 939 934 return err; 940 - DE_INIT(("Analog PCM ok\n")); 935 + dev_dbg(chip->card->dev, "Analog PCM ok\n"); 941 936 942 937 #ifdef ECHOCARD_HAS_DIGITAL_IO 943 938 /* PCM#1 Digital inputs, no outputs */ ··· 950 945 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops); 951 946 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0) 952 947 return err; 953 - DE_INIT(("Digital PCM ok\n")); 948 + dev_dbg(chip->card->dev, "Digital PCM ok\n"); 954 949 #endif /* ECHOCARD_HAS_DIGITAL_IO */ 955 950 956 951 #else /* ECHOCARD_HAS_VMIXER */ ··· 972 967 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &analog_capture_ops); 973 968 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0) 974 969 return err; 975 - DE_INIT(("Analog PCM ok\n")); 970 + dev_dbg(chip->card->dev, "Analog PCM ok\n"); 976 971 977 972 #ifdef ECHOCARD_HAS_DIGITAL_IO 978 973 /* PCM#1 Digital i/o */ ··· 987 982 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &digital_capture_ops); 988 983 if ((err = snd_echo_preallocate_pages(pcm, snd_dma_pci_data(chip->pci))) < 0) 989 984 return err; 990 - DE_INIT(("Digital PCM ok\n")); 985 + dev_dbg(chip->card->dev, "Digital PCM ok\n"); 991 986 #endif /* ECHOCARD_HAS_DIGITAL_IO */ 992 987 993 988 #endif /* ECHOCARD_HAS_VMIXER */ ··· 1480 1475 snd_ctl_notify(chip->card, 1481 1476 SNDRV_CTL_EVENT_MASK_VALUE, 1482 1477 &chip->clock_src_ctl->id); 1483 - DE_ACT(("SDM() =%d\n", changed)); 1478 + dev_dbg(chip->card->dev, 1479 + "SDM() =%d\n", changed); 1484 1480 } 1485 1481 if (changed >= 0) 1486 1482 changed = 1; /* No errors */ ··· 1608 1602 } 1609 1603 1610 1604 if (changed < 0) 1611 - DE_ACT(("seticlk val%d err 0x%x\n", dclock, changed)); 1605 + dev_dbg(chip->card->dev, 1606 + "seticlk val%d err 0x%x\n", dclock, changed); 1612 1607 1613 1608 return changed; 1614 1609 } ··· 1866 1859 #ifdef ECHOCARD_HAS_MIDI 1867 1860 if (st > 0 && chip->midi_in) { 1868 1861 snd_rawmidi_receive(chip->midi_in, chip->midi_buffer, st); 1869 - DE_MID(("rawmidi_iread=%d\n", st)); 1862 + dev_dbg(chip->card->dev, "rawmidi_iread=%d\n", st); 1870 1863 } 1871 1864 #endif 1872 1865 return IRQ_HANDLED; ··· 1881 1874 1882 1875 static int snd_echo_free(struct echoaudio *chip) 1883 1876 { 1884 - DE_INIT(("Stop DSP...\n")); 1877 + dev_dbg(chip->card->dev, "Stop DSP...\n"); 1885 1878 if (chip->comm_page) 1886 1879 rest_in_peace(chip); 1887 - DE_INIT(("Stopped.\n")); 1880 + dev_dbg(chip->card->dev, "Stopped.\n"); 1888 1881 1889 1882 if (chip->irq >= 0) 1890 1883 free_irq(chip->irq, chip); ··· 1898 1891 if (chip->iores) 1899 1892 release_and_free_resource(chip->iores); 1900 1893 1901 - DE_INIT(("MMIO freed.\n")); 1894 + dev_dbg(chip->card->dev, "MMIO freed.\n"); 1902 1895 1903 1896 pci_disable_device(chip->pci); 1904 1897 1905 1898 /* release chip data */ 1906 1899 free_firmware_cache(chip); 1907 1900 kfree(chip); 1908 - DE_INIT(("Chip freed.\n")); 1901 + dev_dbg(chip->card->dev, "Chip freed.\n"); 1909 1902 return 0; 1910 1903 } 1911 1904 ··· 1915 1908 { 1916 1909 struct echoaudio *chip = device->device_data; 1917 1910 1918 - DE_INIT(("snd_echo_dev_free()...\n")); 1911 + dev_dbg(chip->card->dev, "snd_echo_dev_free()...\n"); 1919 1912 return snd_echo_free(chip); 1920 1913 } 1921 1914 ··· 1948 1941 pci_disable_device(pci); 1949 1942 return -ENOMEM; 1950 1943 } 1951 - DE_INIT(("chip=%p\n", chip)); 1944 + dev_dbg(card->dev, "chip=%p\n", chip); 1952 1945 spin_lock_init(&chip->lock); 1953 1946 chip->card = card; 1954 1947 chip->pci = pci; ··· 1985 1978 return -EBUSY; 1986 1979 } 1987 1980 chip->irq = pci->irq; 1988 - DE_INIT(("pci=%p irq=%d subdev=%04x Init hardware...\n", 1989 - chip->pci, chip->irq, chip->pci->subsystem_device)); 1981 + dev_dbg(card->dev, "pci=%p irq=%d subdev=%04x Init hardware...\n", 1982 + chip->pci, chip->irq, chip->pci->subsystem_device); 1990 1983 1991 1984 /* Create the DSP comm page - this is the area of memory used for most 1992 1985 of the communication with the DSP, which accesses it via bus mastering */ ··· 2004 1997 if (err >= 0) 2005 1998 err = set_mixer_defaults(chip); 2006 1999 if (err < 0) { 2007 - DE_INIT(("init_hw err=%d\n", err)); 2000 + dev_err(card->dev, "init_hw err=%d\n", err); 2008 2001 snd_echo_free(chip); 2009 2002 return err; 2010 2003 } 2011 - DE_INIT(("Card init OK\n")); 2004 + dev_dbg(card->dev, "Card init OK\n"); 2012 2005 2013 2006 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { 2014 2007 snd_echo_free(chip); ··· 2038 2031 return -ENOENT; 2039 2032 } 2040 2033 2041 - DE_INIT(("Echoaudio driver starting...\n")); 2034 + dev_dbg(&pci->dev, "Echoaudio driver starting...\n"); 2042 2035 i = 0; 2043 2036 err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE, 2044 2037 0, &card); ··· 2191 2184 struct pci_dev *pci = to_pci_dev(dev); 2192 2185 struct echoaudio *chip = dev_get_drvdata(dev); 2193 2186 2194 - DE_INIT(("suspend start\n")); 2187 + dev_dbg(dev, "suspend start\n"); 2195 2188 snd_pcm_suspend_all(chip->analog_pcm); 2196 2189 snd_pcm_suspend_all(chip->digital_pcm); 2197 2190 ··· 2218 2211 pci_save_state(pci); 2219 2212 pci_disable_device(pci); 2220 2213 2221 - DE_INIT(("suspend done\n")); 2214 + dev_dbg(dev, "suspend done\n"); 2222 2215 return 0; 2223 2216 } 2224 2217 ··· 2232 2225 u32 pipe_alloc_mask; 2233 2226 int err; 2234 2227 2235 - DE_INIT(("resume start\n")); 2228 + dev_dbg(dev, "resume start\n"); 2236 2229 pci_restore_state(pci); 2237 2230 commpage_bak = kmalloc(sizeof(struct echoaudio), GFP_KERNEL); 2238 2231 if (commpage_bak == NULL) ··· 2243 2236 err = init_hw(chip, chip->pci->device, chip->pci->subsystem_device); 2244 2237 if (err < 0) { 2245 2238 kfree(commpage_bak); 2246 - DE_INIT(("resume init_hw err=%d\n", err)); 2239 + dev_err(dev, "resume init_hw err=%d\n", err); 2247 2240 snd_echo_free(chip); 2248 2241 return err; 2249 2242 } 2250 - DE_INIT(("resume init OK\n")); 2243 + dev_dbg(dev, "resume init OK\n"); 2251 2244 2252 2245 /* Temporarily set chip->pipe_alloc_mask=0 otherwise 2253 2246 * restore_dsp_settings() fails. ··· 2260 2253 kfree(commpage_bak); 2261 2254 return err; 2262 2255 } 2263 - DE_INIT(("resume restore OK\n")); 2256 + dev_dbg(dev, "resume restore OK\n"); 2264 2257 2265 2258 memcpy(&commpage->audio_format, &commpage_bak->audio_format, 2266 2259 sizeof(commpage->audio_format)); ··· 2277 2270 return -EBUSY; 2278 2271 } 2279 2272 chip->irq = pci->irq; 2280 - DE_INIT(("resume irq=%d\n", chip->irq)); 2273 + dev_dbg(dev, "resume irq=%d\n", chip->irq); 2281 2274 2282 2275 #ifdef ECHOCARD_HAS_MIDI 2283 2276 if (chip->midi_input_enabled) ··· 2286 2279 snd_echo_midi_output_trigger(chip->midi_out, 1); 2287 2280 #endif 2288 2281 2289 - DE_INIT(("resume done\n")); 2282 + dev_dbg(dev, "resume done\n"); 2290 2283 return 0; 2291 2284 } 2292 2285
-28
sound/pci/echoaudio/echoaudio.h
··· 295 295 #define PIPE_STATE_PENDING 3 /* Pipe has pending start */ 296 296 297 297 298 - /* Debug initialization */ 299 - #ifdef CONFIG_SND_DEBUG 300 - #define DE_INIT(x) snd_printk x 301 - #else 302 - #define DE_INIT(x) 303 - #endif 304 - 305 - /* Debug hw_params callbacks */ 306 - #ifdef CONFIG_SND_DEBUG 307 - #define DE_HWP(x) snd_printk x 308 - #else 309 - #define DE_HWP(x) 310 - #endif 311 - 312 - /* Debug normal activity (open, start, stop...) */ 313 - #ifdef CONFIG_SND_DEBUG 314 - #define DE_ACT(x) snd_printk x 315 - #else 316 - #define DE_ACT(x) 317 - #endif 318 - 319 - /* Debug midi activity */ 320 - #ifdef CONFIG_SND_DEBUG 321 - #define DE_MID(x) snd_printk x 322 - #else 323 - #define DE_MID(x) 324 - #endif 325 - 326 298 327 299 struct audiopipe { 328 300 volatile u32 *dma_counter; /* Commpage register that contains
+18 -14
sound/pci/echoaudio/echoaudio_3g.c
··· 51 51 } 52 52 53 53 box_status = le32_to_cpu(chip->comm_page->ext_box_status); 54 - DE_INIT(("box_status=%x\n", box_status)); 54 + dev_dbg(chip->card->dev, "box_status=%x\n", box_status); 55 55 if (box_status == E3G_ASIC_NOT_LOADED) 56 56 return -ENODEV; 57 57 ··· 76 76 if (wait_handshake(chip)) 77 77 return -EIO; 78 78 79 - DE_ACT(("WriteControlReg: Setting 0x%x, 0x%x\n", ctl, frq)); 79 + dev_dbg(chip->card->dev, 80 + "WriteControlReg: Setting 0x%x, 0x%x\n", ctl, frq); 80 81 81 82 ctl = cpu_to_le32(ctl); 82 83 frq = cpu_to_le32(frq); ··· 90 89 return send_vector(chip, DSP_VC_WRITE_CONTROL_REG); 91 90 } 92 91 93 - DE_ACT(("WriteControlReg: not written, no change\n")); 92 + dev_dbg(chip->card->dev, "WriteControlReg: not written, no change\n"); 94 93 return 0; 95 94 } 96 95 ··· 259 258 260 259 /* Only set the clock for internal mode. */ 261 260 if (chip->input_clock != ECHO_CLOCK_INTERNAL) { 262 - DE_ACT(("set_sample_rate: Cannot set sample rate - " 263 - "clock not set to CLK_CLOCKININTERNAL\n")); 261 + dev_warn(chip->card->dev, 262 + "Cannot set sample rate - clock not set to CLK_CLOCKININTERNAL\n"); 264 263 /* Save the rate anyhow */ 265 264 chip->comm_page->sample_rate = cpu_to_le32(rate); 266 265 chip->sample_rate = rate; ··· 314 313 315 314 chip->comm_page->sample_rate = cpu_to_le32(rate); /* ignored by the DSP */ 316 315 chip->sample_rate = rate; 317 - DE_ACT(("SetSampleRate: %d clock %x\n", rate, control_reg)); 316 + dev_dbg(chip->card->dev, 317 + "SetSampleRate: %d clock %x\n", rate, control_reg); 318 318 319 319 /* Tell the DSP about it - DSP reads both control reg & freq reg */ 320 320 return write_control_reg(chip, control_reg, frq_reg, 0); ··· 328 326 { 329 327 u32 control_reg, clocks_from_dsp; 330 328 331 - DE_ACT(("set_input_clock:\n")); 329 + dev_dbg(chip->card->dev, "set_input_clock:\n"); 332 330 333 331 /* Mask off the clock select bits */ 334 332 control_reg = le32_to_cpu(chip->comm_page->control_register) & ··· 337 335 338 336 switch (clock) { 339 337 case ECHO_CLOCK_INTERNAL: 340 - DE_ACT(("Set Echo3G clock to INTERNAL\n")); 338 + dev_dbg(chip->card->dev, "Set Echo3G clock to INTERNAL\n"); 341 339 chip->input_clock = ECHO_CLOCK_INTERNAL; 342 340 return set_sample_rate(chip, chip->sample_rate); 343 341 case ECHO_CLOCK_SPDIF: 344 342 if (chip->digital_mode == DIGITAL_MODE_ADAT) 345 343 return -EAGAIN; 346 - DE_ACT(("Set Echo3G clock to SPDIF\n")); 344 + dev_dbg(chip->card->dev, "Set Echo3G clock to SPDIF\n"); 347 345 control_reg |= E3G_SPDIF_CLOCK; 348 346 if (clocks_from_dsp & E3G_CLOCK_DETECT_BIT_SPDIF96) 349 347 control_reg |= E3G_DOUBLE_SPEED_MODE; ··· 353 351 case ECHO_CLOCK_ADAT: 354 352 if (chip->digital_mode != DIGITAL_MODE_ADAT) 355 353 return -EAGAIN; 356 - DE_ACT(("Set Echo3G clock to ADAT\n")); 354 + dev_dbg(chip->card->dev, "Set Echo3G clock to ADAT\n"); 357 355 control_reg |= E3G_ADAT_CLOCK; 358 356 control_reg &= ~E3G_DOUBLE_SPEED_MODE; 359 357 break; 360 358 case ECHO_CLOCK_WORD: 361 - DE_ACT(("Set Echo3G clock to WORD\n")); 359 + dev_dbg(chip->card->dev, "Set Echo3G clock to WORD\n"); 362 360 control_reg |= E3G_WORD_CLOCK; 363 361 if (clocks_from_dsp & E3G_CLOCK_DETECT_BIT_WORD96) 364 362 control_reg |= E3G_DOUBLE_SPEED_MODE; ··· 366 364 control_reg &= ~E3G_DOUBLE_SPEED_MODE; 367 365 break; 368 366 default: 369 - DE_ACT(("Input clock 0x%x not supported for Echo3G\n", clock)); 367 + dev_err(chip->card->dev, 368 + "Input clock 0x%x not supported for Echo3G\n", clock); 370 369 return -EINVAL; 371 370 } 372 371 ··· 395 392 incompatible_clock = TRUE; 396 393 break; 397 394 default: 398 - DE_ACT(("Digital mode not supported: %d\n", mode)); 395 + dev_err(chip->card->dev, 396 + "Digital mode not supported: %d\n", mode); 399 397 return -EINVAL; 400 398 } 401 399 ··· 431 427 return err; 432 428 chip->digital_mode = mode; 433 429 434 - DE_ACT(("set_digital_mode(%d)\n", chip->digital_mode)); 430 + dev_dbg(chip->card->dev, "set_digital_mode(%d)\n", chip->digital_mode); 435 431 return incompatible_clock; 436 432 }
+66 -45
sound/pci/echoaudio/echoaudio_dsp.c
··· 80 80 udelay(1); 81 81 } 82 82 83 - DE_ACT((KERN_ERR "timeout on send_vector\n")); 83 + dev_err(chip->card->dev, "timeout on send_vector\n"); 84 84 return -EBUSY; 85 85 } 86 86 ··· 104 104 } 105 105 106 106 chip->bad_board = TRUE; /* Set TRUE until DSP re-loaded */ 107 - DE_ACT((KERN_ERR "write_dsp: Set bad_board to TRUE\n")); 107 + dev_dbg(chip->card->dev, "write_dsp: Set bad_board to TRUE\n"); 108 108 return -EIO; 109 109 } 110 110 ··· 127 127 } 128 128 129 129 chip->bad_board = TRUE; /* Set TRUE until DSP re-loaded */ 130 - DE_INIT((KERN_ERR "read_dsp: Set bad_board to TRUE\n")); 130 + dev_err(chip->card->dev, "read_dsp: Set bad_board to TRUE\n"); 131 131 return -EIO; 132 132 } 133 133 ··· 154 154 return -EIO; 155 155 } 156 156 } 157 - DE_INIT(("Read serial number %08x %08x %08x %08x %08x\n", 158 - sn[0], sn[1], sn[2], sn[3], sn[4])); 157 + dev_dbg(chip->card->dev, 158 + "Read serial number %08x %08x %08x %08x %08x\n", 159 + sn[0], sn[1], sn[2], sn[3], sn[4]); 159 160 return 0; 160 161 } 161 162 ··· 206 205 goto la_error; 207 206 } 208 207 209 - DE_INIT(("ASIC loaded\n")); 208 + dev_dbg(chip->card->dev, "ASIC loaded\n"); 210 209 free_firmware(fw, chip); 211 210 return 0; 212 211 213 212 la_error: 214 - DE_INIT(("failed on write_dsp\n")); 213 + dev_err(chip->card->dev, "failed on write_dsp\n"); 215 214 free_firmware(fw, chip); 216 215 return -EIO; 217 216 } ··· 242 241 loader is already installed, host flag 5 will be on. */ 243 242 status = get_dsp_register(chip, CHI32_STATUS_REG); 244 243 if (status & CHI32_STATUS_REG_HF5) { 245 - DE_INIT(("Resident loader already installed; status is 0x%x\n", 246 - status)); 244 + dev_dbg(chip->card->dev, 245 + "Resident loader already installed; status is 0x%x\n", 246 + status); 247 247 return 0; 248 248 } 249 249 ··· 285 283 286 284 /* Write the count to the DSP */ 287 285 if (write_dsp(chip, words)) { 288 - DE_INIT(("install_resident_loader: Failed to write word count!\n")); 286 + dev_err(chip->card->dev, 287 + "install_resident_loader: Failed to write word count!\n"); 289 288 goto irl_error; 290 289 } 291 290 /* Write the DSP address */ 292 291 if (write_dsp(chip, address)) { 293 - DE_INIT(("install_resident_loader: Failed to write DSP address!\n")); 292 + dev_err(chip->card->dev, 293 + "install_resident_loader: Failed to write DSP address!\n"); 294 294 goto irl_error; 295 295 } 296 296 /* Write out this block of code to the DSP */ ··· 301 297 302 298 data = ((u32)code[index] << 16) + code[index + 1]; 303 299 if (write_dsp(chip, data)) { 304 - DE_INIT(("install_resident_loader: Failed to write DSP code\n")); 300 + dev_err(chip->card->dev, 301 + "install_resident_loader: Failed to write DSP code\n"); 305 302 goto irl_error; 306 303 } 307 304 index += 2; ··· 317 312 } 318 313 319 314 if (i == 200) { 320 - DE_INIT(("Resident loader failed to set HF5\n")); 315 + dev_err(chip->card->dev, "Resident loader failed to set HF5\n"); 321 316 goto irl_error; 322 317 } 323 318 324 - DE_INIT(("Resident loader successfully installed\n")); 319 + dev_dbg(chip->card->dev, "Resident loader successfully installed\n"); 325 320 free_firmware(fw, chip); 326 321 return 0; 327 322 ··· 339 334 int index, words, i; 340 335 341 336 if (chip->dsp_code == code) { 342 - DE_INIT(("DSP is already loaded!\n")); 337 + dev_warn(chip->card->dev, "DSP is already loaded!\n"); 343 338 return 0; 344 339 } 345 340 chip->bad_board = TRUE; /* Set TRUE until DSP loaded */ 346 341 chip->dsp_code = NULL; /* Current DSP code not loaded */ 347 342 chip->asic_loaded = FALSE; /* Loading the DSP code will reset the ASIC */ 348 343 349 - DE_INIT(("load_dsp: Set bad_board to TRUE\n")); 344 + dev_dbg(chip->card->dev, "load_dsp: Set bad_board to TRUE\n"); 350 345 351 346 /* If this board requires a resident loader, install it. */ 352 347 #ifdef DSP_56361 ··· 356 351 357 352 /* Send software reset command */ 358 353 if (send_vector(chip, DSP_VC_RESET) < 0) { 359 - DE_INIT(("LoadDsp: send_vector DSP_VC_RESET failed, Critical Failure\n")); 354 + dev_err(chip->card->dev, 355 + "LoadDsp: send_vector DSP_VC_RESET failed, Critical Failure\n"); 360 356 return -EIO; 361 357 } 362 358 /* Delay 10us */ ··· 372 366 } 373 367 374 368 if (i == 1000) { 375 - DE_INIT(("load_dsp: Timeout waiting for CHI32_STATUS_REG_HF3\n")); 369 + dev_err(chip->card->dev, 370 + "load_dsp: Timeout waiting for CHI32_STATUS_REG_HF3\n"); 376 371 return -EIO; 377 372 } 378 373 ··· 410 403 index += 2; 411 404 412 405 if (write_dsp(chip, words) < 0) { 413 - DE_INIT(("load_dsp: failed to write number of DSP words\n")); 406 + dev_err(chip->card->dev, 407 + "load_dsp: failed to write number of DSP words\n"); 414 408 return -EIO; 415 409 } 416 410 if (write_dsp(chip, address) < 0) { 417 - DE_INIT(("load_dsp: failed to write DSP address\n")); 411 + dev_err(chip->card->dev, 412 + "load_dsp: failed to write DSP address\n"); 418 413 return -EIO; 419 414 } 420 415 if (write_dsp(chip, mem_type) < 0) { 421 - DE_INIT(("load_dsp: failed to write DSP memory type\n")); 416 + dev_err(chip->card->dev, 417 + "load_dsp: failed to write DSP memory type\n"); 422 418 return -EIO; 423 419 } 424 420 /* Code */ 425 421 for (i = 0; i < words; i++, index+=2) { 426 422 data = ((u32)code[index] << 16) + code[index + 1]; 427 423 if (write_dsp(chip, data) < 0) { 428 - DE_INIT(("load_dsp: failed to write DSP data\n")); 424 + dev_err(chip->card->dev, 425 + "load_dsp: failed to write DSP data\n"); 429 426 return -EIO; 430 427 } 431 428 } 432 429 } 433 430 434 431 if (write_dsp(chip, 0) < 0) { /* We're done!!! */ 435 - DE_INIT(("load_dsp: Failed to write final zero\n")); 432 + dev_err(chip->card->dev, 433 + "load_dsp: Failed to write final zero\n"); 436 434 return -EIO; 437 435 } 438 436 udelay(10); ··· 450 438 get_dsp_register(chip, CHI32_CONTROL_REG) & ~0x1b00); 451 439 452 440 if (write_dsp(chip, DSP_FNC_SET_COMMPAGE_ADDR) < 0) { 453 - DE_INIT(("load_dsp: Failed to write DSP_FNC_SET_COMMPAGE_ADDR\n")); 441 + dev_err(chip->card->dev, 442 + "load_dsp: Failed to write DSP_FNC_SET_COMMPAGE_ADDR\n"); 454 443 return -EIO; 455 444 } 456 445 457 446 if (write_dsp(chip, chip->comm_page_phys) < 0) { 458 - DE_INIT(("load_dsp: Failed to write comm page address\n")); 447 + dev_err(chip->card->dev, 448 + "load_dsp: Failed to write comm page address\n"); 459 449 return -EIO; 460 450 } 461 451 ··· 466 452 We don't actually use the serial number but we have to 467 453 get it as part of the DSP init voodoo. */ 468 454 if (read_sn(chip) < 0) { 469 - DE_INIT(("load_dsp: Failed to read serial number\n")); 455 + dev_err(chip->card->dev, 456 + "load_dsp: Failed to read serial number\n"); 470 457 return -EIO; 471 458 } 472 459 473 460 chip->dsp_code = code; /* Show which DSP code loaded */ 474 461 chip->bad_board = FALSE; /* DSP OK */ 475 - DE_INIT(("load_dsp: OK!\n")); 462 + dev_dbg(chip->card->dev, "load_dsp: OK!\n"); 476 463 return 0; 477 464 } 478 465 udelay(100); 479 466 } 480 467 481 - DE_INIT(("load_dsp: DSP load timed out waiting for HF4\n")); 468 + dev_err(chip->card->dev, 469 + "load_dsp: DSP load timed out waiting for HF4\n"); 482 470 return -EIO; 483 471 } 484 472 ··· 674 658 static int restore_dsp_rettings(struct echoaudio *chip) 675 659 { 676 660 int i, o, err; 677 - DE_INIT(("restore_dsp_settings\n")); 661 + dev_dbg(chip->card->dev, "restore_dsp_settings\n"); 678 662 679 663 if ((err = check_asic_status(chip)) < 0) 680 664 return err; ··· 771 755 if (send_vector(chip, DSP_VC_UPDATE_FLAGS) < 0) 772 756 return -EIO; 773 757 774 - DE_INIT(("restore_dsp_rettings done\n")); 758 + dev_dbg(chip->card->dev, "restore_dsp_rettings done\n"); 775 759 return 0; 776 760 } 777 761 ··· 851 835 break; 852 836 } 853 837 } 854 - DE_ACT(("set_audio_format[%d] = %x\n", pipe_index, dsp_format)); 838 + dev_dbg(chip->card->dev, 839 + "set_audio_format[%d] = %x\n", pipe_index, dsp_format); 855 840 chip->comm_page->audio_format[pipe_index] = cpu_to_le16(dsp_format); 856 841 } 857 842 ··· 865 848 static int start_transport(struct echoaudio *chip, u32 channel_mask, 866 849 u32 cyclic_mask) 867 850 { 868 - DE_ACT(("start_transport %x\n", channel_mask)); 851 + dev_dbg(chip->card->dev, "start_transport %x\n", channel_mask); 869 852 870 853 if (wait_handshake(chip)) 871 854 return -EIO; ··· 883 866 return 0; 884 867 } 885 868 886 - DE_ACT(("start_transport: No pipes to start!\n")); 869 + dev_err(chip->card->dev, "start_transport: No pipes to start!\n"); 887 870 return -EINVAL; 888 871 } 889 872 ··· 891 874 892 875 static int pause_transport(struct echoaudio *chip, u32 channel_mask) 893 876 { 894 - DE_ACT(("pause_transport %x\n", channel_mask)); 877 + dev_dbg(chip->card->dev, "pause_transport %x\n", channel_mask); 895 878 896 879 if (wait_handshake(chip)) 897 880 return -EIO; ··· 910 893 return 0; 911 894 } 912 895 913 - DE_ACT(("pause_transport: No pipes to stop!\n")); 896 + dev_warn(chip->card->dev, "pause_transport: No pipes to stop!\n"); 914 897 return 0; 915 898 } 916 899 ··· 918 901 919 902 static int stop_transport(struct echoaudio *chip, u32 channel_mask) 920 903 { 921 - DE_ACT(("stop_transport %x\n", channel_mask)); 904 + dev_dbg(chip->card->dev, "stop_transport %x\n", channel_mask); 922 905 923 906 if (wait_handshake(chip)) 924 907 return -EIO; ··· 937 920 return 0; 938 921 } 939 922 940 - DE_ACT(("stop_transport: No pipes to stop!\n")); 923 + dev_warn(chip->card->dev, "stop_transport: No pipes to stop!\n"); 941 924 return 0; 942 925 } 943 926 ··· 954 937 stopped and unallocated. */ 955 938 static int rest_in_peace(struct echoaudio *chip) 956 939 { 957 - DE_ACT(("rest_in_peace() open=%x\n", chip->pipe_alloc_mask)); 940 + dev_dbg(chip->card->dev, 941 + "rest_in_peace() open=%x\n", chip->pipe_alloc_mask); 958 942 959 943 /* Stops all active pipes (just to be sure) */ 960 944 stop_transport(chip, chip->active_mask); ··· 983 965 { 984 966 /* Check if the compiler added extra padding inside the structure */ 985 967 if (offsetof(struct comm_page, midi_output) != 0xbe0) { 986 - DE_INIT(("init_dsp_comm_page() - Invalid struct comm_page structure\n")); 968 + dev_err(chip->card->dev, 969 + "init_dsp_comm_page() - Invalid struct comm_page structure\n"); 987 970 return -EPERM; 988 971 } 989 972 ··· 1018 999 */ 1019 1000 static int init_line_levels(struct echoaudio *chip) 1020 1001 { 1021 - DE_INIT(("init_line_levels\n")); 1002 + dev_dbg(chip->card->dev, "init_line_levels\n"); 1022 1003 memset(chip->output_gain, ECHOGAIN_MUTED, sizeof(chip->output_gain)); 1023 1004 memset(chip->input_gain, ECHOGAIN_MUTED, sizeof(chip->input_gain)); 1024 1005 memset(chip->monitor_gain, ECHOGAIN_MUTED, sizeof(chip->monitor_gain)); ··· 1070 1051 u32 channel_mask; 1071 1052 char is_cyclic; 1072 1053 1073 - DE_ACT(("allocate_pipes: ch=%d int=%d\n", pipe_index, interleave)); 1054 + dev_dbg(chip->card->dev, 1055 + "allocate_pipes: ch=%d int=%d\n", pipe_index, interleave); 1074 1056 1075 1057 if (chip->bad_board) 1076 1058 return -EIO; ··· 1081 1061 for (channel_mask = i = 0; i < interleave; i++) 1082 1062 channel_mask |= 1 << (pipe_index + i); 1083 1063 if (chip->pipe_alloc_mask & channel_mask) { 1084 - DE_ACT(("allocate_pipes: channel already open\n")); 1064 + dev_err(chip->card->dev, 1065 + "allocate_pipes: channel already open\n"); 1085 1066 return -EAGAIN; 1086 1067 } 1087 1068 ··· 1099 1078 it moves data. The DMA counter is in units of bytes, not samples. */ 1100 1079 pipe->dma_counter = &chip->comm_page->position[pipe_index]; 1101 1080 *pipe->dma_counter = 0; 1102 - DE_ACT(("allocate_pipes: ok\n")); 1081 + dev_dbg(chip->card->dev, "allocate_pipes: ok\n"); 1103 1082 return pipe_index; 1104 1083 } 1105 1084 ··· 1110 1089 u32 channel_mask; 1111 1090 int i; 1112 1091 1113 - DE_ACT(("free_pipes: Pipe %d\n", pipe->index)); 1092 + dev_dbg(chip->card->dev, "free_pipes: Pipe %d\n", pipe->index); 1114 1093 if (snd_BUG_ON(!is_pipe_allocated(chip, pipe->index))) 1115 1094 return -EINVAL; 1116 1095 if (snd_BUG_ON(pipe->state != PIPE_STATE_STOPPED)) ··· 1152 1131 list[head].size = cpu_to_le32(length); 1153 1132 pipe->sglist_head++; 1154 1133 } else { 1155 - DE_ACT(("SGlist: too many fragments\n")); 1134 + dev_err(chip->card->dev, "SGlist: too many fragments\n"); 1156 1135 return -ENOMEM; 1157 1136 } 1158 1137 return 0;
+6 -5
sound/pci/echoaudio/echoaudio_gml.c
··· 46 46 /* The DSP will return a value to indicate whether or not the 47 47 ASIC is currently loaded */ 48 48 if (read_dsp(chip, &asic_status) < 0) { 49 - DE_INIT(("check_asic_status: failed on read_dsp\n")); 49 + dev_err(chip->card->dev, 50 + "check_asic_status: failed on read_dsp\n"); 50 51 chip->asic_loaded = FALSE; 51 52 return -EIO; 52 53 } ··· 69 68 else 70 69 value &= ~GML_DIGITAL_IN_AUTO_MUTE; 71 70 72 - DE_ACT(("write_control_reg: 0x%x\n", value)); 71 + dev_dbg(chip->card->dev, "write_control_reg: 0x%x\n", value); 73 72 74 73 /* Write the control register */ 75 74 value = cpu_to_le32(value); ··· 92 91 what the input clock is set or what is connected. */ 93 92 static int set_input_auto_mute(struct echoaudio *chip, int automute) 94 93 { 95 - DE_ACT(("set_input_auto_mute %d\n", automute)); 94 + dev_dbg(chip->card->dev, "set_input_auto_mute %d\n", automute); 96 95 97 96 chip->digital_in_automute = automute; 98 97 ··· 195 194 if ((err = write_control_reg(chip, control_reg, FALSE))) 196 195 return err; 197 196 chip->professional_spdif = prof; 198 - DE_ACT(("set_professional_spdif to %s\n", 199 - prof ? "Professional" : "Consumer")); 197 + dev_dbg(chip->card->dev, "set_professional_spdif to %s\n", 198 + prof ? "Professional" : "Consumer"); 200 199 return 0; 201 200 }
+8 -7
sound/pci/echoaudio/gina20_dsp.c
··· 37 37 { 38 38 int err; 39 39 40 - DE_INIT(("init_hw() - Gina20\n")); 40 + dev_dbg(chip->card->dev, "init_hw() - Gina20\n"); 41 41 if (snd_BUG_ON((subdevice_id & 0xfff0) != GINA20)) 42 42 return -ENODEV; 43 43 44 44 if ((err = init_dsp_comm_page(chip))) { 45 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 45 + dev_err(chip->card->dev, 46 + "init_hw - could not initialize DSP comm page\n"); 46 47 return err; 47 48 } 48 49 ··· 63 62 return err; 64 63 chip->bad_board = FALSE; 65 64 66 - DE_INIT(("init_hw done\n")); 65 + dev_dbg(chip->card->dev, "init_hw done\n"); 67 66 return err; 68 67 } 69 68 ··· 150 149 151 150 static int set_input_clock(struct echoaudio *chip, u16 clock) 152 151 { 153 - DE_ACT(("set_input_clock:\n")); 152 + dev_dbg(chip->card->dev, "set_input_clock:\n"); 154 153 155 154 switch (clock) { 156 155 case ECHO_CLOCK_INTERNAL: ··· 159 158 chip->spdif_status = GD_SPDIF_STATUS_UNDEF; 160 159 set_sample_rate(chip, chip->sample_rate); 161 160 chip->input_clock = clock; 162 - DE_ACT(("Set Gina clock to INTERNAL\n")); 161 + dev_dbg(chip->card->dev, "Set Gina clock to INTERNAL\n"); 163 162 break; 164 163 case ECHO_CLOCK_SPDIF: 165 164 chip->comm_page->gd_clock_state = GD_CLOCK_SPDIFIN; ··· 167 166 clear_handshake(chip); 168 167 send_vector(chip, DSP_VC_SET_GD_AUDIO_STATE); 169 168 chip->clock_state = GD_CLOCK_SPDIFIN; 170 - DE_ACT(("Set Gina20 clock to SPDIF\n")); 169 + dev_dbg(chip->card->dev, "Set Gina20 clock to SPDIF\n"); 171 170 chip->input_clock = clock; 172 171 break; 173 172 default: ··· 209 208 210 209 static int set_professional_spdif(struct echoaudio *chip, char prof) 211 210 { 212 - DE_ACT(("set_professional_spdif %d\n", prof)); 211 + dev_dbg(chip->card->dev, "set_professional_spdif %d\n", prof); 213 212 if (prof) 214 213 chip->comm_page->flags |= 215 214 cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
+22 -17
sound/pci/echoaudio/gina24_dsp.c
··· 41 41 { 42 42 int err; 43 43 44 - DE_INIT(("init_hw() - Gina24\n")); 44 + dev_dbg(chip->card->dev, "init_hw() - Gina24\n"); 45 45 if (snd_BUG_ON((subdevice_id & 0xfff0) != GINA24)) 46 46 return -ENODEV; 47 47 48 48 if ((err = init_dsp_comm_page(chip))) { 49 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 49 + dev_err(chip->card->dev, 50 + "init_hw - could not initialize DSP comm page\n"); 50 51 return err; 51 52 } 52 53 ··· 79 78 return err; 80 79 chip->bad_board = FALSE; 81 80 82 - DE_INIT(("init_hw done\n")); 81 + dev_dbg(chip->card->dev, "init_hw done\n"); 83 82 return err; 84 83 } 85 84 ··· 156 155 control_reg = GML_CONVERTER_ENABLE | GML_48KHZ; 157 156 err = write_control_reg(chip, control_reg, TRUE); 158 157 } 159 - DE_INIT(("load_asic() done\n")); 158 + dev_dbg(chip->card->dev, "load_asic() done\n"); 160 159 return err; 161 160 } 162 161 ··· 172 171 173 172 /* Only set the clock for internal mode. */ 174 173 if (chip->input_clock != ECHO_CLOCK_INTERNAL) { 175 - DE_ACT(("set_sample_rate: Cannot set sample rate - " 176 - "clock not set to CLK_CLOCKININTERNAL\n")); 174 + dev_warn(chip->card->dev, 175 + "Cannot set sample rate - clock not set to CLK_CLOCKININTERNAL\n"); 177 176 /* Save the rate anyhow */ 178 177 chip->comm_page->sample_rate = cpu_to_le32(rate); 179 178 chip->sample_rate = rate; ··· 218 217 clock = GML_8KHZ; 219 218 break; 220 219 default: 221 - DE_ACT(("set_sample_rate: %d invalid!\n", rate)); 220 + dev_err(chip->card->dev, 221 + "set_sample_rate: %d invalid!\n", rate); 222 222 return -EINVAL; 223 223 } 224 224 ··· 227 225 228 226 chip->comm_page->sample_rate = cpu_to_le32(rate); /* ignored by the DSP */ 229 227 chip->sample_rate = rate; 230 - DE_ACT(("set_sample_rate: %d clock %d\n", rate, clock)); 228 + dev_dbg(chip->card->dev, "set_sample_rate: %d clock %d\n", rate, clock); 231 229 232 230 return write_control_reg(chip, control_reg, FALSE); 233 231 } ··· 238 236 { 239 237 u32 control_reg, clocks_from_dsp; 240 238 241 - DE_ACT(("set_input_clock:\n")); 239 + dev_dbg(chip->card->dev, "set_input_clock:\n"); 242 240 243 241 /* Mask off the clock select bits */ 244 242 control_reg = le32_to_cpu(chip->comm_page->control_register) & ··· 247 245 248 246 switch (clock) { 249 247 case ECHO_CLOCK_INTERNAL: 250 - DE_ACT(("Set Gina24 clock to INTERNAL\n")); 248 + dev_dbg(chip->card->dev, "Set Gina24 clock to INTERNAL\n"); 251 249 chip->input_clock = ECHO_CLOCK_INTERNAL; 252 250 return set_sample_rate(chip, chip->sample_rate); 253 251 case ECHO_CLOCK_SPDIF: 254 252 if (chip->digital_mode == DIGITAL_MODE_ADAT) 255 253 return -EAGAIN; 256 - DE_ACT(("Set Gina24 clock to SPDIF\n")); 254 + dev_dbg(chip->card->dev, "Set Gina24 clock to SPDIF\n"); 257 255 control_reg |= GML_SPDIF_CLOCK; 258 256 if (clocks_from_dsp & GML_CLOCK_DETECT_BIT_SPDIF96) 259 257 control_reg |= GML_DOUBLE_SPEED_MODE; ··· 263 261 case ECHO_CLOCK_ADAT: 264 262 if (chip->digital_mode != DIGITAL_MODE_ADAT) 265 263 return -EAGAIN; 266 - DE_ACT(("Set Gina24 clock to ADAT\n")); 264 + dev_dbg(chip->card->dev, "Set Gina24 clock to ADAT\n"); 267 265 control_reg |= GML_ADAT_CLOCK; 268 266 control_reg &= ~GML_DOUBLE_SPEED_MODE; 269 267 break; 270 268 case ECHO_CLOCK_ESYNC: 271 - DE_ACT(("Set Gina24 clock to ESYNC\n")); 269 + dev_dbg(chip->card->dev, "Set Gina24 clock to ESYNC\n"); 272 270 control_reg |= GML_ESYNC_CLOCK; 273 271 control_reg &= ~GML_DOUBLE_SPEED_MODE; 274 272 break; 275 273 case ECHO_CLOCK_ESYNC96: 276 - DE_ACT(("Set Gina24 clock to ESYNC96\n")); 274 + dev_dbg(chip->card->dev, "Set Gina24 clock to ESYNC96\n"); 277 275 control_reg |= GML_ESYNC_CLOCK | GML_DOUBLE_SPEED_MODE; 278 276 break; 279 277 default: 280 - DE_ACT(("Input clock 0x%x not supported for Gina24\n", clock)); 278 + dev_err(chip->card->dev, 279 + "Input clock 0x%x not supported for Gina24\n", clock); 281 280 return -EINVAL; 282 281 } 283 282 ··· 307 304 incompatible_clock = TRUE; 308 305 break; 309 306 default: 310 - DE_ACT(("Digital mode not supported: %d\n", mode)); 307 + dev_err(chip->card->dev, 308 + "Digital mode not supported: %d\n", mode); 311 309 return -EINVAL; 312 310 } 313 311 ··· 348 344 return err; 349 345 chip->digital_mode = mode; 350 346 351 - DE_ACT(("set_digital_mode to %d\n", chip->digital_mode)); 347 + dev_dbg(chip->card->dev, 348 + "set_digital_mode to %d\n", chip->digital_mode); 352 349 return incompatible_clock; 353 350 }
+8 -5
sound/pci/echoaudio/indigo_dsp.c
··· 38 38 { 39 39 int err; 40 40 41 - DE_INIT(("init_hw() - Indigo\n")); 41 + dev_dbg(chip->card->dev, "init_hw() - Indigo\n"); 42 42 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO)) 43 43 return -ENODEV; 44 44 45 45 if ((err = init_dsp_comm_page(chip))) { 46 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 46 + dev_err(chip->card->dev, 47 + "init_hw - could not initialize DSP comm page\n"); 47 48 return err; 48 49 } 49 50 ··· 61 60 return err; 62 61 chip->bad_board = FALSE; 63 62 64 - DE_INIT(("init_hw done\n")); 63 + dev_dbg(chip->card->dev, "init_hw done\n"); 65 64 return err; 66 65 } 67 66 ··· 110 109 control_reg = MIA_32000; 111 110 break; 112 111 default: 113 - DE_ACT(("set_sample_rate: %d invalid!\n", rate)); 112 + dev_err(chip->card->dev, 113 + "set_sample_rate: %d invalid!\n", rate); 114 114 return -EINVAL; 115 115 } 116 116 ··· 149 147 index = output * num_pipes_out(chip) + pipe; 150 148 chip->comm_page->vmixer[index] = gain; 151 149 152 - DE_ACT(("set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain)); 150 + dev_dbg(chip->card->dev, 151 + "set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain); 153 152 return 0; 154 153 } 155 154
+4 -2
sound/pci/echoaudio/indigo_express_dsp.c
··· 61 61 62 62 control_reg |= clock; 63 63 if (control_reg != old_control_reg) { 64 - DE_ACT(("set_sample_rate: %d clock %d\n", rate, clock)); 64 + dev_dbg(chip->card->dev, 65 + "set_sample_rate: %d clock %d\n", rate, clock); 65 66 chip->comm_page->control_register = cpu_to_le32(control_reg); 66 67 chip->sample_rate = rate; 67 68 clear_handshake(chip); ··· 90 89 index = output * num_pipes_out(chip) + pipe; 91 90 chip->comm_page->vmixer[index] = gain; 92 91 93 - DE_ACT(("set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain)); 92 + dev_dbg(chip->card->dev, 93 + "set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain); 94 94 return 0; 95 95 } 96 96
+8 -5
sound/pci/echoaudio/indigodj_dsp.c
··· 38 38 { 39 39 int err; 40 40 41 - DE_INIT(("init_hw() - Indigo DJ\n")); 41 + dev_dbg(chip->card->dev, "init_hw() - Indigo DJ\n"); 42 42 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_DJ)) 43 43 return -ENODEV; 44 44 45 45 if ((err = init_dsp_comm_page(chip))) { 46 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 46 + dev_err(chip->card->dev, 47 + "init_hw - could not initialize DSP comm page\n"); 47 48 return err; 48 49 } 49 50 ··· 61 60 return err; 62 61 chip->bad_board = FALSE; 63 62 64 - DE_INIT(("init_hw done\n")); 63 + dev_dbg(chip->card->dev, "init_hw done\n"); 65 64 return err; 66 65 } 67 66 ··· 110 109 control_reg = MIA_32000; 111 110 break; 112 111 default: 113 - DE_ACT(("set_sample_rate: %d invalid!\n", rate)); 112 + dev_err(chip->card->dev, 113 + "set_sample_rate: %d invalid!\n", rate); 114 114 return -EINVAL; 115 115 } 116 116 ··· 149 147 index = output * num_pipes_out(chip) + pipe; 150 148 chip->comm_page->vmixer[index] = gain; 151 149 152 - DE_ACT(("set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain)); 150 + dev_dbg(chip->card->dev, 151 + "set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain); 153 152 return 0; 154 153 } 155 154
+4 -3
sound/pci/echoaudio/indigodjx_dsp.c
··· 35 35 { 36 36 int err; 37 37 38 - DE_INIT(("init_hw() - Indigo DJx\n")); 38 + dev_dbg(chip->card->dev, "init_hw() - Indigo DJx\n"); 39 39 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_DJX)) 40 40 return -ENODEV; 41 41 42 42 err = init_dsp_comm_page(chip); 43 43 if (err < 0) { 44 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 44 + dev_err(chip->card->dev, 45 + "init_hw - could not initialize DSP comm page\n"); 45 46 return err; 46 47 } 47 48 ··· 60 59 return err; 61 60 chip->bad_board = FALSE; 62 61 63 - DE_INIT(("init_hw done\n")); 62 + dev_dbg(chip->card->dev, "init_hw done\n"); 64 63 return err; 65 64 } 66 65
+6 -4
sound/pci/echoaudio/indigoio_dsp.c
··· 38 38 { 39 39 int err; 40 40 41 - DE_INIT(("init_hw() - Indigo IO\n")); 41 + dev_dbg(chip->card->dev, "init_hw() - Indigo IO\n"); 42 42 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_IO)) 43 43 return -ENODEV; 44 44 45 45 if ((err = init_dsp_comm_page(chip))) { 46 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 46 + dev_err(chip->card->dev, 47 + "init_hw - could not initialize DSP comm page\n"); 47 48 return err; 48 49 } 49 50 ··· 61 60 return err; 62 61 chip->bad_board = FALSE; 63 62 64 - DE_INIT(("init_hw done\n")); 63 + dev_dbg(chip->card->dev, "init_hw done\n"); 65 64 return err; 66 65 } 67 66 ··· 119 118 index = output * num_pipes_out(chip) + pipe; 120 119 chip->comm_page->vmixer[index] = gain; 121 120 122 - DE_ACT(("set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain)); 121 + dev_dbg(chip->card->dev, 122 + "set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain); 123 123 return 0; 124 124 } 125 125
+4 -3
sound/pci/echoaudio/indigoiox_dsp.c
··· 35 35 { 36 36 int err; 37 37 38 - DE_INIT(("init_hw() - Indigo IOx\n")); 38 + dev_dbg(chip->card->dev, "init_hw() - Indigo IOx\n"); 39 39 if (snd_BUG_ON((subdevice_id & 0xfff0) != INDIGO_IOX)) 40 40 return -ENODEV; 41 41 42 42 err = init_dsp_comm_page(chip); 43 43 if (err < 0) { 44 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 44 + dev_err(chip->card->dev, 45 + "init_hw - could not initialize DSP comm page\n"); 45 46 return err; 46 47 } 47 48 ··· 60 59 return err; 61 60 chip->bad_board = FALSE; 62 61 63 - DE_INIT(("init_hw done\n")); 62 + dev_dbg(chip->card->dev, "init_hw done\n"); 64 63 return err; 65 64 } 66 65
+20 -17
sound/pci/echoaudio/layla20_dsp.c
··· 40 40 { 41 41 int err; 42 42 43 - DE_INIT(("init_hw() - Layla20\n")); 43 + dev_dbg(chip->card->dev, "init_hw() - Layla20\n"); 44 44 if (snd_BUG_ON((subdevice_id & 0xfff0) != LAYLA20)) 45 45 return -ENODEV; 46 46 47 47 if ((err = init_dsp_comm_page(chip))) { 48 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 48 + dev_err(chip->card->dev, 49 + "init_hw - could not initialize DSP comm page\n"); 49 50 return err; 50 51 } 51 52 ··· 65 64 return err; 66 65 chip->bad_board = FALSE; 67 66 68 - DE_INIT(("init_hw done\n")); 67 + dev_dbg(chip->card->dev, "init_hw done\n"); 69 68 return err; 70 69 } 71 70 ··· 122 121 /* The DSP will return a value to indicate whether or not 123 122 the ASIC is currently loaded */ 124 123 if (read_dsp(chip, &asic_status) < 0) { 125 - DE_ACT(("check_asic_status: failed on read_dsp\n")); 124 + dev_err(chip->card->dev, 125 + "check_asic_status: failed on read_dsp\n"); 126 126 return -EIO; 127 127 } 128 128 ··· 166 164 /* Only set the clock for internal mode. Do not return failure, 167 165 simply treat it as a non-event. */ 168 166 if (chip->input_clock != ECHO_CLOCK_INTERNAL) { 169 - DE_ACT(("set_sample_rate: Cannot set sample rate - " 170 - "clock not set to CLK_CLOCKININTERNAL\n")); 167 + dev_warn(chip->card->dev, 168 + "Cannot set sample rate - clock not set to CLK_CLOCKININTERNAL\n"); 171 169 chip->comm_page->sample_rate = cpu_to_le32(rate); 172 170 chip->sample_rate = rate; 173 171 return 0; ··· 176 174 if (wait_handshake(chip)) 177 175 return -EIO; 178 176 179 - DE_ACT(("set_sample_rate(%d)\n", rate)); 177 + dev_dbg(chip->card->dev, "set_sample_rate(%d)\n", rate); 180 178 chip->sample_rate = rate; 181 179 chip->comm_page->sample_rate = cpu_to_le32(rate); 182 180 clear_handshake(chip); ··· 190 188 u16 clock; 191 189 u32 rate; 192 190 193 - DE_ACT(("set_input_clock:\n")); 191 + dev_dbg(chip->card->dev, "set_input_clock:\n"); 194 192 rate = 0; 195 193 switch (clock_source) { 196 194 case ECHO_CLOCK_INTERNAL: 197 - DE_ACT(("Set Layla20 clock to INTERNAL\n")); 195 + dev_dbg(chip->card->dev, "Set Layla20 clock to INTERNAL\n"); 198 196 rate = chip->sample_rate; 199 197 clock = LAYLA20_CLOCK_INTERNAL; 200 198 break; 201 199 case ECHO_CLOCK_SPDIF: 202 - DE_ACT(("Set Layla20 clock to SPDIF\n")); 200 + dev_dbg(chip->card->dev, "Set Layla20 clock to SPDIF\n"); 203 201 clock = LAYLA20_CLOCK_SPDIF; 204 202 break; 205 203 case ECHO_CLOCK_WORD: 206 - DE_ACT(("Set Layla20 clock to WORD\n")); 204 + dev_dbg(chip->card->dev, "Set Layla20 clock to WORD\n"); 207 205 clock = LAYLA20_CLOCK_WORD; 208 206 break; 209 207 case ECHO_CLOCK_SUPER: 210 - DE_ACT(("Set Layla20 clock to SUPER\n")); 208 + dev_dbg(chip->card->dev, "Set Layla20 clock to SUPER\n"); 211 209 clock = LAYLA20_CLOCK_SUPER; 212 210 break; 213 211 default: 214 - DE_ACT(("Input clock 0x%x not supported for Layla24\n", 215 - clock_source)); 212 + dev_err(chip->card->dev, 213 + "Input clock 0x%x not supported for Layla24\n", 214 + clock_source); 216 215 return -EINVAL; 217 216 } 218 217 chip->input_clock = clock_source; ··· 232 229 233 230 static int set_output_clock(struct echoaudio *chip, u16 clock) 234 231 { 235 - DE_ACT(("set_output_clock: %d\n", clock)); 232 + dev_dbg(chip->card->dev, "set_output_clock: %d\n", clock); 236 233 switch (clock) { 237 234 case ECHO_CLOCK_SUPER: 238 235 clock = LAYLA20_OUTPUT_CLOCK_SUPER; ··· 241 238 clock = LAYLA20_OUTPUT_CLOCK_WORD; 242 239 break; 243 240 default: 244 - DE_ACT(("set_output_clock wrong clock\n")); 241 + dev_err(chip->card->dev, "set_output_clock wrong clock\n"); 245 242 return -EINVAL; 246 243 } 247 244 ··· 286 283 287 284 static int set_professional_spdif(struct echoaudio *chip, char prof) 288 285 { 289 - DE_ACT(("set_professional_spdif %d\n", prof)); 286 + dev_dbg(chip->card->dev, "set_professional_spdif %d\n", prof); 290 287 if (prof) 291 288 chip->comm_page->flags |= 292 289 cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
+19 -15
sound/pci/echoaudio/layla24_dsp.c
··· 40 40 { 41 41 int err; 42 42 43 - DE_INIT(("init_hw() - Layla24\n")); 43 + dev_dbg(chip->card->dev, "init_hw() - Layla24\n"); 44 44 if (snd_BUG_ON((subdevice_id & 0xfff0) != LAYLA24)) 45 45 return -ENODEV; 46 46 47 47 if ((err = init_dsp_comm_page(chip))) { 48 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 48 + dev_err(chip->card->dev, 49 + "init_hw - could not initialize DSP comm page\n"); 49 50 return err; 50 51 } 51 52 ··· 70 69 if ((err = init_line_levels(chip)) < 0) 71 70 return err; 72 71 73 - DE_INIT(("init_hw done\n")); 72 + dev_dbg(chip->card->dev, "init_hw done\n"); 74 73 return err; 75 74 } 76 75 ··· 118 117 if (chip->asic_loaded) 119 118 return 1; 120 119 121 - DE_INIT(("load_asic\n")); 120 + dev_dbg(chip->card->dev, "load_asic\n"); 122 121 123 122 /* Give the DSP a few milliseconds to settle down */ 124 123 mdelay(10); ··· 152 151 err = write_control_reg(chip, GML_CONVERTER_ENABLE | GML_48KHZ, 153 152 TRUE); 154 153 155 - DE_INIT(("load_asic() done\n")); 154 + dev_dbg(chip->card->dev, "load_asic() done\n"); 156 155 return err; 157 156 } 158 157 ··· 168 167 169 168 /* Only set the clock for internal mode. */ 170 169 if (chip->input_clock != ECHO_CLOCK_INTERNAL) { 171 - DE_ACT(("set_sample_rate: Cannot set sample rate - " 172 - "clock not set to CLK_CLOCKININTERNAL\n")); 170 + dev_warn(chip->card->dev, 171 + "Cannot set sample rate - clock not set to CLK_CLOCKININTERNAL\n"); 173 172 /* Save the rate anyhow */ 174 173 chip->comm_page->sample_rate = cpu_to_le32(rate); 175 174 chip->sample_rate = rate; ··· 242 241 243 242 chip->comm_page->sample_rate = cpu_to_le32(rate); /* ignored by the DSP ? */ 244 243 chip->sample_rate = rate; 245 - DE_ACT(("set_sample_rate: %d clock %d\n", rate, control_reg)); 244 + dev_dbg(chip->card->dev, 245 + "set_sample_rate: %d clock %d\n", rate, control_reg); 246 246 247 247 return write_control_reg(chip, control_reg, FALSE); 248 248 } ··· 262 260 /* Pick the new clock */ 263 261 switch (clock) { 264 262 case ECHO_CLOCK_INTERNAL: 265 - DE_ACT(("Set Layla24 clock to INTERNAL\n")); 263 + dev_dbg(chip->card->dev, "Set Layla24 clock to INTERNAL\n"); 266 264 chip->input_clock = ECHO_CLOCK_INTERNAL; 267 265 return set_sample_rate(chip, chip->sample_rate); 268 266 case ECHO_CLOCK_SPDIF: ··· 271 269 control_reg |= GML_SPDIF_CLOCK; 272 270 /* Layla24 doesn't support 96KHz S/PDIF */ 273 271 control_reg &= ~GML_DOUBLE_SPEED_MODE; 274 - DE_ACT(("Set Layla24 clock to SPDIF\n")); 272 + dev_dbg(chip->card->dev, "Set Layla24 clock to SPDIF\n"); 275 273 break; 276 274 case ECHO_CLOCK_WORD: 277 275 control_reg |= GML_WORD_CLOCK; ··· 279 277 control_reg |= GML_DOUBLE_SPEED_MODE; 280 278 else 281 279 control_reg &= ~GML_DOUBLE_SPEED_MODE; 282 - DE_ACT(("Set Layla24 clock to WORD\n")); 280 + dev_dbg(chip->card->dev, "Set Layla24 clock to WORD\n"); 283 281 break; 284 282 case ECHO_CLOCK_ADAT: 285 283 if (chip->digital_mode != DIGITAL_MODE_ADAT) 286 284 return -EAGAIN; 287 285 control_reg |= GML_ADAT_CLOCK; 288 286 control_reg &= ~GML_DOUBLE_SPEED_MODE; 289 - DE_ACT(("Set Layla24 clock to ADAT\n")); 287 + dev_dbg(chip->card->dev, "Set Layla24 clock to ADAT\n"); 290 288 break; 291 289 default: 292 - DE_ACT(("Input clock 0x%x not supported for Layla24\n", clock)); 290 + dev_err(chip->card->dev, 291 + "Input clock 0x%x not supported for Layla24\n", clock); 293 292 return -EINVAL; 294 293 } 295 294 ··· 356 353 asic = FW_LAYLA24_2A_ASIC; 357 354 break; 358 355 default: 359 - DE_ACT(("Digital mode not supported: %d\n", mode)); 356 + dev_err(chip->card->dev, 357 + "Digital mode not supported: %d\n", mode); 360 358 return -EINVAL; 361 359 } 362 360 ··· 397 393 return err; 398 394 chip->digital_mode = mode; 399 395 400 - DE_ACT(("set_digital_mode to %d\n", mode)); 396 + dev_dbg(chip->card->dev, "set_digital_mode to %d\n", mode); 401 397 return incompatible_clock; 402 398 }
+10 -7
sound/pci/echoaudio/mia_dsp.c
··· 41 41 { 42 42 int err; 43 43 44 - DE_INIT(("init_hw() - Mia\n")); 44 + dev_dbg(chip->card->dev, "init_hw() - Mia\n"); 45 45 if (snd_BUG_ON((subdevice_id & 0xfff0) != MIA)) 46 46 return -ENODEV; 47 47 48 48 if ((err = init_dsp_comm_page(chip))) { 49 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 49 + dev_err(chip->card->dev, 50 + "init_hw - could not initialize DSP comm page\n"); 50 51 return err; 51 52 } 52 53 ··· 67 66 return err; 68 67 chip->bad_board = FALSE; 69 68 70 - DE_INIT(("init_hw done\n")); 69 + dev_dbg(chip->card->dev, "init_hw done\n"); 71 70 return err; 72 71 } 73 72 ··· 127 126 control_reg = MIA_32000; 128 127 break; 129 128 default: 130 - DE_ACT(("set_sample_rate: %d invalid!\n", rate)); 129 + dev_err(chip->card->dev, 130 + "set_sample_rate: %d invalid!\n", rate); 131 131 return -EINVAL; 132 132 } 133 133 ··· 155 153 156 154 static int set_input_clock(struct echoaudio *chip, u16 clock) 157 155 { 158 - DE_ACT(("set_input_clock(%d)\n", clock)); 156 + dev_dbg(chip->card->dev, "set_input_clock(%d)\n", clock); 159 157 if (snd_BUG_ON(clock != ECHO_CLOCK_INTERNAL && 160 158 clock != ECHO_CLOCK_SPDIF)) 161 159 return -EINVAL; ··· 183 181 index = output * num_pipes_out(chip) + pipe; 184 182 chip->comm_page->vmixer[index] = gain; 185 183 186 - DE_ACT(("set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain)); 184 + dev_dbg(chip->card->dev, 185 + "set_vmixer_gain: pipe %d, out %d = %d\n", pipe, output, gain); 187 186 return 0; 188 187 } 189 188 ··· 214 211 215 212 static int set_professional_spdif(struct echoaudio *chip, char prof) 216 213 { 217 - DE_ACT(("set_professional_spdif %d\n", prof)); 214 + dev_dbg(chip->card->dev, "set_professional_spdif %d\n", prof); 218 215 if (prof) 219 216 chip->comm_page->flags |= 220 217 cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
+15 -14
sound/pci/echoaudio/midi.c
··· 36 36 /* Start and stop Midi input */ 37 37 static int enable_midi_input(struct echoaudio *chip, char enable) 38 38 { 39 - DE_MID(("enable_midi_input(%d)\n", enable)); 39 + dev_dbg(chip->card->dev, "enable_midi_input(%d)\n", enable); 40 40 41 41 if (wait_handshake(chip)) 42 42 return -EIO; ··· 74 74 chip->comm_page->midi_out_free_count = 0; 75 75 clear_handshake(chip); 76 76 send_vector(chip, DSP_VC_MIDI_WRITE); 77 - DE_MID(("write_midi: %d\n", bytes)); 77 + dev_dbg(chip->card->dev, "write_midi: %d\n", bytes); 78 78 return bytes; 79 79 } 80 80 ··· 157 157 struct echoaudio *chip = substream->rmidi->private_data; 158 158 159 159 chip->midi_in = substream; 160 - DE_MID(("rawmidi_iopen\n")); 160 + dev_dbg(chip->card->dev, "rawmidi_iopen\n"); 161 161 return 0; 162 162 } 163 163 ··· 183 183 struct echoaudio *chip = substream->rmidi->private_data; 184 184 185 185 chip->midi_in = NULL; 186 - DE_MID(("rawmidi_iclose\n")); 186 + dev_dbg(chip->card->dev, "rawmidi_iclose\n"); 187 187 return 0; 188 188 } 189 189 ··· 196 196 chip->tinuse = 0; 197 197 chip->midi_full = 0; 198 198 chip->midi_out = substream; 199 - DE_MID(("rawmidi_oopen\n")); 199 + dev_dbg(chip->card->dev, "rawmidi_open\n"); 200 200 return 0; 201 201 } 202 202 ··· 209 209 int bytes, sent, time; 210 210 unsigned char buf[MIDI_OUT_BUFFER_SIZE - 1]; 211 211 212 - DE_MID(("snd_echo_midi_output_write\n")); 212 + dev_dbg(chip->card->dev, "snd_echo_midi_output_write\n"); 213 213 /* No interrupts are involved: we have to check at regular intervals 214 214 if the card's output buffer has room for new data. */ 215 215 sent = bytes = 0; ··· 218 218 if (!snd_rawmidi_transmit_empty(chip->midi_out)) { 219 219 bytes = snd_rawmidi_transmit_peek(chip->midi_out, buf, 220 220 MIDI_OUT_BUFFER_SIZE - 1); 221 - DE_MID(("Try to send %d bytes...\n", bytes)); 221 + dev_dbg(chip->card->dev, "Try to send %d bytes...\n", bytes); 222 222 sent = write_midi(chip, buf, bytes); 223 223 if (sent < 0) { 224 224 dev_err(chip->card->dev, ··· 227 227 sent = 9000; 228 228 chip->midi_full = 1; 229 229 } else if (sent > 0) { 230 - DE_MID(("%d bytes sent\n", sent)); 230 + dev_dbg(chip->card->dev, "%d bytes sent\n", sent); 231 231 snd_rawmidi_transmit_ack(chip->midi_out, sent); 232 232 } else { 233 233 /* Buffer is full. DSP's internal buffer is 64 (128 ?) 234 234 bytes long. Let's wait until half of them are sent */ 235 - DE_MID(("Full\n")); 235 + dev_dbg(chip->card->dev, "Full\n"); 236 236 sent = 32; 237 237 chip->midi_full = 1; 238 238 } ··· 244 244 sent */ 245 245 time = (sent << 3) / 25 + 1; /* 8/25=0.32ms to send a byte */ 246 246 mod_timer(&chip->timer, jiffies + (time * HZ + 999) / 1000); 247 - DE_MID(("Timer armed(%d)\n", ((time * HZ + 999) / 1000))); 247 + dev_dbg(chip->card->dev, 248 + "Timer armed(%d)\n", ((time * HZ + 999) / 1000)); 248 249 } 249 250 spin_unlock_irqrestore(&chip->lock, flags); 250 251 } ··· 257 256 { 258 257 struct echoaudio *chip = substream->rmidi->private_data; 259 258 260 - DE_MID(("snd_echo_midi_output_trigger(%d)\n", up)); 259 + dev_dbg(chip->card->dev, "snd_echo_midi_output_trigger(%d)\n", up); 261 260 spin_lock_irq(&chip->lock); 262 261 if (up) { 263 262 if (!chip->tinuse) { ··· 271 270 chip->tinuse = 0; 272 271 spin_unlock_irq(&chip->lock); 273 272 del_timer_sync(&chip->timer); 274 - DE_MID(("Timer removed\n")); 273 + dev_dbg(chip->card->dev, "Timer removed\n"); 275 274 return; 276 275 } 277 276 } ··· 288 287 struct echoaudio *chip = substream->rmidi->private_data; 289 288 290 289 chip->midi_out = NULL; 291 - DE_MID(("rawmidi_oclose\n")); 290 + dev_dbg(chip->card->dev, "rawmidi_oclose\n"); 292 291 return 0; 293 292 } 294 293 ··· 328 327 329 328 chip->rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | 330 329 SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX; 331 - DE_INIT(("MIDI ok\n")); 330 + dev_dbg(chip->card->dev, "MIDI ok\n"); 332 331 return 0; 333 332 }
+20 -15
sound/pci/echoaudio/mona_dsp.c
··· 41 41 { 42 42 int err; 43 43 44 - DE_INIT(("init_hw() - Mona\n")); 44 + dev_dbg(chip->card->dev, "init_hw() - Mona\n"); 45 45 if (snd_BUG_ON((subdevice_id & 0xfff0) != MONA)) 46 46 return -ENODEV; 47 47 48 48 if ((err = init_dsp_comm_page(chip))) { 49 - DE_INIT(("init_hw - could not initialize DSP comm page\n")); 49 + dev_err(chip->card->dev, 50 + "init_hw - could not initialize DSP comm page\n"); 50 51 return err; 51 52 } 52 53 ··· 72 71 return err; 73 72 chip->bad_board = FALSE; 74 73 75 - DE_INIT(("init_hw done\n")); 74 + dev_dbg(chip->card->dev, "init_hw done\n"); 76 75 return err; 77 76 } 78 77 ··· 203 202 204 203 /* Only set the clock for internal mode. */ 205 204 if (chip->input_clock != ECHO_CLOCK_INTERNAL) { 206 - DE_ACT(("set_sample_rate: Cannot set sample rate - " 207 - "clock not set to CLK_CLOCKININTERNAL\n")); 205 + dev_dbg(chip->card->dev, 206 + "Cannot set sample rate - clock not set to CLK_CLOCKININTERNAL\n"); 208 207 /* Save the rate anyhow */ 209 208 chip->comm_page->sample_rate = cpu_to_le32(rate); 210 209 chip->sample_rate = rate; ··· 280 279 clock = GML_8KHZ; 281 280 break; 282 281 default: 283 - DE_ACT(("set_sample_rate: %d invalid!\n", rate)); 282 + dev_err(chip->card->dev, 283 + "set_sample_rate: %d invalid!\n", rate); 284 284 return -EINVAL; 285 285 } 286 286 ··· 289 287 290 288 chip->comm_page->sample_rate = cpu_to_le32(rate); /* ignored by the DSP */ 291 289 chip->sample_rate = rate; 292 - DE_ACT(("set_sample_rate: %d clock %d\n", rate, clock)); 290 + dev_dbg(chip->card->dev, 291 + "set_sample_rate: %d clock %d\n", rate, clock); 293 292 294 293 return write_control_reg(chip, control_reg, force_write); 295 294 } ··· 302 299 u32 control_reg, clocks_from_dsp; 303 300 int err; 304 301 305 - DE_ACT(("set_input_clock:\n")); 302 + dev_dbg(chip->card->dev, "set_input_clock:\n"); 306 303 307 304 /* Prevent two simultaneous calls to switch_asic() */ 308 305 if (atomic_read(&chip->opencount)) ··· 315 312 316 313 switch (clock) { 317 314 case ECHO_CLOCK_INTERNAL: 318 - DE_ACT(("Set Mona clock to INTERNAL\n")); 315 + dev_dbg(chip->card->dev, "Set Mona clock to INTERNAL\n"); 319 316 chip->input_clock = ECHO_CLOCK_INTERNAL; 320 317 return set_sample_rate(chip, chip->sample_rate); 321 318 case ECHO_CLOCK_SPDIF: ··· 327 324 spin_lock_irq(&chip->lock); 328 325 if (err < 0) 329 326 return err; 330 - DE_ACT(("Set Mona clock to SPDIF\n")); 327 + dev_dbg(chip->card->dev, "Set Mona clock to SPDIF\n"); 331 328 control_reg |= GML_SPDIF_CLOCK; 332 329 if (clocks_from_dsp & GML_CLOCK_DETECT_BIT_SPDIF96) 333 330 control_reg |= GML_DOUBLE_SPEED_MODE; ··· 335 332 control_reg &= ~GML_DOUBLE_SPEED_MODE; 336 333 break; 337 334 case ECHO_CLOCK_WORD: 338 - DE_ACT(("Set Mona clock to WORD\n")); 335 + dev_dbg(chip->card->dev, "Set Mona clock to WORD\n"); 339 336 spin_unlock_irq(&chip->lock); 340 337 err = switch_asic(chip, clocks_from_dsp & 341 338 GML_CLOCK_DETECT_BIT_WORD96); ··· 349 346 control_reg &= ~GML_DOUBLE_SPEED_MODE; 350 347 break; 351 348 case ECHO_CLOCK_ADAT: 352 - DE_ACT(("Set Mona clock to ADAT\n")); 349 + dev_dbg(chip->card->dev, "Set Mona clock to ADAT\n"); 353 350 if (chip->digital_mode != DIGITAL_MODE_ADAT) 354 351 return -EAGAIN; 355 352 control_reg |= GML_ADAT_CLOCK; 356 353 control_reg &= ~GML_DOUBLE_SPEED_MODE; 357 354 break; 358 355 default: 359 - DE_ACT(("Input clock 0x%x not supported for Mona\n", clock)); 356 + dev_err(chip->card->dev, 357 + "Input clock 0x%x not supported for Mona\n", clock); 360 358 return -EINVAL; 361 359 } 362 360 ··· 385 381 incompatible_clock = TRUE; 386 382 break; 387 383 default: 388 - DE_ACT(("Digital mode not supported: %d\n", mode)); 384 + dev_err(chip->card->dev, 385 + "Digital mode not supported: %d\n", mode); 389 386 return -EINVAL; 390 387 } 391 388 ··· 427 422 return err; 428 423 chip->digital_mode = mode; 429 424 430 - DE_ACT(("set_digital_mode to %d\n", mode)); 425 + dev_dbg(chip->card->dev, "set_digital_mode to %d\n", mode); 431 426 return incompatible_clock; 432 427 }