2 * Copyright (c) 2004, 2005 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 * $Id: mthca_main.c 1396 2004-12-28 04:10:27Z roland $
36 #include <linux/config.h>
37 #include <linux/version.h>
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/errno.h>
41 #include <linux/pci.h>
42 #include <linux/interrupt.h>
44 #include "mthca_dev.h"
45 #include "mthca_config_reg.h"
46 #include "mthca_cmd.h"
47 #include "mthca_profile.h"
48 #include "mthca_memfree.h"
50 MODULE_AUTHOR("Roland Dreier");
51 MODULE_DESCRIPTION("Mellanox InfiniBand HCA low-level driver");
52 MODULE_LICENSE("Dual BSD/GPL");
53 MODULE_VERSION(DRV_VERSION
);
58 module_param(msi_x
, int, 0444);
59 MODULE_PARM_DESC(msi_x
, "attempt to use MSI-X if nonzero");
62 module_param(msi
, int, 0444);
63 MODULE_PARM_DESC(msi
, "attempt to use MSI if nonzero");
65 #else /* CONFIG_PCI_MSI */
70 #endif /* CONFIG_PCI_MSI */
72 static const char mthca_version
[] __devinitdata
=
73 "ib_mthca: Mellanox InfiniBand HCA driver v"
74 DRV_VERSION
" (" DRV_RELDATE
")\n";
76 static struct mthca_profile default_profile
= {
83 .num_udav
= 1 << 15, /* Tavor only */
84 .fmr_reserved_mtts
= 1 << 18, /* Tavor only */
85 .uarc_size
= 1 << 18, /* Arbel only */
88 static int __devinit
mthca_tune_pci(struct mthca_dev
*mdev
)
93 /* First try to max out Read Byte Count */
94 cap
= pci_find_capability(mdev
->pdev
, PCI_CAP_ID_PCIX
);
96 if (pci_read_config_word(mdev
->pdev
, cap
+ PCI_X_CMD
, &val
)) {
97 mthca_err(mdev
, "Couldn't read PCI-X command register, "
101 val
= (val
& ~PCI_X_CMD_MAX_READ
) | (3 << 2);
102 if (pci_write_config_word(mdev
->pdev
, cap
+ PCI_X_CMD
, val
)) {
103 mthca_err(mdev
, "Couldn't write PCI-X command register, "
107 } else if (!(mdev
->mthca_flags
& MTHCA_FLAG_PCIE
))
108 mthca_info(mdev
, "No PCI-X capability, not setting RBC.\n");
110 cap
= pci_find_capability(mdev
->pdev
, PCI_CAP_ID_EXP
);
112 if (pci_read_config_word(mdev
->pdev
, cap
+ PCI_EXP_DEVCTL
, &val
)) {
113 mthca_err(mdev
, "Couldn't read PCI Express device control "
114 "register, aborting.\n");
117 val
= (val
& ~PCI_EXP_DEVCTL_READRQ
) | (5 << 12);
118 if (pci_write_config_word(mdev
->pdev
, cap
+ PCI_EXP_DEVCTL
, val
)) {
119 mthca_err(mdev
, "Couldn't write PCI Express device control "
120 "register, aborting.\n");
123 } else if (mdev
->mthca_flags
& MTHCA_FLAG_PCIE
)
124 mthca_info(mdev
, "No PCI Express capability, "
125 "not setting Max Read Request Size.\n");
130 static int __devinit
mthca_dev_lim(struct mthca_dev
*mdev
, struct mthca_dev_lim
*dev_lim
)
135 err
= mthca_QUERY_DEV_LIM(mdev
, dev_lim
, &status
);
137 mthca_err(mdev
, "QUERY_DEV_LIM command failed, aborting.\n");
141 mthca_err(mdev
, "QUERY_DEV_LIM returned status 0x%02x, "
142 "aborting.\n", status
);
145 if (dev_lim
->min_page_sz
> PAGE_SIZE
) {
146 mthca_err(mdev
, "HCA minimum page size of %d bigger than "
147 "kernel PAGE_SIZE of %ld, aborting.\n",
148 dev_lim
->min_page_sz
, PAGE_SIZE
);
151 if (dev_lim
->num_ports
> MTHCA_MAX_PORTS
) {
152 mthca_err(mdev
, "HCA has %d ports, but we only support %d, "
154 dev_lim
->num_ports
, MTHCA_MAX_PORTS
);
158 mdev
->limits
.num_ports
= dev_lim
->num_ports
;
159 mdev
->limits
.vl_cap
= dev_lim
->max_vl
;
160 mdev
->limits
.mtu_cap
= dev_lim
->max_mtu
;
161 mdev
->limits
.gid_table_len
= dev_lim
->max_gids
;
162 mdev
->limits
.pkey_table_len
= dev_lim
->max_pkeys
;
163 mdev
->limits
.local_ca_ack_delay
= dev_lim
->local_ca_ack_delay
;
164 mdev
->limits
.max_sg
= dev_lim
->max_sg
;
165 mdev
->limits
.reserved_qps
= dev_lim
->reserved_qps
;
166 mdev
->limits
.reserved_srqs
= dev_lim
->reserved_srqs
;
167 mdev
->limits
.reserved_eecs
= dev_lim
->reserved_eecs
;
168 mdev
->limits
.reserved_cqs
= dev_lim
->reserved_cqs
;
169 mdev
->limits
.reserved_eqs
= dev_lim
->reserved_eqs
;
170 mdev
->limits
.reserved_mtts
= dev_lim
->reserved_mtts
;
171 mdev
->limits
.reserved_mrws
= dev_lim
->reserved_mrws
;
172 mdev
->limits
.reserved_uars
= dev_lim
->reserved_uars
;
173 mdev
->limits
.reserved_pds
= dev_lim
->reserved_pds
;
175 /* IB_DEVICE_RESIZE_MAX_WR not supported by driver.
176 May be doable since hardware supports it for SRQ.
178 IB_DEVICE_N_NOTIFY_CQ is supported by hardware but not by driver.
180 IB_DEVICE_SRQ_RESIZE is supported by hardware but SRQ is not
181 supported by driver. */
182 mdev
->device_cap_flags
= IB_DEVICE_CHANGE_PHY_PORT
|
183 IB_DEVICE_PORT_ACTIVE_EVENT
|
184 IB_DEVICE_SYS_IMAGE_GUID
|
185 IB_DEVICE_RC_RNR_NAK_GEN
;
187 if (dev_lim
->flags
& DEV_LIM_FLAG_BAD_PKEY_CNTR
)
188 mdev
->device_cap_flags
|= IB_DEVICE_BAD_PKEY_CNTR
;
190 if (dev_lim
->flags
& DEV_LIM_FLAG_BAD_QKEY_CNTR
)
191 mdev
->device_cap_flags
|= IB_DEVICE_BAD_QKEY_CNTR
;
193 if (dev_lim
->flags
& DEV_LIM_FLAG_RAW_MULTI
)
194 mdev
->device_cap_flags
|= IB_DEVICE_RAW_MULTI
;
196 if (dev_lim
->flags
& DEV_LIM_FLAG_AUTO_PATH_MIG
)
197 mdev
->device_cap_flags
|= IB_DEVICE_AUTO_PATH_MIG
;
199 if (dev_lim
->flags
& DEV_LIM_FLAG_UD_AV_PORT_ENFORCE
)
200 mdev
->device_cap_flags
|= IB_DEVICE_UD_AV_PORT_ENFORCE
;
202 if (dev_lim
->flags
& DEV_LIM_FLAG_SRQ
)
203 mdev
->mthca_flags
|= MTHCA_FLAG_SRQ
;
208 static int __devinit
mthca_init_tavor(struct mthca_dev
*mdev
)
212 struct mthca_dev_lim dev_lim
;
213 struct mthca_profile profile
;
214 struct mthca_init_hca_param init_hca
;
215 struct mthca_adapter adapter
;
217 err
= mthca_SYS_EN(mdev
, &status
);
219 mthca_err(mdev
, "SYS_EN command failed, aborting.\n");
223 mthca_err(mdev
, "SYS_EN returned status 0x%02x, "
224 "aborting.\n", status
);
228 err
= mthca_QUERY_FW(mdev
, &status
);
230 mthca_err(mdev
, "QUERY_FW command failed, aborting.\n");
234 mthca_err(mdev
, "QUERY_FW returned status 0x%02x, "
235 "aborting.\n", status
);
239 err
= mthca_QUERY_DDR(mdev
, &status
);
241 mthca_err(mdev
, "QUERY_DDR command failed, aborting.\n");
245 mthca_err(mdev
, "QUERY_DDR returned status 0x%02x, "
246 "aborting.\n", status
);
251 err
= mthca_dev_lim(mdev
, &dev_lim
);
253 profile
= default_profile
;
254 profile
.num_uar
= dev_lim
.uar_size
/ PAGE_SIZE
;
255 profile
.uarc_size
= 0;
257 err
= mthca_make_profile(mdev
, &profile
, &dev_lim
, &init_hca
);
261 err
= mthca_INIT_HCA(mdev
, &init_hca
, &status
);
263 mthca_err(mdev
, "INIT_HCA command failed, aborting.\n");
267 mthca_err(mdev
, "INIT_HCA returned status 0x%02x, "
268 "aborting.\n", status
);
273 err
= mthca_QUERY_ADAPTER(mdev
, &adapter
, &status
);
275 mthca_err(mdev
, "QUERY_ADAPTER command failed, aborting.\n");
279 mthca_err(mdev
, "QUERY_ADAPTER returned status 0x%02x, "
280 "aborting.\n", status
);
285 mdev
->eq_table
.inta_pin
= adapter
.inta_pin
;
286 mdev
->rev_id
= adapter
.revision_id
;
291 mthca_CLOSE_HCA(mdev
, 0, &status
);
294 mthca_SYS_DIS(mdev
, &status
);
299 static int __devinit
mthca_load_fw(struct mthca_dev
*mdev
)
304 /* FIXME: use HCA-attached memory for FW if present */
306 mdev
->fw
.arbel
.fw_icm
=
307 mthca_alloc_icm(mdev
, mdev
->fw
.arbel
.fw_pages
,
308 GFP_HIGHUSER
| __GFP_NOWARN
);
309 if (!mdev
->fw
.arbel
.fw_icm
) {
310 mthca_err(mdev
, "Couldn't allocate FW area, aborting.\n");
314 err
= mthca_MAP_FA(mdev
, mdev
->fw
.arbel
.fw_icm
, &status
);
316 mthca_err(mdev
, "MAP_FA command failed, aborting.\n");
320 mthca_err(mdev
, "MAP_FA returned status 0x%02x, aborting.\n", status
);
324 err
= mthca_RUN_FW(mdev
, &status
);
326 mthca_err(mdev
, "RUN_FW command failed, aborting.\n");
330 mthca_err(mdev
, "RUN_FW returned status 0x%02x, aborting.\n", status
);
338 mthca_UNMAP_FA(mdev
, &status
);
341 mthca_free_icm(mdev
, mdev
->fw
.arbel
.fw_icm
);
345 static int __devinit
mthca_init_icm(struct mthca_dev
*mdev
,
346 struct mthca_dev_lim
*dev_lim
,
347 struct mthca_init_hca_param
*init_hca
,
354 err
= mthca_SET_ICM_SIZE(mdev
, icm_size
, &aux_pages
, &status
);
356 mthca_err(mdev
, "SET_ICM_SIZE command failed, aborting.\n");
360 mthca_err(mdev
, "SET_ICM_SIZE returned status 0x%02x, "
361 "aborting.\n", status
);
365 mthca_dbg(mdev
, "%lld KB of HCA context requires %lld KB aux memory.\n",
366 (unsigned long long) icm_size
>> 10,
367 (unsigned long long) aux_pages
<< 2);
369 mdev
->fw
.arbel
.aux_icm
= mthca_alloc_icm(mdev
, aux_pages
,
370 GFP_HIGHUSER
| __GFP_NOWARN
);
371 if (!mdev
->fw
.arbel
.aux_icm
) {
372 mthca_err(mdev
, "Couldn't allocate aux memory, aborting.\n");
376 err
= mthca_MAP_ICM_AUX(mdev
, mdev
->fw
.arbel
.aux_icm
, &status
);
378 mthca_err(mdev
, "MAP_ICM_AUX command failed, aborting.\n");
382 mthca_err(mdev
, "MAP_ICM_AUX returned status 0x%02x, aborting.\n", status
);
387 err
= mthca_map_eq_icm(mdev
, init_hca
->eqc_base
);
389 mthca_err(mdev
, "Failed to map EQ context memory, aborting.\n");
393 mdev
->mr_table
.mtt_table
= mthca_alloc_icm_table(mdev
, init_hca
->mtt_base
,
395 mdev
->limits
.num_mtt_segs
,
396 mdev
->limits
.reserved_mtts
, 1);
397 if (!mdev
->mr_table
.mtt_table
) {
398 mthca_err(mdev
, "Failed to map MTT context memory, aborting.\n");
403 mdev
->mr_table
.mpt_table
= mthca_alloc_icm_table(mdev
, init_hca
->mpt_base
,
404 dev_lim
->mpt_entry_sz
,
405 mdev
->limits
.num_mpts
,
406 mdev
->limits
.reserved_mrws
, 1);
407 if (!mdev
->mr_table
.mpt_table
) {
408 mthca_err(mdev
, "Failed to map MPT context memory, aborting.\n");
413 mdev
->qp_table
.qp_table
= mthca_alloc_icm_table(mdev
, init_hca
->qpc_base
,
414 dev_lim
->qpc_entry_sz
,
415 mdev
->limits
.num_qps
,
416 mdev
->limits
.reserved_qps
, 0);
417 if (!mdev
->qp_table
.qp_table
) {
418 mthca_err(mdev
, "Failed to map QP context memory, aborting.\n");
423 mdev
->qp_table
.eqp_table
= mthca_alloc_icm_table(mdev
, init_hca
->eqpc_base
,
424 dev_lim
->eqpc_entry_sz
,
425 mdev
->limits
.num_qps
,
426 mdev
->limits
.reserved_qps
, 0);
427 if (!mdev
->qp_table
.eqp_table
) {
428 mthca_err(mdev
, "Failed to map EQP context memory, aborting.\n");
433 mdev
->qp_table
.rdb_table
= mthca_alloc_icm_table(mdev
, init_hca
->rdb_base
,
434 MTHCA_RDB_ENTRY_SIZE
,
435 mdev
->limits
.num_qps
<<
436 mdev
->qp_table
.rdb_shift
,
438 if (!mdev
->qp_table
.rdb_table
) {
439 mthca_err(mdev
, "Failed to map RDB context memory, aborting\n");
444 mdev
->cq_table
.table
= mthca_alloc_icm_table(mdev
, init_hca
->cqc_base
,
445 dev_lim
->cqc_entry_sz
,
446 mdev
->limits
.num_cqs
,
447 mdev
->limits
.reserved_cqs
, 0);
448 if (!mdev
->cq_table
.table
) {
449 mthca_err(mdev
, "Failed to map CQ context memory, aborting.\n");
455 * It's not strictly required, but for simplicity just map the
456 * whole multicast group table now. The table isn't very big
457 * and it's a lot easier than trying to track ref counts.
459 mdev
->mcg_table
.table
= mthca_alloc_icm_table(mdev
, init_hca
->mc_base
,
460 MTHCA_MGM_ENTRY_SIZE
,
461 mdev
->limits
.num_mgms
+
462 mdev
->limits
.num_amgms
,
463 mdev
->limits
.num_mgms
+
464 mdev
->limits
.num_amgms
,
466 if (!mdev
->mcg_table
.table
) {
467 mthca_err(mdev
, "Failed to map MCG context memory, aborting.\n");
475 mthca_free_icm_table(mdev
, mdev
->cq_table
.table
);
478 mthca_free_icm_table(mdev
, mdev
->qp_table
.rdb_table
);
481 mthca_free_icm_table(mdev
, mdev
->qp_table
.eqp_table
);
484 mthca_free_icm_table(mdev
, mdev
->qp_table
.qp_table
);
487 mthca_free_icm_table(mdev
, mdev
->mr_table
.mpt_table
);
490 mthca_free_icm_table(mdev
, mdev
->mr_table
.mtt_table
);
493 mthca_unmap_eq_icm(mdev
);
496 mthca_UNMAP_ICM_AUX(mdev
, &status
);
499 mthca_free_icm(mdev
, mdev
->fw
.arbel
.aux_icm
);
504 static int __devinit
mthca_init_arbel(struct mthca_dev
*mdev
)
506 struct mthca_dev_lim dev_lim
;
507 struct mthca_profile profile
;
508 struct mthca_init_hca_param init_hca
;
509 struct mthca_adapter adapter
;
514 err
= mthca_QUERY_FW(mdev
, &status
);
516 mthca_err(mdev
, "QUERY_FW command failed, aborting.\n");
520 mthca_err(mdev
, "QUERY_FW returned status 0x%02x, "
521 "aborting.\n", status
);
525 err
= mthca_ENABLE_LAM(mdev
, &status
);
527 mthca_err(mdev
, "ENABLE_LAM command failed, aborting.\n");
530 if (status
== MTHCA_CMD_STAT_LAM_NOT_PRE
) {
531 mthca_dbg(mdev
, "No HCA-attached memory (running in MemFree mode)\n");
532 mdev
->mthca_flags
|= MTHCA_FLAG_NO_LAM
;
534 mthca_err(mdev
, "ENABLE_LAM returned status 0x%02x, "
535 "aborting.\n", status
);
539 err
= mthca_load_fw(mdev
);
541 mthca_err(mdev
, "Failed to start FW, aborting.\n");
545 err
= mthca_dev_lim(mdev
, &dev_lim
);
547 mthca_err(mdev
, "QUERY_DEV_LIM command failed, aborting.\n");
551 profile
= default_profile
;
552 profile
.num_uar
= dev_lim
.uar_size
/ PAGE_SIZE
;
553 profile
.num_udav
= 0;
555 icm_size
= mthca_make_profile(mdev
, &profile
, &dev_lim
, &init_hca
);
556 if ((int) icm_size
< 0) {
561 err
= mthca_init_icm(mdev
, &dev_lim
, &init_hca
, icm_size
);
565 err
= mthca_INIT_HCA(mdev
, &init_hca
, &status
);
567 mthca_err(mdev
, "INIT_HCA command failed, aborting.\n");
571 mthca_err(mdev
, "INIT_HCA returned status 0x%02x, "
572 "aborting.\n", status
);
577 err
= mthca_QUERY_ADAPTER(mdev
, &adapter
, &status
);
579 mthca_err(mdev
, "QUERY_ADAPTER command failed, aborting.\n");
583 mthca_err(mdev
, "QUERY_ADAPTER returned status 0x%02x, "
584 "aborting.\n", status
);
589 mdev
->eq_table
.inta_pin
= adapter
.inta_pin
;
590 mdev
->rev_id
= adapter
.revision_id
;
595 mthca_free_icm_table(mdev
, mdev
->cq_table
.table
);
596 mthca_free_icm_table(mdev
, mdev
->qp_table
.rdb_table
);
597 mthca_free_icm_table(mdev
, mdev
->qp_table
.eqp_table
);
598 mthca_free_icm_table(mdev
, mdev
->qp_table
.qp_table
);
599 mthca_free_icm_table(mdev
, mdev
->mr_table
.mpt_table
);
600 mthca_free_icm_table(mdev
, mdev
->mr_table
.mtt_table
);
601 mthca_unmap_eq_icm(mdev
);
603 mthca_UNMAP_ICM_AUX(mdev
, &status
);
604 mthca_free_icm(mdev
, mdev
->fw
.arbel
.aux_icm
);
607 mthca_UNMAP_FA(mdev
, &status
);
608 mthca_free_icm(mdev
, mdev
->fw
.arbel
.fw_icm
);
611 if (!(mdev
->mthca_flags
& MTHCA_FLAG_NO_LAM
))
612 mthca_DISABLE_LAM(mdev
, &status
);
617 static int __devinit
mthca_init_hca(struct mthca_dev
*mdev
)
619 if (mthca_is_memfree(mdev
))
620 return mthca_init_arbel(mdev
);
622 return mthca_init_tavor(mdev
);
625 static int __devinit
mthca_setup_hca(struct mthca_dev
*dev
)
630 MTHCA_INIT_DOORBELL_LOCK(&dev
->doorbell_lock
);
632 err
= mthca_init_uar_table(dev
);
634 mthca_err(dev
, "Failed to initialize "
635 "user access region table, aborting.\n");
639 err
= mthca_uar_alloc(dev
, &dev
->driver_uar
);
641 mthca_err(dev
, "Failed to allocate driver access region, "
643 goto err_uar_table_free
;
646 dev
->kar
= ioremap(dev
->driver_uar
.pfn
<< PAGE_SHIFT
, PAGE_SIZE
);
648 mthca_err(dev
, "Couldn't map kernel access region, "
654 err
= mthca_init_pd_table(dev
);
656 mthca_err(dev
, "Failed to initialize "
657 "protection domain table, aborting.\n");
661 err
= mthca_init_mr_table(dev
);
663 mthca_err(dev
, "Failed to initialize "
664 "memory region table, aborting.\n");
665 goto err_pd_table_free
;
668 err
= mthca_pd_alloc(dev
, &dev
->driver_pd
);
670 mthca_err(dev
, "Failed to create driver PD, "
672 goto err_mr_table_free
;
675 err
= mthca_init_eq_table(dev
);
677 mthca_err(dev
, "Failed to initialize "
678 "event queue table, aborting.\n");
682 err
= mthca_cmd_use_events(dev
);
684 mthca_err(dev
, "Failed to switch to event-driven "
685 "firmware commands, aborting.\n");
686 goto err_eq_table_free
;
689 err
= mthca_NOP(dev
, &status
);
691 mthca_err(dev
, "NOP command failed to generate interrupt (IRQ %d), aborting.\n",
692 dev
->mthca_flags
& MTHCA_FLAG_MSI_X
?
693 dev
->eq_table
.eq
[MTHCA_EQ_CMD
].msi_x_vector
:
695 if (dev
->mthca_flags
& (MTHCA_FLAG_MSI
| MTHCA_FLAG_MSI_X
))
696 mthca_err(dev
, "Try again with MSI/MSI-X disabled.\n");
698 mthca_err(dev
, "BIOS or ACPI interrupt routing problem?\n");
703 mthca_dbg(dev
, "NOP command IRQ test passed\n");
705 err
= mthca_init_cq_table(dev
);
707 mthca_err(dev
, "Failed to initialize "
708 "completion queue table, aborting.\n");
712 err
= mthca_init_qp_table(dev
);
714 mthca_err(dev
, "Failed to initialize "
715 "queue pair table, aborting.\n");
716 goto err_cq_table_free
;
719 err
= mthca_init_av_table(dev
);
721 mthca_err(dev
, "Failed to initialize "
722 "address vector table, aborting.\n");
723 goto err_qp_table_free
;
726 err
= mthca_init_mcg_table(dev
);
728 mthca_err(dev
, "Failed to initialize "
729 "multicast group table, aborting.\n");
730 goto err_av_table_free
;
736 mthca_cleanup_av_table(dev
);
739 mthca_cleanup_qp_table(dev
);
742 mthca_cleanup_cq_table(dev
);
745 mthca_cmd_use_polling(dev
);
748 mthca_cleanup_eq_table(dev
);
751 mthca_pd_free(dev
, &dev
->driver_pd
);
754 mthca_cleanup_mr_table(dev
);
757 mthca_cleanup_pd_table(dev
);
763 mthca_uar_free(dev
, &dev
->driver_uar
);
766 mthca_cleanup_uar_table(dev
);
770 static int __devinit
mthca_request_regions(struct pci_dev
*pdev
,
776 * We can't just use pci_request_regions() because the MSI-X
777 * table is right in the middle of the first BAR. If we did
778 * pci_request_region and grab all of the first BAR, then
779 * setting up MSI-X would fail, since the PCI core wants to do
780 * request_mem_region on the MSI-X vector table.
782 * So just request what we need right now, and request any
783 * other regions we need when setting up EQs.
785 if (!request_mem_region(pci_resource_start(pdev
, 0) + MTHCA_HCR_BASE
,
786 MTHCA_HCR_SIZE
, DRV_NAME
))
789 err
= pci_request_region(pdev
, 2, DRV_NAME
);
791 goto err_bar2_failed
;
794 err
= pci_request_region(pdev
, 4, DRV_NAME
);
796 goto err_bar4_failed
;
802 pci_release_region(pdev
, 2);
805 release_mem_region(pci_resource_start(pdev
, 0) + MTHCA_HCR_BASE
,
811 static void mthca_release_regions(struct pci_dev
*pdev
,
815 pci_release_region(pdev
, 4);
817 pci_release_region(pdev
, 2);
819 release_mem_region(pci_resource_start(pdev
, 0) + MTHCA_HCR_BASE
,
823 static int __devinit
mthca_enable_msi_x(struct mthca_dev
*mdev
)
825 struct msix_entry entries
[3];
828 entries
[0].entry
= 0;
829 entries
[1].entry
= 1;
830 entries
[2].entry
= 2;
832 err
= pci_enable_msix(mdev
->pdev
, entries
, ARRAY_SIZE(entries
));
835 mthca_info(mdev
, "Only %d MSI-X vectors available, "
836 "not using MSI-X\n", err
);
840 mdev
->eq_table
.eq
[MTHCA_EQ_COMP
].msi_x_vector
= entries
[0].vector
;
841 mdev
->eq_table
.eq
[MTHCA_EQ_ASYNC
].msi_x_vector
= entries
[1].vector
;
842 mdev
->eq_table
.eq
[MTHCA_EQ_CMD
].msi_x_vector
= entries
[2].vector
;
847 static void mthca_close_hca(struct mthca_dev
*mdev
)
851 mthca_CLOSE_HCA(mdev
, 0, &status
);
853 if (mthca_is_memfree(mdev
)) {
854 mthca_free_icm_table(mdev
, mdev
->cq_table
.table
);
855 mthca_free_icm_table(mdev
, mdev
->qp_table
.rdb_table
);
856 mthca_free_icm_table(mdev
, mdev
->qp_table
.eqp_table
);
857 mthca_free_icm_table(mdev
, mdev
->qp_table
.qp_table
);
858 mthca_free_icm_table(mdev
, mdev
->mr_table
.mpt_table
);
859 mthca_free_icm_table(mdev
, mdev
->mr_table
.mtt_table
);
860 mthca_unmap_eq_icm(mdev
);
862 mthca_UNMAP_ICM_AUX(mdev
, &status
);
863 mthca_free_icm(mdev
, mdev
->fw
.arbel
.aux_icm
);
865 mthca_UNMAP_FA(mdev
, &status
);
866 mthca_free_icm(mdev
, mdev
->fw
.arbel
.fw_icm
);
868 if (!(mdev
->mthca_flags
& MTHCA_FLAG_NO_LAM
))
869 mthca_DISABLE_LAM(mdev
, &status
);
871 mthca_SYS_DIS(mdev
, &status
);
874 /* Types of supported HCA */
877 ARBEL_COMPAT
, /* MT25208 in Tavor compat mode */
878 ARBEL_NATIVE
, /* MT25208 with extended features */
882 #define MTHCA_FW_VER(major, minor, subminor) \
883 (((u64) (major) << 32) | ((u64) (minor) << 16) | (u64) (subminor))
889 } mthca_hca_table
[] = {
890 [TAVOR
] = { .latest_fw
= MTHCA_FW_VER(3, 3, 2), .is_memfree
= 0, .is_pcie
= 0 },
891 [ARBEL_COMPAT
] = { .latest_fw
= MTHCA_FW_VER(4, 6, 2), .is_memfree
= 0, .is_pcie
= 1 },
892 [ARBEL_NATIVE
] = { .latest_fw
= MTHCA_FW_VER(5, 0, 1), .is_memfree
= 1, .is_pcie
= 1 },
893 [SINAI
] = { .latest_fw
= MTHCA_FW_VER(1, 0, 1), .is_memfree
= 1, .is_pcie
= 1 }
896 static int __devinit
mthca_init_one(struct pci_dev
*pdev
,
897 const struct pci_device_id
*id
)
899 static int mthca_version_printed
= 0;
902 struct mthca_dev
*mdev
;
904 if (!mthca_version_printed
) {
905 printk(KERN_INFO
"%s", mthca_version
);
906 ++mthca_version_printed
;
909 printk(KERN_INFO PFX
"Initializing %s (%s)\n",
910 pci_pretty_name(pdev
), pci_name(pdev
));
912 if (id
->driver_data
>= ARRAY_SIZE(mthca_hca_table
)) {
913 printk(KERN_ERR PFX
"%s (%s) has invalid driver data %lx\n",
914 pci_pretty_name(pdev
), pci_name(pdev
), id
->driver_data
);
918 err
= pci_enable_device(pdev
);
920 dev_err(&pdev
->dev
, "Cannot enable PCI device, "
926 * Check for BARs. We expect 0: 1MB, 2: 8MB, 4: DDR (may not
929 if (!(pci_resource_flags(pdev
, 0) & IORESOURCE_MEM
) ||
930 pci_resource_len(pdev
, 0) != 1 << 20) {
931 dev_err(&pdev
->dev
, "Missing DCS, aborting.");
933 goto err_disable_pdev
;
935 if (!(pci_resource_flags(pdev
, 2) & IORESOURCE_MEM
) ||
936 pci_resource_len(pdev
, 2) != 1 << 23) {
937 dev_err(&pdev
->dev
, "Missing UAR, aborting.");
939 goto err_disable_pdev
;
941 if (!(pci_resource_flags(pdev
, 4) & IORESOURCE_MEM
))
944 err
= mthca_request_regions(pdev
, ddr_hidden
);
946 dev_err(&pdev
->dev
, "Cannot obtain PCI resources, "
948 goto err_disable_pdev
;
951 pci_set_master(pdev
);
953 err
= pci_set_dma_mask(pdev
, DMA_64BIT_MASK
);
955 dev_warn(&pdev
->dev
, "Warning: couldn't set 64-bit PCI DMA mask.\n");
956 err
= pci_set_dma_mask(pdev
, DMA_32BIT_MASK
);
958 dev_err(&pdev
->dev
, "Can't set PCI DMA mask, aborting.\n");
962 err
= pci_set_consistent_dma_mask(pdev
, DMA_64BIT_MASK
);
964 dev_warn(&pdev
->dev
, "Warning: couldn't set 64-bit "
965 "consistent PCI DMA mask.\n");
966 err
= pci_set_consistent_dma_mask(pdev
, DMA_32BIT_MASK
);
968 dev_err(&pdev
->dev
, "Can't set consistent PCI DMA mask, "
974 mdev
= (struct mthca_dev
*) ib_alloc_device(sizeof *mdev
);
976 dev_err(&pdev
->dev
, "Device struct alloc failed, "
985 mdev
->mthca_flags
|= MTHCA_FLAG_DDR_HIDDEN
;
986 if (mthca_hca_table
[id
->driver_data
].is_memfree
)
987 mdev
->mthca_flags
|= MTHCA_FLAG_MEMFREE
;
988 if (mthca_hca_table
[id
->driver_data
].is_pcie
)
989 mdev
->mthca_flags
|= MTHCA_FLAG_PCIE
;
992 * Now reset the HCA before we touch the PCI capabilities or
993 * attempt a firmware command, since a boot ROM may have left
994 * the HCA in an undefined state.
996 err
= mthca_reset(mdev
);
998 mthca_err(mdev
, "Failed to reset HCA, aborting.\n");
1002 if (msi_x
&& !mthca_enable_msi_x(mdev
))
1003 mdev
->mthca_flags
|= MTHCA_FLAG_MSI_X
;
1004 if (msi
&& !(mdev
->mthca_flags
& MTHCA_FLAG_MSI_X
) &&
1005 !pci_enable_msi(pdev
))
1006 mdev
->mthca_flags
|= MTHCA_FLAG_MSI
;
1008 sema_init(&mdev
->cmd
.hcr_sem
, 1);
1009 sema_init(&mdev
->cmd
.poll_sem
, 1);
1010 mdev
->cmd
.use_events
= 0;
1012 mdev
->hcr
= ioremap(pci_resource_start(pdev
, 0) + MTHCA_HCR_BASE
, MTHCA_HCR_SIZE
);
1014 mthca_err(mdev
, "Couldn't map command register, "
1020 err
= mthca_tune_pci(mdev
);
1024 err
= mthca_init_hca(mdev
);
1028 if (mdev
->fw_ver
< mthca_hca_table
[id
->driver_data
].latest_fw
) {
1029 mthca_warn(mdev
, "HCA FW version %x.%x.%x is old (%x.%x.%x is current).\n",
1030 (int) (mdev
->fw_ver
>> 32), (int) (mdev
->fw_ver
>> 16) & 0xffff,
1031 (int) (mdev
->fw_ver
& 0xffff),
1032 (int) (mthca_hca_table
[id
->driver_data
].latest_fw
>> 32),
1033 (int) (mthca_hca_table
[id
->driver_data
].latest_fw
>> 16) & 0xffff,
1034 (int) (mthca_hca_table
[id
->driver_data
].latest_fw
& 0xffff));
1035 mthca_warn(mdev
, "If you have problems, try updating your HCA FW.\n");
1038 err
= mthca_setup_hca(mdev
);
1042 err
= mthca_register_device(mdev
);
1046 err
= mthca_create_agents(mdev
);
1048 goto err_unregister
;
1050 pci_set_drvdata(pdev
, mdev
);
1055 mthca_unregister_device(mdev
);
1058 mthca_cleanup_mcg_table(mdev
);
1059 mthca_cleanup_av_table(mdev
);
1060 mthca_cleanup_qp_table(mdev
);
1061 mthca_cleanup_cq_table(mdev
);
1062 mthca_cmd_use_polling(mdev
);
1063 mthca_cleanup_eq_table(mdev
);
1065 mthca_pd_free(mdev
, &mdev
->driver_pd
);
1067 mthca_cleanup_mr_table(mdev
);
1068 mthca_cleanup_pd_table(mdev
);
1069 mthca_cleanup_uar_table(mdev
);
1072 mthca_close_hca(mdev
);
1078 if (mdev
->mthca_flags
& MTHCA_FLAG_MSI_X
)
1079 pci_disable_msix(pdev
);
1080 if (mdev
->mthca_flags
& MTHCA_FLAG_MSI
)
1081 pci_disable_msi(pdev
);
1083 ib_dealloc_device(&mdev
->ib_dev
);
1086 mthca_release_regions(pdev
, ddr_hidden
);
1089 pci_disable_device(pdev
);
1090 pci_set_drvdata(pdev
, NULL
);
1094 static void __devexit
mthca_remove_one(struct pci_dev
*pdev
)
1096 struct mthca_dev
*mdev
= pci_get_drvdata(pdev
);
1101 mthca_free_agents(mdev
);
1102 mthca_unregister_device(mdev
);
1104 for (p
= 1; p
<= mdev
->limits
.num_ports
; ++p
)
1105 mthca_CLOSE_IB(mdev
, p
, &status
);
1107 mthca_cleanup_mcg_table(mdev
);
1108 mthca_cleanup_av_table(mdev
);
1109 mthca_cleanup_qp_table(mdev
);
1110 mthca_cleanup_cq_table(mdev
);
1111 mthca_cmd_use_polling(mdev
);
1112 mthca_cleanup_eq_table(mdev
);
1114 mthca_pd_free(mdev
, &mdev
->driver_pd
);
1116 mthca_cleanup_mr_table(mdev
);
1117 mthca_cleanup_pd_table(mdev
);
1120 mthca_uar_free(mdev
, &mdev
->driver_uar
);
1121 mthca_cleanup_uar_table(mdev
);
1123 mthca_close_hca(mdev
);
1127 if (mdev
->mthca_flags
& MTHCA_FLAG_MSI_X
)
1128 pci_disable_msix(pdev
);
1129 if (mdev
->mthca_flags
& MTHCA_FLAG_MSI
)
1130 pci_disable_msi(pdev
);
1132 ib_dealloc_device(&mdev
->ib_dev
);
1133 mthca_release_regions(pdev
, mdev
->mthca_flags
&
1134 MTHCA_FLAG_DDR_HIDDEN
);
1135 pci_disable_device(pdev
);
1136 pci_set_drvdata(pdev
, NULL
);
1140 static struct pci_device_id mthca_pci_table
[] = {
1141 { PCI_DEVICE(PCI_VENDOR_ID_MELLANOX
, PCI_DEVICE_ID_MELLANOX_TAVOR
),
1142 .driver_data
= TAVOR
},
1143 { PCI_DEVICE(PCI_VENDOR_ID_TOPSPIN
, PCI_DEVICE_ID_MELLANOX_TAVOR
),
1144 .driver_data
= TAVOR
},
1145 { PCI_DEVICE(PCI_VENDOR_ID_MELLANOX
, PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT
),
1146 .driver_data
= ARBEL_COMPAT
},
1147 { PCI_DEVICE(PCI_VENDOR_ID_TOPSPIN
, PCI_DEVICE_ID_MELLANOX_ARBEL_COMPAT
),
1148 .driver_data
= ARBEL_COMPAT
},
1149 { PCI_DEVICE(PCI_VENDOR_ID_MELLANOX
, PCI_DEVICE_ID_MELLANOX_ARBEL
),
1150 .driver_data
= ARBEL_NATIVE
},
1151 { PCI_DEVICE(PCI_VENDOR_ID_TOPSPIN
, PCI_DEVICE_ID_MELLANOX_ARBEL
),
1152 .driver_data
= ARBEL_NATIVE
},
1153 { PCI_DEVICE(PCI_VENDOR_ID_MELLANOX
, PCI_DEVICE_ID_MELLANOX_SINAI
),
1154 .driver_data
= SINAI
},
1155 { PCI_DEVICE(PCI_VENDOR_ID_TOPSPIN
, PCI_DEVICE_ID_MELLANOX_SINAI
),
1156 .driver_data
= SINAI
},
1157 { PCI_DEVICE(PCI_VENDOR_ID_MELLANOX
, PCI_DEVICE_ID_MELLANOX_SINAI_OLD
),
1158 .driver_data
= SINAI
},
1159 { PCI_DEVICE(PCI_VENDOR_ID_TOPSPIN
, PCI_DEVICE_ID_MELLANOX_SINAI_OLD
),
1160 .driver_data
= SINAI
},
1164 MODULE_DEVICE_TABLE(pci
, mthca_pci_table
);
1166 static struct pci_driver mthca_driver
= {
1168 .id_table
= mthca_pci_table
,
1169 .probe
= mthca_init_one
,
1170 .remove
= __devexit_p(mthca_remove_one
)
1173 static int __init
mthca_init(void)
1177 ret
= pci_register_driver(&mthca_driver
);
1178 return ret
< 0 ? ret
: 0;
1181 static void __exit
mthca_cleanup(void)
1183 pci_unregister_driver(&mthca_driver
);
1186 module_init(mthca_init
);
1187 module_exit(mthca_cleanup
);