snd_mtpav_send_byte(mtp_card, 0xf5);
                snd_mtpav_send_byte(mtp_card, portp->hwport);
-               //snd_printk("new outport: 0x%x\n", (unsigned int) portp->hwport);
-
+               /*
+               snd_printk(KERN_DEBUG "new outport: 0x%x\n",
+                          (unsigned int) portp->hwport);
+               */
                if (!(outbyte & 0x80) && portp->running_status)
                        snd_mtpav_send_byte(mtp_card, portp->running_status);
        }
 
        u8 sbyt = snd_mtpav_getreg(mcrd, SREG);
 
-       //printk("snd_mtpav_read_bytes() sbyt: 0x%x\n", sbyt);
+       /* printk(KERN_DEBUG "snd_mtpav_read_bytes() sbyt: 0x%x\n", sbyt); */
 
        if (!(sbyt & SIGS_BYTE))
                return;
 static int __devinit snd_mtpav_get_ISA(struct mtpav * mcard)
 {
        if ((mcard->res_port = request_region(port, 3, "MotuMTPAV MIDI")) == NULL) {
-               snd_printk("MTVAP port 0x%lx is busy\n", port);
+               snd_printk(KERN_ERR "MTVAP port 0x%lx is busy\n", port);
                return -EBUSY;
        }
        mcard->port = port;
        if (request_irq(irq, snd_mtpav_irqh, IRQF_DISABLED, "MOTU MTPAV", mcard)) {
-               snd_printk("MTVAP IRQ %d busy\n", irq);
+               snd_printk(KERN_ERR "MTVAP IRQ %d busy\n", irq);
                return -EBUSY;
        }
        mcard->irq = irq;
 
                goto __err;
        }
 
-       snd_printk("ESI Miditerminal 4140 on 0x%lx\n", p->base);
+       snd_printk(KERN_INFO "ESI Miditerminal 4140 on 0x%lx\n", p->base);
        return 0;
 
 __err:
 
        opl3 = hw->private_data;
        status = inb(opl3->l_port);
 #if 0
-       snd_printk("AdLib IRQ status = 0x%x\n", status);
+       snd_printk(KERN_DEBUG "AdLib IRQ status = 0x%x\n", status);
 #endif
        if (!(status & 0x80))
                return;
 
        int i;
        char *str = "x.24";
 
-       printk("time %.5i: %s [%.2i]: ", opl3->use_time, s, voice);
+       printk(KERN_DEBUG "time %.5i: %s [%.2i]: ", opl3->use_time, s, voice);
        for (i = 0; i < opl3->max_voices; i++)
                printk("%c", *(str + opl3->voices[i].state + 1));
        printk("\n");
        for (i = 0; i < END; i++) {
                if (best[i].voice >= 0) {
 #ifdef DEBUG_ALLOC
-                       printk("%s %iop allocation on voice %i\n",
+                       printk(KERN_DEBUG "%s %iop allocation on voice %i\n",
                               alloc_type[i], instr_4op ? 4 : 2,
                               best[i].voice);
 #endif
        opl3 = p;
 
 #ifdef DEBUG_MIDI
-       snd_printk("Note on, ch %i, inst %i, note %i, vel %i\n",
+       snd_printk(KERN_DEBUG "Note on, ch %i, inst %i, note %i, vel %i\n",
                   chan->number, chan->midi_program, note, vel);
 #endif
 
                return;
        }
 #ifdef DEBUG_MIDI
-       snd_printk("  --> OPL%i instrument: %s\n",
+       snd_printk(KERN_DEBUG "  --> OPL%i instrument: %s\n",
                   instr_4op ? 3 : 2, patch->name);
 #endif
        /* in SYNTH mode, application takes care of voices */
        }
 
 #ifdef DEBUG_MIDI
-       snd_printk("  --> setting OPL3 connection: 0x%x\n",
+       snd_printk(KERN_DEBUG "  --> setting OPL3 connection: 0x%x\n",
                   opl3->connection_reg);
 #endif
        /*
        /* Program the FM voice characteristics */
        for (i = 0; i < (instr_4op ? 4 : 2); i++) {
 #ifdef DEBUG_MIDI
-               snd_printk("  --> programming operator %i\n", i);
+               snd_printk(KERN_DEBUG "  --> programming operator %i\n", i);
 #endif
                op_offset = snd_opl3_regmap[voice_offset][i];
 
        blocknum |= OPL3_KEYON_BIT;
 
 #ifdef DEBUG_MIDI
-       snd_printk("  --> trigger voice %i\n", voice);
+       snd_printk(KERN_DEBUG "  --> trigger voice %i\n", voice);
 #endif
        /* Set OPL3 KEYON_BLOCK register of requested voice */ 
        opl3_reg = reg_side | (OPL3_REG_KEYON_BLOCK + voice_offset);
                        prg = extra_prg - 1;
                }
 #ifdef DEBUG_MIDI
-               snd_printk(" *** allocating extra program\n");
+               snd_printk(KERN_DEBUG " *** allocating extra program\n");
 #endif
                goto __extra_prg;
        }
 
        /* kill voice */
 #ifdef DEBUG_MIDI
-       snd_printk("  --> kill voice %i\n", voice);
+       snd_printk(KERN_DEBUG "  --> kill voice %i\n", voice);
 #endif
        opl3_reg = reg_side | (OPL3_REG_KEYON_BLOCK + voice_offset);
        /* clear Key ON bit */
        opl3 = p;
 
 #ifdef DEBUG_MIDI
-       snd_printk("Note off, ch %i, inst %i, note %i\n",
+       snd_printk(KERN_DEBUG "Note off, ch %i, inst %i, note %i\n",
                   chan->number, chan->midi_program, note);
 #endif
 
 
        opl3 = p;
 #ifdef DEBUG_MIDI
-       snd_printk("Key pressure, ch#: %i, inst#: %i\n",
+       snd_printk(KERN_DEBUG "Key pressure, ch#: %i, inst#: %i\n",
                   chan->number, chan->midi_program);
 #endif
 }
 
        opl3 = p;
 #ifdef DEBUG_MIDI
-       snd_printk("Terminate note, ch#: %i, inst#: %i\n",
+       snd_printk(KERN_DEBUG "Terminate note, ch#: %i, inst#: %i\n",
                   chan->number, chan->midi_program);
 #endif
 }
 
        opl3 = p;
 #ifdef DEBUG_MIDI
-       snd_printk("Controller, TYPE = %i, ch#: %i, inst#: %i\n",
+       snd_printk(KERN_DEBUG "Controller, TYPE = %i, ch#: %i, inst#: %i\n",
                   type, chan->number, chan->midi_program);
 #endif
 
 
        opl3 = p;
 #ifdef DEBUG_MIDI
-       snd_printk("NRPN, ch#: %i, inst#: %i\n",
+       snd_printk(KERN_DEBUG "NRPN, ch#: %i, inst#: %i\n",
                   chan->number, chan->midi_program);
 #endif
 }
 
        opl3 = p;
 #ifdef DEBUG_MIDI
-       snd_printk("SYSEX\n");
+       snd_printk(KERN_DEBUG "SYSEX\n");
 #endif
 }
 
                return -EINVAL;
 
        if (count < (int)sizeof(sbi)) {
-               snd_printk("FM Error: Patch record too short\n");
+               snd_printk(KERN_ERR "FM Error: Patch record too short\n");
                return -EINVAL;
        }
        if (copy_from_user(&sbi, buf, sizeof(sbi)))
                return -EFAULT;
 
        if (sbi.channel < 0 || sbi.channel >= SBFM_MAXINSTR) {
-               snd_printk("FM Error: Invalid instrument number %d\n",
+               snd_printk(KERN_ERR "FM Error: Invalid instrument number %d\n",
                           sbi.channel);
                return -EINVAL;
        }
        opl3 = arg->private_data;
        switch (cmd) {
                case SNDCTL_FM_LOAD_INSTR:
-                       snd_printk("OPL3: Obsolete ioctl(SNDCTL_FM_LOAD_INSTR) used. Fix the program.\n");
+                       snd_printk(KERN_ERR "OPL3: "
+                                  "Obsolete ioctl(SNDCTL_FM_LOAD_INSTR) used. "
+                                  "Fix the program.\n");
                        return -EINVAL;
 
                case SNDCTL_SYNTH_MEMAVL:
 
 
 #ifdef CONFIG_SND_DEBUG
        default:
-               snd_printk("unknown IOCTL: 0x%x\n", cmd);
+               snd_printk(KERN_WARNING "unknown IOCTL: 0x%x\n", cmd);
 #endif
        }
        return -ENOTTY;
 
        else
                min_div = MAX_DIV;
 #if PCSP_DEBUG
-       printk("PCSP: lpj=%li, min_div=%i, res=%li\n",
+       printk(KERN_DEBUG "PCSP: lpj=%li, min_div=%i, res=%li\n",
               loops_per_jiffy, min_div, tp.tv_nsec);
 #endif
 
 
                        snd_rawmidi_receive(uart->midi_input[substream], &c, 1);
 
                if (status & UART_LSR_OE)
-                       snd_printk("%s: Overrun on device at 0x%lx\n",
+                       snd_printk(KERN_WARNING
+                                  "%s: Overrun on device at 0x%lx\n",
                               uart->rmidi->name, uart->base);
        }
 
                }
        } else {
                if (!snd_uart16550_write_buffer(uart, midi_byte)) {
-                       snd_printk("%s: Buffer overrun on device at 0x%lx\n",
+                       snd_printk(KERN_WARNING
+                                  "%s: Buffer overrun on device at 0x%lx\n",
                                   uart->rmidi->name, uart->base);
                        return 0;
                }
        if (irq >= 0 && irq != SNDRV_AUTO_IRQ) {
                if (request_irq(irq, snd_uart16550_interrupt,
                                IRQF_DISABLED, "Serial MIDI", uart)) {
-                       snd_printk("irq %d busy. Using Polling.\n", irq);
+                       snd_printk(KERN_WARNING
+                                  "irq %d busy. Using Polling.\n", irq);
                } else {
                        uart->irq = irq;
                }
        case SNDRV_SERIAL_GENERIC:
                break;
        default:
-               snd_printk("Adaptor type is out of range 0-%d (%d)\n",
+               snd_printk(KERN_ERR
+                          "Adaptor type is out of range 0-%d (%d)\n",
                           SNDRV_SERIAL_MAX_ADAPTOR, adaptor[dev]);
                return -ENODEV;
        }
 
        if (outs[dev] < 1 || outs[dev] > SNDRV_SERIAL_MAX_OUTS) {
-               snd_printk("Count of outputs is out of range 1-%d (%d)\n",
+               snd_printk(KERN_ERR
+                          "Count of outputs is out of range 1-%d (%d)\n",
                           SNDRV_SERIAL_MAX_OUTS, outs[dev]);
                return -ENODEV;
        }
 
        if (ins[dev] < 1 || ins[dev] > SNDRV_SERIAL_MAX_INS) {
-               snd_printk("Count of inputs is out of range 1-%d (%d)\n",
+               snd_printk(KERN_ERR
+                          "Count of inputs is out of range 1-%d (%d)\n",
                           SNDRV_SERIAL_MAX_INS, ins[dev]);
                return -ENODEV;
        }
 
        vmidi->card = card;
 
        if (midi_devs[dev] > MAX_MIDI_DEVICES) {
-               snd_printk("too much midi devices for virmidi %d: force to use %d\n", dev, MAX_MIDI_DEVICES);
+               snd_printk(KERN_WARNING
+                          "too much midi devices for virmidi %d: "
+                          "force to use %d\n", dev, MAX_MIDI_DEVICES);
                midi_devs[dev] = MAX_MIDI_DEVICES;
        }
        for (idx = 0; idx < midi_devs[dev]; idx++) {
 
                image = dsp->data + i;
                /* Wait DSP ready for a new read */
                if ((err = vx_wait_isr_bit(chip, ISR_TX_EMPTY)) < 0) {
-                       printk("dsp loading error at position %d\n", i);
+                       printk(KERN_ERR
+                              "dsp loading error at position %d\n", i);
                        return err;
                }
                cptr = image;