struct snd_rawmidi           *rmidi;
     struct snd_rawmidi_substream *input;
     struct snd_rawmidi_substream *output;
-    char                     istimer; /* timer in use */
+    signed char                     istimer; /* timer in use */
     struct timer_list       timer;
     spinlock_t               lock;
     int                             pending;
        pid_t                 playback_pid;
        int                   running;
        int                   system_sample_rate;
-       const char           *channel_map;
+       const signed char    *channel_map;
        int                   dev;
        int                   irq;
        unsigned long         port;
    where the data for that channel can be read/written from/to.
 */
 
-static const char channel_map_df_ss[HDSP_MAX_CHANNELS] = {
+static const signed char channel_map_df_ss[HDSP_MAX_CHANNELS] = {
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
        18, 19, 20, 21, 22, 23, 24, 25
 };
        -1, -1, -1, -1, -1, -1, -1, -1
 };
 
-static const char channel_map_ds[HDSP_MAX_CHANNELS] = {
+static const signed char channel_map_ds[HDSP_MAX_CHANNELS] = {
        /* ADAT channels are remapped */
        1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23,
        /* channels 12 and 13 are S/PDIF */
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 };
 
-static const char channel_map_H9632_ss[HDSP_MAX_CHANNELS] = {
+static const signed char channel_map_H9632_ss[HDSP_MAX_CHANNELS] = {
        /* ADAT channels */
        0, 1, 2, 3, 4, 5, 6, 7,
        /* SPDIF */
        -1, -1
 };
 
-static const char channel_map_H9632_ds[HDSP_MAX_CHANNELS] = {
+static const signed char channel_map_H9632_ds[HDSP_MAX_CHANNELS] = {
        /* ADAT */
        1, 3, 5, 7,
        /* SPDIF */
        -1, -1, -1, -1, -1, -1
 };
 
-static const char channel_map_H9632_qs[HDSP_MAX_CHANNELS] = {
+static const signed char channel_map_H9632_qs[HDSP_MAX_CHANNELS] = {
        /* ADAT is disabled in this mode */
        /* SPDIF */
        8, 9,
        return hdsp_hw_pointer(hdsp);
 }
 
-static char *hdsp_channel_buffer_location(struct hdsp *hdsp,
+static signed char *hdsp_channel_buffer_location(struct hdsp *hdsp,
                                             int stream,
                                             int channel)
 
                                  void __user *src, unsigned long count)
 {
        struct hdsp *hdsp = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        if (snd_BUG_ON(pos + count > HDSP_CHANNEL_BUFFER_BYTES))
                return -EINVAL;
                                         void *src, unsigned long count)
 {
        struct hdsp *hdsp = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        channel_buf = hdsp_channel_buffer_location(hdsp, substream->pstr->stream, channel);
        if (snd_BUG_ON(!channel_buf))
                                 void __user *dst, unsigned long count)
 {
        struct hdsp *hdsp = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        if (snd_BUG_ON(pos + count > HDSP_CHANNEL_BUFFER_BYTES))
                return -EINVAL;
                                        void *dst, unsigned long count)
 {
        struct hdsp *hdsp = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        channel_buf = hdsp_channel_buffer_location(hdsp, substream->pstr->stream, channel);
        if (snd_BUG_ON(!channel_buf))
                               unsigned long count)
 {
        struct hdsp *hdsp = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        channel_buf = hdsp_channel_buffer_location (hdsp, substream->pstr->stream, channel);
        if (snd_BUG_ON(!channel_buf))
 
        int last_spdif_sample_rate;     /* so that we can catch externally ... */
        int last_adat_sample_rate;      /* ... induced rate changes            */
 
-       const char *channel_map;
+       const signed char *channel_map;
 
        struct snd_card *card;
        struct snd_pcm *pcm;
    where the data for that channel can be read/written from/to.
 */
 
-static const char channel_map_9652_ss[26] = {
+static const signed char channel_map_9652_ss[26] = {
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
        18, 19, 20, 21, 22, 23, 24, 25
 };
 
-static const char channel_map_9636_ss[26] = {
+static const signed char channel_map_9636_ss[26] = {
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 
        /* channels 16 and 17 are S/PDIF */
        24, 25,
        -1, -1, -1, -1, -1, -1, -1, -1
 };
 
-static const char channel_map_9652_ds[26] = {
+static const signed char channel_map_9652_ds[26] = {
        /* ADAT channels are remapped */
        1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23,
        /* channels 12 and 13 are S/PDIF */
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 };
 
-static const char channel_map_9636_ds[26] = {
+static const signed char channel_map_9636_ds[26] = {
        /* ADAT channels are remapped */
        1, 3, 5, 7, 9, 11, 13, 15,
        /* channels 8 and 9 are S/PDIF */
        return rme9652_hw_pointer(rme9652);
 }
 
-static char *rme9652_channel_buffer_location(struct snd_rme9652 *rme9652,
+static signed char *rme9652_channel_buffer_location(struct snd_rme9652 *rme9652,
                                             int stream,
                                             int channel)
 
                                     void __user *src, unsigned long count)
 {
        struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        if (snd_BUG_ON(pos + count > RME9652_CHANNEL_BUFFER_BYTES))
                return -EINVAL;
                                            void *src, unsigned long count)
 {
        struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        channel_buf = rme9652_channel_buffer_location(rme9652,
                                                      substream->pstr->stream,
                                    void __user *dst, unsigned long count)
 {
        struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        if (snd_BUG_ON(pos + count > RME9652_CHANNEL_BUFFER_BYTES))
                return -EINVAL;
                                           void *dst, unsigned long count)
 {
        struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        channel_buf = rme9652_channel_buffer_location(rme9652,
                                                      substream->pstr->stream,
                                  unsigned long count)
 {
        struct snd_rme9652 *rme9652 = snd_pcm_substream_chip(substream);
-       char *channel_buf;
+       signed char *channel_buf;
 
        channel_buf = rme9652_channel_buffer_location (rme9652,
                                                       substream->pstr->stream,