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