1 /*
2 * Copyright (C) 2001 Troy D. Armstrong IBM Corporation
3 * Copyright (C) 2004-2005 Stephen Rothwell IBM Corporation
4 *
5 * This modules exists as an interface between a Linux secondary partition
6 * running on an iSeries and the primary partition's Virtual Service
7 * Processor (VSP) object. The VSP has final authority over powering on/off
8 * all partitions in the iSeries. It also provides miscellaneous low-level
9 * machine facility type operations.
10 *
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 */
26
27 #include <linux/types.h>
28 #include <linux/errno.h>
29 #include <linux/kernel.h>
30 #include <linux/init.h>
31 #include <linux/completion.h>
32 #include <linux/delay.h>
33 #include <linux/dma-mapping.h>
34 #include <linux/bcd.h>
35 #include <linux/rtc.h>
36
37 #include <asm/time.h>
38 #include <asm/uaccess.h>
39 #include <asm/paca.h>
40 #include <asm/abs_addr.h>
41 #include <asm/firmware.h>
42 #include <asm/iseries/mf.h>
43 #include <asm/iseries/hv_lp_config.h>
44 #include <asm/iseries/hv_lp_event.h>
45 #include <asm/iseries/it_lp_queue.h>
46
47 #include "setup.h"
48
49 static int mf_initialized;
50
51 /*
52 * This is the structure layout for the Machine Facilites LPAR event
53 * flows.
54 */
55 struct vsp_cmd_data {
56 u64 token;
57 u16 cmd;
58 HvLpIndex lp_index;
59 u8 result_code;
60 u32 reserved;
61 union {
62 u64 state; /* GetStateOut */
63 u64 ipl_type; /* GetIplTypeOut, Function02SelectIplTypeIn */
64 u64 ipl_mode; /* GetIplModeOut, Function02SelectIplModeIn */
65 u64 page[4]; /* GetSrcHistoryIn */
66 u64 flag; /* GetAutoIplWhenPrimaryIplsOut,
67 SetAutoIplWhenPrimaryIplsIn,
68 WhiteButtonPowerOffIn,
69 Function08FastPowerOffIn,
70 IsSpcnRackPowerIncompleteOut */
71 struct {
72 u64 token;
73 u64 address_type;
74 u64 side;
75 u32 length;
76 u32 offset;
77 } kern; /* SetKernelImageIn, GetKernelImageIn,
78 SetKernelCmdLineIn, GetKernelCmdLineIn */
79 u32 length_out; /* GetKernelImageOut, GetKernelCmdLineOut */
80 u8 reserved[80];
81 } sub_data;
82 };
83
84 struct vsp_rsp_data {
85 struct completion com;
86 struct vsp_cmd_data *response;
87 };
88
89 struct alloc_data {
90 u16 size;
91 u16 type;
92 u32 count;
93 u16 reserved1;
94 u8 reserved2;
95 HvLpIndex target_lp;
96 };
97
98 struct ce_msg_data;
99
100 typedef void (*ce_msg_comp_hdlr)(void *token, struct ce_msg_data *vsp_cmd_rsp);
101
102 struct ce_msg_comp_data {
103 ce_msg_comp_hdlr handler;
104 void *token;
105 };
106
107 struct ce_msg_data {
108 u8 ce_msg[12];
109 char reserved[4];
110 struct ce_msg_comp_data *completion;
111 };
112
113 struct io_mf_lp_event {
114 struct HvLpEvent hp_lp_event;
115 u16 subtype_result_code;
116 u16 reserved1;
117 u32 reserved2;
118 union {
119 struct alloc_data alloc;
120 struct ce_msg_data ce_msg;
121 struct vsp_cmd_data vsp_cmd;
122 } data;
123 };
124
125 #define subtype_data(a, b, c, d) \
126 (((a) << 24) + ((b) << 16) + ((c) << 8) + (d))
127
128 /*
129 * All outgoing event traffic is kept on a FIFO queue. The first
130 * pointer points to the one that is outstanding, and all new
131 * requests get stuck on the end. Also, we keep a certain number of
132 * preallocated pending events so that we can operate very early in
133 * the boot up sequence (before kmalloc is ready).
134 */
135 struct pending_event {
136 struct pending_event *next;
137 struct io_mf_lp_event event;
138 MFCompleteHandler hdlr;
139 char dma_data[72];
140 unsigned dma_data_length;
141 unsigned remote_address;
142 };
143 static spinlock_t pending_event_spinlock;
144 static struct pending_event *pending_event_head;
145 static struct pending_event *pending_event_tail;
146 static struct pending_event *pending_event_avail;
147 #define PENDING_EVENT_PREALLOC_LEN 16
148 static struct pending_event pending_event_prealloc[PENDING_EVENT_PREALLOC_LEN];
149
150 /*
151 * Put a pending event onto the available queue, so it can get reused.
152 * Attention! You must have the pending_event_spinlock before calling!
153 */
free_pending_event(struct pending_event * ev)154 static void free_pending_event(struct pending_event *ev)
155 {
156 if (ev != NULL) {
157 ev->next = pending_event_avail;
158 pending_event_avail = ev;
159 }
160 }
161
162 /*
163 * Enqueue the outbound event onto the stack. If the queue was
164 * empty to begin with, we must also issue it via the Hypervisor
165 * interface. There is a section of code below that will touch
166 * the first stack pointer without the protection of the pending_event_spinlock.
167 * This is OK, because we know that nobody else will be modifying
168 * the first pointer when we do this.
169 */
signal_event(struct pending_event * ev)170 static int signal_event(struct pending_event *ev)
171 {
172 int rc = 0;
173 unsigned long flags;
174 int go = 1;
175 struct pending_event *ev1;
176 HvLpEvent_Rc hv_rc;
177
178 /* enqueue the event */
179 if (ev != NULL) {
180 ev->next = NULL;
181 spin_lock_irqsave(&pending_event_spinlock, flags);
182 if (pending_event_head == NULL)
183 pending_event_head = ev;
184 else {
185 go = 0;
186 pending_event_tail->next = ev;
187 }
188 pending_event_tail = ev;
189 spin_unlock_irqrestore(&pending_event_spinlock, flags);
190 }
191
192 /* send the event */
193 while (go) {
194 go = 0;
195
196 /* any DMA data to send beforehand? */
197 if (pending_event_head->dma_data_length > 0)
198 HvCallEvent_dmaToSp(pending_event_head->dma_data,
199 pending_event_head->remote_address,
200 pending_event_head->dma_data_length,
201 HvLpDma_Direction_LocalToRemote);
202
203 hv_rc = HvCallEvent_signalLpEvent(
204 &pending_event_head->event.hp_lp_event);
205 if (hv_rc != HvLpEvent_Rc_Good) {
206 printk(KERN_ERR "mf.c: HvCallEvent_signalLpEvent() "
207 "failed with %d\n", (int)hv_rc);
208
209 spin_lock_irqsave(&pending_event_spinlock, flags);
210 ev1 = pending_event_head;
211 pending_event_head = pending_event_head->next;
212 if (pending_event_head != NULL)
213 go = 1;
214 spin_unlock_irqrestore(&pending_event_spinlock, flags);
215
216 if (ev1 == ev)
217 rc = -EIO;
218 else if (ev1->hdlr != NULL)
219 (*ev1->hdlr)((void *)ev1->event.hp_lp_event.xCorrelationToken, -EIO);
220
221 spin_lock_irqsave(&pending_event_spinlock, flags);
222 free_pending_event(ev1);
223 spin_unlock_irqrestore(&pending_event_spinlock, flags);
224 }
225 }
226
227 return rc;
228 }
229
230 /*
231 * Allocate a new pending_event structure, and initialize it.
232 */
new_pending_event(void)233 static struct pending_event *new_pending_event(void)
234 {
235 struct pending_event *ev = NULL;
236 HvLpIndex primary_lp = HvLpConfig_getPrimaryLpIndex();
237 unsigned long flags;
238 struct HvLpEvent *hev;
239
240 spin_lock_irqsave(&pending_event_spinlock, flags);
241 if (pending_event_avail != NULL) {
242 ev = pending_event_avail;
243 pending_event_avail = pending_event_avail->next;
244 }
245 spin_unlock_irqrestore(&pending_event_spinlock, flags);
246 if (ev == NULL) {
247 ev = kmalloc(sizeof(struct pending_event), GFP_ATOMIC);
248 if (ev == NULL) {
249 printk(KERN_ERR "mf.c: unable to kmalloc %ld bytes\n",
250 sizeof(struct pending_event));
251 return NULL;
252 }
253 }
254 memset(ev, 0, sizeof(struct pending_event));
255 hev = &ev->event.hp_lp_event;
256 hev->flags = HV_LP_EVENT_VALID | HV_LP_EVENT_DO_ACK | HV_LP_EVENT_INT;
257 hev->xType = HvLpEvent_Type_MachineFac;
258 hev->xSourceLp = HvLpConfig_getLpIndex();
259 hev->xTargetLp = primary_lp;
260 hev->xSizeMinus1 = sizeof(ev->event) - 1;
261 hev->xRc = HvLpEvent_Rc_Good;
262 hev->xSourceInstanceId = HvCallEvent_getSourceLpInstanceId(primary_lp,
263 HvLpEvent_Type_MachineFac);
264 hev->xTargetInstanceId = HvCallEvent_getTargetLpInstanceId(primary_lp,
265 HvLpEvent_Type_MachineFac);
266
267 return ev;
268 }
269
signal_vsp_instruction(struct vsp_cmd_data * vsp_cmd)270 static int signal_vsp_instruction(struct vsp_cmd_data *vsp_cmd)
271 {
272 struct pending_event *ev = new_pending_event();
273 int rc;
274 struct vsp_rsp_data response;
275
276 if (ev == NULL)
277 return -ENOMEM;
278
279 init_completion(&response.com);
280 response.response = vsp_cmd;
281 ev->event.hp_lp_event.xSubtype = 6;
282 ev->event.hp_lp_event.x.xSubtypeData =
283 subtype_data('M', 'F', 'V', 'I');
284 ev->event.data.vsp_cmd.token = (u64)&response;
285 ev->event.data.vsp_cmd.cmd = vsp_cmd->cmd;
286 ev->event.data.vsp_cmd.lp_index = HvLpConfig_getLpIndex();
287 ev->event.data.vsp_cmd.result_code = 0xFF;
288 ev->event.data.vsp_cmd.reserved = 0;
289 memcpy(&(ev->event.data.vsp_cmd.sub_data),
290 &(vsp_cmd->sub_data), sizeof(vsp_cmd->sub_data));
291 mb();
292
293 rc = signal_event(ev);
294 if (rc == 0)
295 wait_for_completion(&response.com);
296 return rc;
297 }
298
299
300 /*
301 * Send a 12-byte CE message to the primary partition VSP object
302 */
signal_ce_msg(char * ce_msg,struct ce_msg_comp_data * completion)303 static int signal_ce_msg(char *ce_msg, struct ce_msg_comp_data *completion)
304 {
305 struct pending_event *ev = new_pending_event();
306
307 if (ev == NULL)
308 return -ENOMEM;
309
310 ev->event.hp_lp_event.xSubtype = 0;
311 ev->event.hp_lp_event.x.xSubtypeData =
312 subtype_data('M', 'F', 'C', 'E');
313 memcpy(ev->event.data.ce_msg.ce_msg, ce_msg, 12);
314 ev->event.data.ce_msg.completion = completion;
315 return signal_event(ev);
316 }
317
318 /*
319 * Send a 12-byte CE message (with no data) to the primary partition VSP object
320 */
signal_ce_msg_simple(u8 ce_op,struct ce_msg_comp_data * completion)321 static int signal_ce_msg_simple(u8 ce_op, struct ce_msg_comp_data *completion)
322 {
323 u8 ce_msg[12];
324
325 memset(ce_msg, 0, sizeof(ce_msg));
326 ce_msg[3] = ce_op;
327 return signal_ce_msg(ce_msg, completion);
328 }
329
330 /*
331 * Send a 12-byte CE message and DMA data to the primary partition VSP object
332 */
dma_and_signal_ce_msg(char * ce_msg,struct ce_msg_comp_data * completion,void * dma_data,unsigned dma_data_length,unsigned remote_address)333 static int dma_and_signal_ce_msg(char *ce_msg,
334 struct ce_msg_comp_data *completion, void *dma_data,
335 unsigned dma_data_length, unsigned remote_address)
336 {
337 struct pending_event *ev = new_pending_event();
338
339 if (ev == NULL)
340 return -ENOMEM;
341
342 ev->event.hp_lp_event.xSubtype = 0;
343 ev->event.hp_lp_event.x.xSubtypeData =
344 subtype_data('M', 'F', 'C', 'E');
345 memcpy(ev->event.data.ce_msg.ce_msg, ce_msg, 12);
346 ev->event.data.ce_msg.completion = completion;
347 memcpy(ev->dma_data, dma_data, dma_data_length);
348 ev->dma_data_length = dma_data_length;
349 ev->remote_address = remote_address;
350 return signal_event(ev);
351 }
352
353 /*
354 * Initiate a nice (hopefully) shutdown of Linux. We simply are
355 * going to try and send the init process a SIGINT signal. If
356 * this fails (why?), we'll simply force it off in a not-so-nice
357 * manner.
358 */
shutdown(void)359 static int shutdown(void)
360 {
361 int rc = kill_cad_pid(SIGINT, 1);
362
363 if (rc) {
364 printk(KERN_ALERT "mf.c: SIGINT to init failed (%d), "
365 "hard shutdown commencing\n", rc);
366 mf_power_off();
367 } else
368 printk(KERN_INFO "mf.c: init has been successfully notified "
369 "to proceed with shutdown\n");
370 return rc;
371 }
372
373 /*
374 * The primary partition VSP object is sending us a new
375 * event flow. Handle it...
376 */
handle_int(struct io_mf_lp_event * event)377 static void handle_int(struct io_mf_lp_event *event)
378 {
379 struct ce_msg_data *ce_msg_data;
380 struct ce_msg_data *pce_msg_data;
381 unsigned long flags;
382 struct pending_event *pev;
383
384 /* ack the interrupt */
385 event->hp_lp_event.xRc = HvLpEvent_Rc_Good;
386 HvCallEvent_ackLpEvent(&event->hp_lp_event);
387
388 /* process interrupt */
389 switch (event->hp_lp_event.xSubtype) {
390 case 0: /* CE message */
391 ce_msg_data = &event->data.ce_msg;
392 switch (ce_msg_data->ce_msg[3]) {
393 case 0x5B: /* power control notification */
394 if ((ce_msg_data->ce_msg[5] & 0x20) != 0) {
395 printk(KERN_INFO "mf.c: Commencing partition shutdown\n");
396 if (shutdown() == 0)
397 signal_ce_msg_simple(0xDB, NULL);
398 }
399 break;
400 case 0xC0: /* get time */
401 spin_lock_irqsave(&pending_event_spinlock, flags);
402 pev = pending_event_head;
403 if (pev != NULL)
404 pending_event_head = pending_event_head->next;
405 spin_unlock_irqrestore(&pending_event_spinlock, flags);
406 if (pev == NULL)
407 break;
408 pce_msg_data = &pev->event.data.ce_msg;
409 if (pce_msg_data->ce_msg[3] != 0x40)
410 break;
411 if (pce_msg_data->completion != NULL) {
412 ce_msg_comp_hdlr handler =
413 pce_msg_data->completion->handler;
414 void *token = pce_msg_data->completion->token;
415
416 if (handler != NULL)
417 (*handler)(token, ce_msg_data);
418 }
419 spin_lock_irqsave(&pending_event_spinlock, flags);
420 free_pending_event(pev);
421 spin_unlock_irqrestore(&pending_event_spinlock, flags);
422 /* send next waiting event */
423 if (pending_event_head != NULL)
424 signal_event(NULL);
425 break;
426 }
427 break;
428 case 1: /* IT sys shutdown */
429 printk(KERN_INFO "mf.c: Commencing system shutdown\n");
430 shutdown();
431 break;
432 }
433 }
434
435 /*
436 * The primary partition VSP object is acknowledging the receipt
437 * of a flow we sent to them. If there are other flows queued
438 * up, we must send another one now...
439 */
handle_ack(struct io_mf_lp_event * event)440 static void handle_ack(struct io_mf_lp_event *event)
441 {
442 unsigned long flags;
443 struct pending_event *two = NULL;
444 unsigned long free_it = 0;
445 struct ce_msg_data *ce_msg_data;
446 struct ce_msg_data *pce_msg_data;
447 struct vsp_rsp_data *rsp;
448
449 /* handle current event */
450 if (pending_event_head == NULL) {
451 printk(KERN_ERR "mf.c: stack empty for receiving ack\n");
452 return;
453 }
454
455 switch (event->hp_lp_event.xSubtype) {
456 case 0: /* CE msg */
457 ce_msg_data = &event->data.ce_msg;
458 if (ce_msg_data->ce_msg[3] != 0x40) {
459 free_it = 1;
460 break;
461 }
462 if (ce_msg_data->ce_msg[2] == 0)
463 break;
464 free_it = 1;
465 pce_msg_data = &pending_event_head->event.data.ce_msg;
466 if (pce_msg_data->completion != NULL) {
467 ce_msg_comp_hdlr handler =
468 pce_msg_data->completion->handler;
469 void *token = pce_msg_data->completion->token;
470
471 if (handler != NULL)
472 (*handler)(token, ce_msg_data);
473 }
474 break;
475 case 4: /* allocate */
476 case 5: /* deallocate */
477 if (pending_event_head->hdlr != NULL)
478 (*pending_event_head->hdlr)((void *)event->hp_lp_event.xCorrelationToken, event->data.alloc.count);
479 free_it = 1;
480 break;
481 case 6:
482 free_it = 1;
483 rsp = (struct vsp_rsp_data *)event->data.vsp_cmd.token;
484 if (rsp == NULL) {
485 printk(KERN_ERR "mf.c: no rsp\n");
486 break;
487 }
488 if (rsp->response != NULL)
489 memcpy(rsp->response, &event->data.vsp_cmd,
490 sizeof(event->data.vsp_cmd));
491 complete(&rsp->com);
492 break;
493 }
494
495 /* remove from queue */
496 spin_lock_irqsave(&pending_event_spinlock, flags);
497 if ((pending_event_head != NULL) && (free_it == 1)) {
498 struct pending_event *oldHead = pending_event_head;
499
500 pending_event_head = pending_event_head->next;
501 two = pending_event_head;
502 free_pending_event(oldHead);
503 }
504 spin_unlock_irqrestore(&pending_event_spinlock, flags);
505
506 /* send next waiting event */
507 if (two != NULL)
508 signal_event(NULL);
509 }
510
511 /*
512 * This is the generic event handler we are registering with
513 * the Hypervisor. Ensure the flows are for us, and then
514 * parse it enough to know if it is an interrupt or an
515 * acknowledge.
516 */
hv_handler(struct HvLpEvent * event)517 static void hv_handler(struct HvLpEvent *event)
518 {
519 if ((event != NULL) && (event->xType == HvLpEvent_Type_MachineFac)) {
520 if (hvlpevent_is_ack(event))
521 handle_ack((struct io_mf_lp_event *)event);
522 else
523 handle_int((struct io_mf_lp_event *)event);
524 } else
525 printk(KERN_ERR "mf.c: alien event received\n");
526 }
527
528 /*
529 * Global kernel interface to allocate and seed events into the
530 * Hypervisor.
531 */
mf_allocate_lp_events(HvLpIndex target_lp,HvLpEvent_Type type,unsigned size,unsigned count,MFCompleteHandler hdlr,void * user_token)532 void mf_allocate_lp_events(HvLpIndex target_lp, HvLpEvent_Type type,
533 unsigned size, unsigned count, MFCompleteHandler hdlr,
534 void *user_token)
535 {
536 struct pending_event *ev = new_pending_event();
537 int rc;
538
539 if (ev == NULL) {
540 rc = -ENOMEM;
541 } else {
542 ev->event.hp_lp_event.xSubtype = 4;
543 ev->event.hp_lp_event.xCorrelationToken = (u64)user_token;
544 ev->event.hp_lp_event.x.xSubtypeData =
545 subtype_data('M', 'F', 'M', 'A');
546 ev->event.data.alloc.target_lp = target_lp;
547 ev->event.data.alloc.type = type;
548 ev->event.data.alloc.size = size;
549 ev->event.data.alloc.count = count;
550 ev->hdlr = hdlr;
551 rc = signal_event(ev);
552 }
553 if ((rc != 0) && (hdlr != NULL))
554 (*hdlr)(user_token, rc);
555 }
556 EXPORT_SYMBOL(mf_allocate_lp_events);
557
558 /*
559 * Global kernel interface to unseed and deallocate events already in
560 * Hypervisor.
561 */
mf_deallocate_lp_events(HvLpIndex target_lp,HvLpEvent_Type type,unsigned count,MFCompleteHandler hdlr,void * user_token)562 void mf_deallocate_lp_events(HvLpIndex target_lp, HvLpEvent_Type type,
563 unsigned count, MFCompleteHandler hdlr, void *user_token)
564 {
565 struct pending_event *ev = new_pending_event();
566 int rc;
567
568 if (ev == NULL)
569 rc = -ENOMEM;
570 else {
571 ev->event.hp_lp_event.xSubtype = 5;
572 ev->event.hp_lp_event.xCorrelationToken = (u64)user_token;
573 ev->event.hp_lp_event.x.xSubtypeData =
574 subtype_data('M', 'F', 'M', 'D');
575 ev->event.data.alloc.target_lp = target_lp;
576 ev->event.data.alloc.type = type;
577 ev->event.data.alloc.count = count;
578 ev->hdlr = hdlr;
579 rc = signal_event(ev);
580 }
581 if ((rc != 0) && (hdlr != NULL))
582 (*hdlr)(user_token, rc);
583 }
584 EXPORT_SYMBOL(mf_deallocate_lp_events);
585
586 /*
587 * Global kernel interface to tell the VSP object in the primary
588 * partition to power this partition off.
589 */
mf_power_off(void)590 void mf_power_off(void)
591 {
592 printk(KERN_INFO "mf.c: Down it goes...\n");
593 signal_ce_msg_simple(0x4d, NULL);
594 for (;;)
595 ;
596 }
597
598 /*
599 * Global kernel interface to tell the VSP object in the primary
600 * partition to reboot this partition.
601 */
mf_reboot(char * cmd)602 void mf_reboot(char *cmd)
603 {
604 printk(KERN_INFO "mf.c: Preparing to bounce...\n");
605 signal_ce_msg_simple(0x4e, NULL);
606 for (;;)
607 ;
608 }
609
610 /*
611 * Display a single word SRC onto the VSP control panel.
612 */
mf_display_src(u32 word)613 void mf_display_src(u32 word)
614 {
615 u8 ce[12];
616
617 memset(ce, 0, sizeof(ce));
618 ce[3] = 0x4a;
619 ce[7] = 0x01;
620 ce[8] = word >> 24;
621 ce[9] = word >> 16;
622 ce[10] = word >> 8;
623 ce[11] = word;
624 signal_ce_msg(ce, NULL);
625 }
626
627 /*
628 * Display a single word SRC of the form "PROGXXXX" on the VSP control panel.
629 */
mf_display_progress_src(u16 value)630 static __init void mf_display_progress_src(u16 value)
631 {
632 u8 ce[12];
633 u8 src[72];
634
635 memcpy(ce, "\x00\x00\x04\x4A\x00\x00\x00\x48\x00\x00\x00\x00", 12);
636 memcpy(src, "\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00"
637 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
638 "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
639 "\x00\x00\x00\x00PROGxxxx ",
640 72);
641 src[6] = value >> 8;
642 src[7] = value & 255;
643 src[44] = "0123456789ABCDEF"[(value >> 12) & 15];
644 src[45] = "0123456789ABCDEF"[(value >> 8) & 15];
645 src[46] = "0123456789ABCDEF"[(value >> 4) & 15];
646 src[47] = "0123456789ABCDEF"[value & 15];
647 dma_and_signal_ce_msg(ce, NULL, src, sizeof(src), 9 * 64 * 1024);
648 }
649
650 /*
651 * Clear the VSP control panel. Used to "erase" an SRC that was
652 * previously displayed.
653 */
mf_clear_src(void)654 static void mf_clear_src(void)
655 {
656 signal_ce_msg_simple(0x4b, NULL);
657 }
658
mf_display_progress(u16 value)659 void __init mf_display_progress(u16 value)
660 {
661 if (!mf_initialized)
662 return;
663
664 if (0xFFFF == value)
665 mf_clear_src();
666 else
667 mf_display_progress_src(value);
668 }
669
670 /*
671 * Initialization code here.
672 */
mf_init(void)673 void __init mf_init(void)
674 {
675 int i;
676
677 spin_lock_init(&pending_event_spinlock);
678
679 for (i = 0; i < PENDING_EVENT_PREALLOC_LEN; i++)
680 free_pending_event(&pending_event_prealloc[i]);
681
682 HvLpEvent_registerHandler(HvLpEvent_Type_MachineFac, &hv_handler);
683
684 /* virtual continue ack */
685 signal_ce_msg_simple(0x57, NULL);
686
687 mf_initialized = 1;
688 mb();
689
690 printk(KERN_NOTICE "mf.c: iSeries Linux LPAR Machine Facilities "
691 "initialized\n");
692 }
693
694 struct rtc_time_data {
695 struct completion com;
696 struct ce_msg_data ce_msg;
697 int rc;
698 };
699
get_rtc_time_complete(void * token,struct ce_msg_data * ce_msg)700 static void get_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
701 {
702 struct rtc_time_data *rtc = token;
703
704 memcpy(&rtc->ce_msg, ce_msg, sizeof(rtc->ce_msg));
705 rtc->rc = 0;
706 complete(&rtc->com);
707 }
708
mf_set_rtc(struct rtc_time * tm)709 static int mf_set_rtc(struct rtc_time *tm)
710 {
711 char ce_time[12];
712 u8 day, mon, hour, min, sec, y1, y2;
713 unsigned year;
714
715 year = 1900 + tm->tm_year;
716 y1 = year / 100;
717 y2 = year % 100;
718
719 sec = tm->tm_sec;
720 min = tm->tm_min;
721 hour = tm->tm_hour;
722 day = tm->tm_mday;
723 mon = tm->tm_mon + 1;
724
725 sec = bin2bcd(sec);
726 min = bin2bcd(min);
727 hour = bin2bcd(hour);
728 mon = bin2bcd(mon);
729 day = bin2bcd(day);
730 y1 = bin2bcd(y1);
731 y2 = bin2bcd(y2);
732
733 memset(ce_time, 0, sizeof(ce_time));
734 ce_time[3] = 0x41;
735 ce_time[4] = y1;
736 ce_time[5] = y2;
737 ce_time[6] = sec;
738 ce_time[7] = min;
739 ce_time[8] = hour;
740 ce_time[10] = day;
741 ce_time[11] = mon;
742
743 return signal_ce_msg(ce_time, NULL);
744 }
745
rtc_set_tm(int rc,u8 * ce_msg,struct rtc_time * tm)746 static int rtc_set_tm(int rc, u8 *ce_msg, struct rtc_time *tm)
747 {
748 tm->tm_wday = 0;
749 tm->tm_yday = 0;
750 tm->tm_isdst = 0;
751 if (rc) {
752 tm->tm_sec = 0;
753 tm->tm_min = 0;
754 tm->tm_hour = 0;
755 tm->tm_mday = 15;
756 tm->tm_mon = 5;
757 tm->tm_year = 52;
758 return rc;
759 }
760
761 if ((ce_msg[2] == 0xa9) ||
762 (ce_msg[2] == 0xaf)) {
763 /* TOD clock is not set */
764 tm->tm_sec = 1;
765 tm->tm_min = 1;
766 tm->tm_hour = 1;
767 tm->tm_mday = 10;
768 tm->tm_mon = 8;
769 tm->tm_year = 71;
770 mf_set_rtc(tm);
771 }
772 {
773 u8 year = ce_msg[5];
774 u8 sec = ce_msg[6];
775 u8 min = ce_msg[7];
776 u8 hour = ce_msg[8];
777 u8 day = ce_msg[10];
778 u8 mon = ce_msg[11];
779
780 sec = bcd2bin(sec);
781 min = bcd2bin(min);
782 hour = bcd2bin(hour);
783 day = bcd2bin(day);
784 mon = bcd2bin(mon);
785 year = bcd2bin(year);
786
787 if (year <= 69)
788 year += 100;
789
790 tm->tm_sec = sec;
791 tm->tm_min = min;
792 tm->tm_hour = hour;
793 tm->tm_mday = day;
794 tm->tm_mon = mon;
795 tm->tm_year = year;
796 }
797
798 return 0;
799 }
800
mf_get_rtc(struct rtc_time * tm)801 static int mf_get_rtc(struct rtc_time *tm)
802 {
803 struct ce_msg_comp_data ce_complete;
804 struct rtc_time_data rtc_data;
805 int rc;
806
807 memset(&ce_complete, 0, sizeof(ce_complete));
808 memset(&rtc_data, 0, sizeof(rtc_data));
809 init_completion(&rtc_data.com);
810 ce_complete.handler = &get_rtc_time_complete;
811 ce_complete.token = &rtc_data;
812 rc = signal_ce_msg_simple(0x40, &ce_complete);
813 if (rc)
814 return rc;
815 wait_for_completion(&rtc_data.com);
816 return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
817 }
818
819 struct boot_rtc_time_data {
820 int busy;
821 struct ce_msg_data ce_msg;
822 int rc;
823 };
824
get_boot_rtc_time_complete(void * token,struct ce_msg_data * ce_msg)825 static void get_boot_rtc_time_complete(void *token, struct ce_msg_data *ce_msg)
826 {
827 struct boot_rtc_time_data *rtc = token;
828
829 memcpy(&rtc->ce_msg, ce_msg, sizeof(rtc->ce_msg));
830 rtc->rc = 0;
831 rtc->busy = 0;
832 }
833
mf_get_boot_rtc(struct rtc_time * tm)834 static int mf_get_boot_rtc(struct rtc_time *tm)
835 {
836 struct ce_msg_comp_data ce_complete;
837 struct boot_rtc_time_data rtc_data;
838 int rc;
839
840 memset(&ce_complete, 0, sizeof(ce_complete));
841 memset(&rtc_data, 0, sizeof(rtc_data));
842 rtc_data.busy = 1;
843 ce_complete.handler = &get_boot_rtc_time_complete;
844 ce_complete.token = &rtc_data;
845 rc = signal_ce_msg_simple(0x40, &ce_complete);
846 if (rc)
847 return rc;
848 /* We need to poll here as we are not yet taking interrupts */
849 while (rtc_data.busy) {
850 if (hvlpevent_is_pending())
851 process_hvlpevents();
852 }
853 return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
854 }
855
856 #ifdef CONFIG_PROC_FS
857
proc_mf_dump_cmdline(char * page,char ** start,off_t off,int count,int * eof,void * data)858 static int proc_mf_dump_cmdline(char *page, char **start, off_t off,
859 int count, int *eof, void *data)
860 {
861 int len;
862 char *p;
863 struct vsp_cmd_data vsp_cmd;
864 int rc;
865 dma_addr_t dma_addr;
866
867 /* The HV appears to return no more than 256 bytes of command line */
868 if (off >= 256)
869 return 0;
870 if ((off + count) > 256)
871 count = 256 - off;
872
873 dma_addr = iseries_hv_map(page, off + count, DMA_FROM_DEVICE);
874 if (dma_mapping_error(NULL, dma_addr))
875 return -ENOMEM;
876 memset(page, 0, off + count);
877 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
878 vsp_cmd.cmd = 33;
879 vsp_cmd.sub_data.kern.token = dma_addr;
880 vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
881 vsp_cmd.sub_data.kern.side = (u64)data;
882 vsp_cmd.sub_data.kern.length = off + count;
883 mb();
884 rc = signal_vsp_instruction(&vsp_cmd);
885 iseries_hv_unmap(dma_addr, off + count, DMA_FROM_DEVICE);
886 if (rc)
887 return rc;
888 if (vsp_cmd.result_code != 0)
889 return -ENOMEM;
890 p = page;
891 len = 0;
892 while (len < (off + count)) {
893 if ((*p == '\0') || (*p == '\n')) {
894 if (*p == '\0')
895 *p = '\n';
896 p++;
897 len++;
898 *eof = 1;
899 break;
900 }
901 p++;
902 len++;
903 }
904
905 if (len < off) {
906 *eof = 1;
907 len = 0;
908 }
909 return len;
910 }
911
912 #if 0
913 static int mf_getVmlinuxChunk(char *buffer, int *size, int offset, u64 side)
914 {
915 struct vsp_cmd_data vsp_cmd;
916 int rc;
917 int len = *size;
918 dma_addr_t dma_addr;
919
920 dma_addr = iseries_hv_map(buffer, len, DMA_FROM_DEVICE);
921 memset(buffer, 0, len);
922 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
923 vsp_cmd.cmd = 32;
924 vsp_cmd.sub_data.kern.token = dma_addr;
925 vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
926 vsp_cmd.sub_data.kern.side = side;
927 vsp_cmd.sub_data.kern.offset = offset;
928 vsp_cmd.sub_data.kern.length = len;
929 mb();
930 rc = signal_vsp_instruction(&vsp_cmd);
931 if (rc == 0) {
932 if (vsp_cmd.result_code == 0)
933 *size = vsp_cmd.sub_data.length_out;
934 else
935 rc = -ENOMEM;
936 }
937
938 iseries_hv_unmap(dma_addr, len, DMA_FROM_DEVICE);
939
940 return rc;
941 }
942
943 static int proc_mf_dump_vmlinux(char *page, char **start, off_t off,
944 int count, int *eof, void *data)
945 {
946 int sizeToGet = count;
947
948 if (!capable(CAP_SYS_ADMIN))
949 return -EACCES;
950
951 if (mf_getVmlinuxChunk(page, &sizeToGet, off, (u64)data) == 0) {
952 if (sizeToGet != 0) {
953 *start = page + off;
954 return sizeToGet;
955 }
956 *eof = 1;
957 return 0;
958 }
959 *eof = 1;
960 return 0;
961 }
962 #endif
963
proc_mf_dump_side(char * page,char ** start,off_t off,int count,int * eof,void * data)964 static int proc_mf_dump_side(char *page, char **start, off_t off,
965 int count, int *eof, void *data)
966 {
967 int len;
968 char mf_current_side = ' ';
969 struct vsp_cmd_data vsp_cmd;
970
971 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
972 vsp_cmd.cmd = 2;
973 vsp_cmd.sub_data.ipl_type = 0;
974 mb();
975
976 if (signal_vsp_instruction(&vsp_cmd) == 0) {
977 if (vsp_cmd.result_code == 0) {
978 switch (vsp_cmd.sub_data.ipl_type) {
979 case 0: mf_current_side = 'A';
980 break;
981 case 1: mf_current_side = 'B';
982 break;
983 case 2: mf_current_side = 'C';
984 break;
985 default: mf_current_side = 'D';
986 break;
987 }
988 }
989 }
990
991 len = sprintf(page, "%c\n", mf_current_side);
992
993 if (len <= (off + count))
994 *eof = 1;
995 *start = page + off;
996 len -= off;
997 if (len > count)
998 len = count;
999 if (len < 0)
1000 len = 0;
1001 return len;
1002 }
1003
proc_mf_change_side(struct file * file,const char __user * buffer,unsigned long count,void * data)1004 static int proc_mf_change_side(struct file *file, const char __user *buffer,
1005 unsigned long count, void *data)
1006 {
1007 char side;
1008 u64 newSide;
1009 struct vsp_cmd_data vsp_cmd;
1010
1011 if (!capable(CAP_SYS_ADMIN))
1012 return -EACCES;
1013
1014 if (count == 0)
1015 return 0;
1016
1017 if (get_user(side, buffer))
1018 return -EFAULT;
1019
1020 switch (side) {
1021 case 'A': newSide = 0;
1022 break;
1023 case 'B': newSide = 1;
1024 break;
1025 case 'C': newSide = 2;
1026 break;
1027 case 'D': newSide = 3;
1028 break;
1029 default:
1030 printk(KERN_ERR "mf_proc.c: proc_mf_change_side: invalid side\n");
1031 return -EINVAL;
1032 }
1033
1034 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
1035 vsp_cmd.sub_data.ipl_type = newSide;
1036 vsp_cmd.cmd = 10;
1037
1038 (void)signal_vsp_instruction(&vsp_cmd);
1039
1040 return count;
1041 }
1042
1043 #if 0
1044 static void mf_getSrcHistory(char *buffer, int size)
1045 {
1046 struct IplTypeReturnStuff return_stuff;
1047 struct pending_event *ev = new_pending_event();
1048 int rc = 0;
1049 char *pages[4];
1050
1051 pages[0] = kmalloc(4096, GFP_ATOMIC);
1052 pages[1] = kmalloc(4096, GFP_ATOMIC);
1053 pages[2] = kmalloc(4096, GFP_ATOMIC);
1054 pages[3] = kmalloc(4096, GFP_ATOMIC);
1055 if ((ev == NULL) || (pages[0] == NULL) || (pages[1] == NULL)
1056 || (pages[2] == NULL) || (pages[3] == NULL))
1057 return -ENOMEM;
1058
1059 return_stuff.xType = 0;
1060 return_stuff.xRc = 0;
1061 return_stuff.xDone = 0;
1062 ev->event.hp_lp_event.xSubtype = 6;
1063 ev->event.hp_lp_event.x.xSubtypeData =
1064 subtype_data('M', 'F', 'V', 'I');
1065 ev->event.data.vsp_cmd.xEvent = &return_stuff;
1066 ev->event.data.vsp_cmd.cmd = 4;
1067 ev->event.data.vsp_cmd.lp_index = HvLpConfig_getLpIndex();
1068 ev->event.data.vsp_cmd.result_code = 0xFF;
1069 ev->event.data.vsp_cmd.reserved = 0;
1070 ev->event.data.vsp_cmd.sub_data.page[0] = iseries_hv_addr(pages[0]);
1071 ev->event.data.vsp_cmd.sub_data.page[1] = iseries_hv_addr(pages[1]);
1072 ev->event.data.vsp_cmd.sub_data.page[2] = iseries_hv_addr(pages[2]);
1073 ev->event.data.vsp_cmd.sub_data.page[3] = iseries_hv_addr(pages[3]);
1074 mb();
1075 if (signal_event(ev) != 0)
1076 return;
1077
1078 while (return_stuff.xDone != 1)
1079 udelay(10);
1080 if (return_stuff.xRc == 0)
1081 memcpy(buffer, pages[0], size);
1082 kfree(pages[0]);
1083 kfree(pages[1]);
1084 kfree(pages[2]);
1085 kfree(pages[3]);
1086 }
1087 #endif
1088
proc_mf_dump_src(char * page,char ** start,off_t off,int count,int * eof,void * data)1089 static int proc_mf_dump_src(char *page, char **start, off_t off,
1090 int count, int *eof, void *data)
1091 {
1092 #if 0
1093 int len;
1094
1095 mf_getSrcHistory(page, count);
1096 len = count;
1097 len -= off;
1098 if (len < count) {
1099 *eof = 1;
1100 if (len <= 0)
1101 return 0;
1102 } else
1103 len = count;
1104 *start = page + off;
1105 return len;
1106 #else
1107 return 0;
1108 #endif
1109 }
1110
proc_mf_change_src(struct file * file,const char __user * buffer,unsigned long count,void * data)1111 static int proc_mf_change_src(struct file *file, const char __user *buffer,
1112 unsigned long count, void *data)
1113 {
1114 char stkbuf[10];
1115
1116 if (!capable(CAP_SYS_ADMIN))
1117 return -EACCES;
1118
1119 if ((count < 4) && (count != 1)) {
1120 printk(KERN_ERR "mf_proc: invalid src\n");
1121 return -EINVAL;
1122 }
1123
1124 if (count > (sizeof(stkbuf) - 1))
1125 count = sizeof(stkbuf) - 1;
1126 if (copy_from_user(stkbuf, buffer, count))
1127 return -EFAULT;
1128
1129 if ((count == 1) && (*stkbuf == '\0'))
1130 mf_clear_src();
1131 else
1132 mf_display_src(*(u32 *)stkbuf);
1133
1134 return count;
1135 }
1136
proc_mf_change_cmdline(struct file * file,const char __user * buffer,unsigned long count,void * data)1137 static int proc_mf_change_cmdline(struct file *file, const char __user *buffer,
1138 unsigned long count, void *data)
1139 {
1140 struct vsp_cmd_data vsp_cmd;
1141 dma_addr_t dma_addr;
1142 char *page;
1143 int ret = -EACCES;
1144
1145 if (!capable(CAP_SYS_ADMIN))
1146 goto out;
1147
1148 dma_addr = 0;
1149 page = iseries_hv_alloc(count, &dma_addr, GFP_ATOMIC);
1150 ret = -ENOMEM;
1151 if (page == NULL)
1152 goto out;
1153
1154 ret = -EFAULT;
1155 if (copy_from_user(page, buffer, count))
1156 goto out_free;
1157
1158 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
1159 vsp_cmd.cmd = 31;
1160 vsp_cmd.sub_data.kern.token = dma_addr;
1161 vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
1162 vsp_cmd.sub_data.kern.side = (u64)data;
1163 vsp_cmd.sub_data.kern.length = count;
1164 mb();
1165 (void)signal_vsp_instruction(&vsp_cmd);
1166 ret = count;
1167
1168 out_free:
1169 iseries_hv_free(count, page, dma_addr);
1170 out:
1171 return ret;
1172 }
1173
proc_mf_change_vmlinux(struct file * file,const char __user * buf,size_t count,loff_t * ppos)1174 static ssize_t proc_mf_change_vmlinux(struct file *file,
1175 const char __user *buf,
1176 size_t count, loff_t *ppos)
1177 {
1178 struct proc_dir_entry *dp = PDE(file->f_path.dentry->d_inode);
1179 ssize_t rc;
1180 dma_addr_t dma_addr;
1181 char *page;
1182 struct vsp_cmd_data vsp_cmd;
1183
1184 rc = -EACCES;
1185 if (!capable(CAP_SYS_ADMIN))
1186 goto out;
1187
1188 dma_addr = 0;
1189 page = iseries_hv_alloc(count, &dma_addr, GFP_ATOMIC);
1190 rc = -ENOMEM;
1191 if (page == NULL) {
1192 printk(KERN_ERR "mf.c: couldn't allocate memory to set vmlinux chunk\n");
1193 goto out;
1194 }
1195 rc = -EFAULT;
1196 if (copy_from_user(page, buf, count))
1197 goto out_free;
1198
1199 memset(&vsp_cmd, 0, sizeof(vsp_cmd));
1200 vsp_cmd.cmd = 30;
1201 vsp_cmd.sub_data.kern.token = dma_addr;
1202 vsp_cmd.sub_data.kern.address_type = HvLpDma_AddressType_TceIndex;
1203 vsp_cmd.sub_data.kern.side = (u64)dp->data;
1204 vsp_cmd.sub_data.kern.offset = *ppos;
1205 vsp_cmd.sub_data.kern.length = count;
1206 mb();
1207 rc = signal_vsp_instruction(&vsp_cmd);
1208 if (rc)
1209 goto out_free;
1210 rc = -ENOMEM;
1211 if (vsp_cmd.result_code != 0)
1212 goto out_free;
1213
1214 *ppos += count;
1215 rc = count;
1216 out_free:
1217 iseries_hv_free(count, page, dma_addr);
1218 out:
1219 return rc;
1220 }
1221
1222 static const struct file_operations proc_vmlinux_operations = {
1223 .write = proc_mf_change_vmlinux,
1224 };
1225
mf_proc_init(void)1226 static int __init mf_proc_init(void)
1227 {
1228 struct proc_dir_entry *mf_proc_root;
1229 struct proc_dir_entry *ent;
1230 struct proc_dir_entry *mf;
1231 char name[2];
1232 int i;
1233
1234 if (!firmware_has_feature(FW_FEATURE_ISERIES))
1235 return 0;
1236
1237 mf_proc_root = proc_mkdir("iSeries/mf", NULL);
1238 if (!mf_proc_root)
1239 return 1;
1240
1241 name[1] = '\0';
1242 for (i = 0; i < 4; i++) {
1243 name[0] = 'A' + i;
1244 mf = proc_mkdir(name, mf_proc_root);
1245 if (!mf)
1246 return 1;
1247
1248 ent = create_proc_entry("cmdline", S_IFREG|S_IRUSR|S_IWUSR, mf);
1249 if (!ent)
1250 return 1;
1251 ent->data = (void *)(long)i;
1252 ent->read_proc = proc_mf_dump_cmdline;
1253 ent->write_proc = proc_mf_change_cmdline;
1254
1255 if (i == 3) /* no vmlinux entry for 'D' */
1256 continue;
1257
1258 ent = proc_create_data("vmlinux", S_IFREG|S_IWUSR, mf,
1259 &proc_vmlinux_operations,
1260 (void *)(long)i);
1261 if (!ent)
1262 return 1;
1263 }
1264
1265 ent = create_proc_entry("side", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root);
1266 if (!ent)
1267 return 1;
1268 ent->data = (void *)0;
1269 ent->read_proc = proc_mf_dump_side;
1270 ent->write_proc = proc_mf_change_side;
1271
1272 ent = create_proc_entry("src", S_IFREG|S_IRUSR|S_IWUSR, mf_proc_root);
1273 if (!ent)
1274 return 1;
1275 ent->data = (void *)0;
1276 ent->read_proc = proc_mf_dump_src;
1277 ent->write_proc = proc_mf_change_src;
1278
1279 return 0;
1280 }
1281
1282 __initcall(mf_proc_init);
1283
1284 #endif /* CONFIG_PROC_FS */
1285
1286 /*
1287 * Get the RTC from the virtual service processor
1288 * This requires flowing LpEvents to the primary partition
1289 */
iSeries_get_rtc_time(struct rtc_time * rtc_tm)1290 void iSeries_get_rtc_time(struct rtc_time *rtc_tm)
1291 {
1292 mf_get_rtc(rtc_tm);
1293 rtc_tm->tm_mon--;
1294 }
1295
1296 /*
1297 * Set the RTC in the virtual service processor
1298 * This requires flowing LpEvents to the primary partition
1299 */
iSeries_set_rtc_time(struct rtc_time * tm)1300 int iSeries_set_rtc_time(struct rtc_time *tm)
1301 {
1302 mf_set_rtc(tm);
1303 return 0;
1304 }
1305
iSeries_get_boot_time(void)1306 unsigned long iSeries_get_boot_time(void)
1307 {
1308 struct rtc_time tm;
1309
1310 mf_get_boot_rtc(&tm);
1311 return mktime(tm.tm_year + 1900, tm.tm_mon, tm.tm_mday,
1312 tm.tm_hour, tm.tm_min, tm.tm_sec);
1313 }
1314