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