Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 1 | /* |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 2 | * Copyright (c) 2005-2010 Brocade Communications Systems, Inc. |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 3 | * All rights reserved |
| 4 | * www.brocade.com |
| 5 | * |
| 6 | * Linux driver for Brocade Fibre Channel Host Bus Adapter. |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify it |
| 9 | * under the terms of the GNU General Public License (GPL) Version 2 as |
| 10 | * published by the Free Software Foundation |
| 11 | * |
| 12 | * This program is distributed in the hope that it will be useful, but |
| 13 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | * General Public License for more details. |
| 16 | */ |
| 17 | |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 18 | #include "bfa_ioc.h" |
| 19 | #include "bfi_ctreg.h" |
| 20 | #include "bfa_defs.h" |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 21 | |
| 22 | BFA_TRC_FILE(CNA, IOC_CT); |
| 23 | |
| 24 | /* |
| 25 | * forward declarations |
| 26 | */ |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 27 | static bfa_boolean_t bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc); |
| 28 | static void bfa_ioc_ct_firmware_unlock(struct bfa_ioc_s *ioc); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 29 | static void bfa_ioc_ct_reg_init(struct bfa_ioc_s *ioc); |
| 30 | static void bfa_ioc_ct_map_port(struct bfa_ioc_s *ioc); |
| 31 | static void bfa_ioc_ct_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix); |
| 32 | static void bfa_ioc_ct_notify_hbfail(struct bfa_ioc_s *ioc); |
| 33 | static void bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc); |
| 34 | |
Jing Huang | 293f82d | 2010-07-08 19:45:20 -0700 | [diff] [blame] | 35 | struct bfa_ioc_hwif_s hwif_ct; |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 36 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 37 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 38 | * Called from bfa_ioc_attach() to map asic specific calls. |
| 39 | */ |
| 40 | void |
| 41 | bfa_ioc_set_ct_hwif(struct bfa_ioc_s *ioc) |
| 42 | { |
Jing Huang | 293f82d | 2010-07-08 19:45:20 -0700 | [diff] [blame] | 43 | hwif_ct.ioc_pll_init = bfa_ioc_ct_pll_init; |
| 44 | hwif_ct.ioc_firmware_lock = bfa_ioc_ct_firmware_lock; |
| 45 | hwif_ct.ioc_firmware_unlock = bfa_ioc_ct_firmware_unlock; |
| 46 | hwif_ct.ioc_reg_init = bfa_ioc_ct_reg_init; |
| 47 | hwif_ct.ioc_map_port = bfa_ioc_ct_map_port; |
| 48 | hwif_ct.ioc_isr_mode_set = bfa_ioc_ct_isr_mode_set; |
| 49 | hwif_ct.ioc_notify_hbfail = bfa_ioc_ct_notify_hbfail; |
| 50 | hwif_ct.ioc_ownership_reset = bfa_ioc_ct_ownership_reset; |
| 51 | |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 52 | ioc->ioc_hwif = &hwif_ct; |
| 53 | } |
| 54 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 55 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 56 | * Return true if firmware of current driver matches the running firmware. |
| 57 | */ |
| 58 | static bfa_boolean_t |
| 59 | bfa_ioc_ct_firmware_lock(struct bfa_ioc_s *ioc) |
| 60 | { |
| 61 | enum bfi_ioc_state ioc_fwstate; |
Krishna Gudipati | d1c61f8 | 2010-03-05 19:38:44 -0800 | [diff] [blame] | 62 | u32 usecnt; |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 63 | struct bfi_ioc_image_hdr_s fwhdr; |
| 64 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 65 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 66 | * Firmware match check is relevant only for CNA. |
| 67 | */ |
| 68 | if (!ioc->cna) |
| 69 | return BFA_TRUE; |
| 70 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 71 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 72 | * If bios boot (flash based) -- do not increment usage count |
| 73 | */ |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 74 | if (bfa_cb_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)) < |
| 75 | BFA_IOC_FWIMG_MINSZ) |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 76 | return BFA_TRUE; |
| 77 | |
| 78 | bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg); |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 79 | usecnt = readl(ioc->ioc_regs.ioc_usage_reg); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 80 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 81 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 82 | * If usage count is 0, always return TRUE. |
| 83 | */ |
| 84 | if (usecnt == 0) { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 85 | writel(1, ioc->ioc_regs.ioc_usage_reg); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 86 | bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg); |
| 87 | bfa_trc(ioc, usecnt); |
| 88 | return BFA_TRUE; |
| 89 | } |
| 90 | |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 91 | ioc_fwstate = readl(ioc->ioc_regs.ioc_fwstate); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 92 | bfa_trc(ioc, ioc_fwstate); |
| 93 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 94 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 95 | * Use count cannot be non-zero and chip in uninitialized state. |
| 96 | */ |
| 97 | bfa_assert(ioc_fwstate != BFI_IOC_UNINIT); |
| 98 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 99 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 100 | * Check if another driver with a different firmware is active |
| 101 | */ |
| 102 | bfa_ioc_fwver_get(ioc, &fwhdr); |
| 103 | if (!bfa_ioc_fwver_cmp(ioc, &fwhdr)) { |
| 104 | bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg); |
| 105 | bfa_trc(ioc, usecnt); |
| 106 | return BFA_FALSE; |
| 107 | } |
| 108 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 109 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 110 | * Same firmware version. Increment the reference count. |
| 111 | */ |
| 112 | usecnt++; |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 113 | writel(usecnt, ioc->ioc_regs.ioc_usage_reg); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 114 | bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg); |
| 115 | bfa_trc(ioc, usecnt); |
| 116 | return BFA_TRUE; |
| 117 | } |
| 118 | |
| 119 | static void |
| 120 | bfa_ioc_ct_firmware_unlock(struct bfa_ioc_s *ioc) |
| 121 | { |
Krishna Gudipati | d1c61f8 | 2010-03-05 19:38:44 -0800 | [diff] [blame] | 122 | u32 usecnt; |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 123 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 124 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 125 | * Firmware lock is relevant only for CNA. |
Jing Huang | 293f82d | 2010-07-08 19:45:20 -0700 | [diff] [blame] | 126 | */ |
| 127 | if (!ioc->cna) |
| 128 | return; |
| 129 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 130 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 131 | * If bios boot (flash based) -- do not decrement usage count |
| 132 | */ |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 133 | if (bfa_cb_image_get_size(BFA_IOC_FWIMG_TYPE(ioc)) < |
| 134 | BFA_IOC_FWIMG_MINSZ) |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 135 | return; |
| 136 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 137 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 138 | * decrement usage count |
| 139 | */ |
| 140 | bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg); |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 141 | usecnt = readl(ioc->ioc_regs.ioc_usage_reg); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 142 | bfa_assert(usecnt > 0); |
| 143 | |
| 144 | usecnt--; |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 145 | writel(usecnt, ioc->ioc_regs.ioc_usage_reg); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 146 | bfa_trc(ioc, usecnt); |
| 147 | |
| 148 | bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg); |
| 149 | } |
| 150 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 151 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 152 | * Notify other functions on HB failure. |
| 153 | */ |
| 154 | static void |
| 155 | bfa_ioc_ct_notify_hbfail(struct bfa_ioc_s *ioc) |
| 156 | { |
Krishna Gudipati | 816e49b | 2010-03-05 19:36:56 -0800 | [diff] [blame] | 157 | if (ioc->cna) { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 158 | writel(__FW_INIT_HALT_P, ioc->ioc_regs.ll_halt); |
Krishna Gudipati | 816e49b | 2010-03-05 19:36:56 -0800 | [diff] [blame] | 159 | /* Wait for halt to take effect */ |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 160 | readl(ioc->ioc_regs.ll_halt); |
Krishna Gudipati | 816e49b | 2010-03-05 19:36:56 -0800 | [diff] [blame] | 161 | } else { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 162 | writel(__PSS_ERR_STATUS_SET, ioc->ioc_regs.err_set); |
| 163 | readl(ioc->ioc_regs.err_set); |
Krishna Gudipati | 816e49b | 2010-03-05 19:36:56 -0800 | [diff] [blame] | 164 | } |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 165 | } |
| 166 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 167 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 168 | * Host to LPU mailbox message addresses |
| 169 | */ |
Krishna Gudipati | d1c61f8 | 2010-03-05 19:38:44 -0800 | [diff] [blame] | 170 | static struct { u32 hfn_mbox, lpu_mbox, hfn_pgn; } iocreg_fnreg[] = { |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 171 | { HOSTFN0_LPU_MBOX0_0, LPU_HOSTFN0_MBOX0_0, HOST_PAGE_NUM_FN0 }, |
| 172 | { HOSTFN1_LPU_MBOX0_8, LPU_HOSTFN1_MBOX0_8, HOST_PAGE_NUM_FN1 }, |
| 173 | { HOSTFN2_LPU_MBOX0_0, LPU_HOSTFN2_MBOX0_0, HOST_PAGE_NUM_FN2 }, |
| 174 | { HOSTFN3_LPU_MBOX0_8, LPU_HOSTFN3_MBOX0_8, HOST_PAGE_NUM_FN3 } |
| 175 | }; |
| 176 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 177 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 178 | * Host <-> LPU mailbox command/status registers - port 0 |
| 179 | */ |
Krishna Gudipati | d1c61f8 | 2010-03-05 19:38:44 -0800 | [diff] [blame] | 180 | static struct { u32 hfn, lpu; } iocreg_mbcmd_p0[] = { |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 181 | { HOSTFN0_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN0_MBOX0_CMD_STAT }, |
| 182 | { HOSTFN1_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN1_MBOX0_CMD_STAT }, |
| 183 | { HOSTFN2_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN2_MBOX0_CMD_STAT }, |
| 184 | { HOSTFN3_LPU0_MBOX0_CMD_STAT, LPU0_HOSTFN3_MBOX0_CMD_STAT } |
| 185 | }; |
| 186 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 187 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 188 | * Host <-> LPU mailbox command/status registers - port 1 |
| 189 | */ |
Krishna Gudipati | d1c61f8 | 2010-03-05 19:38:44 -0800 | [diff] [blame] | 190 | static struct { u32 hfn, lpu; } iocreg_mbcmd_p1[] = { |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 191 | { HOSTFN0_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN0_MBOX0_CMD_STAT }, |
| 192 | { HOSTFN1_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN1_MBOX0_CMD_STAT }, |
| 193 | { HOSTFN2_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN2_MBOX0_CMD_STAT }, |
| 194 | { HOSTFN3_LPU1_MBOX0_CMD_STAT, LPU1_HOSTFN3_MBOX0_CMD_STAT } |
| 195 | }; |
| 196 | |
| 197 | static void |
| 198 | bfa_ioc_ct_reg_init(struct bfa_ioc_s *ioc) |
| 199 | { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 200 | void __iomem *rb; |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 201 | int pcifn = bfa_ioc_pcifn(ioc); |
| 202 | |
| 203 | rb = bfa_ioc_bar0(ioc); |
| 204 | |
| 205 | ioc->ioc_regs.hfn_mbox = rb + iocreg_fnreg[pcifn].hfn_mbox; |
| 206 | ioc->ioc_regs.lpu_mbox = rb + iocreg_fnreg[pcifn].lpu_mbox; |
| 207 | ioc->ioc_regs.host_page_num_fn = rb + iocreg_fnreg[pcifn].hfn_pgn; |
| 208 | |
| 209 | if (ioc->port_id == 0) { |
| 210 | ioc->ioc_regs.heartbeat = rb + BFA_IOC0_HBEAT_REG; |
| 211 | ioc->ioc_regs.ioc_fwstate = rb + BFA_IOC0_STATE_REG; |
| 212 | ioc->ioc_regs.hfn_mbox_cmd = rb + iocreg_mbcmd_p0[pcifn].hfn; |
| 213 | ioc->ioc_regs.lpu_mbox_cmd = rb + iocreg_mbcmd_p0[pcifn].lpu; |
| 214 | ioc->ioc_regs.ll_halt = rb + FW_INIT_HALT_P0; |
| 215 | } else { |
| 216 | ioc->ioc_regs.heartbeat = (rb + BFA_IOC1_HBEAT_REG); |
| 217 | ioc->ioc_regs.ioc_fwstate = (rb + BFA_IOC1_STATE_REG); |
| 218 | ioc->ioc_regs.hfn_mbox_cmd = rb + iocreg_mbcmd_p1[pcifn].hfn; |
| 219 | ioc->ioc_regs.lpu_mbox_cmd = rb + iocreg_mbcmd_p1[pcifn].lpu; |
| 220 | ioc->ioc_regs.ll_halt = rb + FW_INIT_HALT_P1; |
| 221 | } |
| 222 | |
| 223 | /* |
| 224 | * PSS control registers |
| 225 | */ |
| 226 | ioc->ioc_regs.pss_ctl_reg = (rb + PSS_CTL_REG); |
Krishna Gudipati | 8b651b4 | 2010-03-05 19:34:44 -0800 | [diff] [blame] | 227 | ioc->ioc_regs.pss_err_status_reg = (rb + PSS_ERR_STATUS_REG); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 228 | ioc->ioc_regs.app_pll_fast_ctl_reg = (rb + APP_PLL_425_CTL_REG); |
| 229 | ioc->ioc_regs.app_pll_slow_ctl_reg = (rb + APP_PLL_312_CTL_REG); |
| 230 | |
| 231 | /* |
| 232 | * IOC semaphore registers and serialization |
| 233 | */ |
| 234 | ioc->ioc_regs.ioc_sem_reg = (rb + HOST_SEM0_REG); |
| 235 | ioc->ioc_regs.ioc_usage_sem_reg = (rb + HOST_SEM1_REG); |
| 236 | ioc->ioc_regs.ioc_init_sem_reg = (rb + HOST_SEM2_REG); |
| 237 | ioc->ioc_regs.ioc_usage_reg = (rb + BFA_FW_USE_COUNT); |
| 238 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 239 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 240 | * sram memory access |
| 241 | */ |
| 242 | ioc->ioc_regs.smem_page_start = (rb + PSS_SMEM_PAGE_START); |
| 243 | ioc->ioc_regs.smem_pg0 = BFI_IOC_SMEM_PG0_CT; |
Krishna Gudipati | 816e49b | 2010-03-05 19:36:56 -0800 | [diff] [blame] | 244 | |
| 245 | /* |
| 246 | * err set reg : for notification of hb failure in fcmode |
| 247 | */ |
| 248 | ioc->ioc_regs.err_set = (rb + ERR_SET_REG); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 249 | } |
| 250 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 251 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 252 | * Initialize IOC to port mapping. |
| 253 | */ |
| 254 | |
| 255 | #define FNC_PERS_FN_SHIFT(__fn) ((__fn) * 8) |
| 256 | static void |
| 257 | bfa_ioc_ct_map_port(struct bfa_ioc_s *ioc) |
| 258 | { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 259 | void __iomem *rb = ioc->pcidev.pci_bar_kva; |
Krishna Gudipati | d1c61f8 | 2010-03-05 19:38:44 -0800 | [diff] [blame] | 260 | u32 r32; |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 261 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 262 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 263 | * For catapult, base port id on personality register and IOC type |
| 264 | */ |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 265 | r32 = readl(rb + FNC_PERS_REG); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 266 | r32 >>= FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc)); |
| 267 | ioc->port_id = (r32 & __F0_PORT_MAP_MK) >> __F0_PORT_MAP_SH; |
| 268 | |
| 269 | bfa_trc(ioc, bfa_ioc_pcifn(ioc)); |
| 270 | bfa_trc(ioc, ioc->port_id); |
| 271 | } |
| 272 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 273 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 274 | * Set interrupt mode for a function: INTX or MSIX |
| 275 | */ |
| 276 | static void |
| 277 | bfa_ioc_ct_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix) |
| 278 | { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 279 | void __iomem *rb = ioc->pcidev.pci_bar_kva; |
Krishna Gudipati | d1c61f8 | 2010-03-05 19:38:44 -0800 | [diff] [blame] | 280 | u32 r32, mode; |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 281 | |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 282 | r32 = readl(rb + FNC_PERS_REG); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 283 | bfa_trc(ioc, r32); |
| 284 | |
| 285 | mode = (r32 >> FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc))) & |
| 286 | __F0_INTX_STATUS; |
| 287 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 288 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 289 | * If already in desired mode, do not change anything |
| 290 | */ |
| 291 | if (!msix && mode) |
| 292 | return; |
| 293 | |
| 294 | if (msix) |
| 295 | mode = __F0_INTX_STATUS_MSIX; |
| 296 | else |
| 297 | mode = __F0_INTX_STATUS_INTA; |
| 298 | |
| 299 | r32 &= ~(__F0_INTX_STATUS << FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc))); |
| 300 | r32 |= (mode << FNC_PERS_FN_SHIFT(bfa_ioc_pcifn(ioc))); |
| 301 | bfa_trc(ioc, r32); |
| 302 | |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 303 | writel(r32, rb + FNC_PERS_REG); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 304 | } |
| 305 | |
Jing Huang | 5fbe25c | 2010-10-18 17:17:23 -0700 | [diff] [blame] | 306 | /* |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 307 | * Cleanup hw semaphore and usecnt registers |
| 308 | */ |
| 309 | static void |
| 310 | bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc) |
| 311 | { |
| 312 | |
| 313 | if (ioc->cna) { |
| 314 | bfa_ioc_sem_get(ioc->ioc_regs.ioc_usage_sem_reg); |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 315 | writel(0, ioc->ioc_regs.ioc_usage_reg); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 316 | bfa_ioc_sem_release(ioc->ioc_regs.ioc_usage_sem_reg); |
| 317 | } |
| 318 | |
| 319 | /* |
| 320 | * Read the hw sem reg to make sure that it is locked |
| 321 | * before we clear it. If it is not locked, writing 1 |
| 322 | * will lock it instead of clearing it. |
| 323 | */ |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 324 | readl(ioc->ioc_regs.ioc_sem_reg); |
Krishna Gudipati | 0a20de4 | 2010-03-05 19:34:20 -0800 | [diff] [blame] | 325 | bfa_ioc_hw_sem_release(ioc); |
| 326 | } |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 327 | |
| 328 | |
| 329 | |
| 330 | /* |
| 331 | * Check the firmware state to know if pll_init has been completed already |
| 332 | */ |
| 333 | bfa_boolean_t |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 334 | bfa_ioc_ct_pll_init_complete(void __iomem *rb) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 335 | { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 336 | if ((readl(rb + BFA_IOC0_STATE_REG) == BFI_IOC_OP) || |
| 337 | (readl(rb + BFA_IOC1_STATE_REG) == BFI_IOC_OP)) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 338 | return BFA_TRUE; |
| 339 | |
| 340 | return BFA_FALSE; |
| 341 | } |
| 342 | |
| 343 | bfa_status_t |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 344 | bfa_ioc_ct_pll_init(void __iomem *rb, bfa_boolean_t fcmode) |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 345 | { |
| 346 | u32 pll_sclk, pll_fclk, r32; |
| 347 | |
| 348 | pll_sclk = __APP_PLL_312_LRESETN | __APP_PLL_312_ENARST | |
| 349 | __APP_PLL_312_RSEL200500 | __APP_PLL_312_P0_1(3U) | |
| 350 | __APP_PLL_312_JITLMT0_1(3U) | |
| 351 | __APP_PLL_312_CNTLMT0_1(1U); |
| 352 | pll_fclk = __APP_PLL_425_LRESETN | __APP_PLL_425_ENARST | |
| 353 | __APP_PLL_425_RSEL200500 | __APP_PLL_425_P0_1(3U) | |
| 354 | __APP_PLL_425_JITLMT0_1(3U) | |
| 355 | __APP_PLL_425_CNTLMT0_1(1U); |
| 356 | if (fcmode) { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 357 | writel(0, (rb + OP_MODE)); |
| 358 | writel(__APP_EMS_CMLCKSEL | __APP_EMS_REFCKBUFEN2 | |
| 359 | __APP_EMS_CHANNEL_SEL, (rb + ETH_MAC_SER_REG)); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 360 | } else { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 361 | writel(__GLOBAL_FCOE_MODE, (rb + OP_MODE)); |
| 362 | writel(__APP_EMS_REFCKBUFEN1, (rb + ETH_MAC_SER_REG)); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 363 | } |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 364 | writel(BFI_IOC_UNINIT, (rb + BFA_IOC0_STATE_REG)); |
| 365 | writel(BFI_IOC_UNINIT, (rb + BFA_IOC1_STATE_REG)); |
| 366 | writel(0xffffffffU, (rb + HOSTFN0_INT_MSK)); |
| 367 | writel(0xffffffffU, (rb + HOSTFN1_INT_MSK)); |
| 368 | writel(0xffffffffU, (rb + HOSTFN0_INT_STATUS)); |
| 369 | writel(0xffffffffU, (rb + HOSTFN1_INT_STATUS)); |
| 370 | writel(0xffffffffU, (rb + HOSTFN0_INT_MSK)); |
| 371 | writel(0xffffffffU, (rb + HOSTFN1_INT_MSK)); |
| 372 | writel(pll_sclk | __APP_PLL_312_LOGIC_SOFT_RESET, |
| 373 | rb + APP_PLL_312_CTL_REG); |
| 374 | writel(pll_fclk | __APP_PLL_425_LOGIC_SOFT_RESET, |
| 375 | rb + APP_PLL_425_CTL_REG); |
| 376 | writel(pll_sclk | __APP_PLL_312_LOGIC_SOFT_RESET | __APP_PLL_312_ENABLE, |
| 377 | rb + APP_PLL_312_CTL_REG); |
| 378 | writel(pll_fclk | __APP_PLL_425_LOGIC_SOFT_RESET | __APP_PLL_425_ENABLE, |
| 379 | rb + APP_PLL_425_CTL_REG); |
| 380 | readl(rb + HOSTFN0_INT_MSK); |
Jing Huang | 6a18b16 | 2010-10-18 17:08:54 -0700 | [diff] [blame] | 381 | udelay(2000); |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 382 | writel(0xffffffffU, (rb + HOSTFN0_INT_STATUS)); |
| 383 | writel(0xffffffffU, (rb + HOSTFN1_INT_STATUS)); |
| 384 | writel(pll_sclk | __APP_PLL_312_ENABLE, rb + APP_PLL_312_CTL_REG); |
| 385 | writel(pll_fclk | __APP_PLL_425_ENABLE, rb + APP_PLL_425_CTL_REG); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 386 | if (!fcmode) { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 387 | writel(__PMM_1T_RESET_P, (rb + PMM_1T_RESET_REG_P0)); |
| 388 | writel(__PMM_1T_RESET_P, (rb + PMM_1T_RESET_REG_P1)); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 389 | } |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 390 | r32 = readl((rb + PSS_CTL_REG)); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 391 | r32 &= ~__PSS_LMEM_RESET; |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 392 | writel(r32, (rb + PSS_CTL_REG)); |
Jing Huang | 6a18b16 | 2010-10-18 17:08:54 -0700 | [diff] [blame] | 393 | udelay(1000); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 394 | if (!fcmode) { |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 395 | writel(0, (rb + PMM_1T_RESET_REG_P0)); |
| 396 | writel(0, (rb + PMM_1T_RESET_REG_P1)); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 397 | } |
| 398 | |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 399 | writel(__EDRAM_BISTR_START, (rb + MBIST_CTL_REG)); |
Jing Huang | 6a18b16 | 2010-10-18 17:08:54 -0700 | [diff] [blame] | 400 | udelay(1000); |
Jing Huang | 5344026 | 2010-10-18 17:12:29 -0700 | [diff] [blame] | 401 | r32 = readl((rb + MBIST_STAT_REG)); |
| 402 | writel(0, (rb + MBIST_CTL_REG)); |
Krishna Gudipati | a36c61f | 2010-09-15 11:50:55 -0700 | [diff] [blame] | 403 | return BFA_STATUS_OK; |
| 404 | } |