Merge git://git.kernel.org/pub/scm/linux/kernel/git/czankel/xtensa-2.6
[linux-2.6] / drivers / net / enic / vnic_dev.c
1 /*
2  * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
3  * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
4  *
5  * This program is free software; you may redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; version 2 of the License.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
10  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
11  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
12  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
13  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
14  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
16  * SOFTWARE.
17  *
18  */
19
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/types.h>
23 #include <linux/pci.h>
24 #include <linux/delay.h>
25 #include <linux/if_ether.h>
26
27 #include "vnic_resource.h"
28 #include "vnic_devcmd.h"
29 #include "vnic_dev.h"
30 #include "vnic_stats.h"
31
32 struct vnic_res {
33         void __iomem *vaddr;
34         unsigned int count;
35 };
36
37 struct vnic_dev {
38         void *priv;
39         struct pci_dev *pdev;
40         struct vnic_res res[RES_TYPE_MAX];
41         enum vnic_dev_intr_mode intr_mode;
42         struct vnic_devcmd __iomem *devcmd;
43         struct vnic_devcmd_notify *notify;
44         struct vnic_devcmd_notify notify_copy;
45         dma_addr_t notify_pa;
46         u32 notify_sz;
47         u32 *linkstatus;
48         dma_addr_t linkstatus_pa;
49         struct vnic_stats *stats;
50         dma_addr_t stats_pa;
51         struct vnic_devcmd_fw_info *fw_info;
52         dma_addr_t fw_info_pa;
53 };
54
55 #define VNIC_MAX_RES_HDR_SIZE \
56         (sizeof(struct vnic_resource_header) + \
57         sizeof(struct vnic_resource) * RES_TYPE_MAX)
58 #define VNIC_RES_STRIDE 128
59
60 void *vnic_dev_priv(struct vnic_dev *vdev)
61 {
62         return vdev->priv;
63 }
64
65 static int vnic_dev_discover_res(struct vnic_dev *vdev,
66         struct vnic_dev_bar *bar)
67 {
68         struct vnic_resource_header __iomem *rh;
69         struct vnic_resource __iomem *r;
70         u8 type;
71
72         if (bar->len < VNIC_MAX_RES_HDR_SIZE) {
73                 printk(KERN_ERR "vNIC BAR0 res hdr length error\n");
74                 return -EINVAL;
75         }
76
77         rh = bar->vaddr;
78         if (!rh) {
79                 printk(KERN_ERR "vNIC BAR0 res hdr not mem-mapped\n");
80                 return -EINVAL;
81         }
82
83         if (ioread32(&rh->magic) != VNIC_RES_MAGIC ||
84             ioread32(&rh->version) != VNIC_RES_VERSION) {
85                 printk(KERN_ERR "vNIC BAR0 res magic/version error "
86                         "exp (%lx/%lx) curr (%x/%x)\n",
87                         VNIC_RES_MAGIC, VNIC_RES_VERSION,
88                         ioread32(&rh->magic), ioread32(&rh->version));
89                 return -EINVAL;
90         }
91
92         r = (struct vnic_resource __iomem *)(rh + 1);
93
94         while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {
95
96                 u8 bar_num = ioread8(&r->bar);
97                 u32 bar_offset = ioread32(&r->bar_offset);
98                 u32 count = ioread32(&r->count);
99                 u32 len;
100
101                 r++;
102
103                 if (bar_num != 0)  /* only mapping in BAR0 resources */
104                         continue;
105
106                 switch (type) {
107                 case RES_TYPE_WQ:
108                 case RES_TYPE_RQ:
109                 case RES_TYPE_CQ:
110                 case RES_TYPE_INTR_CTRL:
111                         /* each count is stride bytes long */
112                         len = count * VNIC_RES_STRIDE;
113                         if (len + bar_offset > bar->len) {
114                                 printk(KERN_ERR "vNIC BAR0 resource %d "
115                                         "out-of-bounds, offset 0x%x + "
116                                         "size 0x%x > bar len 0x%lx\n",
117                                         type, bar_offset,
118                                         len,
119                                         bar->len);
120                                 return -EINVAL;
121                         }
122                         break;
123                 case RES_TYPE_INTR_PBA_LEGACY:
124                 case RES_TYPE_DEVCMD:
125                         len = count;
126                         break;
127                 default:
128                         continue;
129                 }
130
131                 vdev->res[type].count = count;
132                 vdev->res[type].vaddr = (char __iomem *)bar->vaddr + bar_offset;
133         }
134
135         return 0;
136 }
137
138 unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev,
139         enum vnic_res_type type)
140 {
141         return vdev->res[type].count;
142 }
143
144 void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type,
145         unsigned int index)
146 {
147         if (!vdev->res[type].vaddr)
148                 return NULL;
149
150         switch (type) {
151         case RES_TYPE_WQ:
152         case RES_TYPE_RQ:
153         case RES_TYPE_CQ:
154         case RES_TYPE_INTR_CTRL:
155                 return (char __iomem *)vdev->res[type].vaddr +
156                         index * VNIC_RES_STRIDE;
157         default:
158                 return (char __iomem *)vdev->res[type].vaddr;
159         }
160 }
161
162 unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
163         unsigned int desc_count, unsigned int desc_size)
164 {
165         /* The base address of the desc rings must be 512 byte aligned.
166          * Descriptor count is aligned to groups of 32 descriptors.  A
167          * count of 0 means the maximum 4096 descriptors.  Descriptor
168          * size is aligned to 16 bytes.
169          */
170
171         unsigned int count_align = 32;
172         unsigned int desc_align = 16;
173
174         ring->base_align = 512;
175
176         if (desc_count == 0)
177                 desc_count = 4096;
178
179         ring->desc_count = ALIGN(desc_count, count_align);
180
181         ring->desc_size = ALIGN(desc_size, desc_align);
182
183         ring->size = ring->desc_count * ring->desc_size;
184         ring->size_unaligned = ring->size + ring->base_align;
185
186         return ring->size_unaligned;
187 }
188
189 void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring)
190 {
191         memset(ring->descs, 0, ring->size);
192 }
193
194 int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring,
195         unsigned int desc_count, unsigned int desc_size)
196 {
197         vnic_dev_desc_ring_size(ring, desc_count, desc_size);
198
199         ring->descs_unaligned = pci_alloc_consistent(vdev->pdev,
200                 ring->size_unaligned,
201                 &ring->base_addr_unaligned);
202
203         if (!ring->descs_unaligned) {
204                 printk(KERN_ERR
205                   "Failed to allocate ring (size=%d), aborting\n",
206                         (int)ring->size);
207                 return -ENOMEM;
208         }
209
210         ring->base_addr = ALIGN(ring->base_addr_unaligned,
211                 ring->base_align);
212         ring->descs = (u8 *)ring->descs_unaligned +
213                 (ring->base_addr - ring->base_addr_unaligned);
214
215         vnic_dev_clear_desc_ring(ring);
216
217         ring->desc_avail = ring->desc_count - 1;
218
219         return 0;
220 }
221
222 void vnic_dev_free_desc_ring(struct vnic_dev *vdev, struct vnic_dev_ring *ring)
223 {
224         if (ring->descs) {
225                 pci_free_consistent(vdev->pdev,
226                         ring->size_unaligned,
227                         ring->descs_unaligned,
228                         ring->base_addr_unaligned);
229                 ring->descs = NULL;
230         }
231 }
232
233 int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
234         u64 *a0, u64 *a1, int wait)
235 {
236         struct vnic_devcmd __iomem *devcmd = vdev->devcmd;
237         int delay;
238         u32 status;
239         int err;
240
241         status = ioread32(&devcmd->status);
242         if (status & STAT_BUSY) {
243                 printk(KERN_ERR "Busy devcmd %d\n", _CMD_N(cmd));
244                 return -EBUSY;
245         }
246
247         if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) {
248                 writeq(*a0, &devcmd->args[0]);
249                 writeq(*a1, &devcmd->args[1]);
250                 wmb();
251         }
252
253         iowrite32(cmd, &devcmd->cmd);
254
255         if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT))
256                         return 0;
257
258         for (delay = 0; delay < wait; delay++) {
259
260                 udelay(100);
261
262                 status = ioread32(&devcmd->status);
263                 if (!(status & STAT_BUSY)) {
264
265                         if (status & STAT_ERROR) {
266                                 err = (int)readq(&devcmd->args[0]);
267                                 if (err != ERR_ECMDUNKNOWN ||
268                                     cmd != CMD_CAPABILITY)
269                                         printk(KERN_ERR "Error %d devcmd %d\n",
270                                                 err, _CMD_N(cmd));
271                                 return err;
272                         }
273
274                         if (_CMD_DIR(cmd) & _CMD_DIR_READ) {
275                                 rmb();
276                                 *a0 = readq(&devcmd->args[0]);
277                                 *a1 = readq(&devcmd->args[1]);
278                         }
279
280                         return 0;
281                 }
282         }
283
284         printk(KERN_ERR "Timedout devcmd %d\n", _CMD_N(cmd));
285         return -ETIMEDOUT;
286 }
287
288 static int vnic_dev_capable(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd)
289 {
290         u64 a0 = (u32)cmd, a1 = 0;
291         int wait = 1000;
292         int err;
293
294         err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait);
295
296         return !(err || a0);
297 }
298
299 int vnic_dev_fw_info(struct vnic_dev *vdev,
300         struct vnic_devcmd_fw_info **fw_info)
301 {
302         u64 a0, a1 = 0;
303         int wait = 1000;
304         int err = 0;
305
306         if (!vdev->fw_info) {
307                 vdev->fw_info = pci_alloc_consistent(vdev->pdev,
308                         sizeof(struct vnic_devcmd_fw_info),
309                         &vdev->fw_info_pa);
310                 if (!vdev->fw_info)
311                         return -ENOMEM;
312
313                 a0 = vdev->fw_info_pa;
314
315                 /* only get fw_info once and cache it */
316                 err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO, &a0, &a1, wait);
317         }
318
319         *fw_info = vdev->fw_info;
320
321         return err;
322 }
323
324 int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, unsigned int size,
325         void *value)
326 {
327         u64 a0, a1;
328         int wait = 1000;
329         int err;
330
331         a0 = offset;
332         a1 = size;
333
334         err = vnic_dev_cmd(vdev, CMD_DEV_SPEC, &a0, &a1, wait);
335
336         switch (size) {
337         case 1: *(u8 *)value = (u8)a0; break;
338         case 2: *(u16 *)value = (u16)a0; break;
339         case 4: *(u32 *)value = (u32)a0; break;
340         case 8: *(u64 *)value = a0; break;
341         default: BUG(); break;
342         }
343
344         return err;
345 }
346
347 int vnic_dev_stats_clear(struct vnic_dev *vdev)
348 {
349         u64 a0 = 0, a1 = 0;
350         int wait = 1000;
351         return vnic_dev_cmd(vdev, CMD_STATS_CLEAR, &a0, &a1, wait);
352 }
353
354 int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats)
355 {
356         u64 a0, a1;
357         int wait = 1000;
358
359         if (!vdev->stats) {
360                 vdev->stats = pci_alloc_consistent(vdev->pdev,
361                         sizeof(struct vnic_stats), &vdev->stats_pa);
362                 if (!vdev->stats)
363                         return -ENOMEM;
364         }
365
366         *stats = vdev->stats;
367         a0 = vdev->stats_pa;
368         a1 = sizeof(struct vnic_stats);
369
370         return vnic_dev_cmd(vdev, CMD_STATS_DUMP, &a0, &a1, wait);
371 }
372
373 int vnic_dev_close(struct vnic_dev *vdev)
374 {
375         u64 a0 = 0, a1 = 0;
376         int wait = 1000;
377         return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait);
378 }
379
380 int vnic_dev_enable(struct vnic_dev *vdev)
381 {
382         u64 a0 = 0, a1 = 0;
383         int wait = 1000;
384         return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait);
385 }
386
387 int vnic_dev_disable(struct vnic_dev *vdev)
388 {
389         u64 a0 = 0, a1 = 0;
390         int wait = 1000;
391         return vnic_dev_cmd(vdev, CMD_DISABLE, &a0, &a1, wait);
392 }
393
394 int vnic_dev_open(struct vnic_dev *vdev, int arg)
395 {
396         u64 a0 = (u32)arg, a1 = 0;
397         int wait = 1000;
398         return vnic_dev_cmd(vdev, CMD_OPEN, &a0, &a1, wait);
399 }
400
401 int vnic_dev_open_done(struct vnic_dev *vdev, int *done)
402 {
403         u64 a0 = 0, a1 = 0;
404         int wait = 1000;
405         int err;
406
407         *done = 0;
408
409         err = vnic_dev_cmd(vdev, CMD_OPEN_STATUS, &a0, &a1, wait);
410         if (err)
411                 return err;
412
413         *done = (a0 == 0);
414
415         return 0;
416 }
417
418 int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg)
419 {
420         u64 a0 = (u32)arg, a1 = 0;
421         int wait = 1000;
422         return vnic_dev_cmd(vdev, CMD_SOFT_RESET, &a0, &a1, wait);
423 }
424
425 int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done)
426 {
427         u64 a0 = 0, a1 = 0;
428         int wait = 1000;
429         int err;
430
431         *done = 0;
432
433         err = vnic_dev_cmd(vdev, CMD_SOFT_RESET_STATUS, &a0, &a1, wait);
434         if (err)
435                 return err;
436
437         *done = (a0 == 0);
438
439         return 0;
440 }
441
442 int vnic_dev_hang_notify(struct vnic_dev *vdev)
443 {
444         u64 a0, a1;
445         int wait = 1000;
446         return vnic_dev_cmd(vdev, CMD_HANG_NOTIFY, &a0, &a1, wait);
447 }
448
449 int vnic_dev_mac_addr(struct vnic_dev *vdev, u8 *mac_addr)
450 {
451         u64 a0, a1;
452         int wait = 1000;
453         int err, i;
454
455         for (i = 0; i < ETH_ALEN; i++)
456                 mac_addr[i] = 0;
457
458         err = vnic_dev_cmd(vdev, CMD_MAC_ADDR, &a0, &a1, wait);
459         if (err)
460                 return err;
461
462         for (i = 0; i < ETH_ALEN; i++)
463                 mac_addr[i] = ((u8 *)&a0)[i];
464
465         return 0;
466 }
467
468 void vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
469         int broadcast, int promisc, int allmulti)
470 {
471         u64 a0, a1 = 0;
472         int wait = 1000;
473         int err;
474
475         a0 = (directed ? CMD_PFILTER_DIRECTED : 0) |
476              (multicast ? CMD_PFILTER_MULTICAST : 0) |
477              (broadcast ? CMD_PFILTER_BROADCAST : 0) |
478              (promisc ? CMD_PFILTER_PROMISCUOUS : 0) |
479              (allmulti ? CMD_PFILTER_ALL_MULTICAST : 0);
480
481         err = vnic_dev_cmd(vdev, CMD_PACKET_FILTER, &a0, &a1, wait);
482         if (err)
483                 printk(KERN_ERR "Can't set packet filter\n");
484 }
485
486 void vnic_dev_add_addr(struct vnic_dev *vdev, u8 *addr)
487 {
488         u64 a0 = 0, a1 = 0;
489         int wait = 1000;
490         int err;
491         int i;
492
493         for (i = 0; i < ETH_ALEN; i++)
494                 ((u8 *)&a0)[i] = addr[i];
495
496         err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
497         if (err)
498                 printk(KERN_ERR "Can't add addr [%pM], %d\n", addr, err);
499 }
500
501 void vnic_dev_del_addr(struct vnic_dev *vdev, u8 *addr)
502 {
503         u64 a0 = 0, a1 = 0;
504         int wait = 1000;
505         int err;
506         int i;
507
508         for (i = 0; i < ETH_ALEN; i++)
509                 ((u8 *)&a0)[i] = addr[i];
510
511         err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a0, &a1, wait);
512         if (err)
513                 printk(KERN_ERR "Can't del addr [%pM], %d\n", addr, err);
514 }
515
516 int vnic_dev_notify_set(struct vnic_dev *vdev, u16 intr)
517 {
518         u64 a0, a1;
519         int wait = 1000;
520         int r;
521
522         if (!vdev->notify) {
523                 vdev->notify = pci_alloc_consistent(vdev->pdev,
524                         sizeof(struct vnic_devcmd_notify),
525                         &vdev->notify_pa);
526                 if (!vdev->notify)
527                         return -ENOMEM;
528                 memset(vdev->notify, 0, sizeof(struct vnic_devcmd_notify));
529         }
530
531         a0 = vdev->notify_pa;
532         a1 = ((u64)intr << 32) & 0x0000ffff00000000ULL;
533         a1 += sizeof(struct vnic_devcmd_notify);
534
535         r = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
536         vdev->notify_sz = (r == 0) ? (u32)a1 : 0;
537         return r;
538 }
539
540 void vnic_dev_notify_unset(struct vnic_dev *vdev)
541 {
542         u64 a0, a1;
543         int wait = 1000;
544
545         a0 = 0;  /* paddr = 0 to unset notify buffer */
546         a1 = 0x0000ffff00000000ULL; /* intr num = -1 to unreg for intr */
547         a1 += sizeof(struct vnic_devcmd_notify);
548
549         vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
550         vdev->notify_sz = 0;
551 }
552
553 static int vnic_dev_notify_ready(struct vnic_dev *vdev)
554 {
555         u32 *words;
556         unsigned int nwords = vdev->notify_sz / 4;
557         unsigned int i;
558         u32 csum;
559
560         if (!vdev->notify || !vdev->notify_sz)
561                 return 0;
562
563         do {
564                 csum = 0;
565                 memcpy(&vdev->notify_copy, vdev->notify, vdev->notify_sz);
566                 words = (u32 *)&vdev->notify_copy;
567                 for (i = 1; i < nwords; i++)
568                         csum += words[i];
569         } while (csum != words[0]);
570
571         return 1;
572 }
573
574 int vnic_dev_init(struct vnic_dev *vdev, int arg)
575 {
576         u64 a0 = (u32)arg, a1 = 0;
577         int wait = 1000;
578         int r = 0;
579
580         if (vnic_dev_capable(vdev, CMD_INIT))
581                 r = vnic_dev_cmd(vdev, CMD_INIT, &a0, &a1, wait);
582         else {
583                 vnic_dev_cmd(vdev, CMD_INIT_v1, &a0, &a1, wait);
584                 if (a0 & CMD_INITF_DEFAULT_MAC) {
585                         // Emulate these for old CMD_INIT_v1 which
586                         // didn't pass a0 so no CMD_INITF_*.
587                         vnic_dev_cmd(vdev, CMD_MAC_ADDR, &a0, &a1, wait);
588                         vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
589                 }
590         }
591         return r;
592 }
593
594 int vnic_dev_link_status(struct vnic_dev *vdev)
595 {
596         if (vdev->linkstatus)
597                 return *vdev->linkstatus;
598
599         if (!vnic_dev_notify_ready(vdev))
600                 return 0;
601
602         return vdev->notify_copy.link_state;
603 }
604
605 u32 vnic_dev_port_speed(struct vnic_dev *vdev)
606 {
607         if (!vnic_dev_notify_ready(vdev))
608                 return 0;
609
610         return vdev->notify_copy.port_speed;
611 }
612
613 u32 vnic_dev_msg_lvl(struct vnic_dev *vdev)
614 {
615         if (!vnic_dev_notify_ready(vdev))
616                 return 0;
617
618         return vdev->notify_copy.msglvl;
619 }
620
621 u32 vnic_dev_mtu(struct vnic_dev *vdev)
622 {
623         if (!vnic_dev_notify_ready(vdev))
624                 return 0;
625
626         return vdev->notify_copy.mtu;
627 }
628
629 void vnic_dev_set_intr_mode(struct vnic_dev *vdev,
630         enum vnic_dev_intr_mode intr_mode)
631 {
632         vdev->intr_mode = intr_mode;
633 }
634
635 enum vnic_dev_intr_mode vnic_dev_get_intr_mode(
636         struct vnic_dev *vdev)
637 {
638         return vdev->intr_mode;
639 }
640
641 void vnic_dev_unregister(struct vnic_dev *vdev)
642 {
643         if (vdev) {
644                 if (vdev->notify)
645                         pci_free_consistent(vdev->pdev,
646                                 sizeof(struct vnic_devcmd_notify),
647                                 vdev->notify,
648                                 vdev->notify_pa);
649                 if (vdev->linkstatus)
650                         pci_free_consistent(vdev->pdev,
651                                 sizeof(u32),
652                                 vdev->linkstatus,
653                                 vdev->linkstatus_pa);
654                 if (vdev->stats)
655                         pci_free_consistent(vdev->pdev,
656                                 sizeof(struct vnic_dev),
657                                 vdev->stats, vdev->stats_pa);
658                 if (vdev->fw_info)
659                         pci_free_consistent(vdev->pdev,
660                                 sizeof(struct vnic_devcmd_fw_info),
661                                 vdev->fw_info, vdev->fw_info_pa);
662                 kfree(vdev);
663         }
664 }
665
666 struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev,
667         void *priv, struct pci_dev *pdev, struct vnic_dev_bar *bar)
668 {
669         if (!vdev) {
670                 vdev = kzalloc(sizeof(struct vnic_dev), GFP_ATOMIC);
671                 if (!vdev)
672                         return NULL;
673         }
674
675         vdev->priv = priv;
676         vdev->pdev = pdev;
677
678         if (vnic_dev_discover_res(vdev, bar))
679                 goto err_out;
680
681         vdev->devcmd = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD, 0);
682         if (!vdev->devcmd)
683                 goto err_out;
684
685         return vdev;
686
687 err_out:
688         vnic_dev_unregister(vdev);
689         return NULL;
690 }
691
692