[i386] Change [u]int32_t to [unsigned] int, rather than [unsigned] long
[people/asdlkf/gpxe.git] / src / drivers / net / mtnic.c
1 /*
2  * Copyright (c) 2007 Mellanox Technologies. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  *
32  */
33 #include <stdio.h>
34 #include <strings.h>
35 #include <errno.h>
36 #include <gpxe/malloc.h>
37 #include <gpxe/umalloc.h>
38 #include <byteswap.h>
39 #include <unistd.h>
40 #include <gpxe/pci.h>
41 #include <gpxe/ethernet.h>
42 #include <gpxe/netdevice.h>
43 #include <gpxe/iobuf.h>
44 #include "mtnic.h"
45
46
47 /*
48
49
50         mtnic.c - gPXE driver for Mellanox 10Gig ConnectX EN
51
52
53 */
54
55
56 /* (mcb30) - The Mellanox driver used "1" as a universal error code;
57  * this at least makes it a valid error number.
58  */
59 #define MTNIC_ERROR -EIO
60
61
62 /** Set port number to use
63  *
64  * 0 - port 1
65  * 1 - port 2
66  */
67 #define MTNIC_PORT_NUM 0
68 /* Note: for verbose printing do Make ... DEBUG=mtnic */
69
70
71
72
73 /********************************************************************
74 *
75 *       MTNIC allocation functions
76 *
77 *********************************************************************/
78 /**
79 * mtnic_alloc_aligned
80 *
81 * @v    unsigned int size       size
82 * @v    void **va               virtual address
83 * @v    u32 *pa                 physical address
84 * @v    u32 aligment            aligment
85 *
86 * Function allocate aligned buffer and put it's virtual address in 'va'
87 * and it's physical aligned address in 'pa'
88 */
89 static int
90 mtnic_alloc_aligned(unsigned int size, void **va, unsigned long *pa, unsigned int alignment)
91 {
92         *va = alloc_memblock(size, alignment);
93         if (!*va) {
94                 return MTNIC_ERROR;
95         }
96         *pa = (u32)virt_to_bus(*va);
97         return 0;
98 }
99
100
101
102 /**
103  *
104  * mtnic alloc command interface
105  *
106  */
107 static int
108 mtnic_alloc_cmdif(struct mtnic_priv *priv)
109 {
110         u32 bar = mtnic_pci_dev.dev.bar[0];
111
112         priv->hcr = ioremap(bar + MTNIC_HCR_BASE, MTNIC_HCR_SIZE);
113         if (!priv->hcr) {
114                 DBG("Couldn't map command register.");
115                 return MTNIC_ERROR;
116         }
117         mtnic_alloc_aligned(PAGE_SIZE, (void *)&priv->cmd.buf, &priv->cmd.mapping, PAGE_SIZE);
118         if (!priv->cmd.buf) {
119                 DBG("Error in allocating buffer for command interface\n");
120                 return MTNIC_ERROR;
121         }
122         return 0;
123 }
124
125 /**
126  * Free RX io buffers
127  */
128 static void
129 mtnic_free_io_buffers(struct mtnic_ring *ring)
130 {
131         int index;
132
133         for (; ring->cons <= ring->prod; ++ring->cons) {
134                 index = ring->cons & ring->size_mask;
135                 if (ring->iobuf[index])
136                         free_iob(ring->iobuf[index]);
137         }
138 }
139
140
141
142 /**
143  *
144  * mtnic alloc and attach io buffers
145  *
146  */
147 static int
148 mtnic_alloc_iobuf(struct mtnic_priv *priv, struct mtnic_ring *ring,
149                   unsigned int size)
150 {
151         struct mtnic_rx_desc *rx_desc_ptr = ring->buf;
152         u32 index;
153
154         while ((u32)(ring->prod - ring->cons) < UNITS_BUFFER_SIZE) {
155                 index = ring->prod & ring->size_mask;
156                 ring->iobuf[index] = alloc_iob(size);
157                 if (!&ring->iobuf[index]) {
158                         if (ring->prod <= (ring->cons + 1)) {
159                                 DBG("Error allocating Rx io "
160                                     "buffer number %x", index);
161                                 /* In case of error freeing io buffer */
162                                 mtnic_free_io_buffers(ring);
163                                 return MTNIC_ERROR;
164                         }
165
166                         break;
167                 }
168
169                 /* Attach io_buffer to descriptor */
170                 rx_desc_ptr = ring->buf +
171                         (sizeof(struct mtnic_rx_desc) * index);
172                 rx_desc_ptr->data.count = cpu_to_be32(size);
173                 rx_desc_ptr->data.mem_type = priv->fw.mem_type_snoop_be;
174                 rx_desc_ptr->data.addr_l = cpu_to_be32(
175                         virt_to_bus(ring->iobuf[index]->data));
176
177                 ++ ring->prod;
178         }
179
180         /* Update RX producer index (PI) */
181         ring->db->count = cpu_to_be32(ring->prod & 0xffff);
182         return 0;
183 }
184
185
186 /**
187  * mtnic alloc ring
188  *
189  *      Alloc and configure TX or RX ring
190  *
191  */
192 static int
193 mtnic_alloc_ring(struct mtnic_priv *priv, struct mtnic_ring *ring,
194                             u32 size, u16 stride, u16 cq, u8 is_rx)
195 {
196         unsigned int i;
197         int err;
198         struct mtnic_rx_desc *rx_desc;
199         struct mtnic_tx_desc *tx_desc;
200
201         ring->size = size; /* Number of descriptors */
202         ring->size_mask = size - 1;
203         ring->stride = stride; /* Size of each entry */
204         ring->cq = cq; /* CQ number associated with this ring */
205         ring->cons = 0;
206         ring->prod = 0;
207
208         /* Alloc descriptors buffer */
209         ring->buf_size = ring->size * ((is_rx) ? sizeof(struct mtnic_rx_desc) :
210                          sizeof(struct mtnic_tx_desc));
211         err = mtnic_alloc_aligned(ring->buf_size, (void *)&ring->buf,
212                             &ring->dma, PAGE_SIZE);
213         if (err) {
214                 DBG("Failed allocating descriptor ring sizeof %x\n",
215                     ring->buf_size);
216                 return MTNIC_ERROR;
217         }
218         memset(ring->buf, 0, ring->buf_size);
219
220         DBG("Allocated %s ring (addr:%p) - buf:%p size:%x"
221             "buf_size:%x dma:%lx\n",
222             is_rx ? "Rx" : "Tx", ring, ring->buf, ring->size,
223             ring->buf_size, ring->dma);
224
225
226         if (is_rx) { /* RX ring */
227                 /* Alloc doorbell */
228                 err = mtnic_alloc_aligned(sizeof(struct mtnic_cq_db_record),
229                                     (void *)&ring->db, &ring->db_dma, 32);
230                 if (err) {
231                         DBG("Failed allocating Rx ring doorbell record\n");
232                         free(ring->buf);
233                         return MTNIC_ERROR;
234                 }
235
236                 /* ==- Configure Descriptor -== */
237                 /* Init ctrl seg of rx desc */
238                 for (i = 0; i < UNITS_BUFFER_SIZE; ++i) {
239                         rx_desc = ring->buf +
240                                   (sizeof(struct mtnic_rx_desc) * i);
241                         /* Pre-link descriptor */
242                         rx_desc->next = cpu_to_be16(i + 1);
243                 }
244                 /*The last ctrl descriptor is '0' and points to the first one*/
245
246                 /* Alloc IO_BUFFERS */
247                 err = mtnic_alloc_iobuf(priv, ring, DEF_IOBUF_SIZE);
248                 if (err) {
249                         DBG("ERROR Allocating io buffer");
250                         free(ring->buf);
251                         return MTNIC_ERROR;
252                 }
253
254         } else { /* TX ring */
255                 /* Set initial ownership of all Tx Desc' to SW (1) */
256                 for (i = 0; i < ring->size; i++) {
257                         tx_desc = ring->buf + ring->stride * i;
258                         tx_desc->ctrl.op_own = cpu_to_be32(MTNIC_BIT_DESC_OWN);
259                 }
260                 /* DB */
261                 ring->db_offset = cpu_to_be32(
262                         ((u32) priv->fw.tx_offset[priv->port]) << 8);
263
264                 /* Map Tx+CQ doorbells */
265                 DBG("Mapping TxCQ doorbell at offset:0x%x\n",
266                     priv->fw.txcq_db_offset);
267                 ring->txcq_db = ioremap(mtnic_pci_dev.dev.bar[2] +
268                                 priv->fw.txcq_db_offset, PAGE_SIZE);
269                 if (!ring->txcq_db) {
270                         DBG("Couldn't map txcq doorbell, aborting...\n");
271                         free(ring->buf);
272                         return MTNIC_ERROR;
273                 }
274         }
275
276         return 0;
277 }
278
279
280
281 /**
282  * mtnic alloc CQ
283  *
284  *      Alloc and configure CQ.
285  *
286  */
287 static int
288 mtnic_alloc_cq(struct net_device *dev, int num, struct mtnic_cq *cq,
289                           u8 is_rx, u32 size, u32 offset_ind)
290 {
291         int err ;
292         unsigned int i;
293
294         cq->num = num;
295         cq->dev = dev;
296         cq->size = size;
297         cq->last = 0;
298         cq->is_rx = is_rx;
299         cq->offset_ind = offset_ind;
300
301         /* Alloc doorbell */
302         err = mtnic_alloc_aligned(sizeof(struct mtnic_cq_db_record),
303                             (void *)&cq->db, &cq->db_dma, 32);
304         if (err) {
305                 DBG("Failed allocating CQ doorbell record\n");
306                 return MTNIC_ERROR;
307         }
308         memset(cq->db, 0, sizeof(struct mtnic_cq_db_record));
309
310         /* Alloc CQEs buffer */
311         cq->buf_size = size * sizeof(struct mtnic_cqe);
312         err = mtnic_alloc_aligned(cq->buf_size,
313                             (void *)&cq->buf, &cq->dma, PAGE_SIZE);
314         if (err) {
315                 DBG("Failed allocating CQ buffer\n");
316                 free(cq->db);
317                 return MTNIC_ERROR;
318         }
319         memset(cq->buf, 0, cq->buf_size);
320         DBG("Allocated CQ (addr:%p) - size:%x buf:%p buf_size:%x "
321             "dma:%lx db:%p db_dma:%lx\n"
322             "cqn offset:%x \n", cq, cq->size, cq->buf,
323             cq->buf_size, cq->dma, cq->db,
324             cq->db_dma, offset_ind);
325
326
327         /* Set ownership of all CQEs to HW */
328         DBG("Setting HW ownership for CQ:%d\n", num);
329         for (i = 0; i < cq->size; i++) {
330                 /* Initial HW ownership is 1 */
331                 cq->buf[i].op_tr_own = MTNIC_BIT_CQ_OWN;
332         }
333         return 0;
334 }
335
336
337
338 /**
339  * mtnic_alloc_resources
340  *
341  *      Alloc and configure CQs, Tx, Rx
342  */
343 unsigned int
344 mtnic_alloc_resources(struct net_device *dev)
345 {
346         struct mtnic_priv *priv = netdev_priv(dev);
347         int err;
348         int cq_ind = 0;
349         int cq_offset = priv->fw.cq_offset;
350
351         /* Alloc 1st CQ */
352         err = mtnic_alloc_cq(dev, cq_ind, &priv->cq[cq_ind], 1 /* RX */,
353                              UNITS_BUFFER_SIZE, cq_offset + cq_ind);
354         if (err) {
355                 DBG("Failed allocating Rx CQ\n");
356                 return MTNIC_ERROR;
357         }
358
359         /* Alloc RX */
360         err = mtnic_alloc_ring(priv, &priv->rx_ring, UNITS_BUFFER_SIZE,
361                                sizeof(struct mtnic_rx_desc), cq_ind, /* RX */1);
362         if (err) {
363                 DBG("Failed allocating Rx Ring\n");
364                 goto cq0_error;
365         }
366
367         ++cq_ind;
368
369         /* alloc 2nd CQ */
370         err = mtnic_alloc_cq(dev, cq_ind, &priv->cq[cq_ind], 0 /* TX */,
371                              UNITS_BUFFER_SIZE, cq_offset + cq_ind);
372         if (err) {
373                 DBG("Failed allocating Tx CQ\n");
374                 goto rx_error;
375         }
376
377         /* Alloc TX */
378         err = mtnic_alloc_ring(priv, &priv->tx_ring, UNITS_BUFFER_SIZE,
379                                sizeof(struct mtnic_tx_desc), cq_ind, /* TX */ 0);
380         if (err) {
381                 DBG("Failed allocating Tx ring\n");
382                 goto cq1_error;
383         }
384
385         return 0;
386
387 cq1_error:
388         free(priv->cq[1].buf);
389         free(priv->cq[1].db);
390 rx_error:
391         free(priv->rx_ring.buf);
392         free(priv->rx_ring.db);
393         mtnic_free_io_buffers(&priv->rx_ring);
394 cq0_error:
395         free(priv->cq[0].buf);
396         free(priv->cq[0].db);
397
398         return MTNIC_ERROR;
399 }
400
401
402 /**
403  *  mtnic alloc_eq
404  *
405  * Note: EQ is not used by the driver but must be allocated
406  */
407 static int
408 mtnic_alloc_eq(struct mtnic_priv *priv)
409 {
410         int err;
411         unsigned int i;
412         struct mtnic_eqe *eqe_desc = NULL;
413
414         /* Allocating doorbell */
415         priv->eq_db = ioremap(mtnic_pci_dev.dev.bar[2] +
416                               priv->fw.eq_db_offset, sizeof(u32));
417         if (!priv->eq_db) {
418                 DBG("Couldn't map EQ doorbell, aborting...\n");
419                 return MTNIC_ERROR;
420         }
421
422         /* Allocating buffer */
423         priv->eq.size = NUM_EQES;
424         priv->eq.buf_size = priv->eq.size * sizeof(struct mtnic_eqe);
425         err = mtnic_alloc_aligned(priv->eq.buf_size, (void *)&priv->eq.buf,
426                             &priv->eq.dma, PAGE_SIZE);
427         if (err) {
428                 DBG("Failed allocating EQ buffer\n");
429                 iounmap(priv->eq_db);
430                 return MTNIC_ERROR;
431         }
432         memset(priv->eq.buf, 0, priv->eq.buf_size);
433
434         for (i = 0; i < priv->eq.size; i++)
435                 eqe_desc = priv->eq.buf + (sizeof(struct mtnic_eqe) * i);
436                 eqe_desc->own |= MTNIC_BIT_EQE_OWN;
437
438         mdelay(20);
439         return 0;
440 }
441
442
443
444
445
446
447
448
449
450
451
452 /********************************************************************
453 *
454 * Mtnic commands functions
455 * -=-=-=-=-=-=-=-=-=-=-=-=
456 *
457 *
458 *
459 *********************************************************************/
460 static inline int
461 cmdif_go_bit(struct mtnic_priv *priv)
462 {
463         struct mtnic_if_cmd_reg *hcr = priv->hcr;
464         u32 status;
465         int i;
466
467         for (i = 0; i < TBIT_RETRIES; i++) {
468                 status = be32_to_cpu(readl(&hcr->status_go_opcode));
469                 if ((status & MTNIC_BC_MASK(MTNIC_MASK_CMD_REG_T_BIT)) ==
470                     (priv->cmd.tbit << MTNIC_BC_OFF(MTNIC_MASK_CMD_REG_T_BIT))) {
471                         /* Read expected t-bit - now return go-bit value */
472                         return status & MTNIC_BC_MASK(MTNIC_MASK_CMD_REG_GO_BIT);
473                 }
474         }
475
476         DBG("Invalid tbit after %d retries!\n", TBIT_RETRIES);
477         return 1; /* Return busy... */
478 }
479
480 /* Base Command interface */
481 static int
482 mtnic_cmd(struct mtnic_priv *priv, void *in_imm,
483           void *out_imm, u32 in_modifier, u16 op)
484 {
485
486         struct mtnic_if_cmd_reg *hcr = priv->hcr;
487         int err = 0;
488         u32 out_param_h = 0;
489         u32 out_param_l = 0;
490         u32 in_param_h = 0;
491         u32 in_param_l = 0;
492
493
494         static u16 token = 0x8000;
495         u32 status;
496         unsigned int timeout = 0;
497
498         token++;
499
500         if (cmdif_go_bit(priv)) {
501                 DBG("GO BIT BUSY:%p.\n", hcr + 6);
502                 err = MTNIC_ERROR;
503                 goto out;
504         }
505         if (in_imm) {
506                 in_param_h = *((u32*)in_imm);
507                 in_param_l = *((u32*)in_imm + 1);
508         } else {
509                 in_param_l = cpu_to_be32(priv->cmd.mapping);
510         }
511         out_param_l = cpu_to_be32(priv->cmd.mapping);
512
513         /* writing to MCR */
514         writel(in_param_h,                      &hcr->in_param_h);
515         writel(in_param_l,                      &hcr->in_param_l);
516         writel((u32) cpu_to_be32(in_modifier),  &hcr->input_modifier);
517         writel(out_param_h,                     &hcr->out_param_h);
518         writel(out_param_l,                     &hcr->out_param_l);
519         writel((u32)cpu_to_be32(token << 16),   &hcr->token);
520         wmb();
521
522         /* flip toggle bit before each write to the HCR */
523         priv->cmd.tbit = !priv->cmd.tbit;
524         writel((u32)
525                 cpu_to_be32(MTNIC_BC_MASK(MTNIC_MASK_CMD_REG_GO_BIT) |
526                 (priv->cmd.tbit << MTNIC_BC_OFF(MTNIC_MASK_CMD_REG_T_BIT)) | op),
527                 &hcr->status_go_opcode);
528
529         while (cmdif_go_bit(priv) && (timeout <= GO_BIT_TIMEOUT)) {
530                 mdelay(1);
531                 ++timeout;
532         }
533
534         if (cmdif_go_bit(priv)) {
535                 DBG("Command opcode:0x%x token:0x%x TIMEOUT.\n", op, token);
536                 err = MTNIC_ERROR;
537                 goto out;
538         }
539
540         if (out_imm) {
541                 *((u32 *)out_imm) = readl(&hcr->out_param_h);
542                 *((u32 *)out_imm + 1) = readl(&hcr->out_param_l);
543         }
544
545         status = be32_to_cpu((u32)readl(&hcr->status_go_opcode)) >> 24;
546         /*DBG("Command opcode:0x%x token:0x%x returned:0x%lx\n",
547                   op, token, status);*/
548
549         if (status) {
550                 return status;
551         }
552
553 out:
554         return err;
555 }
556
557 /* MAP PAGES wrapper */
558 static int
559 mtnic_map_cmd(struct mtnic_priv *priv, u16 op, struct mtnic_pages pages)
560 {
561         unsigned int j;
562         u32 addr;
563         unsigned int len;
564         u32 *page_arr = priv->cmd.buf;
565         int nent = 0;
566         int err = 0;
567
568         memset(page_arr, 0, PAGE_SIZE);
569
570         len = PAGE_SIZE * pages.num;
571         pages.buf = (u32 *)umalloc(PAGE_SIZE * (pages.num + 1));
572         addr = PAGE_SIZE + ((virt_to_bus(pages.buf) & 0xfffff000) + PAGE_SIZE);
573         DBG("Mapping pages: size: %x address: %p\n", pages.num, pages.buf);
574
575         if (addr & (PAGE_MASK)) {
576                 DBG("Got FW area not aligned to %d (%llx/%x)\n",
577                     PAGE_SIZE, (u64) addr, len);
578                 return MTNIC_ERROR;
579         }
580
581         /* Function maps each PAGE seperately */
582         for (j = 0; j < len; j+= PAGE_SIZE) {
583                 page_arr[nent * 4 + 3] = cpu_to_be32(addr + j);
584                 if (++nent == MTNIC_MAILBOX_SIZE / 16) {
585                         err = mtnic_cmd(priv, NULL, NULL, nent, op);
586                         if (err)
587                                 return MTNIC_ERROR;
588                         nent = 0;
589                 }
590         }
591
592         if (nent)
593                 err = mtnic_cmd(priv, NULL, NULL, nent, op);
594
595         return err;
596 }
597
598
599
600 /*
601  * Query FW
602  */
603 static int
604 mtnic_QUERY_FW(struct mtnic_priv *priv)
605 {
606         int err;
607         struct mtnic_if_query_fw_out_mbox *cmd = priv->cmd.buf;
608
609         err = mtnic_cmd(priv, NULL, NULL, 0, MTNIC_IF_CMD_QUERY_FW);
610         if (err)
611                 return MTNIC_ERROR;
612
613         /* Get FW and interface versions */
614         priv->fw_ver = ((u64) be16_to_cpu(cmd->rev_maj) << 32) |
615                 ((u64) be16_to_cpu(cmd->rev_min) << 16) |
616                 (u64) be16_to_cpu(cmd->rev_smin);
617         priv->fw.ifc_rev = be16_to_cpu(cmd->ifc_rev);
618
619         /* Get offset for internal error reports (debug) */
620         priv->fw.err_buf.offset = be64_to_cpu(cmd->err_buf_start);
621         priv->fw.err_buf.size = be32_to_cpu(cmd->err_buf_size);
622
623         DBG("Error buf offset is %llx\n", priv->fw.err_buf.offset);
624
625         /* Get number of required FW (4k) pages */
626         priv->fw.fw_pages.num = be16_to_cpu(cmd->fw_pages);
627
628         return 0;
629 }
630
631
632 static int
633 mtnic_OPEN_NIC(struct mtnic_priv *priv)
634 {
635
636         struct mtnic_if_open_nic_in_mbox *open_nic = priv->cmd.buf;
637         u32 extra_pages[2] = {0};
638         int err;
639
640         memset(open_nic, 0, sizeof *open_nic);
641
642         /* port 1 */
643         open_nic->log_rx_p1 = 0;
644         open_nic->log_cq_p1 = 1;
645
646         open_nic->log_tx_p1 = 0;
647         open_nic->steer_p1 = MTNIC_IF_STEER_RSS;
648         /* MAC + VLAN - leave reserved */
649
650         /* port 2 */
651         open_nic->log_rx_p2 = 0;
652         open_nic->log_cq_p2 = 1;
653
654         open_nic->log_tx_p2 = 0;
655         open_nic->steer_p2 = MTNIC_IF_STEER_RSS;
656         /* MAC + VLAN - leave reserved */
657
658         err = mtnic_cmd(priv, NULL, extra_pages, 0, MTNIC_IF_CMD_OPEN_NIC);
659         priv->fw.extra_pages.num = be32_to_cpu(*(extra_pages+1));
660         DBG("Extra pages num is %x\n", priv->fw.extra_pages.num);
661         return err;
662 }
663
664 static int
665 mtnic_CONFIG_RX(struct mtnic_priv *priv)
666 {
667         struct mtnic_if_config_rx_in_imm config_rx;
668
669         memset(&config_rx, 0, sizeof config_rx);
670         return mtnic_cmd(priv, &config_rx, NULL, 0, MTNIC_IF_CMD_CONFIG_RX);
671 }
672
673 static int
674 mtnic_CONFIG_TX(struct mtnic_priv *priv)
675 {
676         struct mtnic_if_config_send_in_imm config_tx;
677
678         config_tx.enph_gpf = 0;
679         return mtnic_cmd(priv, &config_tx, NULL, 0, MTNIC_IF_CMD_CONFIG_TX);
680 }
681
682 static int
683 mtnic_HEART_BEAT(struct mtnic_priv *priv, u32 *link_state)
684 {
685         struct mtnic_if_heart_beat_out_imm heart_beat;
686
687         int err;
688         u32 flags;
689         err = mtnic_cmd(priv, NULL, &heart_beat, 0, MTNIC_IF_CMD_HEART_BEAT);
690         if (!err) {
691                 flags = be32_to_cpu(heart_beat.flags);
692                 if (flags & MTNIC_BC_MASK(MTNIC_MASK_HEAR_BEAT_INT_ERROR)) {
693                         DBG("Internal error detected\n");
694                         return MTNIC_ERROR;
695                 }
696                 *link_state = flags &
697                         ~((u32) MTNIC_BC_MASK(MTNIC_MASK_HEAR_BEAT_INT_ERROR));
698         }
699         return err;
700 }
701
702
703 /*
704  * Port commands
705  */
706
707 static int
708 mtnic_SET_PORT_DEFAULT_RING(struct mtnic_priv *priv, u8 port, u16 ring)
709 {
710         struct mtnic_if_set_port_default_ring_in_imm def_ring;
711
712         memset(&def_ring, 0, sizeof(def_ring));
713         def_ring.ring = ring;
714         return mtnic_cmd(priv, &def_ring, NULL, port + 1,
715                          MTNIC_IF_CMD_SET_PORT_DEFAULT_RING);
716 }
717
718 static int
719 mtnic_CONFIG_PORT_RSS_STEER(struct mtnic_priv *priv, int port)
720 {
721         memset(priv->cmd.buf, 0, PAGE_SIZE);
722         return  mtnic_cmd(priv, NULL, NULL, port + 1,
723                                MTNIC_IF_CMD_CONFIG_PORT_RSS_STEER);
724 }
725
726 static int
727 mtnic_SET_PORT_RSS_INDIRECTION(struct mtnic_priv *priv, int port)
728
729 {
730         memset(priv->cmd.buf, 0, PAGE_SIZE);
731         return mtnic_cmd(priv, NULL, NULL, port + 1,
732                                MTNIC_IF_CMD_SET_PORT_RSS_INDIRECTION);
733 }
734
735
736 /*
737  * Config commands
738  */
739 static int
740 mtnic_CONFIG_CQ(struct mtnic_priv *priv, int port,
741                     u16 cq_ind, struct mtnic_cq *cq)
742 {
743         struct mtnic_if_config_cq_in_mbox *config_cq = priv->cmd.buf;
744
745         memset(config_cq, 0, sizeof *config_cq);
746         config_cq->cq = cq_ind;
747         config_cq->size = fls(UNITS_BUFFER_SIZE - 1);
748         config_cq->offset = ((cq->dma) & (PAGE_MASK)) >> 6;
749         config_cq->db_record_addr_l = cpu_to_be32(cq->db_dma);
750         config_cq->page_address[1] = cpu_to_be32(cq->dma);
751         DBG("config cq address: %x dma_address: %lx"
752             "offset: %d size %d index: %d "
753             , config_cq->page_address[1],cq->dma,
754             config_cq->offset, config_cq->size, config_cq->cq );
755
756         return mtnic_cmd(priv, NULL, NULL, port + 1,
757                                MTNIC_IF_CMD_CONFIG_CQ);
758 }
759
760
761 static int
762 mtnic_CONFIG_TX_RING(struct mtnic_priv *priv, u8 port,
763                          u16 ring_ind, struct mtnic_ring *ring)
764 {
765         struct mtnic_if_config_send_ring_in_mbox *config_tx_ring = priv->cmd.buf;
766         memset(config_tx_ring, 0, sizeof *config_tx_ring);
767         config_tx_ring->ring = cpu_to_be16(ring_ind);
768         config_tx_ring->size = fls(UNITS_BUFFER_SIZE - 1);
769         config_tx_ring->cq = cpu_to_be16(ring->cq);
770         config_tx_ring->page_address[1] = cpu_to_be32(ring->dma);
771
772         return mtnic_cmd(priv, NULL, NULL, port + 1,
773                          MTNIC_IF_CMD_CONFIG_TX_RING);
774 }
775
776 static int
777 mtnic_CONFIG_RX_RING(struct mtnic_priv *priv, u8 port,
778                          u16 ring_ind, struct mtnic_ring *ring)
779 {
780         struct mtnic_if_config_rx_ring_in_mbox *config_rx_ring = priv->cmd.buf;
781         memset(config_rx_ring, 0, sizeof *config_rx_ring);
782         config_rx_ring->ring = ring_ind;
783                 MTNIC_BC_PUT(config_rx_ring->stride_size, fls(UNITS_BUFFER_SIZE - 1),
784                              MTNIC_MASK_CONFIG_RX_RING_SIZE);
785                 MTNIC_BC_PUT(config_rx_ring->stride_size, 1,
786                              MTNIC_MASK_CONFIG_RX_RING_STRIDE);
787         config_rx_ring->cq = cpu_to_be16(ring->cq);
788         config_rx_ring->db_record_addr_l = cpu_to_be32(ring->db_dma);
789
790         DBG("Config RX ring starting at address:%lx\n", ring->dma);
791
792         config_rx_ring->page_address[1] = cpu_to_be32(ring->dma);
793
794         return mtnic_cmd(priv, NULL, NULL, port + 1,
795                                MTNIC_IF_CMD_CONFIG_RX_RING);
796 }
797
798 static int
799 mtnic_CONFIG_EQ(struct mtnic_priv *priv)
800 {
801         struct mtnic_if_config_eq_in_mbox *eq = priv->cmd.buf;
802
803         if (priv->eq.dma & (PAGE_MASK)) {
804                 DBG("misalligned eq buffer:%lx\n",
805                     priv->eq.dma);
806                 return MTNIC_ERROR;
807         }
808
809         memset(eq, 0, sizeof *eq);
810         MTNIC_BC_PUT(eq->offset, priv->eq.dma >> 6, MTNIC_MASK_CONFIG_EQ_OFFSET);
811         MTNIC_BC_PUT(eq->size, fls(priv->eq.size - 1) - 1, MTNIC_MASK_CONFIG_EQ_SIZE);
812         MTNIC_BC_PUT(eq->int_vector, 0, MTNIC_MASK_CONFIG_EQ_INT_VEC);
813         eq->page_address[1] = cpu_to_be32(priv->eq.dma);
814
815         return mtnic_cmd(priv, NULL, NULL, 0, MTNIC_IF_CMD_CONFIG_EQ);
816 }
817
818
819
820
821 static int
822 mtnic_SET_RX_RING_ADDR(struct mtnic_priv *priv, u8 port, u64* mac)
823 {
824         struct mtnic_if_set_rx_ring_addr_in_imm ring_addr;
825         u32 modifier = ((u32) port + 1) << 16;
826
827         memset(&ring_addr, 0, sizeof(ring_addr));
828
829         ring_addr.mac_31_0 = cpu_to_be32(*mac & 0xffffffff);
830         ring_addr.mac_47_32 = cpu_to_be16((*mac >> 32) & 0xffff);
831         ring_addr.flags_vlan_id |= cpu_to_be16(
832                 MTNIC_BC_MASK(MTNIC_MASK_SET_RX_RING_ADDR_BY_MAC));
833
834         return mtnic_cmd(priv, &ring_addr, NULL, modifier, MTNIC_IF_CMD_SET_RX_RING_ADDR);
835 }
836
837 static int
838 mtnic_SET_PORT_STATE(struct mtnic_priv *priv, u8 port, u8 state)
839 {
840         struct mtnic_if_set_port_state_in_imm port_state;
841
842         port_state.state = state ? cpu_to_be32(
843                 MTNIC_BC_MASK(MTNIC_MASK_CONFIG_PORT_STATE)) : 0;
844         port_state.reserved = 0;
845         return mtnic_cmd(priv, &port_state, NULL, port + 1,
846                          MTNIC_IF_CMD_SET_PORT_STATE);
847 }
848
849 static int
850 mtnic_SET_PORT_MTU(struct mtnic_priv *priv, u8 port, u16 mtu)
851 {
852         struct mtnic_if_set_port_mtu_in_imm set_mtu;
853
854         memset(&set_mtu, 0, sizeof(set_mtu));
855         set_mtu.mtu = cpu_to_be16(mtu);
856         return mtnic_cmd(priv, &set_mtu, NULL, port + 1,
857                                 MTNIC_IF_CMD_SET_PORT_MTU);
858 }
859
860
861 static int
862 mtnic_CONFIG_PORT_VLAN_FILTER(struct mtnic_priv *priv, int port)
863 {
864         struct mtnic_if_config_port_vlan_filter_in_mbox *vlan_filter = priv->cmd.buf;
865
866         /* When no vlans are configured we disable the filter
867          * (i.e., pass all vlans) because we ignore them anyhow */
868         memset(vlan_filter, 0xff, sizeof(*vlan_filter));
869         return mtnic_cmd(priv, NULL, NULL, port + 1,
870                                 MTNIC_IF_CMD_CONFIG_PORT_VLAN_FILTER);
871 }
872
873
874 static int
875 mtnic_RELEASE_RESOURCE(struct mtnic_priv *priv, u8 port, u8 type, u8 index)
876 {
877         struct mtnic_if_release_resource_in_imm rel;
878         memset(&rel, 0, sizeof rel);
879         rel.index = index;
880         rel.type = type;
881         return mtnic_cmd(priv,
882                                 &rel, NULL, (type == MTNIC_IF_RESOURCE_TYPE_EQ) ?
883                                 0 : port + 1, MTNIC_IF_CMD_RELEASE_RESOURCE);
884 }
885
886
887 static int
888 mtnic_QUERY_CAP(struct mtnic_priv *priv, u8 index, u8 mod, u64 *result)
889 {
890         struct mtnic_if_query_cap_in_imm cap;
891         u32 out_imm[2];
892         int err;
893
894         memset(&cap, 0, sizeof cap);
895         cap.cap_index = index;
896         cap.cap_modifier = mod;
897         err = mtnic_cmd(priv, &cap, &out_imm, 0, MTNIC_IF_CMD_QUERY_CAP);
898
899         *((u32*)result) = be32_to_cpu(*(out_imm+1));
900         *((u32*)result + 1) = be32_to_cpu(*out_imm);
901
902         DBG("Called Query cap with index:0x%x mod:%d result:0x%llx"
903             " error:%d\n", index, mod, *result, err);
904         return err;
905 }
906
907
908 #define DO_QUERY_CAP(cap, mod, var)                             \
909                 err = mtnic_QUERY_CAP(priv, cap, mod, &result); \
910                 if (err)                                        \
911                         return err;                             \
912                 (var) = result
913
914 static int
915 mtnic_query_cap(struct mtnic_priv *priv)
916 {
917         int err = 0;
918         int i;
919         u64 result;
920
921         DO_QUERY_CAP(MTNIC_IF_CAP_NUM_PORTS, 0, priv->fw.num_ports);
922         for (i = 0; i < priv->fw.num_ports; i++) {
923                 DO_QUERY_CAP(MTNIC_IF_CAP_DEFAULT_MAC, i + 1, priv->fw.mac[i]);
924         }
925
926         return 0;
927 }
928
929 static int
930 mtnic_query_offsets(struct mtnic_priv *priv)
931 {
932         int err;
933         int i;
934         u64 result;
935
936         DO_QUERY_CAP(MTNIC_IF_CAP_MEM_KEY,
937                      MTNIC_IF_MEM_TYPE_SNOOP,
938                      priv->fw.mem_type_snoop_be);
939         priv->fw.mem_type_snoop_be = cpu_to_be32(priv->fw.mem_type_snoop_be);
940         DO_QUERY_CAP(MTNIC_IF_CAP_TX_CQ_DB_OFFSET, 0, priv->fw.txcq_db_offset);
941         DO_QUERY_CAP(MTNIC_IF_CAP_EQ_DB_OFFSET, 0, priv->fw.eq_db_offset);
942
943         for (i = 0; i < priv->fw.num_ports; i++) {
944                 DO_QUERY_CAP(MTNIC_IF_CAP_CQ_OFFSET, i + 1, priv->fw.cq_offset);
945                 DO_QUERY_CAP(MTNIC_IF_CAP_TX_OFFSET, i + 1, priv->fw.tx_offset[i]);
946                 DO_QUERY_CAP(MTNIC_IF_CAP_RX_OFFSET, i + 1, priv->fw.rx_offset[i]);
947                 DBG("--> Port %d CQ offset:0x%x\n", i, priv->fw.cq_offset);
948                 DBG("--> Port %d Tx offset:0x%x\n", i, priv->fw.tx_offset[i]);
949                 DBG("--> Port %d Rx offset:0x%x\n", i, priv->fw.rx_offset[i]);
950         }
951
952         mdelay(20);
953         return 0;
954 }
955
956
957
958
959
960
961
962
963
964
965
966 /********************************************************************
967 *
968 *       MTNIC initalization functions
969 *
970 *
971 *
972 *
973 *********************************************************************/
974
975 /**
976  * Reset device
977  */
978 void
979 mtnic_reset(void)
980 {
981         void *reset = ioremap(mtnic_pci_dev.dev.bar[0] + MTNIC_RESET_OFFSET, 4);
982         writel(cpu_to_be32(1), reset);
983         iounmap(reset);
984 }
985
986
987 /**
988  * Restore PCI config
989  */
990 static int
991 restore_config(void)
992 {
993         int i;
994         int rc;
995
996         for (i = 0; i < 64; ++i) {
997                 if (i != 22 && i != 23) {
998                         rc = pci_write_config_dword(mtnic_pci_dev.dev.dev,
999                                                     i << 2,
1000                                                     mtnic_pci_dev.dev.
1001                                                     dev_config_space[i]);
1002                         if (rc)
1003                                 return rc;
1004                 }
1005         }
1006         return 0;
1007 }
1008
1009
1010
1011 /**
1012  * Init PCI configuration
1013  */
1014 static int
1015 mtnic_init_pci(struct pci_device *dev)
1016 {
1017         int i;
1018         int err;
1019
1020         /* save bars */
1021         DBG("bus=%d devfn=0x%x", dev->bus, dev->devfn);
1022         for (i = 0; i < 6; ++i) {
1023                 mtnic_pci_dev.dev.bar[i] =
1024                     pci_bar_start(dev, PCI_BASE_ADDRESS_0 + (i << 2));
1025                 DBG("bar[%d]= 0x%08lx \n", i, mtnic_pci_dev.dev.bar[i]);
1026         }
1027
1028         /* save config space */
1029         for (i = 0; i < 64; ++i) {
1030                 err = pci_read_config_dword(dev, i << 2,
1031                                            &mtnic_pci_dev.dev.
1032                                            dev_config_space[i]);
1033                 if (err) {
1034                         DBG("Can not save configuration space");
1035                         return err;
1036                 }
1037         }
1038
1039         mtnic_pci_dev.dev.dev = dev;
1040
1041         return 0;
1042 }
1043
1044 /**
1045  *  Initial hardware
1046  */
1047 static inline
1048 int mtnic_init_card(struct net_device *dev)
1049 {
1050         struct mtnic_priv *priv = netdev_priv(dev);
1051         int err = 0;
1052
1053
1054         /* Set state */
1055         priv->state = CARD_DOWN;
1056         /* Set port */
1057         priv->port = MTNIC_PORT_NUM;
1058
1059         /* Alloc command interface */
1060         err = mtnic_alloc_cmdif(priv);
1061         if (err) {
1062                 DBG("Failed to init command interface, aborting.\n");
1063                 return MTNIC_ERROR;
1064         }
1065
1066
1067
1068         /**
1069          *  Bring up HW
1070          */
1071         err = mtnic_QUERY_FW(priv);
1072         if (err) {
1073                 DBG("QUERY_FW command failed, aborting.\n");
1074                 goto cmd_error;
1075         }
1076
1077         DBG("Command interface revision:%d\n", priv->fw.ifc_rev);
1078
1079         /* Allocate memory for FW and start it */
1080         err = mtnic_map_cmd(priv, MTNIC_IF_CMD_MAP_FW, priv->fw.fw_pages);
1081         if (err) {
1082                 DBG("Eror In MAP_FW\n");
1083                 if (priv->fw.fw_pages.buf)
1084                         free(priv->fw.fw_pages.buf);
1085                 goto cmd_error;
1086         }
1087
1088         /* Run firmware */
1089         err = mtnic_cmd(priv, NULL, NULL, 0, MTNIC_IF_CMD_RUN_FW);
1090         if (err) {
1091                 DBG("Eror In RUN FW\n");
1092                 goto map_fw_error;
1093         }
1094
1095         DBG("FW version:%d.%d.%d\n",
1096             (u16) (priv->fw_ver >> 32),
1097                 (u16) ((priv->fw_ver >> 16) & 0xffff),
1098                 (u16) (priv->fw_ver & 0xffff));
1099
1100
1101         /* Get device information */
1102         err = mtnic_query_cap(priv);
1103         if (err) {
1104                 DBG("Insufficient resources, aborting.\n");
1105                 goto map_fw_error;
1106         }
1107
1108         /* Open NIC */
1109         err = mtnic_OPEN_NIC(priv);
1110         if (err) {
1111                 DBG("Failed opening NIC, aborting.\n");
1112                 goto map_fw_error;
1113         }
1114
1115         /* Allocate and map pages worksace */
1116         err = mtnic_map_cmd(priv, MTNIC_IF_CMD_MAP_PAGES, priv->fw.extra_pages);
1117         if (err) {
1118                 DBG("Couldn't allocate %x FW extra pages, aborting.\n",
1119                     priv->fw.extra_pages.num);
1120                 if (priv->fw.extra_pages.buf)
1121                         free(priv->fw.extra_pages.buf);
1122                 goto map_fw_error;
1123         }
1124
1125         /* Get device offsets */
1126         err = mtnic_query_offsets(priv);
1127         if (err) {
1128                 DBG("Failed retrieving resource offests, aborting.\n");
1129                 free(priv->fw.extra_pages.buf);
1130                 goto map_extra_error;
1131         }
1132
1133
1134         /* Alloc EQ */
1135         err = mtnic_alloc_eq(priv);
1136         if (err) {
1137                 DBG("Failed init shared resources. error: %d\n", err);
1138                 goto map_extra_error;
1139         }
1140
1141         /* Configure HW */
1142         err = mtnic_CONFIG_EQ(priv);
1143         if (err) {
1144                 DBG("Failed configuring EQ\n");
1145                 goto eq_error;
1146         }
1147         err = mtnic_CONFIG_RX(priv);
1148         if (err) {
1149                 DBG("Failed Rx configuration\n");
1150                 goto eq_error;
1151         }
1152         err = mtnic_CONFIG_TX(priv);
1153         if (err) {
1154                 DBG("Failed Tx configuration\n");
1155                 goto eq_error;
1156         }
1157
1158         DBG("Activating port:%d\n", MTNIC_PORT_NUM + 1);
1159
1160         priv->state = CARD_INITIALIZED;
1161
1162         return 0;
1163
1164
1165 eq_error:
1166         iounmap(priv->eq_db);
1167         free(priv->eq.buf);
1168 map_extra_error:
1169         free(priv->fw.extra_pages.buf);
1170 map_fw_error:
1171         free(priv->fw.fw_pages.buf);
1172
1173 cmd_error:
1174         iounmap(priv->hcr);
1175         free(priv->cmd.buf);
1176         free(priv);
1177
1178         return MTNIC_ERROR;
1179 }
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190 /*******************************************************************
1191 *
1192 * Process functions
1193 *
1194 *       process compliations of TX and RX
1195 *
1196 *
1197 ********************************************************************/
1198 void mtnic_process_tx_cq(struct mtnic_priv *priv, struct net_device *dev,
1199                          struct mtnic_cq *cq)
1200 {
1201         struct mtnic_cqe *cqe = cq->buf;
1202         struct mtnic_ring *ring = &priv->tx_ring;
1203         u16 index;
1204
1205
1206         index = cq->last & (cq->size-1);
1207         cqe = &cq->buf[index];
1208
1209         /* Owner bit changes every round */
1210         while (XNOR(cqe->op_tr_own & MTNIC_BIT_CQ_OWN, cq->last & cq->size)) {
1211                 netdev_tx_complete (dev, ring->iobuf[index]);
1212                 ++cq->last;
1213                 index = cq->last & (cq->size-1);
1214                 cqe = &cq->buf[index];
1215         }
1216
1217         /* Update consumer index */
1218         cq->db->update_ci = cpu_to_be32(cq->last & 0xffffff);
1219         wmb(); /* ensure HW sees CQ consumer before we post new buffers */
1220         ring->cons = cq->last;
1221 }
1222
1223
1224 int mtnic_process_rx_cq(struct mtnic_priv *priv, struct net_device *dev, struct mtnic_cq *cq)
1225 {
1226         struct mtnic_cqe *cqe;
1227         struct mtnic_ring *ring = &priv->rx_ring;
1228         int index;
1229         int err;
1230         struct io_buffer *rx_iob;
1231
1232
1233         /* We assume a 1:1 mapping between CQEs and Rx descriptors, so Rx
1234          * descriptor offset can be deduced from the CQE index instead of
1235          * reading 'cqe->index' */
1236         index = cq->last & (cq->size-1);
1237         cqe = &cq->buf[index];
1238
1239         /* Process all completed CQEs */
1240         while (XNOR(cqe->op_tr_own & MTNIC_BIT_CQ_OWN, cq->last & cq->size)) {
1241                 /* Drop packet on bad receive or bad checksum */
1242                 if ((cqe->op_tr_own & 0x1f) == MTNIC_OPCODE_ERROR) {
1243                         DBG("CQE completed with error - vendor \n");
1244                         free_iob(ring->iobuf[index]);
1245                         goto next;
1246                 }
1247                 if (cqe->enc_bf & MTNIC_BIT_BAD_FCS) {
1248                         DBG("Accepted packet with bad FCS\n");
1249                         free_iob(ring->iobuf[index]);
1250                         goto next;
1251                 }
1252
1253                 /*
1254                  * Packet is OK - process it.
1255                  */
1256                 rx_iob = ring->iobuf[index];
1257                 iob_put(rx_iob, DEF_IOBUF_SIZE);
1258                 /* Add this packet to the receive queue. */
1259                 netdev_rx(dev, rx_iob);
1260                 ring->iobuf[index] = NULL;
1261
1262 next:
1263                 ++cq->last;
1264                 index = cq->last & (cq->size-1);
1265                 cqe = &cq->buf[index];
1266         }
1267
1268         /* Update consumer index */
1269         cq->db->update_ci = cpu_to_be32(cq->last & 0xffffff);
1270         wmb(); /* ensure HW sees CQ consumer before we post new buffers */
1271         ring->cons = cq->last;
1272
1273         if (ring->prod - ring->cons < (MAX_GAP_PROD_CONS)) {
1274                 err = mtnic_alloc_iobuf(priv, &priv->rx_ring, DEF_IOBUF_SIZE);
1275                 if (err) {
1276                         DBG("ERROR Allocating io buffer");
1277                         return MTNIC_ERROR;
1278                 }
1279         }
1280
1281         return 0;
1282 }
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299 /********************************************************************
1300 *
1301 * net_device functions
1302 *
1303 *
1304 *       open, poll, close, probe, disable, irq
1305 *
1306 *********************************************************************/
1307 static int
1308 mtnic_open(struct net_device *dev)
1309 {
1310         struct mtnic_priv *priv = netdev_priv(dev);
1311         int err = 0;
1312         struct mtnic_ring *ring;
1313         struct mtnic_cq *cq;
1314         int cq_ind = 0;
1315         u32 dev_link_state;
1316
1317         DBG("starting port:%d", priv->port);
1318
1319         /* Alloc and configure CQs, TX, RX */
1320         err = mtnic_alloc_resources(dev);
1321         if (err) {
1322                 DBG("Error allocating resources\n");
1323                 return MTNIC_ERROR;
1324         }
1325
1326         /* Pass CQs configuration to HW */
1327         for (cq_ind = 0; cq_ind < NUM_CQS; ++cq_ind) {
1328                 cq = &priv->cq[cq_ind];
1329                 err = mtnic_CONFIG_CQ(priv, priv->port, cq_ind, cq);
1330                 if (err) {
1331                         DBG("Failed configuring CQ:%d error %d\n",
1332                             cq_ind, err);
1333                         if (cq_ind)
1334                                 goto cq_error;
1335                         else
1336                                 return MTNIC_ERROR;
1337                 }
1338                 /* Update consumer index */
1339                 cq->db->update_ci = cpu_to_be32(cq->last & 0xffffff);
1340         }
1341
1342
1343         /* Pass Tx configuration to HW */
1344         ring = &priv->tx_ring;
1345         err = mtnic_CONFIG_TX_RING(priv, priv->port, 0, ring);
1346         if (err) {
1347                 DBG("Failed configuring Tx ring:0\n");
1348                 goto cq_error;
1349         }
1350
1351         /* Pass RX configuration to HW */
1352         ring = &priv->rx_ring;
1353         err = mtnic_CONFIG_RX_RING(priv, priv->port, 0, ring);
1354         if (err) {
1355                 DBG("Failed configuring Rx ring:0\n");
1356                 goto tx_error;
1357         }
1358
1359         /* Configure Rx steering */
1360         err = mtnic_CONFIG_PORT_RSS_STEER(priv, priv->port);
1361         if (!err)
1362                 err = mtnic_SET_PORT_RSS_INDIRECTION(priv, priv->port);
1363         if (err) {
1364                 DBG("Failed configuring RSS steering\n");
1365                 goto rx_error;
1366         }
1367
1368         /* Set the port default ring to ring 0 */
1369         err = mtnic_SET_PORT_DEFAULT_RING(priv, priv->port, 0);
1370         if (err) {
1371                 DBG("Failed setting default ring\n");
1372                 goto rx_error;
1373         }
1374
1375         /* Set Mac address */
1376         err = mtnic_SET_RX_RING_ADDR(priv, priv->port, &priv->fw.mac[priv->port]);
1377         if (err) {
1378                 DBG("Failed setting default MAC address\n");
1379                 goto rx_error;
1380         }
1381
1382         /* Set MTU  */
1383         err = mtnic_SET_PORT_MTU(priv, priv->port, DEF_MTU);
1384         if (err) {
1385                 DBG("Failed setting MTU\n");
1386                 goto rx_error;
1387         }
1388
1389         /* Configure VLAN filter */
1390         err = mtnic_CONFIG_PORT_VLAN_FILTER(priv, priv->port);
1391         if (err) {
1392                 DBG("Failed configuring VLAN filter\n");
1393                 goto rx_error;
1394         }
1395
1396         /* Bring up physical link */
1397         err = mtnic_SET_PORT_STATE(priv, priv->port, 1);
1398         if (err) {
1399                 DBG("Failed bringing up port\n");
1400                 goto rx_error;
1401         }
1402         mdelay(300); /* Let link state stabilize if cable was connected */
1403
1404         priv->state = CARD_UP;
1405
1406         err = mtnic_HEART_BEAT(priv, &dev_link_state);
1407         if (err) {
1408                 DBG("Failed getting device link state\n");
1409                 return MTNIC_ERROR;
1410         }
1411         if (!(dev_link_state & 0x3)) {
1412                 DBG("Link down, check cables and restart\n");
1413                 return MTNIC_ERROR;
1414         }
1415
1416         return 0;
1417
1418
1419 rx_error:
1420         err = mtnic_RELEASE_RESOURCE(priv, priv->port,
1421                                       MTNIC_IF_RESOURCE_TYPE_RX_RING, 0);
1422 tx_error:
1423         err |= mtnic_RELEASE_RESOURCE(priv, priv->port,
1424                                       MTNIC_IF_RESOURCE_TYPE_TX_RING, 0);
1425 cq_error:
1426         while (cq_ind) {
1427                 err |= mtnic_RELEASE_RESOURCE(priv, priv->port,
1428                                               MTNIC_IF_RESOURCE_TYPE_CQ, --cq_ind);
1429         }
1430         if (err)
1431                 DBG("Eror Releasing resources\n");
1432
1433         return MTNIC_ERROR;
1434 }
1435
1436
1437
1438 /** Check if we got completion for receive and transmit and
1439  * check the line with heart_bit command */
1440 static void
1441 mtnic_poll(struct net_device *dev)
1442 {
1443         struct mtnic_priv *priv = netdev_priv(dev);
1444         struct mtnic_cq *cq;
1445         u32 dev_link_state;
1446         int err;
1447         unsigned int i;
1448
1449         /* In case of an old error then return */
1450         if (priv->state != CARD_UP)
1451                 return;
1452
1453         /* We do not check the device every call _poll call,
1454                 since it will slow it down */
1455         if ((priv->poll_counter % ROUND_TO_CHECK) == 0) {
1456                 /* Check device */
1457                 err = mtnic_HEART_BEAT(priv, &dev_link_state);
1458                 if (err) {
1459                         DBG("Device has internal error\n");
1460                         priv->state = CARD_DOWN;
1461                         return;
1462                 }
1463                 if (!(dev_link_state & 0x3)) {
1464                         DBG("Link down, check cables and restart\n");
1465                         priv->state = CARD_DOWN;
1466                         return;
1467                 }
1468         }
1469
1470         /* Polling CQ */
1471         for (i = 0; i < NUM_CQS; i++) {
1472                 cq = &priv->cq[i]; //Passing on the 2 cqs.
1473
1474                 if (cq->is_rx) {
1475                         err = mtnic_process_rx_cq(priv, cq->dev, cq);
1476                         if (err) {
1477                                 priv->state = CARD_DOWN;
1478                                 DBG(" Error allocating RX buffers\n");
1479                                 return;
1480                         }
1481                 } else {
1482                         mtnic_process_tx_cq(priv, cq->dev, cq);
1483                 }
1484         }
1485         ++ priv->poll_counter;
1486 }
1487
1488 static int
1489 mtnic_transmit( struct net_device *dev, struct io_buffer *iobuf )
1490 {
1491
1492         struct mtnic_priv *priv = netdev_priv(dev);
1493         struct mtnic_ring *ring;
1494         struct mtnic_tx_desc *tx_desc;
1495         struct mtnic_data_seg *data;
1496         u32 index;
1497
1498         /* In case of an error then return */
1499         if (priv->state != CARD_UP)
1500                 return MTNIC_ERROR;
1501
1502         ring = &priv->tx_ring;
1503
1504         index = ring->prod & ring->size_mask;
1505         if ((ring->prod - ring->cons) >= ring->size) {
1506                 DBG("No space left for descriptors!!! cons: %x prod: %x\n",
1507                     ring->cons, ring->prod);
1508                 mdelay(5);
1509                 return MTNIC_ERROR;/* no space left */
1510         }
1511
1512         /* get current descriptor */
1513         tx_desc = ring->buf + (index * sizeof(struct mtnic_tx_desc));
1514
1515         /* Prepare ctrl segement */
1516         tx_desc->ctrl.size_vlan = cpu_to_be32(2);
1517         tx_desc->ctrl.flags = cpu_to_be32(MTNIC_BIT_TX_COMP |
1518                                           MTNIC_BIT_NO_ICRC);
1519         tx_desc->ctrl.op_own = cpu_to_be32(MTNIC_OPCODE_SEND) |
1520                                ((ring->prod & ring->size) ?
1521                                cpu_to_be32(MTNIC_BIT_DESC_OWN) : 0);
1522
1523         /* Prepare Data Seg */
1524         data = &tx_desc->data;
1525         data->addr_l = cpu_to_be32((u32)virt_to_bus(iobuf->data));
1526         data->count = cpu_to_be32(iob_len(iobuf));
1527         data->mem_type = priv->fw.mem_type_snoop_be;
1528
1529         /* Attach io_buffer */
1530         ring->iobuf[index] = iobuf;
1531
1532         /* Update producer index */
1533         ++ring->prod;
1534
1535         /* Ring doorbell! */
1536         wmb();
1537         writel((u32) ring->db_offset, &ring->txcq_db->send_db);
1538
1539         return 0;
1540 }
1541
1542
1543 static void
1544 mtnic_close(struct net_device *dev)
1545 {
1546         struct mtnic_priv *priv = netdev_priv(dev);
1547         int err = 0;
1548         DBG("Close called for port:%d\n", priv->port);
1549
1550         if (priv->state == CARD_UP) {
1551                 /* Disable port */
1552                 err |= mtnic_SET_PORT_STATE(priv, priv->port, 0);
1553                 /*
1554                  * Stop HW associated with this port
1555                  */
1556                 mdelay(5);
1557
1558                 /* Stop RX */
1559                 err |= mtnic_RELEASE_RESOURCE(priv, priv->port,
1560                                               MTNIC_IF_RESOURCE_TYPE_RX_RING, 0);
1561
1562                 /* Stop TX */
1563                 err |= mtnic_RELEASE_RESOURCE(priv, priv->port,
1564                                               MTNIC_IF_RESOURCE_TYPE_TX_RING, 0);
1565
1566                 /* Stop CQs */
1567                 err |= mtnic_RELEASE_RESOURCE(priv, priv->port,
1568                                                       MTNIC_IF_RESOURCE_TYPE_CQ, 0);
1569                 err |= mtnic_RELEASE_RESOURCE(priv, priv->port,
1570                                                       MTNIC_IF_RESOURCE_TYPE_CQ, 1);
1571                 if (err) {
1572                         DBG("Close reported error %d", err);
1573                 }
1574
1575                 /* Free memory */
1576                 free(priv->tx_ring.buf);
1577                 iounmap(priv->tx_ring.txcq_db);
1578                 free(priv->cq[1].buf);
1579                 free(priv->cq[1].db);
1580
1581                 /* Free RX buffers */
1582                 mtnic_free_io_buffers(&priv->rx_ring);
1583
1584                 free(priv->rx_ring.buf);
1585                 free(priv->rx_ring.db);
1586                 free(priv->cq[0].buf);
1587                 free(priv->cq[0].db);
1588
1589                 priv->state = CARD_INITIALIZED;
1590
1591         }
1592
1593
1594 }
1595
1596
1597 static void
1598 mtnic_disable(struct pci_device *pci)
1599 {
1600
1601         int err;
1602         struct net_device *dev = pci_get_drvdata(pci);
1603         struct mtnic_priv *priv = netdev_priv(dev);
1604
1605         /* Should NOT happen! but just in case */
1606         if (priv->state == CARD_UP)
1607                 mtnic_close(dev);
1608
1609         if (priv->state == CARD_INITIALIZED) {
1610                 err = mtnic_RELEASE_RESOURCE(priv, 0,
1611                                              MTNIC_IF_RESOURCE_TYPE_EQ, 0);
1612                 DBG("Calling MTNIC_CLOSE command\n");
1613                 err |= mtnic_cmd(priv, NULL, NULL, 0,
1614                                         MTNIC_IF_CMD_CLOSE_NIC);
1615                 if (err) {
1616                         DBG("Error Releasing resources %d\n", err);
1617                 }
1618
1619                 free(priv->cmd.buf);
1620                 iounmap(priv->hcr);
1621                 ufree((u32)priv->fw.fw_pages.buf);
1622                 ufree((u32)priv->fw.extra_pages.buf);
1623                 free(priv->eq.buf);
1624                 iounmap(priv->eq_db);
1625                 priv->state = CARD_DOWN;
1626         }
1627
1628         unregister_netdev(dev);
1629         netdev_nullify(dev);
1630         netdev_put(dev);
1631 }
1632
1633
1634
1635 static void
1636 mtnic_irq(struct net_device *netdev __unused, int enable __unused)
1637 {
1638         /* Not implemented */
1639 }
1640
1641
1642
1643 /** mtnic net device operations */
1644 static struct net_device_operations mtnic_operations = {
1645         .open           = mtnic_open,
1646         .close          = mtnic_close,
1647         .transmit       = mtnic_transmit,
1648         .poll           = mtnic_poll,
1649         .irq            = mtnic_irq,
1650 };
1651
1652
1653
1654
1655
1656
1657
1658 static int
1659 mtnic_probe(struct pci_device *pci,
1660               const struct pci_device_id *id __unused)
1661 {
1662         struct net_device *dev;
1663         struct mtnic_priv *priv;
1664         int err;
1665         u64 mac;
1666         u32 result = 0;
1667         void *dev_id;
1668         int i;
1669
1670         adjust_pci_device(pci);
1671
1672         err = mtnic_init_pci(pci);
1673         if (err) {
1674                 DBG("Error in pci_init\n");
1675                 return MTNIC_ERROR;
1676         }
1677
1678         mtnic_reset();
1679         mdelay(1000);
1680
1681         err = restore_config();
1682         if (err) {
1683                 DBG("Error restoring config\n");
1684                 return err;
1685         }
1686
1687         /* Checking MTNIC device ID */
1688         dev_id = ioremap(mtnic_pci_dev.dev.bar[0] +
1689                                MTNIC_DEVICE_ID_OFFSET, 4);
1690         result = ntohl(readl(dev_id));
1691         iounmap(dev_id);
1692         if (result != MTNIC_DEVICE_ID) {
1693                 DBG("Wrong Devie ID (0x%x) !!!", result);
1694                 return MTNIC_ERROR;
1695         }
1696
1697         /* Initializing net device */
1698         dev = alloc_etherdev(sizeof(struct mtnic_priv));
1699         if (dev == NULL) {
1700                 DBG("Net device allocation failed\n");
1701                 return MTNIC_ERROR;
1702         }
1703         /*
1704          * Initialize driver private data
1705          */
1706         priv = netdev_priv(dev);
1707         memset(priv, 0, sizeof(struct mtnic_priv));
1708         priv->dev = dev;
1709         priv->pdev = pci;
1710         priv->dev->dev = &pci->dev;
1711         /* Attach pci device */
1712         pci_set_drvdata(pci, priv->dev);
1713         netdev_init(dev, &mtnic_operations);
1714
1715
1716         /* Initialize hardware */
1717         err = mtnic_init_card(dev);
1718         if (err) {
1719                 DBG("Error in init_card\n");
1720                 return MTNIC_ERROR;
1721         }
1722
1723         /* Program the MAC address */
1724         mac = priv->fw.mac[priv->port];
1725         printf("Port %d  Mac address: 0x%12llx\n", MTNIC_PORT_NUM + 1, mac);
1726         for (i = 0;i < MAC_ADDRESS_SIZE; ++i) {
1727                 dev->ll_addr[MAC_ADDRESS_SIZE - i - 1] = mac & 0xFF;
1728                 mac = mac >> 8;
1729         }
1730
1731         /* Mark as link up; we don't yet handle link state */
1732         netdev_link_up ( dev );
1733
1734         if (register_netdev(dev)) {
1735                 DBG("Netdev registration failed\n");
1736                 return MTNIC_ERROR;
1737         }
1738
1739
1740         return 0;
1741 }
1742
1743
1744
1745
1746
1747
1748 static struct pci_device_id mtnic_nics[] = {
1749         PCI_ROM(0x15b3, 0x6368, "mtnic", "Mellanox MTNIC driver"),
1750 };
1751
1752 struct pci_driver mtnic_driver __pci_driver = {
1753         .ids = mtnic_nics,
1754         .id_count = sizeof(mtnic_nics) / sizeof(mtnic_nics[0]),
1755         .probe = mtnic_probe,
1756         .remove = mtnic_disable,
1757 };
1758