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