litmus-rt.git - The LITMUS^RT kernel.

diff options

Diffstat (limited to 'arch/x86/xen/setup.c')

-rw-r--r--

1 files changed, 14 insertions, 27 deletions

         for (i = 0; i < memmap.nr_entries; i++) {
                 unsigned long long end = map[i].addr + map[i].size;
-                if (map[i].type == E820_RAM) {
+                if (map[i].type == E820_RAM && end > mem_end) {
-                        if (map[i].addr < mem_end && end > mem_end) {
+                        /* RAM off the end - may be partially included */
-                                /* Truncate region to max_mem. */
+                        u64 delta = min(map[i].size, end - mem_end);
-                                u64 delta = end - mem_end;
-                                map[i].size -= delta;
+                        map[i].size -= delta;
-                                extra_pages += PFN_DOWN(delta);
+                        end -= delta;
-                                end = mem_end;
+                        extra_pages += PFN_DOWN(delta);
-                        }
                 }
-                if (end > xen_extra_mem_start)
+                if (map[i].size > 0 && end > xen_extra_mem_start)
                         xen_extra_mem_start = end;
-                /* If region is non-RAM or below mem_end, add what remains */
+                /* Add region if any remains */
-                if ((map[i].type != E820_RAM || map[i].addr < mem_end) &&
+                if (map[i].size > 0)
-                    map[i].size > 0)
                         e820_add_region(map[i].addr, map[i].size, map[i].type);
         }
         return "Xen";
 }
-static void xen_idle(void)
-{
-        local_irq_disable();
-        if (need_resched())
-                local_irq_enable();
-        else {
-                current_thread_info()->status &= ~TS_POLLING;
-                smp_mb__after_clear_bit();
-                safe_halt();
-                current_thread_info()->status |= TS_POLLING;
-        }
-}
 /*
  * Set the bit indicating "nosegneg" library variants should be used.
  * We only need to bother in pure 32-bit mode; compat 32-bit processes
                MAX_GUEST_CMDLINE > COMMAND_LINE_SIZE ?
                COMMAND_LINE_SIZE : MAX_GUEST_CMDLINE);
-        pm_idle = xen_idle;
+        /* Set up idle, making sure it calls safe_halt() pvop */
+#ifdef CONFIG_X86_32
+        boot_cpu_data.hlt_works_ok = 1;
+#endif
+        pm_idle = default_idle;
         fiddle_vdso();
 }

/* * Copyright (c) 2005-2010 Brocade Communications Systems, Inc. * All rights reserved * www.brocade.com * * Linux driver for Brocade Fibre Channel Host Bus Adapter. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License (GPL) Version 2 as * published by the Free Software Foundation * * This program is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. */ /* * bfad.c Linux driver PCI interface module. */ #include <linux/module.h> #include <linux/kthread.h> #include <linux/errno.h> #include <linux/sched.h> #include <linux/init.h> #include <linux/fs.h> #include <linux/pci.h> #include <linux/firmware.h> #include <asm/uaccess.h> #include <asm/fcntl.h> #include "bfad_drv.h" #include "bfad_im.h" #include "bfa_fcs.h" #include "bfa_os_inc.h" #include "bfa_defs.h" #include "bfa.h" BFA_TRC_FILE(LDRV, BFAD); DEFINE_MUTEX(bfad_mutex); LIST_HEAD(bfad_list); static int bfad_inst; static int num_sgpgs_parm; int supported_fc4s; char *host_name, *os_name, *os_patch; int num_rports, num_ios, num_tms; int num_fcxps, num_ufbufs; int reqq_size, rspq_size, num_sgpgs; int rport_del_timeout = BFA_FCS_RPORT_DEF_DEL_TIMEOUT; int bfa_lun_queue_depth = BFAD_LUN_QUEUE_DEPTH; int bfa_io_max_sge = BFAD_IO_MAX_SGE; int bfa_log_level = 3; /* WARNING log level */ int ioc_auto_recover = BFA_TRUE; int bfa_linkup_delay = -1; int fdmi_enable = BFA_TRUE; int pcie_max_read_reqsz; int bfa_debugfs_enable = 1; int msix_disable_cb = 0, msix_disable_ct = 0; u32 bfi_image_ct_fc_size, bfi_image_ct_cna_size, bfi_image_cb_fc_size; u32 *bfi_image_ct_fc, *bfi_image_ct_cna, *bfi_image_cb_fc; const char *msix_name_ct[] = { "cpe0", "cpe1", "cpe2", "cpe3", "rme0", "rme1", "rme2", "rme3", "ctrl" }; const char *msix_name_cb[] = { "cpe0", "cpe1", "cpe2", "cpe3", "rme0", "rme1", "rme2", "rme3", "eemc", "elpu0", "elpu1", "epss", "mlpu" }; MODULE_FIRMWARE(BFAD_FW_FILE_CT_FC); MODULE_FIRMWARE(BFAD_FW_FILE_CT_CNA); MODULE_FIRMWARE(BFAD_FW_FILE_CB_FC); module_param(os_name, charp, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(os_name, "OS name of the hba host machine"); module_param(os_patch, charp, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(os_patch, "OS patch level of the hba host machine"); module_param(host_name, charp, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(host_name, "Hostname of the hba host machine"); module_param(num_rports, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(num_rports, "Max number of rports supported per port " "(physical/logical), default=1024"); module_param(num_ios, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(num_ios, "Max number of ioim requests, default=2000"); module_param(num_tms, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(num_tms, "Max number of task im requests, default=128"); module_param(num_fcxps, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(num_fcxps, "Max number of fcxp requests, default=64"); module_param(num_ufbufs, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(num_ufbufs, "Max number of unsolicited frame " "buffers, default=64"); module_param(reqq_size, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(reqq_size, "Max number of request queue elements, " "default=256"); module_param(rspq_size, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(rspq_size, "Max number of response queue elements, " "default=64"); module_param(num_sgpgs, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(num_sgpgs, "Number of scatter/gather pages, default=2048"); module_param(rport_del_timeout, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(rport_del_timeout, "Rport delete timeout, default=90 secs, " "Range[>0]"); module_param(bfa_lun_queue_depth, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(bfa_lun_queue_depth, "Lun queue depth, default=32, Range[>0]"); module_param(bfa_io_max_sge, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(bfa_io_max_sge, "Max io scatter/gather elements, default=255"); module_param(bfa_log_level, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(bfa_log_level, "Driver log level, default=3, " "Range[Critical:1|Error:2|Warning:3|Info:4]"); module_param(ioc_auto_recover, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(ioc_auto_recover, "IOC auto recovery, default=1, " "Range[off:0|on:1]"); module_param(bfa_linkup_delay, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(bfa_linkup_delay, "Link up delay, default=30 secs for " "boot port. Otherwise 10 secs in RHEL4 & 0 for " "[RHEL5, SLES10, ESX40] Range[>0]"); module_param(msix_disable_cb, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(msix_disable_cb, "Disable Message Signaled Interrupts " "for Brocade-415/425/815/825 cards, default=0, " " Range[false:0|true:1]"); module_param(msix_disable_ct, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(msix_disable_ct, "Disable Message Signaled Interrupts " "if possible for Brocade-1010/1020/804/1007/902/1741 " "cards, default=0, Range[false:0|true:1]"); module_param(fdmi_enable, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(fdmi_enable, "Enables fdmi registration, default=1, " "Range[false:0|true:1]"); module_param(pcie_max_read_reqsz, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(pcie_max_read_reqsz, "PCIe max read request size, default=0 " "(use system setting), Range[128|256|512|1024|2048|4096]"); module_param(bfa_debugfs_enable, int, S_IRUGO | S_IWUSR); MODULE_PARM_DESC(bfa_debugfs_enable, "Enables debugfs feature, default=1," " Range[false:0|true:1]"); static void bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event); static void bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event); static void bfad_sm_initializing(struct bfad_s *bfad, enum bfad_sm_event event); static void bfad_sm_operational(struct bfad_s *bfad, enum bfad_sm_event event); static void bfad_sm_stopping(struct bfad_s *bfad, enum bfad_sm_event event); static void bfad_sm_failed(struct bfad_s *bfad, enum bfad_sm_event event); static void bfad_sm_fcs_exit(struct bfad_s *bfad, enum bfad_sm_event event); /* * Beginning state for the driver instance, awaiting the pci_probe event */ static void bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event) { bfa_trc(bfad, event); switch (event) { case BFAD_E_CREATE: bfa_sm_set_state(bfad, bfad_sm_created); bfad->bfad_tsk = kthread_create(bfad_worker, (void *) bfad, "%s", "bfad_worker"); if (IS_ERR(bfad->bfad_tsk)) { printk(KERN_INFO "bfad[%d]: Kernel thread " "creation failed!\n", bfad->inst_no); bfa_sm_send_event(bfad, BFAD_E_KTHREAD_CREATE_FAILED); } bfa_sm_send_event(bfad, BFAD_E_INIT); break; case BFAD_E_STOP: /* Ignore stop; already in uninit */ break; default: bfa_sm_fault(bfad, event); } } /* * Driver Instance is created, awaiting event INIT to initialize the bfad */ static void bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event) { unsigned long flags; bfa_trc(bfad, event); switch (event) { case BFAD_E_INIT: bfa_sm_set_state(bfad, bfad_sm_initializing); init_completion(&bfad->comp); /* Enable Interrupt and wait bfa_init completion */ if (bfad_setup_intr(bfad)) { printk(KERN_WARNING "bfad%d: bfad_setup_intr failed\n", bfad->inst_no); bfa_sm_send_event(bfad, BFAD_E_INTR_INIT_FAILED); break; } spin_lock_irqsave(&bfad->bfad_lock, flags); bfa_init(&bfad->bfa); spin_unlock_irqrestore(&bfad->bfad_lock, flags); /* Set up interrupt handler for each vectors */ if ((bfad->bfad_flags & BFAD_MSIX_ON) && bfad_install_msix_handler(bfad)) { printk(KERN_WARNING "%s: install_msix failed, bfad%d\n", __func__, bfad->inst_no); } bfad_init_timer(bfad); wait_for_completion(&bfad->comp); if ((bfad->bfad_flags & BFAD_HAL_INIT_DONE)) { bfa_sm_send_event(bfad, BFAD_E_INIT_SUCCESS); } else { bfad->bfad_flags |= BFAD_HAL_INIT_FAIL; bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED); } break; case BFAD_E_KTHREAD_CREATE_FAILED: bfa_sm_set_state(bfad, bfad_sm_uninit); break; default: bfa_sm_fault(bfad, event); } } static void bfad_sm_initializing(struct bfad_s *bfad, enum bfad_sm_event event) { int retval; unsigned long flags; bfa_trc(bfad, event); switch (event) { case BFAD_E_INIT_SUCCESS: kthread_stop(bfad->bfad_tsk); spin_lock_irqsave(&bfad->bfad_lock, flags); bfad->bfad_tsk = NULL; spin_unlock_irqrestore(&bfad->bfad_lock, flags); retval = bfad_start_ops(bfad); if (retval != BFA_STATUS_OK) break; bfa_sm_set_state(bfad, bfad_sm_operational); break; case BFAD_E_INTR_INIT_FAILED: bfa_sm_set_state(bfad, bfad_sm_uninit); kthread_stop(bfad->bfad_tsk); spin_lock_irqsave(&bfad->bfad_lock, flags); bfad->bfad_tsk = NULL; spin_unlock_irqrestore(&bfad->bfad_lock, flags); break; case BFAD_E_INIT_FAILED: bfa_sm_set_state(bfad, bfad_sm_failed); break; default: bfa_sm_fault(bfad, event); } } static void bfad_sm_failed(struct bfad_s *bfad, enum bfad_sm_event event) { int retval; bfa_trc(bfad, event); switch (event) { case BFAD_E_INIT_SUCCESS: retval = bfad_start_ops(bfad); if (retval != BFA_STATUS_OK) break; bfa_sm_set_state(bfad, bfad_sm_operational); break; case BFAD_E_STOP: if (bfad->bfad_flags & BFAD_CFG_PPORT_DONE) bfad_uncfg_pport(bfad); if (bfad->bfad_flags & BFAD_FC4_PROBE_DONE) { bfad_im_probe_undo(bfad); bfad->bfad_flags &= ~BFAD_FC4_PROBE_DONE; } bfad_stop(bfad); break; case BFAD_E_EXIT_COMP: bfa_sm_set_state(bfad, bfad_sm_uninit); bfad_remove_intr(bfad); del_timer_sync(&bfad->hal_tmo); break; default: bfa_sm_fault(bfad, event); } } static void bfad_sm_operational(struct bfad_s *bfad, enum bfad_sm_event event) { bfa_trc(bfad, event); switch (event) { case BFAD_E_STOP: bfa_sm_set_state(bfad, bfad_sm_fcs_exit); bfad_fcs_stop(bfad); break; default: bfa_sm_fault(bfad, event); } } static void bfad_sm_fcs_exit(struct bfad_s *bfad, enum bfad_sm_event event) { bfa_trc(bfad, event); switch (event) { case BFAD_E_FCS_EXIT_COMP: bfa_sm_set_state(bfad, bfad_sm_stopping); bfad_stop(bfad); break; default: bfa_sm_fault(bfad, event); } } static void bfad_sm_stopping(struct bfad_s *bfad, enum bfad_sm_event event) { bfa_trc(bfad, event); switch (event) { case BFAD_E_EXIT_COMP: bfa_sm_set_state(bfad, bfad_sm_uninit); bfad_remove_intr(bfad); del_timer_sync(&bfad->hal_tmo); bfad_im_probe_undo(bfad); bfad->bfad_flags &= ~BFAD_FC4_PROBE_DONE; bfad_uncfg_pport(bfad); break; default: bfa_sm_fault(bfad, event); break; } } /* * BFA callbacks */ void bfad_hcb_comp(void *arg, bfa_status_t status) { struct bfad_hal_comp *fcomp = (struct bfad_hal_comp *)arg; fcomp->status = status; complete(&fcomp->comp); } /* * bfa_init callback */ void bfa_cb_init(void *drv, bfa_status_t init_status) { struct bfad_s *bfad = drv; if (init_status == BFA_STATUS_OK) { bfad->bfad_flags |= BFAD_HAL_INIT_DONE; /* * If BFAD_HAL_INIT_FAIL flag is set: * Wake up the kernel thread to start * the bfad operations after HAL init done */ if ((bfad->bfad_flags & BFAD_HAL_INIT_FAIL)) { bfad->bfad_flags &= ~BFAD_HAL_INIT_FAIL; wake_up_process(bfad->bfad_tsk); } } complete(&bfad->comp); } /* * BFA_FCS callbacks */ struct bfad_port_s * bfa_fcb_lport_new(struct bfad_s *bfad, struct bfa_fcs_lport_s *port, enum bfa_lport_role roles, struct bfad_vf_s *vf_drv, struct bfad_vport_s *vp_drv) { bfa_status_t rc; struct bfad_port_s *port_drv; if (!vp_drv && !vf_drv) { port_drv = &bfad->pport; port_drv->pvb_type = BFAD_PORT_PHYS_BASE; } else if (!vp_drv && vf_drv) { port_drv = &vf_drv->base_port; port_drv->pvb_type = BFAD_PORT_VF_BASE; } else if (vp_drv && !vf_drv) { port_drv = &vp_drv->drv_port; port_drv->pvb_type = BFAD_PORT_PHYS_VPORT; } else { port_drv = &vp_drv->drv_port; port_drv->pvb_type = BFAD_PORT_VF_VPORT; } port_drv->fcs_port = port; port_drv->roles = roles; if (roles & BFA_LPORT_ROLE_FCP_IM) { rc = bfad_im_port_new(bfad, port_drv); if (rc != BFA_STATUS_OK) { bfad_im_port_delete(bfad, port_drv); port_drv = NULL; } } return port_drv; } void bfa_fcb_lport_delete(struct bfad_s *bfad, enum bfa_lport_role roles, struct bfad_vf_s *vf_drv, struct bfad_vport_s *vp_drv) { struct bfad_port_s *port_drv; /* this will be only called from rmmod context */ if (vp_drv && !vp_drv->comp_del) { port_drv = (vp_drv) ? (&(vp_drv)->drv_port) : ((vf_drv) ? (&(vf_drv)->base_port) : (&(bfad)->pport)); bfa_trc(bfad, roles); if (roles & BFA_LPORT_ROLE_FCP_IM) bfad_im_port_delete(bfad, port_drv); } } /* * FCS RPORT alloc callback, after successful PLOGI by FCS */ bfa_status_t bfa_fcb_rport_alloc(struct bfad_s *bfad, struct bfa_fcs_rport_s **rport, struct bfad_rport_s **rport_drv) { bfa_status_t rc = BFA_STATUS_OK; *rport_drv = kzalloc(sizeof(struct bfad_rport_s), GFP_ATOMIC); if (*rport_drv == NULL) { rc = BFA_STATUS_ENOMEM; goto ext; } *rport = &(*rport_drv)->fcs_rport; ext: return rc; } /* * FCS PBC VPORT Create */ void bfa_fcb_pbc_vport_create(struct bfad_s *bfad, struct bfi_pbc_vport_s pbc_vport) { struct bfa_lport_cfg_s port_cfg = {0}; struct bfad_vport_s *vport; int rc; vport = kzalloc(sizeof(struct bfad_vport_s), GFP_KERNEL); if (!vport) { bfa_trc(bfad, 0); return; } vport->drv_port.bfad = bfad; port_cfg.roles = BFA_LPORT_ROLE_FCP_IM; port_cfg.pwwn = pbc_vport.vp_pwwn; port_cfg.nwwn = pbc_vport.vp_nwwn; port_cfg.preboot_vp = BFA_TRUE; rc = bfa_fcs_pbc_vport_create(&vport->fcs_vport, &bfad->bfa_fcs, 0, &port_cfg, vport); if (rc != BFA_STATUS_OK) { bfa_trc(bfad, 0); return; } list_add_tail(&vport->list_entry, &bfad->pbc_vport_list); } void bfad_hal_mem_release(struct bfad_s *bfad) { int i; struct bfa_meminfo_s *hal_meminfo = &bfad->meminfo; struct bfa_mem_elem_s *meminfo_elem; for (i = 0; i < BFA_MEM_TYPE_MAX; i++) { meminfo_elem = &hal_meminfo->meminfo[i]; if (meminfo_elem->kva != NULL) { switch (meminfo_elem->mem_type) { case BFA_MEM_TYPE_KVA: vfree(meminfo_elem->kva); break; case BFA_MEM_TYPE_DMA: dma_free_coherent(&bfad->pcidev->dev, meminfo_elem->mem_len, meminfo_elem->kva, (dma_addr_t) meminfo_elem->dma); break; default: bfa_assert(0); break; } } } memset(hal_meminfo, 0, sizeof(struct bfa_meminfo_s)); } void bfad_update_hal_cfg(struct bfa_iocfc_cfg_s *bfa_cfg) { if (num_rports > 0) bfa_cfg->fwcfg.num_rports = num_rports; if (num_ios > 0) bfa_cfg->fwcfg.num_ioim_reqs = num_ios; if (num_tms > 0) bfa_cfg->fwcfg.num_tskim_reqs = num_tms; if (num_fcxps > 0) bfa_cfg->fwcfg.num_fcxp_reqs = num_fcxps; if (num_ufbufs > 0) bfa_cfg->fwcfg.num_uf_bufs = num_ufbufs; if (reqq_size > 0) bfa_cfg->drvcfg.num_reqq_elems = reqq_size; if (rspq_size > 0) bfa_cfg->drvcfg.num_rspq_elems = rspq_size; if (num_sgpgs > 0) bfa_cfg->drvcfg.num_sgpgs = num_sgpgs; /* * populate the hal values back to the driver for sysfs use. * otherwise, the default values will be shown as 0 in sysfs */ num_rports = bfa_cfg->fwcfg.num_rports; num_ios = bfa_cfg->fwcfg.num_ioim_reqs; num_tms = bfa_cfg->fwcfg.num_tskim_reqs; num_fcxps = bfa_cfg->fwcfg.num_fcxp_reqs; num_ufbufs = bfa_cfg->fwcfg.num_uf_bufs; reqq_size = bfa_cfg->drvcfg.num_reqq_elems; rspq_size = bfa_cfg->drvcfg.num_rspq_elems; num_sgpgs = bfa_cfg->drvcfg.num_sgpgs; } bfa_status_t bfad_hal_mem_alloc(struct bfad_s *bfad) { int i; struct bfa_meminfo_s *hal_meminfo = &bfad->meminfo; struct bfa_mem_elem_s *meminfo_elem; dma_addr_t phys_addr; void *kva; bfa_status_t rc = BFA_STATUS_OK; int retry_count = 0; int reset_value = 1; int min_num_sgpgs = 512; bfa_cfg_get_default(&bfad->ioc_cfg); retry: bfad_update_hal_cfg(&bfad->ioc_cfg); bfad->cfg_data.ioc_queue_depth = bfad->ioc_cfg.fwcfg.num_ioim_reqs; bfa_cfg_get_meminfo(&bfad->ioc_cfg, hal_meminfo); for (i = 0; i < BFA_MEM_TYPE_MAX; i++) { meminfo_elem = &hal_meminfo->meminfo[i]; switch (meminfo_elem->mem_type) { case BFA_MEM_TYPE_KVA: kva = vmalloc(meminfo_elem->mem_len); if (kva == NULL) { bfad_hal_mem_release(bfad); rc = BFA_STATUS_ENOMEM; goto ext; } memset(kva, 0, meminfo_elem->mem_len); meminfo_elem->kva = kva; break; case BFA_MEM_TYPE_DMA: kva = dma_alloc_coherent(&bfad->pcidev->dev, meminfo_elem->mem_len, &phys_addr, GFP_KERNEL); if (kva == NULL) { bfad_hal_mem_release(bfad); /* * If we cannot allocate with default * num_sgpages try with half the value. */ if (num_sgpgs > min_num_sgpgs) { printk(KERN_INFO "bfad[%d]: memory allocation failed" " with num_sgpgs: %d\n", bfad->inst_no, num_sgpgs); nextLowerInt(&num_sgpgs); printk(KERN_INFO "bfad[%d]: trying to allocate memory" " with num_sgpgs: %d\n", bfad->inst_no, num_sgpgs); retry_count++; goto retry; } else { if (num_sgpgs_parm > 0) num_sgpgs = num_sgpgs_parm; else { reset_value = (1 << retry_count); num_sgpgs *= reset_value; } rc = BFA_STATUS_ENOMEM; goto ext; } } if (num_sgpgs_parm > 0) num_sgpgs = num_sgpgs_parm; else { reset_value = (1 << retry_count); num_sgpgs *= reset_value; } memset(kva, 0, meminfo_elem->mem_len); meminfo_elem->kva = kva; meminfo_elem->dma = phys_addr; break; default: break; } } ext: return rc; } /* * Create a vport under a vf. */ bfa_status_t bfad_vport_create(struct bfad_s *bfad, u16 vf_id, struct bfa_lport_cfg_s *port_cfg, struct device *dev) { struct bfad_vport_s *vport; int rc = BFA_STATUS_OK; unsigned long flags; struct completion fcomp; vport = kzalloc(sizeof(struct bfad_vport_s), GFP_KERNEL); if (!vport) { rc = BFA_STATUS_ENOMEM; goto ext; } vport->drv_port.bfad = bfad; spin_lock_irqsave(&bfad->bfad_lock, flags); rc = bfa_fcs_vport_create(&vport->fcs_vport, &bfad->bfa_fcs, vf_id, port_cfg, vport); spin_unlock_irqrestore(&bfad->bfad_lock, flags); if (rc != BFA_STATUS_OK) goto ext_free_vport; if (port_cfg->roles & BFA_LPORT_ROLE_FCP_IM) { rc = bfad_im_scsi_host_alloc(bfad, vport->drv_port.im_port, dev); if (rc != BFA_STATUS_OK) goto ext_free_fcs_vport; } spin_lock_irqsave(&bfad->bfad_lock, flags); bfa_fcs_vport_start(&vport->fcs_vport); spin_unlock_irqrestore(&bfad->bfad_lock, flags); return BFA_STATUS_OK; ext_free_fcs_vport: spin_lock_irqsave(&bfad->bfad_lock, flags); vport->comp_del = &fcomp; init_completion(vport->comp_del); bfa_fcs_vport_delete(&vport->fcs_vport); spin_unlock_irqrestore(&bfad->bfad_lock, flags); wait_for_completion(vport->comp_del); ext_free_vport: kfree(vport); ext: return rc; } void bfad_bfa_tmo(unsigned long data) { struct bfad_s *bfad = (struct bfad_s *) data; unsigned long flags; struct list_head doneq; spin_lock_irqsave(&bfad->bfad_lock, flags); bfa_timer_tick(&bfad->bfa); bfa_comp_deq(&bfad->bfa, &doneq); spin_unlock_irqrestore(&bfad->bfad_lock, flags); if (!list_empty(&doneq)) { bfa_comp_process(&bfad->bfa, &doneq); spin_lock_irqsave(&bfad->bfad_lock, flags); bfa_comp_free(&bfad->bfa, &doneq); spin_unlock_irqrestore(&bfad->bfad_lock, flags); } mod_timer(&bfad->hal_tmo, jiffies + msecs_to_jiffies(BFA_TIMER_FREQ)); } void bfad_init_timer(struct bfad_s *bfad) { init_timer(&bfad->hal_tmo); bfad->hal_tmo.function = bfad_bfa_tmo; bfad->hal_tmo.data = (unsigned long)bfad; mod_timer(&bfad->hal_tmo, jiffies + msecs_to_jiffies(BFA_TIMER_FREQ)); } int bfad_pci_init(struct pci_dev *pdev, struct bfad_s *bfad) { int rc = -ENODEV; if (pci_enable_device(pdev)) { printk(KERN_ERR "pci_enable_device fail %p\n", pdev); goto out; } if (pci_request_regions(pdev, BFAD_DRIVER_NAME)) goto out_disable_device; pci_set_master(pdev); if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) { printk(KERN_ERR "pci_set_dma_mask fail %p\n", pdev); goto out_release_region; } bfad->pci_bar0_kva = pci_iomap(pdev, 0, pci_resource_len(pdev, 0)); if (bfad->pci_bar0_kva == NULL) { printk(KERN_ERR "Fail to map bar0\n"); goto out_release_region; } bfad->hal_pcidev.pci_slot = PCI_SLOT(pdev->devfn); bfad->hal_pcidev.pci_func = PCI_FUNC(pdev->devfn); bfad->hal_pcidev.pci_bar_kva = bfad->pci_bar0_kva; bfad->hal_pcidev.device_id = pdev->device; bfad->pci_name = pci_name(pdev); bfad->pci_attr.vendor_id = pdev->vendor; bfad->pci_attr.device_id = pdev->device; bfad->pci_attr.ssid = pdev->subsystem_device; bfad->pci_attr.ssvid = pdev->subsystem_vendor; bfad->pci_attr.pcifn = PCI_FUNC(pdev->devfn); bfad->pcidev = pdev; /* Adjust PCIe Maximum Read Request Size */ if (pcie_max_read_reqsz > 0) { int pcie_cap_reg; u16 pcie_dev_ctl; u16 mask = 0xffff; switch (pcie_max_read_reqsz) { case 128: mask = 0x0; break; case 256: mask = 0x1000; break; case 512: mask = 0x2000; break; case 1024: mask = 0x3000; break; case 2048: mask = 0x4000; break; case 4096: mask = 0x5000; break; default: break; } pcie_cap_reg = pci_find_capability(pdev, PCI_CAP_ID_EXP);


context:
space:
mode: