2 * Copyright (C) 2001 Troy D. Armstrong IBM Corporation
3 * Copyright (C) 2004-2005 Stephen Rothwell IBM Corporation
5 * This modules exists as an interface between a Linux secondary partition
6 * running on an iSeries and the primary partition's Virtual Service
7 * Processor (VSP) object. The VSP has final authority over powering on/off
8 * all partitions in the iSeries. It also provides miscellaneous low-level
9 * machine facility type operations.
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #include <linux/types.h>
28 #include <linux/errno.h>
29 #include <linux/kernel.h>
30 #include <linux/init.h>
31 #include <linux/completion.h>
32 #include <linux/delay.h>
33 #include <linux/dma-mapping.h>
34 #include <linux/bcd.h>
37 #include <asm/uaccess.h>
39 #include <asm/abs_addr.h>
40 #include <asm/iSeries/vio.h>
41 #include <asm/iSeries/mf.h>
42 #include <asm/iSeries/HvLpConfig.h>
43 #include <asm/iSeries/ItLpQueue.h>
47 extern int piranha_simulator
;
50 * This is the structure layout for the Machine Facilites LPAR event
60 u64 state
; /* GetStateOut */
61 u64 ipl_type
; /* GetIplTypeOut, Function02SelectIplTypeIn */
62 u64 ipl_mode
; /* GetIplModeOut, Function02SelectIplModeIn */
63 u64 page
[4]; /* GetSrcHistoryIn */
64 u64 flag
; /* GetAutoIplWhenPrimaryIplsOut,
65 SetAutoIplWhenPrimaryIplsIn,
66 WhiteButtonPowerOffIn,
67 Function08FastPowerOffIn,
68 IsSpcnRackPowerIncompleteOut */
75 } kern
; /* SetKernelImageIn, GetKernelImageIn,
76 SetKernelCmdLineIn, GetKernelCmdLineIn */
77 u32 length_out
; /* GetKernelImageOut, GetKernelCmdLineOut */
83 struct completion com
;
84 struct vsp_cmd_data
*response
;
98 typedef void (*ce_msg_comp_hdlr
)(void *token
, struct ce_msg_data
*vsp_cmd_rsp
);
100 struct ce_msg_comp_data
{
101 ce_msg_comp_hdlr handler
;
108 struct ce_msg_comp_data
*completion
;
111 struct io_mf_lp_event
{
112 struct HvLpEvent hp_lp_event
;
113 u16 subtype_result_code
;
117 struct alloc_data alloc
;
118 struct ce_msg_data ce_msg
;
119 struct vsp_cmd_data vsp_cmd
;
123 #define subtype_data(a, b, c, d) \
124 (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
127 * All outgoing event traffic is kept on a FIFO queue. The first
128 * pointer points to the one that is outstanding, and all new
129 * requests get stuck on the end. Also, we keep a certain number of
130 * preallocated pending events so that we can operate very early in
131 * the boot up sequence (before kmalloc is ready).
133 struct pending_event
{
134 struct pending_event
*next
;
135 struct io_mf_lp_event event
;
136 MFCompleteHandler hdlr
;
138 unsigned dma_data_length
;
139 unsigned remote_address
;
141 static spinlock_t pending_event_spinlock
;
142 static struct pending_event
*pending_event_head
;
143 static struct pending_event
*pending_event_tail
;
144 static struct pending_event
*pending_event_avail
;
145 static struct pending_event pending_event_prealloc
[16];
148 * Put a pending event onto the available queue, so it can get reused.
149 * Attention! You must have the pending_event_spinlock before calling!
151 static void free_pending_event(struct pending_event
*ev
)
154 ev
->next
= pending_event_avail
;
155 pending_event_avail
= ev
;
160 * Enqueue the outbound event onto the stack. If the queue was
161 * empty to begin with, we must also issue it via the Hypervisor
162 * interface. There is a section of code below that will touch
163 * the first stack pointer without the protection of the pending_event_spinlock.
164 * This is OK, because we know that nobody else will be modifying
165 * the first pointer when we do this.
167 static int signal_event(struct pending_event
*ev
)
172 struct pending_event
*ev1
;
175 /* enqueue the event */
178 spin_lock_irqsave(&pending_event_spinlock
, flags
);
179 if (pending_event_head
== NULL
)
180 pending_event_head
= ev
;
183 pending_event_tail
->next
= ev
;
185 pending_event_tail
= ev
;
186 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
193 /* any DMA data to send beforehand? */
194 if (pending_event_head
->dma_data_length
> 0)
195 HvCallEvent_dmaToSp(pending_event_head
->dma_data
,
196 pending_event_head
->remote_address
,
197 pending_event_head
->dma_data_length
,
198 HvLpDma_Direction_LocalToRemote
);
200 hv_rc
= HvCallEvent_signalLpEvent(
201 &pending_event_head
->event
.hp_lp_event
);
202 if (hv_rc
!= HvLpEvent_Rc_Good
) {
203 printk(KERN_ERR
"mf.c: HvCallEvent_signalLpEvent() "
204 "failed with %d\n", (int)hv_rc
);
206 spin_lock_irqsave(&pending_event_spinlock
, flags
);
207 ev1
= pending_event_head
;
208 pending_event_head
= pending_event_head
->next
;
209 if (pending_event_head
!= NULL
)
211 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
215 else if (ev1
->hdlr
!= NULL
)
216 (*ev1
->hdlr
)((void *)ev1
->event
.hp_lp_event
.xCorrelationToken
, -EIO
);
218 spin_lock_irqsave(&pending_event_spinlock
, flags
);
219 free_pending_event(ev1
);
220 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
228 * Allocate a new pending_event structure, and initialize it.
230 static struct pending_event
*new_pending_event(void)
232 struct pending_event
*ev
= NULL
;
233 HvLpIndex primary_lp
= HvLpConfig_getPrimaryLpIndex();
235 struct HvLpEvent
*hev
;
237 spin_lock_irqsave(&pending_event_spinlock
, flags
);
238 if (pending_event_avail
!= NULL
) {
239 ev
= pending_event_avail
;
240 pending_event_avail
= pending_event_avail
->next
;
242 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
244 ev
= kmalloc(sizeof(struct pending_event
), GFP_ATOMIC
);
246 printk(KERN_ERR
"mf.c: unable to kmalloc %ld bytes\n",
247 sizeof(struct pending_event
));
251 memset(ev
, 0, sizeof(struct pending_event
));
252 hev
= &ev
->event
.hp_lp_event
;
253 hev
->xFlags
.xValid
= 1;
254 hev
->xFlags
.xAckType
= HvLpEvent_AckType_ImmediateAck
;
255 hev
->xFlags
.xAckInd
= HvLpEvent_AckInd_DoAck
;
256 hev
->xFlags
.xFunction
= HvLpEvent_Function_Int
;
257 hev
->xType
= HvLpEvent_Type_MachineFac
;
258 hev
->xSourceLp
= HvLpConfig_getLpIndex();
259 hev
->xTargetLp
= primary_lp
;
260 hev
->xSizeMinus1
= sizeof(ev
->event
) - 1;
261 hev
->xRc
= HvLpEvent_Rc_Good
;
262 hev
->xSourceInstanceId
= HvCallEvent_getSourceLpInstanceId(primary_lp
,
263 HvLpEvent_Type_MachineFac
);
264 hev
->xTargetInstanceId
= HvCallEvent_getTargetLpInstanceId(primary_lp
,
265 HvLpEvent_Type_MachineFac
);
270 static int signal_vsp_instruction(struct vsp_cmd_data
*vsp_cmd
)
272 struct pending_event
*ev
= new_pending_event();
274 struct vsp_rsp_data response
;
279 init_completion(&response
.com
);
280 response
.response
= vsp_cmd
;
281 ev
->event
.hp_lp_event
.xSubtype
= 6;
282 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
283 subtype_data('M', 'F', 'V', 'I');
284 ev
->event
.data
.vsp_cmd
.token
= (u64
)&response
;
285 ev
->event
.data
.vsp_cmd
.cmd
= vsp_cmd
->cmd
;
286 ev
->event
.data
.vsp_cmd
.lp_index
= HvLpConfig_getLpIndex();
287 ev
->event
.data
.vsp_cmd
.result_code
= 0xFF;
288 ev
->event
.data
.vsp_cmd
.reserved
= 0;
289 memcpy(&(ev
->event
.data
.vsp_cmd
.sub_data
),
290 &(vsp_cmd
->sub_data
), sizeof(vsp_cmd
->sub_data
));
293 rc
= signal_event(ev
);
295 wait_for_completion(&response
.com
);
301 * Send a 12-byte CE message to the primary partition VSP object
303 static int signal_ce_msg(char *ce_msg
, struct ce_msg_comp_data
*completion
)
305 struct pending_event
*ev
= new_pending_event();
310 ev
->event
.hp_lp_event
.xSubtype
= 0;
311 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
312 subtype_data('M', 'F', 'C', 'E');
313 memcpy(ev
->event
.data
.ce_msg
.ce_msg
, ce_msg
, 12);
314 ev
->event
.data
.ce_msg
.completion
= completion
;
315 return signal_event(ev
);
319 * Send a 12-byte CE message (with no data) to the primary partition VSP object
321 static int signal_ce_msg_simple(u8 ce_op
, struct ce_msg_comp_data
*completion
)
325 memset(ce_msg
, 0, sizeof(ce_msg
));
327 return signal_ce_msg(ce_msg
, completion
);
331 * Send a 12-byte CE message and DMA data to the primary partition VSP object
333 static int dma_and_signal_ce_msg(char *ce_msg
,
334 struct ce_msg_comp_data
*completion
, void *dma_data
,
335 unsigned dma_data_length
, unsigned remote_address
)
337 struct pending_event
*ev
= new_pending_event();
342 ev
->event
.hp_lp_event
.xSubtype
= 0;
343 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
344 subtype_data('M', 'F', 'C', 'E');
345 memcpy(ev
->event
.data
.ce_msg
.ce_msg
, ce_msg
, 12);
346 ev
->event
.data
.ce_msg
.completion
= completion
;
347 memcpy(ev
->dma_data
, dma_data
, dma_data_length
);
348 ev
->dma_data_length
= dma_data_length
;
349 ev
->remote_address
= remote_address
;
350 return signal_event(ev
);
354 * Initiate a nice (hopefully) shutdown of Linux. We simply are
355 * going to try and send the init process a SIGINT signal. If
356 * this fails (why?), we'll simply force it off in a not-so-nice
359 static int shutdown(void)
361 int rc
= kill_proc(1, SIGINT
, 1);
364 printk(KERN_ALERT
"mf.c: SIGINT to init failed (%d), "
365 "hard shutdown commencing\n", rc
);
368 printk(KERN_INFO
"mf.c: init has been successfully notified "
369 "to proceed with shutdown\n");
374 * The primary partition VSP object is sending us a new
375 * event flow. Handle it...
377 static void handle_int(struct io_mf_lp_event
*event
)
379 struct ce_msg_data
*ce_msg_data
;
380 struct ce_msg_data
*pce_msg_data
;
382 struct pending_event
*pev
;
384 /* ack the interrupt */
385 event
->hp_lp_event
.xRc
= HvLpEvent_Rc_Good
;
386 HvCallEvent_ackLpEvent(&event
->hp_lp_event
);
388 /* process interrupt */
389 switch (event
->hp_lp_event
.xSubtype
) {
390 case 0: /* CE message */
391 ce_msg_data
= &event
->data
.ce_msg
;
392 switch (ce_msg_data
->ce_msg
[3]) {
393 case 0x5B: /* power control notification */
394 if ((ce_msg_data
->ce_msg
[5] & 0x20) != 0) {
395 printk(KERN_INFO
"mf.c: Commencing partition shutdown\n");
397 signal_ce_msg_simple(0xDB, NULL
);
400 case 0xC0: /* get time */
401 spin_lock_irqsave(&pending_event_spinlock
, flags
);
402 pev
= pending_event_head
;
404 pending_event_head
= pending_event_head
->next
;
405 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
408 pce_msg_data
= &pev
->event
.data
.ce_msg
;
409 if (pce_msg_data
->ce_msg
[3] != 0x40)
411 if (pce_msg_data
->completion
!= NULL
) {
412 ce_msg_comp_hdlr handler
=
413 pce_msg_data
->completion
->handler
;
414 void *token
= pce_msg_data
->completion
->token
;
417 (*handler
)(token
, ce_msg_data
);
419 spin_lock_irqsave(&pending_event_spinlock
, flags
);
420 free_pending_event(pev
);
421 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
422 /* send next waiting event */
423 if (pending_event_head
!= NULL
)
428 case 1: /* IT sys shutdown */
429 printk(KERN_INFO
"mf.c: Commencing system shutdown\n");
436 * The primary partition VSP object is acknowledging the receipt
437 * of a flow we sent to them. If there are other flows queued
438 * up, we must send another one now...
440 static void handle_ack(struct io_mf_lp_event
*event
)
443 struct pending_event
*two
= NULL
;
444 unsigned long free_it
= 0;
445 struct ce_msg_data
*ce_msg_data
;
446 struct ce_msg_data
*pce_msg_data
;
447 struct vsp_rsp_data
*rsp
;
449 /* handle current event */
450 if (pending_event_head
== NULL
) {
451 printk(KERN_ERR
"mf.c: stack empty for receiving ack\n");
455 switch (event
->hp_lp_event
.xSubtype
) {
457 ce_msg_data
= &event
->data
.ce_msg
;
458 if (ce_msg_data
->ce_msg
[3] != 0x40) {
462 if (ce_msg_data
->ce_msg
[2] == 0)
465 pce_msg_data
= &pending_event_head
->event
.data
.ce_msg
;
466 if (pce_msg_data
->completion
!= NULL
) {
467 ce_msg_comp_hdlr handler
=
468 pce_msg_data
->completion
->handler
;
469 void *token
= pce_msg_data
->completion
->token
;
472 (*handler
)(token
, ce_msg_data
);
475 case 4: /* allocate */
476 case 5: /* deallocate */
477 if (pending_event_head
->hdlr
!= NULL
)
478 (*pending_event_head
->hdlr
)((void *)event
->hp_lp_event
.xCorrelationToken
, event
->data
.alloc
.count
);
483 rsp
= (struct vsp_rsp_data
*)event
->data
.vsp_cmd
.token
;
485 printk(KERN_ERR
"mf.c: no rsp\n");
488 if (rsp
->response
!= NULL
)
489 memcpy(rsp
->response
, &event
->data
.vsp_cmd
,
490 sizeof(event
->data
.vsp_cmd
));
495 /* remove from queue */
496 spin_lock_irqsave(&pending_event_spinlock
, flags
);
497 if ((pending_event_head
!= NULL
) && (free_it
== 1)) {
498 struct pending_event
*oldHead
= pending_event_head
;
500 pending_event_head
= pending_event_head
->next
;
501 two
= pending_event_head
;
502 free_pending_event(oldHead
);
504 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
506 /* send next waiting event */
512 * This is the generic event handler we are registering with
513 * the Hypervisor. Ensure the flows are for us, and then
514 * parse it enough to know if it is an interrupt or an
517 static void hv_handler(struct HvLpEvent
*event
, struct pt_regs
*regs
)
519 if ((event
!= NULL
) && (event
->xType
== HvLpEvent_Type_MachineFac
)) {
520 switch(event
->xFlags
.xFunction
) {
521 case HvLpEvent_Function_Ack
:
522 handle_ack((struct io_mf_lp_event
*)event
);
524 case HvLpEvent_Function_Int
:
525 handle_int((struct io_mf_lp_event
*)event
);
528 printk(KERN_ERR
"mf.c: non ack/int event received\n");
532 printk(KERN_ERR
"mf.c: alien event received\n");
536 * Global kernel interface to allocate and seed events into the
539 void mf_allocate_lp_events(HvLpIndex target_lp
, HvLpEvent_Type type
,
540 unsigned size
, unsigned count
, MFCompleteHandler hdlr
,
543 struct pending_event
*ev
= new_pending_event();
549 ev
->event
.hp_lp_event
.xSubtype
= 4;
550 ev
->event
.hp_lp_event
.xCorrelationToken
= (u64
)user_token
;
551 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
552 subtype_data('M', 'F', 'M', 'A');
553 ev
->event
.data
.alloc
.target_lp
= target_lp
;
554 ev
->event
.data
.alloc
.type
= type
;
555 ev
->event
.data
.alloc
.size
= size
;
556 ev
->event
.data
.alloc
.count
= count
;
558 rc
= signal_event(ev
);
560 if ((rc
!= 0) && (hdlr
!= NULL
))
561 (*hdlr
)(user_token
, rc
);
563 EXPORT_SYMBOL(mf_allocate_lp_events
);
566 * Global kernel interface to unseed and deallocate events already in
569 void mf_deallocate_lp_events(HvLpIndex target_lp
, HvLpEvent_Type type
,
570 unsigned count
, MFCompleteHandler hdlr
, void *user_token
)
572 struct pending_event
*ev
= new_pending_event();
578 ev
->event
.hp_lp_event
.xSubtype
= 5;
579 ev
->event
.hp_lp_event
.xCorrelationToken
= (u64
)user_token
;
580 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
581 subtype_data('M', 'F', 'M', 'D');
582 ev
->event
.data
.alloc
.target_lp
= target_lp
;
583 ev
->event
.data
.alloc
.type
= type
;
584 ev
->event
.data
.alloc
.count
= count
;
586 rc
= signal_event(ev
);
588 if ((rc
!= 0) && (hdlr
!= NULL
))
589 (*hdlr
)(user_token
, rc
);
591 EXPORT_SYMBOL(mf_deallocate_lp_events
);
594 * Global kernel interface to tell the VSP object in the primary
595 * partition to power this partition off.
597 void mf_power_off(void)
599 printk(KERN_INFO
"mf.c: Down it goes...\n");
600 signal_ce_msg_simple(0x4d, NULL
);
606 * Global kernel interface to tell the VSP object in the primary
607 * partition to reboot this partition.
611 printk(KERN_INFO
"mf.c: Preparing to bounce...\n");
612 signal_ce_msg_simple(0x4e, NULL
);
618 * Display a single word SRC onto the VSP control panel.
620 void mf_display_src(u32 word
)
624 memset(ce
, 0, sizeof(ce
));
631 signal_ce_msg(ce
, NULL
);
635 * Display a single word SRC of the form "PROGXXXX" on the VSP control panel.
637 void mf_display_progress(u16 value
)
642 memcpy(ce
, "\x00\x00\x04\x4A\x00\x00\x00\x48\x00\x00\x00\x00", 12);
643 memcpy(src
, "\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
644 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
645 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
646 "\x00\x00\x00\x00PROGxxxx ",
649 src
[7] = value
& 255;
650 src
[44] = "0123456789ABCDEF"[(value
>> 12) & 15];
651 src
[45] = "0123456789ABCDEF"[(value
>> 8) & 15];
652 src
[46] = "0123456789ABCDEF"[(value
>> 4) & 15];
653 src
[47] = "0123456789ABCDEF"[value
& 15];
654 dma_and_signal_ce_msg(ce
, NULL
, src
, sizeof(src
), 9 * 64 * 1024);
658 * Clear the VSP control panel. Used to "erase" an SRC that was
659 * previously displayed.
661 void mf_clear_src(void)
663 signal_ce_msg_simple(0x4b, NULL
);
667 * Initialization code here.
674 spin_lock_init(&pending_event_spinlock
);
676 i
< sizeof(pending_event_prealloc
) / sizeof(*pending_event_prealloc
);
678 free_pending_event(&pending_event_prealloc
[i
]);
679 HvLpEvent_registerHandler(HvLpEvent_Type_MachineFac
, &hv_handler
);
681 /* virtual continue ack */
682 signal_ce_msg_simple(0x57, NULL
);
684 /* initialization complete */
685 printk(KERN_NOTICE
"mf.c: iSeries Linux LPAR Machine Facilities "
689 struct rtc_time_data
{
690 struct completion com
;
691 struct ce_msg_data ce_msg
;
695 static void get_rtc_time_complete(void *token
, struct ce_msg_data
*ce_msg
)
697 struct rtc_time_data
*rtc
= token
;
699 memcpy(&rtc
->ce_msg
, ce_msg
, sizeof(rtc
->ce_msg
));
704 static int rtc_set_tm(int rc
, u8
*ce_msg
, struct rtc_time
*tm
)
719 if ((ce_msg
[2] == 0xa9) ||
720 (ce_msg
[2] == 0xaf)) {
721 /* TOD clock is not set */
759 int mf_get_rtc(struct rtc_time
*tm
)
761 struct ce_msg_comp_data ce_complete
;
762 struct rtc_time_data rtc_data
;
765 memset(&ce_complete
, 0, sizeof(ce_complete
));
766 memset(&rtc_data
, 0, sizeof(rtc_data
));
767 init_completion(&rtc_data
.com
);
768 ce_complete
.handler
= &get_rtc_time_complete
;
769 ce_complete
.token
= &rtc_data
;
770 rc
= signal_ce_msg_simple(0x40, &ce_complete
);
773 wait_for_completion(&rtc_data
.com
);
774 return rtc_set_tm(rtc_data
.rc
, rtc_data
.ce_msg
.ce_msg
, tm
);
777 struct boot_rtc_time_data
{
779 struct ce_msg_data ce_msg
;
783 static void get_boot_rtc_time_complete(void *token
, struct ce_msg_data
*ce_msg
)
785 struct boot_rtc_time_data
*rtc
= token
;
787 memcpy(&rtc
->ce_msg
, ce_msg
, sizeof(rtc
->ce_msg
));
792 int mf_get_boot_rtc(struct rtc_time
*tm
)
794 struct ce_msg_comp_data ce_complete
;
795 struct boot_rtc_time_data rtc_data
;
798 memset(&ce_complete
, 0, sizeof(ce_complete
));
799 memset(&rtc_data
, 0, sizeof(rtc_data
));
801 ce_complete
.handler
= &get_boot_rtc_time_complete
;
802 ce_complete
.token
= &rtc_data
;
803 rc
= signal_ce_msg_simple(0x40, &ce_complete
);
806 /* We need to poll here as we are not yet taking interrupts */
807 while (rtc_data
.busy
) {
808 if (hvlpevent_is_pending())
809 process_hvlpevents(NULL
);
811 return rtc_set_tm(rtc_data
.rc
, rtc_data
.ce_msg
.ce_msg
, tm
);
814 int mf_set_rtc(struct rtc_time
*tm
)
817 u8 day
, mon
, hour
, min
, sec
, y1
, y2
;
820 year
= 1900 + tm
->tm_year
;
828 mon
= tm
->tm_mon
+ 1;
838 memset(ce_time
, 0, sizeof(ce_time
));
848 return signal_ce_msg(ce_time
, NULL
);
851 #ifdef CONFIG_PROC_FS
853 static int proc_mf_dump_cmdline(char *page
, char **start
, off_t off
,
854 int count
, int *eof
, void *data
)
858 struct vsp_cmd_data vsp_cmd
;
862 /* The HV appears to return no more than 256 bytes of command line */
865 if ((off
+ count
) > 256)
868 dma_addr
= dma_map_single(iSeries_vio_dev
, page
, off
+ count
,
870 if (dma_mapping_error(dma_addr
))
872 memset(page
, 0, off
+ count
);
873 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
875 vsp_cmd
.sub_data
.kern
.token
= dma_addr
;
876 vsp_cmd
.sub_data
.kern
.address_type
= HvLpDma_AddressType_TceIndex
;
877 vsp_cmd
.sub_data
.kern
.side
= (u64
)data
;
878 vsp_cmd
.sub_data
.kern
.length
= off
+ count
;
880 rc
= signal_vsp_instruction(&vsp_cmd
);
881 dma_unmap_single(iSeries_vio_dev
, dma_addr
, off
+ count
,
885 if (vsp_cmd
.result_code
!= 0)
889 while (len
< (off
+ count
)) {
890 if ((*p
== '\0') || (*p
== '\n')) {
910 static int mf_getVmlinuxChunk(char *buffer
, int *size
, int offset
, u64 side
)
912 struct vsp_cmd_data vsp_cmd
;
917 dma_addr
= dma_map_single(iSeries_vio_dev
, buffer
, len
,
919 memset(buffer
, 0, len
);
920 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
922 vsp_cmd
.sub_data
.kern
.token
= dma_addr
;
923 vsp_cmd
.sub_data
.kern
.address_type
= HvLpDma_AddressType_TceIndex
;
924 vsp_cmd
.sub_data
.kern
.side
= side
;
925 vsp_cmd
.sub_data
.kern
.offset
= offset
;
926 vsp_cmd
.sub_data
.kern
.length
= len
;
928 rc
= signal_vsp_instruction(&vsp_cmd
);
930 if (vsp_cmd
.result_code
== 0)
931 *size
= vsp_cmd
.sub_data
.length_out
;
936 dma_unmap_single(iSeries_vio_dev
, dma_addr
, len
, DMA_FROM_DEVICE
);
941 static int proc_mf_dump_vmlinux(char *page
, char **start
, off_t off
,
942 int count
, int *eof
, void *data
)
944 int sizeToGet
= count
;
946 if (!capable(CAP_SYS_ADMIN
))
949 if (mf_getVmlinuxChunk(page
, &sizeToGet
, off
, (u64
)data
) == 0) {
950 if (sizeToGet
!= 0) {
962 static int proc_mf_dump_side(char *page
, char **start
, off_t off
,
963 int count
, int *eof
, void *data
)
966 char mf_current_side
= ' ';
967 struct vsp_cmd_data vsp_cmd
;
969 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
971 vsp_cmd
.sub_data
.ipl_type
= 0;
974 if (signal_vsp_instruction(&vsp_cmd
) == 0) {
975 if (vsp_cmd
.result_code
== 0) {
976 switch (vsp_cmd
.sub_data
.ipl_type
) {
977 case 0: mf_current_side
= 'A';
979 case 1: mf_current_side
= 'B';
981 case 2: mf_current_side
= 'C';
983 default: mf_current_side
= 'D';
989 len
= sprintf(page
, "%c\n", mf_current_side
);
991 if (len
<= (off
+ count
))
1002 static int proc_mf_change_side(struct file
*file
, const char __user
*buffer
,
1003 unsigned long count
, void *data
)
1007 struct vsp_cmd_data vsp_cmd
;
1009 if (!capable(CAP_SYS_ADMIN
))
1015 if (get_user(side
, buffer
))
1019 case 'A': newSide
= 0;
1021 case 'B': newSide
= 1;
1023 case 'C': newSide
= 2;
1025 case 'D': newSide
= 3;
1028 printk(KERN_ERR
"mf_proc.c: proc_mf_change_side: invalid side\n");
1032 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
1033 vsp_cmd
.sub_data
.ipl_type
= newSide
;
1036 (void)signal_vsp_instruction(&vsp_cmd
);
1042 static void mf_getSrcHistory(char *buffer
, int size
)
1044 struct IplTypeReturnStuff return_stuff
;
1045 struct pending_event
*ev
= new_pending_event();
1049 pages
[0] = kmalloc(4096, GFP_ATOMIC
);
1050 pages
[1] = kmalloc(4096, GFP_ATOMIC
);
1051 pages
[2] = kmalloc(4096, GFP_ATOMIC
);
1052 pages
[3] = kmalloc(4096, GFP_ATOMIC
);
1053 if ((ev
== NULL
) || (pages
[0] == NULL
) || (pages
[1] == NULL
)
1054 || (pages
[2] == NULL
) || (pages
[3] == NULL
))
1057 return_stuff
.xType
= 0;
1058 return_stuff
.xRc
= 0;
1059 return_stuff
.xDone
= 0;
1060 ev
->event
.hp_lp_event
.xSubtype
= 6;
1061 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
1062 subtype_data('M', 'F', 'V', 'I');
1063 ev
->event
.data
.vsp_cmd
.xEvent
= &return_stuff
;
1064 ev
->event
.data
.vsp_cmd
.cmd
= 4;
1065 ev
->event
.data
.vsp_cmd
.lp_index
= HvLpConfig_getLpIndex();
1066 ev
->event
.data
.vsp_cmd
.result_code
= 0xFF;
1067 ev
->event
.data
.vsp_cmd
.reserved
= 0;
1068 ev
->event
.data
.vsp_cmd
.sub_data
.page
[0] = iseries_hv_addr(pages
[0]);
1069 ev
->event
.data
.vsp_cmd
.sub_data
.page
[1] = iseries_hv_addr(pages
[1]);
1070 ev
->event
.data
.vsp_cmd
.sub_data
.page
[2] = iseries_hv_addr(pages
[2]);
1071 ev
->event
.data
.vsp_cmd
.sub_data
.page
[3] = iseries_hv_addr(pages
[3]);
1073 if (signal_event(ev
) != 0)
1076 while (return_stuff
.xDone
!= 1)
1078 if (return_stuff
.xRc
== 0)
1079 memcpy(buffer
, pages
[0], size
);
1087 static int proc_mf_dump_src(char *page
, char **start
, off_t off
,
1088 int count
, int *eof
, void *data
)
1093 mf_getSrcHistory(page
, count
);
1102 *start
= page
+ off
;
1109 static int proc_mf_change_src(struct file
*file
, const char __user
*buffer
,
1110 unsigned long count
, void *data
)
1114 if (!capable(CAP_SYS_ADMIN
))
1117 if ((count
< 4) && (count
!= 1)) {
1118 printk(KERN_ERR
"mf_proc: invalid src\n");
1122 if (count
> (sizeof(stkbuf
) - 1))
1123 count
= sizeof(stkbuf
) - 1;
1124 if (copy_from_user(stkbuf
, buffer
, count
))
1127 if ((count
== 1) && (*stkbuf
== '\0'))
1130 mf_display_src(*(u32
*)stkbuf
);
1135 static int proc_mf_change_cmdline(struct file
*file
, const char __user
*buffer
,
1136 unsigned long count
, void *data
)
1138 struct vsp_cmd_data vsp_cmd
;
1139 dma_addr_t dma_addr
;
1143 if (!capable(CAP_SYS_ADMIN
))
1147 page
= dma_alloc_coherent(iSeries_vio_dev
, count
, &dma_addr
,
1154 if (copy_from_user(page
, buffer
, count
))
1157 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
1159 vsp_cmd
.sub_data
.kern
.token
= dma_addr
;
1160 vsp_cmd
.sub_data
.kern
.address_type
= HvLpDma_AddressType_TceIndex
;
1161 vsp_cmd
.sub_data
.kern
.side
= (u64
)data
;
1162 vsp_cmd
.sub_data
.kern
.length
= count
;
1164 (void)signal_vsp_instruction(&vsp_cmd
);
1168 dma_free_coherent(iSeries_vio_dev
, count
, page
, dma_addr
);
1173 static ssize_t
proc_mf_change_vmlinux(struct file
*file
,
1174 const char __user
*buf
,
1175 size_t count
, loff_t
*ppos
)
1177 struct proc_dir_entry
*dp
= PDE(file
->f_dentry
->d_inode
);
1179 dma_addr_t dma_addr
;
1181 struct vsp_cmd_data vsp_cmd
;
1184 if (!capable(CAP_SYS_ADMIN
))
1188 page
= dma_alloc_coherent(iSeries_vio_dev
, count
, &dma_addr
,
1192 printk(KERN_ERR
"mf.c: couldn't allocate memory to set vmlinux chunk\n");
1196 if (copy_from_user(page
, buf
, count
))
1199 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
1201 vsp_cmd
.sub_data
.kern
.token
= dma_addr
;
1202 vsp_cmd
.sub_data
.kern
.address_type
= HvLpDma_AddressType_TceIndex
;
1203 vsp_cmd
.sub_data
.kern
.side
= (u64
)dp
->data
;
1204 vsp_cmd
.sub_data
.kern
.offset
= *ppos
;
1205 vsp_cmd
.sub_data
.kern
.length
= count
;
1207 rc
= signal_vsp_instruction(&vsp_cmd
);
1211 if (vsp_cmd
.result_code
!= 0)
1217 dma_free_coherent(iSeries_vio_dev
, count
, page
, dma_addr
);
1222 static struct file_operations proc_vmlinux_operations
= {
1223 .write
= proc_mf_change_vmlinux
,
1226 static int __init
mf_proc_init(void)
1228 struct proc_dir_entry
*mf_proc_root
;
1229 struct proc_dir_entry
*ent
;
1230 struct proc_dir_entry
*mf
;
1234 mf_proc_root
= proc_mkdir("iSeries/mf", NULL
);
1239 for (i
= 0; i
< 4; i
++) {
1241 mf
= proc_mkdir(name
, mf_proc_root
);
1245 ent
= create_proc_entry("cmdline", S_IFREG
|S_IRUSR
|S_IWUSR
, mf
);
1249 ent
->data
= (void *)(long)i
;
1250 ent
->read_proc
= proc_mf_dump_cmdline
;
1251 ent
->write_proc
= proc_mf_change_cmdline
;
1253 if (i
== 3) /* no vmlinux entry for 'D' */
1256 ent
= create_proc_entry("vmlinux", S_IFREG
|S_IWUSR
, mf
);
1260 ent
->data
= (void *)(long)i
;
1261 ent
->proc_fops
= &proc_vmlinux_operations
;
1264 ent
= create_proc_entry("side", S_IFREG
|S_IRUSR
|S_IWUSR
, mf_proc_root
);
1268 ent
->data
= (void *)0;
1269 ent
->read_proc
= proc_mf_dump_side
;
1270 ent
->write_proc
= proc_mf_change_side
;
1272 ent
= create_proc_entry("src", S_IFREG
|S_IRUSR
|S_IWUSR
, mf_proc_root
);
1276 ent
->data
= (void *)0;
1277 ent
->read_proc
= proc_mf_dump_src
;
1278 ent
->write_proc
= proc_mf_change_src
;
1283 __initcall(mf_proc_init
);
1285 #endif /* CONFIG_PROC_FS */
1288 * Get the RTC from the virtual service processor
1289 * This requires flowing LpEvents to the primary partition
1291 void iSeries_get_rtc_time(struct rtc_time
*rtc_tm
)
1293 if (piranha_simulator
)
1301 * Set the RTC in the virtual service processor
1302 * This requires flowing LpEvents to the primary partition
1304 int iSeries_set_rtc_time(struct rtc_time
*tm
)
1310 void iSeries_get_boot_time(struct rtc_time
*tm
)
1312 if (piranha_simulator
)
1315 mf_get_boot_rtc(tm
);