3 * Copyright (C) 2001 Todd Inglett, IBM Corporation
5 * pSeries LPAR support.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/kernel.h>
25 #include <linux/dma-mapping.h>
26 #include <linux/console.h>
27 #include <asm/processor.h>
30 #include <asm/pgtable.h>
31 #include <asm/machdep.h>
32 #include <asm/abs_addr.h>
33 #include <asm/mmu_context.h>
34 #include <asm/iommu.h>
35 #include <asm/tlbflush.h>
38 #include <asm/abs_addr.h>
39 #include <asm/cputable.h>
43 #include "plpar_wrappers.h"
46 #define DBG_LOW(fmt...) do { udbg_printf(fmt); } while(0)
48 #define DBG_LOW(fmt...) do { } while(0)
52 EXPORT_SYMBOL(plpar_hcall
);
53 EXPORT_SYMBOL(plpar_hcall9
);
54 EXPORT_SYMBOL(plpar_hcall_norets
);
56 extern void pSeries_find_serial_port(void);
59 int vtermno
; /* virtual terminal# for udbg */
61 #define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
62 static void udbg_hvsi_putc(char c
)
64 /* packet's seqno isn't used anyways */
65 uint8_t packet
[] __ALIGNED__
= { 0xff, 5, 0, 0, c
};
72 rc
= plpar_put_term_char(vtermno
, sizeof(packet
), packet
);
73 } while (rc
== H_BUSY
);
76 static long hvsi_udbg_buf_len
;
77 static uint8_t hvsi_udbg_buf
[256];
79 static int udbg_hvsi_getc_poll(void)
84 if (hvsi_udbg_buf_len
== 0) {
85 rc
= plpar_get_term_char(vtermno
, &hvsi_udbg_buf_len
, hvsi_udbg_buf
);
86 if (rc
!= H_SUCCESS
|| hvsi_udbg_buf
[0] != 0xff) {
87 /* bad read or non-data packet */
88 hvsi_udbg_buf_len
= 0;
90 /* remove the packet header */
91 for (i
= 4; i
< hvsi_udbg_buf_len
; i
++)
92 hvsi_udbg_buf
[i
-4] = hvsi_udbg_buf
[i
];
93 hvsi_udbg_buf_len
-= 4;
97 if (hvsi_udbg_buf_len
<= 0 || hvsi_udbg_buf_len
> 256) {
99 hvsi_udbg_buf_len
= 0;
103 ch
= hvsi_udbg_buf
[0];
104 /* shift remaining data down */
105 for (i
= 1; i
< hvsi_udbg_buf_len
; i
++) {
106 hvsi_udbg_buf
[i
-1] = hvsi_udbg_buf
[i
];
113 static int udbg_hvsi_getc(void)
117 ch
= udbg_hvsi_getc_poll();
119 /* This shouldn't be needed...but... */
120 volatile unsigned long delay
;
121 for (delay
=0; delay
< 2000000; delay
++)
129 static void udbg_putcLP(char c
)
139 rc
= plpar_put_term_char(vtermno
, 1, buf
);
140 } while(rc
== H_BUSY
);
143 /* Buffered chars getc */
144 static long inbuflen
;
145 static long inbuf
[2]; /* must be 2 longs */
147 static int udbg_getc_pollLP(void)
149 /* The interface is tricky because it may return up to 16 chars.
150 * We save them statically for future calls to udbg_getc().
152 char ch
, *buf
= (char *)inbuf
;
156 /* get some more chars. */
158 rc
= plpar_get_term_char(vtermno
, &inbuflen
, buf
);
160 inbuflen
= 0; /* otherwise inbuflen is garbage */
162 if (inbuflen
<= 0 || inbuflen
> 16) {
163 /* Catch error case as well as other oddities (corruption) */
168 for (i
= 1; i
< inbuflen
; i
++) /* shuffle them down. */
174 static int udbg_getcLP(void)
178 ch
= udbg_getc_pollLP();
180 /* This shouldn't be needed...but... */
181 volatile unsigned long delay
;
182 for (delay
=0; delay
< 2000000; delay
++)
190 /* call this from early_init() for a working debug console on
191 * vterm capable LPAR machines
193 void __init
udbg_init_debug_lpar(void)
196 udbg_putc
= udbg_putcLP
;
197 udbg_getc
= udbg_getcLP
;
198 udbg_getc_poll
= udbg_getc_pollLP
;
201 /* returns 0 if couldn't find or use /chosen/stdout as console */
202 void __init
find_udbg_vterm(void)
204 struct device_node
*stdout_node
;
209 /* find the boot console from /chosen/stdout */
212 name
= of_get_property(of_chosen
, "linux,stdout-path", NULL
);
215 stdout_node
= of_find_node_by_path(name
);
218 name
= of_get_property(stdout_node
, "name", NULL
);
220 printk(KERN_WARNING
"stdout node missing 'name' property!\n");
223 /* The user has requested a console so this is already set up. */
224 add_console
= !strstr(cmd_line
, "console=");
226 /* Check if it's a virtual terminal */
227 if (strncmp(name
, "vty", 3) != 0)
229 termno
= of_get_property(stdout_node
, "reg", NULL
);
234 if (device_is_compatible(stdout_node
, "hvterm1")) {
235 udbg_putc
= udbg_putcLP
;
236 udbg_getc
= udbg_getcLP
;
237 udbg_getc_poll
= udbg_getc_pollLP
;
239 add_preferred_console("hvc", termno
[0] & 0xff, NULL
);
240 } else if (device_is_compatible(stdout_node
, "hvterm-protocol")) {
242 udbg_putc
= udbg_hvsi_putc
;
243 udbg_getc
= udbg_hvsi_getc
;
244 udbg_getc_poll
= udbg_hvsi_getc_poll
;
246 add_preferred_console("hvsi", termno
[0] & 0xff, NULL
);
249 of_node_put(stdout_node
);
252 void vpa_init(int cpu
)
254 int hwcpu
= get_hard_smp_processor_id(cpu
);
258 if (cpu_has_feature(CPU_FTR_ALTIVEC
))
259 lppaca
[cpu
].vmxregs_in_use
= 1;
261 addr
= __pa(&lppaca
[cpu
]);
262 ret
= register_vpa(hwcpu
, addr
);
265 printk(KERN_ERR
"WARNING: vpa_init: VPA registration for "
266 "cpu %d (hw %d) of area %lx returns %ld\n",
267 cpu
, hwcpu
, addr
, ret
);
271 * PAPR says this feature is SLB-Buffer but firmware never
272 * reports that. All SPLPAR support SLB shadow buffer.
274 addr
= __pa(&slb_shadow
[cpu
]);
275 if (firmware_has_feature(FW_FEATURE_SPLPAR
)) {
276 ret
= register_slb_shadow(hwcpu
, addr
);
279 "WARNING: vpa_init: SLB shadow buffer "
280 "registration for cpu %d (hw %d) of area %lx "
281 "returns %ld\n", cpu
, hwcpu
, addr
, ret
);
285 static long pSeries_lpar_hpte_insert(unsigned long hpte_group
,
286 unsigned long va
, unsigned long pa
,
287 unsigned long rflags
, unsigned long vflags
,
290 unsigned long lpar_rc
;
293 unsigned long hpte_v
, hpte_r
;
295 if (!(vflags
& HPTE_V_BOLTED
))
296 DBG_LOW("hpte_insert(group=%lx, va=%016lx, pa=%016lx, "
297 "rflags=%lx, vflags=%lx, psize=%d)\n",
298 hpte_group
, va
, pa
, rflags
, vflags
, psize
);
300 hpte_v
= hpte_encode_v(va
, psize
) | vflags
| HPTE_V_VALID
;
301 hpte_r
= hpte_encode_r(pa
, psize
) | rflags
;
303 if (!(vflags
& HPTE_V_BOLTED
))
304 DBG_LOW(" hpte_v=%016lx, hpte_r=%016lx\n", hpte_v
, hpte_r
);
306 /* Now fill in the actual HPTE */
307 /* Set CEC cookie to 0 */
309 /* I-cache Invalidate = 0 */
310 /* I-cache synchronize = 0 */
314 /* Make pHyp happy */
315 if (rflags
& (_PAGE_GUARDED
|_PAGE_NO_CACHE
))
316 hpte_r
&= ~_PAGE_COHERENT
;
318 lpar_rc
= plpar_pte_enter(flags
, hpte_group
, hpte_v
, hpte_r
, &slot
);
319 if (unlikely(lpar_rc
== H_PTEG_FULL
)) {
320 if (!(vflags
& HPTE_V_BOLTED
))
326 * Since we try and ioremap PHBs we don't own, the pte insert
327 * will fail. However we must catch the failure in hash_page
328 * or we will loop forever, so return -2 in this case.
330 if (unlikely(lpar_rc
!= H_SUCCESS
)) {
331 if (!(vflags
& HPTE_V_BOLTED
))
332 DBG_LOW(" lpar err %d\n", lpar_rc
);
335 if (!(vflags
& HPTE_V_BOLTED
))
336 DBG_LOW(" -> slot: %d\n", slot
& 7);
338 /* Because of iSeries, we have to pass down the secondary
339 * bucket bit here as well
341 return (slot
& 7) | (!!(vflags
& HPTE_V_SECONDARY
) << 3);
344 static DEFINE_SPINLOCK(pSeries_lpar_tlbie_lock
);
346 static long pSeries_lpar_hpte_remove(unsigned long hpte_group
)
348 unsigned long slot_offset
;
349 unsigned long lpar_rc
;
351 unsigned long dummy1
, dummy2
;
353 /* pick a random slot to start at */
354 slot_offset
= mftb() & 0x7;
356 for (i
= 0; i
< HPTES_PER_GROUP
; i
++) {
358 /* don't remove a bolted entry */
359 lpar_rc
= plpar_pte_remove(H_ANDCOND
, hpte_group
+ slot_offset
,
360 (0x1UL
<< 4), &dummy1
, &dummy2
);
361 if (lpar_rc
== H_SUCCESS
)
363 BUG_ON(lpar_rc
!= H_NOT_FOUND
);
372 static void pSeries_lpar_hptab_clear(void)
374 unsigned long size_bytes
= 1UL << ppc64_pft_size
;
375 unsigned long hpte_count
= size_bytes
>> 4;
376 unsigned long dummy1
, dummy2
;
379 /* TODO: Use bulk call */
380 for (i
= 0; i
< hpte_count
; i
++)
381 plpar_pte_remove_raw(0, i
, 0, &dummy1
, &dummy2
);
385 * NOTE: for updatepp ops we are fortunate that the linux "newpp" bits and
386 * the low 3 bits of flags happen to line up. So no transform is needed.
387 * We can probably optimize here and assume the high bits of newpp are
388 * already zero. For now I am paranoid.
390 static long pSeries_lpar_hpte_updatepp(unsigned long slot
,
393 int psize
, int local
)
395 unsigned long lpar_rc
;
396 unsigned long flags
= (newpp
& 7) | H_AVPN
;
397 unsigned long want_v
;
399 want_v
= hpte_encode_v(va
, psize
);
401 DBG_LOW(" update: avpnv=%016lx, hash=%016lx, f=%x, psize: %d ... ",
402 want_v
& HPTE_V_AVPN
, slot
, flags
, psize
);
404 lpar_rc
= plpar_pte_protect(flags
, slot
, want_v
& HPTE_V_AVPN
);
406 if (lpar_rc
== H_NOT_FOUND
) {
407 DBG_LOW("not found !\n");
413 BUG_ON(lpar_rc
!= H_SUCCESS
);
418 static unsigned long pSeries_lpar_hpte_getword0(unsigned long slot
)
420 unsigned long dword0
;
421 unsigned long lpar_rc
;
422 unsigned long dummy_word1
;
425 /* Read 1 pte at a time */
426 /* Do not need RPN to logical page translation */
427 /* No cross CEC PFT access */
430 lpar_rc
= plpar_pte_read(flags
, slot
, &dword0
, &dummy_word1
);
432 BUG_ON(lpar_rc
!= H_SUCCESS
);
437 static long pSeries_lpar_hpte_find(unsigned long va
, int psize
)
442 unsigned long want_v
, hpte_v
;
444 hash
= hpt_hash(va
, mmu_psize_defs
[psize
].shift
);
445 want_v
= hpte_encode_v(va
, psize
);
447 for (j
= 0; j
< 2; j
++) {
448 slot
= (hash
& htab_hash_mask
) * HPTES_PER_GROUP
;
449 for (i
= 0; i
< HPTES_PER_GROUP
; i
++) {
450 hpte_v
= pSeries_lpar_hpte_getword0(slot
);
452 if (HPTE_V_COMPARE(hpte_v
, want_v
)
453 && (hpte_v
& HPTE_V_VALID
)
454 && (!!(hpte_v
& HPTE_V_SECONDARY
) == j
)) {
468 static void pSeries_lpar_hpte_updateboltedpp(unsigned long newpp
,
472 unsigned long lpar_rc
, slot
, vsid
, va
, flags
;
474 vsid
= get_kernel_vsid(ea
);
475 va
= (vsid
<< 28) | (ea
& 0x0fffffff);
477 slot
= pSeries_lpar_hpte_find(va
, psize
);
481 lpar_rc
= plpar_pte_protect(flags
, slot
, 0);
483 BUG_ON(lpar_rc
!= H_SUCCESS
);
486 static void pSeries_lpar_hpte_invalidate(unsigned long slot
, unsigned long va
,
487 int psize
, int local
)
489 unsigned long want_v
;
490 unsigned long lpar_rc
;
491 unsigned long dummy1
, dummy2
;
493 DBG_LOW(" inval : slot=%lx, va=%016lx, psize: %d, local: %d",
494 slot
, va
, psize
, local
);
496 want_v
= hpte_encode_v(va
, psize
);
497 lpar_rc
= plpar_pte_remove(H_AVPN
, slot
, want_v
& HPTE_V_AVPN
,
499 if (lpar_rc
== H_NOT_FOUND
)
502 BUG_ON(lpar_rc
!= H_SUCCESS
);
505 /* Flag bits for H_BULK_REMOVE */
506 #define HBR_REQUEST 0x4000000000000000UL
507 #define HBR_RESPONSE 0x8000000000000000UL
508 #define HBR_END 0xc000000000000000UL
509 #define HBR_AVPN 0x0200000000000000UL
510 #define HBR_ANDCOND 0x0100000000000000UL
513 * Take a spinlock around flushes to avoid bouncing the hypervisor tlbie
516 static void pSeries_lpar_flush_hash_range(unsigned long number
, int local
)
518 unsigned long i
, pix
, rc
;
519 unsigned long flags
= 0;
520 struct ppc64_tlb_batch
*batch
= &__get_cpu_var(ppc64_tlb_batch
);
521 int lock_tlbie
= !cpu_has_feature(CPU_FTR_LOCKLESS_TLBIE
);
522 unsigned long param
[9];
524 unsigned long hash
, index
, shift
, hidx
, slot
;
529 spin_lock_irqsave(&pSeries_lpar_tlbie_lock
, flags
);
531 psize
= batch
->psize
;
533 for (i
= 0; i
< number
; i
++) {
534 va
= batch
->vaddr
[i
];
536 pte_iterate_hashed_subpages(pte
, psize
, va
, index
, shift
) {
537 hash
= hpt_hash(va
, shift
);
538 hidx
= __rpte_to_hidx(pte
, index
);
539 if (hidx
& _PTEIDX_SECONDARY
)
541 slot
= (hash
& htab_hash_mask
) * HPTES_PER_GROUP
;
542 slot
+= hidx
& _PTEIDX_GROUP_IX
;
543 if (!firmware_has_feature(FW_FEATURE_BULK_REMOVE
)) {
544 pSeries_lpar_hpte_invalidate(slot
, va
, psize
,
547 param
[pix
] = HBR_REQUEST
| HBR_AVPN
| slot
;
548 param
[pix
+1] = hpte_encode_v(va
, psize
) &
552 rc
= plpar_hcall9(H_BULK_REMOVE
, param
,
553 param
[0], param
[1], param
[2],
554 param
[3], param
[4], param
[5],
556 BUG_ON(rc
!= H_SUCCESS
);
560 } pte_iterate_hashed_end();
563 param
[pix
] = HBR_END
;
564 rc
= plpar_hcall9(H_BULK_REMOVE
, param
, param
[0], param
[1],
565 param
[2], param
[3], param
[4], param
[5],
567 BUG_ON(rc
!= H_SUCCESS
);
571 spin_unlock_irqrestore(&pSeries_lpar_tlbie_lock
, flags
);
574 void __init
hpte_init_lpar(void)
576 ppc_md
.hpte_invalidate
= pSeries_lpar_hpte_invalidate
;
577 ppc_md
.hpte_updatepp
= pSeries_lpar_hpte_updatepp
;
578 ppc_md
.hpte_updateboltedpp
= pSeries_lpar_hpte_updateboltedpp
;
579 ppc_md
.hpte_insert
= pSeries_lpar_hpte_insert
;
580 ppc_md
.hpte_remove
= pSeries_lpar_hpte_remove
;
581 ppc_md
.flush_hash_range
= pSeries_lpar_flush_hash_range
;
582 ppc_md
.hpte_clear_all
= pSeries_lpar_hptab_clear
;