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/firmware.h>
42 #include <asm/iseries/mf.h>
43 #include <asm/iseries/hv_lp_config.h>
44 #include <asm/iseries/hv_lp_event.h>
45 #include <asm/iseries/it_lp_queue.h>
49 static int mf_initialized;
52 * This is the structure layout for the Machine Facilites LPAR event
62 u64 state; /* GetStateOut */
63 u64 ipl_type; /* GetIplTypeOut, Function02SelectIplTypeIn */
64 u64 ipl_mode; /* GetIplModeOut, Function02SelectIplModeIn */
65 u64 page[4]; /* GetSrcHistoryIn */
66 u64 flag; /* GetAutoIplWhenPrimaryIplsOut,
67 SetAutoIplWhenPrimaryIplsIn,
68 WhiteButtonPowerOffIn,
69 Function08FastPowerOffIn,
70 IsSpcnRackPowerIncompleteOut */
77 } kern; /* SetKernelImageIn, GetKernelImageIn,
78 SetKernelCmdLineIn, GetKernelCmdLineIn */
79 u32 length_out; /* GetKernelImageOut, GetKernelCmdLineOut */
85 struct completion com;
86 struct vsp_cmd_data *response;
100 typedef void (*ce_msg_comp_hdlr)(void *token, struct ce_msg_data *vsp_cmd_rsp);
102 struct ce_msg_comp_data {
103 ce_msg_comp_hdlr handler;
110 struct ce_msg_comp_data *completion;
113 struct io_mf_lp_event {
114 struct HvLpEvent hp_lp_event;
115 u16 subtype_result_code;
119 struct alloc_data alloc;
120 struct ce_msg_data ce_msg;
121 struct vsp_cmd_data vsp_cmd;
125 #define subtype_data(a, b, c, d) \
126 (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
129 * All outgoing event traffic is kept on a FIFO queue. The first
130 * pointer points to the one that is outstanding, and all new
131 * requests get stuck on the end. Also, we keep a certain number of
132 * preallocated pending events so that we can operate very early in
133 * the boot up sequence (before kmalloc is ready).
135 struct pending_event {
136 struct pending_event *next;
137 struct io_mf_lp_event event;
138 MFCompleteHandler hdlr;
140 unsigned dma_data_length;
141 unsigned remote_address;
143 static spinlock_t pending_event_spinlock;
144 static struct pending_event *pending_event_head;
145 static struct pending_event *pending_event_tail;
146 static struct pending_event *pending_event_avail;
147 #define PENDING_EVENT_PREALLOC_LEN 16
148 static struct pending_event pending_event_prealloc[PENDING_EVENT_PREALLOC_LEN];
151 * Put a pending event onto the available queue, so it can get reused.
152 * Attention! You must have the pending_event_spinlock before calling!
154 static void free_pending_event(struct pending_event *ev)
157 ev->next = pending_event_avail;
158 pending_event_avail = ev;
163 * Enqueue the outbound event onto the stack. If the queue was
164 * empty to begin with, we must also issue it via the Hypervisor
165 * interface. There is a section of code below that will touch
166 * the first stack pointer without the protection of the pending_event_spinlock.
167 * This is OK, because we know that nobody else will be modifying
168 * the first pointer when we do this.
170 static int signal_event(struct pending_event *ev)
175 struct pending_event *ev1;
178 /* enqueue the event */
181 spin_lock_irqsave(&pending_event_spinlock, flags);
182 if (pending_event_head == NULL)
183 pending_event_head = ev;
186 pending_event_tail->next = ev;
188 pending_event_tail = ev;
189 spin_unlock_irqrestore(&pending_event_spinlock, flags);
196 /* any DMA data to send beforehand? */
197 if (pending_event_head->dma_data_length > 0)
198 HvCallEvent_dmaToSp(pending_event_head->dma_data,
199 pending_event_head->remote_address,
200 pending_event_head->dma_data_length,
201 HvLpDma_Direction_LocalToRemote);
203 hv_rc = HvCallEvent_signalLpEvent(
204 &pending_event_head->event.hp_lp_event);
205 if (hv_rc != HvLpEvent_Rc_Good) {
206 printk(KERN_ERR "mf.c: HvCallEvent_signalLpEvent() "
207 "failed with %d\n", (int)hv_rc);
209 spin_lock_irqsave(&pending_event_spinlock, flags);
210 ev1 = pending_event_head;
211 pending_event_head = pending_event_head->next;
212 if (pending_event_head != NULL)
214 spin_unlock_irqrestore(&pending_event_spinlock, flags);
218 else if (ev1->hdlr != NULL)
219 (*ev1->hdlr)((void *)ev1->event.hp_lp_event.xCorrelationToken, -EIO);
221 spin_lock_irqsave(&pending_event_spinlock, flags);
222 free_pending_event(ev1);
223 spin_unlock_irqrestore(&pending_event_spinlock, flags);
231 * Allocate a new pending_event structure, and initialize it.
233 static struct pending_event *new_pending_event(void)
235 struct pending_event *ev = NULL;
236 HvLpIndex primary_lp = HvLpConfig_getPrimaryLpIndex();
238 struct HvLpEvent *hev;
240 spin_lock_irqsave(&pending_event_spinlock, flags);
241 if (pending_event_avail != NULL) {
242 ev = pending_event_avail;
243 pending_event_avail = pending_event_avail->next;
245 spin_unlock_irqrestore(&pending_event_spinlock, flags);
247 ev = kmalloc(sizeof(struct pending_event), GFP_ATOMIC);
249 printk(KERN_ERR "mf.c: unable to kmalloc %ld bytes\n",
250 sizeof(struct pending_event));
254 memset(ev, 0, sizeof(struct pending_event));
255 hev = &ev->event.hp_lp_event;
256 hev->flags = HV_LP_EVENT_VALID | HV_LP_EVENT_DO_ACK | HV_LP_EVENT_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 __maybe_unused
271 signal_vsp_instruction(struct vsp_cmd_data *vsp_cmd)
273 struct pending_event *ev = new_pending_event();
275 struct vsp_rsp_data response;
280 init_completion(&response.com);
281 response.response = vsp_cmd;
282 ev->event.hp_lp_event.xSubtype = 6;
283 ev->event.hp_lp_event.x.xSubtypeData =
284 subtype_data('M', 'F', 'V', 'I');
285 ev->event.data.vsp_cmd.token = (u64)&response;
286 ev->event.data.vsp_cmd.cmd = vsp_cmd->cmd;
287 ev->event.data.vsp_cmd.lp_index = HvLpConfig_getLpIndex();
288 ev->event.data.vsp_cmd.result_code = 0xFF;
289 ev->event.data.vsp_cmd.reserved = 0;
290 memcpy(&(ev->event.data.vsp_cmd.sub_data),
291 &(vsp_cmd->sub_data), sizeof(vsp_cmd->sub_data));
294 rc = signal_event(ev);
296 wait_for_completion(&response.com);
302 * Send a 12-byte CE message to the primary partition VSP object
304 static int signal_ce_msg(char *ce_msg, struct ce_msg_comp_data *completion)
306 struct pending_event *ev = new_pending_event();
311 ev->event.hp_lp_event.xSubtype = 0;
312 ev->event.hp_lp_event.x.xSubtypeData =
313 subtype_data('M', 'F', 'C', 'E');
314 memcpy(ev->event.data.ce_msg.ce_msg, ce_msg, 12);
315 ev->event.data.ce_msg.completion = completion;
316 return signal_event(ev);
320 * Send a 12-byte CE message (with no data) to the primary partition VSP object
322 static int signal_ce_msg_simple(u8 ce_op, struct ce_msg_comp_data *completion)
326 memset(ce_msg, 0, sizeof(ce_msg));
328 return signal_ce_msg(ce_msg, completion);
332 * Send a 12-byte CE message and DMA data to the primary partition VSP object
334 static int dma_and_signal_ce_msg(char *ce_msg,
335 struct ce_msg_comp_data *completion, void *dma_data,
336 unsigned dma_data_length, unsigned remote_address)
338 struct pending_event *ev = new_pending_event();
343 ev->event.hp_lp_event.xSubtype = 0;
344 ev->event.hp_lp_event.x.xSubtypeData =
345 subtype_data('M', 'F', 'C', 'E');
346 memcpy(ev->event.data.ce_msg.ce_msg, ce_msg, 12);
347 ev->event.data.ce_msg.completion = completion;
348 memcpy(ev->dma_data, dma_data, dma_data_length);
349 ev->dma_data_length = dma_data_length;
350 ev->remote_address = remote_address;
351 return signal_event(ev);
355 * Initiate a nice (hopefully) shutdown of Linux. We simply are
356 * going to try and send the init process a SIGINT signal. If
357 * this fails (why?), we'll simply force it off in a not-so-nice
360 static int shutdown(void)
362 int rc = kill_cad_pid(SIGINT, 1);
365 printk(KERN_ALERT "mf.c: SIGINT to init failed (%d), "
366 "hard shutdown commencing\n", rc);
369 printk(KERN_INFO "mf.c: init has been successfully notified "
370 "to proceed with shutdown\n");
375 * The primary partition VSP object is sending us a new
376 * event flow. Handle it...
378 static void handle_int(struct io_mf_lp_event *event)
380 struct ce_msg_data *ce_msg_data;
381 struct ce_msg_data *pce_msg_data;
383 struct pending_event *pev;
385 /* ack the interrupt */
386 event->hp_lp_event.xRc = HvLpEvent_Rc_Good;
387 HvCallEvent_ackLpEvent(&event->hp_lp_event);
389 /* process interrupt */
390 switch (event->hp_lp_event.xSubtype) {
391 case 0: /* CE message */
392 ce_msg_data = &event->data.ce_msg;
393 switch (ce_msg_data->ce_msg[3]) {
394 case 0x5B: /* power control notification */
395 if ((ce_msg_data->ce_msg[5] & 0x20) != 0) {
396 printk(KERN_INFO "mf.c: Commencing partition shutdown\n");
398 signal_ce_msg_simple(0xDB, NULL);
401 case 0xC0: /* get time */
402 spin_lock_irqsave(&pending_event_spinlock, flags);
403 pev = pending_event_head;
405 pending_event_head = pending_event_head->next;
406 spin_unlock_irqrestore(&pending_event_spinlock, flags);
409 pce_msg_data = &pev->event.data.ce_msg;
410 if (pce_msg_data->ce_msg[3] != 0x40)
412 if (pce_msg_data->completion != NULL) {
413 ce_msg_comp_hdlr handler =
414 pce_msg_data->completion->handler;
415 void *token = pce_msg_data->completion->token;
418 (*handler)(token, ce_msg_data);
420 spin_lock_irqsave(&pending_event_spinlock, flags);
421 free_pending_event(pev);
422 spin_unlock_irqrestore(&pending_event_spinlock, flags);
423 /* send next waiting event */
424 if (pending_event_head != NULL)
429 case 1: /* IT sys shutdown */
430 printk(KERN_INFO "mf.c: Commencing system shutdown\n");
437 * The primary partition VSP object is acknowledging the receipt
438 * of a flow we sent to them. If there are other flows queued
439 * up, we must send another one now...
441 static void handle_ack(struct io_mf_lp_event *event)
444 struct pending_event *two = NULL;
445 unsigned long free_it = 0;
446 struct ce_msg_data *ce_msg_data;
447 struct ce_msg_data *pce_msg_data;
448 struct vsp_rsp_data *rsp;
450 /* handle current event */
451 if (pending_event_head == NULL) {
452 printk(KERN_ERR "mf.c: stack empty for receiving ack\n");
456 switch (event->hp_lp_event.xSubtype) {
458 ce_msg_data = &event->data.ce_msg;
459 if (ce_msg_data->ce_msg[3] != 0x40) {
463 if (ce_msg_data->ce_msg[2] == 0)
466 pce_msg_data = &pending_event_head->event.data.ce_msg;
467 if (pce_msg_data->completion != NULL) {
468 ce_msg_comp_hdlr handler =
469 pce_msg_data->completion->handler;
470 void *token = pce_msg_data->completion->token;
473 (*handler)(token, ce_msg_data);
476 case 4: /* allocate */
477 case 5: /* deallocate */
478 if (pending_event_head->hdlr != NULL)
479 (*pending_event_head->hdlr)((void *)event->hp_lp_event.xCorrelationToken, event->data.alloc.count);
484 rsp = (struct vsp_rsp_data *)event->data.vsp_cmd.token;
486 printk(KERN_ERR "mf.c: no rsp\n");
489 if (rsp->response != NULL)
490 memcpy(rsp->response, &event->data.vsp_cmd,
491 sizeof(event->data.vsp_cmd));
496 /* remove from queue */
497 spin_lock_irqsave(&pending_event_spinlock, flags);
498 if ((pending_event_head != NULL) && (free_it == 1)) {
499 struct pending_event *oldHead = pending_event_head;
501 pending_event_head = pending_event_head->next;
502 two = pending_event_head;
503 free_pending_event(oldHead);
505 spin_unlock_irqrestore(&pending_event_spinlock, flags);
507 /* send next waiting event */
513 * This is the generic event handler we are registering with
514 * the Hypervisor. Ensure the flows are for us, and then
515 * parse it enough to know if it is an interrupt or an
518 static void hv_handler(struct HvLpEvent *event)
520 if ((event != NULL) && (event->xType == HvLpEvent_Type_MachineFac)) {
521 if (hvlpevent_is_ack(event))
522 handle_ack((struct io_mf_lp_event *)event);
524 handle_int((struct io_mf_lp_event *)event);
526 printk(KERN_ERR "mf.c: alien event received\n");
530 * Global kernel interface to allocate and seed events into the
533 void mf_allocate_lp_events(HvLpIndex target_lp, HvLpEvent_Type type,
534 unsigned size, unsigned count, MFCompleteHandler hdlr,
537 struct pending_event *ev = new_pending_event();
543 ev->event.hp_lp_event.xSubtype = 4;
544 ev->event.hp_lp_event.xCorrelationToken = (u64)user_token;
545 ev->event.hp_lp_event.x.xSubtypeData =
546 subtype_data('M', 'F', 'M', 'A');
547 ev->event.data.alloc.target_lp = target_lp;
548 ev->event.data.alloc.type = type;
549 ev->event.data.alloc.size = size;
550 ev->event.data.alloc.count = count;
552 rc = signal_event(ev);
554 if ((rc != 0) && (hdlr != NULL))
555 (*hdlr)(user_token, rc);
557 EXPORT_SYMBOL(mf_allocate_lp_events);
560 * Global kernel interface to unseed and deallocate events already in
563 void mf_deallocate_lp_events(HvLpIndex target_lp, HvLpEvent_Type type,
564 unsigned count, MFCompleteHandler hdlr, void *user_token)
566 struct pending_event *ev = new_pending_event();
572 ev->event.hp_lp_event.xSubtype = 5;
573 ev->event.hp_lp_event.xCorrelationToken = (u64)user_token;
574 ev->event.hp_lp_event.x.xSubtypeData =
575 subtype_data('M', 'F', 'M', 'D');
576 ev->event.data.alloc.target_lp = target_lp;
577 ev->event.data.alloc.type = type;
578 ev->event.data.alloc.count = count;
580 rc = signal_event(ev);
582 if ((rc != 0) && (hdlr != NULL))
583 (*hdlr)(user_token, rc);
585 EXPORT_SYMBOL(mf_deallocate_lp_events);
588 * Global kernel interface to tell the VSP object in the primary
589 * partition to power this partition off.
591 void mf_power_off(void)
593 printk(KERN_INFO "mf.c: Down it goes...\n");
594 signal_ce_msg_simple(0x4d, NULL);
600 * Global kernel interface to tell the VSP object in the primary
601 * partition to reboot this partition.
603 void mf_reboot(char *cmd)
605 printk(KERN_INFO "mf.c: Preparing to bounce...\n");
606 signal_ce_msg_simple(0x4e, NULL);
612 * Display a single word SRC onto the VSP control panel.
614 void mf_display_src(u32 word)
618 memset(ce, 0, sizeof(ce));
625 signal_ce_msg(ce, NULL);
629 * Display a single word SRC of the form "PROGXXXX" on the VSP control panel.
631 static __init void mf_display_progress_src(u16 value)
636 memcpy(ce, "\x00\x00\x04\x4A\x00\x00\x00\x48\x00\x00\x00\x00", 12);
637 memcpy(src, "\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
638 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
639 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
640 "\x00\x00\x00\x00PROGxxxx ",
643 src[7] = value & 255;
644 src[44] = "0123456789ABCDEF"[(value >> 12) & 15];
645 src[45] = "0123456789ABCDEF"[(value >> 8) & 15];
646 src[46] = "0123456789ABCDEF"[(value >> 4) & 15];
647 src[47] = "0123456789ABCDEF"[value & 15];
648 dma_and_signal_ce_msg(ce, NULL, src, sizeof(src), 9 * 64 * 1024);
652 * Clear the VSP control panel. Used to "erase" an SRC that was
653 * previously displayed.
655 static void mf_clear_src(void)
657 signal_ce_msg_simple(0x4b, NULL);
660 void __init mf_display_progress(u16 value)
668 mf_display_progress_src(value);
672 * Initialization code here.
674 void __init mf_init(void)
678 spin_lock_init(&pending_event_spinlock);
680 for (i = 0; i < PENDING_EVENT_PREALLOC_LEN; i++)
681 free_pending_event(&pending_event_prealloc[i]);
683 HvLpEvent_registerHandler(HvLpEvent_Type_MachineFac, &hv_handler);
685 /* virtual continue ack */
686 signal_ce_msg_simple(0x57, NULL);
691 printk(KERN_NOTICE "mf.c: iSeries Linux LPAR Machine Facilities "
695 struct rtc_time_data {
696 struct completion com;
697 struct ce_msg_data ce_msg;
701 static void get_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
703 struct rtc_time_data *rtc = token;
705 memcpy(&rtc->ce_msg, ce_msg, sizeof(rtc->ce_msg));
710 static int mf_set_rtc(struct rtc_time *tm)
713 u8 day, mon, hour, min, sec, y1, y2;
716 year = 1900 + tm->tm_year;
724 mon = tm->tm_mon + 1;
728 hour = bin2bcd(hour);
734 memset(ce_time, 0, sizeof(ce_time));
744 return signal_ce_msg(ce_time, NULL);
747 static int rtc_set_tm(int rc, u8 *ce_msg, struct rtc_time *tm)
762 if ((ce_msg[2] == 0xa9) ||
763 (ce_msg[2] == 0xaf)) {
764 /* TOD clock is not set */
783 hour = bcd2bin(hour);
786 year = bcd2bin(year);
802 static int mf_get_rtc(struct rtc_time *tm)
804 struct ce_msg_comp_data ce_complete;
805 struct rtc_time_data rtc_data;
808 memset(&ce_complete, 0, sizeof(ce_complete));
809 memset(&rtc_data, 0, sizeof(rtc_data));
810 init_completion(&rtc_data.com);
811 ce_complete.handler = &get_rtc_time_complete;
812 ce_complete.token = &rtc_data;
813 rc = signal_ce_msg_simple(0x40, &ce_complete);
816 wait_for_completion(&rtc_data.com);
817 return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
820 struct boot_rtc_time_data {
822 struct ce_msg_data ce_msg;
826 static void get_boot_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
828 struct boot_rtc_time_data *rtc = token;
830 memcpy(&rtc->ce_msg, ce_msg, sizeof(rtc->ce_msg));
835 static int mf_get_boot_rtc(struct rtc_time *tm)
837 struct ce_msg_comp_data ce_complete;
838 struct boot_rtc_time_data rtc_data;
841 memset(&ce_complete, 0, sizeof(ce_complete));
842 memset(&rtc_data, 0, sizeof(rtc_data));
844 ce_complete.handler = &get_boot_rtc_time_complete;
845 ce_complete.token = &rtc_data;
846 rc = signal_ce_msg_simple(0x40, &ce_complete);
849 /* We need to poll here as we are not yet taking interrupts */
850 while (rtc_data.busy) {
851 if (hvlpevent_is_pending())
852 process_hvlpevents();
854 return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
857 #ifdef CONFIG_PROC_FS
859 static int proc_mf_dump_cmdline(char *page, char **start, off_t off,
860 int count, int *eof, void *data)
864 struct vsp_cmd_data vsp_cmd;
868 /* The HV appears to return no more than 256 bytes of command line */
871 if ((off + count) > 256)
874 dma_addr = iseries_hv_map(page, off + count, DMA_FROM_DEVICE);
875 if (dma_addr == DMA_ERROR_CODE)
877 memset(page, 0, off + count);
878 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
880 vsp_cmd.sub_data.kern.token = dma_addr;
881 vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
882 vsp_cmd.sub_data.kern.side = (u64)data;
883 vsp_cmd.sub_data.kern.length = off + count;
885 rc = signal_vsp_instruction(&vsp_cmd);
886 iseries_hv_unmap(dma_addr, off + count, DMA_FROM_DEVICE);
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 = iseries_hv_map(buffer, len, DMA_FROM_DEVICE);
922 memset(buffer, 0, len);
923 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
925 vsp_cmd.sub_data.kern.token = dma_addr;
926 vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
927 vsp_cmd.sub_data.kern.side = side;
928 vsp_cmd.sub_data.kern.offset = offset;
929 vsp_cmd.sub_data.kern.length = len;
931 rc = signal_vsp_instruction(&vsp_cmd);
933 if (vsp_cmd.result_code == 0)
934 *size = vsp_cmd.sub_data.length_out;
939 iseries_hv_unmap(dma_addr, len, DMA_FROM_DEVICE);
944 static int proc_mf_dump_vmlinux(char *page, char **start, off_t off,
945 int count, int *eof, void *data)
947 int sizeToGet = count;
949 if (!capable(CAP_SYS_ADMIN))
952 if (mf_getVmlinuxChunk(page, &sizeToGet, off, (u64)data) == 0) {
953 if (sizeToGet != 0) {
965 static int proc_mf_dump_side(char *page, char **start, off_t off,
966 int count, int *eof, void *data)
969 char mf_current_side = ' ';
970 struct vsp_cmd_data vsp_cmd;
972 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
974 vsp_cmd.sub_data.ipl_type = 0;
977 if (signal_vsp_instruction(&vsp_cmd) == 0) {
978 if (vsp_cmd.result_code == 0) {
979 switch (vsp_cmd.sub_data.ipl_type) {
980 case 0: mf_current_side = 'A';
982 case 1: mf_current_side = 'B';
984 case 2: mf_current_side = 'C';
986 default: mf_current_side = 'D';
992 len = sprintf(page, "%c\n", mf_current_side);
994 if (len <= (off + count))
1005 static int proc_mf_change_side(struct file *file, const char __user *buffer,
1006 unsigned long count, void *data)
1010 struct vsp_cmd_data vsp_cmd;
1012 if (!capable(CAP_SYS_ADMIN))
1018 if (get_user(side, buffer))
1022 case 'A': newSide = 0;
1024 case 'B': newSide = 1;
1026 case 'C': newSide = 2;
1028 case 'D': newSide = 3;
1031 printk(KERN_ERR "mf_proc.c: proc_mf_change_side: invalid side\n");
1035 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
1036 vsp_cmd.sub_data.ipl_type = newSide;
1039 (void)signal_vsp_instruction(&vsp_cmd);
1045 static void mf_getSrcHistory(char *buffer, int size)
1047 struct IplTypeReturnStuff return_stuff;
1048 struct pending_event *ev = new_pending_event();
1052 pages[0] = kmalloc(4096, GFP_ATOMIC);
1053 pages[1] = kmalloc(4096, GFP_ATOMIC);
1054 pages[2] = kmalloc(4096, GFP_ATOMIC);
1055 pages[3] = kmalloc(4096, GFP_ATOMIC);
1056 if ((ev == NULL) || (pages[0] == NULL) || (pages[1] == NULL)
1057 || (pages[2] == NULL) || (pages[3] == NULL))
1060 return_stuff.xType = 0;
1061 return_stuff.xRc = 0;
1062 return_stuff.xDone = 0;
1063 ev->event.hp_lp_event.xSubtype = 6;
1064 ev->event.hp_lp_event.x.xSubtypeData =
1065 subtype_data('M', 'F', 'V', 'I');
1066 ev->event.data.vsp_cmd.xEvent = &return_stuff;
1067 ev->event.data.vsp_cmd.cmd = 4;
1068 ev->event.data.vsp_cmd.lp_index = HvLpConfig_getLpIndex();
1069 ev->event.data.vsp_cmd.result_code = 0xFF;
1070 ev->event.data.vsp_cmd.reserved = 0;
1071 ev->event.data.vsp_cmd.sub_data.page[0] = iseries_hv_addr(pages[0]);
1072 ev->event.data.vsp_cmd.sub_data.page[1] = iseries_hv_addr(pages[1]);
1073 ev->event.data.vsp_cmd.sub_data.page[2] = iseries_hv_addr(pages[2]);
1074 ev->event.data.vsp_cmd.sub_data.page[3] = iseries_hv_addr(pages[3]);
1076 if (signal_event(ev) != 0)
1079 while (return_stuff.xDone != 1)
1081 if (return_stuff.xRc == 0)
1082 memcpy(buffer, pages[0], size);
1090 static int proc_mf_dump_src(char *page, char **start, off_t off,
1091 int count, int *eof, void *data)
1096 mf_getSrcHistory(page, count);
1105 *start = page + off;
1112 static int proc_mf_change_src(struct file *file, const char __user *buffer,
1113 unsigned long count, void *data)
1117 if (!capable(CAP_SYS_ADMIN))
1120 if ((count < 4) && (count != 1)) {
1121 printk(KERN_ERR "mf_proc: invalid src\n");
1125 if (count > (sizeof(stkbuf) - 1))
1126 count = sizeof(stkbuf) - 1;
1127 if (copy_from_user(stkbuf, buffer, count))
1130 if ((count == 1) && (*stkbuf == '\0'))
1133 mf_display_src(*(u32 *)stkbuf);
1138 static int proc_mf_change_cmdline(struct file *file, const char __user *buffer,
1139 unsigned long count, void *data)
1141 struct vsp_cmd_data vsp_cmd;
1142 dma_addr_t dma_addr;
1146 if (!capable(CAP_SYS_ADMIN))
1150 page = iseries_hv_alloc(count, &dma_addr, GFP_ATOMIC);
1156 if (copy_from_user(page, buffer, count))
1159 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
1161 vsp_cmd.sub_data.kern.token = dma_addr;
1162 vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
1163 vsp_cmd.sub_data.kern.side = (u64)data;
1164 vsp_cmd.sub_data.kern.length = count;
1166 (void)signal_vsp_instruction(&vsp_cmd);
1170 iseries_hv_free(count, page, dma_addr);
1175 static ssize_t proc_mf_change_vmlinux(struct file *file,
1176 const char __user *buf,
1177 size_t count, loff_t *ppos)
1179 struct proc_dir_entry *dp = PDE(file->f_path.dentry->d_inode);
1181 dma_addr_t dma_addr;
1183 struct vsp_cmd_data vsp_cmd;
1186 if (!capable(CAP_SYS_ADMIN))
1190 page = iseries_hv_alloc(count, &dma_addr, GFP_ATOMIC);
1193 printk(KERN_ERR "mf.c: couldn't allocate memory to set vmlinux chunk\n");
1197 if (copy_from_user(page, buf, count))
1200 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
1202 vsp_cmd.sub_data.kern.token = dma_addr;
1203 vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
1204 vsp_cmd.sub_data.kern.side = (u64)dp->data;
1205 vsp_cmd.sub_data.kern.offset = *ppos;
1206 vsp_cmd.sub_data.kern.length = count;
1208 rc = signal_vsp_instruction(&vsp_cmd);
1212 if (vsp_cmd.result_code != 0)
1218 iseries_hv_free(count, page, dma_addr);
1223 static const struct file_operations proc_vmlinux_operations = {
1224 .write = proc_mf_change_vmlinux,
1227 static int __init mf_proc_init(void)
1229 struct proc_dir_entry *mf_proc_root;
1230 struct proc_dir_entry *ent;
1231 struct proc_dir_entry *mf;
1235 if (!firmware_has_feature(FW_FEATURE_ISERIES))
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);
1252 ent->data = (void *)(long)i;
1253 ent->read_proc = proc_mf_dump_cmdline;
1254 ent->write_proc = proc_mf_change_cmdline;
1256 if (i == 3) /* no vmlinux entry for 'D' */
1259 ent = proc_create_data("vmlinux", S_IFREG|S_IWUSR, mf,
1260 &proc_vmlinux_operations,
1266 ent = create_proc_entry("side", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root);
1269 ent->data = (void *)0;
1270 ent->read_proc = proc_mf_dump_side;
1271 ent->write_proc = proc_mf_change_side;
1273 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)
1298 * Set the RTC in the virtual service processor
1299 * This requires flowing LpEvents to the primary partition
1301 int iSeries_set_rtc_time(struct rtc_time *tm)
1307 unsigned long iSeries_get_boot_time(void)
1311 mf_get_boot_rtc(&tm);
1312 return mktime(tm.tm_year + 1900, tm.tm_mon, tm.tm_mday,
1313 tm.tm_hour, tm.tm_min, tm.tm_sec);