ir243_endian_fix.diff

   1 diff -u -p linux/include/net/irda/parameters.d2.h linux/include/net/irda/parameters.h
   2 --- linux/include/net/irda/parameters.d2.h      Thu Nov  1 14:15:51 2001
   3 +++ linux/include/net/irda/parameters.h Mon Nov  5 18:57:28 2001
   4 @@ -25,6 +25,9 @@
   5   *     along with this program; if not, write to the Free Software
   6   *     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
   7   *     MA 02111-1307 USA
   8 + *
   9 + *     Michel Dänzer <daenzer@debian.org>, 10/2001
  10 + *     - simplify irda_pv_t to avoid endianness issues
  11   *
  12   ********************************************************************/
  13
  14 @@ -55,11 +58,7 @@ typedef enum {
  15
  16  typedef union {
  17         char   *c;
  18 -       __u8    b;
  19 -       __u16   s;
  20         __u32   i;
  21 -       __u8  *bp;
  22 -       __u16 *sp;
  23         __u32 *ip;
  24  } irda_pv_t;
  25
  26 diff -u -p linux/net/irda/parameters.d2.c linux/net/irda/parameters.c
  27 --- linux/net/irda/parameters.d2.c      Thu Nov  1 14:17:32 2001
  28 +++ linux/net/irda/parameters.c Mon Nov  5 18:57:13 2001
  29 @@ -167,14 +167,14 @@ static int irda_insert_integer(void *sel
  30         IRDA_DEBUG(2, __FUNCTION__ "(), pi=%#x, pl=%d, pi=%d\n", p.pi, p.pl, p.pv.i);
  31         switch (p.pl) {
  32         case 1:
  33 -               n += irda_param_pack(buf, "bbb", p.pi, p.pl, p.pv.b);
  34 +               n += irda_param_pack(buf, "bbb", p.pi, p.pl, (__u8) p.pv.i);
  35                 break;
  36         case 2:
  37                 if (type & PV_BIG_ENDIAN)
  38 -                       cpu_to_be16s(&p.pv.s);
  39 +                       p.pv.i = cpu_to_be16((__u16) p.pv.i);
  40                 else
  41 -                       cpu_to_le16s(&p.pv.s);
  42 -               n += irda_param_pack(buf, "bbs", p.pi, p.pl, p.pv.s);
  43 +                       p.pv.i = cpu_to_le16((__u16) p.pv.i);
  44 +               n += irda_param_pack(buf, "bbs", p.pi, p.pl, (__u16) p.pv.i);
  45                 break;
  46         case 4:
  47                 if (type & PV_BIG_ENDIAN)
  48 @@ -230,16 +230,17 @@ static int irda_extract_integer(void *se
  49                 return p.pl+2;
  50         }
  51
  52 +
  53         switch (p.pl) {
  54         case 1:
  55 -               n += irda_param_unpack(buf+2, "b", &p.pv.b);
  56 +               n += irda_param_unpack(buf+2, "b", &p.pv.i);
  57                 break;
  58         case 2:
  59 -               n += irda_param_unpack(buf+2, "s", &p.pv.s);
  60 +               n += irda_param_unpack(buf+2, "s", &p.pv.i);
  61                 if (type & PV_BIG_ENDIAN)
  62 -                       be16_to_cpus(&p.pv.s);
  63 +                       p.pv.i = be16_to_cpu((__u16) p.pv.i);
  64                 else
  65 -                       le16_to_cpus(&p.pv.s);
  66 +                       p.pv.i = le16_to_cpu((__u16) p.pv.i);
  67                 break;
  68         case 4:
  69                 n += irda_param_unpack(buf+2, "i", &p.pv.i);
  70 @@ -255,6 +256,7 @@ static int irda_extract_integer(void *se
  71                 return p.pl+2;
  72         }
  73
  74 +       IRDA_DEBUG(2, __FUNCTION__ "(), pi=%#x, pl=%d, pi=%d\n", p.pi, p.pl, p.pv.i);
  75         /* Call handler for this parameter */
  76         err = (*func)(self, &p, PV_PUT);
  77         if (err < 0)
  78 @@ -359,8 +361,8 @@ int irda_param_pack(__u8 *buf, char *fmt
  79                         buf[n++] = (__u8)va_arg(args, int);
  80                         break;
  81                 case 's':  /* 16 bits unsigned short */
  82 -                       arg.s = (__u16)va_arg(args, int);
  83 -                       put_unaligned(arg.s, (__u16 *)(buf+n)); n+=2;
  84 +                       arg.i = (__u16)va_arg(args, int);
  85 +                       put_unaligned((__u16)arg.i, (__u16 *)(buf+n)); n+=2;
  86                         break;
  87                 case 'i':  /* 32 bits unsigned integer */
  88                         arg.i = va_arg(args, __u32);
  89 @@ -402,12 +404,12 @@ int irda_param_unpack(__u8 *buf, char *f
  90         for (p = fmt; *p != '\0'; p++) {
  91                 switch (*p) {
  92                 case 'b':  /* 8 bits byte */
  93 -                       arg.bp = va_arg(args, __u8 *);
  94 -                       *arg.bp = buf[n++];
  95 +                       arg.ip = va_arg(args, __u32 *);
  96 +                       *arg.ip = buf[n++];
  97                         break;
  98                 case 's':  /* 16 bits short */
  99 -                       arg.sp = va_arg(args, __u16 *);
 100 -                       *arg.sp = get_unaligned((__u16 *)(buf+n)); n+=2;
 101 +                       arg.ip = va_arg(args, __u32 *);
 102 +                       *arg.ip = get_unaligned((__u16 *)(buf+n)); n+=2;
 103                         break;
 104                 case 'i':  /* 32 bits unsigned integer */
 105                         arg.ip = va_arg(args, __u32 *);
 106 diff -u -p linux/net/irda/qos.d2.c linux/net/irda/qos.c
 107 --- linux/net/irda/qos.d2.c     Thu Nov  1 14:17:42 2001
 108 +++ linux/net/irda/qos.c        Mon Nov  5 18:45:07 2001
 109 @@ -11,6 +11,7 @@
 110   *
 111   *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
 112   *     All Rights Reserved.
 113 + *     Copyright (c) 2000-2001 Jean Tourrilhes <jt@hpl.hp.com>
 114   *
 115   *     This program is free software; you can redistribute it and/or
 116   *     modify it under the terms of the GNU General Public License as
 117 @@ -455,8 +456,8 @@ static int irlap_param_baud_rate(void *i
 118                  *  Stations must agree on baud rate, so calculate
 119                  *  intersection
 120                  */
 121 -               IRDA_DEBUG(2, "Requested BAUD_RATE: 0x%04x\n", param->pv.s);
 122 -               final = param->pv.s & self->qos_rx.baud_rate.bits;
 123 +               IRDA_DEBUG(2, "Requested BAUD_RATE: 0x%04x\n", (__u16) param->pv.i);
 124 +               final = (__u16) param->pv.i & self->qos_rx.baud_rate.bits;
 125
 126                 IRDA_DEBUG(2, "Final BAUD_RATE: 0x%04x\n", final);
 127                 self->qos_tx.baud_rate.bits = final;
 128 @@ -483,14 +484,14 @@ static int irlap_param_link_disconnect(v
 129         ASSERT(self->magic == LAP_MAGIC, return -1;);
 130
 131         if (get)
 132 -               param->pv.b = self->qos_rx.link_disc_time.bits;
 133 +               param->pv.i = self->qos_rx.link_disc_time.bits;
 134         else {
 135                 /*
 136                  *  Stations must agree on link disconnect/threshold
 137                  *  time.
 138                  */
 139 -               IRDA_DEBUG(2, "LINK_DISC: %02x\n", param->pv.b);
 140 -               final = param->pv.b & self->qos_rx.link_disc_time.bits;
 141 +               IRDA_DEBUG(2, "LINK_DISC: %02x\n", (__u8) param->pv.i);
 142 +               final = (__u8) param->pv.i & self->qos_rx.link_disc_time.bits;
 143
 144                 IRDA_DEBUG(2, "Final LINK_DISC: %02x\n", final);
 145                 self->qos_tx.link_disc_time.bits = final;
 146 @@ -515,9 +516,9 @@ static int irlap_param_max_turn_time(voi
 147         ASSERT(self->magic == LAP_MAGIC, return -1;);
 148
 149         if (get)
 150 -               param->pv.b = self->qos_rx.max_turn_time.bits;
 151 +               param->pv.i = self->qos_rx.max_turn_time.bits;
 152         else
 153 -               self->qos_tx.max_turn_time.bits = param->pv.b;
 154 +               self->qos_tx.max_turn_time.bits = (__u8) param->pv.i;
 155
 156         return 0;
 157  }
 158 @@ -537,9 +538,9 @@ static int irlap_param_data_size(void *i
 159         ASSERT(self->magic == LAP_MAGIC, return -1;);
 160
 161         if (get)
 162 -               param->pv.b = self->qos_rx.data_size.bits;
 163 +               param->pv.i = self->qos_rx.data_size.bits;
 164         else
 165 -               self->qos_tx.data_size.bits = param->pv.b;
 166 +               self->qos_tx.data_size.bits = (__u8) param->pv.i;
 167
 168         return 0;
 169  }
 170 @@ -560,9 +561,9 @@ static int irlap_param_window_size(void
 171         ASSERT(self->magic == LAP_MAGIC, return -1;);
 172
 173         if (get)
 174 -               param->pv.b = self->qos_rx.window_size.bits;
 175 +               param->pv.i = self->qos_rx.window_size.bits;
 176         else
 177 -               self->qos_tx.window_size.bits = param->pv.b;
 178 +               self->qos_tx.window_size.bits = (__u8) param->pv.i;
 179
 180         return 0;
 181  }
 182 @@ -581,9 +582,9 @@ static int irlap_param_additional_bofs(v
 183         ASSERT(self->magic == LAP_MAGIC, return -1;);
 184
 185         if (get)
 186 -               param->pv.b = self->qos_rx.additional_bofs.bits;
 187 +               param->pv.i = self->qos_rx.additional_bofs.bits;
 188         else
 189 -               self->qos_tx.additional_bofs.bits = param->pv.b;
 190 +               self->qos_tx.additional_bofs.bits = (__u8) param->pv.i;
 191
 192         return 0;
 193  }
 194 @@ -603,9 +604,9 @@ static int irlap_param_min_turn_time(voi
 195         ASSERT(self->magic == LAP_MAGIC, return -1;);
 196
 197         if (get)
 198 -               param->pv.b = self->qos_rx.min_turn_time.bits;
 199 +               param->pv.i = self->qos_rx.min_turn_time.bits;
 200         else
 201 -               self->qos_tx.min_turn_time.bits = param->pv.b;
 202 +               self->qos_tx.min_turn_time.bits = (__u8) param->pv.i;
 203
 204         return 0;
 205  }
 206 diff -u -p linux/net/irda/ircomm/ircomm_param.d2.c linux/net/irda/ircomm/ircomm_param.c
 207 --- linux/net/irda/ircomm/ircomm_param.d2.c     Thu Nov  1 14:17:19 2001
 208 +++ linux/net/irda/ircomm/ircomm_param.c        Thu Nov  1 14:18:17 2001
 209 @@ -182,13 +182,13 @@ static int ircomm_param_service_type(voi
 210                                      int get)
 211  {
 212         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 213 -       __u8 service_type = param->pv.b; /* We know it's a one byte integer */
 214 +       __u8 service_type = (__u8) param->pv.i;
 215
 216         ASSERT(self != NULL, return -1;);
 217         ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 218
 219         if (get) {
 220 -               param->pv.b = self->settings.service_type;
 221 +               param->pv.i = self->settings.service_type;
 222                 return 0;
 223         }
 224
 225 @@ -246,9 +246,9 @@ static int ircomm_param_port_type(void *
 226         ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 227
 228         if (get)
 229 -               param->pv.b = IRCOMM_SERIAL;
 230 +               param->pv.i = IRCOMM_SERIAL;
 231         else {
 232 -               self->settings.port_type = param->pv.b;
 233 +               self->settings.port_type = (__u8) param->pv.i;
 234
 235                 IRDA_DEBUG(0, __FUNCTION__ "(), port type=%d\n",
 236                            self->settings.port_type);
 237 @@ -317,9 +317,9 @@ static int ircomm_param_data_format(void
 238         ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 239
 240         if (get)
 241 -               param->pv.b = self->settings.data_format;
 242 +               param->pv.i = self->settings.data_format;
 243         else
 244 -               self->settings.data_format = param->pv.b;
 245 +               self->settings.data_format = (__u8) param->pv.i;
 246
 247         return 0;
 248  }
 249 @@ -339,11 +339,11 @@ static int ircomm_param_flow_control(voi
 250         ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 251
 252         if (get)
 253 -               param->pv.b = self->settings.flow_control;
 254 +               param->pv.i = self->settings.flow_control;
 255         else
 256 -               self->settings.flow_control = param->pv.b;
 257 +               self->settings.flow_control = (__u8) param->pv.i;
 258
 259 -       IRDA_DEBUG(1, __FUNCTION__ "(), flow control = 0x%02x\n", param->pv.b);
 260 +       IRDA_DEBUG(1, __FUNCTION__ "(), flow control = 0x%02x\n", (__u8) param->pv.i);
 261
 262         return 0;
 263  }
 264 @@ -362,15 +362,15 @@ static int ircomm_param_xon_xoff(void *i
 265         ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 266
 267         if (get) {
 268 -               param->pv.s = self->settings.xonxoff[0];
 269 -               param->pv.s |= self->settings.xonxoff[1] << 8;
 270 +               param->pv.i = self->settings.xonxoff[0];
 271 +               param->pv.i |= self->settings.xonxoff[1] << 8;
 272         } else {
 273 -               self->settings.xonxoff[0] = param->pv.s & 0xff;
 274 -               self->settings.xonxoff[1] = param->pv.s >> 8;
 275 +               self->settings.xonxoff[0] = (__u16) param->pv.i & 0xff;
 276 +               self->settings.xonxoff[1] = (__u16) param->pv.i >> 8;
 277         }
 278
 279         IRDA_DEBUG(0, __FUNCTION__ "(), XON/XOFF = 0x%02x,0x%02x\n",
 280 -                  param->pv.s & 0xff, param->pv.s >> 8);
 281 +                  param->pv.i & 0xff, param->pv.i >> 8);
 282
 283         return 0;
 284  }
 285 @@ -389,15 +389,15 @@ static int ircomm_param_enq_ack(void *in
 286         ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 287
 288         if (get) {
 289 -               param->pv.s = self->settings.enqack[0];
 290 -               param->pv.s |= self->settings.enqack[1] << 8;
 291 +               param->pv.i = self->settings.enqack[0];
 292 +               param->pv.i |= self->settings.enqack[1] << 8;
 293         } else {
 294 -               self->settings.enqack[0] = param->pv.s & 0xff;
 295 -               self->settings.enqack[1] = param->pv.s >> 8;
 296 +               self->settings.enqack[0] = (__u16) param->pv.i & 0xff;
 297 +               self->settings.enqack[1] = (__u16) param->pv.i >> 8;
 298         }
 299
 300         IRDA_DEBUG(0, __FUNCTION__ "(), ENQ/ACK = 0x%02x,0x%02x\n",
 301 -                  param->pv.s & 0xff, param->pv.s >> 8);
 302 +                  param->pv.i & 0xff, param->pv.i >> 8);
 303
 304         return 0;
 305  }
 306 @@ -431,9 +431,9 @@ static int ircomm_param_dte(void *instan
 307         ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 308
 309         if (get)
 310 -               param->pv.b = self->settings.dte;
 311 +               param->pv.i = self->settings.dte;
 312         else {
 313 -               dte = param->pv.b;
 314 +               dte = (__u8) param->pv.i;
 315
 316                 if (dte & IRCOMM_DELTA_DTR)
 317                         self->settings.dce |= (IRCOMM_DELTA_DSR|
 318 @@ -470,9 +470,9 @@ static int ircomm_param_dce(void *instan
 319         struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 320         __u8 dce;
 321
 322 -       IRDA_DEBUG(1, __FUNCTION__ "(), dce = 0x%02x\n", param->pv.b);
 323 +       IRDA_DEBUG(1, __FUNCTION__ "(), dce = 0x%02x\n", (__u8) param->pv.i);
 324
 325 -       dce = param->pv.b;
 326 +       dce = (__u8) param->pv.i;
 327
 328         ASSERT(self != NULL, return -1;);
 329         ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 330