1f931551bSRalph Campbell /* 2f931551bSRalph Campbell * Copyright (c) 2006, 2007, 2008, 2009, 2010 QLogic Corporation. 3f931551bSRalph Campbell * All rights reserved. 4f931551bSRalph Campbell * Copyright (c) 2003, 2004, 2005, 2006 PathScale, Inc. All rights reserved. 5f931551bSRalph Campbell * 6f931551bSRalph Campbell * This software is available to you under a choice of one of two 7f931551bSRalph Campbell * licenses. You may choose to be licensed under the terms of the GNU 8f931551bSRalph Campbell * General Public License (GPL) Version 2, available from the file 9f931551bSRalph Campbell * COPYING in the main directory of this source tree, or the 10f931551bSRalph Campbell * OpenIB.org BSD license below: 11f931551bSRalph Campbell * 12f931551bSRalph Campbell * Redistribution and use in source and binary forms, with or 13f931551bSRalph Campbell * without modification, are permitted provided that the following 14f931551bSRalph Campbell * conditions are met: 15f931551bSRalph Campbell * 16f931551bSRalph Campbell * - Redistributions of source code must retain the above 17f931551bSRalph Campbell * copyright notice, this list of conditions and the following 18f931551bSRalph Campbell * disclaimer. 19f931551bSRalph Campbell * 20f931551bSRalph Campbell * - Redistributions in binary form must reproduce the above 21f931551bSRalph Campbell * copyright notice, this list of conditions and the following 22f931551bSRalph Campbell * disclaimer in the documentation and/or other materials 23f931551bSRalph Campbell * provided with the distribution. 24f931551bSRalph Campbell * 25f931551bSRalph Campbell * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26f931551bSRalph Campbell * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27f931551bSRalph Campbell * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28f931551bSRalph Campbell * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29f931551bSRalph Campbell * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30f931551bSRalph Campbell * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31f931551bSRalph Campbell * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32f931551bSRalph Campbell * SOFTWARE. 33f931551bSRalph Campbell */ 34f931551bSRalph Campbell 35f931551bSRalph Campbell #include <linux/pci.h> 36f931551bSRalph Campbell #include <linux/netdevice.h> 37f931551bSRalph Campbell #include <linux/vmalloc.h> 38f931551bSRalph Campbell #include <linux/delay.h> 39f931551bSRalph Campbell #include <linux/idr.h> 40f931551bSRalph Campbell 41f931551bSRalph Campbell #include "qib.h" 42f931551bSRalph Campbell #include "qib_common.h" 43f931551bSRalph Campbell 44f931551bSRalph Campbell /* 45f931551bSRalph Campbell * min buffers we want to have per context, after driver 46f931551bSRalph Campbell */ 47f931551bSRalph Campbell #define QIB_MIN_USER_CTXT_BUFCNT 7 48f931551bSRalph Campbell 49f931551bSRalph Campbell #define QLOGIC_IB_R_SOFTWARE_MASK 0xFF 50f931551bSRalph Campbell #define QLOGIC_IB_R_SOFTWARE_SHIFT 24 51f931551bSRalph Campbell #define QLOGIC_IB_R_EMULATOR_MASK (1ULL<<62) 52f931551bSRalph Campbell 53f931551bSRalph Campbell /* 54f931551bSRalph Campbell * Number of ctxts we are configured to use (to allow for more pio 55f931551bSRalph Campbell * buffers per ctxt, etc.) Zero means use chip value. 56f931551bSRalph Campbell */ 57f931551bSRalph Campbell ushort qib_cfgctxts; 58f931551bSRalph Campbell module_param_named(cfgctxts, qib_cfgctxts, ushort, S_IRUGO); 59f931551bSRalph Campbell MODULE_PARM_DESC(cfgctxts, "Set max number of contexts to use"); 60f931551bSRalph Campbell 61f931551bSRalph Campbell /* 62f931551bSRalph Campbell * If set, do not write to any regs if avoidable, hack to allow 63f931551bSRalph Campbell * check for deranged default register values. 64f931551bSRalph Campbell */ 65f931551bSRalph Campbell ushort qib_mini_init; 66f931551bSRalph Campbell module_param_named(mini_init, qib_mini_init, ushort, S_IRUGO); 67f931551bSRalph Campbell MODULE_PARM_DESC(mini_init, "If set, do minimal diag init"); 68f931551bSRalph Campbell 69f931551bSRalph Campbell unsigned qib_n_krcv_queues; 70f931551bSRalph Campbell module_param_named(krcvqs, qib_n_krcv_queues, uint, S_IRUGO); 71f931551bSRalph Campbell MODULE_PARM_DESC(krcvqs, "number of kernel receive queues per IB port"); 72f931551bSRalph Campbell 73f931551bSRalph Campbell /* 74f931551bSRalph Campbell * qib_wc_pat parameter: 75f931551bSRalph Campbell * 0 is WC via MTRR 76f931551bSRalph Campbell * 1 is WC via PAT 77f931551bSRalph Campbell * If PAT initialization fails, code reverts back to MTRR 78f931551bSRalph Campbell */ 79f931551bSRalph Campbell unsigned qib_wc_pat = 1; /* default (1) is to use PAT, not MTRR */ 80f931551bSRalph Campbell module_param_named(wc_pat, qib_wc_pat, uint, S_IRUGO); 81f931551bSRalph Campbell MODULE_PARM_DESC(wc_pat, "enable write-combining via PAT mechanism"); 82f931551bSRalph Campbell 83f931551bSRalph Campbell struct workqueue_struct *qib_wq; 84f931551bSRalph Campbell struct workqueue_struct *qib_cq_wq; 85f931551bSRalph Campbell 86f931551bSRalph Campbell static void verify_interrupt(unsigned long); 87f931551bSRalph Campbell 88f931551bSRalph Campbell static struct idr qib_unit_table; 89f931551bSRalph Campbell u32 qib_cpulist_count; 90f931551bSRalph Campbell unsigned long *qib_cpulist; 91f931551bSRalph Campbell 92f931551bSRalph Campbell /* set number of contexts we'll actually use */ 93f931551bSRalph Campbell void qib_set_ctxtcnt(struct qib_devdata *dd) 94f931551bSRalph Campbell { 95f931551bSRalph Campbell if (!qib_cfgctxts) 96f931551bSRalph Campbell dd->cfgctxts = dd->ctxtcnt; 97f931551bSRalph Campbell else if (qib_cfgctxts < dd->num_pports) 98f931551bSRalph Campbell dd->cfgctxts = dd->ctxtcnt; 99f931551bSRalph Campbell else if (qib_cfgctxts <= dd->ctxtcnt) 100f931551bSRalph Campbell dd->cfgctxts = qib_cfgctxts; 101f931551bSRalph Campbell else 102f931551bSRalph Campbell dd->cfgctxts = dd->ctxtcnt; 103f931551bSRalph Campbell } 104f931551bSRalph Campbell 105f931551bSRalph Campbell /* 106f931551bSRalph Campbell * Common code for creating the receive context array. 107f931551bSRalph Campbell */ 108f931551bSRalph Campbell int qib_create_ctxts(struct qib_devdata *dd) 109f931551bSRalph Campbell { 110f931551bSRalph Campbell unsigned i; 111f931551bSRalph Campbell int ret; 112f931551bSRalph Campbell 113f931551bSRalph Campbell /* 114f931551bSRalph Campbell * Allocate full ctxtcnt array, rather than just cfgctxts, because 115f931551bSRalph Campbell * cleanup iterates across all possible ctxts. 116f931551bSRalph Campbell */ 117f931551bSRalph Campbell dd->rcd = kzalloc(sizeof(*dd->rcd) * dd->ctxtcnt, GFP_KERNEL); 118f931551bSRalph Campbell if (!dd->rcd) { 119f931551bSRalph Campbell qib_dev_err(dd, "Unable to allocate ctxtdata array, " 120f931551bSRalph Campbell "failing\n"); 121f931551bSRalph Campbell ret = -ENOMEM; 122f931551bSRalph Campbell goto done; 123f931551bSRalph Campbell } 124f931551bSRalph Campbell 125f931551bSRalph Campbell /* create (one or more) kctxt */ 126f931551bSRalph Campbell for (i = 0; i < dd->first_user_ctxt; ++i) { 127f931551bSRalph Campbell struct qib_pportdata *ppd; 128f931551bSRalph Campbell struct qib_ctxtdata *rcd; 129f931551bSRalph Campbell 130f931551bSRalph Campbell if (dd->skip_kctxt_mask & (1 << i)) 131f931551bSRalph Campbell continue; 132f931551bSRalph Campbell 133f931551bSRalph Campbell ppd = dd->pport + (i % dd->num_pports); 134f931551bSRalph Campbell rcd = qib_create_ctxtdata(ppd, i); 135f931551bSRalph Campbell if (!rcd) { 136f931551bSRalph Campbell qib_dev_err(dd, "Unable to allocate ctxtdata" 137f931551bSRalph Campbell " for Kernel ctxt, failing\n"); 138f931551bSRalph Campbell ret = -ENOMEM; 139f931551bSRalph Campbell goto done; 140f931551bSRalph Campbell } 141f931551bSRalph Campbell rcd->pkeys[0] = QIB_DEFAULT_P_KEY; 142f931551bSRalph Campbell rcd->seq_cnt = 1; 143f931551bSRalph Campbell } 144f931551bSRalph Campbell ret = 0; 145f931551bSRalph Campbell done: 146f931551bSRalph Campbell return ret; 147f931551bSRalph Campbell } 148f931551bSRalph Campbell 149f931551bSRalph Campbell /* 150f931551bSRalph Campbell * Common code for user and kernel context setup. 151f931551bSRalph Campbell */ 152f931551bSRalph Campbell struct qib_ctxtdata *qib_create_ctxtdata(struct qib_pportdata *ppd, u32 ctxt) 153f931551bSRalph Campbell { 154f931551bSRalph Campbell struct qib_devdata *dd = ppd->dd; 155f931551bSRalph Campbell struct qib_ctxtdata *rcd; 156f931551bSRalph Campbell 157f931551bSRalph Campbell rcd = kzalloc(sizeof(*rcd), GFP_KERNEL); 158f931551bSRalph Campbell if (rcd) { 159f931551bSRalph Campbell INIT_LIST_HEAD(&rcd->qp_wait_list); 160f931551bSRalph Campbell rcd->ppd = ppd; 161f931551bSRalph Campbell rcd->dd = dd; 162f931551bSRalph Campbell rcd->cnt = 1; 163f931551bSRalph Campbell rcd->ctxt = ctxt; 164f931551bSRalph Campbell dd->rcd[ctxt] = rcd; 165f931551bSRalph Campbell 166f931551bSRalph Campbell dd->f_init_ctxt(rcd); 167f931551bSRalph Campbell 168f931551bSRalph Campbell /* 169f931551bSRalph Campbell * To avoid wasting a lot of memory, we allocate 32KB chunks 170f931551bSRalph Campbell * of physically contiguous memory, advance through it until 171f931551bSRalph Campbell * used up and then allocate more. Of course, we need 172f931551bSRalph Campbell * memory to store those extra pointers, now. 32KB seems to 173f931551bSRalph Campbell * be the most that is "safe" under memory pressure 174f931551bSRalph Campbell * (creating large files and then copying them over 175f931551bSRalph Campbell * NFS while doing lots of MPI jobs). The OOM killer can 176f931551bSRalph Campbell * get invoked, even though we say we can sleep and this can 177f931551bSRalph Campbell * cause significant system problems.... 178f931551bSRalph Campbell */ 179f931551bSRalph Campbell rcd->rcvegrbuf_size = 0x8000; 180f931551bSRalph Campbell rcd->rcvegrbufs_perchunk = 181f931551bSRalph Campbell rcd->rcvegrbuf_size / dd->rcvegrbufsize; 182f931551bSRalph Campbell rcd->rcvegrbuf_chunks = (rcd->rcvegrcnt + 183f931551bSRalph Campbell rcd->rcvegrbufs_perchunk - 1) / 184f931551bSRalph Campbell rcd->rcvegrbufs_perchunk; 185f931551bSRalph Campbell } 186f931551bSRalph Campbell return rcd; 187f931551bSRalph Campbell } 188f931551bSRalph Campbell 189f931551bSRalph Campbell /* 190f931551bSRalph Campbell * Common code for initializing the physical port structure. 191f931551bSRalph Campbell */ 192f931551bSRalph Campbell void qib_init_pportdata(struct qib_pportdata *ppd, struct qib_devdata *dd, 193f931551bSRalph Campbell u8 hw_pidx, u8 port) 194f931551bSRalph Campbell { 195f931551bSRalph Campbell ppd->dd = dd; 196f931551bSRalph Campbell ppd->hw_pidx = hw_pidx; 197f931551bSRalph Campbell ppd->port = port; /* IB port number, not index */ 198f931551bSRalph Campbell 199f931551bSRalph Campbell spin_lock_init(&ppd->sdma_lock); 200f931551bSRalph Campbell spin_lock_init(&ppd->lflags_lock); 201f931551bSRalph Campbell init_waitqueue_head(&ppd->state_wait); 202f931551bSRalph Campbell 203f931551bSRalph Campbell init_timer(&ppd->symerr_clear_timer); 204f931551bSRalph Campbell ppd->symerr_clear_timer.function = qib_clear_symerror_on_linkup; 205f931551bSRalph Campbell ppd->symerr_clear_timer.data = (unsigned long)ppd; 206f931551bSRalph Campbell } 207f931551bSRalph Campbell 208f931551bSRalph Campbell static int init_pioavailregs(struct qib_devdata *dd) 209f931551bSRalph Campbell { 210f931551bSRalph Campbell int ret, pidx; 211f931551bSRalph Campbell u64 *status_page; 212f931551bSRalph Campbell 213f931551bSRalph Campbell dd->pioavailregs_dma = dma_alloc_coherent( 214f931551bSRalph Campbell &dd->pcidev->dev, PAGE_SIZE, &dd->pioavailregs_phys, 215f931551bSRalph Campbell GFP_KERNEL); 216f931551bSRalph Campbell if (!dd->pioavailregs_dma) { 217f931551bSRalph Campbell qib_dev_err(dd, "failed to allocate PIOavail reg area " 218f931551bSRalph Campbell "in memory\n"); 219f931551bSRalph Campbell ret = -ENOMEM; 220f931551bSRalph Campbell goto done; 221f931551bSRalph Campbell } 222f931551bSRalph Campbell 223f931551bSRalph Campbell /* 224f931551bSRalph Campbell * We really want L2 cache aligned, but for current CPUs of 225f931551bSRalph Campbell * interest, they are the same. 226f931551bSRalph Campbell */ 227f931551bSRalph Campbell status_page = (u64 *) 228f931551bSRalph Campbell ((char *) dd->pioavailregs_dma + 229f931551bSRalph Campbell ((2 * L1_CACHE_BYTES + 230f931551bSRalph Campbell dd->pioavregs * sizeof(u64)) & ~L1_CACHE_BYTES)); 231f931551bSRalph Campbell /* device status comes first, for backwards compatibility */ 232f931551bSRalph Campbell dd->devstatusp = status_page; 233f931551bSRalph Campbell *status_page++ = 0; 234f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) { 235f931551bSRalph Campbell dd->pport[pidx].statusp = status_page; 236f931551bSRalph Campbell *status_page++ = 0; 237f931551bSRalph Campbell } 238f931551bSRalph Campbell 239f931551bSRalph Campbell /* 240f931551bSRalph Campbell * Setup buffer to hold freeze and other messages, accessible to 241f931551bSRalph Campbell * apps, following statusp. This is per-unit, not per port. 242f931551bSRalph Campbell */ 243f931551bSRalph Campbell dd->freezemsg = (char *) status_page; 244f931551bSRalph Campbell *dd->freezemsg = 0; 245f931551bSRalph Campbell /* length of msg buffer is "whatever is left" */ 246f931551bSRalph Campbell ret = (char *) status_page - (char *) dd->pioavailregs_dma; 247f931551bSRalph Campbell dd->freezelen = PAGE_SIZE - ret; 248f931551bSRalph Campbell 249f931551bSRalph Campbell ret = 0; 250f931551bSRalph Campbell 251f931551bSRalph Campbell done: 252f931551bSRalph Campbell return ret; 253f931551bSRalph Campbell } 254f931551bSRalph Campbell 255f931551bSRalph Campbell /** 256f931551bSRalph Campbell * init_shadow_tids - allocate the shadow TID array 257f931551bSRalph Campbell * @dd: the qlogic_ib device 258f931551bSRalph Campbell * 259f931551bSRalph Campbell * allocate the shadow TID array, so we can qib_munlock previous 260f931551bSRalph Campbell * entries. It may make more sense to move the pageshadow to the 261f931551bSRalph Campbell * ctxt data structure, so we only allocate memory for ctxts actually 262f931551bSRalph Campbell * in use, since we at 8k per ctxt, now. 263f931551bSRalph Campbell * We don't want failures here to prevent use of the driver/chip, 264f931551bSRalph Campbell * so no return value. 265f931551bSRalph Campbell */ 266f931551bSRalph Campbell static void init_shadow_tids(struct qib_devdata *dd) 267f931551bSRalph Campbell { 268f931551bSRalph Campbell struct page **pages; 269f931551bSRalph Campbell dma_addr_t *addrs; 270f931551bSRalph Campbell 271f931551bSRalph Campbell pages = vmalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(struct page *)); 272f931551bSRalph Campbell if (!pages) { 273f931551bSRalph Campbell qib_dev_err(dd, "failed to allocate shadow page * " 274f931551bSRalph Campbell "array, no expected sends!\n"); 275f931551bSRalph Campbell goto bail; 276f931551bSRalph Campbell } 277f931551bSRalph Campbell 278f931551bSRalph Campbell addrs = vmalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(dma_addr_t)); 279f931551bSRalph Campbell if (!addrs) { 280f931551bSRalph Campbell qib_dev_err(dd, "failed to allocate shadow dma handle " 281f931551bSRalph Campbell "array, no expected sends!\n"); 282f931551bSRalph Campbell goto bail_free; 283f931551bSRalph Campbell } 284f931551bSRalph Campbell 285f931551bSRalph Campbell memset(pages, 0, dd->cfgctxts * dd->rcvtidcnt * sizeof(struct page *)); 286f931551bSRalph Campbell memset(addrs, 0, dd->cfgctxts * dd->rcvtidcnt * sizeof(dma_addr_t)); 287f931551bSRalph Campbell 288f931551bSRalph Campbell dd->pageshadow = pages; 289f931551bSRalph Campbell dd->physshadow = addrs; 290f931551bSRalph Campbell return; 291f931551bSRalph Campbell 292f931551bSRalph Campbell bail_free: 293f931551bSRalph Campbell vfree(pages); 294f931551bSRalph Campbell bail: 295f931551bSRalph Campbell dd->pageshadow = NULL; 296f931551bSRalph Campbell } 297f931551bSRalph Campbell 298f931551bSRalph Campbell /* 299f931551bSRalph Campbell * Do initialization for device that is only needed on 300f931551bSRalph Campbell * first detect, not on resets. 301f931551bSRalph Campbell */ 302f931551bSRalph Campbell static int loadtime_init(struct qib_devdata *dd) 303f931551bSRalph Campbell { 304f931551bSRalph Campbell int ret = 0; 305f931551bSRalph Campbell 306f931551bSRalph Campbell if (((dd->revision >> QLOGIC_IB_R_SOFTWARE_SHIFT) & 307f931551bSRalph Campbell QLOGIC_IB_R_SOFTWARE_MASK) != QIB_CHIP_SWVERSION) { 308f931551bSRalph Campbell qib_dev_err(dd, "Driver only handles version %d, " 309f931551bSRalph Campbell "chip swversion is %d (%llx), failng\n", 310f931551bSRalph Campbell QIB_CHIP_SWVERSION, 311f931551bSRalph Campbell (int)(dd->revision >> 312f931551bSRalph Campbell QLOGIC_IB_R_SOFTWARE_SHIFT) & 313f931551bSRalph Campbell QLOGIC_IB_R_SOFTWARE_MASK, 314f931551bSRalph Campbell (unsigned long long) dd->revision); 315f931551bSRalph Campbell ret = -ENOSYS; 316f931551bSRalph Campbell goto done; 317f931551bSRalph Campbell } 318f931551bSRalph Campbell 319f931551bSRalph Campbell if (dd->revision & QLOGIC_IB_R_EMULATOR_MASK) 320f931551bSRalph Campbell qib_devinfo(dd->pcidev, "%s", dd->boardversion); 321f931551bSRalph Campbell 322f931551bSRalph Campbell spin_lock_init(&dd->pioavail_lock); 323f931551bSRalph Campbell spin_lock_init(&dd->sendctrl_lock); 324f931551bSRalph Campbell spin_lock_init(&dd->uctxt_lock); 325f931551bSRalph Campbell spin_lock_init(&dd->qib_diag_trans_lock); 326f931551bSRalph Campbell spin_lock_init(&dd->eep_st_lock); 327f931551bSRalph Campbell mutex_init(&dd->eep_lock); 328f931551bSRalph Campbell 329f931551bSRalph Campbell if (qib_mini_init) 330f931551bSRalph Campbell goto done; 331f931551bSRalph Campbell 332f931551bSRalph Campbell ret = init_pioavailregs(dd); 333f931551bSRalph Campbell init_shadow_tids(dd); 334f931551bSRalph Campbell 335f931551bSRalph Campbell qib_get_eeprom_info(dd); 336f931551bSRalph Campbell 337f931551bSRalph Campbell /* setup time (don't start yet) to verify we got interrupt */ 338f931551bSRalph Campbell init_timer(&dd->intrchk_timer); 339f931551bSRalph Campbell dd->intrchk_timer.function = verify_interrupt; 340f931551bSRalph Campbell dd->intrchk_timer.data = (unsigned long) dd; 341f931551bSRalph Campbell 342f931551bSRalph Campbell done: 343f931551bSRalph Campbell return ret; 344f931551bSRalph Campbell } 345f931551bSRalph Campbell 346f931551bSRalph Campbell /** 347f931551bSRalph Campbell * init_after_reset - re-initialize after a reset 348f931551bSRalph Campbell * @dd: the qlogic_ib device 349f931551bSRalph Campbell * 350f931551bSRalph Campbell * sanity check at least some of the values after reset, and 351f931551bSRalph Campbell * ensure no receive or transmit (explictly, in case reset 352f931551bSRalph Campbell * failed 353f931551bSRalph Campbell */ 354f931551bSRalph Campbell static int init_after_reset(struct qib_devdata *dd) 355f931551bSRalph Campbell { 356f931551bSRalph Campbell int i; 357f931551bSRalph Campbell 358f931551bSRalph Campbell /* 359f931551bSRalph Campbell * Ensure chip does no sends or receives, tail updates, or 360f931551bSRalph Campbell * pioavail updates while we re-initialize. This is mostly 361f931551bSRalph Campbell * for the driver data structures, not chip registers. 362f931551bSRalph Campbell */ 363f931551bSRalph Campbell for (i = 0; i < dd->num_pports; ++i) { 364f931551bSRalph Campbell /* 365f931551bSRalph Campbell * ctxt == -1 means "all contexts". Only really safe for 366f931551bSRalph Campbell * _dis_abling things, as here. 367f931551bSRalph Campbell */ 368f931551bSRalph Campbell dd->f_rcvctrl(dd->pport + i, QIB_RCVCTRL_CTXT_DIS | 369f931551bSRalph Campbell QIB_RCVCTRL_INTRAVAIL_DIS | 370f931551bSRalph Campbell QIB_RCVCTRL_TAILUPD_DIS, -1); 371f931551bSRalph Campbell /* Redundant across ports for some, but no big deal. */ 372f931551bSRalph Campbell dd->f_sendctrl(dd->pport + i, QIB_SENDCTRL_SEND_DIS | 373f931551bSRalph Campbell QIB_SENDCTRL_AVAIL_DIS); 374f931551bSRalph Campbell } 375f931551bSRalph Campbell 376f931551bSRalph Campbell return 0; 377f931551bSRalph Campbell } 378f931551bSRalph Campbell 379f931551bSRalph Campbell static void enable_chip(struct qib_devdata *dd) 380f931551bSRalph Campbell { 381f931551bSRalph Campbell u64 rcvmask; 382f931551bSRalph Campbell int i; 383f931551bSRalph Campbell 384f931551bSRalph Campbell /* 385f931551bSRalph Campbell * Enable PIO send, and update of PIOavail regs to memory. 386f931551bSRalph Campbell */ 387f931551bSRalph Campbell for (i = 0; i < dd->num_pports; ++i) 388f931551bSRalph Campbell dd->f_sendctrl(dd->pport + i, QIB_SENDCTRL_SEND_ENB | 389f931551bSRalph Campbell QIB_SENDCTRL_AVAIL_ENB); 390f931551bSRalph Campbell /* 391f931551bSRalph Campbell * Enable kernel ctxts' receive and receive interrupt. 392f931551bSRalph Campbell * Other ctxts done as user opens and inits them. 393f931551bSRalph Campbell */ 394f931551bSRalph Campbell rcvmask = QIB_RCVCTRL_CTXT_ENB | QIB_RCVCTRL_INTRAVAIL_ENB; 395f931551bSRalph Campbell rcvmask |= (dd->flags & QIB_NODMA_RTAIL) ? 396f931551bSRalph Campbell QIB_RCVCTRL_TAILUPD_DIS : QIB_RCVCTRL_TAILUPD_ENB; 397f931551bSRalph Campbell for (i = 0; dd->rcd && i < dd->first_user_ctxt; ++i) { 398f931551bSRalph Campbell struct qib_ctxtdata *rcd = dd->rcd[i]; 399f931551bSRalph Campbell 400f931551bSRalph Campbell if (rcd) 401f931551bSRalph Campbell dd->f_rcvctrl(rcd->ppd, rcvmask, i); 402f931551bSRalph Campbell } 403f931551bSRalph Campbell } 404f931551bSRalph Campbell 405f931551bSRalph Campbell static void verify_interrupt(unsigned long opaque) 406f931551bSRalph Campbell { 407f931551bSRalph Campbell struct qib_devdata *dd = (struct qib_devdata *) opaque; 408f931551bSRalph Campbell 409f931551bSRalph Campbell if (!dd) 410f931551bSRalph Campbell return; /* being torn down */ 411f931551bSRalph Campbell 412f931551bSRalph Campbell /* 413f931551bSRalph Campbell * If we don't have a lid or any interrupts, let the user know and 414f931551bSRalph Campbell * don't bother checking again. 415f931551bSRalph Campbell */ 416f931551bSRalph Campbell if (dd->int_counter == 0) { 417f931551bSRalph Campbell if (!dd->f_intr_fallback(dd)) 418f931551bSRalph Campbell dev_err(&dd->pcidev->dev, "No interrupts detected, " 419f931551bSRalph Campbell "not usable.\n"); 420f931551bSRalph Campbell else /* re-arm the timer to see if fallback works */ 421f931551bSRalph Campbell mod_timer(&dd->intrchk_timer, jiffies + HZ/2); 422f931551bSRalph Campbell } 423f931551bSRalph Campbell } 424f931551bSRalph Campbell 425f931551bSRalph Campbell static void init_piobuf_state(struct qib_devdata *dd) 426f931551bSRalph Campbell { 427f931551bSRalph Campbell int i, pidx; 428f931551bSRalph Campbell u32 uctxts; 429f931551bSRalph Campbell 430f931551bSRalph Campbell /* 431f931551bSRalph Campbell * Ensure all buffers are free, and fifos empty. Buffers 432f931551bSRalph Campbell * are common, so only do once for port 0. 433f931551bSRalph Campbell * 434f931551bSRalph Campbell * After enable and qib_chg_pioavailkernel so we can safely 435f931551bSRalph Campbell * enable pioavail updates and PIOENABLE. After this, packets 436f931551bSRalph Campbell * are ready and able to go out. 437f931551bSRalph Campbell */ 438f931551bSRalph Campbell dd->f_sendctrl(dd->pport, QIB_SENDCTRL_DISARM_ALL); 439f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) 440f931551bSRalph Campbell dd->f_sendctrl(dd->pport + pidx, QIB_SENDCTRL_FLUSH); 441f931551bSRalph Campbell 442f931551bSRalph Campbell /* 443f931551bSRalph Campbell * If not all sendbufs are used, add the one to each of the lower 444f931551bSRalph Campbell * numbered contexts. pbufsctxt and lastctxt_piobuf are 445f931551bSRalph Campbell * calculated in chip-specific code because it may cause some 446f931551bSRalph Campbell * chip-specific adjustments to be made. 447f931551bSRalph Campbell */ 448f931551bSRalph Campbell uctxts = dd->cfgctxts - dd->first_user_ctxt; 449f931551bSRalph Campbell dd->ctxts_extrabuf = dd->pbufsctxt ? 450f931551bSRalph Campbell dd->lastctxt_piobuf - (dd->pbufsctxt * uctxts) : 0; 451f931551bSRalph Campbell 452f931551bSRalph Campbell /* 453f931551bSRalph Campbell * Set up the shadow copies of the piobufavail registers, 454f931551bSRalph Campbell * which we compare against the chip registers for now, and 455f931551bSRalph Campbell * the in memory DMA'ed copies of the registers. 456f931551bSRalph Campbell * By now pioavail updates to memory should have occurred, so 457f931551bSRalph Campbell * copy them into our working/shadow registers; this is in 458f931551bSRalph Campbell * case something went wrong with abort, but mostly to get the 459f931551bSRalph Campbell * initial values of the generation bit correct. 460f931551bSRalph Campbell */ 461f931551bSRalph Campbell for (i = 0; i < dd->pioavregs; i++) { 462f931551bSRalph Campbell __le64 tmp; 463f931551bSRalph Campbell 464f931551bSRalph Campbell tmp = dd->pioavailregs_dma[i]; 465f931551bSRalph Campbell /* 466f931551bSRalph Campbell * Don't need to worry about pioavailkernel here 467f931551bSRalph Campbell * because we will call qib_chg_pioavailkernel() later 468f931551bSRalph Campbell * in initialization, to busy out buffers as needed. 469f931551bSRalph Campbell */ 470f931551bSRalph Campbell dd->pioavailshadow[i] = le64_to_cpu(tmp); 471f931551bSRalph Campbell } 472f931551bSRalph Campbell while (i < ARRAY_SIZE(dd->pioavailshadow)) 473f931551bSRalph Campbell dd->pioavailshadow[i++] = 0; /* for debugging sanity */ 474f931551bSRalph Campbell 475f931551bSRalph Campbell /* after pioavailshadow is setup */ 476f931551bSRalph Campbell qib_chg_pioavailkernel(dd, 0, dd->piobcnt2k + dd->piobcnt4k, 477f931551bSRalph Campbell TXCHK_CHG_TYPE_KERN, NULL); 478f931551bSRalph Campbell dd->f_initvl15_bufs(dd); 479f931551bSRalph Campbell } 480f931551bSRalph Campbell 481f931551bSRalph Campbell /** 482f931551bSRalph Campbell * qib_init - do the actual initialization sequence on the chip 483f931551bSRalph Campbell * @dd: the qlogic_ib device 484f931551bSRalph Campbell * @reinit: reinitializing, so don't allocate new memory 485f931551bSRalph Campbell * 486f931551bSRalph Campbell * Do the actual initialization sequence on the chip. This is done 487f931551bSRalph Campbell * both from the init routine called from the PCI infrastructure, and 488f931551bSRalph Campbell * when we reset the chip, or detect that it was reset internally, 489f931551bSRalph Campbell * or it's administratively re-enabled. 490f931551bSRalph Campbell * 491f931551bSRalph Campbell * Memory allocation here and in called routines is only done in 492f931551bSRalph Campbell * the first case (reinit == 0). We have to be careful, because even 493f931551bSRalph Campbell * without memory allocation, we need to re-write all the chip registers 494f931551bSRalph Campbell * TIDs, etc. after the reset or enable has completed. 495f931551bSRalph Campbell */ 496f931551bSRalph Campbell int qib_init(struct qib_devdata *dd, int reinit) 497f931551bSRalph Campbell { 498f931551bSRalph Campbell int ret = 0, pidx, lastfail = 0; 499f931551bSRalph Campbell u32 portok = 0; 500f931551bSRalph Campbell unsigned i; 501f931551bSRalph Campbell struct qib_ctxtdata *rcd; 502f931551bSRalph Campbell struct qib_pportdata *ppd; 503f931551bSRalph Campbell unsigned long flags; 504f931551bSRalph Campbell 505f931551bSRalph Campbell /* Set linkstate to unknown, so we can watch for a transition. */ 506f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) { 507f931551bSRalph Campbell ppd = dd->pport + pidx; 508f931551bSRalph Campbell spin_lock_irqsave(&ppd->lflags_lock, flags); 509f931551bSRalph Campbell ppd->lflags &= ~(QIBL_LINKACTIVE | QIBL_LINKARMED | 510f931551bSRalph Campbell QIBL_LINKDOWN | QIBL_LINKINIT | 511f931551bSRalph Campbell QIBL_LINKV); 512f931551bSRalph Campbell spin_unlock_irqrestore(&ppd->lflags_lock, flags); 513f931551bSRalph Campbell } 514f931551bSRalph Campbell 515f931551bSRalph Campbell if (reinit) 516f931551bSRalph Campbell ret = init_after_reset(dd); 517f931551bSRalph Campbell else 518f931551bSRalph Campbell ret = loadtime_init(dd); 519f931551bSRalph Campbell if (ret) 520f931551bSRalph Campbell goto done; 521f931551bSRalph Campbell 522f931551bSRalph Campbell /* Bypass most chip-init, to get to device creation */ 523f931551bSRalph Campbell if (qib_mini_init) 524f931551bSRalph Campbell return 0; 525f931551bSRalph Campbell 526f931551bSRalph Campbell ret = dd->f_late_initreg(dd); 527f931551bSRalph Campbell if (ret) 528f931551bSRalph Campbell goto done; 529f931551bSRalph Campbell 530f931551bSRalph Campbell /* dd->rcd can be NULL if early init failed */ 531f931551bSRalph Campbell for (i = 0; dd->rcd && i < dd->first_user_ctxt; ++i) { 532f931551bSRalph Campbell /* 533f931551bSRalph Campbell * Set up the (kernel) rcvhdr queue and egr TIDs. If doing 534f931551bSRalph Campbell * re-init, the simplest way to handle this is to free 535f931551bSRalph Campbell * existing, and re-allocate. 536f931551bSRalph Campbell * Need to re-create rest of ctxt 0 ctxtdata as well. 537f931551bSRalph Campbell */ 538f931551bSRalph Campbell rcd = dd->rcd[i]; 539f931551bSRalph Campbell if (!rcd) 540f931551bSRalph Campbell continue; 541f931551bSRalph Campbell 542f931551bSRalph Campbell lastfail = qib_create_rcvhdrq(dd, rcd); 543f931551bSRalph Campbell if (!lastfail) 544f931551bSRalph Campbell lastfail = qib_setup_eagerbufs(rcd); 545f931551bSRalph Campbell if (lastfail) { 546f931551bSRalph Campbell qib_dev_err(dd, "failed to allocate kernel ctxt's " 547f931551bSRalph Campbell "rcvhdrq and/or egr bufs\n"); 548f931551bSRalph Campbell continue; 549f931551bSRalph Campbell } 550f931551bSRalph Campbell } 551f931551bSRalph Campbell 552f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) { 553f931551bSRalph Campbell int mtu; 554f931551bSRalph Campbell if (lastfail) 555f931551bSRalph Campbell ret = lastfail; 556f931551bSRalph Campbell ppd = dd->pport + pidx; 557f931551bSRalph Campbell mtu = ib_mtu_enum_to_int(qib_ibmtu); 558f931551bSRalph Campbell if (mtu == -1) { 559f931551bSRalph Campbell mtu = QIB_DEFAULT_MTU; 560f931551bSRalph Campbell qib_ibmtu = 0; /* don't leave invalid value */ 561f931551bSRalph Campbell } 562f931551bSRalph Campbell /* set max we can ever have for this driver load */ 563f931551bSRalph Campbell ppd->init_ibmaxlen = min(mtu > 2048 ? 564f931551bSRalph Campbell dd->piosize4k : dd->piosize2k, 565f931551bSRalph Campbell dd->rcvegrbufsize + 566f931551bSRalph Campbell (dd->rcvhdrentsize << 2)); 567f931551bSRalph Campbell /* 568f931551bSRalph Campbell * Have to initialize ibmaxlen, but this will normally 569f931551bSRalph Campbell * change immediately in qib_set_mtu(). 570f931551bSRalph Campbell */ 571f931551bSRalph Campbell ppd->ibmaxlen = ppd->init_ibmaxlen; 572f931551bSRalph Campbell qib_set_mtu(ppd, mtu); 573f931551bSRalph Campbell 574f931551bSRalph Campbell spin_lock_irqsave(&ppd->lflags_lock, flags); 575f931551bSRalph Campbell ppd->lflags |= QIBL_IB_LINK_DISABLED; 576f931551bSRalph Campbell spin_unlock_irqrestore(&ppd->lflags_lock, flags); 577f931551bSRalph Campbell 578f931551bSRalph Campbell lastfail = dd->f_bringup_serdes(ppd); 579f931551bSRalph Campbell if (lastfail) { 580f931551bSRalph Campbell qib_devinfo(dd->pcidev, 581f931551bSRalph Campbell "Failed to bringup IB port %u\n", ppd->port); 582f931551bSRalph Campbell lastfail = -ENETDOWN; 583f931551bSRalph Campbell continue; 584f931551bSRalph Campbell } 585f931551bSRalph Campbell 586f931551bSRalph Campbell /* let link come up, and enable IBC */ 587f931551bSRalph Campbell spin_lock_irqsave(&ppd->lflags_lock, flags); 588f931551bSRalph Campbell ppd->lflags &= ~QIBL_IB_LINK_DISABLED; 589f931551bSRalph Campbell spin_unlock_irqrestore(&ppd->lflags_lock, flags); 590f931551bSRalph Campbell portok++; 591f931551bSRalph Campbell } 592f931551bSRalph Campbell 593f931551bSRalph Campbell if (!portok) { 594f931551bSRalph Campbell /* none of the ports initialized */ 595f931551bSRalph Campbell if (!ret && lastfail) 596f931551bSRalph Campbell ret = lastfail; 597f931551bSRalph Campbell else if (!ret) 598f931551bSRalph Campbell ret = -ENETDOWN; 599f931551bSRalph Campbell /* but continue on, so we can debug cause */ 600f931551bSRalph Campbell } 601f931551bSRalph Campbell 602f931551bSRalph Campbell enable_chip(dd); 603f931551bSRalph Campbell 604f931551bSRalph Campbell init_piobuf_state(dd); 605f931551bSRalph Campbell 606f931551bSRalph Campbell done: 607f931551bSRalph Campbell if (!ret) { 608f931551bSRalph Campbell /* chip is OK for user apps; mark it as initialized */ 609f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) { 610f931551bSRalph Campbell ppd = dd->pport + pidx; 611f931551bSRalph Campbell /* 612f931551bSRalph Campbell * Set status even if port serdes is not initialized 613f931551bSRalph Campbell * so that diags will work. 614f931551bSRalph Campbell */ 615f931551bSRalph Campbell *ppd->statusp |= QIB_STATUS_CHIP_PRESENT | 616f931551bSRalph Campbell QIB_STATUS_INITTED; 617f931551bSRalph Campbell if (!ppd->link_speed_enabled) 618f931551bSRalph Campbell continue; 619f931551bSRalph Campbell if (dd->flags & QIB_HAS_SEND_DMA) 620f931551bSRalph Campbell ret = qib_setup_sdma(ppd); 621f931551bSRalph Campbell init_timer(&ppd->hol_timer); 622f931551bSRalph Campbell ppd->hol_timer.function = qib_hol_event; 623f931551bSRalph Campbell ppd->hol_timer.data = (unsigned long)ppd; 624f931551bSRalph Campbell ppd->hol_state = QIB_HOL_UP; 625f931551bSRalph Campbell } 626f931551bSRalph Campbell 627f931551bSRalph Campbell /* now we can enable all interrupts from the chip */ 628f931551bSRalph Campbell dd->f_set_intr_state(dd, 1); 629f931551bSRalph Campbell 630f931551bSRalph Campbell /* 631f931551bSRalph Campbell * Setup to verify we get an interrupt, and fallback 632f931551bSRalph Campbell * to an alternate if necessary and possible. 633f931551bSRalph Campbell */ 634f931551bSRalph Campbell mod_timer(&dd->intrchk_timer, jiffies + HZ/2); 635f931551bSRalph Campbell /* start stats retrieval timer */ 636f931551bSRalph Campbell mod_timer(&dd->stats_timer, jiffies + HZ * ACTIVITY_TIMER); 637f931551bSRalph Campbell } 638f931551bSRalph Campbell 639f931551bSRalph Campbell /* if ret is non-zero, we probably should do some cleanup here... */ 640f931551bSRalph Campbell return ret; 641f931551bSRalph Campbell } 642f931551bSRalph Campbell 643f931551bSRalph Campbell /* 644f931551bSRalph Campbell * These next two routines are placeholders in case we don't have per-arch 645f931551bSRalph Campbell * code for controlling write combining. If explicit control of write 646f931551bSRalph Campbell * combining is not available, performance will probably be awful. 647f931551bSRalph Campbell */ 648f931551bSRalph Campbell 649f931551bSRalph Campbell int __attribute__((weak)) qib_enable_wc(struct qib_devdata *dd) 650f931551bSRalph Campbell { 651f931551bSRalph Campbell return -EOPNOTSUPP; 652f931551bSRalph Campbell } 653f931551bSRalph Campbell 654f931551bSRalph Campbell void __attribute__((weak)) qib_disable_wc(struct qib_devdata *dd) 655f931551bSRalph Campbell { 656f931551bSRalph Campbell } 657f931551bSRalph Campbell 658f931551bSRalph Campbell static inline struct qib_devdata *__qib_lookup(int unit) 659f931551bSRalph Campbell { 660f931551bSRalph Campbell return idr_find(&qib_unit_table, unit); 661f931551bSRalph Campbell } 662f931551bSRalph Campbell 663f931551bSRalph Campbell struct qib_devdata *qib_lookup(int unit) 664f931551bSRalph Campbell { 665f931551bSRalph Campbell struct qib_devdata *dd; 666f931551bSRalph Campbell unsigned long flags; 667f931551bSRalph Campbell 668f931551bSRalph Campbell spin_lock_irqsave(&qib_devs_lock, flags); 669f931551bSRalph Campbell dd = __qib_lookup(unit); 670f931551bSRalph Campbell spin_unlock_irqrestore(&qib_devs_lock, flags); 671f931551bSRalph Campbell 672f931551bSRalph Campbell return dd; 673f931551bSRalph Campbell } 674f931551bSRalph Campbell 675f931551bSRalph Campbell /* 676f931551bSRalph Campbell * Stop the timers during unit shutdown, or after an error late 677f931551bSRalph Campbell * in initialization. 678f931551bSRalph Campbell */ 679f931551bSRalph Campbell static void qib_stop_timers(struct qib_devdata *dd) 680f931551bSRalph Campbell { 681f931551bSRalph Campbell struct qib_pportdata *ppd; 682f931551bSRalph Campbell int pidx; 683f931551bSRalph Campbell 684f931551bSRalph Campbell if (dd->stats_timer.data) { 685f931551bSRalph Campbell del_timer_sync(&dd->stats_timer); 686f931551bSRalph Campbell dd->stats_timer.data = 0; 687f931551bSRalph Campbell } 688f931551bSRalph Campbell if (dd->intrchk_timer.data) { 689f931551bSRalph Campbell del_timer_sync(&dd->intrchk_timer); 690f931551bSRalph Campbell dd->intrchk_timer.data = 0; 691f931551bSRalph Campbell } 692f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) { 693f931551bSRalph Campbell ppd = dd->pport + pidx; 694f931551bSRalph Campbell if (ppd->hol_timer.data) 695f931551bSRalph Campbell del_timer_sync(&ppd->hol_timer); 696f931551bSRalph Campbell if (ppd->led_override_timer.data) { 697f931551bSRalph Campbell del_timer_sync(&ppd->led_override_timer); 698f931551bSRalph Campbell atomic_set(&ppd->led_override_timer_active, 0); 699f931551bSRalph Campbell } 700f931551bSRalph Campbell if (ppd->symerr_clear_timer.data) 701f931551bSRalph Campbell del_timer_sync(&ppd->symerr_clear_timer); 702f931551bSRalph Campbell } 703f931551bSRalph Campbell } 704f931551bSRalph Campbell 705f931551bSRalph Campbell /** 706f931551bSRalph Campbell * qib_shutdown_device - shut down a device 707f931551bSRalph Campbell * @dd: the qlogic_ib device 708f931551bSRalph Campbell * 709f931551bSRalph Campbell * This is called to make the device quiet when we are about to 710f931551bSRalph Campbell * unload the driver, and also when the device is administratively 711f931551bSRalph Campbell * disabled. It does not free any data structures. 712f931551bSRalph Campbell * Everything it does has to be setup again by qib_init(dd, 1) 713f931551bSRalph Campbell */ 714f931551bSRalph Campbell static void qib_shutdown_device(struct qib_devdata *dd) 715f931551bSRalph Campbell { 716f931551bSRalph Campbell struct qib_pportdata *ppd; 717f931551bSRalph Campbell unsigned pidx; 718f931551bSRalph Campbell 719f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) { 720f931551bSRalph Campbell ppd = dd->pport + pidx; 721f931551bSRalph Campbell 722f931551bSRalph Campbell spin_lock_irq(&ppd->lflags_lock); 723f931551bSRalph Campbell ppd->lflags &= ~(QIBL_LINKDOWN | QIBL_LINKINIT | 724f931551bSRalph Campbell QIBL_LINKARMED | QIBL_LINKACTIVE | 725f931551bSRalph Campbell QIBL_LINKV); 726f931551bSRalph Campbell spin_unlock_irq(&ppd->lflags_lock); 727f931551bSRalph Campbell *ppd->statusp &= ~(QIB_STATUS_IB_CONF | QIB_STATUS_IB_READY); 728f931551bSRalph Campbell } 729f931551bSRalph Campbell dd->flags &= ~QIB_INITTED; 730f931551bSRalph Campbell 731f931551bSRalph Campbell /* mask interrupts, but not errors */ 732f931551bSRalph Campbell dd->f_set_intr_state(dd, 0); 733f931551bSRalph Campbell 734f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) { 735f931551bSRalph Campbell ppd = dd->pport + pidx; 736f931551bSRalph Campbell dd->f_rcvctrl(ppd, QIB_RCVCTRL_TAILUPD_DIS | 737f931551bSRalph Campbell QIB_RCVCTRL_CTXT_DIS | 738f931551bSRalph Campbell QIB_RCVCTRL_INTRAVAIL_DIS | 739f931551bSRalph Campbell QIB_RCVCTRL_PKEY_ENB, -1); 740f931551bSRalph Campbell /* 741f931551bSRalph Campbell * Gracefully stop all sends allowing any in progress to 742f931551bSRalph Campbell * trickle out first. 743f931551bSRalph Campbell */ 744f931551bSRalph Campbell dd->f_sendctrl(ppd, QIB_SENDCTRL_CLEAR); 745f931551bSRalph Campbell } 746f931551bSRalph Campbell 747f931551bSRalph Campbell /* 748f931551bSRalph Campbell * Enough for anything that's going to trickle out to have actually 749f931551bSRalph Campbell * done so. 750f931551bSRalph Campbell */ 751f931551bSRalph Campbell udelay(20); 752f931551bSRalph Campbell 753f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) { 754f931551bSRalph Campbell ppd = dd->pport + pidx; 755f931551bSRalph Campbell dd->f_setextled(ppd, 0); /* make sure LEDs are off */ 756f931551bSRalph Campbell 757f931551bSRalph Campbell if (dd->flags & QIB_HAS_SEND_DMA) 758f931551bSRalph Campbell qib_teardown_sdma(ppd); 759f931551bSRalph Campbell 760f931551bSRalph Campbell dd->f_sendctrl(ppd, QIB_SENDCTRL_AVAIL_DIS | 761f931551bSRalph Campbell QIB_SENDCTRL_SEND_DIS); 762f931551bSRalph Campbell /* 763f931551bSRalph Campbell * Clear SerdesEnable. 764f931551bSRalph Campbell * We can't count on interrupts since we are stopping. 765f931551bSRalph Campbell */ 766f931551bSRalph Campbell dd->f_quiet_serdes(ppd); 767f931551bSRalph Campbell } 768f931551bSRalph Campbell 769f931551bSRalph Campbell qib_update_eeprom_log(dd); 770f931551bSRalph Campbell } 771f931551bSRalph Campbell 772f931551bSRalph Campbell /** 773f931551bSRalph Campbell * qib_free_ctxtdata - free a context's allocated data 774f931551bSRalph Campbell * @dd: the qlogic_ib device 775f931551bSRalph Campbell * @rcd: the ctxtdata structure 776f931551bSRalph Campbell * 777f931551bSRalph Campbell * free up any allocated data for a context 778f931551bSRalph Campbell * This should not touch anything that would affect a simultaneous 779f931551bSRalph Campbell * re-allocation of context data, because it is called after qib_mutex 780f931551bSRalph Campbell * is released (and can be called from reinit as well). 781f931551bSRalph Campbell * It should never change any chip state, or global driver state. 782f931551bSRalph Campbell */ 783f931551bSRalph Campbell void qib_free_ctxtdata(struct qib_devdata *dd, struct qib_ctxtdata *rcd) 784f931551bSRalph Campbell { 785f931551bSRalph Campbell if (!rcd) 786f931551bSRalph Campbell return; 787f931551bSRalph Campbell 788f931551bSRalph Campbell if (rcd->rcvhdrq) { 789f931551bSRalph Campbell dma_free_coherent(&dd->pcidev->dev, rcd->rcvhdrq_size, 790f931551bSRalph Campbell rcd->rcvhdrq, rcd->rcvhdrq_phys); 791f931551bSRalph Campbell rcd->rcvhdrq = NULL; 792f931551bSRalph Campbell if (rcd->rcvhdrtail_kvaddr) { 793f931551bSRalph Campbell dma_free_coherent(&dd->pcidev->dev, PAGE_SIZE, 794f931551bSRalph Campbell rcd->rcvhdrtail_kvaddr, 795f931551bSRalph Campbell rcd->rcvhdrqtailaddr_phys); 796f931551bSRalph Campbell rcd->rcvhdrtail_kvaddr = NULL; 797f931551bSRalph Campbell } 798f931551bSRalph Campbell } 799f931551bSRalph Campbell if (rcd->rcvegrbuf) { 800f931551bSRalph Campbell unsigned e; 801f931551bSRalph Campbell 802f931551bSRalph Campbell for (e = 0; e < rcd->rcvegrbuf_chunks; e++) { 803f931551bSRalph Campbell void *base = rcd->rcvegrbuf[e]; 804f931551bSRalph Campbell size_t size = rcd->rcvegrbuf_size; 805f931551bSRalph Campbell 806f931551bSRalph Campbell dma_free_coherent(&dd->pcidev->dev, size, 807f931551bSRalph Campbell base, rcd->rcvegrbuf_phys[e]); 808f931551bSRalph Campbell } 809f931551bSRalph Campbell kfree(rcd->rcvegrbuf); 810f931551bSRalph Campbell rcd->rcvegrbuf = NULL; 811f931551bSRalph Campbell kfree(rcd->rcvegrbuf_phys); 812f931551bSRalph Campbell rcd->rcvegrbuf_phys = NULL; 813f931551bSRalph Campbell rcd->rcvegrbuf_chunks = 0; 814f931551bSRalph Campbell } 815f931551bSRalph Campbell 816f931551bSRalph Campbell kfree(rcd->tid_pg_list); 817f931551bSRalph Campbell vfree(rcd->user_event_mask); 818f931551bSRalph Campbell vfree(rcd->subctxt_uregbase); 819f931551bSRalph Campbell vfree(rcd->subctxt_rcvegrbuf); 820f931551bSRalph Campbell vfree(rcd->subctxt_rcvhdr_base); 821f931551bSRalph Campbell kfree(rcd); 822f931551bSRalph Campbell } 823f931551bSRalph Campbell 824f931551bSRalph Campbell /* 825f931551bSRalph Campbell * Perform a PIO buffer bandwidth write test, to verify proper system 826f931551bSRalph Campbell * configuration. Even when all the setup calls work, occasionally 827f931551bSRalph Campbell * BIOS or other issues can prevent write combining from working, or 828f931551bSRalph Campbell * can cause other bandwidth problems to the chip. 829f931551bSRalph Campbell * 830f931551bSRalph Campbell * This test simply writes the same buffer over and over again, and 831f931551bSRalph Campbell * measures close to the peak bandwidth to the chip (not testing 832f931551bSRalph Campbell * data bandwidth to the wire). On chips that use an address-based 833f931551bSRalph Campbell * trigger to send packets to the wire, this is easy. On chips that 834f931551bSRalph Campbell * use a count to trigger, we want to make sure that the packet doesn't 835f931551bSRalph Campbell * go out on the wire, or trigger flow control checks. 836f931551bSRalph Campbell */ 837f931551bSRalph Campbell static void qib_verify_pioperf(struct qib_devdata *dd) 838f931551bSRalph Campbell { 839f931551bSRalph Campbell u32 pbnum, cnt, lcnt; 840f931551bSRalph Campbell u32 __iomem *piobuf; 841f931551bSRalph Campbell u32 *addr; 842f931551bSRalph Campbell u64 msecs, emsecs; 843f931551bSRalph Campbell 844f931551bSRalph Campbell piobuf = dd->f_getsendbuf(dd->pport, 0ULL, &pbnum); 845f931551bSRalph Campbell if (!piobuf) { 846f931551bSRalph Campbell qib_devinfo(dd->pcidev, 847f931551bSRalph Campbell "No PIObufs for checking perf, skipping\n"); 848f931551bSRalph Campbell return; 849f931551bSRalph Campbell } 850f931551bSRalph Campbell 851f931551bSRalph Campbell /* 852f931551bSRalph Campbell * Enough to give us a reasonable test, less than piobuf size, and 853f931551bSRalph Campbell * likely multiple of store buffer length. 854f931551bSRalph Campbell */ 855f931551bSRalph Campbell cnt = 1024; 856f931551bSRalph Campbell 857f931551bSRalph Campbell addr = vmalloc(cnt); 858f931551bSRalph Campbell if (!addr) { 859f931551bSRalph Campbell qib_devinfo(dd->pcidev, 860f931551bSRalph Campbell "Couldn't get memory for checking PIO perf," 861f931551bSRalph Campbell " skipping\n"); 862f931551bSRalph Campbell goto done; 863f931551bSRalph Campbell } 864f931551bSRalph Campbell 865f931551bSRalph Campbell preempt_disable(); /* we want reasonably accurate elapsed time */ 866f931551bSRalph Campbell msecs = 1 + jiffies_to_msecs(jiffies); 867f931551bSRalph Campbell for (lcnt = 0; lcnt < 10000U; lcnt++) { 868f931551bSRalph Campbell /* wait until we cross msec boundary */ 869f931551bSRalph Campbell if (jiffies_to_msecs(jiffies) >= msecs) 870f931551bSRalph Campbell break; 871f931551bSRalph Campbell udelay(1); 872f931551bSRalph Campbell } 873f931551bSRalph Campbell 874f931551bSRalph Campbell dd->f_set_armlaunch(dd, 0); 875f931551bSRalph Campbell 876f931551bSRalph Campbell /* 877f931551bSRalph Campbell * length 0, no dwords actually sent 878f931551bSRalph Campbell */ 879f931551bSRalph Campbell writeq(0, piobuf); 880f931551bSRalph Campbell qib_flush_wc(); 881f931551bSRalph Campbell 882f931551bSRalph Campbell /* 883f931551bSRalph Campbell * This is only roughly accurate, since even with preempt we 884f931551bSRalph Campbell * still take interrupts that could take a while. Running for 885f931551bSRalph Campbell * >= 5 msec seems to get us "close enough" to accurate values. 886f931551bSRalph Campbell */ 887f931551bSRalph Campbell msecs = jiffies_to_msecs(jiffies); 888f931551bSRalph Campbell for (emsecs = lcnt = 0; emsecs <= 5UL; lcnt++) { 889f931551bSRalph Campbell qib_pio_copy(piobuf + 64, addr, cnt >> 2); 890f931551bSRalph Campbell emsecs = jiffies_to_msecs(jiffies) - msecs; 891f931551bSRalph Campbell } 892f931551bSRalph Campbell 893f931551bSRalph Campbell /* 1 GiB/sec, slightly over IB SDR line rate */ 894f931551bSRalph Campbell if (lcnt < (emsecs * 1024U)) 895f931551bSRalph Campbell qib_dev_err(dd, 896f931551bSRalph Campbell "Performance problem: bandwidth to PIO buffers is " 897f931551bSRalph Campbell "only %u MiB/sec\n", 898f931551bSRalph Campbell lcnt / (u32) emsecs); 899f931551bSRalph Campbell 900f931551bSRalph Campbell preempt_enable(); 901f931551bSRalph Campbell 902f931551bSRalph Campbell vfree(addr); 903f931551bSRalph Campbell 904f931551bSRalph Campbell done: 905f931551bSRalph Campbell /* disarm piobuf, so it's available again */ 906f931551bSRalph Campbell dd->f_sendctrl(dd->pport, QIB_SENDCTRL_DISARM_BUF(pbnum)); 907f931551bSRalph Campbell qib_sendbuf_done(dd, pbnum); 908f931551bSRalph Campbell dd->f_set_armlaunch(dd, 1); 909f931551bSRalph Campbell } 910f931551bSRalph Campbell 911f931551bSRalph Campbell 912f931551bSRalph Campbell void qib_free_devdata(struct qib_devdata *dd) 913f931551bSRalph Campbell { 914f931551bSRalph Campbell unsigned long flags; 915f931551bSRalph Campbell 916f931551bSRalph Campbell spin_lock_irqsave(&qib_devs_lock, flags); 917f931551bSRalph Campbell idr_remove(&qib_unit_table, dd->unit); 918f931551bSRalph Campbell list_del(&dd->list); 919f931551bSRalph Campbell spin_unlock_irqrestore(&qib_devs_lock, flags); 920f931551bSRalph Campbell 921f931551bSRalph Campbell ib_dealloc_device(&dd->verbs_dev.ibdev); 922f931551bSRalph Campbell } 923f931551bSRalph Campbell 924f931551bSRalph Campbell /* 925f931551bSRalph Campbell * Allocate our primary per-unit data structure. Must be done via verbs 926f931551bSRalph Campbell * allocator, because the verbs cleanup process both does cleanup and 927f931551bSRalph Campbell * free of the data structure. 928f931551bSRalph Campbell * "extra" is for chip-specific data. 929f931551bSRalph Campbell * 930f931551bSRalph Campbell * Use the idr mechanism to get a unit number for this unit. 931f931551bSRalph Campbell */ 932f931551bSRalph Campbell struct qib_devdata *qib_alloc_devdata(struct pci_dev *pdev, size_t extra) 933f931551bSRalph Campbell { 934f931551bSRalph Campbell unsigned long flags; 935f931551bSRalph Campbell struct qib_devdata *dd; 936f931551bSRalph Campbell int ret; 937f931551bSRalph Campbell 938f931551bSRalph Campbell if (!idr_pre_get(&qib_unit_table, GFP_KERNEL)) { 939f931551bSRalph Campbell dd = ERR_PTR(-ENOMEM); 940f931551bSRalph Campbell goto bail; 941f931551bSRalph Campbell } 942f931551bSRalph Campbell 943f931551bSRalph Campbell dd = (struct qib_devdata *) ib_alloc_device(sizeof(*dd) + extra); 944f931551bSRalph Campbell if (!dd) { 945f931551bSRalph Campbell dd = ERR_PTR(-ENOMEM); 946f931551bSRalph Campbell goto bail; 947f931551bSRalph Campbell } 948f931551bSRalph Campbell 949f931551bSRalph Campbell spin_lock_irqsave(&qib_devs_lock, flags); 950f931551bSRalph Campbell ret = idr_get_new(&qib_unit_table, dd, &dd->unit); 951f931551bSRalph Campbell if (ret >= 0) 952f931551bSRalph Campbell list_add(&dd->list, &qib_dev_list); 953f931551bSRalph Campbell spin_unlock_irqrestore(&qib_devs_lock, flags); 954f931551bSRalph Campbell 955f931551bSRalph Campbell if (ret < 0) { 956f931551bSRalph Campbell qib_early_err(&pdev->dev, 957f931551bSRalph Campbell "Could not allocate unit ID: error %d\n", -ret); 958f931551bSRalph Campbell ib_dealloc_device(&dd->verbs_dev.ibdev); 959f931551bSRalph Campbell dd = ERR_PTR(ret); 960f931551bSRalph Campbell goto bail; 961f931551bSRalph Campbell } 962f931551bSRalph Campbell 963f931551bSRalph Campbell if (!qib_cpulist_count) { 964f931551bSRalph Campbell u32 count = num_online_cpus(); 965f931551bSRalph Campbell qib_cpulist = kzalloc(BITS_TO_LONGS(count) * 966f931551bSRalph Campbell sizeof(long), GFP_KERNEL); 967f931551bSRalph Campbell if (qib_cpulist) 968f931551bSRalph Campbell qib_cpulist_count = count; 969f931551bSRalph Campbell else 970f931551bSRalph Campbell qib_early_err(&pdev->dev, "Could not alloc cpulist " 971f931551bSRalph Campbell "info, cpu affinity might be wrong\n"); 972f931551bSRalph Campbell } 973f931551bSRalph Campbell 974f931551bSRalph Campbell bail: 975f931551bSRalph Campbell return dd; 976f931551bSRalph Campbell } 977f931551bSRalph Campbell 978f931551bSRalph Campbell /* 979f931551bSRalph Campbell * Called from freeze mode handlers, and from PCI error 980f931551bSRalph Campbell * reporting code. Should be paranoid about state of 981f931551bSRalph Campbell * system and data structures. 982f931551bSRalph Campbell */ 983f931551bSRalph Campbell void qib_disable_after_error(struct qib_devdata *dd) 984f931551bSRalph Campbell { 985f931551bSRalph Campbell if (dd->flags & QIB_INITTED) { 986f931551bSRalph Campbell u32 pidx; 987f931551bSRalph Campbell 988f931551bSRalph Campbell dd->flags &= ~QIB_INITTED; 989f931551bSRalph Campbell if (dd->pport) 990f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) { 991f931551bSRalph Campbell struct qib_pportdata *ppd; 992f931551bSRalph Campbell 993f931551bSRalph Campbell ppd = dd->pport + pidx; 994f931551bSRalph Campbell if (dd->flags & QIB_PRESENT) { 995f931551bSRalph Campbell qib_set_linkstate(ppd, 996f931551bSRalph Campbell QIB_IB_LINKDOWN_DISABLE); 997f931551bSRalph Campbell dd->f_setextled(ppd, 0); 998f931551bSRalph Campbell } 999f931551bSRalph Campbell *ppd->statusp &= ~QIB_STATUS_IB_READY; 1000f931551bSRalph Campbell } 1001f931551bSRalph Campbell } 1002f931551bSRalph Campbell 1003f931551bSRalph Campbell /* 1004f931551bSRalph Campbell * Mark as having had an error for driver, and also 1005f931551bSRalph Campbell * for /sys and status word mapped to user programs. 1006f931551bSRalph Campbell * This marks unit as not usable, until reset. 1007f931551bSRalph Campbell */ 1008f931551bSRalph Campbell if (dd->devstatusp) 1009f931551bSRalph Campbell *dd->devstatusp |= QIB_STATUS_HWERROR; 1010f931551bSRalph Campbell } 1011f931551bSRalph Campbell 1012f931551bSRalph Campbell static void __devexit qib_remove_one(struct pci_dev *); 1013f931551bSRalph Campbell static int __devinit qib_init_one(struct pci_dev *, 1014f931551bSRalph Campbell const struct pci_device_id *); 1015f931551bSRalph Campbell 1016f931551bSRalph Campbell #define DRIVER_LOAD_MSG "QLogic " QIB_DRV_NAME " loaded: " 1017f931551bSRalph Campbell #define PFX QIB_DRV_NAME ": " 1018f931551bSRalph Campbell 1019f931551bSRalph Campbell static const struct pci_device_id qib_pci_tbl[] = { 1020f931551bSRalph Campbell { PCI_DEVICE(PCI_VENDOR_ID_PATHSCALE, PCI_DEVICE_ID_QLOGIC_IB_6120) }, 1021f931551bSRalph Campbell { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_IB_7220) }, 1022f931551bSRalph Campbell { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_IB_7322) }, 1023f931551bSRalph Campbell { 0, } 1024f931551bSRalph Campbell }; 1025f931551bSRalph Campbell 1026f931551bSRalph Campbell MODULE_DEVICE_TABLE(pci, qib_pci_tbl); 1027f931551bSRalph Campbell 1028f931551bSRalph Campbell struct pci_driver qib_driver = { 1029f931551bSRalph Campbell .name = QIB_DRV_NAME, 1030f931551bSRalph Campbell .probe = qib_init_one, 1031f931551bSRalph Campbell .remove = __devexit_p(qib_remove_one), 1032f931551bSRalph Campbell .id_table = qib_pci_tbl, 1033f931551bSRalph Campbell .err_handler = &qib_pci_err_handler, 1034f931551bSRalph Campbell }; 1035f931551bSRalph Campbell 1036f931551bSRalph Campbell /* 1037f931551bSRalph Campbell * Do all the generic driver unit- and chip-independent memory 1038f931551bSRalph Campbell * allocation and initialization. 1039f931551bSRalph Campbell */ 1040f931551bSRalph Campbell static int __init qlogic_ib_init(void) 1041f931551bSRalph Campbell { 1042f931551bSRalph Campbell int ret; 1043f931551bSRalph Campbell 1044f931551bSRalph Campbell ret = qib_dev_init(); 1045f931551bSRalph Campbell if (ret) 1046f931551bSRalph Campbell goto bail; 1047f931551bSRalph Campbell 1048f931551bSRalph Campbell /* 1049f931551bSRalph Campbell * We create our own workqueue mainly because we want to be 1050f931551bSRalph Campbell * able to flush it when devices are being removed. We can't 1051f931551bSRalph Campbell * use schedule_work()/flush_scheduled_work() because both 1052f931551bSRalph Campbell * unregister_netdev() and linkwatch_event take the rtnl lock, 1053f931551bSRalph Campbell * so flush_scheduled_work() can deadlock during device 1054f931551bSRalph Campbell * removal. 1055f931551bSRalph Campbell */ 1056f931551bSRalph Campbell qib_wq = create_workqueue("qib"); 1057f931551bSRalph Campbell if (!qib_wq) { 1058f931551bSRalph Campbell ret = -ENOMEM; 1059f931551bSRalph Campbell goto bail_dev; 1060f931551bSRalph Campbell } 1061f931551bSRalph Campbell 1062f931551bSRalph Campbell qib_cq_wq = create_workqueue("qib_cq"); 1063f931551bSRalph Campbell if (!qib_cq_wq) { 1064f931551bSRalph Campbell ret = -ENOMEM; 1065f931551bSRalph Campbell goto bail_wq; 1066f931551bSRalph Campbell } 1067f931551bSRalph Campbell 1068f931551bSRalph Campbell /* 1069f931551bSRalph Campbell * These must be called before the driver is registered with 1070f931551bSRalph Campbell * the PCI subsystem. 1071f931551bSRalph Campbell */ 1072f931551bSRalph Campbell idr_init(&qib_unit_table); 1073f931551bSRalph Campbell if (!idr_pre_get(&qib_unit_table, GFP_KERNEL)) { 1074f931551bSRalph Campbell printk(KERN_ERR QIB_DRV_NAME ": idr_pre_get() failed\n"); 1075f931551bSRalph Campbell ret = -ENOMEM; 1076f931551bSRalph Campbell goto bail_cq_wq; 1077f931551bSRalph Campbell } 1078f931551bSRalph Campbell 1079f931551bSRalph Campbell ret = pci_register_driver(&qib_driver); 1080f931551bSRalph Campbell if (ret < 0) { 1081f931551bSRalph Campbell printk(KERN_ERR QIB_DRV_NAME 1082f931551bSRalph Campbell ": Unable to register driver: error %d\n", -ret); 1083f931551bSRalph Campbell goto bail_unit; 1084f931551bSRalph Campbell } 1085f931551bSRalph Campbell 1086f931551bSRalph Campbell /* not fatal if it doesn't work */ 1087f931551bSRalph Campbell if (qib_init_qibfs()) 1088f931551bSRalph Campbell printk(KERN_ERR QIB_DRV_NAME ": Unable to register ipathfs\n"); 1089f931551bSRalph Campbell goto bail; /* all OK */ 1090f931551bSRalph Campbell 1091f931551bSRalph Campbell bail_unit: 1092f931551bSRalph Campbell idr_destroy(&qib_unit_table); 1093f931551bSRalph Campbell bail_cq_wq: 1094f931551bSRalph Campbell destroy_workqueue(qib_cq_wq); 1095f931551bSRalph Campbell bail_wq: 1096f931551bSRalph Campbell destroy_workqueue(qib_wq); 1097f931551bSRalph Campbell bail_dev: 1098f931551bSRalph Campbell qib_dev_cleanup(); 1099f931551bSRalph Campbell bail: 1100f931551bSRalph Campbell return ret; 1101f931551bSRalph Campbell } 1102f931551bSRalph Campbell 1103f931551bSRalph Campbell module_init(qlogic_ib_init); 1104f931551bSRalph Campbell 1105f931551bSRalph Campbell /* 1106f931551bSRalph Campbell * Do the non-unit driver cleanup, memory free, etc. at unload. 1107f931551bSRalph Campbell */ 1108f931551bSRalph Campbell static void __exit qlogic_ib_cleanup(void) 1109f931551bSRalph Campbell { 1110f931551bSRalph Campbell int ret; 1111f931551bSRalph Campbell 1112f931551bSRalph Campbell ret = qib_exit_qibfs(); 1113f931551bSRalph Campbell if (ret) 1114f931551bSRalph Campbell printk(KERN_ERR QIB_DRV_NAME ": " 1115f931551bSRalph Campbell "Unable to cleanup counter filesystem: " 1116f931551bSRalph Campbell "error %d\n", -ret); 1117f931551bSRalph Campbell 1118f931551bSRalph Campbell pci_unregister_driver(&qib_driver); 1119f931551bSRalph Campbell 1120f931551bSRalph Campbell destroy_workqueue(qib_wq); 1121f931551bSRalph Campbell destroy_workqueue(qib_cq_wq); 1122f931551bSRalph Campbell 1123f931551bSRalph Campbell qib_cpulist_count = 0; 1124f931551bSRalph Campbell kfree(qib_cpulist); 1125f931551bSRalph Campbell 1126f931551bSRalph Campbell idr_destroy(&qib_unit_table); 1127f931551bSRalph Campbell qib_dev_cleanup(); 1128f931551bSRalph Campbell } 1129f931551bSRalph Campbell 1130f931551bSRalph Campbell module_exit(qlogic_ib_cleanup); 1131f931551bSRalph Campbell 1132f931551bSRalph Campbell /* this can only be called after a successful initialization */ 1133f931551bSRalph Campbell static void cleanup_device_data(struct qib_devdata *dd) 1134f931551bSRalph Campbell { 1135f931551bSRalph Campbell int ctxt; 1136f931551bSRalph Campbell int pidx; 1137f931551bSRalph Campbell struct qib_ctxtdata **tmp; 1138f931551bSRalph Campbell unsigned long flags; 1139f931551bSRalph Campbell 1140f931551bSRalph Campbell /* users can't do anything more with chip */ 1141f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) 1142f931551bSRalph Campbell if (dd->pport[pidx].statusp) 1143f931551bSRalph Campbell *dd->pport[pidx].statusp &= ~QIB_STATUS_CHIP_PRESENT; 1144f931551bSRalph Campbell 1145f931551bSRalph Campbell if (!qib_wc_pat) 1146f931551bSRalph Campbell qib_disable_wc(dd); 1147f931551bSRalph Campbell 1148f931551bSRalph Campbell if (dd->pioavailregs_dma) { 1149f931551bSRalph Campbell dma_free_coherent(&dd->pcidev->dev, PAGE_SIZE, 1150f931551bSRalph Campbell (void *) dd->pioavailregs_dma, 1151f931551bSRalph Campbell dd->pioavailregs_phys); 1152f931551bSRalph Campbell dd->pioavailregs_dma = NULL; 1153f931551bSRalph Campbell } 1154f931551bSRalph Campbell 1155f931551bSRalph Campbell if (dd->pageshadow) { 1156f931551bSRalph Campbell struct page **tmpp = dd->pageshadow; 1157f931551bSRalph Campbell dma_addr_t *tmpd = dd->physshadow; 1158f931551bSRalph Campbell int i, cnt = 0; 1159f931551bSRalph Campbell 1160f931551bSRalph Campbell for (ctxt = 0; ctxt < dd->cfgctxts; ctxt++) { 1161f931551bSRalph Campbell int ctxt_tidbase = ctxt * dd->rcvtidcnt; 1162f931551bSRalph Campbell int maxtid = ctxt_tidbase + dd->rcvtidcnt; 1163f931551bSRalph Campbell 1164f931551bSRalph Campbell for (i = ctxt_tidbase; i < maxtid; i++) { 1165f931551bSRalph Campbell if (!tmpp[i]) 1166f931551bSRalph Campbell continue; 1167f931551bSRalph Campbell pci_unmap_page(dd->pcidev, tmpd[i], 1168f931551bSRalph Campbell PAGE_SIZE, PCI_DMA_FROMDEVICE); 1169f931551bSRalph Campbell qib_release_user_pages(&tmpp[i], 1); 1170f931551bSRalph Campbell tmpp[i] = NULL; 1171f931551bSRalph Campbell cnt++; 1172f931551bSRalph Campbell } 1173f931551bSRalph Campbell } 1174f931551bSRalph Campbell 1175f931551bSRalph Campbell tmpp = dd->pageshadow; 1176f931551bSRalph Campbell dd->pageshadow = NULL; 1177f931551bSRalph Campbell vfree(tmpp); 1178f931551bSRalph Campbell } 1179f931551bSRalph Campbell 1180f931551bSRalph Campbell /* 1181f931551bSRalph Campbell * Free any resources still in use (usually just kernel contexts) 1182f931551bSRalph Campbell * at unload; we do for ctxtcnt, because that's what we allocate. 1183f931551bSRalph Campbell * We acquire lock to be really paranoid that rcd isn't being 1184f931551bSRalph Campbell * accessed from some interrupt-related code (that should not happen, 1185f931551bSRalph Campbell * but best to be sure). 1186f931551bSRalph Campbell */ 1187f931551bSRalph Campbell spin_lock_irqsave(&dd->uctxt_lock, flags); 1188f931551bSRalph Campbell tmp = dd->rcd; 1189f931551bSRalph Campbell dd->rcd = NULL; 1190f931551bSRalph Campbell spin_unlock_irqrestore(&dd->uctxt_lock, flags); 1191f931551bSRalph Campbell for (ctxt = 0; tmp && ctxt < dd->ctxtcnt; ctxt++) { 1192f931551bSRalph Campbell struct qib_ctxtdata *rcd = tmp[ctxt]; 1193f931551bSRalph Campbell 1194f931551bSRalph Campbell tmp[ctxt] = NULL; /* debugging paranoia */ 1195f931551bSRalph Campbell qib_free_ctxtdata(dd, rcd); 1196f931551bSRalph Campbell } 1197f931551bSRalph Campbell kfree(tmp); 1198f931551bSRalph Campbell kfree(dd->boardname); 1199f931551bSRalph Campbell } 1200f931551bSRalph Campbell 1201f931551bSRalph Campbell /* 1202f931551bSRalph Campbell * Clean up on unit shutdown, or error during unit load after 1203f931551bSRalph Campbell * successful initialization. 1204f931551bSRalph Campbell */ 1205f931551bSRalph Campbell static void qib_postinit_cleanup(struct qib_devdata *dd) 1206f931551bSRalph Campbell { 1207f931551bSRalph Campbell /* 1208f931551bSRalph Campbell * Clean up chip-specific stuff. 1209f931551bSRalph Campbell * We check for NULL here, because it's outside 1210f931551bSRalph Campbell * the kregbase check, and we need to call it 1211f931551bSRalph Campbell * after the free_irq. Thus it's possible that 1212f931551bSRalph Campbell * the function pointers were never initialized. 1213f931551bSRalph Campbell */ 1214f931551bSRalph Campbell if (dd->f_cleanup) 1215f931551bSRalph Campbell dd->f_cleanup(dd); 1216f931551bSRalph Campbell 1217f931551bSRalph Campbell qib_pcie_ddcleanup(dd); 1218f931551bSRalph Campbell 1219f931551bSRalph Campbell cleanup_device_data(dd); 1220f931551bSRalph Campbell 1221f931551bSRalph Campbell qib_free_devdata(dd); 1222f931551bSRalph Campbell } 1223f931551bSRalph Campbell 1224f931551bSRalph Campbell static int __devinit qib_init_one(struct pci_dev *pdev, 1225f931551bSRalph Campbell const struct pci_device_id *ent) 1226f931551bSRalph Campbell { 1227f931551bSRalph Campbell int ret, j, pidx, initfail; 1228f931551bSRalph Campbell struct qib_devdata *dd = NULL; 1229f931551bSRalph Campbell 1230f931551bSRalph Campbell ret = qib_pcie_init(pdev, ent); 1231f931551bSRalph Campbell if (ret) 1232f931551bSRalph Campbell goto bail; 1233f931551bSRalph Campbell 1234f931551bSRalph Campbell /* 1235f931551bSRalph Campbell * Do device-specific initialiation, function table setup, dd 1236f931551bSRalph Campbell * allocation, etc. 1237f931551bSRalph Campbell */ 1238f931551bSRalph Campbell switch (ent->device) { 1239f931551bSRalph Campbell case PCI_DEVICE_ID_QLOGIC_IB_6120: 12407e3a1f4aSRalph Campbell #ifdef CONFIG_PCI_MSI 1241f931551bSRalph Campbell dd = qib_init_iba6120_funcs(pdev, ent); 12427e3a1f4aSRalph Campbell #else 12437e3a1f4aSRalph Campbell qib_early_err(&pdev->dev, "QLogic PCIE device 0x%x cannot " 12447e3a1f4aSRalph Campbell "work if CONFIG_PCI_MSI is not enabled\n", 12457e3a1f4aSRalph Campbell ent->device); 12467e3a1f4aSRalph Campbell #endif 1247f931551bSRalph Campbell break; 1248f931551bSRalph Campbell 1249f931551bSRalph Campbell case PCI_DEVICE_ID_QLOGIC_IB_7220: 1250f931551bSRalph Campbell dd = qib_init_iba7220_funcs(pdev, ent); 1251f931551bSRalph Campbell break; 1252f931551bSRalph Campbell 1253f931551bSRalph Campbell case PCI_DEVICE_ID_QLOGIC_IB_7322: 1254f931551bSRalph Campbell dd = qib_init_iba7322_funcs(pdev, ent); 1255f931551bSRalph Campbell break; 1256f931551bSRalph Campbell 1257f931551bSRalph Campbell default: 1258f931551bSRalph Campbell qib_early_err(&pdev->dev, "Failing on unknown QLogic " 1259f931551bSRalph Campbell "deviceid 0x%x\n", ent->device); 1260f931551bSRalph Campbell ret = -ENODEV; 1261f931551bSRalph Campbell } 1262f931551bSRalph Campbell 1263f931551bSRalph Campbell if (IS_ERR(dd)) 1264f931551bSRalph Campbell ret = PTR_ERR(dd); 1265f931551bSRalph Campbell if (ret) 1266f931551bSRalph Campbell goto bail; /* error already printed */ 1267f931551bSRalph Campbell 1268f931551bSRalph Campbell /* do the generic initialization */ 1269f931551bSRalph Campbell initfail = qib_init(dd, 0); 1270f931551bSRalph Campbell 1271f931551bSRalph Campbell ret = qib_register_ib_device(dd); 1272f931551bSRalph Campbell 1273f931551bSRalph Campbell /* 1274f931551bSRalph Campbell * Now ready for use. this should be cleared whenever we 1275f931551bSRalph Campbell * detect a reset, or initiate one. If earlier failure, 1276f931551bSRalph Campbell * we still create devices, so diags, etc. can be used 1277f931551bSRalph Campbell * to determine cause of problem. 1278f931551bSRalph Campbell */ 1279f931551bSRalph Campbell if (!qib_mini_init && !initfail && !ret) 1280f931551bSRalph Campbell dd->flags |= QIB_INITTED; 1281f931551bSRalph Campbell 1282f931551bSRalph Campbell j = qib_device_create(dd); 1283f931551bSRalph Campbell if (j) 1284f931551bSRalph Campbell qib_dev_err(dd, "Failed to create /dev devices: %d\n", -j); 1285f931551bSRalph Campbell j = qibfs_add(dd); 1286f931551bSRalph Campbell if (j) 1287f931551bSRalph Campbell qib_dev_err(dd, "Failed filesystem setup for counters: %d\n", 1288f931551bSRalph Campbell -j); 1289f931551bSRalph Campbell 1290f931551bSRalph Campbell if (qib_mini_init || initfail || ret) { 1291f931551bSRalph Campbell qib_stop_timers(dd); 1292f931551bSRalph Campbell for (pidx = 0; pidx < dd->num_pports; ++pidx) 1293f931551bSRalph Campbell dd->f_quiet_serdes(dd->pport + pidx); 1294f931551bSRalph Campbell if (initfail) 1295f931551bSRalph Campbell ret = initfail; 1296f931551bSRalph Campbell goto bail; 1297f931551bSRalph Campbell } 1298f931551bSRalph Campbell 1299f931551bSRalph Campbell if (!qib_wc_pat) { 1300f931551bSRalph Campbell ret = qib_enable_wc(dd); 1301f931551bSRalph Campbell if (ret) { 1302f931551bSRalph Campbell qib_dev_err(dd, "Write combining not enabled " 1303f931551bSRalph Campbell "(err %d): performance may be poor\n", 1304f931551bSRalph Campbell -ret); 1305f931551bSRalph Campbell ret = 0; 1306f931551bSRalph Campbell } 1307f931551bSRalph Campbell } 1308f931551bSRalph Campbell 1309f931551bSRalph Campbell qib_verify_pioperf(dd); 1310f931551bSRalph Campbell bail: 1311f931551bSRalph Campbell return ret; 1312f931551bSRalph Campbell } 1313f931551bSRalph Campbell 1314f931551bSRalph Campbell static void __devexit qib_remove_one(struct pci_dev *pdev) 1315f931551bSRalph Campbell { 1316f931551bSRalph Campbell struct qib_devdata *dd = pci_get_drvdata(pdev); 1317f931551bSRalph Campbell int ret; 1318f931551bSRalph Campbell 1319f931551bSRalph Campbell /* unregister from IB core */ 1320f931551bSRalph Campbell qib_unregister_ib_device(dd); 1321f931551bSRalph Campbell 1322f931551bSRalph Campbell /* 1323f931551bSRalph Campbell * Disable the IB link, disable interrupts on the device, 1324f931551bSRalph Campbell * clear dma engines, etc. 1325f931551bSRalph Campbell */ 1326f931551bSRalph Campbell if (!qib_mini_init) 1327f931551bSRalph Campbell qib_shutdown_device(dd); 1328f931551bSRalph Campbell 1329f931551bSRalph Campbell qib_stop_timers(dd); 1330f931551bSRalph Campbell 1331f931551bSRalph Campbell /* wait until all of our (qsfp) schedule_work() calls complete */ 1332f931551bSRalph Campbell flush_scheduled_work(); 1333f931551bSRalph Campbell 1334f931551bSRalph Campbell ret = qibfs_remove(dd); 1335f931551bSRalph Campbell if (ret) 1336f931551bSRalph Campbell qib_dev_err(dd, "Failed counters filesystem cleanup: %d\n", 1337f931551bSRalph Campbell -ret); 1338f931551bSRalph Campbell 1339f931551bSRalph Campbell qib_device_remove(dd); 1340f931551bSRalph Campbell 1341f931551bSRalph Campbell qib_postinit_cleanup(dd); 1342f931551bSRalph Campbell } 1343f931551bSRalph Campbell 1344f931551bSRalph Campbell /** 1345f931551bSRalph Campbell * qib_create_rcvhdrq - create a receive header queue 1346f931551bSRalph Campbell * @dd: the qlogic_ib device 1347f931551bSRalph Campbell * @rcd: the context data 1348f931551bSRalph Campbell * 1349f931551bSRalph Campbell * This must be contiguous memory (from an i/o perspective), and must be 1350f931551bSRalph Campbell * DMA'able (which means for some systems, it will go through an IOMMU, 1351f931551bSRalph Campbell * or be forced into a low address range). 1352f931551bSRalph Campbell */ 1353f931551bSRalph Campbell int qib_create_rcvhdrq(struct qib_devdata *dd, struct qib_ctxtdata *rcd) 1354f931551bSRalph Campbell { 1355f931551bSRalph Campbell unsigned amt; 1356f931551bSRalph Campbell 1357f931551bSRalph Campbell if (!rcd->rcvhdrq) { 1358f931551bSRalph Campbell dma_addr_t phys_hdrqtail; 1359f931551bSRalph Campbell gfp_t gfp_flags; 1360f931551bSRalph Campbell 1361f931551bSRalph Campbell amt = ALIGN(dd->rcvhdrcnt * dd->rcvhdrentsize * 1362f931551bSRalph Campbell sizeof(u32), PAGE_SIZE); 1363f931551bSRalph Campbell gfp_flags = (rcd->ctxt >= dd->first_user_ctxt) ? 1364f931551bSRalph Campbell GFP_USER : GFP_KERNEL; 1365f931551bSRalph Campbell rcd->rcvhdrq = dma_alloc_coherent( 1366f931551bSRalph Campbell &dd->pcidev->dev, amt, &rcd->rcvhdrq_phys, 1367f931551bSRalph Campbell gfp_flags | __GFP_COMP); 1368f931551bSRalph Campbell 1369f931551bSRalph Campbell if (!rcd->rcvhdrq) { 1370f931551bSRalph Campbell qib_dev_err(dd, "attempt to allocate %d bytes " 1371f931551bSRalph Campbell "for ctxt %u rcvhdrq failed\n", 1372f931551bSRalph Campbell amt, rcd->ctxt); 1373f931551bSRalph Campbell goto bail; 1374f931551bSRalph Campbell } 1375f931551bSRalph Campbell 1376f931551bSRalph Campbell if (rcd->ctxt >= dd->first_user_ctxt) { 1377f931551bSRalph Campbell rcd->user_event_mask = vmalloc_user(PAGE_SIZE); 1378f931551bSRalph Campbell if (!rcd->user_event_mask) 1379f931551bSRalph Campbell goto bail_free_hdrq; 1380f931551bSRalph Campbell } 1381f931551bSRalph Campbell 1382f931551bSRalph Campbell if (!(dd->flags & QIB_NODMA_RTAIL)) { 1383f931551bSRalph Campbell rcd->rcvhdrtail_kvaddr = dma_alloc_coherent( 1384f931551bSRalph Campbell &dd->pcidev->dev, PAGE_SIZE, &phys_hdrqtail, 1385f931551bSRalph Campbell gfp_flags); 1386f931551bSRalph Campbell if (!rcd->rcvhdrtail_kvaddr) 1387f931551bSRalph Campbell goto bail_free; 1388f931551bSRalph Campbell rcd->rcvhdrqtailaddr_phys = phys_hdrqtail; 1389f931551bSRalph Campbell } 1390f931551bSRalph Campbell 1391f931551bSRalph Campbell rcd->rcvhdrq_size = amt; 1392f931551bSRalph Campbell } 1393f931551bSRalph Campbell 1394f931551bSRalph Campbell /* clear for security and sanity on each use */ 1395f931551bSRalph Campbell memset(rcd->rcvhdrq, 0, rcd->rcvhdrq_size); 1396f931551bSRalph Campbell if (rcd->rcvhdrtail_kvaddr) 1397f931551bSRalph Campbell memset(rcd->rcvhdrtail_kvaddr, 0, PAGE_SIZE); 1398f931551bSRalph Campbell return 0; 1399f931551bSRalph Campbell 1400f931551bSRalph Campbell bail_free: 1401f931551bSRalph Campbell qib_dev_err(dd, "attempt to allocate 1 page for ctxt %u " 1402f931551bSRalph Campbell "rcvhdrqtailaddr failed\n", rcd->ctxt); 1403f931551bSRalph Campbell vfree(rcd->user_event_mask); 1404f931551bSRalph Campbell rcd->user_event_mask = NULL; 1405f931551bSRalph Campbell bail_free_hdrq: 1406f931551bSRalph Campbell dma_free_coherent(&dd->pcidev->dev, amt, rcd->rcvhdrq, 1407f931551bSRalph Campbell rcd->rcvhdrq_phys); 1408f931551bSRalph Campbell rcd->rcvhdrq = NULL; 1409f931551bSRalph Campbell bail: 1410f931551bSRalph Campbell return -ENOMEM; 1411f931551bSRalph Campbell } 1412f931551bSRalph Campbell 1413f931551bSRalph Campbell /** 1414f931551bSRalph Campbell * allocate eager buffers, both kernel and user contexts. 1415f931551bSRalph Campbell * @rcd: the context we are setting up. 1416f931551bSRalph Campbell * 1417f931551bSRalph Campbell * Allocate the eager TID buffers and program them into hip. 1418f931551bSRalph Campbell * They are no longer completely contiguous, we do multiple allocation 1419f931551bSRalph Campbell * calls. Otherwise we get the OOM code involved, by asking for too 1420f931551bSRalph Campbell * much per call, with disastrous results on some kernels. 1421f931551bSRalph Campbell */ 1422f931551bSRalph Campbell int qib_setup_eagerbufs(struct qib_ctxtdata *rcd) 1423f931551bSRalph Campbell { 1424f931551bSRalph Campbell struct qib_devdata *dd = rcd->dd; 1425f931551bSRalph Campbell unsigned e, egrcnt, egrperchunk, chunk, egrsize, egroff; 1426f931551bSRalph Campbell size_t size; 1427f931551bSRalph Campbell gfp_t gfp_flags; 1428f931551bSRalph Campbell 1429f931551bSRalph Campbell /* 1430f931551bSRalph Campbell * GFP_USER, but without GFP_FS, so buffer cache can be 1431f931551bSRalph Campbell * coalesced (we hope); otherwise, even at order 4, 1432f931551bSRalph Campbell * heavy filesystem activity makes these fail, and we can 1433f931551bSRalph Campbell * use compound pages. 1434f931551bSRalph Campbell */ 1435f931551bSRalph Campbell gfp_flags = __GFP_WAIT | __GFP_IO | __GFP_COMP; 1436f931551bSRalph Campbell 1437f931551bSRalph Campbell egrcnt = rcd->rcvegrcnt; 1438f931551bSRalph Campbell egroff = rcd->rcvegr_tid_base; 1439f931551bSRalph Campbell egrsize = dd->rcvegrbufsize; 1440f931551bSRalph Campbell 1441f931551bSRalph Campbell chunk = rcd->rcvegrbuf_chunks; 1442f931551bSRalph Campbell egrperchunk = rcd->rcvegrbufs_perchunk; 1443f931551bSRalph Campbell size = rcd->rcvegrbuf_size; 1444f931551bSRalph Campbell if (!rcd->rcvegrbuf) { 1445f931551bSRalph Campbell rcd->rcvegrbuf = 1446f931551bSRalph Campbell kzalloc(chunk * sizeof(rcd->rcvegrbuf[0]), 1447f931551bSRalph Campbell GFP_KERNEL); 1448f931551bSRalph Campbell if (!rcd->rcvegrbuf) 1449f931551bSRalph Campbell goto bail; 1450f931551bSRalph Campbell } 1451f931551bSRalph Campbell if (!rcd->rcvegrbuf_phys) { 1452f931551bSRalph Campbell rcd->rcvegrbuf_phys = 1453f931551bSRalph Campbell kmalloc(chunk * sizeof(rcd->rcvegrbuf_phys[0]), 1454f931551bSRalph Campbell GFP_KERNEL); 1455f931551bSRalph Campbell if (!rcd->rcvegrbuf_phys) 1456f931551bSRalph Campbell goto bail_rcvegrbuf; 1457f931551bSRalph Campbell } 1458f931551bSRalph Campbell for (e = 0; e < rcd->rcvegrbuf_chunks; e++) { 1459f931551bSRalph Campbell if (rcd->rcvegrbuf[e]) 1460f931551bSRalph Campbell continue; 1461f931551bSRalph Campbell rcd->rcvegrbuf[e] = 1462f931551bSRalph Campbell dma_alloc_coherent(&dd->pcidev->dev, size, 1463f931551bSRalph Campbell &rcd->rcvegrbuf_phys[e], 1464f931551bSRalph Campbell gfp_flags); 1465f931551bSRalph Campbell if (!rcd->rcvegrbuf[e]) 1466f931551bSRalph Campbell goto bail_rcvegrbuf_phys; 1467f931551bSRalph Campbell } 1468f931551bSRalph Campbell 1469f931551bSRalph Campbell rcd->rcvegr_phys = rcd->rcvegrbuf_phys[0]; 1470f931551bSRalph Campbell 1471f931551bSRalph Campbell for (e = chunk = 0; chunk < rcd->rcvegrbuf_chunks; chunk++) { 1472f931551bSRalph Campbell dma_addr_t pa = rcd->rcvegrbuf_phys[chunk]; 1473f931551bSRalph Campbell unsigned i; 1474f931551bSRalph Campbell 1475f931551bSRalph Campbell for (i = 0; e < egrcnt && i < egrperchunk; e++, i++) { 1476f931551bSRalph Campbell dd->f_put_tid(dd, e + egroff + 1477f931551bSRalph Campbell (u64 __iomem *) 1478f931551bSRalph Campbell ((char __iomem *) 1479f931551bSRalph Campbell dd->kregbase + 1480f931551bSRalph Campbell dd->rcvegrbase), 1481f931551bSRalph Campbell RCVHQ_RCV_TYPE_EAGER, pa); 1482f931551bSRalph Campbell pa += egrsize; 1483f931551bSRalph Campbell } 1484f931551bSRalph Campbell cond_resched(); /* don't hog the cpu */ 1485f931551bSRalph Campbell } 1486f931551bSRalph Campbell 1487f931551bSRalph Campbell return 0; 1488f931551bSRalph Campbell 1489f931551bSRalph Campbell bail_rcvegrbuf_phys: 1490f931551bSRalph Campbell for (e = 0; e < rcd->rcvegrbuf_chunks && rcd->rcvegrbuf[e]; e++) 1491f931551bSRalph Campbell dma_free_coherent(&dd->pcidev->dev, size, 1492f931551bSRalph Campbell rcd->rcvegrbuf[e], rcd->rcvegrbuf_phys[e]); 1493f931551bSRalph Campbell kfree(rcd->rcvegrbuf_phys); 1494f931551bSRalph Campbell rcd->rcvegrbuf_phys = NULL; 1495f931551bSRalph Campbell bail_rcvegrbuf: 1496f931551bSRalph Campbell kfree(rcd->rcvegrbuf); 1497f931551bSRalph Campbell rcd->rcvegrbuf = NULL; 1498f931551bSRalph Campbell bail: 1499f931551bSRalph Campbell return -ENOMEM; 1500f931551bSRalph Campbell } 1501f931551bSRalph Campbell 1502fce24a9dSDave Olson /* 1503fce24a9dSDave Olson * Note: Changes to this routine should be mirrored 1504fce24a9dSDave Olson * for the diagnostics routine qib_remap_ioaddr32(). 1505fce24a9dSDave Olson * There is also related code for VL15 buffers in qib_init_7322_variables(). 1506fce24a9dSDave Olson * The teardown code that unmaps is in qib_pcie_ddcleanup() 1507fce24a9dSDave Olson */ 1508f931551bSRalph Campbell int init_chip_wc_pat(struct qib_devdata *dd, u32 vl15buflen) 1509f931551bSRalph Campbell { 1510f931551bSRalph Campbell u64 __iomem *qib_kregbase = NULL; 1511f931551bSRalph Campbell void __iomem *qib_piobase = NULL; 1512f931551bSRalph Campbell u64 __iomem *qib_userbase = NULL; 1513f931551bSRalph Campbell u64 qib_kreglen; 1514f931551bSRalph Campbell u64 qib_pio2koffset = dd->piobufbase & 0xffffffff; 1515f931551bSRalph Campbell u64 qib_pio4koffset = dd->piobufbase >> 32; 1516f931551bSRalph Campbell u64 qib_pio2klen = dd->piobcnt2k * dd->palign; 1517f931551bSRalph Campbell u64 qib_pio4klen = dd->piobcnt4k * dd->align4k; 1518f931551bSRalph Campbell u64 qib_physaddr = dd->physaddr; 1519f931551bSRalph Campbell u64 qib_piolen; 1520f931551bSRalph Campbell u64 qib_userlen = 0; 1521f931551bSRalph Campbell 1522f931551bSRalph Campbell /* 1523f931551bSRalph Campbell * Free the old mapping because the kernel will try to reuse the 1524f931551bSRalph Campbell * old mapping and not create a new mapping with the 1525f931551bSRalph Campbell * write combining attribute. 1526f931551bSRalph Campbell */ 1527f931551bSRalph Campbell iounmap(dd->kregbase); 1528f931551bSRalph Campbell dd->kregbase = NULL; 1529f931551bSRalph Campbell 1530f931551bSRalph Campbell /* 1531f931551bSRalph Campbell * Assumes chip address space looks like: 1532f931551bSRalph Campbell * - kregs + sregs + cregs + uregs (in any order) 1533f931551bSRalph Campbell * - piobufs (2K and 4K bufs in either order) 1534f931551bSRalph Campbell * or: 1535f931551bSRalph Campbell * - kregs + sregs + cregs (in any order) 1536f931551bSRalph Campbell * - piobufs (2K and 4K bufs in either order) 1537f931551bSRalph Campbell * - uregs 1538f931551bSRalph Campbell */ 1539f931551bSRalph Campbell if (dd->piobcnt4k == 0) { 1540f931551bSRalph Campbell qib_kreglen = qib_pio2koffset; 1541f931551bSRalph Campbell qib_piolen = qib_pio2klen; 1542f931551bSRalph Campbell } else if (qib_pio2koffset < qib_pio4koffset) { 1543f931551bSRalph Campbell qib_kreglen = qib_pio2koffset; 1544f931551bSRalph Campbell qib_piolen = qib_pio4koffset + qib_pio4klen - qib_kreglen; 1545f931551bSRalph Campbell } else { 1546f931551bSRalph Campbell qib_kreglen = qib_pio4koffset; 1547f931551bSRalph Campbell qib_piolen = qib_pio2koffset + qib_pio2klen - qib_kreglen; 1548f931551bSRalph Campbell } 1549f931551bSRalph Campbell qib_piolen += vl15buflen; 1550f931551bSRalph Campbell /* Map just the configured ports (not all hw ports) */ 1551f931551bSRalph Campbell if (dd->uregbase > qib_kreglen) 1552f931551bSRalph Campbell qib_userlen = dd->ureg_align * dd->cfgctxts; 1553f931551bSRalph Campbell 1554f931551bSRalph Campbell /* Sanity checks passed, now create the new mappings */ 1555f931551bSRalph Campbell qib_kregbase = ioremap_nocache(qib_physaddr, qib_kreglen); 1556f931551bSRalph Campbell if (!qib_kregbase) 1557f931551bSRalph Campbell goto bail; 1558f931551bSRalph Campbell 1559f931551bSRalph Campbell qib_piobase = ioremap_wc(qib_physaddr + qib_kreglen, qib_piolen); 1560f931551bSRalph Campbell if (!qib_piobase) 1561f931551bSRalph Campbell goto bail_kregbase; 1562f931551bSRalph Campbell 1563f931551bSRalph Campbell if (qib_userlen) { 1564f931551bSRalph Campbell qib_userbase = ioremap_nocache(qib_physaddr + dd->uregbase, 1565f931551bSRalph Campbell qib_userlen); 1566f931551bSRalph Campbell if (!qib_userbase) 1567f931551bSRalph Campbell goto bail_piobase; 1568f931551bSRalph Campbell } 1569f931551bSRalph Campbell 1570f931551bSRalph Campbell dd->kregbase = qib_kregbase; 1571f931551bSRalph Campbell dd->kregend = (u64 __iomem *) 1572f931551bSRalph Campbell ((char __iomem *) qib_kregbase + qib_kreglen); 1573f931551bSRalph Campbell dd->piobase = qib_piobase; 1574f931551bSRalph Campbell dd->pio2kbase = (void __iomem *) 1575f931551bSRalph Campbell (((char __iomem *) dd->piobase) + 1576f931551bSRalph Campbell qib_pio2koffset - qib_kreglen); 1577f931551bSRalph Campbell if (dd->piobcnt4k) 1578f931551bSRalph Campbell dd->pio4kbase = (void __iomem *) 1579f931551bSRalph Campbell (((char __iomem *) dd->piobase) + 1580f931551bSRalph Campbell qib_pio4koffset - qib_kreglen); 1581f931551bSRalph Campbell if (qib_userlen) 1582f931551bSRalph Campbell /* ureg will now be accessed relative to dd->userbase */ 1583f931551bSRalph Campbell dd->userbase = qib_userbase; 1584f931551bSRalph Campbell return 0; 1585f931551bSRalph Campbell 1586f931551bSRalph Campbell bail_piobase: 1587f931551bSRalph Campbell iounmap(qib_piobase); 1588f931551bSRalph Campbell bail_kregbase: 1589f931551bSRalph Campbell iounmap(qib_kregbase); 1590f931551bSRalph Campbell bail: 1591f931551bSRalph Campbell return -ENOMEM; 1592f931551bSRalph Campbell } 1593