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 if (ia64_platform_is("sn2") && (sal_revision == SAL_VERSION_CODE(2, 9))) 114 /* 115 * SGI Altix has hard-coded version 2.9 in their prom 116 * but they actually implement 3.2, so let's fix it here. 117 */ 118 sal_revision = SAL_VERSION_CODE(3, 2); 119 } 120 121 static void __init 122 sal_desc_entry_point (void *p) 123 { 124 struct ia64_sal_desc_entry_point *ep = p; 125 ia64_pal_handler_init(__va(ep->pal_proc)); 126 ia64_sal_handler_init(__va(ep->sal_proc), __va(ep->gp)); 127 } 128 129 #ifdef CONFIG_SMP 130 static void __init 131 set_smp_redirect (int flag) 132 { 133 #ifndef CONFIG_HOTPLUG_CPU 134 if (no_int_routing) 135 smp_int_redirect &= ~flag; 136 else 137 smp_int_redirect |= flag; 138 #else 139 /* 140 * For CPU Hotplug we dont want to do any chipset supported 141 * interrupt redirection. The reason is this would require that 142 * All interrupts be stopped and hard bind the irq to a cpu. 143 * Later when the interrupt is fired we need to set the redir hint 144 * on again in the vector. This is cumbersome for something that the 145 * user mode irq balancer will solve anyways. 146 */ 147 no_int_routing=1; 148 smp_int_redirect &= ~flag; 149 #endif 150 } 151 #else 152 #define set_smp_redirect(flag) do { } while (0) 153 #endif 154 155 static void __init 156 sal_desc_platform_feature (void *p) 157 { 158 struct ia64_sal_desc_platform_feature *pf = p; 159 sal_platform_features = pf->feature_mask; 160 161 printk(KERN_INFO "SAL Platform features:"); 162 if (!sal_platform_features) { 163 printk(" None\n"); 164 return; 165 } 166 167 if (sal_platform_features & IA64_SAL_PLATFORM_FEATURE_BUS_LOCK) 168 printk(" BusLock"); 169 if (sal_platform_features & IA64_SAL_PLATFORM_FEATURE_IRQ_REDIR_HINT) { 170 printk(" IRQ_Redirection"); 171 set_smp_redirect(SMP_IRQ_REDIRECTION); 172 } 173 if (sal_platform_features & IA64_SAL_PLATFORM_FEATURE_IPI_REDIR_HINT) { 174 printk(" IPI_Redirection"); 175 set_smp_redirect(SMP_IPI_REDIRECTION); 176 } 177 if (sal_platform_features & IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT) 178 printk(" ITC_Drift"); 179 printk("\n"); 180 } 181 182 #ifdef CONFIG_SMP 183 static void __init 184 sal_desc_ap_wakeup (void *p) 185 { 186 struct ia64_sal_desc_ap_wakeup *ap = p; 187 188 switch (ap->mechanism) { 189 case IA64_SAL_AP_EXTERNAL_INT: 190 ap_wakeup_vector = ap->vector; 191 printk(KERN_INFO "SAL: AP wakeup using external interrupt " 192 "vector 0x%lx\n", ap_wakeup_vector); 193 break; 194 default: 195 printk(KERN_ERR "SAL: AP wakeup mechanism unsupported!\n"); 196 break; 197 } 198 } 199 200 static void __init 201 chk_nointroute_opt(void) 202 { 203 char *cp; 204 205 for (cp = boot_command_line; *cp; ) { 206 if (memcmp(cp, "nointroute", 10) == 0) { 207 no_int_routing = 1; 208 printk ("no_int_routing on\n"); 209 break; 210 } else { 211 while (*cp != ' ' && *cp) 212 ++cp; 213 while (*cp == ' ') 214 ++cp; 215 } 216 } 217 } 218 219 #else 220 static void __init sal_desc_ap_wakeup(void *p) { } 221 #endif 222 223 /* 224 * HP rx5670 firmware polls for interrupts during SAL_CACHE_FLUSH by reading 225 * cr.ivr, but it never writes cr.eoi. This leaves any interrupt marked as 226 * "in-service" and masks other interrupts of equal or lower priority. 227 * 228 * HP internal defect reports: F1859, F2775, F3031. 229 */ 230 static int sal_cache_flush_drops_interrupts; 231 232 static int __init 233 force_pal_cache_flush(char *str) 234 { 235 sal_cache_flush_drops_interrupts = 1; 236 return 0; 237 } 238 early_param("force_pal_cache_flush", force_pal_cache_flush); 239 240 void __init 241 check_sal_cache_flush (void) 242 { 243 unsigned long flags; 244 int cpu; 245 u64 vector, cache_type = 3; 246 struct ia64_sal_retval isrv; 247 248 if (sal_cache_flush_drops_interrupts) 249 return; 250 251 cpu = get_cpu(); 252 local_irq_save(flags); 253 254 /* 255 * Send ourselves a timer interrupt, wait until it's reported, and see 256 * if SAL_CACHE_FLUSH drops it. 257 */ 258 platform_send_ipi(cpu, IA64_TIMER_VECTOR, IA64_IPI_DM_INT, 0); 259 260 while (!ia64_get_irr(IA64_TIMER_VECTOR)) 261 cpu_relax(); 262 263 SAL_CALL(isrv, SAL_CACHE_FLUSH, cache_type, 0, 0, 0, 0, 0, 0); 264 265 if (isrv.status) 266 printk(KERN_ERR "SAL_CAL_FLUSH failed with %ld\n", isrv.status); 267 268 if (ia64_get_irr(IA64_TIMER_VECTOR)) { 269 vector = ia64_get_ivr(); 270 ia64_eoi(); 271 WARN_ON(vector != IA64_TIMER_VECTOR); 272 } else { 273 sal_cache_flush_drops_interrupts = 1; 274 printk(KERN_ERR "SAL: SAL_CACHE_FLUSH drops interrupts; " 275 "PAL_CACHE_FLUSH will be used instead\n"); 276 ia64_eoi(); 277 } 278 279 local_irq_restore(flags); 280 put_cpu(); 281 } 282 283 s64 284 ia64_sal_cache_flush (u64 cache_type) 285 { 286 struct ia64_sal_retval isrv; 287 288 if (sal_cache_flush_drops_interrupts) { 289 unsigned long flags; 290 u64 progress; 291 s64 rc; 292 293 progress = 0; 294 local_irq_save(flags); 295 rc = ia64_pal_cache_flush(cache_type, 296 PAL_CACHE_FLUSH_INVALIDATE, &progress, NULL); 297 local_irq_restore(flags); 298 return rc; 299 } 300 301 SAL_CALL(isrv, SAL_CACHE_FLUSH, cache_type, 0, 0, 0, 0, 0, 0); 302 return isrv.status; 303 } 304 EXPORT_SYMBOL_GPL(ia64_sal_cache_flush); 305 306 void __init 307 ia64_sal_init (struct ia64_sal_systab *systab) 308 { 309 char *p; 310 int i; 311 312 if (!systab) { 313 printk(KERN_WARNING "Hmm, no SAL System Table.\n"); 314 return; 315 } 316 317 if (strncmp(systab->signature, "SST_", 4) != 0) 318 printk(KERN_ERR "bad signature in system table!"); 319 320 check_versions(systab); 321 #ifdef CONFIG_SMP 322 chk_nointroute_opt(); 323 #endif 324 325 /* revisions are coded in BCD, so %x does the job for us */ 326 printk(KERN_INFO "SAL %x.%x: %.32s %.32s%sversion %x.%x\n", 327 SAL_MAJOR(sal_revision), SAL_MINOR(sal_revision), 328 systab->oem_id, systab->product_id, 329 systab->product_id[0] ? " " : "", 330 SAL_MAJOR(sal_version), SAL_MINOR(sal_version)); 331 332 p = (char *) (systab + 1); 333 for (i = 0; i < systab->entry_count; i++) { 334 /* 335 * The first byte of each entry type contains the type 336 * descriptor. 337 */ 338 switch (*p) { 339 case SAL_DESC_ENTRY_POINT: 340 sal_desc_entry_point(p); 341 break; 342 case SAL_DESC_PLATFORM_FEATURE: 343 sal_desc_platform_feature(p); 344 break; 345 case SAL_DESC_PTC: 346 ia64_ptc_domain_info = (ia64_sal_desc_ptc_t *)p; 347 break; 348 case SAL_DESC_AP_WAKEUP: 349 sal_desc_ap_wakeup(p); 350 break; 351 } 352 p += SAL_DESC_SIZE(*p); 353 } 354 355 } 356 357 int 358 ia64_sal_oemcall(struct ia64_sal_retval *isrvp, u64 oemfunc, u64 arg1, 359 u64 arg2, u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7) 360 { 361 if (oemfunc < IA64_SAL_OEMFUNC_MIN || oemfunc > IA64_SAL_OEMFUNC_MAX) 362 return -1; 363 SAL_CALL(*isrvp, oemfunc, arg1, arg2, arg3, arg4, arg5, arg6, arg7); 364 return 0; 365 } 366 EXPORT_SYMBOL(ia64_sal_oemcall); 367 368 int 369 ia64_sal_oemcall_nolock(struct ia64_sal_retval *isrvp, u64 oemfunc, u64 arg1, 370 u64 arg2, u64 arg3, u64 arg4, u64 arg5, u64 arg6, 371 u64 arg7) 372 { 373 if (oemfunc < IA64_SAL_OEMFUNC_MIN || oemfunc > IA64_SAL_OEMFUNC_MAX) 374 return -1; 375 SAL_CALL_NOLOCK(*isrvp, oemfunc, arg1, arg2, arg3, arg4, arg5, arg6, 376 arg7); 377 return 0; 378 } 379 EXPORT_SYMBOL(ia64_sal_oemcall_nolock); 380 381 int 382 ia64_sal_oemcall_reentrant(struct ia64_sal_retval *isrvp, u64 oemfunc, 383 u64 arg1, u64 arg2, u64 arg3, u64 arg4, u64 arg5, 384 u64 arg6, u64 arg7) 385 { 386 if (oemfunc < IA64_SAL_OEMFUNC_MIN || oemfunc > IA64_SAL_OEMFUNC_MAX) 387 return -1; 388 SAL_CALL_REENTRANT(*isrvp, oemfunc, arg1, arg2, arg3, arg4, arg5, arg6, 389 arg7); 390 return 0; 391 } 392 EXPORT_SYMBOL(ia64_sal_oemcall_reentrant); 393 394 long 395 ia64_sal_freq_base (unsigned long which, unsigned long *ticks_per_second, 396 unsigned long *drift_info) 397 { 398 struct ia64_sal_retval isrv; 399 400 SAL_CALL(isrv, SAL_FREQ_BASE, which, 0, 0, 0, 0, 0, 0); 401 *ticks_per_second = isrv.v0; 402 *drift_info = isrv.v1; 403 return isrv.status; 404 } 405 EXPORT_SYMBOL_GPL(ia64_sal_freq_base); 406