chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->dsp_code_to_load = FW_DARLA20_DSP;
        chip->spdif_status = GD_SPDIF_STATUS_UNDEF;
        chip->clock_state = GD_CLOCK_UNDEF;
        /* Since this card has no ASIC, mark it as loaded so everything
           works OK */
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL;
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->dsp_code_to_load = FW_DARLA24_DSP;
        /* Since this card has no ASIC, mark it as loaded so everything
           works OK */
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL |
                ECHO_CLOCK_BIT_ESYNC;
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
                cpu_to_le32((E3G_MAGIC_NUMBER / 48000) - 2);
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
-       chip->has_midi = TRUE;
+       chip->bad_board = true;
+       chip->has_midi = true;
        chip->dsp_code_to_load = FW_ECHO3G_DSP;
 
        /* Load the DSP code and the ASIC on the PCI card and get
                chip->px_analog_in = chip->bx_analog_in = 14;
                chip->px_digital_in = chip->bx_digital_in = 16;
                chip->px_num = chip->bx_num = 24;
-               chip->has_phantom_power = TRUE;
-               chip->hasnt_input_nominal_level = TRUE;
+               chip->has_phantom_power = true;
+               chip->hasnt_input_nominal_level = true;
        } else if (err == E3G_LAYLA3G_BOX_TYPE) {
                chip->input_clock_types =       ECHO_CLOCK_BIT_INTERNAL |
                                                ECHO_CLOCK_BIT_SPDIF |
 static int set_mixer_defaults(struct echoaudio *chip)
 {
        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
-       chip->professional_spdif = FALSE;
-       chip->non_audio_spdif = FALSE;
-       chip->bad_board = FALSE;
-       chip->phantom_power = FALSE;
+       chip->professional_spdif = false;
+       chip->non_audio_spdif = false;
+       chip->bad_board = false;
+       chip->phantom_power = false;
        return init_line_levels(chip);
 }
 
 
 
 #ifdef ECHOCARD_HAS_MIDI
        if (chip->midi_input_enabled)
-               enable_midi_input(chip, TRUE);
+               enable_midi_input(chip, true);
        if (chip->midi_out)
                snd_echo_midi_output_trigger(chip->midi_out, 1);
 #endif
 
 #define _ECHOAUDIO_H_
 
 
-#define TRUE 1
-#define FALSE 0
-
 #include "echoaudio_dsp.h"
 
 
                                         */
        u8 output_clock;                /* Layla20 only */
        char meters_enabled;            /* VU-meters status */
-       char asic_loaded;               /* Set TRUE when ASIC loaded */
-       char bad_board;                 /* Set TRUE if DSP won't load */
+       char asic_loaded;               /* Set true when ASIC loaded */
+       char bad_board;                 /* Set true if DSP won't load */
        char professional_spdif;        /* 0 = consumer; 1 = professional */
        char non_audio_spdif;           /* 3G - only */
        char digital_in_automute;       /* Gina24, Layla24, Mona - only */
 
                return -EIO;
 
        chip->comm_page->ext_box_status = cpu_to_le32(E3G_ASIC_NOT_LOADED);
-       chip->asic_loaded = FALSE;
+       chip->asic_loaded = false;
        clear_handshake(chip);
        send_vector(chip, DSP_VC_TEST_ASIC);
 
        if (box_status == E3G_ASIC_NOT_LOADED)
                return -ENODEV;
 
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        return box_status & E3G_BOX_TYPE_MASK;
 }
 
         * 48 kHz, internal clock, S/PDIF RCA mode */
        if (box_type >= 0) {
                err = write_control_reg(chip, E3G_48KHZ,
-                                       E3G_FREQ_REG_DEFAULT, TRUE);
+                                       E3G_FREQ_REG_DEFAULT, true);
                if (err < 0)
                        return err;
        }
        int err, incompatible_clock;
 
        /* Set clock to "internal" if it's not compatible with the new mode */
-       incompatible_clock = FALSE;
+       incompatible_clock = false;
        switch (mode) {
        case DIGITAL_MODE_SPDIF_OPTICAL:
        case DIGITAL_MODE_SPDIF_RCA:
                if (chip->input_clock == ECHO_CLOCK_ADAT)
-                       incompatible_clock = TRUE;
+                       incompatible_clock = true;
                break;
        case DIGITAL_MODE_ADAT:
                if (chip->input_clock == ECHO_CLOCK_SPDIF)
-                       incompatible_clock = TRUE;
+                       incompatible_clock = true;
                break;
        default:
                dev_err(chip->card->dev,
 
                cond_resched();
        }
 
-       chip->bad_board = TRUE;         /* Set TRUE until DSP re-loaded */
-       dev_dbg(chip->card->dev, "write_dsp: Set bad_board to TRUE\n");
+       chip->bad_board = true;         /* Set true until DSP re-loaded */
+       dev_dbg(chip->card->dev, "write_dsp: Set bad_board to true\n");
        return -EIO;
 }
 
                cond_resched();
        }
 
-       chip->bad_board = TRUE;         /* Set TRUE until DSP re-loaded */
-       dev_err(chip->card->dev, "read_dsp: Set bad_board to TRUE\n");
+       chip->bad_board = true;         /* Set true until DSP re-loaded */
+       dev_err(chip->card->dev, "read_dsp: Set bad_board to true\n");
        return -EIO;
 }
 
 /* This card has no ASIC, just return ok */
 static inline int check_asic_status(struct echoaudio *chip)
 {
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        return 0;
 }
 
                dev_warn(chip->card->dev, "DSP is already loaded!\n");
                return 0;
        }
-       chip->bad_board = TRUE;         /* Set TRUE until DSP loaded */
+       chip->bad_board = true;         /* Set true until DSP loaded */
        chip->dsp_code = NULL;          /* Current DSP code not loaded */
-       chip->asic_loaded = FALSE;      /* Loading the DSP code will reset the ASIC */
+       chip->asic_loaded = false;      /* Loading the DSP code will reset the ASIC */
 
-       dev_dbg(chip->card->dev, "load_dsp: Set bad_board to TRUE\n");
+       dev_dbg(chip->card->dev, "load_dsp: Set bad_board to true\n");
 
        /* If this board requires a resident loader, install it. */
 #ifdef DSP_56361
                        }
 
                        chip->dsp_code = code;          /* Show which DSP code loaded */
-                       chip->bad_board = FALSE;        /* DSP OK */
+                       chip->bad_board = false;        /* DSP OK */
                        return 0;
                }
                udelay(100);
        /* Stops all active pipes (just to be sure) */
        stop_transport(chip, chip->active_mask);
 
-       set_meters_on(chip, FALSE);
+       set_meters_on(chip, false);
 
 #ifdef ECHOCARD_HAS_MIDI
-       enable_midi_input(chip, FALSE);
+       enable_midi_input(chip, false);
 #endif
 
        /* Go to sleep */
 
        /* Init all the basic stuff */
        chip->card_name = ECHOCARD_NAME;
-       chip->bad_board = TRUE; /* Set TRUE until DSP loaded */
+       chip->bad_board = true; /* Set true until DSP loaded */
        chip->dsp_code = NULL;  /* Current DSP code not loaded */
-       chip->asic_loaded = FALSE;
+       chip->asic_loaded = false;
        memset(chip->comm_page, 0, sizeof(struct comm_page));
 
        /* Init the comm page */
 
        if (read_dsp(chip, &asic_status) < 0) {
                dev_err(chip->card->dev,
                        "check_asic_status: failed on read_dsp\n");
-               chip->asic_loaded = FALSE;
+               chip->asic_loaded = false;
                return -EIO;
        }
 
                }
        }
 
-       if ((err = write_control_reg(chip, control_reg, FALSE)))
+       if ((err = write_control_reg(chip, control_reg, false)))
                return err;
        chip->professional_spdif = prof;
        dev_dbg(chip->card->dev, "set_professional_spdif to %s\n",
 
 #define ECHOCARD_HAS_INPUT_GAIN
 #define ECHOCARD_HAS_DIGITAL_IO
 #define ECHOCARD_HAS_EXTERNAL_CLOCK
-#define ECHOCARD_HAS_ADAT      FALSE
+#define ECHOCARD_HAS_ADAT      false
 
 /* Pipe indexes */
 #define PX_ANALOG_OUT  0       /* 8 */
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->dsp_code_to_load = FW_GINA20_DSP;
        chip->spdif_status = GD_SPDIF_STATUS_UNDEF;
        chip->clock_state = GD_CLOCK_UNDEF;
        /* Since this card has no ASIC, mark it as loaded so everything
           works OK */
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL |
                ECHO_CLOCK_BIT_SPDIF;
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
 static int set_mixer_defaults(struct echoaudio *chip)
 {
-       chip->professional_spdif = FALSE;
+       chip->professional_spdif = false;
        return init_line_levels(chip);
 }
 
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->input_clock_types =
                ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
                ECHO_CLOCK_BIT_ESYNC | ECHO_CLOCK_BIT_ESYNC96 |
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 static int set_mixer_defaults(struct echoaudio *chip)
 {
        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
-       chip->professional_spdif = FALSE;
-       chip->digital_in_automute = TRUE;
+       chip->professional_spdif = false;
+       chip->digital_in_automute = true;
        return init_line_levels(chip);
 }
 
           48 kHz, internal clock, S/PDIF RCA mode */
        if (!err) {
                control_reg = GML_CONVERTER_ENABLE | GML_48KHZ;
-               err = write_control_reg(chip, control_reg, TRUE);
+               err = write_control_reg(chip, control_reg, true);
        }
        return err;
 }
        chip->sample_rate = rate;
        dev_dbg(chip->card->dev, "set_sample_rate: %d clock %d\n", rate, clock);
 
-       return write_control_reg(chip, control_reg, FALSE);
+       return write_control_reg(chip, control_reg, false);
 }
 
 
        }
 
        chip->input_clock = clock;
-       return write_control_reg(chip, control_reg, TRUE);
+       return write_control_reg(chip, control_reg, true);
 }
 
 
        int err, incompatible_clock;
 
        /* Set clock to "internal" if it's not compatible with the new mode */
-       incompatible_clock = FALSE;
+       incompatible_clock = false;
        switch (mode) {
        case DIGITAL_MODE_SPDIF_OPTICAL:
        case DIGITAL_MODE_SPDIF_CDROM:
        case DIGITAL_MODE_SPDIF_RCA:
                if (chip->input_clock == ECHO_CLOCK_ADAT)
-                       incompatible_clock = TRUE;
+                       incompatible_clock = true;
                break;
        case DIGITAL_MODE_ADAT:
                if (chip->input_clock == ECHO_CLOCK_SPDIF)
-                       incompatible_clock = TRUE;
+                       incompatible_clock = true;
                break;
        default:
                dev_err(chip->card->dev,
                break;
        }
 
-       err = write_control_reg(chip, control_reg, TRUE);
+       err = write_control_reg(chip, control_reg, true);
        spin_unlock_irq(&chip->lock);
        if (err < 0)
                return err;
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->dsp_code_to_load = FW_INDIGO_DSP;
        /* Since this card has no ASIC, mark it as loaded so everything
           works OK */
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL;
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->dsp_code_to_load = FW_INDIGO_DJ_DSP;
        /* Since this card has no ASIC, mark it as loaded so everything
           works OK */
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL;
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->dsp_code_to_load = FW_INDIGO_DJX_DSP;
        /* Since this card has no ASIC, mark it as loaded so everything
           works OK */
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL;
 
        err = load_firmware(chip);
        if (err < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->dsp_code_to_load = FW_INDIGO_IO_DSP;
        /* Since this card has no ASIC, mark it as loaded so everything
           works OK */
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL;
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->dsp_code_to_load = FW_INDIGO_IOX_DSP;
        /* Since this card has no ASIC, mark it as loaded so everything
           works OK */
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL;
 
        err = load_firmware(chip);
        if (err < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
 #define ECHOCARD_HAS_SUPER_INTERLEAVE
 #define ECHOCARD_HAS_DIGITAL_IO
 #define ECHOCARD_HAS_EXTERNAL_CLOCK
-#define ECHOCARD_HAS_ADAT      FALSE
+#define ECHOCARD_HAS_ADAT      false
 #define ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH
 #define ECHOCARD_HAS_MIDI
 
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
-       chip->has_midi = TRUE;
+       chip->bad_board = true;
+       chip->has_midi = true;
        chip->dsp_code_to_load = FW_LAYLA20_DSP;
        chip->input_clock_types =
                ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
 static int set_mixer_defaults(struct echoaudio *chip)
 {
-       chip->professional_spdif = FALSE;
+       chip->professional_spdif = false;
        return init_line_levels(chip);
 }
 
        u32 asic_status;
        int goodcnt, i;
 
-       chip->asic_loaded = FALSE;
+       chip->asic_loaded = false;
        for (i = goodcnt = 0; i < 5; i++) {
                send_vector(chip, DSP_VC_TEST_ASIC);
 
 
                if (asic_status == ASIC_ALREADY_LOADED) {
                        if (++goodcnt == 3) {
-                               chip->asic_loaded = TRUE;
+                               chip->asic_loaded = true;
                                return 0;
                        }
                }
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
-       chip->has_midi = TRUE;
+       chip->bad_board = true;
+       chip->has_midi = true;
        chip->dsp_code_to_load = FW_LAYLA24_DSP;
        chip->input_clock_types =
                ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        if ((err = init_line_levels(chip)) < 0)
                return err;
 static int set_mixer_defaults(struct echoaudio *chip)
 {
        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
-       chip->professional_spdif = FALSE;
-       chip->digital_in_automute = TRUE;
+       chip->professional_spdif = false;
+       chip->digital_in_automute = true;
        return init_line_levels(chip);
 }
 
        err = load_asic_generic(chip, DSP_FNC_LOAD_LAYLA24_EXTERNAL_ASIC,
                                FW_LAYLA24_2S_ASIC);
        if (err < 0)
-               return FALSE;
+               return false;
 
        /* Now give the external ASIC a little time to set up */
        mdelay(10);
           48 kHz, internal clock, S/PDIF RCA mode */
        if (!err)
                err = write_control_reg(chip, GML_CONVERTER_ENABLE | GML_48KHZ,
-                                       TRUE);
+                                       true);
        
        return err;
 }
        dev_dbg(chip->card->dev,
                "set_sample_rate: %d clock %d\n", rate, control_reg);
 
-       return write_control_reg(chip, control_reg, FALSE);
+       return write_control_reg(chip, control_reg, false);
 }
 
 
        }
 
        chip->input_clock = clock;
-       return write_control_reg(chip, control_reg, TRUE);
+       return write_control_reg(chip, control_reg, true);
 }
 
 
        short asic;
 
        /* Set clock to "internal" if it's not compatible with the new mode */
-       incompatible_clock = FALSE;
+       incompatible_clock = false;
        switch (mode) {
        case DIGITAL_MODE_SPDIF_OPTICAL:
        case DIGITAL_MODE_SPDIF_RCA:
                if (chip->input_clock == ECHO_CLOCK_ADAT)
-                       incompatible_clock = TRUE;
+                       incompatible_clock = true;
                asic = FW_LAYLA24_2S_ASIC;
                break;
        case DIGITAL_MODE_ADAT:
                if (chip->input_clock == ECHO_CLOCK_SPDIF)
-                       incompatible_clock = TRUE;
+                       incompatible_clock = true;
                asic = FW_LAYLA24_2A_ASIC;
                break;
        default:
                break;
        }
 
-       err = write_control_reg(chip, control_reg, TRUE);
+       err = write_control_reg(chip, control_reg, true);
        spin_unlock_irq(&chip->lock);
        if (err < 0)
                return err;
 
 #define ECHOCARD_HAS_VMIXER
 #define ECHOCARD_HAS_DIGITAL_IO
 #define ECHOCARD_HAS_EXTERNAL_CLOCK
-#define ECHOCARD_HAS_ADAT      FALSE
+#define ECHOCARD_HAS_ADAT      false
 #define ECHOCARD_HAS_STEREO_BIG_ENDIAN32
 #define ECHOCARD_HAS_MIDI
 #define ECHOCARD_HAS_LINE_OUT_GAIN
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->dsp_code_to_load = FW_MIA_DSP;
        /* Since this card has no ASIC, mark it as loaded so everything
           works OK */
-       chip->asic_loaded = TRUE;
+       chip->asic_loaded = true;
        if ((subdevice_id & 0x0000f) == MIA_MIDI_REV)
-               chip->has_midi = TRUE;
+               chip->has_midi = true;
        chip->input_clock_types = ECHO_CLOCK_BIT_INTERNAL |
                ECHO_CLOCK_BIT_SPDIF;
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 
 
        chip->device_id = device_id;
        chip->subdevice_id = subdevice_id;
-       chip->bad_board = TRUE;
+       chip->bad_board = true;
        chip->input_clock_types =
                ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
                ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_ADAT;
 
        if ((err = load_firmware(chip)) < 0)
                return err;
-       chip->bad_board = FALSE;
+       chip->bad_board = false;
 
        return err;
 }
 static int set_mixer_defaults(struct echoaudio *chip)
 {
        chip->digital_mode = DIGITAL_MODE_SPDIF_RCA;
-       chip->professional_spdif = FALSE;
-       chip->digital_in_automute = TRUE;
+       chip->professional_spdif = false;
+       chip->digital_in_automute = true;
        return init_line_levels(chip);
 }
 
           48 kHz, internal clock, S/PDIF RCA mode */
        if (!err) {
                control_reg = GML_CONVERTER_ENABLE | GML_48KHZ;
-               err = write_control_reg(chip, control_reg, TRUE);
+               err = write_control_reg(chip, control_reg, true);
        }
 
        return err;
        }
 
        chip->input_clock = clock;
-       return write_control_reg(chip, control_reg, TRUE);
+       return write_control_reg(chip, control_reg, true);
 }
 
 
        int err, incompatible_clock;
 
        /* Set clock to "internal" if it's not compatible with the new mode */
-       incompatible_clock = FALSE;
+       incompatible_clock = false;
        switch (mode) {
        case DIGITAL_MODE_SPDIF_OPTICAL:
        case DIGITAL_MODE_SPDIF_RCA:
                if (chip->input_clock == ECHO_CLOCK_ADAT)
-                       incompatible_clock = TRUE;
+                       incompatible_clock = true;
                break;
        case DIGITAL_MODE_ADAT:
                if (chip->input_clock == ECHO_CLOCK_SPDIF)
-                       incompatible_clock = TRUE;
+                       incompatible_clock = true;
                break;
        default:
                dev_err(chip->card->dev,
                break;
        }
 
-       err = write_control_reg(chip, control_reg, FALSE);
+       err = write_control_reg(chip, control_reg, false);
        spin_unlock_irq(&chip->lock);
        if (err < 0)
                return err;