1/* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (c) 2000-2007 Silicon Graphics, Inc. All Rights Reserved. 7 */ 8 9#include <linux/types.h> 10#include <asm/sn/sn_sal.h> 11#include "ioerror.h" 12#include <asm/sn/addrs.h> 13#include <asm/sn/shubio.h> 14#include <asm/sn/geo.h> 15#include "xtalk/xwidgetdev.h" 16#include "xtalk/hubdev.h" 17#include <asm/sn/bte.h> 18#include <asm/param.h> 19 20/* 21 * Bte error handling is done in two parts. The first captures 22 * any crb related errors. Since there can be multiple crbs per 23 * interface and multiple interfaces active, we need to wait until 24 * all active crbs are completed. This is the first job of the 25 * second part error handler. When all bte related CRBs are cleanly 26 * completed, it resets the interfaces and gets them ready for new 27 * transfers to be queued. 28 */ 29 30void bte_error_handler(unsigned long); 31 32/* 33 * Wait until all BTE related CRBs are completed 34 * and then reset the interfaces. 35 */ 36int shub1_bte_error_handler(unsigned long _nodepda) 37{ 38 struct nodepda_s *err_nodepda = (struct nodepda_s *)_nodepda; 39 struct timer_list *recovery_timer = &err_nodepda->bte_recovery_timer; 40 nasid_t nasid; 41 int i; 42 int valid_crbs; 43 ii_imem_u_t imem; /* II IMEM Register */ 44 ii_icrb0_d_u_t icrbd; /* II CRB Register D */ 45 ii_ibcr_u_t ibcr; 46 ii_icmr_u_t icmr; 47 ii_ieclr_u_t ieclr; 48 49 BTE_PRINTK(("shub1_bte_error_handler(%p) - %d\n", err_nodepda, 50 smp_processor_id())); 51 52 if ((err_nodepda->bte_if[0].bh_error == BTE_SUCCESS) && 53 (err_nodepda->bte_if[1].bh_error == BTE_SUCCESS)) { 54 BTE_PRINTK(("eh:%p:%d Nothing to do.\n", err_nodepda, 55 smp_processor_id())); 56 return 1; 57 } 58 59 /* Determine information about our hub */ 60 nasid = cnodeid_to_nasid(err_nodepda->bte_if[0].bte_cnode); 61 62 /* 63 * A BTE transfer can use multiple CRBs. We need to make sure 64 * that all the BTE CRBs are complete (or timed out) before 65 * attempting to clean up the error. Resetting the BTE while 66 * there are still BTE CRBs active will hang the BTE. 67 * We should look at all the CRBs to see if they are allocated 68 * to the BTE and see if they are still active. When none 69 * are active, we can continue with the cleanup. 70 * 71 * We also want to make sure that the local NI port is up. 72 * When a router resets the NI port can go down, while it 73 * goes through the LLP handshake, but then comes back up. 74 */ 75 icmr.ii_icmr_regval = REMOTE_HUB_L(nasid, IIO_ICMR); 76 if (icmr.ii_icmr_fld_s.i_crb_mark != 0) { 77 /* 78 * There are errors which still need to be cleaned up by 79 * hubiio_crb_error_handler 80 */ 81 mod_timer(recovery_timer, jiffies + (HZ * 5)); 82 BTE_PRINTK(("eh:%p:%d Marked Giving up\n", err_nodepda, 83 smp_processor_id())); 84 return 1; 85 } 86 if (icmr.ii_icmr_fld_s.i_crb_vld != 0) { 87 88 valid_crbs = icmr.ii_icmr_fld_s.i_crb_vld; 89 90 for (i = 0; i < IIO_NUM_CRBS; i++) { 91 if (!((1 << i) & valid_crbs)) { 92 /* This crb was not marked as valid, ignore */ 93 continue; 94 } 95 icrbd.ii_icrb0_d_regval = 96 REMOTE_HUB_L(nasid, IIO_ICRB_D(i)); 97 if (icrbd.d_bteop) { 98 mod_timer(recovery_timer, jiffies + (HZ * 5)); 99 BTE_PRINTK(("eh:%p:%d Valid %d, Giving up\n", 100 err_nodepda, smp_processor_id(), 101 i)); 102 return 1; 103 } 104 } 105 } 106 107 BTE_PRINTK(("eh:%p:%d Cleaning up\n", err_nodepda, smp_processor_id())); 108 /* Re-enable both bte interfaces */ 109 imem.ii_imem_regval = REMOTE_HUB_L(nasid, IIO_IMEM); 110 imem.ii_imem_fld_s.i_b0_esd = imem.ii_imem_fld_s.i_b1_esd = 1; 111 REMOTE_HUB_S(nasid, IIO_IMEM, imem.ii_imem_regval); 112 113 /* Clear BTE0/1 error bits */ 114 ieclr.ii_ieclr_regval = 0; 115 if (err_nodepda->bte_if[0].bh_error != BTE_SUCCESS) 116 ieclr.ii_ieclr_fld_s.i_e_bte_0 = 1; 117 if (err_nodepda->bte_if[1].bh_error != BTE_SUCCESS) 118 ieclr.ii_ieclr_fld_s.i_e_bte_1 = 1; 119 REMOTE_HUB_S(nasid, IIO_IECLR, ieclr.ii_ieclr_regval); 120 121 /* Reinitialize both BTE state machines. */ 122 ibcr.ii_ibcr_regval = REMOTE_HUB_L(nasid, IIO_IBCR); 123 ibcr.ii_ibcr_fld_s.i_soft_reset = 1; 124 REMOTE_HUB_S(nasid, IIO_IBCR, ibcr.ii_ibcr_regval); 125 126 del_timer(recovery_timer); 127 return 0; 128} 129 130/* 131 * Wait until all BTE related CRBs are completed 132 * and then reset the interfaces. 133 */ 134int shub2_bte_error_handler(unsigned long _nodepda) 135{ 136 struct nodepda_s *err_nodepda = (struct nodepda_s *)_nodepda; 137 struct timer_list *recovery_timer = &err_nodepda->bte_recovery_timer; 138 struct bteinfo_s *bte; 139 nasid_t nasid; 140 u64 status; 141 int i; 142 143 nasid = cnodeid_to_nasid(err_nodepda->bte_if[0].bte_cnode); 144 145 /* 146 * Verify that all the BTEs are complete 147 */ 148 for (i = 0; i < BTES_PER_NODE; i++) { 149 bte = &err_nodepda->bte_if[i]; 150 status = BTE_LNSTAT_LOAD(bte); 151 if (status & IBLS_ERROR) { 152 bte->bh_error = BTE_SHUB2_ERROR(status); 153 continue; 154 } 155 if (!(status & IBLS_BUSY)) 156 continue; 157 mod_timer(recovery_timer, jiffies + (HZ * 5)); 158 BTE_PRINTK(("eh:%p:%d Marked Giving up\n", err_nodepda, 159 smp_processor_id())); 160 return 1; 161 } 162 if (ia64_sn_bte_recovery(nasid)) 163 panic("bte_error_handler(): Fatal BTE Error"); 164 165 del_timer(recovery_timer); 166 return 0; 167} 168 169/* 170 * Wait until all BTE related CRBs are completed 171 * and then reset the interfaces. 172 */ 173void bte_error_handler(unsigned long _nodepda) 174{ 175 struct nodepda_s *err_nodepda = (struct nodepda_s *)_nodepda; 176 spinlock_t *recovery_lock = &err_nodepda->bte_recovery_lock; 177 int i; 178 unsigned long irq_flags; 179 volatile u64 *notify; 180 bte_result_t bh_error; 181 182 BTE_PRINTK(("bte_error_handler(%p) - %d\n", err_nodepda, 183 smp_processor_id())); 184 185 spin_lock_irqsave(recovery_lock, irq_flags); 186 187 /* 188 * Lock all interfaces on this node to prevent new transfers 189 * from being queued. 190 */ 191 for (i = 0; i < BTES_PER_NODE; i++) { 192 if (err_nodepda->bte_if[i].cleanup_active) { 193 continue; 194 } 195 spin_lock(&err_nodepda->bte_if[i].spinlock); 196 BTE_PRINTK(("eh:%p:%d locked %d\n", err_nodepda, 197 smp_processor_id(), i)); 198 err_nodepda->bte_if[i].cleanup_active = 1; 199 } 200 201 if (is_shub1()) { 202 if (shub1_bte_error_handler(_nodepda)) { 203 spin_unlock_irqrestore(recovery_lock, irq_flags); 204 return; 205 } 206 } else { 207 if (shub2_bte_error_handler(_nodepda)) { 208 spin_unlock_irqrestore(recovery_lock, irq_flags); 209 return; 210 } 211 } 212 213 for (i = 0; i < BTES_PER_NODE; i++) { 214 bh_error = err_nodepda->bte_if[i].bh_error; 215 if (bh_error != BTE_SUCCESS) { 216 /* There is an error which needs to be notified */ 217 notify = err_nodepda->bte_if[i].most_rcnt_na; 218 BTE_PRINTK(("cnode %d bte %d error=0x%lx\n", 219 err_nodepda->bte_if[i].bte_cnode, 220 err_nodepda->bte_if[i].bte_num, 221 IBLS_ERROR | (u64) bh_error)); 222 *notify = IBLS_ERROR | bh_error; 223 err_nodepda->bte_if[i].bh_error = BTE_SUCCESS; 224 } 225 226 err_nodepda->bte_if[i].cleanup_active = 0; 227 BTE_PRINTK(("eh:%p:%d Unlocked %d\n", err_nodepda, 228 smp_processor_id(), i)); 229 spin_unlock(&err_nodepda->bte_if[i].spinlock); 230 } 231 232 spin_unlock_irqrestore(recovery_lock, irq_flags); 233} 234 235/* 236 * First part error handler. This is called whenever any error CRB interrupt 237 * is generated by the II. 238 */ 239void 240bte_crb_error_handler(cnodeid_t cnode, int btenum, 241 int crbnum, ioerror_t * ioe, int bteop) 242{ 243 struct bteinfo_s *bte; 244 245 246 bte = &(NODEPDA(cnode)->bte_if[btenum]); 247 248 /* 249 * The caller has already figured out the error type, we save that 250 * in the bte handle structure for the thread exercising the 251 * interface to consume. 252 */ 253 bte->bh_error = ioe->ie_errortype + BTEFAIL_OFFSET; 254 bte->bte_error_count++; 255 256 BTE_PRINTK(("Got an error on cnode %d bte %d: HW error type 0x%x\n", 257 bte->bte_cnode, bte->bte_num, ioe->ie_errortype)); 258 bte_error_handler((unsigned long) NODEPDA(cnode)); 259} 260