1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54#include <stdarg.h>
55
56#include <linux/delay.h>
57#include <linux/init.h>
58#include <linux/kernel.h>
59#include <linux/module.h>
60#include <linux/string.h>
61#include <linux/spinlock.h>
62
63#include <asm/page.h>
64#include <asm/pdc.h>
65#include <asm/pdcpat.h>
66#include <asm/processor.h>
67
68#if defined(BOOTLOADER)
69# undef spin_lock_irqsave
70# define spin_lock_irqsave(a, b) { b = 1; }
71# undef spin_unlock_irqrestore
72# define spin_unlock_irqrestore(a, b)
73#else
74static DEFINE_SPINLOCK(pdc_lock);
75#endif
76
77extern unsigned long pdc_result[NUM_PDC_RESULT];
78extern unsigned long pdc_result2[NUM_PDC_RESULT];
79
80#ifdef CONFIG_64BIT
81#define WIDE_FIRMWARE 0x1
82#define NARROW_FIRMWARE 0x2
83
84
85
86int parisc_narrow_firmware __ro_after_init = 1;
87#endif
88
89
90
91
92
93
94
95
96
97
98
99
100#ifdef CONFIG_64BIT
101long real64_call(unsigned long function, ...);
102#endif
103long real32_call(unsigned long function, ...);
104
105#ifdef CONFIG_64BIT
106# define MEM_PDC (unsigned long)(PAGE0->mem_pdc_hi) << 32 | PAGE0->mem_pdc
107# define mem_pdc_call(args...) unlikely(parisc_narrow_firmware) ? real32_call(MEM_PDC, args) : real64_call(MEM_PDC, args)
108#else
109# define MEM_PDC (unsigned long)PAGE0->mem_pdc
110# define mem_pdc_call(args...) real32_call(MEM_PDC, args)
111#endif
112
113
114
115
116
117
118
119
120
121static unsigned long f_extend(unsigned long address)
122{
123#ifdef CONFIG_64BIT
124 if(unlikely(parisc_narrow_firmware)) {
125 if((address & 0xff000000) == 0xf0000000)
126 return 0xf0f0f0f000000000UL | (u32)address;
127
128 if((address & 0xf0000000) == 0xf0000000)
129 return 0xffffffff00000000UL | (u32)address;
130 }
131#endif
132 return address;
133}
134
135
136
137
138
139
140
141
142
143static void convert_to_wide(unsigned long *addr)
144{
145#ifdef CONFIG_64BIT
146 int i;
147 unsigned int *p = (unsigned int *)addr;
148
149 if (unlikely(parisc_narrow_firmware)) {
150 for (i = (NUM_PDC_RESULT-1); i >= 0; --i)
151 addr[i] = p[i];
152 }
153#endif
154}
155
156#ifdef CONFIG_64BIT
157void set_firmware_width_unlocked(void)
158{
159 int ret;
160
161 ret = mem_pdc_call(PDC_MODEL, PDC_MODEL_CAPABILITIES,
162 __pa(pdc_result), 0);
163 convert_to_wide(pdc_result);
164 if (pdc_result[0] != NARROW_FIRMWARE)
165 parisc_narrow_firmware = 0;
166}
167
168
169
170
171
172
173
174void set_firmware_width(void)
175{
176 unsigned long flags;
177 spin_lock_irqsave(&pdc_lock, flags);
178 set_firmware_width_unlocked();
179 spin_unlock_irqrestore(&pdc_lock, flags);
180}
181#else
182void set_firmware_width_unlocked(void)
183{
184 return;
185}
186
187void set_firmware_width(void)
188{
189 return;
190}
191#endif
192
193
194#if !defined(BOOTLOADER)
195
196
197
198
199
200
201void pdc_emergency_unlock(void)
202{
203
204 if (spin_is_locked(&pdc_lock))
205 spin_unlock(&pdc_lock);
206}
207
208
209
210
211
212
213
214
215
216
217
218int pdc_add_valid(unsigned long address)
219{
220 int retval;
221 unsigned long flags;
222
223 spin_lock_irqsave(&pdc_lock, flags);
224 retval = mem_pdc_call(PDC_ADD_VALID, PDC_ADD_VALID_VERIFY, address);
225 spin_unlock_irqrestore(&pdc_lock, flags);
226
227 return retval;
228}
229EXPORT_SYMBOL(pdc_add_valid);
230
231
232
233
234
235
236
237int __init pdc_instr(unsigned int *instr)
238{
239 int retval;
240 unsigned long flags;
241
242 spin_lock_irqsave(&pdc_lock, flags);
243 retval = mem_pdc_call(PDC_INSTR, 0UL, __pa(pdc_result));
244 convert_to_wide(pdc_result);
245 *instr = pdc_result[0];
246 spin_unlock_irqrestore(&pdc_lock, flags);
247
248 return retval;
249}
250
251
252
253
254
255
256
257
258
259int __init pdc_chassis_info(struct pdc_chassis_info *chassis_info, void *led_info, unsigned long len)
260{
261 int retval;
262 unsigned long flags;
263
264 spin_lock_irqsave(&pdc_lock, flags);
265 memcpy(&pdc_result, chassis_info, sizeof(*chassis_info));
266 memcpy(&pdc_result2, led_info, len);
267 retval = mem_pdc_call(PDC_CHASSIS, PDC_RETURN_CHASSIS_INFO,
268 __pa(pdc_result), __pa(pdc_result2), len);
269 memcpy(chassis_info, pdc_result, sizeof(*chassis_info));
270 memcpy(led_info, pdc_result2, len);
271 spin_unlock_irqrestore(&pdc_lock, flags);
272
273 return retval;
274}
275
276
277
278
279
280
281
282#ifdef CONFIG_64BIT
283int pdc_pat_chassis_send_log(unsigned long state, unsigned long data)
284{
285 int retval = 0;
286 unsigned long flags;
287
288 if (!is_pdc_pat())
289 return -1;
290
291 spin_lock_irqsave(&pdc_lock, flags);
292 retval = mem_pdc_call(PDC_PAT_CHASSIS_LOG, PDC_PAT_CHASSIS_WRITE_LOG, __pa(&state), __pa(&data));
293 spin_unlock_irqrestore(&pdc_lock, flags);
294
295 return retval;
296}
297#endif
298
299
300
301
302
303int pdc_chassis_disp(unsigned long disp)
304{
305 int retval = 0;
306 unsigned long flags;
307
308 spin_lock_irqsave(&pdc_lock, flags);
309 retval = mem_pdc_call(PDC_CHASSIS, PDC_CHASSIS_DISP, disp);
310 spin_unlock_irqrestore(&pdc_lock, flags);
311
312 return retval;
313}
314
315
316
317
318
319int __pdc_cpu_rendezvous(void)
320{
321 if (is_pdc_pat())
322 return mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_RENDEZVOUS);
323 else
324 return mem_pdc_call(PDC_PROC, 1, 0);
325}
326
327
328
329
330
331
332int pdc_chassis_warn(unsigned long *warn)
333{
334 int retval = 0;
335 unsigned long flags;
336
337 spin_lock_irqsave(&pdc_lock, flags);
338 retval = mem_pdc_call(PDC_CHASSIS, PDC_CHASSIS_WARN, __pa(pdc_result));
339 *warn = pdc_result[0];
340 spin_unlock_irqrestore(&pdc_lock, flags);
341
342 return retval;
343}
344
345int pdc_coproc_cfg_unlocked(struct pdc_coproc_cfg *pdc_coproc_info)
346{
347 int ret;
348
349 ret = mem_pdc_call(PDC_COPROC, PDC_COPROC_CFG, __pa(pdc_result));
350 convert_to_wide(pdc_result);
351 pdc_coproc_info->ccr_functional = pdc_result[0];
352 pdc_coproc_info->ccr_present = pdc_result[1];
353 pdc_coproc_info->revision = pdc_result[17];
354 pdc_coproc_info->model = pdc_result[18];
355
356 return ret;
357}
358
359
360
361
362
363
364
365
366int pdc_coproc_cfg(struct pdc_coproc_cfg *pdc_coproc_info)
367{
368 int ret;
369 unsigned long flags;
370
371 spin_lock_irqsave(&pdc_lock, flags);
372 ret = pdc_coproc_cfg_unlocked(pdc_coproc_info);
373 spin_unlock_irqrestore(&pdc_lock, flags);
374
375 return ret;
376}
377
378
379
380
381
382
383
384
385
386
387
388
389int pdc_iodc_read(unsigned long *actcnt, unsigned long hpa, unsigned int index,
390 void *iodc_data, unsigned int iodc_data_size)
391{
392 int retval;
393 unsigned long flags;
394
395 spin_lock_irqsave(&pdc_lock, flags);
396 retval = mem_pdc_call(PDC_IODC, PDC_IODC_READ, __pa(pdc_result), hpa,
397 index, __pa(pdc_result2), iodc_data_size);
398 convert_to_wide(pdc_result);
399 *actcnt = pdc_result[0];
400 memcpy(iodc_data, pdc_result2, iodc_data_size);
401 spin_unlock_irqrestore(&pdc_lock, flags);
402
403 return retval;
404}
405EXPORT_SYMBOL(pdc_iodc_read);
406
407
408
409
410
411
412
413
414
415
416int pdc_system_map_find_mods(struct pdc_system_map_mod_info *pdc_mod_info,
417 struct pdc_module_path *mod_path, long mod_index)
418{
419 int retval;
420 unsigned long flags;
421
422 spin_lock_irqsave(&pdc_lock, flags);
423 retval = mem_pdc_call(PDC_SYSTEM_MAP, PDC_FIND_MODULE, __pa(pdc_result),
424 __pa(pdc_result2), mod_index);
425 convert_to_wide(pdc_result);
426 memcpy(pdc_mod_info, pdc_result, sizeof(*pdc_mod_info));
427 memcpy(mod_path, pdc_result2, sizeof(*mod_path));
428 spin_unlock_irqrestore(&pdc_lock, flags);
429
430 pdc_mod_info->mod_addr = f_extend(pdc_mod_info->mod_addr);
431 return retval;
432}
433
434
435
436
437
438
439
440
441
442
443int pdc_system_map_find_addrs(struct pdc_system_map_addr_info *pdc_addr_info,
444 long mod_index, long addr_index)
445{
446 int retval;
447 unsigned long flags;
448
449 spin_lock_irqsave(&pdc_lock, flags);
450 retval = mem_pdc_call(PDC_SYSTEM_MAP, PDC_FIND_ADDRESS, __pa(pdc_result),
451 mod_index, addr_index);
452 convert_to_wide(pdc_result);
453 memcpy(pdc_addr_info, pdc_result, sizeof(*pdc_addr_info));
454 spin_unlock_irqrestore(&pdc_lock, flags);
455
456 pdc_addr_info->mod_addr = f_extend(pdc_addr_info->mod_addr);
457 return retval;
458}
459
460
461
462
463
464
465
466int pdc_model_info(struct pdc_model *model)
467{
468 int retval;
469 unsigned long flags;
470
471 spin_lock_irqsave(&pdc_lock, flags);
472 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_INFO, __pa(pdc_result), 0);
473 convert_to_wide(pdc_result);
474 memcpy(model, pdc_result, sizeof(*model));
475 spin_unlock_irqrestore(&pdc_lock, flags);
476
477 return retval;
478}
479
480
481
482
483
484
485
486
487
488int pdc_model_sysmodel(char *name)
489{
490 int retval;
491 unsigned long flags;
492
493 spin_lock_irqsave(&pdc_lock, flags);
494 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_SYSMODEL, __pa(pdc_result),
495 OS_ID_HPUX, __pa(name));
496 convert_to_wide(pdc_result);
497
498 if (retval == PDC_OK) {
499 name[pdc_result[0]] = '\0';
500 } else {
501 name[0] = 0;
502 }
503 spin_unlock_irqrestore(&pdc_lock, flags);
504
505 return retval;
506}
507
508
509
510
511
512
513
514
515
516
517
518int pdc_model_versions(unsigned long *versions, int id)
519{
520 int retval;
521 unsigned long flags;
522
523 spin_lock_irqsave(&pdc_lock, flags);
524 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_VERSIONS, __pa(pdc_result), id);
525 convert_to_wide(pdc_result);
526 *versions = pdc_result[0];
527 spin_unlock_irqrestore(&pdc_lock, flags);
528
529 return retval;
530}
531
532
533
534
535
536
537
538
539int pdc_model_cpuid(unsigned long *cpu_id)
540{
541 int retval;
542 unsigned long flags;
543
544 spin_lock_irqsave(&pdc_lock, flags);
545 pdc_result[0] = 0;
546 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_CPU_ID, __pa(pdc_result), 0);
547 convert_to_wide(pdc_result);
548 *cpu_id = pdc_result[0];
549 spin_unlock_irqrestore(&pdc_lock, flags);
550
551 return retval;
552}
553
554
555
556
557
558
559
560
561int pdc_model_capabilities(unsigned long *capabilities)
562{
563 int retval;
564 unsigned long flags;
565
566 spin_lock_irqsave(&pdc_lock, flags);
567 pdc_result[0] = 0;
568 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_CAPABILITIES, __pa(pdc_result), 0);
569 convert_to_wide(pdc_result);
570 if (retval == PDC_OK) {
571 *capabilities = pdc_result[0];
572 } else {
573 *capabilities = PDC_MODEL_OS32;
574 }
575 spin_unlock_irqrestore(&pdc_lock, flags);
576
577 return retval;
578}
579
580
581
582
583
584
585
586
587
588
589int pdc_model_platform_info(char *orig_prod_num, char *current_prod_num,
590 char *serial_no)
591{
592 int retval;
593 unsigned long flags;
594
595 spin_lock_irqsave(&pdc_lock, flags);
596 retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_GET_PLATFORM_INFO,
597 __pa(orig_prod_num), __pa(current_prod_num), __pa(serial_no));
598 convert_to_wide(pdc_result);
599 spin_unlock_irqrestore(&pdc_lock, flags);
600
601 return retval;
602}
603
604
605
606
607
608
609
610int pdc_cache_info(struct pdc_cache_info *cache_info)
611{
612 int retval;
613 unsigned long flags;
614
615 spin_lock_irqsave(&pdc_lock, flags);
616 retval = mem_pdc_call(PDC_CACHE, PDC_CACHE_INFO, __pa(pdc_result), 0);
617 convert_to_wide(pdc_result);
618 memcpy(cache_info, pdc_result, sizeof(*cache_info));
619 spin_unlock_irqrestore(&pdc_lock, flags);
620
621 return retval;
622}
623
624
625
626
627
628
629
630int pdc_spaceid_bits(unsigned long *space_bits)
631{
632 int retval;
633 unsigned long flags;
634
635 spin_lock_irqsave(&pdc_lock, flags);
636 pdc_result[0] = 0;
637 retval = mem_pdc_call(PDC_CACHE, PDC_CACHE_RET_SPID, __pa(pdc_result), 0);
638 convert_to_wide(pdc_result);
639 *space_bits = pdc_result[0];
640 spin_unlock_irqrestore(&pdc_lock, flags);
641
642 return retval;
643}
644
645#ifndef CONFIG_PA20
646
647
648
649
650
651
652int pdc_btlb_info(struct pdc_btlb_info *btlb)
653{
654 int retval;
655 unsigned long flags;
656
657 spin_lock_irqsave(&pdc_lock, flags);
658 retval = mem_pdc_call(PDC_BLOCK_TLB, PDC_BTLB_INFO, __pa(pdc_result), 0);
659 memcpy(btlb, pdc_result, sizeof(*btlb));
660 spin_unlock_irqrestore(&pdc_lock, flags);
661
662 if(retval < 0) {
663 btlb->max_size = 0;
664 }
665 return retval;
666}
667
668
669
670
671
672
673
674
675
676
677
678
679
680int pdc_mem_map_hpa(struct pdc_memory_map *address,
681 struct pdc_module_path *mod_path)
682{
683 int retval;
684 unsigned long flags;
685
686 spin_lock_irqsave(&pdc_lock, flags);
687 memcpy(pdc_result2, mod_path, sizeof(*mod_path));
688 retval = mem_pdc_call(PDC_MEM_MAP, PDC_MEM_MAP_HPA, __pa(pdc_result),
689 __pa(pdc_result2));
690 memcpy(address, pdc_result, sizeof(*address));
691 spin_unlock_irqrestore(&pdc_lock, flags);
692
693 return retval;
694}
695#endif
696
697
698
699
700
701
702
703
704int pdc_lan_station_id(char *lan_addr, unsigned long hpa)
705{
706 int retval;
707 unsigned long flags;
708
709 spin_lock_irqsave(&pdc_lock, flags);
710 retval = mem_pdc_call(PDC_LAN_STATION_ID, PDC_LAN_STATION_ID_READ,
711 __pa(pdc_result), hpa);
712 if (retval < 0) {
713
714 memset(lan_addr, 0, PDC_LAN_STATION_ID_SIZE);
715 } else {
716 memcpy(lan_addr, pdc_result, PDC_LAN_STATION_ID_SIZE);
717 }
718 spin_unlock_irqrestore(&pdc_lock, flags);
719
720 return retval;
721}
722EXPORT_SYMBOL(pdc_lan_station_id);
723
724
725
726
727
728
729
730
731
732
733
734int pdc_stable_read(unsigned long staddr, void *memaddr, unsigned long count)
735{
736 int retval;
737 unsigned long flags;
738
739 spin_lock_irqsave(&pdc_lock, flags);
740 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_READ, staddr,
741 __pa(pdc_result), count);
742 convert_to_wide(pdc_result);
743 memcpy(memaddr, pdc_result, count);
744 spin_unlock_irqrestore(&pdc_lock, flags);
745
746 return retval;
747}
748EXPORT_SYMBOL(pdc_stable_read);
749
750
751
752
753
754
755
756
757
758
759
760int pdc_stable_write(unsigned long staddr, void *memaddr, unsigned long count)
761{
762 int retval;
763 unsigned long flags;
764
765 spin_lock_irqsave(&pdc_lock, flags);
766 memcpy(pdc_result, memaddr, count);
767 convert_to_wide(pdc_result);
768 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_WRITE, staddr,
769 __pa(pdc_result), count);
770 spin_unlock_irqrestore(&pdc_lock, flags);
771
772 return retval;
773}
774EXPORT_SYMBOL(pdc_stable_write);
775
776
777
778
779
780
781
782
783
784
785int pdc_stable_get_size(unsigned long *size)
786{
787 int retval;
788 unsigned long flags;
789
790 spin_lock_irqsave(&pdc_lock, flags);
791 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_RETURN_SIZE, __pa(pdc_result));
792 *size = pdc_result[0];
793 spin_unlock_irqrestore(&pdc_lock, flags);
794
795 return retval;
796}
797EXPORT_SYMBOL(pdc_stable_get_size);
798
799
800
801
802
803
804
805int pdc_stable_verify_contents(void)
806{
807 int retval;
808 unsigned long flags;
809
810 spin_lock_irqsave(&pdc_lock, flags);
811 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_VERIFY_CONTENTS);
812 spin_unlock_irqrestore(&pdc_lock, flags);
813
814 return retval;
815}
816EXPORT_SYMBOL(pdc_stable_verify_contents);
817
818
819
820
821
822
823
824int pdc_stable_initialize(void)
825{
826 int retval;
827 unsigned long flags;
828
829 spin_lock_irqsave(&pdc_lock, flags);
830 retval = mem_pdc_call(PDC_STABLE, PDC_STABLE_INITIALIZE);
831 spin_unlock_irqrestore(&pdc_lock, flags);
832
833 return retval;
834}
835EXPORT_SYMBOL(pdc_stable_initialize);
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851int pdc_get_initiator(struct hardware_path *hwpath, struct pdc_initiator *initiator)
852{
853 int retval;
854 unsigned long flags;
855
856 spin_lock_irqsave(&pdc_lock, flags);
857
858
859#define IS_SPROCKETS() (strlen(boot_cpu_data.pdc.sys_model_name) == 14 && \
860 strncmp(boot_cpu_data.pdc.sys_model_name, "9000/785", 8) == 0)
861
862 retval = mem_pdc_call(PDC_INITIATOR, PDC_GET_INITIATOR,
863 __pa(pdc_result), __pa(hwpath));
864 if (retval < PDC_OK)
865 goto out;
866
867 if (pdc_result[0] < 16) {
868 initiator->host_id = pdc_result[0];
869 } else {
870 initiator->host_id = -1;
871 }
872
873
874
875
876
877 switch (pdc_result[1]) {
878 case 1: initiator->factor = 50; break;
879 case 2: initiator->factor = 25; break;
880 case 5: initiator->factor = 12; break;
881 case 25: initiator->factor = 10; break;
882 case 20: initiator->factor = 12; break;
883 case 40: initiator->factor = 10; break;
884 default: initiator->factor = -1; break;
885 }
886
887 if (IS_SPROCKETS()) {
888 initiator->width = pdc_result[4];
889 initiator->mode = pdc_result[5];
890 } else {
891 initiator->width = -1;
892 initiator->mode = -1;
893 }
894
895 out:
896 spin_unlock_irqrestore(&pdc_lock, flags);
897
898 return (retval >= PDC_OK);
899}
900EXPORT_SYMBOL(pdc_get_initiator);
901
902
903
904
905
906
907
908
909
910
911
912int pdc_pci_irt_size(unsigned long *num_entries, unsigned long hpa)
913{
914 int retval;
915 unsigned long flags;
916
917 spin_lock_irqsave(&pdc_lock, flags);
918 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_GET_INT_TBL_SIZE,
919 __pa(pdc_result), hpa);
920 convert_to_wide(pdc_result);
921 *num_entries = pdc_result[0];
922 spin_unlock_irqrestore(&pdc_lock, flags);
923
924 return retval;
925}
926
927
928
929
930
931
932
933
934
935
936int pdc_pci_irt(unsigned long num_entries, unsigned long hpa, void *tbl)
937{
938 int retval;
939 unsigned long flags;
940
941 BUG_ON((unsigned long)tbl & 0x7);
942
943 spin_lock_irqsave(&pdc_lock, flags);
944 pdc_result[0] = num_entries;
945 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_GET_INT_TBL,
946 __pa(pdc_result), hpa, __pa(tbl));
947 spin_unlock_irqrestore(&pdc_lock, flags);
948
949 return retval;
950}
951
952
953#if 0
954
955
956
957
958
959
960
961
962unsigned int pdc_pci_config_read(void *hpa, unsigned long cfg_addr)
963{
964 int retval;
965 unsigned long flags;
966
967 spin_lock_irqsave(&pdc_lock, flags);
968 pdc_result[0] = 0;
969 pdc_result[1] = 0;
970 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_READ_CONFIG,
971 __pa(pdc_result), hpa, cfg_addr&~3UL, 4UL);
972 spin_unlock_irqrestore(&pdc_lock, flags);
973
974 return retval ? ~0 : (unsigned int) pdc_result[0];
975}
976
977
978
979
980
981
982
983
984
985
986void pdc_pci_config_write(void *hpa, unsigned long cfg_addr, unsigned int val)
987{
988 int retval;
989 unsigned long flags;
990
991 spin_lock_irqsave(&pdc_lock, flags);
992 pdc_result[0] = 0;
993 retval = mem_pdc_call(PDC_PCI_INDEX, PDC_PCI_WRITE_CONFIG,
994 __pa(pdc_result), hpa,
995 cfg_addr&~3UL, 4UL, (unsigned long) val);
996 spin_unlock_irqrestore(&pdc_lock, flags);
997
998 return retval;
999}
1000#endif
1001
1002
1003
1004
1005
1006
1007
1008int pdc_tod_read(struct pdc_tod *tod)
1009{
1010 int retval;
1011 unsigned long flags;
1012
1013 spin_lock_irqsave(&pdc_lock, flags);
1014 retval = mem_pdc_call(PDC_TOD, PDC_TOD_READ, __pa(pdc_result), 0);
1015 convert_to_wide(pdc_result);
1016 memcpy(tod, pdc_result, sizeof(*tod));
1017 spin_unlock_irqrestore(&pdc_lock, flags);
1018
1019 return retval;
1020}
1021EXPORT_SYMBOL(pdc_tod_read);
1022
1023int pdc_mem_pdt_info(struct pdc_mem_retinfo *rinfo)
1024{
1025 int retval;
1026 unsigned long flags;
1027
1028 spin_lock_irqsave(&pdc_lock, flags);
1029 retval = mem_pdc_call(PDC_MEM, PDC_MEM_MEMINFO, __pa(pdc_result), 0);
1030 convert_to_wide(pdc_result);
1031 memcpy(rinfo, pdc_result, sizeof(*rinfo));
1032 spin_unlock_irqrestore(&pdc_lock, flags);
1033
1034 return retval;
1035}
1036
1037int pdc_mem_pdt_read_entries(struct pdc_mem_read_pdt *pret,
1038 unsigned long *pdt_entries_ptr)
1039{
1040 int retval;
1041 unsigned long flags;
1042
1043 spin_lock_irqsave(&pdc_lock, flags);
1044 retval = mem_pdc_call(PDC_MEM, PDC_MEM_READ_PDT, __pa(pdc_result),
1045 __pa(pdt_entries_ptr));
1046 if (retval == PDC_OK) {
1047 convert_to_wide(pdc_result);
1048 memcpy(pret, pdc_result, sizeof(*pret));
1049 }
1050 spin_unlock_irqrestore(&pdc_lock, flags);
1051
1052#ifdef CONFIG_64BIT
1053
1054
1055
1056
1057 if (WARN_ON_ONCE((retval == PDC_OK) && parisc_narrow_firmware))
1058 return PDC_ERROR;
1059#endif
1060
1061 return retval;
1062}
1063
1064
1065
1066
1067
1068
1069
1070
1071int pdc_tod_set(unsigned long sec, unsigned long usec)
1072{
1073 int retval;
1074 unsigned long flags;
1075
1076 spin_lock_irqsave(&pdc_lock, flags);
1077 retval = mem_pdc_call(PDC_TOD, PDC_TOD_WRITE, sec, usec);
1078 spin_unlock_irqrestore(&pdc_lock, flags);
1079
1080 return retval;
1081}
1082EXPORT_SYMBOL(pdc_tod_set);
1083
1084#ifdef CONFIG_64BIT
1085int pdc_mem_mem_table(struct pdc_memory_table_raddr *r_addr,
1086 struct pdc_memory_table *tbl, unsigned long entries)
1087{
1088 int retval;
1089 unsigned long flags;
1090
1091 spin_lock_irqsave(&pdc_lock, flags);
1092 retval = mem_pdc_call(PDC_MEM, PDC_MEM_TABLE, __pa(pdc_result), __pa(pdc_result2), entries);
1093 convert_to_wide(pdc_result);
1094 memcpy(r_addr, pdc_result, sizeof(*r_addr));
1095 memcpy(tbl, pdc_result2, entries * sizeof(*tbl));
1096 spin_unlock_irqrestore(&pdc_lock, flags);
1097
1098 return retval;
1099}
1100#endif
1101
1102
1103
1104
1105
1106int pdc_do_firm_test_reset(unsigned long ftc_bitmap)
1107{
1108 int retval;
1109 unsigned long flags;
1110
1111 spin_lock_irqsave(&pdc_lock, flags);
1112 retval = mem_pdc_call(PDC_BROADCAST_RESET, PDC_DO_FIRM_TEST_RESET,
1113 PDC_FIRM_TEST_MAGIC, ftc_bitmap);
1114 spin_unlock_irqrestore(&pdc_lock, flags);
1115
1116 return retval;
1117}
1118
1119
1120
1121
1122
1123
1124int pdc_do_reset(void)
1125{
1126 int retval;
1127 unsigned long flags;
1128
1129 spin_lock_irqsave(&pdc_lock, flags);
1130 retval = mem_pdc_call(PDC_BROADCAST_RESET, PDC_DO_RESET);
1131 spin_unlock_irqrestore(&pdc_lock, flags);
1132
1133 return retval;
1134}
1135
1136
1137
1138
1139
1140
1141
1142int __init pdc_soft_power_info(unsigned long *power_reg)
1143{
1144 int retval;
1145 unsigned long flags;
1146
1147 *power_reg = (unsigned long) (-1);
1148
1149 spin_lock_irqsave(&pdc_lock, flags);
1150 retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_INFO, __pa(pdc_result), 0);
1151 if (retval == PDC_OK) {
1152 convert_to_wide(pdc_result);
1153 *power_reg = f_extend(pdc_result[0]);
1154 }
1155 spin_unlock_irqrestore(&pdc_lock, flags);
1156
1157 return retval;
1158}
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171int pdc_soft_power_button(int sw_control)
1172{
1173 int retval;
1174 unsigned long flags;
1175
1176 spin_lock_irqsave(&pdc_lock, flags);
1177 retval = mem_pdc_call(PDC_SOFT_POWER, PDC_SOFT_POWER_ENABLE, __pa(pdc_result), sw_control);
1178 spin_unlock_irqrestore(&pdc_lock, flags);
1179
1180 return retval;
1181}
1182
1183
1184
1185
1186
1187
1188void pdc_io_reset(void)
1189{
1190 unsigned long flags;
1191
1192 spin_lock_irqsave(&pdc_lock, flags);
1193 mem_pdc_call(PDC_IO, PDC_IO_RESET, 0);
1194 spin_unlock_irqrestore(&pdc_lock, flags);
1195}
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206void pdc_io_reset_devices(void)
1207{
1208 unsigned long flags;
1209
1210 spin_lock_irqsave(&pdc_lock, flags);
1211 mem_pdc_call(PDC_IO, PDC_IO_RESET_DEVICES, 0);
1212 spin_unlock_irqrestore(&pdc_lock, flags);
1213}
1214
1215#endif
1216
1217
1218static int __attribute__((aligned(8))) iodc_retbuf[32];
1219static char __attribute__((aligned(64))) iodc_dbuf[4096];
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231int pdc_iodc_print(const unsigned char *str, unsigned count)
1232{
1233 unsigned int i;
1234 unsigned long flags;
1235
1236 for (i = 0; i < count;) {
1237 switch(str[i]) {
1238 case '\n':
1239 iodc_dbuf[i+0] = '\r';
1240 iodc_dbuf[i+1] = '\n';
1241 i += 2;
1242 goto print;
1243 default:
1244 iodc_dbuf[i] = str[i];
1245 i++;
1246 break;
1247 }
1248 }
1249
1250print:
1251 spin_lock_irqsave(&pdc_lock, flags);
1252 real32_call(PAGE0->mem_cons.iodc_io,
1253 (unsigned long)PAGE0->mem_cons.hpa, ENTRY_IO_COUT,
1254 PAGE0->mem_cons.spa, __pa(PAGE0->mem_cons.dp.layers),
1255 __pa(iodc_retbuf), 0, __pa(iodc_dbuf), i, 0);
1256 spin_unlock_irqrestore(&pdc_lock, flags);
1257
1258 return i;
1259}
1260
1261#if !defined(BOOTLOADER)
1262
1263
1264
1265
1266
1267
1268int pdc_iodc_getc(void)
1269{
1270 int ch;
1271 int status;
1272 unsigned long flags;
1273
1274
1275 if (!PAGE0->mem_kbd.iodc_io)
1276 return 0;
1277
1278
1279 spin_lock_irqsave(&pdc_lock, flags);
1280 real32_call(PAGE0->mem_kbd.iodc_io,
1281 (unsigned long)PAGE0->mem_kbd.hpa, ENTRY_IO_CIN,
1282 PAGE0->mem_kbd.spa, __pa(PAGE0->mem_kbd.dp.layers),
1283 __pa(iodc_retbuf), 0, __pa(iodc_dbuf), 1, 0);
1284
1285 ch = *iodc_dbuf;
1286 status = *iodc_retbuf;
1287 spin_unlock_irqrestore(&pdc_lock, flags);
1288
1289 if (status == 0)
1290 return -1;
1291
1292 return ch;
1293}
1294
1295int pdc_sti_call(unsigned long func, unsigned long flags,
1296 unsigned long inptr, unsigned long outputr,
1297 unsigned long glob_cfg)
1298{
1299 int retval;
1300 unsigned long irqflags;
1301
1302 spin_lock_irqsave(&pdc_lock, irqflags);
1303 retval = real32_call(func, flags, inptr, outputr, glob_cfg);
1304 spin_unlock_irqrestore(&pdc_lock, irqflags);
1305
1306 return retval;
1307}
1308EXPORT_SYMBOL(pdc_sti_call);
1309
1310#ifdef CONFIG_64BIT
1311
1312
1313
1314
1315
1316
1317
1318int pdc_pat_cell_get_number(struct pdc_pat_cell_num *cell_info)
1319{
1320 int retval;
1321 unsigned long flags;
1322
1323 spin_lock_irqsave(&pdc_lock, flags);
1324 retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_GET_NUMBER, __pa(pdc_result));
1325 memcpy(cell_info, pdc_result, sizeof(*cell_info));
1326 spin_unlock_irqrestore(&pdc_lock, flags);
1327
1328 return retval;
1329}
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342int pdc_pat_cell_module(unsigned long *actcnt, unsigned long ploc, unsigned long mod,
1343 unsigned long view_type, void *mem_addr)
1344{
1345 int retval;
1346 unsigned long flags;
1347 static struct pdc_pat_cell_mod_maddr_block result __attribute__ ((aligned (8)));
1348
1349 spin_lock_irqsave(&pdc_lock, flags);
1350 retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_MODULE, __pa(pdc_result),
1351 ploc, mod, view_type, __pa(&result));
1352 if(!retval) {
1353 *actcnt = pdc_result[0];
1354 memcpy(mem_addr, &result, *actcnt);
1355 }
1356 spin_unlock_irqrestore(&pdc_lock, flags);
1357
1358 return retval;
1359}
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370int pdc_pat_cell_info(struct pdc_pat_cell_info_rtn_block *info,
1371 unsigned long *actcnt, unsigned long offset,
1372 unsigned long cell_number)
1373{
1374 int retval;
1375 unsigned long flags;
1376 struct pdc_pat_cell_info_rtn_block result;
1377
1378 spin_lock_irqsave(&pdc_lock, flags);
1379 retval = mem_pdc_call(PDC_PAT_CELL, PDC_PAT_CELL_GET_INFO,
1380 __pa(pdc_result), __pa(&result), *actcnt,
1381 offset, cell_number);
1382 if (!retval) {
1383 *actcnt = pdc_result[0];
1384 memcpy(info, &result, *actcnt);
1385 }
1386 spin_unlock_irqrestore(&pdc_lock, flags);
1387
1388 return retval;
1389}
1390
1391
1392
1393
1394
1395
1396
1397
1398int pdc_pat_cpu_get_number(struct pdc_pat_cpu_num *cpu_info, unsigned long hpa)
1399{
1400 int retval;
1401 unsigned long flags;
1402
1403 spin_lock_irqsave(&pdc_lock, flags);
1404 retval = mem_pdc_call(PDC_PAT_CPU, PDC_PAT_CPU_GET_NUMBER,
1405 __pa(&pdc_result), hpa);
1406 memcpy(cpu_info, pdc_result, sizeof(*cpu_info));
1407 spin_unlock_irqrestore(&pdc_lock, flags);
1408
1409 return retval;
1410}
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420int pdc_pat_get_irt_size(unsigned long *num_entries, unsigned long cell_num)
1421{
1422 int retval;
1423 unsigned long flags;
1424
1425 spin_lock_irqsave(&pdc_lock, flags);
1426 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE_SIZE,
1427 __pa(pdc_result), cell_num);
1428 *num_entries = pdc_result[0];
1429 spin_unlock_irqrestore(&pdc_lock, flags);
1430
1431 return retval;
1432}
1433
1434
1435
1436
1437
1438
1439
1440
1441int pdc_pat_get_irt(void *r_addr, unsigned long cell_num)
1442{
1443 int retval;
1444 unsigned long flags;
1445
1446 spin_lock_irqsave(&pdc_lock, flags);
1447 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_GET_PCI_ROUTING_TABLE,
1448 __pa(r_addr), cell_num);
1449 spin_unlock_irqrestore(&pdc_lock, flags);
1450
1451 return retval;
1452}
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462int pdc_pat_pd_get_addr_map(unsigned long *actual_len, void *mem_addr,
1463 unsigned long count, unsigned long offset)
1464{
1465 int retval;
1466 unsigned long flags;
1467
1468 spin_lock_irqsave(&pdc_lock, flags);
1469 retval = mem_pdc_call(PDC_PAT_PD, PDC_PAT_PD_GET_ADDR_MAP, __pa(pdc_result),
1470 __pa(pdc_result2), count, offset);
1471 *actual_len = pdc_result[0];
1472 memcpy(mem_addr, pdc_result2, *actual_len);
1473 spin_unlock_irqrestore(&pdc_lock, flags);
1474
1475 return retval;
1476}
1477
1478
1479
1480
1481
1482
1483
1484
1485int pdc_pat_pd_get_pdc_revisions(unsigned long *legacy_rev,
1486 unsigned long *pat_rev, unsigned long *pdc_cap)
1487{
1488 int retval;
1489 unsigned long flags;
1490
1491 spin_lock_irqsave(&pdc_lock, flags);
1492 retval = mem_pdc_call(PDC_PAT_PD, PDC_PAT_PD_GET_PDC_INTERF_REV,
1493 __pa(pdc_result));
1494 if (retval == PDC_OK) {
1495 *legacy_rev = pdc_result[0];
1496 *pat_rev = pdc_result[1];
1497 *pdc_cap = pdc_result[2];
1498 }
1499 spin_unlock_irqrestore(&pdc_lock, flags);
1500
1501 return retval;
1502}
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512int pdc_pat_io_pci_cfg_read(unsigned long pci_addr, int pci_size, u32 *mem_addr)
1513{
1514 int retval;
1515 unsigned long flags;
1516
1517 spin_lock_irqsave(&pdc_lock, flags);
1518 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_READ,
1519 __pa(pdc_result), pci_addr, pci_size);
1520 switch(pci_size) {
1521 case 1: *(u8 *) mem_addr = (u8) pdc_result[0]; break;
1522 case 2: *(u16 *)mem_addr = (u16) pdc_result[0]; break;
1523 case 4: *(u32 *)mem_addr = (u32) pdc_result[0]; break;
1524 }
1525 spin_unlock_irqrestore(&pdc_lock, flags);
1526
1527 return retval;
1528}
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538int pdc_pat_io_pci_cfg_write(unsigned long pci_addr, int pci_size, u32 val)
1539{
1540 int retval;
1541 unsigned long flags;
1542
1543 spin_lock_irqsave(&pdc_lock, flags);
1544 retval = mem_pdc_call(PDC_PAT_IO, PDC_PAT_IO_PCI_CONFIG_WRITE,
1545 pci_addr, pci_size, val);
1546 spin_unlock_irqrestore(&pdc_lock, flags);
1547
1548 return retval;
1549}
1550
1551
1552
1553
1554
1555
1556int pdc_pat_mem_pdt_info(struct pdc_pat_mem_retinfo *rinfo)
1557{
1558 int retval;
1559 unsigned long flags;
1560
1561 spin_lock_irqsave(&pdc_lock, flags);
1562 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_PD_INFO,
1563 __pa(&pdc_result));
1564 if (retval == PDC_OK)
1565 memcpy(rinfo, &pdc_result, sizeof(*rinfo));
1566 spin_unlock_irqrestore(&pdc_lock, flags);
1567
1568 return retval;
1569}
1570
1571
1572
1573
1574
1575
1576
1577
1578int pdc_pat_mem_pdt_cell_info(struct pdc_pat_mem_cell_pdt_retinfo *rinfo,
1579 unsigned long cell)
1580{
1581 int retval;
1582 unsigned long flags;
1583
1584 spin_lock_irqsave(&pdc_lock, flags);
1585 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_INFO,
1586 __pa(&pdc_result), cell);
1587 if (retval == PDC_OK)
1588 memcpy(rinfo, &pdc_result, sizeof(*rinfo));
1589 spin_unlock_irqrestore(&pdc_lock, flags);
1590
1591 return retval;
1592}
1593
1594
1595
1596
1597
1598
1599
1600
1601int pdc_pat_mem_read_cell_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
1602 unsigned long *pdt_entries_ptr, unsigned long max_entries)
1603{
1604 int retval;
1605 unsigned long flags, entries;
1606
1607 spin_lock_irqsave(&pdc_lock, flags);
1608
1609 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_CELL_READ,
1610 __pa(&pdc_result), parisc_cell_num,
1611 __pa(pdt_entries_ptr));
1612
1613 if (retval == PDC_OK) {
1614
1615 entries = min(pdc_result[0], max_entries);
1616 pret->pdt_entries = entries;
1617 pret->actual_count_bytes = entries * sizeof(unsigned long);
1618 }
1619
1620 spin_unlock_irqrestore(&pdc_lock, flags);
1621 WARN_ON(retval == PDC_OK && pdc_result[0] > max_entries);
1622
1623 return retval;
1624}
1625
1626
1627
1628
1629
1630
1631
1632
1633int pdc_pat_mem_read_pd_pdt(struct pdc_pat_mem_read_pd_retinfo *pret,
1634 unsigned long *pdt_entries_ptr, unsigned long count,
1635 unsigned long offset)
1636{
1637 int retval;
1638 unsigned long flags, entries;
1639
1640 spin_lock_irqsave(&pdc_lock, flags);
1641 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_PD_READ,
1642 __pa(&pdc_result), __pa(pdt_entries_ptr),
1643 count, offset);
1644
1645 if (retval == PDC_OK) {
1646 entries = min(pdc_result[0], count);
1647 pret->actual_count_bytes = entries;
1648 pret->pdt_entries = entries / sizeof(unsigned long);
1649 }
1650
1651 spin_unlock_irqrestore(&pdc_lock, flags);
1652
1653 return retval;
1654}
1655
1656
1657
1658
1659
1660
1661
1662int pdc_pat_mem_get_dimm_phys_location(
1663 struct pdc_pat_mem_phys_mem_location *pret,
1664 unsigned long phys_addr)
1665{
1666 int retval;
1667 unsigned long flags;
1668
1669 spin_lock_irqsave(&pdc_lock, flags);
1670 retval = mem_pdc_call(PDC_PAT_MEM, PDC_PAT_MEM_ADDRESS,
1671 __pa(&pdc_result), phys_addr);
1672
1673 if (retval == PDC_OK)
1674 memcpy(pret, &pdc_result, sizeof(*pret));
1675
1676 spin_unlock_irqrestore(&pdc_lock, flags);
1677
1678 return retval;
1679}
1680#endif
1681#endif
1682
1683
1684
1685
1686
1687
1688
1689
1690struct narrow_stack {
1691
1692 unsigned int arg13;
1693 unsigned int arg12;
1694 unsigned int arg11;
1695 unsigned int arg10;
1696 unsigned int arg9;
1697 unsigned int arg8;
1698 unsigned int arg7;
1699 unsigned int arg6;
1700 unsigned int arg5;
1701 unsigned int arg4;
1702 unsigned int arg3;
1703 unsigned int arg2;
1704 unsigned int arg1;
1705 unsigned int arg0;
1706 unsigned int frame_marker[8];
1707 unsigned int sp;
1708
1709};
1710
1711long real32_call(unsigned long fn, ...)
1712{
1713 va_list args;
1714 extern struct narrow_stack real_stack;
1715 extern unsigned long real32_call_asm(unsigned int *,
1716 unsigned int *,
1717 unsigned int);
1718
1719 va_start(args, fn);
1720 real_stack.arg0 = va_arg(args, unsigned int);
1721 real_stack.arg1 = va_arg(args, unsigned int);
1722 real_stack.arg2 = va_arg(args, unsigned int);
1723 real_stack.arg3 = va_arg(args, unsigned int);
1724 real_stack.arg4 = va_arg(args, unsigned int);
1725 real_stack.arg5 = va_arg(args, unsigned int);
1726 real_stack.arg6 = va_arg(args, unsigned int);
1727 real_stack.arg7 = va_arg(args, unsigned int);
1728 real_stack.arg8 = va_arg(args, unsigned int);
1729 real_stack.arg9 = va_arg(args, unsigned int);
1730 real_stack.arg10 = va_arg(args, unsigned int);
1731 real_stack.arg11 = va_arg(args, unsigned int);
1732 real_stack.arg12 = va_arg(args, unsigned int);
1733 real_stack.arg13 = va_arg(args, unsigned int);
1734 va_end(args);
1735
1736 return real32_call_asm(&real_stack.sp, &real_stack.arg0, fn);
1737}
1738
1739#ifdef CONFIG_64BIT
1740
1741
1742struct wide_stack {
1743 unsigned long arg0;
1744 unsigned long arg1;
1745 unsigned long arg2;
1746 unsigned long arg3;
1747 unsigned long arg4;
1748 unsigned long arg5;
1749 unsigned long arg6;
1750 unsigned long arg7;
1751 unsigned long arg8;
1752 unsigned long arg9;
1753 unsigned long arg10;
1754 unsigned long arg11;
1755 unsigned long arg12;
1756 unsigned long arg13;
1757 unsigned long frame_marker[2];
1758 unsigned long sp;
1759
1760};
1761
1762long real64_call(unsigned long fn, ...)
1763{
1764 va_list args;
1765 extern struct wide_stack real64_stack;
1766 extern unsigned long real64_call_asm(unsigned long *,
1767 unsigned long *,
1768 unsigned long);
1769
1770 va_start(args, fn);
1771 real64_stack.arg0 = va_arg(args, unsigned long);
1772 real64_stack.arg1 = va_arg(args, unsigned long);
1773 real64_stack.arg2 = va_arg(args, unsigned long);
1774 real64_stack.arg3 = va_arg(args, unsigned long);
1775 real64_stack.arg4 = va_arg(args, unsigned long);
1776 real64_stack.arg5 = va_arg(args, unsigned long);
1777 real64_stack.arg6 = va_arg(args, unsigned long);
1778 real64_stack.arg7 = va_arg(args, unsigned long);
1779 real64_stack.arg8 = va_arg(args, unsigned long);
1780 real64_stack.arg9 = va_arg(args, unsigned long);
1781 real64_stack.arg10 = va_arg(args, unsigned long);
1782 real64_stack.arg11 = va_arg(args, unsigned long);
1783 real64_stack.arg12 = va_arg(args, unsigned long);
1784 real64_stack.arg13 = va_arg(args, unsigned long);
1785 va_end(args);
1786
1787 return real64_call_asm(&real64_stack.sp, &real64_stack.arg0, fn);
1788}
1789
1790#endif
1791