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>
35 #include <linux/rtc.h>
38 #include <asm/uaccess.h>
40 #include <asm/abs_addr.h>
41 #include <asm/iseries/vio.h>
42 #include <asm/iseries/mf.h>
43 #include <asm/iseries/hv_lp_config.h>
44 #include <asm/iseries/it_lp_queue.h>
48 static int mf_initialized
;
51 * This is the structure layout for the Machine Facilites LPAR event
61 u64 state
; /* GetStateOut */
62 u64 ipl_type
; /* GetIplTypeOut, Function02SelectIplTypeIn */
63 u64 ipl_mode
; /* GetIplModeOut, Function02SelectIplModeIn */
64 u64 page
[4]; /* GetSrcHistoryIn */
65 u64 flag
; /* GetAutoIplWhenPrimaryIplsOut,
66 SetAutoIplWhenPrimaryIplsIn,
67 WhiteButtonPowerOffIn,
68 Function08FastPowerOffIn,
69 IsSpcnRackPowerIncompleteOut */
76 } kern
; /* SetKernelImageIn, GetKernelImageIn,
77 SetKernelCmdLineIn, GetKernelCmdLineIn */
78 u32 length_out
; /* GetKernelImageOut, GetKernelCmdLineOut */
84 struct completion com
;
85 struct vsp_cmd_data
*response
;
99 typedef void (*ce_msg_comp_hdlr
)(void *token
, struct ce_msg_data
*vsp_cmd_rsp
);
101 struct ce_msg_comp_data
{
102 ce_msg_comp_hdlr handler
;
109 struct ce_msg_comp_data
*completion
;
112 struct io_mf_lp_event
{
113 struct HvLpEvent hp_lp_event
;
114 u16 subtype_result_code
;
118 struct alloc_data alloc
;
119 struct ce_msg_data ce_msg
;
120 struct vsp_cmd_data vsp_cmd
;
124 #define subtype_data(a, b, c, d) \
125 (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
128 * All outgoing event traffic is kept on a FIFO queue. The first
129 * pointer points to the one that is outstanding, and all new
130 * requests get stuck on the end. Also, we keep a certain number of
131 * preallocated pending events so that we can operate very early in
132 * the boot up sequence (before kmalloc is ready).
134 struct pending_event
{
135 struct pending_event
*next
;
136 struct io_mf_lp_event event
;
137 MFCompleteHandler hdlr
;
139 unsigned dma_data_length
;
140 unsigned remote_address
;
142 static spinlock_t pending_event_spinlock
;
143 static struct pending_event
*pending_event_head
;
144 static struct pending_event
*pending_event_tail
;
145 static struct pending_event
*pending_event_avail
;
146 #define PENDING_EVENT_PREALLOC_LEN 16
147 static struct pending_event pending_event_prealloc
[PENDING_EVENT_PREALLOC_LEN
];
150 * Put a pending event onto the available queue, so it can get reused.
151 * Attention! You must have the pending_event_spinlock before calling!
153 static void free_pending_event(struct pending_event
*ev
)
156 ev
->next
= pending_event_avail
;
157 pending_event_avail
= ev
;
162 * Enqueue the outbound event onto the stack. If the queue was
163 * empty to begin with, we must also issue it via the Hypervisor
164 * interface. There is a section of code below that will touch
165 * the first stack pointer without the protection of the pending_event_spinlock.
166 * This is OK, because we know that nobody else will be modifying
167 * the first pointer when we do this.
169 static int signal_event(struct pending_event
*ev
)
174 struct pending_event
*ev1
;
177 /* enqueue the event */
180 spin_lock_irqsave(&pending_event_spinlock
, flags
);
181 if (pending_event_head
== NULL
)
182 pending_event_head
= ev
;
185 pending_event_tail
->next
= ev
;
187 pending_event_tail
= ev
;
188 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
195 /* any DMA data to send beforehand? */
196 if (pending_event_head
->dma_data_length
> 0)
197 HvCallEvent_dmaToSp(pending_event_head
->dma_data
,
198 pending_event_head
->remote_address
,
199 pending_event_head
->dma_data_length
,
200 HvLpDma_Direction_LocalToRemote
);
202 hv_rc
= HvCallEvent_signalLpEvent(
203 &pending_event_head
->event
.hp_lp_event
);
204 if (hv_rc
!= HvLpEvent_Rc_Good
) {
205 printk(KERN_ERR
"mf.c: HvCallEvent_signalLpEvent() "
206 "failed with %d\n", (int)hv_rc
);
208 spin_lock_irqsave(&pending_event_spinlock
, flags
);
209 ev1
= pending_event_head
;
210 pending_event_head
= pending_event_head
->next
;
211 if (pending_event_head
!= NULL
)
213 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
217 else if (ev1
->hdlr
!= NULL
)
218 (*ev1
->hdlr
)((void *)ev1
->event
.hp_lp_event
.xCorrelationToken
, -EIO
);
220 spin_lock_irqsave(&pending_event_spinlock
, flags
);
221 free_pending_event(ev1
);
222 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
230 * Allocate a new pending_event structure, and initialize it.
232 static struct pending_event
*new_pending_event(void)
234 struct pending_event
*ev
= NULL
;
235 HvLpIndex primary_lp
= HvLpConfig_getPrimaryLpIndex();
237 struct HvLpEvent
*hev
;
239 spin_lock_irqsave(&pending_event_spinlock
, flags
);
240 if (pending_event_avail
!= NULL
) {
241 ev
= pending_event_avail
;
242 pending_event_avail
= pending_event_avail
->next
;
244 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
246 ev
= kmalloc(sizeof(struct pending_event
), GFP_ATOMIC
);
248 printk(KERN_ERR
"mf.c: unable to kmalloc %ld bytes\n",
249 sizeof(struct pending_event
));
253 memset(ev
, 0, sizeof(struct pending_event
));
254 hev
= &ev
->event
.hp_lp_event
;
255 hev
->flags
= HV_LP_EVENT_VALID
| HV_LP_EVENT_DO_ACK
| HV_LP_EVENT_INT
;
256 hev
->xType
= HvLpEvent_Type_MachineFac
;
257 hev
->xSourceLp
= HvLpConfig_getLpIndex();
258 hev
->xTargetLp
= primary_lp
;
259 hev
->xSizeMinus1
= sizeof(ev
->event
) - 1;
260 hev
->xRc
= HvLpEvent_Rc_Good
;
261 hev
->xSourceInstanceId
= HvCallEvent_getSourceLpInstanceId(primary_lp
,
262 HvLpEvent_Type_MachineFac
);
263 hev
->xTargetInstanceId
= HvCallEvent_getTargetLpInstanceId(primary_lp
,
264 HvLpEvent_Type_MachineFac
);
269 static int signal_vsp_instruction(struct vsp_cmd_data
*vsp_cmd
)
271 struct pending_event
*ev
= new_pending_event();
273 struct vsp_rsp_data response
;
278 init_completion(&response
.com
);
279 response
.response
= vsp_cmd
;
280 ev
->event
.hp_lp_event
.xSubtype
= 6;
281 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
282 subtype_data('M', 'F', 'V', 'I');
283 ev
->event
.data
.vsp_cmd
.token
= (u64
)&response
;
284 ev
->event
.data
.vsp_cmd
.cmd
= vsp_cmd
->cmd
;
285 ev
->event
.data
.vsp_cmd
.lp_index
= HvLpConfig_getLpIndex();
286 ev
->event
.data
.vsp_cmd
.result_code
= 0xFF;
287 ev
->event
.data
.vsp_cmd
.reserved
= 0;
288 memcpy(&(ev
->event
.data
.vsp_cmd
.sub_data
),
289 &(vsp_cmd
->sub_data
), sizeof(vsp_cmd
->sub_data
));
292 rc
= signal_event(ev
);
294 wait_for_completion(&response
.com
);
300 * Send a 12-byte CE message to the primary partition VSP object
302 static int signal_ce_msg(char *ce_msg
, struct ce_msg_comp_data
*completion
)
304 struct pending_event
*ev
= new_pending_event();
309 ev
->event
.hp_lp_event
.xSubtype
= 0;
310 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
311 subtype_data('M', 'F', 'C', 'E');
312 memcpy(ev
->event
.data
.ce_msg
.ce_msg
, ce_msg
, 12);
313 ev
->event
.data
.ce_msg
.completion
= completion
;
314 return signal_event(ev
);
318 * Send a 12-byte CE message (with no data) to the primary partition VSP object
320 static int signal_ce_msg_simple(u8 ce_op
, struct ce_msg_comp_data
*completion
)
324 memset(ce_msg
, 0, sizeof(ce_msg
));
326 return signal_ce_msg(ce_msg
, completion
);
330 * Send a 12-byte CE message and DMA data to the primary partition VSP object
332 static int dma_and_signal_ce_msg(char *ce_msg
,
333 struct ce_msg_comp_data
*completion
, void *dma_data
,
334 unsigned dma_data_length
, unsigned remote_address
)
336 struct pending_event
*ev
= new_pending_event();
341 ev
->event
.hp_lp_event
.xSubtype
= 0;
342 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
343 subtype_data('M', 'F', 'C', 'E');
344 memcpy(ev
->event
.data
.ce_msg
.ce_msg
, ce_msg
, 12);
345 ev
->event
.data
.ce_msg
.completion
= completion
;
346 memcpy(ev
->dma_data
, dma_data
, dma_data_length
);
347 ev
->dma_data_length
= dma_data_length
;
348 ev
->remote_address
= remote_address
;
349 return signal_event(ev
);
353 * Initiate a nice (hopefully) shutdown of Linux. We simply are
354 * going to try and send the init process a SIGINT signal. If
355 * this fails (why?), we'll simply force it off in a not-so-nice
358 static int shutdown(void)
360 int rc
= kill_proc(1, SIGINT
, 1);
363 printk(KERN_ALERT
"mf.c: SIGINT to init failed (%d), "
364 "hard shutdown commencing\n", rc
);
367 printk(KERN_INFO
"mf.c: init has been successfully notified "
368 "to proceed with shutdown\n");
373 * The primary partition VSP object is sending us a new
374 * event flow. Handle it...
376 static void handle_int(struct io_mf_lp_event
*event
)
378 struct ce_msg_data
*ce_msg_data
;
379 struct ce_msg_data
*pce_msg_data
;
381 struct pending_event
*pev
;
383 /* ack the interrupt */
384 event
->hp_lp_event
.xRc
= HvLpEvent_Rc_Good
;
385 HvCallEvent_ackLpEvent(&event
->hp_lp_event
);
387 /* process interrupt */
388 switch (event
->hp_lp_event
.xSubtype
) {
389 case 0: /* CE message */
390 ce_msg_data
= &event
->data
.ce_msg
;
391 switch (ce_msg_data
->ce_msg
[3]) {
392 case 0x5B: /* power control notification */
393 if ((ce_msg_data
->ce_msg
[5] & 0x20) != 0) {
394 printk(KERN_INFO
"mf.c: Commencing partition shutdown\n");
396 signal_ce_msg_simple(0xDB, NULL
);
399 case 0xC0: /* get time */
400 spin_lock_irqsave(&pending_event_spinlock
, flags
);
401 pev
= pending_event_head
;
403 pending_event_head
= pending_event_head
->next
;
404 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
407 pce_msg_data
= &pev
->event
.data
.ce_msg
;
408 if (pce_msg_data
->ce_msg
[3] != 0x40)
410 if (pce_msg_data
->completion
!= NULL
) {
411 ce_msg_comp_hdlr handler
=
412 pce_msg_data
->completion
->handler
;
413 void *token
= pce_msg_data
->completion
->token
;
416 (*handler
)(token
, ce_msg_data
);
418 spin_lock_irqsave(&pending_event_spinlock
, flags
);
419 free_pending_event(pev
);
420 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
421 /* send next waiting event */
422 if (pending_event_head
!= NULL
)
427 case 1: /* IT sys shutdown */
428 printk(KERN_INFO
"mf.c: Commencing system shutdown\n");
435 * The primary partition VSP object is acknowledging the receipt
436 * of a flow we sent to them. If there are other flows queued
437 * up, we must send another one now...
439 static void handle_ack(struct io_mf_lp_event
*event
)
442 struct pending_event
*two
= NULL
;
443 unsigned long free_it
= 0;
444 struct ce_msg_data
*ce_msg_data
;
445 struct ce_msg_data
*pce_msg_data
;
446 struct vsp_rsp_data
*rsp
;
448 /* handle current event */
449 if (pending_event_head
== NULL
) {
450 printk(KERN_ERR
"mf.c: stack empty for receiving ack\n");
454 switch (event
->hp_lp_event
.xSubtype
) {
456 ce_msg_data
= &event
->data
.ce_msg
;
457 if (ce_msg_data
->ce_msg
[3] != 0x40) {
461 if (ce_msg_data
->ce_msg
[2] == 0)
464 pce_msg_data
= &pending_event_head
->event
.data
.ce_msg
;
465 if (pce_msg_data
->completion
!= NULL
) {
466 ce_msg_comp_hdlr handler
=
467 pce_msg_data
->completion
->handler
;
468 void *token
= pce_msg_data
->completion
->token
;
471 (*handler
)(token
, ce_msg_data
);
474 case 4: /* allocate */
475 case 5: /* deallocate */
476 if (pending_event_head
->hdlr
!= NULL
)
477 (*pending_event_head
->hdlr
)((void *)event
->hp_lp_event
.xCorrelationToken
, event
->data
.alloc
.count
);
482 rsp
= (struct vsp_rsp_data
*)event
->data
.vsp_cmd
.token
;
484 printk(KERN_ERR
"mf.c: no rsp\n");
487 if (rsp
->response
!= NULL
)
488 memcpy(rsp
->response
, &event
->data
.vsp_cmd
,
489 sizeof(event
->data
.vsp_cmd
));
494 /* remove from queue */
495 spin_lock_irqsave(&pending_event_spinlock
, flags
);
496 if ((pending_event_head
!= NULL
) && (free_it
== 1)) {
497 struct pending_event
*oldHead
= pending_event_head
;
499 pending_event_head
= pending_event_head
->next
;
500 two
= pending_event_head
;
501 free_pending_event(oldHead
);
503 spin_unlock_irqrestore(&pending_event_spinlock
, flags
);
505 /* send next waiting event */
511 * This is the generic event handler we are registering with
512 * the Hypervisor. Ensure the flows are for us, and then
513 * parse it enough to know if it is an interrupt or an
516 static void hv_handler(struct HvLpEvent
*event
, struct pt_regs
*regs
)
518 if ((event
!= NULL
) && (event
->xType
== HvLpEvent_Type_MachineFac
)) {
519 if (hvlpevent_is_ack(event
))
520 handle_ack((struct io_mf_lp_event
*)event
);
522 handle_int((struct io_mf_lp_event
*)event
);
524 printk(KERN_ERR
"mf.c: alien event received\n");
528 * Global kernel interface to allocate and seed events into the
531 void mf_allocate_lp_events(HvLpIndex target_lp
, HvLpEvent_Type type
,
532 unsigned size
, unsigned count
, MFCompleteHandler hdlr
,
535 struct pending_event
*ev
= new_pending_event();
541 ev
->event
.hp_lp_event
.xSubtype
= 4;
542 ev
->event
.hp_lp_event
.xCorrelationToken
= (u64
)user_token
;
543 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
544 subtype_data('M', 'F', 'M', 'A');
545 ev
->event
.data
.alloc
.target_lp
= target_lp
;
546 ev
->event
.data
.alloc
.type
= type
;
547 ev
->event
.data
.alloc
.size
= size
;
548 ev
->event
.data
.alloc
.count
= count
;
550 rc
= signal_event(ev
);
552 if ((rc
!= 0) && (hdlr
!= NULL
))
553 (*hdlr
)(user_token
, rc
);
555 EXPORT_SYMBOL(mf_allocate_lp_events
);
558 * Global kernel interface to unseed and deallocate events already in
561 void mf_deallocate_lp_events(HvLpIndex target_lp
, HvLpEvent_Type type
,
562 unsigned count
, MFCompleteHandler hdlr
, void *user_token
)
564 struct pending_event
*ev
= new_pending_event();
570 ev
->event
.hp_lp_event
.xSubtype
= 5;
571 ev
->event
.hp_lp_event
.xCorrelationToken
= (u64
)user_token
;
572 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
573 subtype_data('M', 'F', 'M', 'D');
574 ev
->event
.data
.alloc
.target_lp
= target_lp
;
575 ev
->event
.data
.alloc
.type
= type
;
576 ev
->event
.data
.alloc
.count
= count
;
578 rc
= signal_event(ev
);
580 if ((rc
!= 0) && (hdlr
!= NULL
))
581 (*hdlr
)(user_token
, rc
);
583 EXPORT_SYMBOL(mf_deallocate_lp_events
);
586 * Global kernel interface to tell the VSP object in the primary
587 * partition to power this partition off.
589 void mf_power_off(void)
591 printk(KERN_INFO
"mf.c: Down it goes...\n");
592 signal_ce_msg_simple(0x4d, NULL
);
598 * Global kernel interface to tell the VSP object in the primary
599 * partition to reboot this partition.
601 void mf_reboot(char *cmd
)
603 printk(KERN_INFO
"mf.c: Preparing to bounce...\n");
604 signal_ce_msg_simple(0x4e, NULL
);
610 * Display a single word SRC onto the VSP control panel.
612 void mf_display_src(u32 word
)
616 memset(ce
, 0, sizeof(ce
));
623 signal_ce_msg(ce
, NULL
);
627 * Display a single word SRC of the form "PROGXXXX" on the VSP control panel.
629 static __init
void mf_display_progress_src(u16 value
)
634 memcpy(ce
, "\x00\x00\x04\x4A\x00\x00\x00\x48\x00\x00\x00\x00", 12);
635 memcpy(src
, "\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
636 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
637 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
638 "\x00\x00\x00\x00PROGxxxx ",
641 src
[7] = value
& 255;
642 src
[44] = "0123456789ABCDEF"[(value
>> 12) & 15];
643 src
[45] = "0123456789ABCDEF"[(value
>> 8) & 15];
644 src
[46] = "0123456789ABCDEF"[(value
>> 4) & 15];
645 src
[47] = "0123456789ABCDEF"[value
& 15];
646 dma_and_signal_ce_msg(ce
, NULL
, src
, sizeof(src
), 9 * 64 * 1024);
650 * Clear the VSP control panel. Used to "erase" an SRC that was
651 * previously displayed.
653 static void mf_clear_src(void)
655 signal_ce_msg_simple(0x4b, NULL
);
658 void __init
mf_display_progress(u16 value
)
666 mf_display_progress_src(value
);
670 * Initialization code here.
672 void __init
mf_init(void)
676 spin_lock_init(&pending_event_spinlock
);
678 for (i
= 0; i
< PENDING_EVENT_PREALLOC_LEN
; i
++)
679 free_pending_event(&pending_event_prealloc
[i
]);
681 HvLpEvent_registerHandler(HvLpEvent_Type_MachineFac
, &hv_handler
);
683 /* virtual continue ack */
684 signal_ce_msg_simple(0x57, NULL
);
689 printk(KERN_NOTICE
"mf.c: iSeries Linux LPAR Machine Facilities "
693 struct rtc_time_data
{
694 struct completion com
;
695 struct ce_msg_data ce_msg
;
699 static void get_rtc_time_complete(void *token
, struct ce_msg_data
*ce_msg
)
701 struct rtc_time_data
*rtc
= token
;
703 memcpy(&rtc
->ce_msg
, ce_msg
, sizeof(rtc
->ce_msg
));
708 static int mf_set_rtc(struct rtc_time
*tm
)
711 u8 day
, mon
, hour
, min
, sec
, y1
, y2
;
714 year
= 1900 + tm
->tm_year
;
722 mon
= tm
->tm_mon
+ 1;
732 memset(ce_time
, 0, sizeof(ce_time
));
742 return signal_ce_msg(ce_time
, NULL
);
745 static int rtc_set_tm(int rc
, u8
*ce_msg
, struct rtc_time
*tm
)
760 if ((ce_msg
[2] == 0xa9) ||
761 (ce_msg
[2] == 0xaf)) {
762 /* TOD clock is not set */
800 static int mf_get_rtc(struct rtc_time
*tm
)
802 struct ce_msg_comp_data ce_complete
;
803 struct rtc_time_data rtc_data
;
806 memset(&ce_complete
, 0, sizeof(ce_complete
));
807 memset(&rtc_data
, 0, sizeof(rtc_data
));
808 init_completion(&rtc_data
.com
);
809 ce_complete
.handler
= &get_rtc_time_complete
;
810 ce_complete
.token
= &rtc_data
;
811 rc
= signal_ce_msg_simple(0x40, &ce_complete
);
814 wait_for_completion(&rtc_data
.com
);
815 return rtc_set_tm(rtc_data
.rc
, rtc_data
.ce_msg
.ce_msg
, tm
);
818 struct boot_rtc_time_data
{
820 struct ce_msg_data ce_msg
;
824 static void get_boot_rtc_time_complete(void *token
, struct ce_msg_data
*ce_msg
)
826 struct boot_rtc_time_data
*rtc
= token
;
828 memcpy(&rtc
->ce_msg
, ce_msg
, sizeof(rtc
->ce_msg
));
833 static int mf_get_boot_rtc(struct rtc_time
*tm
)
835 struct ce_msg_comp_data ce_complete
;
836 struct boot_rtc_time_data rtc_data
;
839 memset(&ce_complete
, 0, sizeof(ce_complete
));
840 memset(&rtc_data
, 0, sizeof(rtc_data
));
842 ce_complete
.handler
= &get_boot_rtc_time_complete
;
843 ce_complete
.token
= &rtc_data
;
844 rc
= signal_ce_msg_simple(0x40, &ce_complete
);
847 /* We need to poll here as we are not yet taking interrupts */
848 while (rtc_data
.busy
) {
849 if (hvlpevent_is_pending())
850 process_hvlpevents(NULL
);
852 return rtc_set_tm(rtc_data
.rc
, rtc_data
.ce_msg
.ce_msg
, tm
);
855 #ifdef CONFIG_PROC_FS
857 static int proc_mf_dump_cmdline(char *page
, char **start
, off_t off
,
858 int count
, int *eof
, void *data
)
862 struct vsp_cmd_data vsp_cmd
;
866 /* The HV appears to return no more than 256 bytes of command line */
869 if ((off
+ count
) > 256)
872 dma_addr
= dma_map_single(iSeries_vio_dev
, page
, off
+ count
,
874 if (dma_mapping_error(dma_addr
))
876 memset(page
, 0, off
+ count
);
877 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
879 vsp_cmd
.sub_data
.kern
.token
= dma_addr
;
880 vsp_cmd
.sub_data
.kern
.address_type
= HvLpDma_AddressType_TceIndex
;
881 vsp_cmd
.sub_data
.kern
.side
= (u64
)data
;
882 vsp_cmd
.sub_data
.kern
.length
= off
+ count
;
884 rc
= signal_vsp_instruction(&vsp_cmd
);
885 dma_unmap_single(iSeries_vio_dev
, dma_addr
, off
+ count
,
889 if (vsp_cmd
.result_code
!= 0)
893 while (len
< (off
+ count
)) {
894 if ((*p
== '\0') || (*p
== '\n')) {
914 static int mf_getVmlinuxChunk(char *buffer
, int *size
, int offset
, u64 side
)
916 struct vsp_cmd_data vsp_cmd
;
921 dma_addr
= dma_map_single(iSeries_vio_dev
, buffer
, len
,
923 memset(buffer
, 0, len
);
924 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
926 vsp_cmd
.sub_data
.kern
.token
= dma_addr
;
927 vsp_cmd
.sub_data
.kern
.address_type
= HvLpDma_AddressType_TceIndex
;
928 vsp_cmd
.sub_data
.kern
.side
= side
;
929 vsp_cmd
.sub_data
.kern
.offset
= offset
;
930 vsp_cmd
.sub_data
.kern
.length
= len
;
932 rc
= signal_vsp_instruction(&vsp_cmd
);
934 if (vsp_cmd
.result_code
== 0)
935 *size
= vsp_cmd
.sub_data
.length_out
;
940 dma_unmap_single(iSeries_vio_dev
, dma_addr
, len
, DMA_FROM_DEVICE
);
945 static int proc_mf_dump_vmlinux(char *page
, char **start
, off_t off
,
946 int count
, int *eof
, void *data
)
948 int sizeToGet
= count
;
950 if (!capable(CAP_SYS_ADMIN
))
953 if (mf_getVmlinuxChunk(page
, &sizeToGet
, off
, (u64
)data
) == 0) {
954 if (sizeToGet
!= 0) {
966 static int proc_mf_dump_side(char *page
, char **start
, off_t off
,
967 int count
, int *eof
, void *data
)
970 char mf_current_side
= ' ';
971 struct vsp_cmd_data vsp_cmd
;
973 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
975 vsp_cmd
.sub_data
.ipl_type
= 0;
978 if (signal_vsp_instruction(&vsp_cmd
) == 0) {
979 if (vsp_cmd
.result_code
== 0) {
980 switch (vsp_cmd
.sub_data
.ipl_type
) {
981 case 0: mf_current_side
= 'A';
983 case 1: mf_current_side
= 'B';
985 case 2: mf_current_side
= 'C';
987 default: mf_current_side
= 'D';
993 len
= sprintf(page
, "%c\n", mf_current_side
);
995 if (len
<= (off
+ count
))
1006 static int proc_mf_change_side(struct file
*file
, const char __user
*buffer
,
1007 unsigned long count
, void *data
)
1011 struct vsp_cmd_data vsp_cmd
;
1013 if (!capable(CAP_SYS_ADMIN
))
1019 if (get_user(side
, buffer
))
1023 case 'A': newSide
= 0;
1025 case 'B': newSide
= 1;
1027 case 'C': newSide
= 2;
1029 case 'D': newSide
= 3;
1032 printk(KERN_ERR
"mf_proc.c: proc_mf_change_side: invalid side\n");
1036 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
1037 vsp_cmd
.sub_data
.ipl_type
= newSide
;
1040 (void)signal_vsp_instruction(&vsp_cmd
);
1046 static void mf_getSrcHistory(char *buffer
, int size
)
1048 struct IplTypeReturnStuff return_stuff
;
1049 struct pending_event
*ev
= new_pending_event();
1053 pages
[0] = kmalloc(4096, GFP_ATOMIC
);
1054 pages
[1] = kmalloc(4096, GFP_ATOMIC
);
1055 pages
[2] = kmalloc(4096, GFP_ATOMIC
);
1056 pages
[3] = kmalloc(4096, GFP_ATOMIC
);
1057 if ((ev
== NULL
) || (pages
[0] == NULL
) || (pages
[1] == NULL
)
1058 || (pages
[2] == NULL
) || (pages
[3] == NULL
))
1061 return_stuff
.xType
= 0;
1062 return_stuff
.xRc
= 0;
1063 return_stuff
.xDone
= 0;
1064 ev
->event
.hp_lp_event
.xSubtype
= 6;
1065 ev
->event
.hp_lp_event
.x
.xSubtypeData
=
1066 subtype_data('M', 'F', 'V', 'I');
1067 ev
->event
.data
.vsp_cmd
.xEvent
= &return_stuff
;
1068 ev
->event
.data
.vsp_cmd
.cmd
= 4;
1069 ev
->event
.data
.vsp_cmd
.lp_index
= HvLpConfig_getLpIndex();
1070 ev
->event
.data
.vsp_cmd
.result_code
= 0xFF;
1071 ev
->event
.data
.vsp_cmd
.reserved
= 0;
1072 ev
->event
.data
.vsp_cmd
.sub_data
.page
[0] = iseries_hv_addr(pages
[0]);
1073 ev
->event
.data
.vsp_cmd
.sub_data
.page
[1] = iseries_hv_addr(pages
[1]);
1074 ev
->event
.data
.vsp_cmd
.sub_data
.page
[2] = iseries_hv_addr(pages
[2]);
1075 ev
->event
.data
.vsp_cmd
.sub_data
.page
[3] = iseries_hv_addr(pages
[3]);
1077 if (signal_event(ev
) != 0)
1080 while (return_stuff
.xDone
!= 1)
1082 if (return_stuff
.xRc
== 0)
1083 memcpy(buffer
, pages
[0], size
);
1091 static int proc_mf_dump_src(char *page
, char **start
, off_t off
,
1092 int count
, int *eof
, void *data
)
1097 mf_getSrcHistory(page
, count
);
1106 *start
= page
+ off
;
1113 static int proc_mf_change_src(struct file
*file
, const char __user
*buffer
,
1114 unsigned long count
, void *data
)
1118 if (!capable(CAP_SYS_ADMIN
))
1121 if ((count
< 4) && (count
!= 1)) {
1122 printk(KERN_ERR
"mf_proc: invalid src\n");
1126 if (count
> (sizeof(stkbuf
) - 1))
1127 count
= sizeof(stkbuf
) - 1;
1128 if (copy_from_user(stkbuf
, buffer
, count
))
1131 if ((count
== 1) && (*stkbuf
== '\0'))
1134 mf_display_src(*(u32
*)stkbuf
);
1139 static int proc_mf_change_cmdline(struct file
*file
, const char __user
*buffer
,
1140 unsigned long count
, void *data
)
1142 struct vsp_cmd_data vsp_cmd
;
1143 dma_addr_t dma_addr
;
1147 if (!capable(CAP_SYS_ADMIN
))
1151 page
= dma_alloc_coherent(iSeries_vio_dev
, count
, &dma_addr
,
1158 if (copy_from_user(page
, buffer
, count
))
1161 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
1163 vsp_cmd
.sub_data
.kern
.token
= dma_addr
;
1164 vsp_cmd
.sub_data
.kern
.address_type
= HvLpDma_AddressType_TceIndex
;
1165 vsp_cmd
.sub_data
.kern
.side
= (u64
)data
;
1166 vsp_cmd
.sub_data
.kern
.length
= count
;
1168 (void)signal_vsp_instruction(&vsp_cmd
);
1172 dma_free_coherent(iSeries_vio_dev
, count
, page
, dma_addr
);
1177 static ssize_t
proc_mf_change_vmlinux(struct file
*file
,
1178 const char __user
*buf
,
1179 size_t count
, loff_t
*ppos
)
1181 struct proc_dir_entry
*dp
= PDE(file
->f_dentry
->d_inode
);
1183 dma_addr_t dma_addr
;
1185 struct vsp_cmd_data vsp_cmd
;
1188 if (!capable(CAP_SYS_ADMIN
))
1192 page
= dma_alloc_coherent(iSeries_vio_dev
, count
, &dma_addr
,
1196 printk(KERN_ERR
"mf.c: couldn't allocate memory to set vmlinux chunk\n");
1200 if (copy_from_user(page
, buf
, count
))
1203 memset(&vsp_cmd
, 0, sizeof(vsp_cmd
));
1205 vsp_cmd
.sub_data
.kern
.token
= dma_addr
;
1206 vsp_cmd
.sub_data
.kern
.address_type
= HvLpDma_AddressType_TceIndex
;
1207 vsp_cmd
.sub_data
.kern
.side
= (u64
)dp
->data
;
1208 vsp_cmd
.sub_data
.kern
.offset
= *ppos
;
1209 vsp_cmd
.sub_data
.kern
.length
= count
;
1211 rc
= signal_vsp_instruction(&vsp_cmd
);
1215 if (vsp_cmd
.result_code
!= 0)
1221 dma_free_coherent(iSeries_vio_dev
, count
, page
, dma_addr
);
1226 static struct file_operations proc_vmlinux_operations
= {
1227 .write
= proc_mf_change_vmlinux
,
1230 static int __init
mf_proc_init(void)
1232 struct proc_dir_entry
*mf_proc_root
;
1233 struct proc_dir_entry
*ent
;
1234 struct proc_dir_entry
*mf
;
1238 mf_proc_root
= proc_mkdir("iSeries/mf", NULL
);
1243 for (i
= 0; i
< 4; i
++) {
1245 mf
= proc_mkdir(name
, mf_proc_root
);
1249 ent
= create_proc_entry("cmdline", S_IFREG
|S_IRUSR
|S_IWUSR
, mf
);
1253 ent
->data
= (void *)(long)i
;
1254 ent
->read_proc
= proc_mf_dump_cmdline
;
1255 ent
->write_proc
= proc_mf_change_cmdline
;
1257 if (i
== 3) /* no vmlinux entry for 'D' */
1260 ent
= create_proc_entry("vmlinux", S_IFREG
|S_IWUSR
, mf
);
1264 ent
->data
= (void *)(long)i
;
1265 ent
->proc_fops
= &proc_vmlinux_operations
;
1268 ent
= create_proc_entry("side", S_IFREG
|S_IRUSR
|S_IWUSR
, mf_proc_root
);
1272 ent
->data
= (void *)0;
1273 ent
->read_proc
= proc_mf_dump_side
;
1274 ent
->write_proc
= proc_mf_change_side
;
1276 ent
= create_proc_entry("src", S_IFREG
|S_IRUSR
|S_IWUSR
, mf_proc_root
);
1280 ent
->data
= (void *)0;
1281 ent
->read_proc
= proc_mf_dump_src
;
1282 ent
->write_proc
= proc_mf_change_src
;
1287 __initcall(mf_proc_init
);
1289 #endif /* CONFIG_PROC_FS */
1292 * Get the RTC from the virtual service processor
1293 * This requires flowing LpEvents to the primary partition
1295 void iSeries_get_rtc_time(struct rtc_time
*rtc_tm
)
1302 * Set the RTC in the virtual service processor
1303 * This requires flowing LpEvents to the primary partition
1305 int iSeries_set_rtc_time(struct rtc_time
*tm
)
1311 unsigned long iSeries_get_boot_time(void)
1315 mf_get_boot_rtc(&tm
);
1316 return mktime(tm
.tm_year
+ 1900, tm
.tm_mon
, tm
.tm_mday
,
1317 tm
.tm_hour
, tm
.tm_min
, tm
.tm_sec
);