drivers/net/wireless/prism54/islpci_mgt.c

   1 /*
   2  *  Copyright (C) 2002 Intersil Americas Inc.
   3  *  Copyright 2004 Jens Maurer <Jens.Maurer@gmx.net>
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  *
  18  */
  19
  20 #include <linux/netdevice.h>
  21 #include <linux/module.h>
  22 #include <linux/pci.h>
  23
  24 #include <asm/io.h>
  25 #include <asm/system.h>
  26 #include <linux/if_arp.h>
  27
  28 #include "prismcompat.h"
  29 #include "isl_38xx.h"
  30 #include "islpci_mgt.h"
  31 #include "isl_oid.h"            /* additional types and defs for isl38xx fw */
  32 #include "isl_ioctl.h"
  33
  34 #include <net/iw_handler.h>
  35
  36 /******************************************************************************
  37         Global variable definition section
  38 ******************************************************************************/
  39 int pc_debug = VERBOSE;
  40 module_param(pc_debug, int, 0);
  41
  42 /******************************************************************************
  43     Driver general functions
  44 ******************************************************************************/
  45 #if VERBOSE > SHOW_ERROR_MESSAGES
  46 void
  47 display_buffer(char *buffer, int length)
  48 {
  49         if ((pc_debug & SHOW_BUFFER_CONTENTS) == 0)
  50                 return;
  51
  52         while (length > 0) {
  53                 printk("[%02x]", *buffer & 255);
  54                 length--;
  55                 buffer++;
  56         }
  57
  58         printk("\n");
  59 }
  60 #endif
  61
  62 /*****************************************************************************
  63     Queue handling for management frames
  64 ******************************************************************************/
  65
  66 /*
  67  * Helper function to create a PIMFOR management frame header.
  68  */
  69 static void
  70 pimfor_encode_header(int operation, u32 oid, u32 length, pimfor_header_t *h)
  71 {
  72         h->version = PIMFOR_VERSION;
  73         h->operation = operation;
  74         h->device_id = PIMFOR_DEV_ID_MHLI_MIB;
  75         h->flags = 0;
  76         h->oid = cpu_to_be32(oid);
  77         h->length = cpu_to_be32(length);
  78 }
  79
  80 /*
  81  * Helper function to analyze a PIMFOR management frame header.
  82  */
  83 static pimfor_header_t *
  84 pimfor_decode_header(void *data, int len)
  85 {
  86         pimfor_header_t *h = data;
  87
  88         while ((void *) h < data + len) {
  89                 if (h->flags & PIMFOR_FLAG_LITTLE_ENDIAN) {
  90                         le32_to_cpus(&h->oid);
  91                         le32_to_cpus(&h->length);
  92                 } else {
  93                         be32_to_cpus(&h->oid);
  94                         be32_to_cpus(&h->length);
  95                 }
  96                 if (h->oid != OID_INL_TUNNEL)
  97                         return h;
  98                 h++;
  99         }
 100         return NULL;
 101 }
 102
 103 /*
 104  * Fill the receive queue for management frames with fresh buffers.
 105  */
 106 int
 107 islpci_mgmt_rx_fill(struct net_device *ndev)
 108 {
 109         islpci_private *priv = netdev_priv(ndev);
 110         isl38xx_control_block *cb =     /* volatile not needed */
 111             (isl38xx_control_block *) priv->control_block;
 112         u32 curr = le32_to_cpu(cb->driver_curr_frag[ISL38XX_CB_RX_MGMTQ]);
 113
 114 #if VERBOSE > SHOW_ERROR_MESSAGES
 115         DEBUG(SHOW_FUNCTION_CALLS, "islpci_mgmt_rx_fill \n");
 116 #endif
 117
 118         while (curr - priv->index_mgmt_rx < ISL38XX_CB_MGMT_QSIZE) {
 119                 u32 index = curr % ISL38XX_CB_MGMT_QSIZE;
 120                 struct islpci_membuf *buf = &priv->mgmt_rx[index];
 121                 isl38xx_fragment *frag = &cb->rx_data_mgmt[index];
 122
 123                 if (buf->mem == NULL) {
 124                         buf->mem = kmalloc(MGMT_FRAME_SIZE, GFP_ATOMIC);
 125                         if (!buf->mem) {
 126                                 printk(KERN_WARNING
 127                                        "Error allocating management frame.\n");
 128                                 return -ENOMEM;
 129                         }
 130                         buf->size = MGMT_FRAME_SIZE;
 131                 }
 132                 if (buf->pci_addr == 0) {
 133                         buf->pci_addr = pci_map_single(priv->pdev, buf->mem,
 134                                                        MGMT_FRAME_SIZE,
 135                                                        PCI_DMA_FROMDEVICE);
 136                         if (!buf->pci_addr) {
 137                                 printk(KERN_WARNING
 138                                        "Failed to make memory DMA'able.\n");
 139                                 return -ENOMEM;
 140                         }
 141                 }
 142
 143                 /* be safe: always reset control block information */
 144                 frag->size = cpu_to_le16(MGMT_FRAME_SIZE);
 145                 frag->flags = 0;
 146                 frag->address = cpu_to_le32(buf->pci_addr);
 147                 curr++;
 148
 149                 /* The fragment address in the control block must have
 150                  * been written before announcing the frame buffer to
 151                  * device */
 152                 wmb();
 153                 cb->driver_curr_frag[ISL38XX_CB_RX_MGMTQ] = cpu_to_le32(curr);
 154         }
 155         return 0;
 156 }
 157
 158 /*
 159  * Create and transmit a management frame using "operation" and "oid",
 160  * with arguments data/length.
 161  * We either return an error and free the frame, or we return 0 and
 162  * islpci_mgt_cleanup_transmit() frees the frame in the tx-done
 163  * interrupt.
 164  */
 165 static int
 166 islpci_mgt_transmit(struct net_device *ndev, int operation, unsigned long oid,
 167                     void *data, int length)
 168 {
 169         islpci_private *priv = netdev_priv(ndev);
 170         isl38xx_control_block *cb =
 171             (isl38xx_control_block *) priv->control_block;
 172         void *p;
 173         int err = -EINVAL;
 174         unsigned long flags;
 175         isl38xx_fragment *frag;
 176         struct islpci_membuf buf;
 177         u32 curr_frag;
 178         int index;
 179         int frag_len = length + PIMFOR_HEADER_SIZE;
 180
 181 #if VERBOSE > SHOW_ERROR_MESSAGES
 182         DEBUG(SHOW_FUNCTION_CALLS, "islpci_mgt_transmit\n");
 183 #endif
 184
 185         if (frag_len > MGMT_FRAME_SIZE) {
 186                 printk(KERN_DEBUG "%s: mgmt frame too large %d\n",
 187                        ndev->name, frag_len);
 188                 goto error;
 189         }
 190
 191         err = -ENOMEM;
 192         p = buf.mem = kmalloc(frag_len, GFP_KERNEL);
 193         if (!buf.mem) {
 194                 printk(KERN_DEBUG "%s: cannot allocate mgmt frame\n",
 195                        ndev->name);
 196                 goto error;
 197         }
 198         buf.size = frag_len;
 199
 200         /* create the header directly in the fragment data area */
 201         pimfor_encode_header(operation, oid, length, (pimfor_header_t *) p);
 202         p += PIMFOR_HEADER_SIZE;
 203
 204         if (data)
 205                 memcpy(p, data, length);
 206         else
 207                 memset(p, 0, length);
 208
 209 #if VERBOSE > SHOW_ERROR_MESSAGES
 210         {
 211                 pimfor_header_t *h = buf.mem;
 212                 DEBUG(SHOW_PIMFOR_FRAMES,
 213                       "PIMFOR: op %i, oid 0x%08lx, device %i, flags 0x%x length 0x%x \n",
 214                       h->operation, oid, h->device_id, h->flags, length);
 215
 216                 /* display the buffer contents for debugging */
 217                 display_buffer((char *) h, sizeof (pimfor_header_t));
 218                 display_buffer(p, length);
 219         }
 220 #endif
 221
 222         err = -ENOMEM;
 223         buf.pci_addr = pci_map_single(priv->pdev, buf.mem, frag_len,
 224                                       PCI_DMA_TODEVICE);
 225         if (!buf.pci_addr) {
 226                 printk(KERN_WARNING "%s: cannot map PCI memory for mgmt\n",
 227                        ndev->name);
 228                 goto error_free;
 229         }
 230
 231         /* Protect the control block modifications against interrupts. */
 232         spin_lock_irqsave(&priv->slock, flags);
 233         curr_frag = le32_to_cpu(cb->driver_curr_frag[ISL38XX_CB_TX_MGMTQ]);
 234         if (curr_frag - priv->index_mgmt_tx >= ISL38XX_CB_MGMT_QSIZE) {
 235                 printk(KERN_WARNING "%s: mgmt tx queue is still full\n",
 236                        ndev->name);
 237                 goto error_unlock;
 238         }
 239
 240         /* commit the frame to the tx device queue */
 241         index = curr_frag % ISL38XX_CB_MGMT_QSIZE;
 242         priv->mgmt_tx[index] = buf;
 243         frag = &cb->tx_data_mgmt[index];
 244         frag->size = cpu_to_le16(frag_len);
 245         frag->flags = 0;        /* for any other than the last fragment, set to 1 */
 246         frag->address = cpu_to_le32(buf.pci_addr);
 247
 248         /* The fragment address in the control block must have
 249          * been written before announcing the frame buffer to
 250          * device */
 251         wmb();
 252         cb->driver_curr_frag[ISL38XX_CB_TX_MGMTQ] = cpu_to_le32(curr_frag + 1);
 253         spin_unlock_irqrestore(&priv->slock, flags);
 254
 255         /* trigger the device */
 256         islpci_trigger(priv);
 257         return 0;
 258
 259       error_unlock:
 260         spin_unlock_irqrestore(&priv->slock, flags);
 261       error_free:
 262         kfree(buf.mem);
 263       error:
 264         return err;
 265 }
 266
 267 /*
 268  * Receive a management frame from the device.
 269  * This can be an arbitrary number of traps, and at most one response
 270  * frame for a previous request sent via islpci_mgt_transmit().
 271  */
 272 int
 273 islpci_mgt_receive(struct net_device *ndev)
 274 {
 275         islpci_private *priv = netdev_priv(ndev);
 276         isl38xx_control_block *cb =
 277             (isl38xx_control_block *) priv->control_block;
 278         u32 curr_frag;
 279
 280 #if VERBOSE > SHOW_ERROR_MESSAGES
 281         DEBUG(SHOW_FUNCTION_CALLS, "islpci_mgt_receive \n");
 282 #endif
 283
 284         /* Only once per interrupt, determine fragment range to
 285          * process.  This avoids an endless loop (i.e. lockup) if
 286          * frames come in faster than we can process them. */
 287         curr_frag = le32_to_cpu(cb->device_curr_frag[ISL38XX_CB_RX_MGMTQ]);
 288         barrier();
 289
 290         for (; priv->index_mgmt_rx < curr_frag; priv->index_mgmt_rx++) {
 291                 pimfor_header_t *header;
 292                 u32 index = priv->index_mgmt_rx % ISL38XX_CB_MGMT_QSIZE;
 293                 struct islpci_membuf *buf = &priv->mgmt_rx[index];
 294                 u16 frag_len;
 295                 int size;
 296                 struct islpci_mgmtframe *frame;
 297
 298                 /* I have no idea (and no documentation) if flags != 0
 299                  * is possible.  Drop the frame, reuse the buffer. */
 300                 if (le16_to_cpu(cb->rx_data_mgmt[index].flags) != 0) {
 301                         printk(KERN_WARNING "%s: unknown flags 0x%04x\n",
 302                                ndev->name,
 303                                le16_to_cpu(cb->rx_data_mgmt[index].flags));
 304                         continue;
 305                 }
 306
 307                 /* The device only returns the size of the header(s) here. */
 308                 frag_len = le16_to_cpu(cb->rx_data_mgmt[index].size);
 309
 310                 /*
 311                  * We appear to have no way to tell the device the
 312                  * size of a receive buffer.  Thus, if this check
 313                  * triggers, we likely have kernel heap corruption. */
 314                 if (frag_len > MGMT_FRAME_SIZE) {
 315                         printk(KERN_WARNING
 316                                 "%s: Bogus packet size of %d (%#x).\n",
 317                                 ndev->name, frag_len, frag_len);
 318                         frag_len = MGMT_FRAME_SIZE;
 319                 }
 320
 321                 /* Ensure the results of device DMA are visible to the CPU. */
 322                 pci_dma_sync_single_for_cpu(priv->pdev, buf->pci_addr,
 323                                             buf->size, PCI_DMA_FROMDEVICE);
 324
 325                 /* Perform endianess conversion for PIMFOR header in-place. */
 326                 header = pimfor_decode_header(buf->mem, frag_len);
 327                 if (!header) {
 328                         printk(KERN_WARNING "%s: no PIMFOR header found\n",
 329                                ndev->name);
 330                         continue;
 331                 }
 332
 333                 /* The device ID from the PIMFOR packet received from
 334                  * the MVC is always 0.  We forward a sensible device_id.
 335                  * Not that anyone upstream would care... */
 336                 header->device_id = priv->ndev->ifindex;
 337
 338 #if VERBOSE > SHOW_ERROR_MESSAGES
 339                 DEBUG(SHOW_PIMFOR_FRAMES,
 340                       "PIMFOR: op %i, oid 0x%08x, device %i, flags 0x%x length 0x%x \n",
 341                       header->operation, header->oid, header->device_id,
 342                       header->flags, header->length);
 343
 344                 /* display the buffer contents for debugging */
 345                 display_buffer((char *) header, PIMFOR_HEADER_SIZE);
 346                 display_buffer((char *) header + PIMFOR_HEADER_SIZE,
 347                                header->length);
 348 #endif
 349
 350                 /* nobody sends these */
 351                 if (header->flags & PIMFOR_FLAG_APPLIC_ORIGIN) {
 352                         printk(KERN_DEBUG
 353                                "%s: errant PIMFOR application frame\n",
 354                                ndev->name);
 355                         continue;
 356                 }
 357
 358                 /* Determine frame size, skipping OID_INL_TUNNEL headers. */
 359                 size = PIMFOR_HEADER_SIZE + header->length;
 360                 frame = kmalloc(sizeof (struct islpci_mgmtframe) + size,
 361                                 GFP_ATOMIC);
 362                 if (!frame) {
 363                         printk(KERN_WARNING
 364                                "%s: Out of memory, cannot handle oid 0x%08x\n",
 365                                ndev->name, header->oid);
 366                         continue;
 367                 }
 368                 frame->ndev = ndev;
 369                 memcpy(&frame->buf, header, size);
 370                 frame->header = (pimfor_header_t *) frame->buf;
 371                 frame->data = frame->buf + PIMFOR_HEADER_SIZE;
 372
 373 #if VERBOSE > SHOW_ERROR_MESSAGES
 374                 DEBUG(SHOW_PIMFOR_FRAMES,
 375                       "frame: header: %p, data: %p, size: %d\n",
 376                       frame->header, frame->data, size);
 377 #endif
 378
 379                 if (header->operation == PIMFOR_OP_TRAP) {
 380 #if VERBOSE > SHOW_ERROR_MESSAGES
 381                         printk(KERN_DEBUG
 382                                "TRAP: oid 0x%x, device %i, flags 0x%x length %i\n",
 383                                header->oid, header->device_id, header->flags,
 384                                header->length);
 385 #endif
 386
 387                         /* Create work to handle trap out of interrupt
 388                          * context. */
 389                         INIT_WORK(&frame->ws, prism54_process_trap);
 390                         schedule_work(&frame->ws);
 391
 392                 } else {
 393                         /* Signal the one waiting process that a response
 394                          * has been received. */
 395                         if ((frame = xchg(&priv->mgmt_received, frame)) != NULL) {
 396                                 printk(KERN_WARNING
 397                                        "%s: mgmt response not collected\n",
 398                                        ndev->name);
 399                                 kfree(frame);
 400                         }
 401 #if VERBOSE > SHOW_ERROR_MESSAGES
 402                         DEBUG(SHOW_TRACING, "Wake up Mgmt Queue\n");
 403 #endif
 404                         wake_up(&priv->mgmt_wqueue);
 405                 }
 406
 407         }
 408
 409         return 0;
 410 }
 411
 412 /*
 413  * Cleanup the transmit queue by freeing all frames handled by the device.
 414  */
 415 void
 416 islpci_mgt_cleanup_transmit(struct net_device *ndev)
 417 {
 418         islpci_private *priv = netdev_priv(ndev);
 419         isl38xx_control_block *cb =     /* volatile not needed */
 420             (isl38xx_control_block *) priv->control_block;
 421         u32 curr_frag;
 422
 423 #if VERBOSE > SHOW_ERROR_MESSAGES
 424         DEBUG(SHOW_FUNCTION_CALLS, "islpci_mgt_cleanup_transmit\n");
 425 #endif
 426
 427         /* Only once per cleanup, determine fragment range to
 428          * process.  This avoids an endless loop (i.e. lockup) if
 429          * the device became confused, incrementing device_curr_frag
 430          * rapidly. */
 431         curr_frag = le32_to_cpu(cb->device_curr_frag[ISL38XX_CB_TX_MGMTQ]);
 432         barrier();
 433
 434         for (; priv->index_mgmt_tx < curr_frag; priv->index_mgmt_tx++) {
 435                 int index = priv->index_mgmt_tx % ISL38XX_CB_MGMT_QSIZE;
 436                 struct islpci_membuf *buf = &priv->mgmt_tx[index];
 437                 pci_unmap_single(priv->pdev, buf->pci_addr, buf->size,
 438                                  PCI_DMA_TODEVICE);
 439                 buf->pci_addr = 0;
 440                 kfree(buf->mem);
 441                 buf->mem = NULL;
 442                 buf->size = 0;
 443         }
 444 }
 445
 446 /*
 447  * Perform one request-response transaction to the device.
 448  */
 449 int
 450 islpci_mgt_transaction(struct net_device *ndev,
 451                        int operation, unsigned long oid,
 452                        void *senddata, int sendlen,
 453                        struct islpci_mgmtframe **recvframe)
 454 {
 455         islpci_private *priv = netdev_priv(ndev);
 456         const long wait_cycle_jiffies = msecs_to_jiffies(ISL38XX_WAIT_CYCLE * 10);
 457         long timeout_left = ISL38XX_MAX_WAIT_CYCLES * wait_cycle_jiffies;
 458         int err;
 459         DEFINE_WAIT(wait);
 460
 461         *recvframe = NULL;
 462
 463         if (mutex_lock_interruptible(&priv->mgmt_lock))
 464                 return -ERESTARTSYS;
 465
 466         prepare_to_wait(&priv->mgmt_wqueue, &wait, TASK_UNINTERRUPTIBLE);
 467         err = islpci_mgt_transmit(ndev, operation, oid, senddata, sendlen);
 468         if (err)
 469                 goto out;
 470
 471         err = -ETIMEDOUT;
 472         while (timeout_left > 0) {
 473                 int timeleft;
 474                 struct islpci_mgmtframe *frame;
 475
 476                 timeleft = schedule_timeout_uninterruptible(wait_cycle_jiffies);
 477                 frame = xchg(&priv->mgmt_received, NULL);
 478                 if (frame) {
 479                         if (frame->header->oid == oid) {
 480                                 *recvframe = frame;
 481                                 err = 0;
 482                                 goto out;
 483                         } else {
 484                                 printk(KERN_DEBUG
 485                                        "%s: expecting oid 0x%x, received 0x%x.\n",
 486                                        ndev->name, (unsigned int) oid,
 487                                        frame->header->oid);
 488                                 kfree(frame);
 489                                 frame = NULL;
 490                         }
 491                 }
 492                 if (timeleft == 0) {
 493                         printk(KERN_DEBUG
 494                                 "%s: timeout waiting for mgmt response %lu, "
 495                                 "triggering device\n",
 496                                 ndev->name, timeout_left);
 497                         islpci_trigger(priv);
 498                 }
 499                 timeout_left += timeleft - wait_cycle_jiffies;
 500         }
 501         printk(KERN_WARNING "%s: timeout waiting for mgmt response\n",
 502                ndev->name);
 503
 504         /* TODO: we should reset the device here */
 505  out:
 506         finish_wait(&priv->mgmt_wqueue, &wait);
 507         mutex_unlock(&priv->mgmt_lock);
 508         return err;
 509 }
 510