src/patches/suse-2.6.27.31/patches.drivers/netxen-fix-endianness-in-firmware-commands.patch

   1 From 2edbb454428729f450f7a0aabbf95ac62b46b78a Mon Sep 17 00:00:00 2001
   2 From: Dhananjay Phadke <dhananjay@netxen.com>
   3 Date: Wed, 14 Jan 2009 20:47:30 -0800
   4 Subject: netxen: fix endianness in firmware commands
   5 Acked-by: Karsten Keil <kkeil@novell.com>
   6 Reference: bnc#472416
   7
   8 o Set restricted (little endian) data types in firmware command
   9   requests and responses.
  10 o Remove unnecessary conversion to LE when writing registers.
  11
  12 Signed-off-by: Dhananjay Phadke <dhananjay@netxen.com>
  13 Signed-off-by: David S. Miller <davem@davemloft.net>
  14 ---
  15  drivers/net/netxen/netxen_nic.h      |   98 +++++++++++++++++-----------------
  16  drivers/net/netxen/netxen_nic_ctx.c  |   50 +++++++----------
  17  drivers/net/netxen/netxen_nic_hw.c   |   42 ++++++++------
  18  drivers/net/netxen/netxen_nic_init.c |    2 +-
  19  4 files changed, 95 insertions(+), 97 deletions(-)
  20
  21 Index: linux-2.6.27-kketmp/drivers/net/netxen/netxen_nic.h
  22 ===================================================================
  23 --- linux-2.6.27-kketmp.orig/drivers/net/netxen/netxen_nic.h
  24 +++ linux-2.6.27-kketmp/drivers/net/netxen/netxen_nic.h
  25 @@ -995,31 +995,31 @@ struct netxen_recv_context {
  26   */
  27
  28  typedef struct {
  29 -       u64 host_phys_addr;     /* Ring base addr */
  30 -       u32 ring_size;          /* Ring entries */
  31 -       u16 msi_index;
  32 -       u16 rsvd;               /* Padding */
  33 +       __le64 host_phys_addr;  /* Ring base addr */
  34 +       __le32 ring_size;               /* Ring entries */
  35 +       __le16 msi_index;
  36 +       __le16 rsvd;            /* Padding */
  37  } nx_hostrq_sds_ring_t;
  38
  39  typedef struct {
  40 -       u64 host_phys_addr;     /* Ring base addr */
  41 -       u64 buff_size;          /* Packet buffer size */
  42 -       u32 ring_size;          /* Ring entries */
  43 -       u32 ring_kind;          /* Class of ring */
  44 +       __le64 host_phys_addr;  /* Ring base addr */
  45 +       __le64 buff_size;               /* Packet buffer size */
  46 +       __le32 ring_size;               /* Ring entries */
  47 +       __le32 ring_kind;               /* Class of ring */
  48  } nx_hostrq_rds_ring_t;
  49
  50  typedef struct {
  51 -       u64 host_rsp_dma_addr;  /* Response dma'd here */
  52 -       u32 capabilities[4];    /* Flag bit vector */
  53 -       u32 host_int_crb_mode;  /* Interrupt crb usage */
  54 -       u32 host_rds_crb_mode;  /* RDS crb usage */
  55 +       __le64 host_rsp_dma_addr;       /* Response dma'd here */
  56 +       __le32 capabilities[4]; /* Flag bit vector */
  57 +       __le32 host_int_crb_mode;       /* Interrupt crb usage */
  58 +       __le32 host_rds_crb_mode;       /* RDS crb usage */
  59         /* These ring offsets are relative to data[0] below */
  60 -       u32 rds_ring_offset;    /* Offset to RDS config */
  61 -       u32 sds_ring_offset;    /* Offset to SDS config */
  62 -       u16 num_rds_rings;      /* Count of RDS rings */
  63 -       u16 num_sds_rings;      /* Count of SDS rings */
  64 -       u16 rsvd1;              /* Padding */
  65 -       u16 rsvd2;              /* Padding */
  66 +       __le32 rds_ring_offset; /* Offset to RDS config */
  67 +       __le32 sds_ring_offset; /* Offset to SDS config */
  68 +       __le16 num_rds_rings;   /* Count of RDS rings */
  69 +       __le16 num_sds_rings;   /* Count of SDS rings */
  70 +       __le16 rsvd1;           /* Padding */
  71 +       __le16 rsvd2;           /* Padding */
  72         u8  reserved[128];      /* reserve space for future expansion*/
  73         /* MUST BE 64-bit aligned.
  74            The following is packed:
  75 @@ -1029,24 +1029,24 @@ typedef struct {
  76  } nx_hostrq_rx_ctx_t;
  77
  78  typedef struct {
  79 -       u32 host_producer_crb;  /* Crb to use */
  80 -       u32 rsvd1;              /* Padding */
  81 +       __le32 host_producer_crb;       /* Crb to use */
  82 +       __le32 rsvd1;           /* Padding */
  83  } nx_cardrsp_rds_ring_t;
  84
  85  typedef struct {
  86 -       u32 host_consumer_crb;  /* Crb to use */
  87 -       u32 interrupt_crb;      /* Crb to use */
  88 +       __le32 host_consumer_crb;       /* Crb to use */
  89 +       __le32 interrupt_crb;   /* Crb to use */
  90  } nx_cardrsp_sds_ring_t;
  91
  92  typedef struct {
  93         /* These ring offsets are relative to data[0] below */
  94 -       u32 rds_ring_offset;    /* Offset to RDS config */
  95 -       u32 sds_ring_offset;    /* Offset to SDS config */
  96 -       u32 host_ctx_state;     /* Starting State */
  97 -       u32 num_fn_per_port;    /* How many PCI fn share the port */
  98 -       u16 num_rds_rings;      /* Count of RDS rings */
  99 -       u16 num_sds_rings;      /* Count of SDS rings */
 100 -       u16 context_id;         /* Handle for context */
 101 +       __le32 rds_ring_offset; /* Offset to RDS config */
 102 +       __le32 sds_ring_offset; /* Offset to SDS config */
 103 +       __le32 host_ctx_state;  /* Starting State */
 104 +       __le32 num_fn_per_port; /* How many PCI fn share the port */
 105 +       __le16 num_rds_rings;   /* Count of RDS rings */
 106 +       __le16 num_sds_rings;   /* Count of SDS rings */
 107 +       __le16 context_id;              /* Handle for context */
 108         u8  phys_port;          /* Physical id of port */
 109         u8  virt_port;          /* Virtual/Logical id of port */
 110         u8  reserved[128];      /* save space for future expansion */
 111 @@ -1072,34 +1072,34 @@ typedef struct {
 112   */
 113
 114  typedef struct {
 115 -       u64 host_phys_addr;     /* Ring base addr */
 116 -       u32 ring_size;          /* Ring entries */
 117 -       u32 rsvd;               /* Padding */
 118 +       __le64 host_phys_addr;  /* Ring base addr */
 119 +       __le32 ring_size;               /* Ring entries */
 120 +       __le32 rsvd;            /* Padding */
 121  } nx_hostrq_cds_ring_t;
 122
 123  typedef struct {
 124 -       u64 host_rsp_dma_addr;  /* Response dma'd here */
 125 -       u64 cmd_cons_dma_addr;  /*  */
 126 -       u64 dummy_dma_addr;     /*  */
 127 -       u32 capabilities[4];    /* Flag bit vector */
 128 -       u32 host_int_crb_mode;  /* Interrupt crb usage */
 129 -       u32 rsvd1;              /* Padding */
 130 -       u16 rsvd2;              /* Padding */
 131 -       u16 interrupt_ctl;
 132 -       u16 msi_index;
 133 -       u16 rsvd3;              /* Padding */
 134 +       __le64 host_rsp_dma_addr;       /* Response dma'd here */
 135 +       __le64 cmd_cons_dma_addr;       /*  */
 136 +       __le64 dummy_dma_addr;  /*  */
 137 +       __le32 capabilities[4]; /* Flag bit vector */
 138 +       __le32 host_int_crb_mode;       /* Interrupt crb usage */
 139 +       __le32 rsvd1;           /* Padding */
 140 +       __le16 rsvd2;           /* Padding */
 141 +       __le16 interrupt_ctl;
 142 +       __le16 msi_index;
 143 +       __le16 rsvd3;           /* Padding */
 144         nx_hostrq_cds_ring_t cds_ring;  /* Desc of cds ring */
 145         u8  reserved[128];      /* future expansion */
 146  } nx_hostrq_tx_ctx_t;
 147
 148  typedef struct {
 149 -       u32 host_producer_crb;  /* Crb to use */
 150 -       u32 interrupt_crb;      /* Crb to use */
 151 +       __le32 host_producer_crb;       /* Crb to use */
 152 +       __le32 interrupt_crb;   /* Crb to use */
 153  } nx_cardrsp_cds_ring_t;
 154
 155  typedef struct {
 156 -       u32 host_ctx_state;     /* Starting state */
 157 -       u16 context_id;         /* Handle for context */
 158 +       __le32 host_ctx_state;  /* Starting state */
 159 +       __le16 context_id;              /* Handle for context */
 160         u8  phys_port;          /* Physical id of port */
 161         u8  virt_port;          /* Virtual/Logical id of port */
 162         nx_cardrsp_cds_ring_t cds_ring; /* Card cds settings */
 163 @@ -1202,9 +1202,9 @@ enum {
 164  #define VPORT_MISS_MODE_ACCEPT_MULTI   2 /* accept unmatched multicast */
 165
 166  typedef struct {
 167 -       u64 qhdr;
 168 -       u64 req_hdr;
 169 -       u64 words[6];
 170 +       __le64 qhdr;
 171 +       __le64 req_hdr;
 172 +       __le64 words[6];
 173  } nx_nic_req_t;
 174
 175  typedef struct {
 176 Index: linux-2.6.27-kketmp/drivers/net/netxen/netxen_nic_ctx.c
 177 ===================================================================
 178 --- linux-2.6.27-kketmp.orig/drivers/net/netxen/netxen_nic_ctx.c
 179 +++ linux-2.6.27-kketmp/drivers/net/netxen/netxen_nic_ctx.c
 180 @@ -76,7 +76,7 @@ netxen_api_unlock(struct netxen_adapter
 181  static u32
 182  netxen_poll_rsp(struct netxen_adapter *adapter)
 183  {
 184 -       u32 raw_rsp, rsp = NX_CDRP_RSP_OK;
 185 +       u32 rsp = NX_CDRP_RSP_OK;
 186         int     timeout = 0;
 187
 188         do {
 189 @@ -86,10 +86,7 @@ netxen_poll_rsp(struct netxen_adapter *a
 190                 if (++timeout > NX_OS_CRB_RETRY_COUNT)
 191                         return NX_CDRP_RSP_TIMEOUT;
 192
 193 -               netxen_nic_read_w1(adapter, NX_CDRP_CRB_OFFSET,
 194 -                               &raw_rsp);
 195 -
 196 -               rsp = le32_to_cpu(raw_rsp);
 197 +               netxen_nic_read_w1(adapter, NX_CDRP_CRB_OFFSET, &rsp);
 198         } while (!NX_CDRP_IS_RSP(rsp));
 199
 200         return rsp;
 201 @@ -109,20 +106,16 @@ netxen_issue_cmd(struct netxen_adapter *
 202         if (netxen_api_lock(adapter))
 203                 return NX_RCODE_TIMEOUT;
 204
 205 -       netxen_nic_write_w1(adapter, NX_SIGN_CRB_OFFSET,
 206 -                       cpu_to_le32(signature));
 207 +       netxen_nic_write_w1(adapter, NX_SIGN_CRB_OFFSET, signature);
 208
 209 -       netxen_nic_write_w1(adapter, NX_ARG1_CRB_OFFSET,
 210 -                       cpu_to_le32(arg1));
 211 +       netxen_nic_write_w1(adapter, NX_ARG1_CRB_OFFSET, arg1);
 212
 213 -       netxen_nic_write_w1(adapter, NX_ARG2_CRB_OFFSET,
 214 -                       cpu_to_le32(arg2));
 215 +       netxen_nic_write_w1(adapter, NX_ARG2_CRB_OFFSET, arg2);
 216
 217 -       netxen_nic_write_w1(adapter, NX_ARG3_CRB_OFFSET,
 218 -                       cpu_to_le32(arg3));
 219 +       netxen_nic_write_w1(adapter, NX_ARG3_CRB_OFFSET, arg3);
 220
 221         netxen_nic_write_w1(adapter, NX_CDRP_CRB_OFFSET,
 222 -                       cpu_to_le32(NX_CDRP_FORM_CMD(cmd)));
 223 +                       NX_CDRP_FORM_CMD(cmd));
 224
 225         rsp = netxen_poll_rsp(adapter);
 226
 227 @@ -133,7 +126,6 @@ netxen_issue_cmd(struct netxen_adapter *
 228                 rcode = NX_RCODE_TIMEOUT;
 229         } else if (rsp == NX_CDRP_RSP_FAIL) {
 230                 netxen_nic_read_w1(adapter, NX_ARG1_CRB_OFFSET, &rcode);
 231 -               rcode = le32_to_cpu(rcode);
 232
 233                 printk(KERN_ERR "%s: failed card response code:0x%x\n",
 234                                 netxen_nic_driver_name, rcode);
 235 @@ -183,7 +175,7 @@ nx_fw_cmd_create_rx_ctx(struct netxen_ad
 236
 237         int i, nrds_rings, nsds_rings;
 238         size_t rq_size, rsp_size;
 239 -       u32 cap, reg;
 240 +       u32 cap, reg, val;
 241
 242         int err;
 243
 244 @@ -225,11 +217,14 @@ nx_fw_cmd_create_rx_ctx(struct netxen_ad
 245
 246         prq->num_rds_rings = cpu_to_le16(nrds_rings);
 247         prq->num_sds_rings = cpu_to_le16(nsds_rings);
 248 -       prq->rds_ring_offset = 0;
 249 -       prq->sds_ring_offset = prq->rds_ring_offset +
 250 +       prq->rds_ring_offset = cpu_to_le32(0);
 251 +
 252 +       val = le32_to_cpu(prq->rds_ring_offset) +
 253                 (sizeof(nx_hostrq_rds_ring_t) * nrds_rings);
 254 +       prq->sds_ring_offset = cpu_to_le32(val);
 255
 256 -       prq_rds = (nx_hostrq_rds_ring_t *)(prq->data + prq->rds_ring_offset);
 257 +       prq_rds = (nx_hostrq_rds_ring_t *)(prq->data +
 258 +                       le32_to_cpu(prq->rds_ring_offset));
 259
 260         for (i = 0; i < nrds_rings; i++) {
 261
 262 @@ -241,17 +236,14 @@ nx_fw_cmd_create_rx_ctx(struct netxen_ad
 263                 prq_rds[i].buff_size = cpu_to_le64(rds_ring->dma_size);
 264         }
 265
 266 -       prq_sds = (nx_hostrq_sds_ring_t *)(prq->data + prq->sds_ring_offset);
 267 +       prq_sds = (nx_hostrq_sds_ring_t *)(prq->data +
 268 +                       le32_to_cpu(prq->sds_ring_offset));
 269
 270         prq_sds[0].host_phys_addr =
 271                 cpu_to_le64(recv_ctx->rcv_status_desc_phys_addr);
 272         prq_sds[0].ring_size = cpu_to_le32(adapter->max_rx_desc_count);
 273         /* only one msix vector for now */
 274 -       prq_sds[0].msi_index = cpu_to_le32(0);
 275 -
 276 -       /* now byteswap offsets */
 277 -       prq->rds_ring_offset = cpu_to_le32(prq->rds_ring_offset);
 278 -       prq->sds_ring_offset = cpu_to_le32(prq->sds_ring_offset);
 279 +       prq_sds[0].msi_index = cpu_to_le16(0);
 280
 281         phys_addr = hostrq_phys_addr;
 282         err = netxen_issue_cmd(adapter,
 283 @@ -269,9 +261,9 @@ nx_fw_cmd_create_rx_ctx(struct netxen_ad
 284
 285
 286         prsp_rds = ((nx_cardrsp_rds_ring_t *)
 287 -                        &prsp->data[prsp->rds_ring_offset]);
 288 +                        &prsp->data[le32_to_cpu(prsp->rds_ring_offset)]);
 289
 290 -       for (i = 0; i < le32_to_cpu(prsp->num_rds_rings); i++) {
 291 +       for (i = 0; i < le16_to_cpu(prsp->num_rds_rings); i++) {
 292                 rds_ring = &recv_ctx->rds_rings[i];
 293
 294                 reg = le32_to_cpu(prsp_rds[i].host_producer_crb);
 295 @@ -279,7 +271,7 @@ nx_fw_cmd_create_rx_ctx(struct netxen_ad
 296         }
 297
 298         prsp_sds = ((nx_cardrsp_sds_ring_t *)
 299 -                       &prsp->data[prsp->sds_ring_offset]);
 300 +                       &prsp->data[le32_to_cpu(prsp->sds_ring_offset)]);
 301         reg = le32_to_cpu(prsp_sds[0].host_consumer_crb);
 302         recv_ctx->crb_sts_consumer = NETXEN_NIC_REG(reg - 0x200);
 303
 304 @@ -288,7 +280,7 @@ nx_fw_cmd_create_rx_ctx(struct netxen_ad
 305
 306         recv_ctx->state = le32_to_cpu(prsp->host_ctx_state);
 307         recv_ctx->context_id = le16_to_cpu(prsp->context_id);
 308 -       recv_ctx->virt_port = le16_to_cpu(prsp->virt_port);
 309 +       recv_ctx->virt_port = prsp->virt_port;
 310
 311  out_free_rsp:
 312         pci_free_consistent(adapter->pdev, rsp_size, prsp, cardrsp_phys_addr);
 313 Index: linux-2.6.27-kketmp/drivers/net/netxen/netxen_nic_hw.c
 314 ===================================================================
 315 --- linux-2.6.27-kketmp.orig/drivers/net/netxen/netxen_nic_hw.c
 316 +++ linux-2.6.27-kketmp/drivers/net/netxen/netxen_nic_hw.c
 317 @@ -539,16 +539,19 @@ static int nx_p3_sre_macaddr_change(stru
 318  {
 319         struct netxen_adapter *adapter = (struct netxen_adapter *)dev->priv;
 320         nx_nic_req_t req;
 321 -       nx_mac_req_t mac_req;
 322 +       nx_mac_req_t *mac_req;
 323 +       u64 word;
 324         int rv;
 325
 326         memset(&req, 0, sizeof(nx_nic_req_t));
 327 -       req.qhdr |= (NX_NIC_REQUEST << 23);
 328 -       req.req_hdr |= NX_MAC_EVENT;
 329 -       req.req_hdr |= ((u64)adapter->portnum << 16);
 330 -       mac_req.op = op;
 331 -       memcpy(&mac_req.mac_addr, addr, 6);
 332 -       req.words[0] = cpu_to_le64(*(u64 *)&mac_req);
 333 +       req.qhdr = cpu_to_le64(NX_NIC_REQUEST << 23);
 334 +
 335 +       word = NX_MAC_EVENT | ((u64)adapter->portnum << 16);
 336 +       req.req_hdr = cpu_to_le64(word);
 337 +
 338 +       mac_req = (nx_mac_req_t *)&req.words[0];
 339 +       mac_req->op = op;
 340 +       memcpy(mac_req->mac_addr, addr, 6);
 341
 342         rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
 343         if (rv != 0) {
 344 @@ -612,12 +615,16 @@ send_fw_cmd:
 345  int netxen_p3_nic_set_promisc(struct netxen_adapter *adapter, u32 mode)
 346  {
 347         nx_nic_req_t req;
 348 +       u64 word;
 349
 350         memset(&req, 0, sizeof(nx_nic_req_t));
 351
 352 -       req.qhdr |= (NX_HOST_REQUEST << 23);
 353 -       req.req_hdr |= NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE;
 354 -       req.req_hdr |= ((u64)adapter->portnum << 16);
 355 +       req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
 356 +
 357 +       word = NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE |
 358 +                       ((u64)adapter->portnum << 16);
 359 +       req.req_hdr = cpu_to_le64(word);
 360 +
 361         req.words[0] = cpu_to_le64(mode);
 362
 363         return netxen_send_cmd_descs(adapter,
 364 @@ -632,13 +639,15 @@ int netxen_p3_nic_set_promisc(struct net
 365  int netxen_config_intr_coalesce(struct netxen_adapter *adapter)
 366  {
 367         nx_nic_req_t req;
 368 +       u64 word;
 369         int rv;
 370
 371         memset(&req, 0, sizeof(nx_nic_req_t));
 372
 373 -       req.qhdr |= (NX_NIC_REQUEST << 23);
 374 -       req.req_hdr |= NETXEN_CONFIG_INTR_COALESCE;
 375 -       req.req_hdr |= ((u64)adapter->portnum << 16);
 376 +       req.qhdr = cpu_to_le64(NX_NIC_REQUEST << 23);
 377 +
 378 +       word = NETXEN_CONFIG_INTR_COALESCE | ((u64)adapter->portnum << 16);
 379 +       req.req_hdr = cpu_to_le64(word);
 380
 381         memcpy(&req.words[0], &adapter->coal, sizeof(adapter->coal));
 382
 383 @@ -772,13 +781,10 @@ int netxen_p3_get_mac_addr(struct netxen
 384         adapter->hw_read_wx(adapter, crbaddr, &mac_lo, 4);
 385         adapter->hw_read_wx(adapter, crbaddr+4, &mac_hi, 4);
 386
 387 -       mac_hi = cpu_to_le32(mac_hi);
 388 -       mac_lo = cpu_to_le32(mac_lo);
 389 -
 390         if (pci_func & 1)
 391 -               *mac = ((mac_lo >> 16) | ((u64)mac_hi << 16));
 392 +               *mac = le64_to_cpu((mac_lo >> 16) | ((u64)mac_hi << 16));
 393         else
 394 -               *mac = ((mac_lo) | ((u64)mac_hi << 32));
 395 +               *mac = le64_to_cpu((u64)mac_lo | ((u64)mac_hi << 32));
 396
 397         return 0;
 398  }
 399 Index: linux-2.6.27-kketmp/drivers/net/netxen/netxen_nic_init.c
 400 ===================================================================
 401 --- linux-2.6.27-kketmp.orig/drivers/net/netxen/netxen_nic_init.c
 402 +++ linux-2.6.27-kketmp/drivers/net/netxen/netxen_nic_init.c
 403 @@ -1277,7 +1277,7 @@ static void netxen_process_rcv(struct ne
 404
 405                 dev_kfree_skb_any(skb);
 406                 for (i = 0; i < nr_frags; i++) {
 407 -                       index = frag_desc->frag_handles[i];
 408 +                       index = le16_to_cpu(frag_desc->frag_handles[i]);
 409                         skb = netxen_process_rxbuf(adapter,
 410                                         rds_ring, index, cksum);
 411                         if (skb)