1 /* 2 * System Abstraction Layer (SAL) interface routines. 3 * 4 * Copyright (C) 1998, 1999, 2001, 2003 Hewlett-Packard Co 5 * David Mosberger-Tang <davidm@hpl.hp.com> 6 * Copyright (C) 1999 VA Linux Systems 7 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com> 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/init.h> 12 #include <linux/module.h> 13 #include <linux/spinlock.h> 14 #include <linux/string.h> 15 16 #include <asm/delay.h> 17 #include <asm/page.h> 18 #include <asm/sal.h> 19 #include <asm/pal.h> 20 21 __cacheline_aligned DEFINE_SPINLOCK(sal_lock); 22 unsigned long sal_platform_features; 23 24 unsigned short sal_revision; 25 unsigned short sal_version; 26 27 #define SAL_MAJOR(x) ((x) >> 8) 28 #define SAL_MINOR(x) ((x) & 0xff) 29 30 static struct { 31 void *addr; /* function entry point */ 32 void *gpval; /* gp value to use */ 33 } pdesc; 34 35 static long 36 default_handler (void) 37 { 38 return -1; 39 } 40 41 ia64_sal_handler ia64_sal = (ia64_sal_handler) default_handler; 42 ia64_sal_desc_ptc_t *ia64_ptc_domain_info; 43 44 const char * 45 ia64_sal_strerror (long status) 46 { 47 const char *str; 48 switch (status) { 49 case 0: str = "Call completed without error"; break; 50 case 1: str = "Effect a warm boot of the system to complete " 51 "the update"; break; 52 case -1: str = "Not implemented"; break; 53 case -2: str = "Invalid argument"; break; 54 case -3: str = "Call completed with error"; break; 55 case -4: str = "Virtual address not registered"; break; 56 case -5: str = "No information available"; break; 57 case -6: str = "Insufficient space to add the entry"; break; 58 case -7: str = "Invalid entry_addr value"; break; 59 case -8: str = "Invalid interrupt vector"; break; 60 case -9: str = "Requested memory not available"; break; 61 case -10: str = "Unable to write to the NVM device"; break; 62 case -11: str = "Invalid partition type specified"; break; 63 case -12: str = "Invalid NVM_Object id specified"; break; 64 case -13: str = "NVM_Object already has the maximum number " 65 "of partitions"; break; 66 case -14: str = "Insufficient space in partition for the " 67 "requested write sub-function"; break; 68 case -15: str = "Insufficient data buffer space for the " 69 "requested read record sub-function"; break; 70 case -16: str = "Scratch buffer required for the write/delete " 71 "sub-function"; break; 72 case -17: str = "Insufficient space in the NVM_Object for the " 73 "requested create sub-function"; break; 74 case -18: str = "Invalid value specified in the partition_rec " 75 "argument"; break; 76 case -19: str = "Record oriented I/O not supported for this " 77 "partition"; break; 78 case -20: str = "Bad format of record to be written or " 79 "required keyword variable not " 80 "specified"; break; 81 default: str = "Unknown SAL status code"; break; 82 } 83 return str; 84 } 85 86 void __init 87 ia64_sal_handler_init (void *entry_point, void *gpval) 88 { 89 /* fill in the SAL procedure descriptor and point ia64_sal to it: */ 90 pdesc.addr = entry_point; 91 pdesc.gpval = gpval; 92 ia64_sal = (ia64_sal_handler) &pdesc; 93 } 94 95 static void __init 96 check_versions (struct ia64_sal_systab *systab) 97 { 98 sal_revision = (systab->sal_rev_major << 8) | systab->sal_rev_minor; 99 sal_version = (systab->sal_b_rev_major << 8) | systab->sal_b_rev_minor; 100 101 /* Check for broken firmware */ 102 if ((sal_revision == SAL_VERSION_CODE(49, 29)) 103 && (sal_version == SAL_VERSION_CODE(49, 29))) 104 { 105 /* 106 * Old firmware for zx2000 prototypes have this weird version number, 107 * reset it to something sane. 108 */ 109 sal_revision = SAL_VERSION_CODE(2, 8); 110 sal_version = SAL_VERSION_CODE(0, 0); 111 } 112 } 113 114 static void __init 115 sal_desc_entry_point (void *p) 116 { 117 struct ia64_sal_desc_entry_point *ep = p; 118 ia64_pal_handler_init(__va(ep->pal_proc)); 119 ia64_sal_handler_init(__va(ep->sal_proc), __va(ep->gp)); 120 } 121 122 #ifdef CONFIG_SMP 123 static void __init 124 set_smp_redirect (int flag) 125 { 126 #ifndef CONFIG_HOTPLUG_CPU 127 if (no_int_routing) 128 smp_int_redirect &= ~flag; 129 else 130 smp_int_redirect |= flag; 131 #else 132 /* 133 * For CPU Hotplug we dont want to do any chipset supported 134 * interrupt redirection. The reason is this would require that 135 * All interrupts be stopped and hard bind the irq to a cpu. 136 * Later when the interrupt is fired we need to set the redir hint 137 * on again in the vector. This is cumbersome for something that the 138 * user mode irq balancer will solve anyways. 139 */ 140 no_int_routing=1; 141 smp_int_redirect &= ~flag; 142 #endif 143 } 144 #else 145 #define set_smp_redirect(flag) do { } while (0) 146 #endif 147 148 static void __init 149 sal_desc_platform_feature (void *p) 150 { 151 struct ia64_sal_desc_platform_feature *pf = p; 152 sal_platform_features = pf->feature_mask; 153 154 printk(KERN_INFO "SAL Platform features:"); 155 if (!sal_platform_features) { 156 printk(" None\n"); 157 return; 158 } 159 160 if (sal_platform_features & IA64_SAL_PLATFORM_FEATURE_BUS_LOCK) 161 printk(" BusLock"); 162 if (sal_platform_features & IA64_SAL_PLATFORM_FEATURE_IRQ_REDIR_HINT) { 163 printk(" IRQ_Redirection"); 164 set_smp_redirect(SMP_IRQ_REDIRECTION); 165 } 166 if (sal_platform_features & IA64_SAL_PLATFORM_FEATURE_IPI_REDIR_HINT) { 167 printk(" IPI_Redirection"); 168 set_smp_redirect(SMP_IPI_REDIRECTION); 169 } 170 if (sal_platform_features & IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT) 171 printk(" ITC_Drift"); 172 printk("\n"); 173 } 174 175 #ifdef CONFIG_SMP 176 static void __init 177 sal_desc_ap_wakeup (void *p) 178 { 179 struct ia64_sal_desc_ap_wakeup *ap = p; 180 181 switch (ap->mechanism) { 182 case IA64_SAL_AP_EXTERNAL_INT: 183 ap_wakeup_vector = ap->vector; 184 printk(KERN_INFO "SAL: AP wakeup using external interrupt " 185 "vector 0x%lx\n", ap_wakeup_vector); 186 break; 187 default: 188 printk(KERN_ERR "SAL: AP wakeup mechanism unsupported!\n"); 189 break; 190 } 191 } 192 193 static void __init 194 chk_nointroute_opt(void) 195 { 196 char *cp; 197 198 for (cp = boot_command_line; *cp; ) { 199 if (memcmp(cp, "nointroute", 10) == 0) { 200 no_int_routing = 1; 201 printk ("no_int_routing on\n"); 202 break; 203 } else { 204 while (*cp != ' ' && *cp) 205 ++cp; 206 while (*cp == ' ') 207 ++cp; 208 } 209 } 210 } 211 212 #else 213 static void __init sal_desc_ap_wakeup(void *p) { } 214 #endif 215 216 /* 217 * HP rx5670 firmware polls for interrupts during SAL_CACHE_FLUSH by reading 218 * cr.ivr, but it never writes cr.eoi. This leaves any interrupt marked as 219 * "in-service" and masks other interrupts of equal or lower priority. 220 * 221 * HP internal defect reports: F1859, F2775, F3031. 222 */ 223 static int sal_cache_flush_drops_interrupts; 224 225 void __init 226 check_sal_cache_flush (void) 227 { 228 unsigned long flags; 229 int cpu; 230 u64 vector, cache_type = 3; 231 struct ia64_sal_retval isrv; 232 233 cpu = get_cpu(); 234 local_irq_save(flags); 235 236 /* 237 * Schedule a timer interrupt, wait until it's reported, and see if 238 * SAL_CACHE_FLUSH drops it. 239 */ 240 ia64_set_itv(IA64_TIMER_VECTOR); 241 ia64_set_itm(ia64_get_itc() + 1000); 242 243 while (!ia64_get_irr(IA64_TIMER_VECTOR)) 244 cpu_relax(); 245 246 SAL_CALL(isrv, SAL_CACHE_FLUSH, cache_type, 0, 0, 0, 0, 0, 0); 247 248 if (isrv.status) 249 printk(KERN_ERR "SAL_CAL_FLUSH failed with %ld\n", isrv.status); 250 251 if (ia64_get_irr(IA64_TIMER_VECTOR)) { 252 vector = ia64_get_ivr(); 253 ia64_eoi(); 254 WARN_ON(vector != IA64_TIMER_VECTOR); 255 } else { 256 sal_cache_flush_drops_interrupts = 1; 257 printk(KERN_ERR "SAL: SAL_CACHE_FLUSH drops interrupts; " 258 "PAL_CACHE_FLUSH will be used instead\n"); 259 ia64_eoi(); 260 } 261 262 local_irq_restore(flags); 263 put_cpu(); 264 } 265 266 s64 267 ia64_sal_cache_flush (u64 cache_type) 268 { 269 struct ia64_sal_retval isrv; 270 271 if (sal_cache_flush_drops_interrupts) { 272 unsigned long flags; 273 u64 progress; 274 s64 rc; 275 276 progress = 0; 277 local_irq_save(flags); 278 rc = ia64_pal_cache_flush(cache_type, 279 PAL_CACHE_FLUSH_INVALIDATE, &progress, NULL); 280 local_irq_restore(flags); 281 return rc; 282 } 283 284 SAL_CALL(isrv, SAL_CACHE_FLUSH, cache_type, 0, 0, 0, 0, 0, 0); 285 return isrv.status; 286 } 287 288 void __init 289 ia64_sal_init (struct ia64_sal_systab *systab) 290 { 291 char *p; 292 int i; 293 294 if (!systab) { 295 printk(KERN_WARNING "Hmm, no SAL System Table.\n"); 296 return; 297 } 298 299 if (strncmp(systab->signature, "SST_", 4) != 0) 300 printk(KERN_ERR "bad signature in system table!"); 301 302 check_versions(systab); 303 #ifdef CONFIG_SMP 304 chk_nointroute_opt(); 305 #endif 306 307 /* revisions are coded in BCD, so %x does the job for us */ 308 printk(KERN_INFO "SAL %x.%x: %.32s %.32s%sversion %x.%x\n", 309 SAL_MAJOR(sal_revision), SAL_MINOR(sal_revision), 310 systab->oem_id, systab->product_id, 311 systab->product_id[0] ? " " : "", 312 SAL_MAJOR(sal_version), SAL_MINOR(sal_version)); 313 314 p = (char *) (systab + 1); 315 for (i = 0; i < systab->entry_count; i++) { 316 /* 317 * The first byte of each entry type contains the type 318 * descriptor. 319 */ 320 switch (*p) { 321 case SAL_DESC_ENTRY_POINT: 322 sal_desc_entry_point(p); 323 break; 324 case SAL_DESC_PLATFORM_FEATURE: 325 sal_desc_platform_feature(p); 326 break; 327 case SAL_DESC_PTC: 328 ia64_ptc_domain_info = (ia64_sal_desc_ptc_t *)p; 329 break; 330 case SAL_DESC_AP_WAKEUP: 331 sal_desc_ap_wakeup(p); 332 break; 333 } 334 p += SAL_DESC_SIZE(*p); 335 } 336 337 } 338 339 int 340 ia64_sal_oemcall(struct ia64_sal_retval *isrvp, u64 oemfunc, u64 arg1, 341 u64 arg2, u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7) 342 { 343 if (oemfunc < IA64_SAL_OEMFUNC_MIN || oemfunc > IA64_SAL_OEMFUNC_MAX) 344 return -1; 345 SAL_CALL(*isrvp, oemfunc, arg1, arg2, arg3, arg4, arg5, arg6, arg7); 346 return 0; 347 } 348 EXPORT_SYMBOL(ia64_sal_oemcall); 349 350 int 351 ia64_sal_oemcall_nolock(struct ia64_sal_retval *isrvp, u64 oemfunc, u64 arg1, 352 u64 arg2, u64 arg3, u64 arg4, u64 arg5, u64 arg6, 353 u64 arg7) 354 { 355 if (oemfunc < IA64_SAL_OEMFUNC_MIN || oemfunc > IA64_SAL_OEMFUNC_MAX) 356 return -1; 357 SAL_CALL_NOLOCK(*isrvp, oemfunc, arg1, arg2, arg3, arg4, arg5, arg6, 358 arg7); 359 return 0; 360 } 361 EXPORT_SYMBOL(ia64_sal_oemcall_nolock); 362 363 int 364 ia64_sal_oemcall_reentrant(struct ia64_sal_retval *isrvp, u64 oemfunc, 365 u64 arg1, u64 arg2, u64 arg3, u64 arg4, u64 arg5, 366 u64 arg6, u64 arg7) 367 { 368 if (oemfunc < IA64_SAL_OEMFUNC_MIN || oemfunc > IA64_SAL_OEMFUNC_MAX) 369 return -1; 370 SAL_CALL_REENTRANT(*isrvp, oemfunc, arg1, arg2, arg3, arg4, arg5, arg6, 371 arg7); 372 return 0; 373 } 374 EXPORT_SYMBOL(ia64_sal_oemcall_reentrant); 375