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