powerpc: move iSeries_setup.[ch] and mf.c into platforms/iseries
authorStephen Rothwell <sfr@canb.auug.org.au>
Tue, 27 Sep 2005 08:44:42 +0000 (18:44 +1000)
committerStephen Rothwell <sfr@canb.auug.org.au>
Tue, 27 Sep 2005 08:44:42 +0000 (18:44 +1000)
iSeries_setup.c becomes setup.c
iSeries_setup.h becomes setup.h
mf.c retains its name

Also moved iSeries_[gs]et_rtc_time and iSeries_get_boot_time into
mf.c since they are just small wrappers around mf_ functions.

Signed-off-by: Stephen Rothwell <sfr@canb.auug.org.au>
arch/powerpc/platforms/iseries/Makefile
arch/powerpc/platforms/iseries/mf.c [new file with mode: 0644]
arch/powerpc/platforms/iseries/setup.c [new file with mode: 0644]
arch/powerpc/platforms/iseries/setup.h [new file with mode: 0644]
arch/ppc64/kernel/Makefile
arch/ppc64/kernel/iSeries_setup.c [deleted file]
arch/ppc64/kernel/iSeries_setup.h [deleted file]
arch/ppc64/kernel/mf.c [deleted file]
arch/ppc64/kernel/rtc.c

index 095471d50d9fb3403f527961c3b68cd559f74854..f5e11907cab1a264d442b388c6680176ad5d7957 100644 (file)
@@ -1 +1 @@
-obj-$(CONFIG_PPC_ISERIES) += hvcall.o hvlpconfig.o lpardata.o
+obj-y += hvcall.o hvlpconfig.o lpardata.o setup.o mf.o
diff --git a/arch/powerpc/platforms/iseries/mf.c b/arch/powerpc/platforms/iseries/mf.c
new file mode 100644 (file)
index 0000000..82f5aba
--- /dev/null
@@ -0,0 +1,1316 @@
+/*
+ * Copyright (C) 2001 Troy D. Armstrong  IBM Corporation
+ * Copyright (C) 2004-2005 Stephen Rothwell  IBM Corporation
+ *
+ * This modules exists as an interface between a Linux secondary partition
+ * running on an iSeries and the primary partition's Virtual Service
+ * Processor (VSP) object.  The VSP has final authority over powering on/off
+ * all partitions in the iSeries.  It also provides miscellaneous low-level
+ * machine facility type operations.
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/completion.h>
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/bcd.h>
+
+#include <asm/time.h>
+#include <asm/uaccess.h>
+#include <asm/paca.h>
+#include <asm/iSeries/vio.h>
+#include <asm/iSeries/mf.h>
+#include <asm/iSeries/HvLpConfig.h>
+#include <asm/iSeries/ItLpQueue.h>
+
+#include "setup.h"
+
+extern int piranha_simulator;
+
+/*
+ * This is the structure layout for the Machine Facilites LPAR event
+ * flows.
+ */
+struct vsp_cmd_data {
+       u64 token;
+       u16 cmd;
+       HvLpIndex lp_index;
+       u8 result_code;
+       u32 reserved;
+       union {
+               u64 state;      /* GetStateOut */
+               u64 ipl_type;   /* GetIplTypeOut, Function02SelectIplTypeIn */
+               u64 ipl_mode;   /* GetIplModeOut, Function02SelectIplModeIn */
+               u64 page[4];    /* GetSrcHistoryIn */
+               u64 flag;       /* GetAutoIplWhenPrimaryIplsOut,
+                                  SetAutoIplWhenPrimaryIplsIn,
+                                  WhiteButtonPowerOffIn,
+                                  Function08FastPowerOffIn,
+                                  IsSpcnRackPowerIncompleteOut */
+               struct {
+                       u64 token;
+                       u64 address_type;
+                       u64 side;
+                       u32 length;
+                       u32 offset;
+               } kern;         /* SetKernelImageIn, GetKernelImageIn,
+                                  SetKernelCmdLineIn, GetKernelCmdLineIn */
+               u32 length_out; /* GetKernelImageOut, GetKernelCmdLineOut */
+               u8 reserved[80];
+       } sub_data;
+};
+
+struct vsp_rsp_data {
+       struct completion com;
+       struct vsp_cmd_data *response;
+};
+
+struct alloc_data {
+       u16 size;
+       u16 type;
+       u32 count;
+       u16 reserved1;
+       u8 reserved2;
+       HvLpIndex target_lp;
+};
+
+struct ce_msg_data;
+
+typedef void (*ce_msg_comp_hdlr)(void *token, struct ce_msg_data *vsp_cmd_rsp);
+
+struct ce_msg_comp_data {
+       ce_msg_comp_hdlr handler;
+       void *token;
+};
+
+struct ce_msg_data {
+       u8 ce_msg[12];
+       char reserved[4];
+       struct ce_msg_comp_data *completion;
+};
+
+struct io_mf_lp_event {
+       struct HvLpEvent hp_lp_event;
+       u16 subtype_result_code;
+       u16 reserved1;
+       u32 reserved2;
+       union {
+               struct alloc_data alloc;
+               struct ce_msg_data ce_msg;
+               struct vsp_cmd_data vsp_cmd;
+       } data;
+};
+
+#define subtype_data(a, b, c, d)       \
+               (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
+
+/*
+ * All outgoing event traffic is kept on a FIFO queue.  The first
+ * pointer points to the one that is outstanding, and all new
+ * requests get stuck on the end.  Also, we keep a certain number of
+ * preallocated pending events so that we can operate very early in
+ * the boot up sequence (before kmalloc is ready).
+ */
+struct pending_event {
+       struct pending_event *next;
+       struct io_mf_lp_event event;
+       MFCompleteHandler hdlr;
+       char dma_data[72];
+       unsigned dma_data_length;
+       unsigned remote_address;
+};
+static spinlock_t pending_event_spinlock;
+static struct pending_event *pending_event_head;
+static struct pending_event *pending_event_tail;
+static struct pending_event *pending_event_avail;
+static struct pending_event pending_event_prealloc[16];
+
+/*
+ * Put a pending event onto the available queue, so it can get reused.
+ * Attention! You must have the pending_event_spinlock before calling!
+ */
+static void free_pending_event(struct pending_event *ev)
+{
+       if (ev != NULL) {
+               ev->next = pending_event_avail;
+               pending_event_avail = ev;
+       }
+}
+
+/*
+ * Enqueue the outbound event onto the stack.  If the queue was
+ * empty to begin with, we must also issue it via the Hypervisor
+ * interface.  There is a section of code below that will touch
+ * the first stack pointer without the protection of the pending_event_spinlock.
+ * This is OK, because we know that nobody else will be modifying
+ * the first pointer when we do this.
+ */
+static int signal_event(struct pending_event *ev)
+{
+       int rc = 0;
+       unsigned long flags;
+       int go = 1;
+       struct pending_event *ev1;
+       HvLpEvent_Rc hv_rc;
+
+       /* enqueue the event */
+       if (ev != NULL) {
+               ev->next = NULL;
+               spin_lock_irqsave(&pending_event_spinlock, flags);
+               if (pending_event_head == NULL)
+                       pending_event_head = ev;
+               else {
+                       go = 0;
+                       pending_event_tail->next = ev;
+               }
+               pending_event_tail = ev;
+               spin_unlock_irqrestore(&pending_event_spinlock, flags);
+       }
+
+       /* send the event */
+       while (go) {
+               go = 0;
+
+               /* any DMA data to send beforehand? */
+               if (pending_event_head->dma_data_length > 0)
+                       HvCallEvent_dmaToSp(pending_event_head->dma_data,
+                                       pending_event_head->remote_address,
+                                       pending_event_head->dma_data_length,
+                                       HvLpDma_Direction_LocalToRemote);
+
+               hv_rc = HvCallEvent_signalLpEvent(
+                               &pending_event_head->event.hp_lp_event);
+               if (hv_rc != HvLpEvent_Rc_Good) {
+                       printk(KERN_ERR "mf.c: HvCallEvent_signalLpEvent() "
+                                       "failed with %d\n", (int)hv_rc);
+
+                       spin_lock_irqsave(&pending_event_spinlock, flags);
+                       ev1 = pending_event_head;
+                       pending_event_head = pending_event_head->next;
+                       if (pending_event_head != NULL)
+                               go = 1;
+                       spin_unlock_irqrestore(&pending_event_spinlock, flags);
+
+                       if (ev1 == ev)
+                               rc = -EIO;
+                       else if (ev1->hdlr != NULL)
+                               (*ev1->hdlr)((void *)ev1->event.hp_lp_event.xCorrelationToken, -EIO);
+
+                       spin_lock_irqsave(&pending_event_spinlock, flags);
+                       free_pending_event(ev1);
+                       spin_unlock_irqrestore(&pending_event_spinlock, flags);
+               }
+       }
+
+       return rc;
+}
+
+/*
+ * Allocate a new pending_event structure, and initialize it.
+ */
+static struct pending_event *new_pending_event(void)
+{
+       struct pending_event *ev = NULL;
+       HvLpIndex primary_lp = HvLpConfig_getPrimaryLpIndex();
+       unsigned long flags;
+       struct HvLpEvent *hev;
+
+       spin_lock_irqsave(&pending_event_spinlock, flags);
+       if (pending_event_avail != NULL) {
+               ev = pending_event_avail;
+               pending_event_avail = pending_event_avail->next;
+       }
+       spin_unlock_irqrestore(&pending_event_spinlock, flags);
+       if (ev == NULL) {
+               ev = kmalloc(sizeof(struct pending_event), GFP_ATOMIC);
+               if (ev == NULL) {
+                       printk(KERN_ERR "mf.c: unable to kmalloc %ld bytes\n",
+                                       sizeof(struct pending_event));
+                       return NULL;
+               }
+       }
+       memset(ev, 0, sizeof(struct pending_event));
+       hev = &ev->event.hp_lp_event;
+       hev->xFlags.xValid = 1;
+       hev->xFlags.xAckType = HvLpEvent_AckType_ImmediateAck;
+       hev->xFlags.xAckInd = HvLpEvent_AckInd_DoAck;
+       hev->xFlags.xFunction = HvLpEvent_Function_Int;
+       hev->xType = HvLpEvent_Type_MachineFac;
+       hev->xSourceLp = HvLpConfig_getLpIndex();
+       hev->xTargetLp = primary_lp;
+       hev->xSizeMinus1 = sizeof(ev->event) - 1;
+       hev->xRc = HvLpEvent_Rc_Good;
+       hev->xSourceInstanceId = HvCallEvent_getSourceLpInstanceId(primary_lp,
+                       HvLpEvent_Type_MachineFac);
+       hev->xTargetInstanceId = HvCallEvent_getTargetLpInstanceId(primary_lp,
+                       HvLpEvent_Type_MachineFac);
+
+       return ev;
+}
+
+static int signal_vsp_instruction(struct vsp_cmd_data *vsp_cmd)
+{
+       struct pending_event *ev = new_pending_event();
+       int rc;
+       struct vsp_rsp_data response;
+
+       if (ev == NULL)
+               return -ENOMEM;
+
+       init_completion(&response.com);
+       response.response = vsp_cmd;
+       ev->event.hp_lp_event.xSubtype = 6;
+       ev->event.hp_lp_event.x.xSubtypeData =
+               subtype_data('M', 'F',  'V',  'I');
+       ev->event.data.vsp_cmd.token = (u64)&response;
+       ev->event.data.vsp_cmd.cmd = vsp_cmd->cmd;
+       ev->event.data.vsp_cmd.lp_index = HvLpConfig_getLpIndex();
+       ev->event.data.vsp_cmd.result_code = 0xFF;
+       ev->event.data.vsp_cmd.reserved = 0;
+       memcpy(&(ev->event.data.vsp_cmd.sub_data),
+                       &(vsp_cmd->sub_data), sizeof(vsp_cmd->sub_data));
+       mb();
+
+       rc = signal_event(ev);
+       if (rc == 0)
+               wait_for_completion(&response.com);
+       return rc;
+}
+
+
+/*
+ * Send a 12-byte CE message to the primary partition VSP object
+ */
+static int signal_ce_msg(char *ce_msg, struct ce_msg_comp_data *completion)
+{
+       struct pending_event *ev = new_pending_event();
+
+       if (ev == NULL)
+               return -ENOMEM;
+
+       ev->event.hp_lp_event.xSubtype = 0;
+       ev->event.hp_lp_event.x.xSubtypeData =
+               subtype_data('M',  'F',  'C',  'E');
+       memcpy(ev->event.data.ce_msg.ce_msg, ce_msg, 12);
+       ev->event.data.ce_msg.completion = completion;
+       return signal_event(ev);
+}
+
+/*
+ * Send a 12-byte CE message (with no data) to the primary partition VSP object
+ */
+static int signal_ce_msg_simple(u8 ce_op, struct ce_msg_comp_data *completion)
+{
+       u8 ce_msg[12];
+
+       memset(ce_msg, 0, sizeof(ce_msg));
+       ce_msg[3] = ce_op;
+       return signal_ce_msg(ce_msg, completion);
+}
+
+/*
+ * Send a 12-byte CE message and DMA data to the primary partition VSP object
+ */
+static int dma_and_signal_ce_msg(char *ce_msg,
+               struct ce_msg_comp_data *completion, void *dma_data,
+               unsigned dma_data_length, unsigned remote_address)
+{
+       struct pending_event *ev = new_pending_event();
+
+       if (ev == NULL)
+               return -ENOMEM;
+
+       ev->event.hp_lp_event.xSubtype = 0;
+       ev->event.hp_lp_event.x.xSubtypeData =
+               subtype_data('M', 'F', 'C', 'E');
+       memcpy(ev->event.data.ce_msg.ce_msg, ce_msg, 12);
+       ev->event.data.ce_msg.completion = completion;
+       memcpy(ev->dma_data, dma_data, dma_data_length);
+       ev->dma_data_length = dma_data_length;
+       ev->remote_address = remote_address;
+       return signal_event(ev);
+}
+
+/*
+ * Initiate a nice (hopefully) shutdown of Linux.  We simply are
+ * going to try and send the init process a SIGINT signal.  If
+ * this fails (why?), we'll simply force it off in a not-so-nice
+ * manner.
+ */
+static int shutdown(void)
+{
+       int rc = kill_proc(1, SIGINT, 1);
+
+       if (rc) {
+               printk(KERN_ALERT "mf.c: SIGINT to init failed (%d), "
+                               "hard shutdown commencing\n", rc);
+               mf_power_off();
+       } else
+               printk(KERN_INFO "mf.c: init has been successfully notified "
+                               "to proceed with shutdown\n");
+       return rc;
+}
+
+/*
+ * The primary partition VSP object is sending us a new
+ * event flow.  Handle it...
+ */
+static void handle_int(struct io_mf_lp_event *event)
+{
+       struct ce_msg_data *ce_msg_data;
+       struct ce_msg_data *pce_msg_data;
+       unsigned long flags;
+       struct pending_event *pev;
+
+       /* ack the interrupt */
+       event->hp_lp_event.xRc = HvLpEvent_Rc_Good;
+       HvCallEvent_ackLpEvent(&event->hp_lp_event);
+
+       /* process interrupt */
+       switch (event->hp_lp_event.xSubtype) {
+       case 0: /* CE message */
+               ce_msg_data = &event->data.ce_msg;
+               switch (ce_msg_data->ce_msg[3]) {
+               case 0x5B:      /* power control notification */
+                       if ((ce_msg_data->ce_msg[5] & 0x20) != 0) {
+                               printk(KERN_INFO "mf.c: Commencing partition shutdown\n");
+                               if (shutdown() == 0)
+                                       signal_ce_msg_simple(0xDB, NULL);
+                       }
+                       break;
+               case 0xC0:      /* get time */
+                       spin_lock_irqsave(&pending_event_spinlock, flags);
+                       pev = pending_event_head;
+                       if (pev != NULL)
+                               pending_event_head = pending_event_head->next;
+                       spin_unlock_irqrestore(&pending_event_spinlock, flags);
+                       if (pev == NULL)
+                               break;
+                       pce_msg_data = &pev->event.data.ce_msg;
+                       if (pce_msg_data->ce_msg[3] != 0x40)
+                               break;
+                       if (pce_msg_data->completion != NULL) {
+                               ce_msg_comp_hdlr handler =
+                                       pce_msg_data->completion->handler;
+                               void *token = pce_msg_data->completion->token;
+
+                               if (handler != NULL)
+                                       (*handler)(token, ce_msg_data);
+                       }
+                       spin_lock_irqsave(&pending_event_spinlock, flags);
+                       free_pending_event(pev);
+                       spin_unlock_irqrestore(&pending_event_spinlock, flags);
+                       /* send next waiting event */
+                       if (pending_event_head != NULL)
+                               signal_event(NULL);
+                       break;
+               }
+               break;
+       case 1: /* IT sys shutdown */
+               printk(KERN_INFO "mf.c: Commencing system shutdown\n");
+               shutdown();
+               break;
+       }
+}
+
+/*
+ * The primary partition VSP object is acknowledging the receipt
+ * of a flow we sent to them.  If there are other flows queued
+ * up, we must send another one now...
+ */
+static void handle_ack(struct io_mf_lp_event *event)
+{
+       unsigned long flags;
+       struct pending_event *two = NULL;
+       unsigned long free_it = 0;
+       struct ce_msg_data *ce_msg_data;
+       struct ce_msg_data *pce_msg_data;
+       struct vsp_rsp_data *rsp;
+
+       /* handle current event */
+       if (pending_event_head == NULL) {
+               printk(KERN_ERR "mf.c: stack empty for receiving ack\n");
+               return;
+       }
+
+       switch (event->hp_lp_event.xSubtype) {
+       case 0:     /* CE msg */
+               ce_msg_data = &event->data.ce_msg;
+               if (ce_msg_data->ce_msg[3] != 0x40) {
+                       free_it = 1;
+                       break;
+               }
+               if (ce_msg_data->ce_msg[2] == 0)
+                       break;
+               free_it = 1;
+               pce_msg_data = &pending_event_head->event.data.ce_msg;
+               if (pce_msg_data->completion != NULL) {
+                       ce_msg_comp_hdlr handler =
+                               pce_msg_data->completion->handler;
+                       void *token = pce_msg_data->completion->token;
+
+                       if (handler != NULL)
+                               (*handler)(token, ce_msg_data);
+               }
+               break;
+       case 4: /* allocate */
+       case 5: /* deallocate */
+               if (pending_event_head->hdlr != NULL)
+                       (*pending_event_head->hdlr)((void *)event->hp_lp_event.xCorrelationToken, event->data.alloc.count);
+               free_it = 1;
+               break;
+       case 6:
+               free_it = 1;
+               rsp = (struct vsp_rsp_data *)event->data.vsp_cmd.token;
+               if (rsp == NULL) {
+                       printk(KERN_ERR "mf.c: no rsp\n");
+                       break;
+               }
+               if (rsp->response != NULL)
+                       memcpy(rsp->response, &event->data.vsp_cmd,
+                                       sizeof(event->data.vsp_cmd));
+               complete(&rsp->com);
+               break;
+       }
+
+       /* remove from queue */
+       spin_lock_irqsave(&pending_event_spinlock, flags);
+       if ((pending_event_head != NULL) && (free_it == 1)) {
+               struct pending_event *oldHead = pending_event_head;
+
+               pending_event_head = pending_event_head->next;
+               two = pending_event_head;
+               free_pending_event(oldHead);
+       }
+       spin_unlock_irqrestore(&pending_event_spinlock, flags);
+
+       /* send next waiting event */
+       if (two != NULL)
+               signal_event(NULL);
+}
+
+/*
+ * This is the generic event handler we are registering with
+ * the Hypervisor.  Ensure the flows are for us, and then
+ * parse it enough to know if it is an interrupt or an
+ * acknowledge.
+ */
+static void hv_handler(struct HvLpEvent *event, struct pt_regs *regs)
+{
+       if ((event != NULL) && (event->xType == HvLpEvent_Type_MachineFac)) {
+               switch(event->xFlags.xFunction) {
+               case HvLpEvent_Function_Ack:
+                       handle_ack((struct io_mf_lp_event *)event);
+                       break;
+               case HvLpEvent_Function_Int:
+                       handle_int((struct io_mf_lp_event *)event);
+                       break;
+               default:
+                       printk(KERN_ERR "mf.c: non ack/int event received\n");
+                       break;
+               }
+       } else
+               printk(KERN_ERR "mf.c: alien event received\n");
+}
+
+/*
+ * Global kernel interface to allocate and seed events into the
+ * Hypervisor.
+ */
+void mf_allocate_lp_events(HvLpIndex target_lp, HvLpEvent_Type type,
+               unsigned size, unsigned count, MFCompleteHandler hdlr,
+               void *user_token)
+{
+       struct pending_event *ev = new_pending_event();
+       int rc;
+
+       if (ev == NULL) {
+               rc = -ENOMEM;
+       } else {
+               ev->event.hp_lp_event.xSubtype = 4;
+               ev->event.hp_lp_event.xCorrelationToken = (u64)user_token;
+               ev->event.hp_lp_event.x.xSubtypeData =
+                       subtype_data('M', 'F', 'M', 'A');
+               ev->event.data.alloc.target_lp = target_lp;
+               ev->event.data.alloc.type = type;
+               ev->event.data.alloc.size = size;
+               ev->event.data.alloc.count = count;
+               ev->hdlr = hdlr;
+               rc = signal_event(ev);
+       }
+       if ((rc != 0) && (hdlr != NULL))
+               (*hdlr)(user_token, rc);
+}
+EXPORT_SYMBOL(mf_allocate_lp_events);
+
+/*
+ * Global kernel interface to unseed and deallocate events already in
+ * Hypervisor.
+ */
+void mf_deallocate_lp_events(HvLpIndex target_lp, HvLpEvent_Type type,
+               unsigned count, MFCompleteHandler hdlr, void *user_token)
+{
+       struct pending_event *ev = new_pending_event();
+       int rc;
+
+       if (ev == NULL)
+               rc = -ENOMEM;
+       else {
+               ev->event.hp_lp_event.xSubtype = 5;
+               ev->event.hp_lp_event.xCorrelationToken = (u64)user_token;
+               ev->event.hp_lp_event.x.xSubtypeData =
+                       subtype_data('M', 'F', 'M', 'D');
+               ev->event.data.alloc.target_lp = target_lp;
+               ev->event.data.alloc.type = type;
+               ev->event.data.alloc.count = count;
+               ev->hdlr = hdlr;
+               rc = signal_event(ev);
+       }
+       if ((rc != 0) && (hdlr != NULL))
+               (*hdlr)(user_token, rc);
+}
+EXPORT_SYMBOL(mf_deallocate_lp_events);
+
+/*
+ * Global kernel interface to tell the VSP object in the primary
+ * partition to power this partition off.
+ */
+void mf_power_off(void)
+{
+       printk(KERN_INFO "mf.c: Down it goes...\n");
+       signal_ce_msg_simple(0x4d, NULL);
+       for (;;)
+               ;
+}
+
+/*
+ * Global kernel interface to tell the VSP object in the primary
+ * partition to reboot this partition.
+ */
+void mf_reboot(void)
+{
+       printk(KERN_INFO "mf.c: Preparing to bounce...\n");
+       signal_ce_msg_simple(0x4e, NULL);
+       for (;;)
+               ;
+}
+
+/*
+ * Display a single word SRC onto the VSP control panel.
+ */
+void mf_display_src(u32 word)
+{
+       u8 ce[12];
+
+       memset(ce, 0, sizeof(ce));
+       ce[3] = 0x4a;
+       ce[7] = 0x01;
+       ce[8] = word >> 24;
+       ce[9] = word >> 16;
+       ce[10] = word >> 8;
+       ce[11] = word;
+       signal_ce_msg(ce, NULL);
+}
+
+/*
+ * Display a single word SRC of the form "PROGXXXX" on the VSP control panel.
+ */
+void mf_display_progress(u16 value)
+{
+       u8 ce[12];
+       u8 src[72];
+
+       memcpy(ce, "\x00\x00\x04\x4A\x00\x00\x00\x48\x00\x00\x00\x00", 12);
+       memcpy(src, "\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
+               "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+               "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+               "\x00\x00\x00\x00PROGxxxx                        ",
+               72);
+       src[6] = value >> 8;
+       src[7] = value & 255;
+       src[44] = "0123456789ABCDEF"[(value >> 12) & 15];
+       src[45] = "0123456789ABCDEF"[(value >> 8) & 15];
+       src[46] = "0123456789ABCDEF"[(value >> 4) & 15];
+       src[47] = "0123456789ABCDEF"[value & 15];
+       dma_and_signal_ce_msg(ce, NULL, src, sizeof(src), 9 * 64 * 1024);
+}
+
+/*
+ * Clear the VSP control panel.  Used to "erase" an SRC that was
+ * previously displayed.
+ */
+void mf_clear_src(void)
+{
+       signal_ce_msg_simple(0x4b, NULL);
+}
+
+/*
+ * Initialization code here.
+ */
+void mf_init(void)
+{
+       int i;
+
+       /* initialize */
+       spin_lock_init(&pending_event_spinlock);
+       for (i = 0;
+            i < sizeof(pending_event_prealloc) / sizeof(*pending_event_prealloc);
+            ++i)
+               free_pending_event(&pending_event_prealloc[i]);
+       HvLpEvent_registerHandler(HvLpEvent_Type_MachineFac, &hv_handler);
+
+       /* virtual continue ack */
+       signal_ce_msg_simple(0x57, NULL);
+
+       /* initialization complete */
+       printk(KERN_NOTICE "mf.c: iSeries Linux LPAR Machine Facilities "
+                       "initialized\n");
+}
+
+struct rtc_time_data {
+       struct completion com;
+       struct ce_msg_data ce_msg;
+       int rc;
+};
+
+static void get_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
+{
+       struct rtc_time_data *rtc = token;
+
+       memcpy(&rtc->ce_msg, ce_msg, sizeof(rtc->ce_msg));
+       rtc->rc = 0;
+       complete(&rtc->com);
+}
+
+static int rtc_set_tm(int rc, u8 *ce_msg, struct rtc_time *tm)
+{
+       tm->tm_wday = 0;
+       tm->tm_yday = 0;
+       tm->tm_isdst = 0;
+       if (rc) {
+               tm->tm_sec = 0;
+               tm->tm_min = 0;
+               tm->tm_hour = 0;
+               tm->tm_mday = 15;
+               tm->tm_mon = 5;
+               tm->tm_year = 52;
+               return rc;
+       }
+
+       if ((ce_msg[2] == 0xa9) ||
+           (ce_msg[2] == 0xaf)) {
+               /* TOD clock is not set */
+               tm->tm_sec = 1;
+               tm->tm_min = 1;
+               tm->tm_hour = 1;
+               tm->tm_mday = 10;
+               tm->tm_mon = 8;
+               tm->tm_year = 71;
+               mf_set_rtc(tm);
+       }
+       {
+               u8 year = ce_msg[5];
+               u8 sec = ce_msg[6];
+               u8 min = ce_msg[7];
+               u8 hour = ce_msg[8];
+               u8 day = ce_msg[10];
+               u8 mon = ce_msg[11];
+
+               BCD_TO_BIN(sec);
+               BCD_TO_BIN(min);
+               BCD_TO_BIN(hour);
+               BCD_TO_BIN(day);
+               BCD_TO_BIN(mon);
+               BCD_TO_BIN(year);
+
+               if (year <= 69)
+                       year += 100;
+
+               tm->tm_sec = sec;
+               tm->tm_min = min;
+               tm->tm_hour = hour;
+               tm->tm_mday = day;
+               tm->tm_mon = mon;
+               tm->tm_year = year;
+       }
+
+       return 0;
+}
+
+int mf_get_rtc(struct rtc_time *tm)
+{
+       struct ce_msg_comp_data ce_complete;
+       struct rtc_time_data rtc_data;
+       int rc;
+
+       memset(&ce_complete, 0, sizeof(ce_complete));
+       memset(&rtc_data, 0, sizeof(rtc_data));
+       init_completion(&rtc_data.com);
+       ce_complete.handler = &get_rtc_time_complete;
+       ce_complete.token = &rtc_data;
+       rc = signal_ce_msg_simple(0x40, &ce_complete);
+       if (rc)
+               return rc;
+       wait_for_completion(&rtc_data.com);
+       return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
+}
+
+struct boot_rtc_time_data {
+       int busy;
+       struct ce_msg_data ce_msg;
+       int rc;
+};
+
+static void get_boot_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
+{
+       struct boot_rtc_time_data *rtc = token;
+
+       memcpy(&rtc->ce_msg, ce_msg, sizeof(rtc->ce_msg));
+       rtc->rc = 0;
+       rtc->busy = 0;
+}
+
+int mf_get_boot_rtc(struct rtc_time *tm)
+{
+       struct ce_msg_comp_data ce_complete;
+       struct boot_rtc_time_data rtc_data;
+       int rc;
+
+       memset(&ce_complete, 0, sizeof(ce_complete));
+       memset(&rtc_data, 0, sizeof(rtc_data));
+       rtc_data.busy = 1;
+       ce_complete.handler = &get_boot_rtc_time_complete;
+       ce_complete.token = &rtc_data;
+       rc = signal_ce_msg_simple(0x40, &ce_complete);
+       if (rc)
+               return rc;
+       /* We need to poll here as we are not yet taking interrupts */
+       while (rtc_data.busy) {
+               if (hvlpevent_is_pending())
+                       process_hvlpevents(NULL);
+       }
+       return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
+}
+
+int mf_set_rtc(struct rtc_time *tm)
+{
+       char ce_time[12];
+       u8 day, mon, hour, min, sec, y1, y2;
+       unsigned year;
+
+       year = 1900 + tm->tm_year;
+       y1 = year / 100;
+       y2 = year % 100;
+
+       sec = tm->tm_sec;
+       min = tm->tm_min;
+       hour = tm->tm_hour;
+       day = tm->tm_mday;
+       mon = tm->tm_mon + 1;
+
+       BIN_TO_BCD(sec);
+       BIN_TO_BCD(min);
+       BIN_TO_BCD(hour);
+       BIN_TO_BCD(mon);
+       BIN_TO_BCD(day);
+       BIN_TO_BCD(y1);
+       BIN_TO_BCD(y2);
+
+       memset(ce_time, 0, sizeof(ce_time));
+       ce_time[3] = 0x41;
+       ce_time[4] = y1;
+       ce_time[5] = y2;
+       ce_time[6] = sec;
+       ce_time[7] = min;
+       ce_time[8] = hour;
+       ce_time[10] = day;
+       ce_time[11] = mon;
+
+       return signal_ce_msg(ce_time, NULL);
+}
+
+#ifdef CONFIG_PROC_FS
+
+static int proc_mf_dump_cmdline(char *page, char **start, off_t off,
+               int count, int *eof, void *data)
+{
+       int len;
+       char *p;
+       struct vsp_cmd_data vsp_cmd;
+       int rc;
+       dma_addr_t dma_addr;
+
+       /* The HV appears to return no more than 256 bytes of command line */
+       if (off >= 256)
+               return 0;
+       if ((off + count) > 256)
+               count = 256 - off;
+
+       dma_addr = dma_map_single(iSeries_vio_dev, page, off + count,
+                       DMA_FROM_DEVICE);
+       if (dma_mapping_error(dma_addr))
+               return -ENOMEM;
+       memset(page, 0, off + count);
+       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
+       vsp_cmd.cmd = 33;
+       vsp_cmd.sub_data.kern.token = dma_addr;
+       vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
+       vsp_cmd.sub_data.kern.side = (u64)data;
+       vsp_cmd.sub_data.kern.length = off + count;
+       mb();
+       rc = signal_vsp_instruction(&vsp_cmd);
+       dma_unmap_single(iSeries_vio_dev, dma_addr, off + count,
+                       DMA_FROM_DEVICE);
+       if (rc)
+               return rc;
+       if (vsp_cmd.result_code != 0)
+               return -ENOMEM;
+       p = page;
+       len = 0;
+       while (len < (off + count)) {
+               if ((*p == '\0') || (*p == '\n')) {
+                       if (*p == '\0')
+                               *p = '\n';
+                       p++;
+                       len++;
+                       *eof = 1;
+                       break;
+               }
+               p++;
+               len++;
+       }
+
+       if (len < off) {
+               *eof = 1;
+               len = 0;
+       }
+       return len;
+}
+
+#if 0
+static int mf_getVmlinuxChunk(char *buffer, int *size, int offset, u64 side)
+{
+       struct vsp_cmd_data vsp_cmd;
+       int rc;
+       int len = *size;
+       dma_addr_t dma_addr;
+
+       dma_addr = dma_map_single(iSeries_vio_dev, buffer, len,
+                       DMA_FROM_DEVICE);
+       memset(buffer, 0, len);
+       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
+       vsp_cmd.cmd = 32;
+       vsp_cmd.sub_data.kern.token = dma_addr;
+       vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
+       vsp_cmd.sub_data.kern.side = side;
+       vsp_cmd.sub_data.kern.offset = offset;
+       vsp_cmd.sub_data.kern.length = len;
+       mb();
+       rc = signal_vsp_instruction(&vsp_cmd);
+       if (rc == 0) {
+               if (vsp_cmd.result_code == 0)
+                       *size = vsp_cmd.sub_data.length_out;
+               else
+                       rc = -ENOMEM;
+       }
+
+       dma_unmap_single(iSeries_vio_dev, dma_addr, len, DMA_FROM_DEVICE);
+
+       return rc;
+}
+
+static int proc_mf_dump_vmlinux(char *page, char **start, off_t off,
+               int count, int *eof, void *data)
+{
+       int sizeToGet = count;
+
+       if (!capable(CAP_SYS_ADMIN))
+               return -EACCES;
+
+       if (mf_getVmlinuxChunk(page, &sizeToGet, off, (u64)data) == 0) {
+               if (sizeToGet != 0) {
+                       *start = page + off;
+                       return sizeToGet;
+               }
+               *eof = 1;
+               return 0;
+       }
+       *eof = 1;
+       return 0;
+}
+#endif
+
+static int proc_mf_dump_side(char *page, char **start, off_t off,
+               int count, int *eof, void *data)
+{
+       int len;
+       char mf_current_side = ' ';
+       struct vsp_cmd_data vsp_cmd;
+
+       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
+       vsp_cmd.cmd = 2;
+       vsp_cmd.sub_data.ipl_type = 0;
+       mb();
+
+       if (signal_vsp_instruction(&vsp_cmd) == 0) {
+               if (vsp_cmd.result_code == 0) {
+                       switch (vsp_cmd.sub_data.ipl_type) {
+                       case 0: mf_current_side = 'A';
+                               break;
+                       case 1: mf_current_side = 'B';
+                               break;
+                       case 2: mf_current_side = 'C';
+                               break;
+                       default:        mf_current_side = 'D';
+                               break;
+                       }
+               }
+       }
+
+       len = sprintf(page, "%c\n", mf_current_side);
+
+       if (len <= (off + count))
+               *eof = 1;
+       *start = page + off;
+       len -= off;
+       if (len > count)
+               len = count;
+       if (len < 0)
+               len = 0;
+       return len;
+}
+
+static int proc_mf_change_side(struct file *file, const char __user *buffer,
+               unsigned long count, void *data)
+{
+       char side;
+       u64 newSide;
+       struct vsp_cmd_data vsp_cmd;
+
+       if (!capable(CAP_SYS_ADMIN))
+               return -EACCES;
+
+       if (count == 0)
+               return 0;
+
+       if (get_user(side, buffer))
+               return -EFAULT;
+
+       switch (side) {
+       case 'A':       newSide = 0;
+                       break;
+       case 'B':       newSide = 1;
+                       break;
+       case 'C':       newSide = 2;
+                       break;
+       case 'D':       newSide = 3;
+                       break;
+       default:
+               printk(KERN_ERR "mf_proc.c: proc_mf_change_side: invalid side\n");
+               return -EINVAL;
+       }
+
+       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
+       vsp_cmd.sub_data.ipl_type = newSide;
+       vsp_cmd.cmd = 10;
+
+       (void)signal_vsp_instruction(&vsp_cmd);
+
+       return count;
+}
+
+#if 0
+static void mf_getSrcHistory(char *buffer, int size)
+{
+       struct IplTypeReturnStuff return_stuff;
+       struct pending_event *ev = new_pending_event();
+       int rc = 0;
+       char *pages[4];
+
+       pages[0] = kmalloc(4096, GFP_ATOMIC);
+       pages[1] = kmalloc(4096, GFP_ATOMIC);
+       pages[2] = kmalloc(4096, GFP_ATOMIC);
+       pages[3] = kmalloc(4096, GFP_ATOMIC);
+       if ((ev == NULL) || (pages[0] == NULL) || (pages[1] == NULL)
+                        || (pages[2] == NULL) || (pages[3] == NULL))
+               return -ENOMEM;
+
+       return_stuff.xType = 0;
+       return_stuff.xRc = 0;
+       return_stuff.xDone = 0;
+       ev->event.hp_lp_event.xSubtype = 6;
+       ev->event.hp_lp_event.x.xSubtypeData =
+               subtype_data('M', 'F', 'V', 'I');
+       ev->event.data.vsp_cmd.xEvent = &return_stuff;
+       ev->event.data.vsp_cmd.cmd = 4;
+       ev->event.data.vsp_cmd.lp_index = HvLpConfig_getLpIndex();
+       ev->event.data.vsp_cmd.result_code = 0xFF;
+       ev->event.data.vsp_cmd.reserved = 0;
+       ev->event.data.vsp_cmd.sub_data.page[0] = ISERIES_HV_ADDR(pages[0]);
+       ev->event.data.vsp_cmd.sub_data.page[1] = ISERIES_HV_ADDR(pages[1]);
+       ev->event.data.vsp_cmd.sub_data.page[2] = ISERIES_HV_ADDR(pages[2]);
+       ev->event.data.vsp_cmd.sub_data.page[3] = ISERIES_HV_ADDR(pages[3]);
+       mb();
+       if (signal_event(ev) != 0)
+               return;
+
+       while (return_stuff.xDone != 1)
+               udelay(10);
+       if (return_stuff.xRc == 0)
+               memcpy(buffer, pages[0], size);
+       kfree(pages[0]);
+       kfree(pages[1]);
+       kfree(pages[2]);
+       kfree(pages[3]);
+}
+#endif
+
+static int proc_mf_dump_src(char *page, char **start, off_t off,
+               int count, int *eof, void *data)
+{
+#if 0
+       int len;
+
+       mf_getSrcHistory(page, count);
+       len = count;
+       len -= off;
+       if (len < count) {
+               *eof = 1;
+               if (len <= 0)
+                       return 0;
+       } else
+               len = count;
+       *start = page + off;
+       return len;
+#else
+       return 0;
+#endif
+}
+
+static int proc_mf_change_src(struct file *file, const char __user *buffer,
+               unsigned long count, void *data)
+{
+       char stkbuf[10];
+
+       if (!capable(CAP_SYS_ADMIN))
+               return -EACCES;
+
+       if ((count < 4) && (count != 1)) {
+               printk(KERN_ERR "mf_proc: invalid src\n");
+               return -EINVAL;
+       }
+
+       if (count > (sizeof(stkbuf) - 1))
+               count = sizeof(stkbuf) - 1;
+       if (copy_from_user(stkbuf, buffer, count))
+               return -EFAULT;
+
+       if ((count == 1) && (*stkbuf == '\0'))
+               mf_clear_src();
+       else
+               mf_display_src(*(u32 *)stkbuf);
+
+       return count;
+}
+
+static int proc_mf_change_cmdline(struct file *file, const char __user *buffer,
+               unsigned long count, void *data)
+{
+       struct vsp_cmd_data vsp_cmd;
+       dma_addr_t dma_addr;
+       char *page;
+       int ret = -EACCES;
+
+       if (!capable(CAP_SYS_ADMIN))
+               goto out;
+
+       dma_addr = 0;
+       page = dma_alloc_coherent(iSeries_vio_dev, count, &dma_addr,
+                       GFP_ATOMIC);
+       ret = -ENOMEM;
+       if (page == NULL)
+               goto out;
+
+       ret = -EFAULT;
+       if (copy_from_user(page, buffer, count))
+               goto out_free;
+
+       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
+       vsp_cmd.cmd = 31;
+       vsp_cmd.sub_data.kern.token = dma_addr;
+       vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
+       vsp_cmd.sub_data.kern.side = (u64)data;
+       vsp_cmd.sub_data.kern.length = count;
+       mb();
+       (void)signal_vsp_instruction(&vsp_cmd);
+       ret = count;
+
+out_free:
+       dma_free_coherent(iSeries_vio_dev, count, page, dma_addr);
+out:
+       return ret;
+}
+
+static ssize_t proc_mf_change_vmlinux(struct file *file,
+                                     const char __user *buf,
+                                     size_t count, loff_t *ppos)
+{
+       struct proc_dir_entry *dp = PDE(file->f_dentry->d_inode);
+       ssize_t rc;
+       dma_addr_t dma_addr;
+       char *page;
+       struct vsp_cmd_data vsp_cmd;
+
+       rc = -EACCES;
+       if (!capable(CAP_SYS_ADMIN))
+               goto out;
+
+       dma_addr = 0;
+       page = dma_alloc_coherent(iSeries_vio_dev, count, &dma_addr,
+                       GFP_ATOMIC);
+       rc = -ENOMEM;
+       if (page == NULL) {
+               printk(KERN_ERR "mf.c: couldn't allocate memory to set vmlinux chunk\n");
+               goto out;
+       }
+       rc = -EFAULT;
+       if (copy_from_user(page, buf, count))
+               goto out_free;
+
+       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
+       vsp_cmd.cmd = 30;
+       vsp_cmd.sub_data.kern.token = dma_addr;
+       vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
+       vsp_cmd.sub_data.kern.side = (u64)dp->data;
+       vsp_cmd.sub_data.kern.offset = *ppos;
+       vsp_cmd.sub_data.kern.length = count;
+       mb();
+       rc = signal_vsp_instruction(&vsp_cmd);
+       if (rc)
+               goto out_free;
+       rc = -ENOMEM;
+       if (vsp_cmd.result_code != 0)
+               goto out_free;
+
+       *ppos += count;
+       rc = count;
+out_free:
+       dma_free_coherent(iSeries_vio_dev, count, page, dma_addr);
+out:
+       return rc;
+}
+
+static struct file_operations proc_vmlinux_operations = {
+       .write          = proc_mf_change_vmlinux,
+};
+
+static int __init mf_proc_init(void)
+{
+       struct proc_dir_entry *mf_proc_root;
+       struct proc_dir_entry *ent;
+       struct proc_dir_entry *mf;
+       char name[2];
+       int i;
+
+       mf_proc_root = proc_mkdir("iSeries/mf", NULL);
+       if (!mf_proc_root)
+               return 1;
+
+       name[1] = '\0';
+       for (i = 0; i < 4; i++) {
+               name[0] = 'A' + i;
+               mf = proc_mkdir(name, mf_proc_root);
+               if (!mf)
+                       return 1;
+
+               ent = create_proc_entry("cmdline", S_IFREG|S_IRUSR|S_IWUSR, mf);
+               if (!ent)
+                       return 1;
+               ent->nlink = 1;
+               ent->data = (void *)(long)i;
+               ent->read_proc = proc_mf_dump_cmdline;
+               ent->write_proc = proc_mf_change_cmdline;
+
+               if (i == 3)     /* no vmlinux entry for 'D' */
+                       continue;
+
+               ent = create_proc_entry("vmlinux", S_IFREG|S_IWUSR, mf);
+               if (!ent)
+                       return 1;
+               ent->nlink = 1;
+               ent->data = (void *)(long)i;
+               ent->proc_fops = &proc_vmlinux_operations;
+       }
+
+       ent = create_proc_entry("side", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root);
+       if (!ent)
+               return 1;
+       ent->nlink = 1;
+       ent->data = (void *)0;
+       ent->read_proc = proc_mf_dump_side;
+       ent->write_proc = proc_mf_change_side;
+
+       ent = create_proc_entry("src", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root);
+       if (!ent)
+               return 1;
+       ent->nlink = 1;
+       ent->data = (void *)0;
+       ent->read_proc = proc_mf_dump_src;
+       ent->write_proc = proc_mf_change_src;
+
+       return 0;
+}
+
+__initcall(mf_proc_init);
+
+#endif /* CONFIG_PROC_FS */
+
+/*
+ * Get the RTC from the virtual service processor
+ * This requires flowing LpEvents to the primary partition
+ */
+void iSeries_get_rtc_time(struct rtc_time *rtc_tm)
+{
+       if (piranha_simulator)
+               return;
+
+       mf_get_rtc(rtc_tm);
+       rtc_tm->tm_mon--;
+}
+
+/*
+ * Set the RTC in the virtual service processor
+ * This requires flowing LpEvents to the primary partition
+ */
+int iSeries_set_rtc_time(struct rtc_time *tm)
+{
+       mf_set_rtc(tm);
+       return 0;
+}
+
+void iSeries_get_boot_time(struct rtc_time *tm)
+{
+       if (piranha_simulator)
+               return;
+
+       mf_get_boot_rtc(tm);
+       tm->tm_mon  -= 1;
+}
diff --git a/arch/powerpc/platforms/iseries/setup.c b/arch/powerpc/platforms/iseries/setup.c
new file mode 100644 (file)
index 0000000..ad78c85
--- /dev/null
@@ -0,0 +1,1006 @@
+/*
+ *    Copyright (c) 2000 Mike Corrigan <mikejc@us.ibm.com>
+ *    Copyright (c) 1999-2000 Grant Erickson <grant@lcse.umn.edu>
+ *
+ *    Description:
+ *      Architecture- / platform-specific boot-time initialization code for
+ *      the IBM iSeries LPAR.  Adapted from original code by Grant Erickson and
+ *      code by Gary Thomas, Cort Dougan <cort@fsmlabs.com>, and Dan Malek
+ *      <dan@net4x.com>.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#undef DEBUG
+
+#include <linux/config.h>
+#include <linux/init.h>
+#include <linux/threads.h>
+#include <linux/smp.h>
+#include <linux/param.h>
+#include <linux/string.h>
+#include <linux/initrd.h>
+#include <linux/seq_file.h>
+#include <linux/kdev_t.h>
+#include <linux/major.h>
+#include <linux/root_dev.h>
+
+#include <asm/processor.h>
+#include <asm/machdep.h>
+#include <asm/page.h>
+#include <asm/mmu.h>
+#include <asm/pgtable.h>
+#include <asm/mmu_context.h>
+#include <asm/cputable.h>
+#include <asm/sections.h>
+#include <asm/iommu.h>
+#include <asm/firmware.h>
+
+#include <asm/time.h>
+#include <asm/naca.h>
+#include <asm/paca.h>
+#include <asm/cache.h>
+#include <asm/sections.h>
+#include <asm/abs_addr.h>
+#include <asm/iSeries/HvCallHpt.h>
+#include <asm/iSeries/HvLpConfig.h>
+#include <asm/iSeries/HvCallEvent.h>
+#include <asm/iSeries/HvCallSm.h>
+#include <asm/iSeries/HvCallXm.h>
+#include <asm/iSeries/ItLpQueue.h>
+#include <asm/iSeries/IoHriMainStore.h>
+#include <asm/iSeries/mf.h>
+#include <asm/iSeries/HvLpEvent.h>
+#include <asm/iSeries/iSeries_irq.h>
+#include <asm/iSeries/IoHriProcessorVpd.h>
+#include <asm/iSeries/ItVpdAreas.h>
+#include <asm/iSeries/LparMap.h>
+
+#include "setup.h"
+
+extern void hvlog(char *fmt, ...);
+
+#ifdef DEBUG
+#define DBG(fmt...) hvlog(fmt)
+#else
+#define DBG(fmt...)
+#endif
+
+/* Function Prototypes */
+extern void ppcdbg_initialize(void);
+
+static void build_iSeries_Memory_Map(void);
+static int iseries_shared_idle(void);
+static int iseries_dedicated_idle(void);
+#ifdef CONFIG_PCI
+extern void iSeries_pci_final_fixup(void);
+#else
+static void iSeries_pci_final_fixup(void) { }
+#endif
+
+/* Global Variables */
+int piranha_simulator;
+
+extern int rd_size;            /* Defined in drivers/block/rd.c */
+extern unsigned long klimit;
+extern unsigned long embedded_sysmap_start;
+extern unsigned long embedded_sysmap_end;
+
+extern unsigned long iSeries_recal_tb;
+extern unsigned long iSeries_recal_titan;
+
+static int mf_initialized;
+
+struct MemoryBlock {
+       unsigned long absStart;
+       unsigned long absEnd;
+       unsigned long logicalStart;
+       unsigned long logicalEnd;
+};
+
+/*
+ * Process the main store vpd to determine where the holes in memory are
+ * and return the number of physical blocks and fill in the array of
+ * block data.
+ */
+static unsigned long iSeries_process_Condor_mainstore_vpd(
+               struct MemoryBlock *mb_array, unsigned long max_entries)
+{
+       unsigned long holeFirstChunk, holeSizeChunks;
+       unsigned long numMemoryBlocks = 1;
+       struct IoHriMainStoreSegment4 *msVpd =
+               (struct IoHriMainStoreSegment4 *)xMsVpd;
+       unsigned long holeStart = msVpd->nonInterleavedBlocksStartAdr;
+       unsigned long holeEnd = msVpd->nonInterleavedBlocksEndAdr;
+       unsigned long holeSize = holeEnd - holeStart;
+
+       printk("Mainstore_VPD: Condor\n");
+       /*
+        * Determine if absolute memory has any
+        * holes so that we can interpret the
+        * access map we get back from the hypervisor
+        * correctly.
+        */
+       mb_array[0].logicalStart = 0;
+       mb_array[0].logicalEnd = 0x100000000;
+       mb_array[0].absStart = 0;
+       mb_array[0].absEnd = 0x100000000;
+
+       if (holeSize) {
+               numMemoryBlocks = 2;
+               holeStart = holeStart & 0x000fffffffffffff;
+               holeStart = addr_to_chunk(holeStart);
+               holeFirstChunk = holeStart;
+               holeSize = addr_to_chunk(holeSize);
+               holeSizeChunks = holeSize;
+               printk( "Main store hole: start chunk = %0lx, size = %0lx chunks\n",
+                               holeFirstChunk, holeSizeChunks );
+               mb_array[0].logicalEnd = holeFirstChunk;
+               mb_array[0].absEnd = holeFirstChunk;
+               mb_array[1].logicalStart = holeFirstChunk;
+               mb_array[1].logicalEnd = 0x100000000 - holeSizeChunks;
+               mb_array[1].absStart = holeFirstChunk + holeSizeChunks;
+               mb_array[1].absEnd = 0x100000000;
+       }
+       return numMemoryBlocks;
+}
+
+#define MaxSegmentAreas                        32
+#define MaxSegmentAdrRangeBlocks       128
+#define MaxAreaRangeBlocks             4
+
+static unsigned long iSeries_process_Regatta_mainstore_vpd(
+               struct MemoryBlock *mb_array, unsigned long max_entries)
+{
+       struct IoHriMainStoreSegment5 *msVpdP =
+               (struct IoHriMainStoreSegment5 *)xMsVpd;
+       unsigned long numSegmentBlocks = 0;
+       u32 existsBits = msVpdP->msAreaExists;
+       unsigned long area_num;
+
+       printk("Mainstore_VPD: Regatta\n");
+
+       for (area_num = 0; area_num < MaxSegmentAreas; ++area_num ) {
+               unsigned long numAreaBlocks;
+               struct IoHriMainStoreArea4 *currentArea;
+
+               if (existsBits & 0x80000000) {
+                       unsigned long block_num;
+
+                       currentArea = &msVpdP->msAreaArray[area_num];
+                       numAreaBlocks = currentArea->numAdrRangeBlocks;
+                       printk("ms_vpd: processing area %2ld  blocks=%ld",
+                                       area_num, numAreaBlocks);
+                       for (block_num = 0; block_num < numAreaBlocks;
+                                       ++block_num ) {
+                               /* Process an address range block */
+                               struct MemoryBlock tempBlock;
+                               unsigned long i;
+
+                               tempBlock.absStart =
+                                       (unsigned long)currentArea->xAdrRangeBlock[block_num].blockStart;
+                               tempBlock.absEnd =
+                                       (unsigned long)currentArea->xAdrRangeBlock[block_num].blockEnd;
+                               tempBlock.logicalStart = 0;
+                               tempBlock.logicalEnd   = 0;
+                               printk("\n          block %ld absStart=%016lx absEnd=%016lx",
+                                               block_num, tempBlock.absStart,
+                                               tempBlock.absEnd);
+
+                               for (i = 0; i < numSegmentBlocks; ++i) {
+                                       if (mb_array[i].absStart ==
+                                                       tempBlock.absStart)
+                                               break;
+                               }
+                               if (i == numSegmentBlocks) {
+                                       if (numSegmentBlocks == max_entries)
+                                               panic("iSeries_process_mainstore_vpd: too many memory blocks");
+                                       mb_array[numSegmentBlocks] = tempBlock;
+                                       ++numSegmentBlocks;
+                               } else
+                                       printk(" (duplicate)");
+                       }
+                       printk("\n");
+               }
+               existsBits <<= 1;
+       }
+       /* Now sort the blocks found into ascending sequence */
+       if (numSegmentBlocks > 1) {
+               unsigned long m, n;
+
+               for (m = 0; m < numSegmentBlocks - 1; ++m) {
+                       for (n = numSegmentBlocks - 1; m < n; --n) {
+                               if (mb_array[n].absStart <
+                                               mb_array[n-1].absStart) {
+                                       struct MemoryBlock tempBlock;
+
+                                       tempBlock = mb_array[n];
+                                       mb_array[n] = mb_array[n-1];
+                                       mb_array[n-1] = tempBlock;
+                               }
+                       }
+               }
+       }
+       /*
+        * Assign "logical" addresses to each block.  These
+        * addresses correspond to the hypervisor "bitmap" space.
+        * Convert all addresses into units of 256K chunks.
+        */
+       {
+       unsigned long i, nextBitmapAddress;
+
+       printk("ms_vpd: %ld sorted memory blocks\n", numSegmentBlocks);
+       nextBitmapAddress = 0;
+       for (i = 0; i < numSegmentBlocks; ++i) {
+               unsigned long length = mb_array[i].absEnd -
+                       mb_array[i].absStart;
+
+               mb_array[i].logicalStart = nextBitmapAddress;
+               mb_array[i].logicalEnd = nextBitmapAddress + length;
+               nextBitmapAddress += length;
+               printk("          Bitmap range: %016lx - %016lx\n"
+                               "        Absolute range: %016lx - %016lx\n",
+                               mb_array[i].logicalStart,
+                               mb_array[i].logicalEnd,
+                               mb_array[i].absStart, mb_array[i].absEnd);
+               mb_array[i].absStart = addr_to_chunk(mb_array[i].absStart &
+                               0x000fffffffffffff);
+               mb_array[i].absEnd = addr_to_chunk(mb_array[i].absEnd &
+                               0x000fffffffffffff);
+               mb_array[i].logicalStart =
+                       addr_to_chunk(mb_array[i].logicalStart);
+               mb_array[i].logicalEnd = addr_to_chunk(mb_array[i].logicalEnd);
+       }
+       }
+
+       return numSegmentBlocks;
+}
+
+static unsigned long iSeries_process_mainstore_vpd(struct MemoryBlock *mb_array,
+               unsigned long max_entries)
+{
+       unsigned long i;
+       unsigned long mem_blocks = 0;
+
+       if (cpu_has_feature(CPU_FTR_SLB))
+               mem_blocks = iSeries_process_Regatta_mainstore_vpd(mb_array,
+                               max_entries);
+       else
+               mem_blocks = iSeries_process_Condor_mainstore_vpd(mb_array,
+                               max_entries);
+
+       printk("Mainstore_VPD: numMemoryBlocks = %ld \n", mem_blocks);
+       for (i = 0; i < mem_blocks; ++i) {
+               printk("Mainstore_VPD: block %3ld logical chunks %016lx - %016lx\n"
+                      "                             abs chunks %016lx - %016lx\n",
+                       i, mb_array[i].logicalStart, mb_array[i].logicalEnd,
+                       mb_array[i].absStart, mb_array[i].absEnd);
+       }
+       return mem_blocks;
+}
+
+static void __init iSeries_get_cmdline(void)
+{
+       char *p, *q;
+
+       /* copy the command line parameter from the primary VSP  */
+       HvCallEvent_dmaToSp(cmd_line, 2 * 64* 1024, 256,
+                       HvLpDma_Direction_RemoteToLocal);
+
+       p = cmd_line;
+       q = cmd_line + 255;
+       while(p < q) {
+               if (!*p || *p == '\n')
+                       break;
+               ++p;
+       }
+       *p = 0;
+}
+
+static void __init iSeries_init_early(void)
+{
+       extern unsigned long memory_limit;
+
+       DBG(" -> iSeries_init_early()\n");
+
+       ppc64_firmware_features = FW_FEATURE_ISERIES;
+
+       ppcdbg_initialize();
+
+       ppc64_interrupt_controller = IC_ISERIES;
+
+#if defined(CONFIG_BLK_DEV_INITRD)
+       /*
+        * If the init RAM disk has been configured and there is
+        * a non-zero starting address for it, set it up
+        */
+       if (naca.xRamDisk) {
+               initrd_start = (unsigned long)__va(naca.xRamDisk);
+               initrd_end = initrd_start + naca.xRamDiskSize * PAGE_SIZE;
+               initrd_below_start_ok = 1;      // ramdisk in kernel space
+               ROOT_DEV = Root_RAM0;
+               if (((rd_size * 1024) / PAGE_SIZE) < naca.xRamDiskSize)
+                       rd_size = (naca.xRamDiskSize * PAGE_SIZE) / 1024;
+       } else
+#endif /* CONFIG_BLK_DEV_INITRD */
+       {
+           /* ROOT_DEV = MKDEV(VIODASD_MAJOR, 1); */
+       }
+
+       iSeries_recal_tb = get_tb();
+       iSeries_recal_titan = HvCallXm_loadTod();
+
+       /*
+        * Initialize the hash table management pointers
+        */
+       hpte_init_iSeries();
+
+       /*
+        * Initialize the DMA/TCE management
+        */
+       iommu_init_early_iSeries();
+
+       iSeries_get_cmdline();
+
+       /* Save unparsed command line copy for /proc/cmdline */
+       strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
+
+       /* Parse early parameters, in particular mem=x */
+       parse_early_param();
+
+       if (memory_limit) {
+               if (memory_limit < systemcfg->physicalMemorySize)
+                       systemcfg->physicalMemorySize = memory_limit;
+               else {
+                       printk("Ignoring mem=%lu >= ram_top.\n", memory_limit);
+                       memory_limit = 0;
+               }
+       }
+
+       /* Initialize machine-dependency vectors */
+#ifdef CONFIG_SMP
+       smp_init_iSeries();
+#endif
+       if (itLpNaca.xPirEnvironMode == 0)
+               piranha_simulator = 1;
+
+       /* Associate Lp Event Queue 0 with processor 0 */
+       HvCallEvent_setLpEventQueueInterruptProc(0, 0);
+
+       mf_init();
+       mf_initialized = 1;
+       mb();
+
+       /* If we were passed an initrd, set the ROOT_DEV properly if the values
+        * look sensible. If not, clear initrd reference.
+        */
+#ifdef CONFIG_BLK_DEV_INITRD
+       if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE &&
+           initrd_end > initrd_start)
+               ROOT_DEV = Root_RAM0;
+       else
+               initrd_start = initrd_end = 0;
+#endif /* CONFIG_BLK_DEV_INITRD */
+
+       DBG(" <- iSeries_init_early()\n");
+}
+
+struct mschunks_map mschunks_map = {
+       /* XXX We don't use these, but Piranha might need them. */
+       .chunk_size  = MSCHUNKS_CHUNK_SIZE,
+       .chunk_shift = MSCHUNKS_CHUNK_SHIFT,
+       .chunk_mask  = MSCHUNKS_OFFSET_MASK,
+};
+EXPORT_SYMBOL(mschunks_map);
+
+void mschunks_alloc(unsigned long num_chunks)
+{
+       klimit = _ALIGN(klimit, sizeof(u32));
+       mschunks_map.mapping = (u32 *)klimit;
+       klimit += num_chunks * sizeof(u32);
+       mschunks_map.num_chunks = num_chunks;
+}
+
+/*
+ * The iSeries may have very large memories ( > 128 GB ) and a partition
+ * may get memory in "chunks" that may be anywhere in the 2**52 real
+ * address space.  The chunks are 256K in size.  To map this to the
+ * memory model Linux expects, the AS/400 specific code builds a
+ * translation table to translate what Linux thinks are "physical"
+ * addresses to the actual real addresses.  This allows us to make
+ * it appear to Linux that we have contiguous memory starting at
+ * physical address zero while in fact this could be far from the truth.
+ * To avoid confusion, I'll let the words physical and/or real address
+ * apply to the Linux addresses while I'll use "absolute address" to
+ * refer to the actual hardware real address.
+ *
+ * build_iSeries_Memory_Map gets information from the Hypervisor and
+ * looks at the Main Store VPD to determine the absolute addresses
+ * of the memory that has been assigned to our partition and builds
+ * a table used to translate Linux's physical addresses to these
+ * absolute addresses.  Absolute addresses are needed when
+ * communicating with the hypervisor (e.g. to build HPT entries)
+ */
+
+static void __init build_iSeries_Memory_Map(void)
+{
+       u32 loadAreaFirstChunk, loadAreaLastChunk, loadAreaSize;
+       u32 nextPhysChunk;
+       u32 hptFirstChunk, hptLastChunk, hptSizeChunks, hptSizePages;
+       u32 num_ptegs;
+       u32 totalChunks,moreChunks;
+       u32 currChunk, thisChunk, absChunk;
+       u32 currDword;
+       u32 chunkBit;
+       u64 map;
+       struct MemoryBlock mb[32];
+       unsigned long numMemoryBlocks, curBlock;
+
+       /* Chunk size on iSeries is 256K bytes */
+       totalChunks = (u32)HvLpConfig_getMsChunks();
+       mschunks_alloc(totalChunks);
+
+       /*
+        * Get absolute address of our load area
+        * and map it to physical address 0
+        * This guarantees that the loadarea ends up at physical 0
+        * otherwise, it might not be returned by PLIC as the first
+        * chunks
+        */
+
+       loadAreaFirstChunk = (u32)addr_to_chunk(itLpNaca.xLoadAreaAddr);
+       loadAreaSize =  itLpNaca.xLoadAreaChunks;
+
+       /*
+        * Only add the pages already mapped here.
+        * Otherwise we might add the hpt pages
+        * The rest of the pages of the load area
+        * aren't in the HPT yet and can still
+        * be assigned an arbitrary physical address
+        */
+       if ((loadAreaSize * 64) > HvPagesToMap)
+               loadAreaSize = HvPagesToMap / 64;
+
+       loadAreaLastChunk = loadAreaFirstChunk + loadAreaSize - 1;
+
+       /*
+        * TODO Do we need to do something if the HPT is in the 64MB load area?
+        * This would be required if the itLpNaca.xLoadAreaChunks includes
+        * the HPT size
+        */
+
+       printk("Mapping load area - physical addr = 0000000000000000\n"
+               "                    absolute addr = %016lx\n",
+               chunk_to_addr(loadAreaFirstChunk));
+       printk("Load area size %dK\n", loadAreaSize * 256);
+
+       for (nextPhysChunk = 0; nextPhysChunk < loadAreaSize; ++nextPhysChunk)
+               mschunks_map.mapping[nextPhysChunk] =
+                       loadAreaFirstChunk + nextPhysChunk;
+
+       /*
+        * Get absolute address of our HPT and remember it so
+        * we won't map it to any physical address
+        */
+       hptFirstChunk = (u32)addr_to_chunk(HvCallHpt_getHptAddress());
+       hptSizePages = (u32)HvCallHpt_getHptPages();
+       hptSizeChunks = hptSizePages >> (MSCHUNKS_CHUNK_SHIFT - PAGE_SHIFT);
+       hptLastChunk = hptFirstChunk + hptSizeChunks - 1;
+
+       printk("HPT absolute addr = %016lx, size = %dK\n",
+                       chunk_to_addr(hptFirstChunk), hptSizeChunks * 256);
+
+       /* Fill in the hashed page table hash mask */
+       num_ptegs = hptSizePages *
+               (PAGE_SIZE / (sizeof(hpte_t) * HPTES_PER_GROUP));
+       htab_hash_mask = num_ptegs - 1;
+
+       /*
+        * The actual hashed page table is in the hypervisor,
+        * we have no direct access
+        */
+       htab_address = NULL;
+
+       /*
+        * Determine if absolute memory has any
+        * holes so that we can interpret the
+        * access map we get back from the hypervisor
+        * correctly.
+        */
+       numMemoryBlocks = iSeries_process_mainstore_vpd(mb, 32);
+
+       /*
+        * Process the main store access map from the hypervisor
+        * to build up our physical -> absolute translation table
+        */
+       curBlock = 0;
+       currChunk = 0;
+       currDword = 0;
+       moreChunks = totalChunks;
+
+       while (moreChunks) {
+               map = HvCallSm_get64BitsOfAccessMap(itLpNaca.xLpIndex,
+                               currDword);
+               thisChunk = currChunk;
+               while (map) {
+                       chunkBit = map >> 63;
+                       map <<= 1;
+                       if (chunkBit) {
+                               --moreChunks;
+                               while (thisChunk >= mb[curBlock].logicalEnd) {
+                                       ++curBlock;
+                                       if (curBlock >= numMemoryBlocks)
+                                               panic("out of memory blocks");
+                               }
+                               if (thisChunk < mb[curBlock].logicalStart)
+                                       panic("memory block error");
+
+                               absChunk = mb[curBlock].absStart +
+                                       (thisChunk - mb[curBlock].logicalStart);
+                               if (((absChunk < hptFirstChunk) ||
+                                    (absChunk > hptLastChunk)) &&
+                                   ((absChunk < loadAreaFirstChunk) ||
+                                    (absChunk > loadAreaLastChunk))) {
+                                       mschunks_map.mapping[nextPhysChunk] =
+                                               absChunk;
+                                       ++nextPhysChunk;
+                               }
+                       }
+                       ++thisChunk;
+               }
+               ++currDword;
+               currChunk += 64;
+       }
+
+       /*
+        * main store size (in chunks) is
+        *   totalChunks - hptSizeChunks
+        * which should be equal to
+        *   nextPhysChunk
+        */
+       systemcfg->physicalMemorySize = chunk_to_addr(nextPhysChunk);
+}
+
+/*
+ * Document me.
+ */
+static void __init iSeries_setup_arch(void)
+{
+       unsigned procIx = get_paca()->lppaca.dyn_hv_phys_proc_index;
+
+       if (get_paca()->lppaca.shared_proc) {
+               ppc_md.idle_loop = iseries_shared_idle;
+               printk(KERN_INFO "Using shared processor idle loop\n");
+       } else {
+               ppc_md.idle_loop = iseries_dedicated_idle;
+               printk(KERN_INFO "Using dedicated idle loop\n");
+       }
+
+       /* Setup the Lp Event Queue */
+       setup_hvlpevent_queue();
+
+       printk("Max  logical processors = %d\n",
+                       itVpdAreas.xSlicMaxLogicalProcs);
+       printk("Max physical processors = %d\n",
+                       itVpdAreas.xSlicMaxPhysicalProcs);
+
+       systemcfg->processor = xIoHriProcessorVpd[procIx].xPVR;
+       printk("Processor version = %x\n", systemcfg->processor);
+}
+
+static void iSeries_get_cpuinfo(struct seq_file *m)
+{
+       seq_printf(m, "machine\t\t: 64-bit iSeries Logical Partition\n");
+}
+
+/*
+ * Document me.
+ * and Implement me.
+ */
+static int iSeries_get_irq(struct pt_regs *regs)
+{
+       /* -2 means ignore this interrupt */
+       return -2;
+}
+
+/*
+ * Document me.
+ */
+static void iSeries_restart(char *cmd)
+{
+       mf_reboot();
+}
+
+/*
+ * Document me.
+ */
+static void iSeries_power_off(void)
+{
+       mf_power_off();
+}
+
+/*
+ * Document me.
+ */
+static void iSeries_halt(void)
+{
+       mf_power_off();
+}
+
+static void __init iSeries_progress(char * st, unsigned short code)
+{
+       printk("Progress: [%04x] - %s\n", (unsigned)code, st);
+       if (!piranha_simulator && mf_initialized) {
+               if (code != 0xffff)
+                       mf_display_progress(code);
+               else
+                       mf_clear_src();
+       }
+}
+
+static void __init iSeries_fixup_klimit(void)
+{
+       /*
+        * Change klimit to take into account any ram disk
+        * that may be included
+        */
+       if (naca.xRamDisk)
+               klimit = KERNELBASE + (u64)naca.xRamDisk +
+                       (naca.xRamDiskSize * PAGE_SIZE);
+       else {
+               /*
+                * No ram disk was included - check and see if there
+                * was an embedded system map.  Change klimit to take
+                * into account any embedded system map
+                */
+               if (embedded_sysmap_end)
+                       klimit = KERNELBASE + ((embedded_sysmap_end + 4095) &
+                                       0xfffffffffffff000);
+       }
+}
+
+static int __init iSeries_src_init(void)
+{
+        /* clear the progress line */
+        ppc_md.progress(" ", 0xffff);
+        return 0;
+}
+
+late_initcall(iSeries_src_init);
+
+static inline void process_iSeries_events(void)
+{
+       asm volatile ("li 0,0x5555; sc" : : : "r0", "r3");
+}
+
+static void yield_shared_processor(void)
+{
+       unsigned long tb;
+
+       HvCall_setEnabledInterrupts(HvCall_MaskIPI |
+                                   HvCall_MaskLpEvent |
+                                   HvCall_MaskLpProd |
+                                   HvCall_MaskTimeout);
+
+       tb = get_tb();
+       /* Compute future tb value when yield should expire */
+       HvCall_yieldProcessor(HvCall_YieldTimed, tb+tb_ticks_per_jiffy);
+
+       /*
+        * The decrementer stops during the yield.  Force a fake decrementer
+        * here and let the timer_interrupt code sort out the actual time.
+        */
+       get_paca()->lppaca.int_dword.fields.decr_int = 1;
+       process_iSeries_events();
+}
+
+static int iseries_shared_idle(void)
+{
+       while (1) {
+               while (!need_resched() && !hvlpevent_is_pending()) {
+                       local_irq_disable();
+                       ppc64_runlatch_off();
+
+                       /* Recheck with irqs off */
+                       if (!need_resched() && !hvlpevent_is_pending())
+                               yield_shared_processor();
+
+                       HMT_medium();
+                       local_irq_enable();
+               }
+
+               ppc64_runlatch_on();
+
+               if (hvlpevent_is_pending())
+                       process_iSeries_events();
+
+               schedule();
+       }
+
+       return 0;
+}
+
+static int iseries_dedicated_idle(void)
+{
+       long oldval;
+
+       while (1) {
+               oldval = test_and_clear_thread_flag(TIF_NEED_RESCHED);
+
+               if (!oldval) {
+                       set_thread_flag(TIF_POLLING_NRFLAG);
+
+                       while (!need_resched()) {
+                               ppc64_runlatch_off();
+                               HMT_low();
+
+                               if (hvlpevent_is_pending()) {
+                                       HMT_medium();
+                                       ppc64_runlatch_on();
+                                       process_iSeries_events();
+                               }
+                       }
+
+                       HMT_medium();
+                       clear_thread_flag(TIF_POLLING_NRFLAG);
+               } else {
+                       set_need_resched();
+               }
+
+               ppc64_runlatch_on();
+               schedule();
+       }
+
+       return 0;
+}
+
+#ifndef CONFIG_PCI
+void __init iSeries_init_IRQ(void) { }
+#endif
+
+static int __init iseries_probe(int platform)
+{
+       return PLATFORM_ISERIES_LPAR == platform;
+}
+
+struct machdep_calls __initdata iseries_md = {
+       .setup_arch     = iSeries_setup_arch,
+       .get_cpuinfo    = iSeries_get_cpuinfo,
+       .init_IRQ       = iSeries_init_IRQ,
+       .get_irq        = iSeries_get_irq,
+       .init_early     = iSeries_init_early,
+       .pcibios_fixup  = iSeries_pci_final_fixup,
+       .restart        = iSeries_restart,
+       .power_off      = iSeries_power_off,
+       .halt           = iSeries_halt,
+       .get_boot_time  = iSeries_get_boot_time,
+       .set_rtc_time   = iSeries_set_rtc_time,
+       .get_rtc_time   = iSeries_get_rtc_time,
+       .calibrate_decr = generic_calibrate_decr,
+       .progress       = iSeries_progress,
+       .probe          = iseries_probe,
+       /* XXX Implement enable_pmcs for iSeries */
+};
+
+struct blob {
+       unsigned char data[PAGE_SIZE];
+       unsigned long next;
+};
+
+struct iseries_flat_dt {
+       struct boot_param_header header;
+       u64 reserve_map[2];
+       struct blob dt;
+       struct blob strings;
+};
+
+struct iseries_flat_dt iseries_dt;
+
+void dt_init(struct iseries_flat_dt *dt)
+{
+       dt->header.off_mem_rsvmap =
+               offsetof(struct iseries_flat_dt, reserve_map);
+       dt->header.off_dt_struct = offsetof(struct iseries_flat_dt, dt);
+       dt->header.off_dt_strings = offsetof(struct iseries_flat_dt, strings);
+       dt->header.totalsize = sizeof(struct iseries_flat_dt);
+       dt->header.dt_strings_size = sizeof(struct blob);
+
+       /* There is no notion of hardware cpu id on iSeries */
+       dt->header.boot_cpuid_phys = smp_processor_id();
+
+       dt->dt.next = (unsigned long)&dt->dt.data;
+       dt->strings.next = (unsigned long)&dt->strings.data;
+
+       dt->header.magic = OF_DT_HEADER;
+       dt->header.version = 0x10;
+       dt->header.last_comp_version = 0x10;
+
+       dt->reserve_map[0] = 0;
+       dt->reserve_map[1] = 0;
+}
+
+void dt_check_blob(struct blob *b)
+{
+       if (b->next >= (unsigned long)&b->next) {
+               DBG("Ran out of space in flat device tree blob!\n");
+               BUG();
+       }
+}
+
+void dt_push_u32(struct iseries_flat_dt *dt, u32 value)
+{
+       *((u32*)dt->dt.next) = value;
+       dt->dt.next += sizeof(u32);
+
+       dt_check_blob(&dt->dt);
+}
+
+void dt_push_u64(struct iseries_flat_dt *dt, u64 value)
+{
+       *((u64*)dt->dt.next) = value;
+       dt->dt.next += sizeof(u64);
+
+       dt_check_blob(&dt->dt);
+}
+
+unsigned long dt_push_bytes(struct blob *blob, char *data, int len)
+{
+       unsigned long start = blob->next - (unsigned long)blob->data;
+
+       memcpy((char *)blob->next, data, len);
+       blob->next = _ALIGN(blob->next + len, 4);
+
+       dt_check_blob(blob);
+
+       return start;
+}
+
+void dt_start_node(struct iseries_flat_dt *dt, char *name)
+{
+       dt_push_u32(dt, OF_DT_BEGIN_NODE);
+       dt_push_bytes(&dt->dt, name, strlen(name) + 1);
+}
+
+#define dt_end_node(dt) dt_push_u32(dt, OF_DT_END_NODE)
+
+void dt_prop(struct iseries_flat_dt *dt, char *name, char *data, int len)
+{
+       unsigned long offset;
+
+       dt_push_u32(dt, OF_DT_PROP);
+
+       /* Length of the data */
+       dt_push_u32(dt, len);
+
+       /* Put the property name in the string blob. */
+       offset = dt_push_bytes(&dt->strings, name, strlen(name) + 1);
+
+       /* The offset of the properties name in the string blob. */
+       dt_push_u32(dt, (u32)offset);
+
+       /* The actual data. */
+       dt_push_bytes(&dt->dt, data, len);
+}
+
+void dt_prop_str(struct iseries_flat_dt *dt, char *name, char *data)
+{
+       dt_prop(dt, name, data, strlen(data) + 1); /* + 1 for NULL */
+}
+
+void dt_prop_u32(struct iseries_flat_dt *dt, char *name, u32 data)
+{
+       dt_prop(dt, name, (char *)&data, sizeof(u32));
+}
+
+void dt_prop_u64(struct iseries_flat_dt *dt, char *name, u64 data)
+{
+       dt_prop(dt, name, (char *)&data, sizeof(u64));
+}
+
+void dt_prop_u64_list(struct iseries_flat_dt *dt, char *name, u64 *data, int n)
+{
+       dt_prop(dt, name, (char *)data, sizeof(u64) * n);
+}
+
+void dt_prop_empty(struct iseries_flat_dt *dt, char *name)
+{
+       dt_prop(dt, name, NULL, 0);
+}
+
+void dt_cpus(struct iseries_flat_dt *dt)
+{
+       unsigned char buf[32];
+       unsigned char *p;
+       unsigned int i, index;
+       struct IoHriProcessorVpd *d;
+
+       /* yuck */
+       snprintf(buf, 32, "PowerPC,%s", cur_cpu_spec->cpu_name);
+       p = strchr(buf, ' ');
+       if (!p) p = buf + strlen(buf);
+
+       dt_start_node(dt, "cpus");
+       dt_prop_u32(dt, "#address-cells", 1);
+       dt_prop_u32(dt, "#size-cells", 0);
+
+       for (i = 0; i < NR_CPUS; i++) {
+               if (paca[i].lppaca.dyn_proc_status >= 2)
+                       continue;
+
+               snprintf(p, 32 - (p - buf), "@%d", i);
+               dt_start_node(dt, buf);
+
+               dt_prop_str(dt, "device_type", "cpu");
+
+               index = paca[i].lppaca.dyn_hv_phys_proc_index;
+               d = &xIoHriProcessorVpd[index];
+
+               dt_prop_u32(dt, "i-cache-size", d->xInstCacheSize * 1024);
+               dt_prop_u32(dt, "i-cache-line-size", d->xInstCacheOperandSize);
+
+               dt_prop_u32(dt, "d-cache-size", d->xDataL1CacheSizeKB * 1024);
+               dt_prop_u32(dt, "d-cache-line-size", d->xDataCacheOperandSize);
+
+               /* magic conversions to Hz copied from old code */
+               dt_prop_u32(dt, "clock-frequency",
+                       ((1UL << 34) * 1000000) / d->xProcFreq);
+               dt_prop_u32(dt, "timebase-frequency",
+                       ((1UL << 32) * 1000000) / d->xTimeBaseFreq);
+
+               dt_prop_u32(dt, "reg", i);
+
+               dt_end_node(dt);
+       }
+
+       dt_end_node(dt);
+}
+
+void build_flat_dt(struct iseries_flat_dt *dt)
+{
+       u64 tmp[2];
+
+       dt_init(dt);
+
+       dt_start_node(dt, "");
+
+       dt_prop_u32(dt, "#address-cells", 2);
+       dt_prop_u32(dt, "#size-cells", 2);
+
+       /* /memory */
+       dt_start_node(dt, "memory@0");
+       dt_prop_str(dt, "name", "memory");
+       dt_prop_str(dt, "device_type", "memory");
+       tmp[0] = 0;
+       tmp[1] = systemcfg->physicalMemorySize;
+       dt_prop_u64_list(dt, "reg", tmp, 2);
+       dt_end_node(dt);
+
+       /* /chosen */
+       dt_start_node(dt, "chosen");
+       dt_prop_u32(dt, "linux,platform", PLATFORM_ISERIES_LPAR);
+       dt_end_node(dt);
+
+       dt_cpus(dt);
+
+       dt_end_node(dt);
+
+       dt_push_u32(dt, OF_DT_END);
+}
+
+void * __init iSeries_early_setup(void)
+{
+       iSeries_fixup_klimit();
+
+       /*
+        * Initialize the table which translate Linux physical addresses to
+        * AS/400 absolute addresses
+        */
+       build_iSeries_Memory_Map();
+
+       build_flat_dt(&iseries_dt);
+
+       return (void *) __pa(&iseries_dt);
+}
diff --git a/arch/powerpc/platforms/iseries/setup.h b/arch/powerpc/platforms/iseries/setup.h
new file mode 100644 (file)
index 0000000..6da89ae
--- /dev/null
@@ -0,0 +1,24 @@
+/*
+ *    Copyright (c) 2000 Mike Corrigan <mikejc@us.ibm.com>
+ *    Copyright (c) 1999-2000 Grant Erickson <grant@lcse.umn.edu>
+ *
+ *    Description:
+ *      Architecture- / platform-specific boot-time initialization code for
+ *      the IBM AS/400 LPAR. Adapted from original code by Grant Erickson and
+ *      code by Gary Thomas, Cort Dougan <cort@cs.nmt.edu>, and Dan Malek
+ *      <dan@netx4.com>.
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      as published by the Free Software Foundation; either version
+ *      2 of the License, or (at your option) any later version.
+ */
+
+#ifndef        __ISERIES_SETUP_H__
+#define        __ISERIES_SETUP_H__
+
+extern void iSeries_get_boot_time(struct rtc_time *tm);
+extern int iSeries_set_rtc_time(struct rtc_time *tm);
+extern void iSeries_get_rtc_time(struct rtc_time *tm);
+
+#endif /* __ISERIES_SETUP_H__ */
index 4d95f0d0137a4fbc9c78e8920635920b7fa31126..b558cc0f4d9ec28cec4a9ef8cfbbcd5b499ab6c8 100644 (file)
@@ -22,8 +22,8 @@ pci-obj-$(CONFIG_PPC_MULTIPLATFORM)   += pci_dn.o pci_direct_iommu.o
 
 obj-$(CONFIG_PCI)      += pci.o pci_iommu.o iomap.o $(pci-obj-y)
 
-obj-$(CONFIG_PPC_ISERIES) += iSeries_setup.o ItLpQueue.o hvCall.o \
-                            mf.o HvLpEvent.o iSeries_proc.o iSeries_htab.o \
+obj-$(CONFIG_PPC_ISERIES) += ItLpQueue.o hvCall.o \
+                            HvLpEvent.o iSeries_proc.o iSeries_htab.o \
                             iSeries_iommu.o
 
 obj-$(CONFIG_PPC_MULTIPLATFORM) += nvram.o i8259.o prom_init.o
diff --git a/arch/ppc64/kernel/iSeries_setup.c b/arch/ppc64/kernel/iSeries_setup.c
deleted file mode 100644 (file)
index 9daf734..0000000
+++ /dev/null
@@ -1,1007 +0,0 @@
-/*
- *    Copyright (c) 2000 Mike Corrigan <mikejc@us.ibm.com>
- *    Copyright (c) 1999-2000 Grant Erickson <grant@lcse.umn.edu>
- *
- *    Module name: iSeries_setup.c
- *
- *    Description:
- *      Architecture- / platform-specific boot-time initialization code for
- *      the IBM iSeries LPAR.  Adapted from original code by Grant Erickson and
- *      code by Gary Thomas, Cort Dougan <cort@fsmlabs.com>, and Dan Malek
- *      <dan@net4x.com>.
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- */
-
-#undef DEBUG
-
-#include <linux/config.h>
-#include <linux/init.h>
-#include <linux/threads.h>
-#include <linux/smp.h>
-#include <linux/param.h>
-#include <linux/string.h>
-#include <linux/initrd.h>
-#include <linux/seq_file.h>
-#include <linux/kdev_t.h>
-#include <linux/major.h>
-#include <linux/root_dev.h>
-
-#include <asm/processor.h>
-#include <asm/machdep.h>
-#include <asm/page.h>
-#include <asm/mmu.h>
-#include <asm/pgtable.h>
-#include <asm/mmu_context.h>
-#include <asm/cputable.h>
-#include <asm/sections.h>
-#include <asm/iommu.h>
-#include <asm/firmware.h>
-
-#include <asm/time.h>
-#include "iSeries_setup.h"
-#include <asm/naca.h>
-#include <asm/paca.h>
-#include <asm/cache.h>
-#include <asm/sections.h>
-#include <asm/abs_addr.h>
-#include <asm/iSeries/HvCallHpt.h>
-#include <asm/iSeries/HvLpConfig.h>
-#include <asm/iSeries/HvCallEvent.h>
-#include <asm/iSeries/HvCallSm.h>
-#include <asm/iSeries/HvCallXm.h>
-#include <asm/iSeries/ItLpQueue.h>
-#include <asm/iSeries/IoHriMainStore.h>
-#include <asm/iSeries/mf.h>
-#include <asm/iSeries/HvLpEvent.h>
-#include <asm/iSeries/iSeries_irq.h>
-#include <asm/iSeries/IoHriProcessorVpd.h>
-#include <asm/iSeries/ItVpdAreas.h>
-#include <asm/iSeries/LparMap.h>
-
-extern void hvlog(char *fmt, ...);
-
-#ifdef DEBUG
-#define DBG(fmt...) hvlog(fmt)
-#else
-#define DBG(fmt...)
-#endif
-
-/* Function Prototypes */
-extern void ppcdbg_initialize(void);
-
-static void build_iSeries_Memory_Map(void);
-static int iseries_shared_idle(void);
-static int iseries_dedicated_idle(void);
-#ifdef CONFIG_PCI
-extern void iSeries_pci_final_fixup(void);
-#else
-static void iSeries_pci_final_fixup(void) { }
-#endif
-
-/* Global Variables */
-int piranha_simulator;
-
-extern int rd_size;            /* Defined in drivers/block/rd.c */
-extern unsigned long klimit;
-extern unsigned long embedded_sysmap_start;
-extern unsigned long embedded_sysmap_end;
-
-extern unsigned long iSeries_recal_tb;
-extern unsigned long iSeries_recal_titan;
-
-static int mf_initialized;
-
-struct MemoryBlock {
-       unsigned long absStart;
-       unsigned long absEnd;
-       unsigned long logicalStart;
-       unsigned long logicalEnd;
-};
-
-/*
- * Process the main store vpd to determine where the holes in memory are
- * and return the number of physical blocks and fill in the array of
- * block data.
- */
-static unsigned long iSeries_process_Condor_mainstore_vpd(
-               struct MemoryBlock *mb_array, unsigned long max_entries)
-{
-       unsigned long holeFirstChunk, holeSizeChunks;
-       unsigned long numMemoryBlocks = 1;
-       struct IoHriMainStoreSegment4 *msVpd =
-               (struct IoHriMainStoreSegment4 *)xMsVpd;
-       unsigned long holeStart = msVpd->nonInterleavedBlocksStartAdr;
-       unsigned long holeEnd = msVpd->nonInterleavedBlocksEndAdr;
-       unsigned long holeSize = holeEnd - holeStart;
-
-       printk("Mainstore_VPD: Condor\n");
-       /*
-        * Determine if absolute memory has any
-        * holes so that we can interpret the
-        * access map we get back from the hypervisor
-        * correctly.
-        */
-       mb_array[0].logicalStart = 0;
-       mb_array[0].logicalEnd = 0x100000000;
-       mb_array[0].absStart = 0;
-       mb_array[0].absEnd = 0x100000000;
-
-       if (holeSize) {
-               numMemoryBlocks = 2;
-               holeStart = holeStart & 0x000fffffffffffff;
-               holeStart = addr_to_chunk(holeStart);
-               holeFirstChunk = holeStart;
-               holeSize = addr_to_chunk(holeSize);
-               holeSizeChunks = holeSize;
-               printk( "Main store hole: start chunk = %0lx, size = %0lx chunks\n",
-                               holeFirstChunk, holeSizeChunks );
-               mb_array[0].logicalEnd = holeFirstChunk;
-               mb_array[0].absEnd = holeFirstChunk;
-               mb_array[1].logicalStart = holeFirstChunk;
-               mb_array[1].logicalEnd = 0x100000000 - holeSizeChunks;
-               mb_array[1].absStart = holeFirstChunk + holeSizeChunks;
-               mb_array[1].absEnd = 0x100000000;
-       }
-       return numMemoryBlocks;
-}
-
-#define MaxSegmentAreas                        32
-#define MaxSegmentAdrRangeBlocks       128
-#define MaxAreaRangeBlocks             4
-
-static unsigned long iSeries_process_Regatta_mainstore_vpd(
-               struct MemoryBlock *mb_array, unsigned long max_entries)
-{
-       struct IoHriMainStoreSegment5 *msVpdP =
-               (struct IoHriMainStoreSegment5 *)xMsVpd;
-       unsigned long numSegmentBlocks = 0;
-       u32 existsBits = msVpdP->msAreaExists;
-       unsigned long area_num;
-
-       printk("Mainstore_VPD: Regatta\n");
-
-       for (area_num = 0; area_num < MaxSegmentAreas; ++area_num ) {
-               unsigned long numAreaBlocks;
-               struct IoHriMainStoreArea4 *currentArea;
-
-               if (existsBits & 0x80000000) {
-                       unsigned long block_num;
-
-                       currentArea = &msVpdP->msAreaArray[area_num];
-                       numAreaBlocks = currentArea->numAdrRangeBlocks;
-                       printk("ms_vpd: processing area %2ld  blocks=%ld",
-                                       area_num, numAreaBlocks);
-                       for (block_num = 0; block_num < numAreaBlocks;
-                                       ++block_num ) {
-                               /* Process an address range block */
-                               struct MemoryBlock tempBlock;
-                               unsigned long i;
-
-                               tempBlock.absStart =
-                                       (unsigned long)currentArea->xAdrRangeBlock[block_num].blockStart;
-                               tempBlock.absEnd =
-                                       (unsigned long)currentArea->xAdrRangeBlock[block_num].blockEnd;
-                               tempBlock.logicalStart = 0;
-                               tempBlock.logicalEnd   = 0;
-                               printk("\n          block %ld absStart=%016lx absEnd=%016lx",
-                                               block_num, tempBlock.absStart,
-                                               tempBlock.absEnd);
-
-                               for (i = 0; i < numSegmentBlocks; ++i) {
-                                       if (mb_array[i].absStart ==
-                                                       tempBlock.absStart)
-                                               break;
-                               }
-                               if (i == numSegmentBlocks) {
-                                       if (numSegmentBlocks == max_entries)
-                                               panic("iSeries_process_mainstore_vpd: too many memory blocks");
-                                       mb_array[numSegmentBlocks] = tempBlock;
-                                       ++numSegmentBlocks;
-                               } else
-                                       printk(" (duplicate)");
-                       }
-                       printk("\n");
-               }
-               existsBits <<= 1;
-       }
-       /* Now sort the blocks found into ascending sequence */
-       if (numSegmentBlocks > 1) {
-               unsigned long m, n;
-
-               for (m = 0; m < numSegmentBlocks - 1; ++m) {
-                       for (n = numSegmentBlocks - 1; m < n; --n) {
-                               if (mb_array[n].absStart <
-                                               mb_array[n-1].absStart) {
-                                       struct MemoryBlock tempBlock;
-
-                                       tempBlock = mb_array[n];
-                                       mb_array[n] = mb_array[n-1];
-                                       mb_array[n-1] = tempBlock;
-                               }
-                       }
-               }
-       }
-       /*
-        * Assign "logical" addresses to each block.  These
-        * addresses correspond to the hypervisor "bitmap" space.
-        * Convert all addresses into units of 256K chunks.
-        */
-       {
-       unsigned long i, nextBitmapAddress;
-
-       printk("ms_vpd: %ld sorted memory blocks\n", numSegmentBlocks);
-       nextBitmapAddress = 0;
-       for (i = 0; i < numSegmentBlocks; ++i) {
-               unsigned long length = mb_array[i].absEnd -
-                       mb_array[i].absStart;
-
-               mb_array[i].logicalStart = nextBitmapAddress;
-               mb_array[i].logicalEnd = nextBitmapAddress + length;
-               nextBitmapAddress += length;
-               printk("          Bitmap range: %016lx - %016lx\n"
-                               "        Absolute range: %016lx - %016lx\n",
-                               mb_array[i].logicalStart,
-                               mb_array[i].logicalEnd,
-                               mb_array[i].absStart, mb_array[i].absEnd);
-               mb_array[i].absStart = addr_to_chunk(mb_array[i].absStart &
-                               0x000fffffffffffff);
-               mb_array[i].absEnd = addr_to_chunk(mb_array[i].absEnd &
-                               0x000fffffffffffff);
-               mb_array[i].logicalStart =
-                       addr_to_chunk(mb_array[i].logicalStart);
-               mb_array[i].logicalEnd = addr_to_chunk(mb_array[i].logicalEnd);
-       }
-       }
-
-       return numSegmentBlocks;
-}
-
-static unsigned long iSeries_process_mainstore_vpd(struct MemoryBlock *mb_array,
-               unsigned long max_entries)
-{
-       unsigned long i;
-       unsigned long mem_blocks = 0;
-
-       if (cpu_has_feature(CPU_FTR_SLB))
-               mem_blocks = iSeries_process_Regatta_mainstore_vpd(mb_array,
-                               max_entries);
-       else
-               mem_blocks = iSeries_process_Condor_mainstore_vpd(mb_array,
-                               max_entries);
-
-       printk("Mainstore_VPD: numMemoryBlocks = %ld \n", mem_blocks);
-       for (i = 0; i < mem_blocks; ++i) {
-               printk("Mainstore_VPD: block %3ld logical chunks %016lx - %016lx\n"
-                      "                             abs chunks %016lx - %016lx\n",
-                       i, mb_array[i].logicalStart, mb_array[i].logicalEnd,
-                       mb_array[i].absStart, mb_array[i].absEnd);
-       }
-       return mem_blocks;
-}
-
-static void __init iSeries_get_cmdline(void)
-{
-       char *p, *q;
-
-       /* copy the command line parameter from the primary VSP  */
-       HvCallEvent_dmaToSp(cmd_line, 2 * 64* 1024, 256,
-                       HvLpDma_Direction_RemoteToLocal);
-
-       p = cmd_line;
-       q = cmd_line + 255;
-       while(p < q) {
-               if (!*p || *p == '\n')
-                       break;
-               ++p;
-       }
-       *p = 0;
-}
-
-static void __init iSeries_init_early(void)
-{
-       extern unsigned long memory_limit;
-
-       DBG(" -> iSeries_init_early()\n");
-
-       ppc64_firmware_features = FW_FEATURE_ISERIES;
-
-       ppcdbg_initialize();
-
-       ppc64_interrupt_controller = IC_ISERIES;
-
-#if defined(CONFIG_BLK_DEV_INITRD)
-       /*
-        * If the init RAM disk has been configured and there is
-        * a non-zero starting address for it, set it up
-        */
-       if (naca.xRamDisk) {
-               initrd_start = (unsigned long)__va(naca.xRamDisk);
-               initrd_end = initrd_start + naca.xRamDiskSize * PAGE_SIZE;
-               initrd_below_start_ok = 1;      // ramdisk in kernel space
-               ROOT_DEV = Root_RAM0;
-               if (((rd_size * 1024) / PAGE_SIZE) < naca.xRamDiskSize)
-                       rd_size = (naca.xRamDiskSize * PAGE_SIZE) / 1024;
-       } else
-#endif /* CONFIG_BLK_DEV_INITRD */
-       {
-           /* ROOT_DEV = MKDEV(VIODASD_MAJOR, 1); */
-       }
-
-       iSeries_recal_tb = get_tb();
-       iSeries_recal_titan = HvCallXm_loadTod();
-
-       /*
-        * Initialize the hash table management pointers
-        */
-       hpte_init_iSeries();
-
-       /*
-        * Initialize the DMA/TCE management
-        */
-       iommu_init_early_iSeries();
-
-       iSeries_get_cmdline();
-
-       /* Save unparsed command line copy for /proc/cmdline */
-       strlcpy(saved_command_line, cmd_line, COMMAND_LINE_SIZE);
-
-       /* Parse early parameters, in particular mem=x */
-       parse_early_param();
-
-       if (memory_limit) {
-               if (memory_limit < systemcfg->physicalMemorySize)
-                       systemcfg->physicalMemorySize = memory_limit;
-               else {
-                       printk("Ignoring mem=%lu >= ram_top.\n", memory_limit);
-                       memory_limit = 0;
-               }
-       }
-
-       /* Initialize machine-dependency vectors */
-#ifdef CONFIG_SMP
-       smp_init_iSeries();
-#endif
-       if (itLpNaca.xPirEnvironMode == 0)
-               piranha_simulator = 1;
-
-       /* Associate Lp Event Queue 0 with processor 0 */
-       HvCallEvent_setLpEventQueueInterruptProc(0, 0);
-
-       mf_init();
-       mf_initialized = 1;
-       mb();
-
-       /* If we were passed an initrd, set the ROOT_DEV properly if the values
-        * look sensible. If not, clear initrd reference.
-        */
-#ifdef CONFIG_BLK_DEV_INITRD
-       if (initrd_start >= KERNELBASE && initrd_end >= KERNELBASE &&
-           initrd_end > initrd_start)
-               ROOT_DEV = Root_RAM0;
-       else
-               initrd_start = initrd_end = 0;
-#endif /* CONFIG_BLK_DEV_INITRD */
-
-       DBG(" <- iSeries_init_early()\n");
-}
-
-struct mschunks_map mschunks_map = {
-       /* XXX We don't use these, but Piranha might need them. */
-       .chunk_size  = MSCHUNKS_CHUNK_SIZE,
-       .chunk_shift = MSCHUNKS_CHUNK_SHIFT,
-       .chunk_mask  = MSCHUNKS_OFFSET_MASK,
-};
-EXPORT_SYMBOL(mschunks_map);
-
-void mschunks_alloc(unsigned long num_chunks)
-{
-       klimit = _ALIGN(klimit, sizeof(u32));
-       mschunks_map.mapping = (u32 *)klimit;
-       klimit += num_chunks * sizeof(u32);
-       mschunks_map.num_chunks = num_chunks;
-}
-
-/*
- * The iSeries may have very large memories ( > 128 GB ) and a partition
- * may get memory in "chunks" that may be anywhere in the 2**52 real
- * address space.  The chunks are 256K in size.  To map this to the
- * memory model Linux expects, the AS/400 specific code builds a
- * translation table to translate what Linux thinks are "physical"
- * addresses to the actual real addresses.  This allows us to make
- * it appear to Linux that we have contiguous memory starting at
- * physical address zero while in fact this could be far from the truth.
- * To avoid confusion, I'll let the words physical and/or real address
- * apply to the Linux addresses while I'll use "absolute address" to
- * refer to the actual hardware real address.
- *
- * build_iSeries_Memory_Map gets information from the Hypervisor and
- * looks at the Main Store VPD to determine the absolute addresses
- * of the memory that has been assigned to our partition and builds
- * a table used to translate Linux's physical addresses to these
- * absolute addresses.  Absolute addresses are needed when
- * communicating with the hypervisor (e.g. to build HPT entries)
- */
-
-static void __init build_iSeries_Memory_Map(void)
-{
-       u32 loadAreaFirstChunk, loadAreaLastChunk, loadAreaSize;
-       u32 nextPhysChunk;
-       u32 hptFirstChunk, hptLastChunk, hptSizeChunks, hptSizePages;
-       u32 num_ptegs;
-       u32 totalChunks,moreChunks;
-       u32 currChunk, thisChunk, absChunk;
-       u32 currDword;
-       u32 chunkBit;
-       u64 map;
-       struct MemoryBlock mb[32];
-       unsigned long numMemoryBlocks, curBlock;
-
-       /* Chunk size on iSeries is 256K bytes */
-       totalChunks = (u32)HvLpConfig_getMsChunks();
-       mschunks_alloc(totalChunks);
-
-       /*
-        * Get absolute address of our load area
-        * and map it to physical address 0
-        * This guarantees that the loadarea ends up at physical 0
-        * otherwise, it might not be returned by PLIC as the first
-        * chunks
-        */
-
-       loadAreaFirstChunk = (u32)addr_to_chunk(itLpNaca.xLoadAreaAddr);
-       loadAreaSize =  itLpNaca.xLoadAreaChunks;
-
-       /*
-        * Only add the pages already mapped here.
-        * Otherwise we might add the hpt pages
-        * The rest of the pages of the load area
-        * aren't in the HPT yet and can still
-        * be assigned an arbitrary physical address
-        */
-       if ((loadAreaSize * 64) > HvPagesToMap)
-               loadAreaSize = HvPagesToMap / 64;
-
-       loadAreaLastChunk = loadAreaFirstChunk + loadAreaSize - 1;
-
-       /*
-        * TODO Do we need to do something if the HPT is in the 64MB load area?
-        * This would be required if the itLpNaca.xLoadAreaChunks includes
-        * the HPT size
-        */
-
-       printk("Mapping load area - physical addr = 0000000000000000\n"
-               "                    absolute addr = %016lx\n",
-               chunk_to_addr(loadAreaFirstChunk));
-       printk("Load area size %dK\n", loadAreaSize * 256);
-
-       for (nextPhysChunk = 0; nextPhysChunk < loadAreaSize; ++nextPhysChunk)
-               mschunks_map.mapping[nextPhysChunk] =
-                       loadAreaFirstChunk + nextPhysChunk;
-
-       /*
-        * Get absolute address of our HPT and remember it so
-        * we won't map it to any physical address
-        */
-       hptFirstChunk = (u32)addr_to_chunk(HvCallHpt_getHptAddress());
-       hptSizePages = (u32)HvCallHpt_getHptPages();
-       hptSizeChunks = hptSizePages >> (MSCHUNKS_CHUNK_SHIFT - PAGE_SHIFT);
-       hptLastChunk = hptFirstChunk + hptSizeChunks - 1;
-
-       printk("HPT absolute addr = %016lx, size = %dK\n",
-                       chunk_to_addr(hptFirstChunk), hptSizeChunks * 256);
-
-       /* Fill in the hashed page table hash mask */
-       num_ptegs = hptSizePages *
-               (PAGE_SIZE / (sizeof(hpte_t) * HPTES_PER_GROUP));
-       htab_hash_mask = num_ptegs - 1;
-
-       /*
-        * The actual hashed page table is in the hypervisor,
-        * we have no direct access
-        */
-       htab_address = NULL;
-
-       /*
-        * Determine if absolute memory has any
-        * holes so that we can interpret the
-        * access map we get back from the hypervisor
-        * correctly.
-        */
-       numMemoryBlocks = iSeries_process_mainstore_vpd(mb, 32);
-
-       /*
-        * Process the main store access map from the hypervisor
-        * to build up our physical -> absolute translation table
-        */
-       curBlock = 0;
-       currChunk = 0;
-       currDword = 0;
-       moreChunks = totalChunks;
-
-       while (moreChunks) {
-               map = HvCallSm_get64BitsOfAccessMap(itLpNaca.xLpIndex,
-                               currDword);
-               thisChunk = currChunk;
-               while (map) {
-                       chunkBit = map >> 63;
-                       map <<= 1;
-                       if (chunkBit) {
-                               --moreChunks;
-                               while (thisChunk >= mb[curBlock].logicalEnd) {
-                                       ++curBlock;
-                                       if (curBlock >= numMemoryBlocks)
-                                               panic("out of memory blocks");
-                               }
-                               if (thisChunk < mb[curBlock].logicalStart)
-                                       panic("memory block error");
-
-                               absChunk = mb[curBlock].absStart +
-                                       (thisChunk - mb[curBlock].logicalStart);
-                               if (((absChunk < hptFirstChunk) ||
-                                    (absChunk > hptLastChunk)) &&
-                                   ((absChunk < loadAreaFirstChunk) ||
-                                    (absChunk > loadAreaLastChunk))) {
-                                       mschunks_map.mapping[nextPhysChunk] =
-                                               absChunk;
-                                       ++nextPhysChunk;
-                               }
-                       }
-                       ++thisChunk;
-               }
-               ++currDword;
-               currChunk += 64;
-       }
-
-       /*
-        * main store size (in chunks) is
-        *   totalChunks - hptSizeChunks
-        * which should be equal to
-        *   nextPhysChunk
-        */
-       systemcfg->physicalMemorySize = chunk_to_addr(nextPhysChunk);
-}
-
-/*
- * Document me.
- */
-static void __init iSeries_setup_arch(void)
-{
-       unsigned procIx = get_paca()->lppaca.dyn_hv_phys_proc_index;
-
-       if (get_paca()->lppaca.shared_proc) {
-               ppc_md.idle_loop = iseries_shared_idle;
-               printk(KERN_INFO "Using shared processor idle loop\n");
-       } else {
-               ppc_md.idle_loop = iseries_dedicated_idle;
-               printk(KERN_INFO "Using dedicated idle loop\n");
-       }
-
-       /* Setup the Lp Event Queue */
-       setup_hvlpevent_queue();
-
-       printk("Max  logical processors = %d\n",
-                       itVpdAreas.xSlicMaxLogicalProcs);
-       printk("Max physical processors = %d\n",
-                       itVpdAreas.xSlicMaxPhysicalProcs);
-
-       systemcfg->processor = xIoHriProcessorVpd[procIx].xPVR;
-       printk("Processor version = %x\n", systemcfg->processor);
-}
-
-static void iSeries_get_cpuinfo(struct seq_file *m)
-{
-       seq_printf(m, "machine\t\t: 64-bit iSeries Logical Partition\n");
-}
-
-/*
- * Document me.
- * and Implement me.
- */
-static int iSeries_get_irq(struct pt_regs *regs)
-{
-       /* -2 means ignore this interrupt */
-       return -2;
-}
-
-/*
- * Document me.
- */
-static void iSeries_restart(char *cmd)
-{
-       mf_reboot();
-}
-
-/*
- * Document me.
- */
-static void iSeries_power_off(void)
-{
-       mf_power_off();
-}
-
-/*
- * Document me.
- */
-static void iSeries_halt(void)
-{
-       mf_power_off();
-}
-
-static void __init iSeries_progress(char * st, unsigned short code)
-{
-       printk("Progress: [%04x] - %s\n", (unsigned)code, st);
-       if (!piranha_simulator && mf_initialized) {
-               if (code != 0xffff)
-                       mf_display_progress(code);
-               else
-                       mf_clear_src();
-       }
-}
-
-static void __init iSeries_fixup_klimit(void)
-{
-       /*
-        * Change klimit to take into account any ram disk
-        * that may be included
-        */
-       if (naca.xRamDisk)
-               klimit = KERNELBASE + (u64)naca.xRamDisk +
-                       (naca.xRamDiskSize * PAGE_SIZE);
-       else {
-               /*
-                * No ram disk was included - check and see if there
-                * was an embedded system map.  Change klimit to take
-                * into account any embedded system map
-                */
-               if (embedded_sysmap_end)
-                       klimit = KERNELBASE + ((embedded_sysmap_end + 4095) &
-                                       0xfffffffffffff000);
-       }
-}
-
-static int __init iSeries_src_init(void)
-{
-        /* clear the progress line */
-        ppc_md.progress(" ", 0xffff);
-        return 0;
-}
-
-late_initcall(iSeries_src_init);
-
-static inline void process_iSeries_events(void)
-{
-       asm volatile ("li 0,0x5555; sc" : : : "r0", "r3");
-}
-
-static void yield_shared_processor(void)
-{
-       unsigned long tb;
-
-       HvCall_setEnabledInterrupts(HvCall_MaskIPI |
-                                   HvCall_MaskLpEvent |
-                                   HvCall_MaskLpProd |
-                                   HvCall_MaskTimeout);
-
-       tb = get_tb();
-       /* Compute future tb value when yield should expire */
-       HvCall_yieldProcessor(HvCall_YieldTimed, tb+tb_ticks_per_jiffy);
-
-       /*
-        * The decrementer stops during the yield.  Force a fake decrementer
-        * here and let the timer_interrupt code sort out the actual time.
-        */
-       get_paca()->lppaca.int_dword.fields.decr_int = 1;
-       process_iSeries_events();
-}
-
-static int iseries_shared_idle(void)
-{
-       while (1) {
-               while (!need_resched() && !hvlpevent_is_pending()) {
-                       local_irq_disable();
-                       ppc64_runlatch_off();
-
-                       /* Recheck with irqs off */
-                       if (!need_resched() && !hvlpevent_is_pending())
-                               yield_shared_processor();
-
-                       HMT_medium();
-                       local_irq_enable();
-               }
-
-               ppc64_runlatch_on();
-
-               if (hvlpevent_is_pending())
-                       process_iSeries_events();
-
-               schedule();
-       }
-
-       return 0;
-}
-
-static int iseries_dedicated_idle(void)
-{
-       long oldval;
-
-       while (1) {
-               oldval = test_and_clear_thread_flag(TIF_NEED_RESCHED);
-
-               if (!oldval) {
-                       set_thread_flag(TIF_POLLING_NRFLAG);
-
-                       while (!need_resched()) {
-                               ppc64_runlatch_off();
-                               HMT_low();
-
-                               if (hvlpevent_is_pending()) {
-                                       HMT_medium();
-                                       ppc64_runlatch_on();
-                                       process_iSeries_events();
-                               }
-                       }
-
-                       HMT_medium();
-                       clear_thread_flag(TIF_POLLING_NRFLAG);
-               } else {
-                       set_need_resched();
-               }
-
-               ppc64_runlatch_on();
-               schedule();
-       }
-
-       return 0;
-}
-
-#ifndef CONFIG_PCI
-void __init iSeries_init_IRQ(void) { }
-#endif
-
-static int __init iseries_probe(int platform)
-{
-       return PLATFORM_ISERIES_LPAR == platform;
-}
-
-struct machdep_calls __initdata iseries_md = {
-       .setup_arch     = iSeries_setup_arch,
-       .get_cpuinfo    = iSeries_get_cpuinfo,
-       .init_IRQ       = iSeries_init_IRQ,
-       .get_irq        = iSeries_get_irq,
-       .init_early     = iSeries_init_early,
-       .pcibios_fixup  = iSeries_pci_final_fixup,
-       .restart        = iSeries_restart,
-       .power_off      = iSeries_power_off,
-       .halt           = iSeries_halt,
-       .get_boot_time  = iSeries_get_boot_time,
-       .set_rtc_time   = iSeries_set_rtc_time,
-       .get_rtc_time   = iSeries_get_rtc_time,
-       .calibrate_decr = generic_calibrate_decr,
-       .progress       = iSeries_progress,
-       .probe          = iseries_probe,
-       /* XXX Implement enable_pmcs for iSeries */
-};
-
-struct blob {
-       unsigned char data[PAGE_SIZE];
-       unsigned long next;
-};
-
-struct iseries_flat_dt {
-       struct boot_param_header header;
-       u64 reserve_map[2];
-       struct blob dt;
-       struct blob strings;
-};
-
-struct iseries_flat_dt iseries_dt;
-
-void dt_init(struct iseries_flat_dt *dt)
-{
-       dt->header.off_mem_rsvmap =
-               offsetof(struct iseries_flat_dt, reserve_map);
-       dt->header.off_dt_struct = offsetof(struct iseries_flat_dt, dt);
-       dt->header.off_dt_strings = offsetof(struct iseries_flat_dt, strings);
-       dt->header.totalsize = sizeof(struct iseries_flat_dt);
-       dt->header.dt_strings_size = sizeof(struct blob);
-
-       /* There is no notion of hardware cpu id on iSeries */
-       dt->header.boot_cpuid_phys = smp_processor_id();
-
-       dt->dt.next = (unsigned long)&dt->dt.data;
-       dt->strings.next = (unsigned long)&dt->strings.data;
-
-       dt->header.magic = OF_DT_HEADER;
-       dt->header.version = 0x10;
-       dt->header.last_comp_version = 0x10;
-
-       dt->reserve_map[0] = 0;
-       dt->reserve_map[1] = 0;
-}
-
-void dt_check_blob(struct blob *b)
-{
-       if (b->next >= (unsigned long)&b->next) {
-               DBG("Ran out of space in flat device tree blob!\n");
-               BUG();
-       }
-}
-
-void dt_push_u32(struct iseries_flat_dt *dt, u32 value)
-{
-       *((u32*)dt->dt.next) = value;
-       dt->dt.next += sizeof(u32);
-
-       dt_check_blob(&dt->dt);
-}
-
-void dt_push_u64(struct iseries_flat_dt *dt, u64 value)
-{
-       *((u64*)dt->dt.next) = value;
-       dt->dt.next += sizeof(u64);
-
-       dt_check_blob(&dt->dt);
-}
-
-unsigned long dt_push_bytes(struct blob *blob, char *data, int len)
-{
-       unsigned long start = blob->next - (unsigned long)blob->data;
-
-       memcpy((char *)blob->next, data, len);
-       blob->next = _ALIGN(blob->next + len, 4);
-
-       dt_check_blob(blob);
-
-       return start;
-}
-
-void dt_start_node(struct iseries_flat_dt *dt, char *name)
-{
-       dt_push_u32(dt, OF_DT_BEGIN_NODE);
-       dt_push_bytes(&dt->dt, name, strlen(name) + 1);
-}
-
-#define dt_end_node(dt) dt_push_u32(dt, OF_DT_END_NODE)
-
-void dt_prop(struct iseries_flat_dt *dt, char *name, char *data, int len)
-{
-       unsigned long offset;
-
-       dt_push_u32(dt, OF_DT_PROP);
-
-       /* Length of the data */
-       dt_push_u32(dt, len);
-
-       /* Put the property name in the string blob. */
-       offset = dt_push_bytes(&dt->strings, name, strlen(name) + 1);
-
-       /* The offset of the properties name in the string blob. */
-       dt_push_u32(dt, (u32)offset);
-
-       /* The actual data. */
-       dt_push_bytes(&dt->dt, data, len);
-}
-
-void dt_prop_str(struct iseries_flat_dt *dt, char *name, char *data)
-{
-       dt_prop(dt, name, data, strlen(data) + 1); /* + 1 for NULL */
-}
-
-void dt_prop_u32(struct iseries_flat_dt *dt, char *name, u32 data)
-{
-       dt_prop(dt, name, (char *)&data, sizeof(u32));
-}
-
-void dt_prop_u64(struct iseries_flat_dt *dt, char *name, u64 data)
-{
-       dt_prop(dt, name, (char *)&data, sizeof(u64));
-}
-
-void dt_prop_u64_list(struct iseries_flat_dt *dt, char *name, u64 *data, int n)
-{
-       dt_prop(dt, name, (char *)data, sizeof(u64) * n);
-}
-
-void dt_prop_empty(struct iseries_flat_dt *dt, char *name)
-{
-       dt_prop(dt, name, NULL, 0);
-}
-
-void dt_cpus(struct iseries_flat_dt *dt)
-{
-       unsigned char buf[32];
-       unsigned char *p;
-       unsigned int i, index;
-       struct IoHriProcessorVpd *d;
-
-       /* yuck */
-       snprintf(buf, 32, "PowerPC,%s", cur_cpu_spec->cpu_name);
-       p = strchr(buf, ' ');
-       if (!p) p = buf + strlen(buf);
-
-       dt_start_node(dt, "cpus");
-       dt_prop_u32(dt, "#address-cells", 1);
-       dt_prop_u32(dt, "#size-cells", 0);
-
-       for (i = 0; i < NR_CPUS; i++) {
-               if (paca[i].lppaca.dyn_proc_status >= 2)
-                       continue;
-
-               snprintf(p, 32 - (p - buf), "@%d", i);
-               dt_start_node(dt, buf);
-
-               dt_prop_str(dt, "device_type", "cpu");
-
-               index = paca[i].lppaca.dyn_hv_phys_proc_index;
-               d = &xIoHriProcessorVpd[index];
-
-               dt_prop_u32(dt, "i-cache-size", d->xInstCacheSize * 1024);
-               dt_prop_u32(dt, "i-cache-line-size", d->xInstCacheOperandSize);
-
-               dt_prop_u32(dt, "d-cache-size", d->xDataL1CacheSizeKB * 1024);
-               dt_prop_u32(dt, "d-cache-line-size", d->xDataCacheOperandSize);
-
-               /* magic conversions to Hz copied from old code */
-               dt_prop_u32(dt, "clock-frequency",
-                       ((1UL << 34) * 1000000) / d->xProcFreq);
-               dt_prop_u32(dt, "timebase-frequency",
-                       ((1UL << 32) * 1000000) / d->xTimeBaseFreq);
-
-               dt_prop_u32(dt, "reg", i);
-
-               dt_end_node(dt);
-       }
-
-       dt_end_node(dt);
-}
-
-void build_flat_dt(struct iseries_flat_dt *dt)
-{
-       u64 tmp[2];
-
-       dt_init(dt);
-
-       dt_start_node(dt, "");
-
-       dt_prop_u32(dt, "#address-cells", 2);
-       dt_prop_u32(dt, "#size-cells", 2);
-
-       /* /memory */
-       dt_start_node(dt, "memory@0");
-       dt_prop_str(dt, "name", "memory");
-       dt_prop_str(dt, "device_type", "memory");
-       tmp[0] = 0;
-       tmp[1] = systemcfg->physicalMemorySize;
-       dt_prop_u64_list(dt, "reg", tmp, 2);
-       dt_end_node(dt);
-
-       /* /chosen */
-       dt_start_node(dt, "chosen");
-       dt_prop_u32(dt, "linux,platform", PLATFORM_ISERIES_LPAR);
-       dt_end_node(dt);
-
-       dt_cpus(dt);
-
-       dt_end_node(dt);
-
-       dt_push_u32(dt, OF_DT_END);
-}
-
-void * __init iSeries_early_setup(void)
-{
-       iSeries_fixup_klimit();
-
-       /*
-        * Initialize the table which translate Linux physical addresses to
-        * AS/400 absolute addresses
-        */
-       build_iSeries_Memory_Map();
-
-       build_flat_dt(&iseries_dt);
-
-       return (void *) __pa(&iseries_dt);
-}
diff --git a/arch/ppc64/kernel/iSeries_setup.h b/arch/ppc64/kernel/iSeries_setup.h
deleted file mode 100644 (file)
index c6eb29a..0000000
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- *    Copyright (c) 2000 Mike Corrigan <mikejc@us.ibm.com>
- *    Copyright (c) 1999-2000 Grant Erickson <grant@lcse.umn.edu>
- *
- *    Module name: as400_setup.h
- *
- *    Description:
- *      Architecture- / platform-specific boot-time initialization code for
- *      the IBM AS/400 LPAR. Adapted from original code by Grant Erickson and
- *      code by Gary Thomas, Cort Dougan <cort@cs.nmt.edu>, and Dan Malek
- *      <dan@netx4.com>.
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License
- *      as published by the Free Software Foundation; either version
- *      2 of the License, or (at your option) any later version.
- */
-
-#ifndef        __ISERIES_SETUP_H__
-#define        __ISERIES_SETUP_H__
-
-extern void iSeries_get_boot_time(struct rtc_time *tm);
-extern int iSeries_set_rtc_time(struct rtc_time *tm);
-extern void iSeries_get_rtc_time(struct rtc_time *tm);
-
-#endif /* __ISERIES_SETUP_H__ */
diff --git a/arch/ppc64/kernel/mf.c b/arch/ppc64/kernel/mf.c
deleted file mode 100644 (file)
index ef4a338..0000000
+++ /dev/null
@@ -1,1281 +0,0 @@
-/*
-  * mf.c
-  * Copyright (C) 2001 Troy D. Armstrong  IBM Corporation
-  * Copyright (C) 2004-2005 Stephen Rothwell  IBM Corporation
-  *
-  * This modules exists as an interface between a Linux secondary partition
-  * running on an iSeries and the primary partition's Virtual Service
-  * Processor (VSP) object.  The VSP has final authority over powering on/off
-  * all partitions in the iSeries.  It also provides miscellaneous low-level
-  * machine facility type operations.
-  *
-  *
-  * This program is free software; you can redistribute it and/or modify
-  * it under the terms of the GNU General Public License as published by
-  * the Free Software Foundation; either version 2 of the License, or
-  * (at your option) any later version.
-  *
-  * This program is distributed in the hope that it will be useful,
-  * but WITHOUT ANY WARRANTY; without even the implied warranty of
-  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  * GNU General Public License for more details.
-  *
-  * You should have received a copy of the GNU General Public License
-  * along with this program; if not, write to the Free Software
-  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-  */
-
-#include <linux/types.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/completion.h>
-#include <linux/delay.h>
-#include <linux/dma-mapping.h>
-#include <linux/bcd.h>
-
-#include <asm/time.h>
-#include <asm/uaccess.h>
-#include <asm/paca.h>
-#include <asm/iSeries/vio.h>
-#include <asm/iSeries/mf.h>
-#include <asm/iSeries/HvLpConfig.h>
-#include <asm/iSeries/ItLpQueue.h>
-
-/*
- * This is the structure layout for the Machine Facilites LPAR event
- * flows.
- */
-struct vsp_cmd_data {
-       u64 token;
-       u16 cmd;
-       HvLpIndex lp_index;
-       u8 result_code;
-       u32 reserved;
-       union {
-               u64 state;      /* GetStateOut */
-               u64 ipl_type;   /* GetIplTypeOut, Function02SelectIplTypeIn */
-               u64 ipl_mode;   /* GetIplModeOut, Function02SelectIplModeIn */
-               u64 page[4];    /* GetSrcHistoryIn */
-               u64 flag;       /* GetAutoIplWhenPrimaryIplsOut,
-                                  SetAutoIplWhenPrimaryIplsIn,
-                                  WhiteButtonPowerOffIn,
-                                  Function08FastPowerOffIn,
-                                  IsSpcnRackPowerIncompleteOut */
-               struct {
-                       u64 token;
-                       u64 address_type;
-                       u64 side;
-                       u32 length;
-                       u32 offset;
-               } kern;         /* SetKernelImageIn, GetKernelImageIn,
-                                  SetKernelCmdLineIn, GetKernelCmdLineIn */
-               u32 length_out; /* GetKernelImageOut, GetKernelCmdLineOut */
-               u8 reserved[80];
-       } sub_data;
-};
-
-struct vsp_rsp_data {
-       struct completion com;
-       struct vsp_cmd_data *response;
-};
-
-struct alloc_data {
-       u16 size;
-       u16 type;
-       u32 count;
-       u16 reserved1;
-       u8 reserved2;
-       HvLpIndex target_lp;
-};
-
-struct ce_msg_data;
-
-typedef void (*ce_msg_comp_hdlr)(void *token, struct ce_msg_data *vsp_cmd_rsp);
-
-struct ce_msg_comp_data {
-       ce_msg_comp_hdlr handler;
-       void *token;
-};
-
-struct ce_msg_data {
-       u8 ce_msg[12];
-       char reserved[4];
-       struct ce_msg_comp_data *completion;
-};
-
-struct io_mf_lp_event {
-       struct HvLpEvent hp_lp_event;
-       u16 subtype_result_code;
-       u16 reserved1;
-       u32 reserved2;
-       union {
-               struct alloc_data alloc;
-               struct ce_msg_data ce_msg;
-               struct vsp_cmd_data vsp_cmd;
-       } data;
-};
-
-#define subtype_data(a, b, c, d)       \
-               (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
-
-/*
- * All outgoing event traffic is kept on a FIFO queue.  The first
- * pointer points to the one that is outstanding, and all new
- * requests get stuck on the end.  Also, we keep a certain number of
- * preallocated pending events so that we can operate very early in
- * the boot up sequence (before kmalloc is ready).
- */
-struct pending_event {
-       struct pending_event *next;
-       struct io_mf_lp_event event;
-       MFCompleteHandler hdlr;
-       char dma_data[72];
-       unsigned dma_data_length;
-       unsigned remote_address;
-};
-static spinlock_t pending_event_spinlock;
-static struct pending_event *pending_event_head;
-static struct pending_event *pending_event_tail;
-static struct pending_event *pending_event_avail;
-static struct pending_event pending_event_prealloc[16];
-
-/*
- * Put a pending event onto the available queue, so it can get reused.
- * Attention! You must have the pending_event_spinlock before calling!
- */
-static void free_pending_event(struct pending_event *ev)
-{
-       if (ev != NULL) {
-               ev->next = pending_event_avail;
-               pending_event_avail = ev;
-       }
-}
-
-/*
- * Enqueue the outbound event onto the stack.  If the queue was
- * empty to begin with, we must also issue it via the Hypervisor
- * interface.  There is a section of code below that will touch
- * the first stack pointer without the protection of the pending_event_spinlock.
- * This is OK, because we know that nobody else will be modifying
- * the first pointer when we do this.
- */
-static int signal_event(struct pending_event *ev)
-{
-       int rc = 0;
-       unsigned long flags;
-       int go = 1;
-       struct pending_event *ev1;
-       HvLpEvent_Rc hv_rc;
-
-       /* enqueue the event */
-       if (ev != NULL) {
-               ev->next = NULL;
-               spin_lock_irqsave(&pending_event_spinlock, flags);
-               if (pending_event_head == NULL)
-                       pending_event_head = ev;
-               else {
-                       go = 0;
-                       pending_event_tail->next = ev;
-               }
-               pending_event_tail = ev;
-               spin_unlock_irqrestore(&pending_event_spinlock, flags);
-       }
-
-       /* send the event */
-       while (go) {
-               go = 0;
-
-               /* any DMA data to send beforehand? */
-               if (pending_event_head->dma_data_length > 0)
-                       HvCallEvent_dmaToSp(pending_event_head->dma_data,
-                                       pending_event_head->remote_address,
-                                       pending_event_head->dma_data_length,
-                                       HvLpDma_Direction_LocalToRemote);
-
-               hv_rc = HvCallEvent_signalLpEvent(
-                               &pending_event_head->event.hp_lp_event);
-               if (hv_rc != HvLpEvent_Rc_Good) {
-                       printk(KERN_ERR "mf.c: HvCallEvent_signalLpEvent() "
-                                       "failed with %d\n", (int)hv_rc);
-
-                       spin_lock_irqsave(&pending_event_spinlock, flags);
-                       ev1 = pending_event_head;
-                       pending_event_head = pending_event_head->next;
-                       if (pending_event_head != NULL)
-                               go = 1;
-                       spin_unlock_irqrestore(&pending_event_spinlock, flags);
-
-                       if (ev1 == ev)
-                               rc = -EIO;
-                       else if (ev1->hdlr != NULL)
-                               (*ev1->hdlr)((void *)ev1->event.hp_lp_event.xCorrelationToken, -EIO);
-
-                       spin_lock_irqsave(&pending_event_spinlock, flags);
-                       free_pending_event(ev1);
-                       spin_unlock_irqrestore(&pending_event_spinlock, flags);
-               }
-       }
-
-       return rc;
-}
-
-/*
- * Allocate a new pending_event structure, and initialize it.
- */
-static struct pending_event *new_pending_event(void)
-{
-       struct pending_event *ev = NULL;
-       HvLpIndex primary_lp = HvLpConfig_getPrimaryLpIndex();
-       unsigned long flags;
-       struct HvLpEvent *hev;
-
-       spin_lock_irqsave(&pending_event_spinlock, flags);
-       if (pending_event_avail != NULL) {
-               ev = pending_event_avail;
-               pending_event_avail = pending_event_avail->next;
-       }
-       spin_unlock_irqrestore(&pending_event_spinlock, flags);
-       if (ev == NULL) {
-               ev = kmalloc(sizeof(struct pending_event), GFP_ATOMIC);
-               if (ev == NULL) {
-                       printk(KERN_ERR "mf.c: unable to kmalloc %ld bytes\n",
-                                       sizeof(struct pending_event));
-                       return NULL;
-               }
-       }
-       memset(ev, 0, sizeof(struct pending_event));
-       hev = &ev->event.hp_lp_event;
-       hev->xFlags.xValid = 1;
-       hev->xFlags.xAckType = HvLpEvent_AckType_ImmediateAck;
-       hev->xFlags.xAckInd = HvLpEvent_AckInd_DoAck;
-       hev->xFlags.xFunction = HvLpEvent_Function_Int;
-       hev->xType = HvLpEvent_Type_MachineFac;
-       hev->xSourceLp = HvLpConfig_getLpIndex();
-       hev->xTargetLp = primary_lp;
-       hev->xSizeMinus1 = sizeof(ev->event) - 1;
-       hev->xRc = HvLpEvent_Rc_Good;
-       hev->xSourceInstanceId = HvCallEvent_getSourceLpInstanceId(primary_lp,
-                       HvLpEvent_Type_MachineFac);
-       hev->xTargetInstanceId = HvCallEvent_getTargetLpInstanceId(primary_lp,
-                       HvLpEvent_Type_MachineFac);
-
-       return ev;
-}
-
-static int signal_vsp_instruction(struct vsp_cmd_data *vsp_cmd)
-{
-       struct pending_event *ev = new_pending_event();
-       int rc;
-       struct vsp_rsp_data response;
-
-       if (ev == NULL)
-               return -ENOMEM;
-
-       init_completion(&response.com);
-       response.response = vsp_cmd;
-       ev->event.hp_lp_event.xSubtype = 6;
-       ev->event.hp_lp_event.x.xSubtypeData =
-               subtype_data('M', 'F',  'V',  'I');
-       ev->event.data.vsp_cmd.token = (u64)&response;
-       ev->event.data.vsp_cmd.cmd = vsp_cmd->cmd;
-       ev->event.data.vsp_cmd.lp_index = HvLpConfig_getLpIndex();
-       ev->event.data.vsp_cmd.result_code = 0xFF;
-       ev->event.data.vsp_cmd.reserved = 0;
-       memcpy(&(ev->event.data.vsp_cmd.sub_data),
-                       &(vsp_cmd->sub_data), sizeof(vsp_cmd->sub_data));
-       mb();
-
-       rc = signal_event(ev);
-       if (rc == 0)
-               wait_for_completion(&response.com);
-       return rc;
-}
-
-
-/*
- * Send a 12-byte CE message to the primary partition VSP object
- */
-static int signal_ce_msg(char *ce_msg, struct ce_msg_comp_data *completion)
-{
-       struct pending_event *ev = new_pending_event();
-
-       if (ev == NULL)
-               return -ENOMEM;
-
-       ev->event.hp_lp_event.xSubtype = 0;
-       ev->event.hp_lp_event.x.xSubtypeData =
-               subtype_data('M',  'F',  'C',  'E');
-       memcpy(ev->event.data.ce_msg.ce_msg, ce_msg, 12);
-       ev->event.data.ce_msg.completion = completion;
-       return signal_event(ev);
-}
-
-/*
- * Send a 12-byte CE message (with no data) to the primary partition VSP object
- */
-static int signal_ce_msg_simple(u8 ce_op, struct ce_msg_comp_data *completion)
-{
-       u8 ce_msg[12];
-
-       memset(ce_msg, 0, sizeof(ce_msg));
-       ce_msg[3] = ce_op;
-       return signal_ce_msg(ce_msg, completion);
-}
-
-/*
- * Send a 12-byte CE message and DMA data to the primary partition VSP object
- */
-static int dma_and_signal_ce_msg(char *ce_msg,
-               struct ce_msg_comp_data *completion, void *dma_data,
-               unsigned dma_data_length, unsigned remote_address)
-{
-       struct pending_event *ev = new_pending_event();
-
-       if (ev == NULL)
-               return -ENOMEM;
-
-       ev->event.hp_lp_event.xSubtype = 0;
-       ev->event.hp_lp_event.x.xSubtypeData =
-               subtype_data('M', 'F', 'C', 'E');
-       memcpy(ev->event.data.ce_msg.ce_msg, ce_msg, 12);
-       ev->event.data.ce_msg.completion = completion;
-       memcpy(ev->dma_data, dma_data, dma_data_length);
-       ev->dma_data_length = dma_data_length;
-       ev->remote_address = remote_address;
-       return signal_event(ev);
-}
-
-/*
- * Initiate a nice (hopefully) shutdown of Linux.  We simply are
- * going to try and send the init process a SIGINT signal.  If
- * this fails (why?), we'll simply force it off in a not-so-nice
- * manner.
- */
-static int shutdown(void)
-{
-       int rc = kill_proc(1, SIGINT, 1);
-
-       if (rc) {
-               printk(KERN_ALERT "mf.c: SIGINT to init failed (%d), "
-                               "hard shutdown commencing\n", rc);
-               mf_power_off();
-       } else
-               printk(KERN_INFO "mf.c: init has been successfully notified "
-                               "to proceed with shutdown\n");
-       return rc;
-}
-
-/*
- * The primary partition VSP object is sending us a new
- * event flow.  Handle it...
- */
-static void handle_int(struct io_mf_lp_event *event)
-{
-       struct ce_msg_data *ce_msg_data;
-       struct ce_msg_data *pce_msg_data;
-       unsigned long flags;
-       struct pending_event *pev;
-
-       /* ack the interrupt */
-       event->hp_lp_event.xRc = HvLpEvent_Rc_Good;
-       HvCallEvent_ackLpEvent(&event->hp_lp_event);
-
-       /* process interrupt */
-       switch (event->hp_lp_event.xSubtype) {
-       case 0: /* CE message */
-               ce_msg_data = &event->data.ce_msg;
-               switch (ce_msg_data->ce_msg[3]) {
-               case 0x5B:      /* power control notification */
-                       if ((ce_msg_data->ce_msg[5] & 0x20) != 0) {
-                               printk(KERN_INFO "mf.c: Commencing partition shutdown\n");
-                               if (shutdown() == 0)
-                                       signal_ce_msg_simple(0xDB, NULL);
-                       }
-                       break;
-               case 0xC0:      /* get time */
-                       spin_lock_irqsave(&pending_event_spinlock, flags);
-                       pev = pending_event_head;
-                       if (pev != NULL)
-                               pending_event_head = pending_event_head->next;
-                       spin_unlock_irqrestore(&pending_event_spinlock, flags);
-                       if (pev == NULL)
-                               break;
-                       pce_msg_data = &pev->event.data.ce_msg;
-                       if (pce_msg_data->ce_msg[3] != 0x40)
-                               break;
-                       if (pce_msg_data->completion != NULL) {
-                               ce_msg_comp_hdlr handler =
-                                       pce_msg_data->completion->handler;
-                               void *token = pce_msg_data->completion->token;
-
-                               if (handler != NULL)
-                                       (*handler)(token, ce_msg_data);
-                       }
-                       spin_lock_irqsave(&pending_event_spinlock, flags);
-                       free_pending_event(pev);
-                       spin_unlock_irqrestore(&pending_event_spinlock, flags);
-                       /* send next waiting event */
-                       if (pending_event_head != NULL)
-                               signal_event(NULL);
-                       break;
-               }
-               break;
-       case 1: /* IT sys shutdown */
-               printk(KERN_INFO "mf.c: Commencing system shutdown\n");
-               shutdown();
-               break;
-       }
-}
-
-/*
- * The primary partition VSP object is acknowledging the receipt
- * of a flow we sent to them.  If there are other flows queued
- * up, we must send another one now...
- */
-static void handle_ack(struct io_mf_lp_event *event)
-{
-       unsigned long flags;
-       struct pending_event *two = NULL;
-       unsigned long free_it = 0;
-       struct ce_msg_data *ce_msg_data;
-       struct ce_msg_data *pce_msg_data;
-       struct vsp_rsp_data *rsp;
-
-       /* handle current event */
-       if (pending_event_head == NULL) {
-               printk(KERN_ERR "mf.c: stack empty for receiving ack\n");
-               return;
-       }
-
-       switch (event->hp_lp_event.xSubtype) {
-       case 0:     /* CE msg */
-               ce_msg_data = &event->data.ce_msg;
-               if (ce_msg_data->ce_msg[3] != 0x40) {
-                       free_it = 1;
-                       break;
-               }
-               if (ce_msg_data->ce_msg[2] == 0)
-                       break;
-               free_it = 1;
-               pce_msg_data = &pending_event_head->event.data.ce_msg;
-               if (pce_msg_data->completion != NULL) {
-                       ce_msg_comp_hdlr handler =
-                               pce_msg_data->completion->handler;
-                       void *token = pce_msg_data->completion->token;
-
-                       if (handler != NULL)
-                               (*handler)(token, ce_msg_data);
-               }
-               break;
-       case 4: /* allocate */
-       case 5: /* deallocate */
-               if (pending_event_head->hdlr != NULL)
-                       (*pending_event_head->hdlr)((void *)event->hp_lp_event.xCorrelationToken, event->data.alloc.count);
-               free_it = 1;
-               break;
-       case 6:
-               free_it = 1;
-               rsp = (struct vsp_rsp_data *)event->data.vsp_cmd.token;
-               if (rsp == NULL) {
-                       printk(KERN_ERR "mf.c: no rsp\n");
-                       break;
-               }
-               if (rsp->response != NULL)
-                       memcpy(rsp->response, &event->data.vsp_cmd,
-                                       sizeof(event->data.vsp_cmd));
-               complete(&rsp->com);
-               break;
-       }
-
-       /* remove from queue */
-       spin_lock_irqsave(&pending_event_spinlock, flags);
-       if ((pending_event_head != NULL) && (free_it == 1)) {
-               struct pending_event *oldHead = pending_event_head;
-
-               pending_event_head = pending_event_head->next;
-               two = pending_event_head;
-               free_pending_event(oldHead);
-       }
-       spin_unlock_irqrestore(&pending_event_spinlock, flags);
-
-       /* send next waiting event */
-       if (two != NULL)
-               signal_event(NULL);
-}
-
-/*
- * This is the generic event handler we are registering with
- * the Hypervisor.  Ensure the flows are for us, and then
- * parse it enough to know if it is an interrupt or an
- * acknowledge.
- */
-static void hv_handler(struct HvLpEvent *event, struct pt_regs *regs)
-{
-       if ((event != NULL) && (event->xType == HvLpEvent_Type_MachineFac)) {
-               switch(event->xFlags.xFunction) {
-               case HvLpEvent_Function_Ack:
-                       handle_ack((struct io_mf_lp_event *)event);
-                       break;
-               case HvLpEvent_Function_Int:
-                       handle_int((struct io_mf_lp_event *)event);
-                       break;
-               default:
-                       printk(KERN_ERR "mf.c: non ack/int event received\n");
-                       break;
-               }
-       } else
-               printk(KERN_ERR "mf.c: alien event received\n");
-}
-
-/*
- * Global kernel interface to allocate and seed events into the
- * Hypervisor.
- */
-void mf_allocate_lp_events(HvLpIndex target_lp, HvLpEvent_Type type,
-               unsigned size, unsigned count, MFCompleteHandler hdlr,
-               void *user_token)
-{
-       struct pending_event *ev = new_pending_event();
-       int rc;
-
-       if (ev == NULL) {
-               rc = -ENOMEM;
-       } else {
-               ev->event.hp_lp_event.xSubtype = 4;
-               ev->event.hp_lp_event.xCorrelationToken = (u64)user_token;
-               ev->event.hp_lp_event.x.xSubtypeData =
-                       subtype_data('M', 'F', 'M', 'A');
-               ev->event.data.alloc.target_lp = target_lp;
-               ev->event.data.alloc.type = type;
-               ev->event.data.alloc.size = size;
-               ev->event.data.alloc.count = count;
-               ev->hdlr = hdlr;
-               rc = signal_event(ev);
-       }
-       if ((rc != 0) && (hdlr != NULL))
-               (*hdlr)(user_token, rc);
-}
-EXPORT_SYMBOL(mf_allocate_lp_events);
-
-/*
- * Global kernel interface to unseed and deallocate events already in
- * Hypervisor.
- */
-void mf_deallocate_lp_events(HvLpIndex target_lp, HvLpEvent_Type type,
-               unsigned count, MFCompleteHandler hdlr, void *user_token)
-{
-       struct pending_event *ev = new_pending_event();
-       int rc;
-
-       if (ev == NULL)
-               rc = -ENOMEM;
-       else {
-               ev->event.hp_lp_event.xSubtype = 5;
-               ev->event.hp_lp_event.xCorrelationToken = (u64)user_token;
-               ev->event.hp_lp_event.x.xSubtypeData =
-                       subtype_data('M', 'F', 'M', 'D');
-               ev->event.data.alloc.target_lp = target_lp;
-               ev->event.data.alloc.type = type;
-               ev->event.data.alloc.count = count;
-               ev->hdlr = hdlr;
-               rc = signal_event(ev);
-       }
-       if ((rc != 0) && (hdlr != NULL))
-               (*hdlr)(user_token, rc);
-}
-EXPORT_SYMBOL(mf_deallocate_lp_events);
-
-/*
- * Global kernel interface to tell the VSP object in the primary
- * partition to power this partition off.
- */
-void mf_power_off(void)
-{
-       printk(KERN_INFO "mf.c: Down it goes...\n");
-       signal_ce_msg_simple(0x4d, NULL);
-       for (;;)
-               ;
-}
-
-/*
- * Global kernel interface to tell the VSP object in the primary
- * partition to reboot this partition.
- */
-void mf_reboot(void)
-{
-       printk(KERN_INFO "mf.c: Preparing to bounce...\n");
-       signal_ce_msg_simple(0x4e, NULL);
-       for (;;)
-               ;
-}
-
-/*
- * Display a single word SRC onto the VSP control panel.
- */
-void mf_display_src(u32 word)
-{
-       u8 ce[12];
-
-       memset(ce, 0, sizeof(ce));
-       ce[3] = 0x4a;
-       ce[7] = 0x01;
-       ce[8] = word >> 24;
-       ce[9] = word >> 16;
-       ce[10] = word >> 8;
-       ce[11] = word;
-       signal_ce_msg(ce, NULL);
-}
-
-/*
- * Display a single word SRC of the form "PROGXXXX" on the VSP control panel.
- */
-void mf_display_progress(u16 value)
-{
-       u8 ce[12];
-       u8 src[72];
-
-       memcpy(ce, "\x00\x00\x04\x4A\x00\x00\x00\x48\x00\x00\x00\x00", 12);
-       memcpy(src, "\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
-               "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-               "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
-               "\x00\x00\x00\x00PROGxxxx                        ",
-               72);
-       src[6] = value >> 8;
-       src[7] = value & 255;
-       src[44] = "0123456789ABCDEF"[(value >> 12) & 15];
-       src[45] = "0123456789ABCDEF"[(value >> 8) & 15];
-       src[46] = "0123456789ABCDEF"[(value >> 4) & 15];
-       src[47] = "0123456789ABCDEF"[value & 15];
-       dma_and_signal_ce_msg(ce, NULL, src, sizeof(src), 9 * 64 * 1024);
-}
-
-/*
- * Clear the VSP control panel.  Used to "erase" an SRC that was
- * previously displayed.
- */
-void mf_clear_src(void)
-{
-       signal_ce_msg_simple(0x4b, NULL);
-}
-
-/*
- * Initialization code here.
- */
-void mf_init(void)
-{
-       int i;
-
-       /* initialize */
-       spin_lock_init(&pending_event_spinlock);
-       for (i = 0;
-            i < sizeof(pending_event_prealloc) / sizeof(*pending_event_prealloc);
-            ++i)
-               free_pending_event(&pending_event_prealloc[i]);
-       HvLpEvent_registerHandler(HvLpEvent_Type_MachineFac, &hv_handler);
-
-       /* virtual continue ack */
-       signal_ce_msg_simple(0x57, NULL);
-
-       /* initialization complete */
-       printk(KERN_NOTICE "mf.c: iSeries Linux LPAR Machine Facilities "
-                       "initialized\n");
-}
-
-struct rtc_time_data {
-       struct completion com;
-       struct ce_msg_data ce_msg;
-       int rc;
-};
-
-static void get_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
-{
-       struct rtc_time_data *rtc = token;
-
-       memcpy(&rtc->ce_msg, ce_msg, sizeof(rtc->ce_msg));
-       rtc->rc = 0;
-       complete(&rtc->com);
-}
-
-static int rtc_set_tm(int rc, u8 *ce_msg, struct rtc_time *tm)
-{
-       tm->tm_wday = 0;
-       tm->tm_yday = 0;
-       tm->tm_isdst = 0;
-       if (rc) {
-               tm->tm_sec = 0;
-               tm->tm_min = 0;
-               tm->tm_hour = 0;
-               tm->tm_mday = 15;
-               tm->tm_mon = 5;
-               tm->tm_year = 52;
-               return rc;
-       }
-
-       if ((ce_msg[2] == 0xa9) ||
-           (ce_msg[2] == 0xaf)) {
-               /* TOD clock is not set */
-               tm->tm_sec = 1;
-               tm->tm_min = 1;
-               tm->tm_hour = 1;
-               tm->tm_mday = 10;
-               tm->tm_mon = 8;
-               tm->tm_year = 71;
-               mf_set_rtc(tm);
-       }
-       {
-               u8 year = ce_msg[5];
-               u8 sec = ce_msg[6];
-               u8 min = ce_msg[7];
-               u8 hour = ce_msg[8];
-               u8 day = ce_msg[10];
-               u8 mon = ce_msg[11];
-
-               BCD_TO_BIN(sec);
-               BCD_TO_BIN(min);
-               BCD_TO_BIN(hour);
-               BCD_TO_BIN(day);
-               BCD_TO_BIN(mon);
-               BCD_TO_BIN(year);
-
-               if (year <= 69)
-                       year += 100;
-
-               tm->tm_sec = sec;
-               tm->tm_min = min;
-               tm->tm_hour = hour;
-               tm->tm_mday = day;
-               tm->tm_mon = mon;
-               tm->tm_year = year;
-       }
-
-       return 0;
-}
-
-int mf_get_rtc(struct rtc_time *tm)
-{
-       struct ce_msg_comp_data ce_complete;
-       struct rtc_time_data rtc_data;
-       int rc;
-
-       memset(&ce_complete, 0, sizeof(ce_complete));
-       memset(&rtc_data, 0, sizeof(rtc_data));
-       init_completion(&rtc_data.com);
-       ce_complete.handler = &get_rtc_time_complete;
-       ce_complete.token = &rtc_data;
-       rc = signal_ce_msg_simple(0x40, &ce_complete);
-       if (rc)
-               return rc;
-       wait_for_completion(&rtc_data.com);
-       return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
-}
-
-struct boot_rtc_time_data {
-       int busy;
-       struct ce_msg_data ce_msg;
-       int rc;
-};
-
-static void get_boot_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
-{
-       struct boot_rtc_time_data *rtc = token;
-
-       memcpy(&rtc->ce_msg, ce_msg, sizeof(rtc->ce_msg));
-       rtc->rc = 0;
-       rtc->busy = 0;
-}
-
-int mf_get_boot_rtc(struct rtc_time *tm)
-{
-       struct ce_msg_comp_data ce_complete;
-       struct boot_rtc_time_data rtc_data;
-       int rc;
-
-       memset(&ce_complete, 0, sizeof(ce_complete));
-       memset(&rtc_data, 0, sizeof(rtc_data));
-       rtc_data.busy = 1;
-       ce_complete.handler = &get_boot_rtc_time_complete;
-       ce_complete.token = &rtc_data;
-       rc = signal_ce_msg_simple(0x40, &ce_complete);
-       if (rc)
-               return rc;
-       /* We need to poll here as we are not yet taking interrupts */
-       while (rtc_data.busy) {
-               if (hvlpevent_is_pending())
-                       process_hvlpevents(NULL);
-       }
-       return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
-}
-
-int mf_set_rtc(struct rtc_time *tm)
-{
-       char ce_time[12];
-       u8 day, mon, hour, min, sec, y1, y2;
-       unsigned year;
-
-       year = 1900 + tm->tm_year;
-       y1 = year / 100;
-       y2 = year % 100;
-
-       sec = tm->tm_sec;
-       min = tm->tm_min;
-       hour = tm->tm_hour;
-       day = tm->tm_mday;
-       mon = tm->tm_mon + 1;
-
-       BIN_TO_BCD(sec);
-       BIN_TO_BCD(min);
-       BIN_TO_BCD(hour);
-       BIN_TO_BCD(mon);
-       BIN_TO_BCD(day);
-       BIN_TO_BCD(y1);
-       BIN_TO_BCD(y2);
-
-       memset(ce_time, 0, sizeof(ce_time));
-       ce_time[3] = 0x41;
-       ce_time[4] = y1;
-       ce_time[5] = y2;
-       ce_time[6] = sec;
-       ce_time[7] = min;
-       ce_time[8] = hour;
-       ce_time[10] = day;
-       ce_time[11] = mon;
-
-       return signal_ce_msg(ce_time, NULL);
-}
-
-#ifdef CONFIG_PROC_FS
-
-static int proc_mf_dump_cmdline(char *page, char **start, off_t off,
-               int count, int *eof, void *data)
-{
-       int len;
-       char *p;
-       struct vsp_cmd_data vsp_cmd;
-       int rc;
-       dma_addr_t dma_addr;
-
-       /* The HV appears to return no more than 256 bytes of command line */
-       if (off >= 256)
-               return 0;
-       if ((off + count) > 256)
-               count = 256 - off;
-
-       dma_addr = dma_map_single(iSeries_vio_dev, page, off + count,
-                       DMA_FROM_DEVICE);
-       if (dma_mapping_error(dma_addr))
-               return -ENOMEM;
-       memset(page, 0, off + count);
-       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
-       vsp_cmd.cmd = 33;
-       vsp_cmd.sub_data.kern.token = dma_addr;
-       vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
-       vsp_cmd.sub_data.kern.side = (u64)data;
-       vsp_cmd.sub_data.kern.length = off + count;
-       mb();
-       rc = signal_vsp_instruction(&vsp_cmd);
-       dma_unmap_single(iSeries_vio_dev, dma_addr, off + count,
-                       DMA_FROM_DEVICE);
-       if (rc)
-               return rc;
-       if (vsp_cmd.result_code != 0)
-               return -ENOMEM;
-       p = page;
-       len = 0;
-       while (len < (off + count)) {
-               if ((*p == '\0') || (*p == '\n')) {
-                       if (*p == '\0')
-                               *p = '\n';
-                       p++;
-                       len++;
-                       *eof = 1;
-                       break;
-               }
-               p++;
-               len++;
-       }
-
-       if (len < off) {
-               *eof = 1;
-               len = 0;
-       }
-       return len;
-}
-
-#if 0
-static int mf_getVmlinuxChunk(char *buffer, int *size, int offset, u64 side)
-{
-       struct vsp_cmd_data vsp_cmd;
-       int rc;
-       int len = *size;
-       dma_addr_t dma_addr;
-
-       dma_addr = dma_map_single(iSeries_vio_dev, buffer, len,
-                       DMA_FROM_DEVICE);
-       memset(buffer, 0, len);
-       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
-       vsp_cmd.cmd = 32;
-       vsp_cmd.sub_data.kern.token = dma_addr;
-       vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
-       vsp_cmd.sub_data.kern.side = side;
-       vsp_cmd.sub_data.kern.offset = offset;
-       vsp_cmd.sub_data.kern.length = len;
-       mb();
-       rc = signal_vsp_instruction(&vsp_cmd);
-       if (rc == 0) {
-               if (vsp_cmd.result_code == 0)
-                       *size = vsp_cmd.sub_data.length_out;
-               else
-                       rc = -ENOMEM;
-       }
-
-       dma_unmap_single(iSeries_vio_dev, dma_addr, len, DMA_FROM_DEVICE);
-
-       return rc;
-}
-
-static int proc_mf_dump_vmlinux(char *page, char **start, off_t off,
-               int count, int *eof, void *data)
-{
-       int sizeToGet = count;
-
-       if (!capable(CAP_SYS_ADMIN))
-               return -EACCES;
-
-       if (mf_getVmlinuxChunk(page, &sizeToGet, off, (u64)data) == 0) {
-               if (sizeToGet != 0) {
-                       *start = page + off;
-                       return sizeToGet;
-               }
-               *eof = 1;
-               return 0;
-       }
-       *eof = 1;
-       return 0;
-}
-#endif
-
-static int proc_mf_dump_side(char *page, char **start, off_t off,
-               int count, int *eof, void *data)
-{
-       int len;
-       char mf_current_side = ' ';
-       struct vsp_cmd_data vsp_cmd;
-
-       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
-       vsp_cmd.cmd = 2;
-       vsp_cmd.sub_data.ipl_type = 0;
-       mb();
-
-       if (signal_vsp_instruction(&vsp_cmd) == 0) {
-               if (vsp_cmd.result_code == 0) {
-                       switch (vsp_cmd.sub_data.ipl_type) {
-                       case 0: mf_current_side = 'A';
-                               break;
-                       case 1: mf_current_side = 'B';
-                               break;
-                       case 2: mf_current_side = 'C';
-                               break;
-                       default:        mf_current_side = 'D';
-                               break;
-                       }
-               }
-       }
-
-       len = sprintf(page, "%c\n", mf_current_side);
-
-       if (len <= (off + count))
-               *eof = 1;
-       *start = page + off;
-       len -= off;
-       if (len > count)
-               len = count;
-       if (len < 0)
-               len = 0;
-       return len;
-}
-
-static int proc_mf_change_side(struct file *file, const char __user *buffer,
-               unsigned long count, void *data)
-{
-       char side;
-       u64 newSide;
-       struct vsp_cmd_data vsp_cmd;
-
-       if (!capable(CAP_SYS_ADMIN))
-               return -EACCES;
-
-       if (count == 0)
-               return 0;
-
-       if (get_user(side, buffer))
-               return -EFAULT;
-
-       switch (side) {
-       case 'A':       newSide = 0;
-                       break;
-       case 'B':       newSide = 1;
-                       break;
-       case 'C':       newSide = 2;
-                       break;
-       case 'D':       newSide = 3;
-                       break;
-       default:
-               printk(KERN_ERR "mf_proc.c: proc_mf_change_side: invalid side\n");
-               return -EINVAL;
-       }
-
-       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
-       vsp_cmd.sub_data.ipl_type = newSide;
-       vsp_cmd.cmd = 10;
-
-       (void)signal_vsp_instruction(&vsp_cmd);
-
-       return count;
-}
-
-#if 0
-static void mf_getSrcHistory(char *buffer, int size)
-{
-       struct IplTypeReturnStuff return_stuff;
-       struct pending_event *ev = new_pending_event();
-       int rc = 0;
-       char *pages[4];
-
-       pages[0] = kmalloc(4096, GFP_ATOMIC);
-       pages[1] = kmalloc(4096, GFP_ATOMIC);
-       pages[2] = kmalloc(4096, GFP_ATOMIC);
-       pages[3] = kmalloc(4096, GFP_ATOMIC);
-       if ((ev == NULL) || (pages[0] == NULL) || (pages[1] == NULL)
-                        || (pages[2] == NULL) || (pages[3] == NULL))
-               return -ENOMEM;
-
-       return_stuff.xType = 0;
-       return_stuff.xRc = 0;
-       return_stuff.xDone = 0;
-       ev->event.hp_lp_event.xSubtype = 6;
-       ev->event.hp_lp_event.x.xSubtypeData =
-               subtype_data('M', 'F', 'V', 'I');
-       ev->event.data.vsp_cmd.xEvent = &return_stuff;
-       ev->event.data.vsp_cmd.cmd = 4;
-       ev->event.data.vsp_cmd.lp_index = HvLpConfig_getLpIndex();
-       ev->event.data.vsp_cmd.result_code = 0xFF;
-       ev->event.data.vsp_cmd.reserved = 0;
-       ev->event.data.vsp_cmd.sub_data.page[0] = ISERIES_HV_ADDR(pages[0]);
-       ev->event.data.vsp_cmd.sub_data.page[1] = ISERIES_HV_ADDR(pages[1]);
-       ev->event.data.vsp_cmd.sub_data.page[2] = ISERIES_HV_ADDR(pages[2]);
-       ev->event.data.vsp_cmd.sub_data.page[3] = ISERIES_HV_ADDR(pages[3]);
-       mb();
-       if (signal_event(ev) != 0)
-               return;
-
-       while (return_stuff.xDone != 1)
-               udelay(10);
-       if (return_stuff.xRc == 0)
-               memcpy(buffer, pages[0], size);
-       kfree(pages[0]);
-       kfree(pages[1]);
-       kfree(pages[2]);
-       kfree(pages[3]);
-}
-#endif
-
-static int proc_mf_dump_src(char *page, char **start, off_t off,
-               int count, int *eof, void *data)
-{
-#if 0
-       int len;
-
-       mf_getSrcHistory(page, count);
-       len = count;
-       len -= off;
-       if (len < count) {
-               *eof = 1;
-               if (len <= 0)
-                       return 0;
-       } else
-               len = count;
-       *start = page + off;
-       return len;
-#else
-       return 0;
-#endif
-}
-
-static int proc_mf_change_src(struct file *file, const char __user *buffer,
-               unsigned long count, void *data)
-{
-       char stkbuf[10];
-
-       if (!capable(CAP_SYS_ADMIN))
-               return -EACCES;
-
-       if ((count < 4) && (count != 1)) {
-               printk(KERN_ERR "mf_proc: invalid src\n");
-               return -EINVAL;
-       }
-
-       if (count > (sizeof(stkbuf) - 1))
-               count = sizeof(stkbuf) - 1;
-       if (copy_from_user(stkbuf, buffer, count))
-               return -EFAULT;
-
-       if ((count == 1) && (*stkbuf == '\0'))
-               mf_clear_src();
-       else
-               mf_display_src(*(u32 *)stkbuf);
-
-       return count;
-}
-
-static int proc_mf_change_cmdline(struct file *file, const char __user *buffer,
-               unsigned long count, void *data)
-{
-       struct vsp_cmd_data vsp_cmd;
-       dma_addr_t dma_addr;
-       char *page;
-       int ret = -EACCES;
-
-       if (!capable(CAP_SYS_ADMIN))
-               goto out;
-
-       dma_addr = 0;
-       page = dma_alloc_coherent(iSeries_vio_dev, count, &dma_addr,
-                       GFP_ATOMIC);
-       ret = -ENOMEM;
-       if (page == NULL)
-               goto out;
-
-       ret = -EFAULT;
-       if (copy_from_user(page, buffer, count))
-               goto out_free;
-
-       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
-       vsp_cmd.cmd = 31;
-       vsp_cmd.sub_data.kern.token = dma_addr;
-       vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
-       vsp_cmd.sub_data.kern.side = (u64)data;
-       vsp_cmd.sub_data.kern.length = count;
-       mb();
-       (void)signal_vsp_instruction(&vsp_cmd);
-       ret = count;
-
-out_free:
-       dma_free_coherent(iSeries_vio_dev, count, page, dma_addr);
-out:
-       return ret;
-}
-
-static ssize_t proc_mf_change_vmlinux(struct file *file,
-                                     const char __user *buf,
-                                     size_t count, loff_t *ppos)
-{
-       struct proc_dir_entry *dp = PDE(file->f_dentry->d_inode);
-       ssize_t rc;
-       dma_addr_t dma_addr;
-       char *page;
-       struct vsp_cmd_data vsp_cmd;
-
-       rc = -EACCES;
-       if (!capable(CAP_SYS_ADMIN))
-               goto out;
-
-       dma_addr = 0;
-       page = dma_alloc_coherent(iSeries_vio_dev, count, &dma_addr,
-                       GFP_ATOMIC);
-       rc = -ENOMEM;
-       if (page == NULL) {
-               printk(KERN_ERR "mf.c: couldn't allocate memory to set vmlinux chunk\n");
-               goto out;
-       }
-       rc = -EFAULT;
-       if (copy_from_user(page, buf, count))
-               goto out_free;
-
-       memset(&vsp_cmd, 0, sizeof(vsp_cmd));
-       vsp_cmd.cmd = 30;
-       vsp_cmd.sub_data.kern.token = dma_addr;
-       vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
-       vsp_cmd.sub_data.kern.side = (u64)dp->data;
-       vsp_cmd.sub_data.kern.offset = *ppos;
-       vsp_cmd.sub_data.kern.length = count;
-       mb();
-       rc = signal_vsp_instruction(&vsp_cmd);
-       if (rc)
-               goto out_free;
-       rc = -ENOMEM;
-       if (vsp_cmd.result_code != 0)
-               goto out_free;
-
-       *ppos += count;
-       rc = count;
-out_free:
-       dma_free_coherent(iSeries_vio_dev, count, page, dma_addr);
-out:
-       return rc;
-}
-
-static struct file_operations proc_vmlinux_operations = {
-       .write          = proc_mf_change_vmlinux,
-};
-
-static int __init mf_proc_init(void)
-{
-       struct proc_dir_entry *mf_proc_root;
-       struct proc_dir_entry *ent;
-       struct proc_dir_entry *mf;
-       char name[2];
-       int i;
-
-       mf_proc_root = proc_mkdir("iSeries/mf", NULL);
-       if (!mf_proc_root)
-               return 1;
-
-       name[1] = '\0';
-       for (i = 0; i < 4; i++) {
-               name[0] = 'A' + i;
-               mf = proc_mkdir(name, mf_proc_root);
-               if (!mf)
-                       return 1;
-
-               ent = create_proc_entry("cmdline", S_IFREG|S_IRUSR|S_IWUSR, mf);
-               if (!ent)
-                       return 1;
-               ent->nlink = 1;
-               ent->data = (void *)(long)i;
-               ent->read_proc = proc_mf_dump_cmdline;
-               ent->write_proc = proc_mf_change_cmdline;
-
-               if (i == 3)     /* no vmlinux entry for 'D' */
-                       continue;
-
-               ent = create_proc_entry("vmlinux", S_IFREG|S_IWUSR, mf);
-               if (!ent)
-                       return 1;
-               ent->nlink = 1;
-               ent->data = (void *)(long)i;
-               ent->proc_fops = &proc_vmlinux_operations;
-       }
-
-       ent = create_proc_entry("side", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root);
-       if (!ent)
-               return 1;
-       ent->nlink = 1;
-       ent->data = (void *)0;
-       ent->read_proc = proc_mf_dump_side;
-       ent->write_proc = proc_mf_change_side;
-
-       ent = create_proc_entry("src", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root);
-       if (!ent)
-               return 1;
-       ent->nlink = 1;
-       ent->data = (void *)0;
-       ent->read_proc = proc_mf_dump_src;
-       ent->write_proc = proc_mf_change_src;
-
-       return 0;
-}
-
-__initcall(mf_proc_init);
-
-#endif /* CONFIG_PROC_FS */
index 6ff52bc61325bc500c243ded44c6076415e663e6..88ae13f81c46b78c026563e685106daa1b5e873b 100644 (file)
 #include <asm/time.h>
 #include <asm/rtas.h>
 
-#include <asm/iSeries/mf.h>
 #include <asm/machdep.h>
 
-extern int piranha_simulator;
-
 /*
  *     We sponge a minor off of the misc major. No need slurping
  *     up another valuable major dev number for this. If you add
@@ -265,40 +262,6 @@ static int rtc_read_proc(char *page, char **start, off_t off,
         return len;
 }
 
-#ifdef CONFIG_PPC_ISERIES
-/*
- * Get the RTC from the virtual service processor
- * This requires flowing LpEvents to the primary partition
- */
-void iSeries_get_rtc_time(struct rtc_time *rtc_tm)
-{
-       if (piranha_simulator)
-               return;
-
-       mf_get_rtc(rtc_tm);
-       rtc_tm->tm_mon--;
-}
-
-/*
- * Set the RTC in the virtual service processor
- * This requires flowing LpEvents to the primary partition
- */
-int iSeries_set_rtc_time(struct rtc_time *tm)
-{
-       mf_set_rtc(tm);
-       return 0;
-}
-
-void iSeries_get_boot_time(struct rtc_time *tm)
-{
-       if ( piranha_simulator )
-               return;
-
-       mf_get_boot_rtc(tm);
-       tm->tm_mon  -= 1;
-}
-#endif
-
 #ifdef CONFIG_PPC_RTAS
 #define MAX_RTC_WAIT 5000      /* 5 sec */
 #define RTAS_CLOCK_BUSY (-2)