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