?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial commit
[wrt350n-kernel.git] / drivers / s390 / cio / chsc.c
blob007aaeb4f53214533f7dc8c6b8bca62922d28442
1 /*
2 * drivers/s390/cio/chsc.c
3 * S/390 common I/O routines -- channel subsystem call
4 *
5 * Copyright (C) 1999-2002 IBM Deutschland Entwicklung GmbH,
6 * IBM Corporation
7 * Author(s): Ingo Adlung (adlung@de.ibm.com)
8 * Cornelia Huck (cornelia.huck@de.ibm.com)
9 * Arnd Bergmann (arndb@de.ibm.com)
10 */
11
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/init.h>
15 #include <linux/device.h>
16
17 #include <asm/cio.h>
18 #include <asm/chpid.h>
19
20 #include "css.h"
21 #include "cio.h"
22 #include "cio_debug.h"
23 #include "ioasm.h"
24 #include "chp.h"
25 #include "chsc.h"
26
27 static void *sei_page;
28
29 static int chsc_error_from_response(int response)
30 {
31 switch (response) {
32 case 0x0001:
33 return 0;
34 case 0x0002:
35 case 0x0003:
36 case 0x0006:
37 case 0x0007:
38 case 0x0008:
39 case 0x000a:
40 return -EINVAL;
41 case 0x0004:
42 return -EOPNOTSUPP;
43 default:
44 return -EIO;
45 }
46 }
47
48 struct chsc_ssd_area {
49 struct chsc_header request;
50 u16 :10;
51 u16 ssid:2;
52 u16 :4;
53 u16 f_sch; /* first subchannel */
54 u16 :16;
55 u16 l_sch; /* last subchannel */
56 u32 :32;
57 struct chsc_header response;
58 u32 :32;
59 u8 sch_valid : 1;
60 u8 dev_valid : 1;
61 u8 st : 3; /* subchannel type */
62 u8 zeroes : 3;
63 u8 unit_addr; /* unit address */
64 u16 devno; /* device number */
65 u8 path_mask;
66 u8 fla_valid_mask;
67 u16 sch; /* subchannel */
68 u8 chpid[8]; /* chpids 0-7 */
69 u16 fla[8]; /* full link addresses 0-7 */
70 } __attribute__ ((packed));
71
72 int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd)
73 {
74 unsigned long page;
75 struct chsc_ssd_area *ssd_area;
76 int ccode;
77 int ret;
78 int i;
79 int mask;
80
81 page = get_zeroed_page(GFP_KERNEL | GFP_DMA);
82 if (!page)
83 return -ENOMEM;
84 ssd_area = (struct chsc_ssd_area *) page;
85 ssd_area->request.length = 0x0010;
86 ssd_area->request.code = 0x0004;
87 ssd_area->ssid = schid.ssid;
88 ssd_area->f_sch = schid.sch_no;
89 ssd_area->l_sch = schid.sch_no;
90
91 ccode = chsc(ssd_area);
92 /* Check response. */
93 if (ccode > 0) {
94 ret = (ccode == 3) ? -ENODEV : -EBUSY;
95 goto out_free;
96 }
97 ret = chsc_error_from_response(ssd_area->response.code);
98 if (ret != 0) {
99 CIO_MSG_EVENT(2, "chsc: ssd failed for 0.%x.%04x (rc=%04x)\n",
100 schid.ssid, schid.sch_no,
101 ssd_area->response.code);
102 goto out_free;
103 }
104 if (!ssd_area->sch_valid) {
105 ret = -ENODEV;
106 goto out_free;
107 }
108 /* Copy data */
109 ret = 0;
110 memset(ssd, 0, sizeof(struct chsc_ssd_info));
111 if ((ssd_area->st != SUBCHANNEL_TYPE_IO) &&
112 (ssd_area->st != SUBCHANNEL_TYPE_MSG))
113 goto out_free;
114 ssd->path_mask = ssd_area->path_mask;
115 ssd->fla_valid_mask = ssd_area->fla_valid_mask;
116 for (i = 0; i < 8; i++) {
117 mask = 0x80 >> i;
118 if (ssd_area->path_mask & mask) {
119 chp_id_init(&ssd->chpid[i]);
120 ssd->chpid[i].id = ssd_area->chpid[i];
121 }
122 if (ssd_area->fla_valid_mask & mask)
123 ssd->fla[i] = ssd_area->fla[i];
124 }
125 out_free:
126 free_page(page);
127 return ret;
128 }
129
130 static int check_for_io_on_path(struct subchannel *sch, int mask)
131 {
132 int cc;
133
134 cc = stsch(sch->schid, &sch->schib);
135 if (cc)
136 return 0;
137 if (sch->schib.scsw.actl && sch->schib.pmcw.lpum == mask)
138 return 1;
139 return 0;
140 }
141
142 static void terminate_internal_io(struct subchannel *sch)
143 {
144 if (cio_clear(sch)) {
145 /* Recheck device in case clear failed. */
146 sch->lpm = 0;
147 if (device_trigger_verify(sch) != 0)
148 css_schedule_eval(sch->schid);
149 return;
150 }
151 /* Request retry of internal operation. */
152 device_set_intretry(sch);
153 /* Call handler. */
154 if (sch->driver && sch->driver->termination)
155 sch->driver->termination(sch);
156 }
157
158 static int s390_subchannel_remove_chpid(struct subchannel *sch, void *data)
159 {
160 int j;
161 int mask;
162 struct chp_id *chpid = data;
163 struct schib schib;
164
165 for (j = 0; j < 8; j++) {
166 mask = 0x80 >> j;
167 if ((sch->schib.pmcw.pim & mask) &&
168 (sch->schib.pmcw.chpid[j] == chpid->id))
169 break;
170 }
171 if (j >= 8)
172 return 0;
173
174 spin_lock_irq(sch->lock);
175
176 stsch(sch->schid, &schib);
177 if (!css_sch_is_valid(&schib))
178 goto out_unreg;
179 memcpy(&sch->schib, &schib, sizeof(struct schib));
180 /* Check for single path devices. */
181 if (sch->schib.pmcw.pim == 0x80)
182 goto out_unreg;
183
184 if (check_for_io_on_path(sch, mask)) {
185 if (device_is_online(sch))
186 device_kill_io(sch);
187 else {
188 terminate_internal_io(sch);
189 /* Re-start path verification. */
190 if (sch->driver && sch->driver->verify)
191 sch->driver->verify(sch);
192 }
193 } else {
194 /* trigger path verification. */
195 if (sch->driver && sch->driver->verify)
196 sch->driver->verify(sch);
197 else if (sch->lpm == mask)
198 goto out_unreg;
199 }
200
201 spin_unlock_irq(sch->lock);
202 return 0;
203
204 out_unreg:
205 sch->lpm = 0;
206 spin_unlock_irq(sch->lock);
207 css_schedule_eval(sch->schid);
208 return 0;
209 }
210
211 void chsc_chp_offline(struct chp_id chpid)
212 {
213 char dbf_txt[15];
214
215 sprintf(dbf_txt, "chpr%x.%02x", chpid.cssid, chpid.id);
216 CIO_TRACE_EVENT(2, dbf_txt);
217
218 if (chp_get_status(chpid) <= 0)
219 return;
220 for_each_subchannel_staged(s390_subchannel_remove_chpid, NULL, &chpid);
221 }
222
223 static int s390_process_res_acc_new_sch(struct subchannel_id schid, void *data)
224 {
225 struct schib schib;
226 /*
227 * We don't know the device yet, but since a path
228 * may be available now to the device we'll have
229 * to do recognition again.
230 * Since we don't have any idea about which chpid
231 * that beast may be on we'll have to do a stsch
232 * on all devices, grr...
233 */
234 if (stsch_err(schid, &schib))
235 /* We're through */
236 return -ENXIO;
237
238 /* Put it on the slow path. */
239 css_schedule_eval(schid);
240 return 0;
241 }
242
243 struct res_acc_data {
244 struct chp_id chpid;
245 u32 fla_mask;
246 u16 fla;
247 };
248
249 static int get_res_chpid_mask(struct chsc_ssd_info *ssd,
250 struct res_acc_data *data)
251 {
252 int i;
253 int mask;
254
255 for (i = 0; i < 8; i++) {
256 mask = 0x80 >> i;
257 if (!(ssd->path_mask & mask))
258 continue;
259 if (!chp_id_is_equal(&ssd->chpid[i], &data->chpid))
260 continue;
261 if ((ssd->fla_valid_mask & mask) &&
262 ((ssd->fla[i] & data->fla_mask) != data->fla))
263 continue;
264 return mask;
265 }
266 return 0;
267 }
268
269 static int __s390_process_res_acc(struct subchannel *sch, void *data)
270 {
271 int chp_mask, old_lpm;
272 struct res_acc_data *res_data = data;
273
274 spin_lock_irq(sch->lock);
275 chp_mask = get_res_chpid_mask(&sch->ssd_info, res_data);
276 if (chp_mask == 0)
277 goto out;
278 if (stsch(sch->schid, &sch->schib))
279 goto out;
280 old_lpm = sch->lpm;
281 sch->lpm = ((sch->schib.pmcw.pim &
282 sch->schib.pmcw.pam &
283 sch->schib.pmcw.pom)
284 | chp_mask) & sch->opm;
285 if (!old_lpm && sch->lpm)
286 device_trigger_reprobe(sch);
287 else if (sch->driver && sch->driver->verify)
288 sch->driver->verify(sch);
289 out:
290 spin_unlock_irq(sch->lock);
291
292 return 0;
293 }
294
295 static void s390_process_res_acc (struct res_acc_data *res_data)
296 {
297 char dbf_txt[15];
298
299 sprintf(dbf_txt, "accpr%x.%02x", res_data->chpid.cssid,
300 res_data->chpid.id);
301 CIO_TRACE_EVENT( 2, dbf_txt);
302 if (res_data->fla != 0) {
303 sprintf(dbf_txt, "fla%x", res_data->fla);
304 CIO_TRACE_EVENT( 2, dbf_txt);
305 }
306
307 /*
308 * I/O resources may have become accessible.
309 * Scan through all subchannels that may be concerned and
310 * do a validation on those.
311 * The more information we have (info), the less scanning
312 * will we have to do.
313 */
314 for_each_subchannel_staged(__s390_process_res_acc,
315 s390_process_res_acc_new_sch, res_data);
316 }
317
318 static int
319 __get_chpid_from_lir(void *data)
320 {
321 struct lir {
322 u8 iq;
323 u8 ic;
324 u16 sci;
325 /* incident-node descriptor */
326 u32 indesc[28];
327 /* attached-node descriptor */
328 u32 andesc[28];
329 /* incident-specific information */
330 u32 isinfo[28];
331 } __attribute__ ((packed)) *lir;
332
333 lir = data;
334 if (!(lir->iq&0x80))
335 /* NULL link incident record */
336 return -EINVAL;
337 if (!(lir->indesc[0]&0xc0000000))
338 /* node descriptor not valid */
339 return -EINVAL;
340 if (!(lir->indesc[0]&0x10000000))
341 /* don't handle device-type nodes - FIXME */
342 return -EINVAL;
343 /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */
344
345 return (u16) (lir->indesc[0]&0x000000ff);
346 }
347
348 struct chsc_sei_area {
349 struct chsc_header request;
350 u32 reserved1;
351 u32 reserved2;
352 u32 reserved3;
353 struct chsc_header response;
354 u32 reserved4;
355 u8 flags;
356 u8 vf; /* validity flags */
357 u8 rs; /* reporting source */
358 u8 cc; /* content code */
359 u16 fla; /* full link address */
360 u16 rsid; /* reporting source id */
361 u32 reserved5;
362 u32 reserved6;
363 u8 ccdf[4096 - 16 - 24]; /* content-code dependent field */
364 /* ccdf has to be big enough for a link-incident record */
365 } __attribute__ ((packed));
366
367 static void chsc_process_sei_link_incident(struct chsc_sei_area *sei_area)
368 {
369 struct chp_id chpid;
370 int id;
371
372 CIO_CRW_EVENT(4, "chsc: link incident (rs=%02x, rs_id=%04x)\n",
373 sei_area->rs, sei_area->rsid);
374 if (sei_area->rs != 4)
375 return;
376 id = __get_chpid_from_lir(sei_area->ccdf);
377 if (id < 0)
378 CIO_CRW_EVENT(4, "chsc: link incident - invalid LIR\n");
379 else {
380 chp_id_init(&chpid);
381 chpid.id = id;
382 chsc_chp_offline(chpid);
383 }
384 }
385
386 static void chsc_process_sei_res_acc(struct chsc_sei_area *sei_area)
387 {
388 struct res_acc_data res_data;
389 struct chp_id chpid;
390 int status;
391
392 CIO_CRW_EVENT(4, "chsc: resource accessibility event (rs=%02x, "
393 "rs_id=%04x)\n", sei_area->rs, sei_area->rsid);
394 if (sei_area->rs != 4)
395 return;
396 chp_id_init(&chpid);
397 chpid.id = sei_area->rsid;
398 /* allocate a new channel path structure, if needed */
399 status = chp_get_status(chpid);
400 if (status < 0)
401 chp_new(chpid);
402 else if (!status)
403 return;
404 memset(&res_data, 0, sizeof(struct res_acc_data));
405 res_data.chpid = chpid;
406 if ((sei_area->vf & 0xc0) != 0) {
407 res_data.fla = sei_area->fla;
408 if ((sei_area->vf & 0xc0) == 0xc0)
409 /* full link address */
410 res_data.fla_mask = 0xffff;
411 else
412 /* link address */
413 res_data.fla_mask = 0xff00;
414 }
415 s390_process_res_acc(&res_data);
416 }
417
418 struct chp_config_data {
419 u8 map[32];
420 u8 op;
421 u8 pc;
422 };
423
424 static void chsc_process_sei_chp_config(struct chsc_sei_area *sei_area)
425 {
426 struct chp_config_data *data;
427 struct chp_id chpid;
428 int num;
429
430 CIO_CRW_EVENT(4, "chsc: channel-path-configuration notification\n");
431 if (sei_area->rs != 0)
432 return;
433 data = (struct chp_config_data *) &(sei_area->ccdf);
434 chp_id_init(&chpid);
435 for (num = 0; num <= __MAX_CHPID; num++) {
436 if (!chp_test_bit(data->map, num))
437 continue;
438 chpid.id = num;
439 printk(KERN_WARNING "cio: processing configure event %d for "
440 "chpid %x.%02x\n", data->op, chpid.cssid, chpid.id);
441 switch (data->op) {
442 case 0:
443 chp_cfg_schedule(chpid, 1);
444 break;
445 case 1:
446 chp_cfg_schedule(chpid, 0);
447 break;
448 case 2:
449 chp_cfg_cancel_deconfigure(chpid);
450 break;
451 }
452 }
453 }
454
455 static void chsc_process_sei(struct chsc_sei_area *sei_area)
456 {
457 /* Check if we might have lost some information. */
458 if (sei_area->flags & 0x40) {
459 CIO_CRW_EVENT(2, "chsc: event overflow\n");
460 css_schedule_eval_all();
461 }
462 /* which kind of information was stored? */
463 switch (sei_area->cc) {
464 case 1: /* link incident*/
465 chsc_process_sei_link_incident(sei_area);
466 break;
467 case 2: /* i/o resource accessibiliy */
468 chsc_process_sei_res_acc(sei_area);
469 break;
470 case 8: /* channel-path-configuration notification */
471 chsc_process_sei_chp_config(sei_area);
472 break;
473 default: /* other stuff */
474 CIO_CRW_EVENT(4, "chsc: unhandled sei content code %d\n",
475 sei_area->cc);
476 break;
477 }
478 }
479
480 void chsc_process_crw(void)
481 {
482 struct chsc_sei_area *sei_area;
483
484 if (!sei_page)
485 return;
486 /* Access to sei_page is serialized through machine check handler
487 * thread, so no need for locking. */
488 sei_area = sei_page;
489
490 CIO_TRACE_EVENT( 2, "prcss");
491 do {
492 memset(sei_area, 0, sizeof(*sei_area));
493 sei_area->request.length = 0x0010;
494 sei_area->request.code = 0x000e;
495 if (chsc(sei_area))
496 break;
497
498 if (sei_area->response.code == 0x0001) {
499 CIO_CRW_EVENT(4, "chsc: sei successful\n");
500 chsc_process_sei(sei_area);
501 } else {
502 CIO_CRW_EVENT(2, "chsc: sei failed (rc=%04x)\n",
503 sei_area->response.code);
504 break;
505 }
506 } while (sei_area->flags & 0x80);
507 }
508
509 static int __chp_add_new_sch(struct subchannel_id schid, void *data)
510 {
511 struct schib schib;
512
513 if (stsch_err(schid, &schib))
514 /* We're through */
515 return -ENXIO;
516
517 /* Put it on the slow path. */
518 css_schedule_eval(schid);
519 return 0;
520 }
521
522
523 static int __chp_add(struct subchannel *sch, void *data)
524 {
525 int i, mask;
526 struct chp_id *chpid = data;
527
528 spin_lock_irq(sch->lock);
529 for (i=0; i<8; i++) {
530 mask = 0x80 >> i;
531 if ((sch->schib.pmcw.pim & mask) &&
532 (sch->schib.pmcw.chpid[i] == chpid->id))
533 break;
534 }
535 if (i==8) {
536 spin_unlock_irq(sch->lock);
537 return 0;
538 }
539 if (stsch(sch->schid, &sch->schib)) {
540 spin_unlock_irq(sch->lock);
541 css_schedule_eval(sch->schid);
542 return 0;
543 }
544 sch->lpm = ((sch->schib.pmcw.pim &
545 sch->schib.pmcw.pam &
546 sch->schib.pmcw.pom)
547 | mask) & sch->opm;
548
549 if (sch->driver && sch->driver->verify)
550 sch->driver->verify(sch);
551
552 spin_unlock_irq(sch->lock);
553
554 return 0;
555 }
556
557 void chsc_chp_online(struct chp_id chpid)
558 {
559 char dbf_txt[15];
560
561 sprintf(dbf_txt, "cadd%x.%02x", chpid.cssid, chpid.id);
562 CIO_TRACE_EVENT(2, dbf_txt);
563
564 if (chp_get_status(chpid) != 0)
565 for_each_subchannel_staged(__chp_add, __chp_add_new_sch,
566 &chpid);
567 }
568
569 static void __s390_subchannel_vary_chpid(struct subchannel *sch,
570 struct chp_id chpid, int on)
571 {
572 int chp, old_lpm;
573 int mask;
574 unsigned long flags;
575
576 spin_lock_irqsave(sch->lock, flags);
577 old_lpm = sch->lpm;
578 for (chp = 0; chp < 8; chp++) {
579 mask = 0x80 >> chp;
580 if (!(sch->ssd_info.path_mask & mask))
581 continue;
582 if (!chp_id_is_equal(&sch->ssd_info.chpid[chp], &chpid))
583 continue;
584
585 if (on) {
586 sch->opm |= mask;
587 sch->lpm |= mask;
588 if (!old_lpm)
589 device_trigger_reprobe(sch);
590 else if (sch->driver && sch->driver->verify)
591 sch->driver->verify(sch);
592 break;
593 }
594 sch->opm &= ~mask;
595 sch->lpm &= ~mask;
596 if (check_for_io_on_path(sch, mask)) {
597 if (device_is_online(sch))
598 /* Path verification is done after killing. */
599 device_kill_io(sch);
600 else {
601 /* Kill and retry internal I/O. */
602 terminate_internal_io(sch);
603 /* Re-start path verification. */
604 if (sch->driver && sch->driver->verify)
605 sch->driver->verify(sch);
606 }
607 } else if (!sch->lpm) {
608 if (device_trigger_verify(sch) != 0)
609 css_schedule_eval(sch->schid);
610 } else if (sch->driver && sch->driver->verify)
611 sch->driver->verify(sch);
612 break;
613 }
614 spin_unlock_irqrestore(sch->lock, flags);
615 }
616
617 static int s390_subchannel_vary_chpid_off(struct subchannel *sch, void *data)
618 {
619 struct chp_id *chpid = data;
620
621 __s390_subchannel_vary_chpid(sch, *chpid, 0);
622 return 0;
623 }
624
625 static int s390_subchannel_vary_chpid_on(struct subchannel *sch, void *data)
626 {
627 struct chp_id *chpid = data;
628
629 __s390_subchannel_vary_chpid(sch, *chpid, 1);
630 return 0;
631 }
632
633 static int
634 __s390_vary_chpid_on(struct subchannel_id schid, void *data)
635 {
636 struct schib schib;
637
638 if (stsch_err(schid, &schib))
639 /* We're through */
640 return -ENXIO;
641 /* Put it on the slow path. */
642 css_schedule_eval(schid);
643 return 0;
644 }
645
646 /**
647 * chsc_chp_vary - propagate channel-path vary operation to subchannels
648 * @chpid: channl-path ID
649 * @on: non-zero for vary online, zero for vary offline
650 */
651 int chsc_chp_vary(struct chp_id chpid, int on)
652 {
653 /*
654 * Redo PathVerification on the devices the chpid connects to
655 */
656
657 if (on)
658 for_each_subchannel_staged(s390_subchannel_vary_chpid_on,
659 __s390_vary_chpid_on, &chpid);
660 else
661 for_each_subchannel_staged(s390_subchannel_vary_chpid_off,
662 NULL, &chpid);
663
664 return 0;
665 }
666
667 static void
668 chsc_remove_cmg_attr(struct channel_subsystem *css)
669 {
670 int i;
671
672 for (i = 0; i <= __MAX_CHPID; i++) {
673 if (!css->chps[i])
674 continue;
675 chp_remove_cmg_attr(css->chps[i]);
676 }
677 }
678
679 static int
680 chsc_add_cmg_attr(struct channel_subsystem *css)
681 {
682 int i, ret;
683
684 ret = 0;
685 for (i = 0; i <= __MAX_CHPID; i++) {
686 if (!css->chps[i])
687 continue;
688 ret = chp_add_cmg_attr(css->chps[i]);
689 if (ret)
690 goto cleanup;
691 }
692 return ret;
693 cleanup:
694 for (--i; i >= 0; i--) {
695 if (!css->chps[i])
696 continue;
697 chp_remove_cmg_attr(css->chps[i]);
698 }
699 return ret;
700 }
701
702 static int
703 __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
704 {
705 struct {
706 struct chsc_header request;
707 u32 operation_code : 2;
708 u32 : 30;
709 u32 key : 4;
710 u32 : 28;
711 u32 zeroes1;
712 u32 cub_addr1;
713 u32 zeroes2;
714 u32 cub_addr2;
715 u32 reserved[13];
716 struct chsc_header response;
717 u32 status : 8;
718 u32 : 4;
719 u32 fmt : 4;
720 u32 : 16;
721 } __attribute__ ((packed)) *secm_area;
722 int ret, ccode;
723
724 secm_area = page;
725 secm_area->request.length = 0x0050;
726 secm_area->request.code = 0x0016;
727
728 secm_area->key = PAGE_DEFAULT_KEY;
729 secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
730 secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
731
732 secm_area->operation_code = enable ? 0 : 1;
733
734 ccode = chsc(secm_area);
735 if (ccode > 0)
736 return (ccode == 3) ? -ENODEV : -EBUSY;
737
738 switch (secm_area->response.code) {
739 case 0x0102:
740 case 0x0103:
741 ret = -EINVAL;
742 default:
743 ret = chsc_error_from_response(secm_area->response.code);
744 }
745 if (ret != 0)
746 CIO_CRW_EVENT(2, "chsc: secm failed (rc=%04x)\n",
747 secm_area->response.code);
748 return ret;
749 }
750
751 int
752 chsc_secm(struct channel_subsystem *css, int enable)
753 {
754 void *secm_area;
755 int ret;
756
757 secm_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
758 if (!secm_area)
759 return -ENOMEM;
760
761 mutex_lock(&css->mutex);
762 if (enable && !css->cm_enabled) {
763 css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
764 css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
765 if (!css->cub_addr1 || !css->cub_addr2) {
766 free_page((unsigned long)css->cub_addr1);
767 free_page((unsigned long)css->cub_addr2);
768 free_page((unsigned long)secm_area);
769 mutex_unlock(&css->mutex);
770 return -ENOMEM;
771 }
772 }
773 ret = __chsc_do_secm(css, enable, secm_area);
774 if (!ret) {
775 css->cm_enabled = enable;
776 if (css->cm_enabled) {
777 ret = chsc_add_cmg_attr(css);
778 if (ret) {
779 memset(secm_area, 0, PAGE_SIZE);
780 __chsc_do_secm(css, 0, secm_area);
781 css->cm_enabled = 0;
782 }
783 } else
784 chsc_remove_cmg_attr(css);
785 }
786 if (!css->cm_enabled) {
787 free_page((unsigned long)css->cub_addr1);
788 free_page((unsigned long)css->cub_addr2);
789 }
790 mutex_unlock(&css->mutex);
791 free_page((unsigned long)secm_area);
792 return ret;
793 }
794
795 int chsc_determine_channel_path_description(struct chp_id chpid,
796 struct channel_path_desc *desc)
797 {
798 int ccode, ret;
799
800 struct {
801 struct chsc_header request;
802 u32 : 24;
803 u32 first_chpid : 8;
804 u32 : 24;
805 u32 last_chpid : 8;
806 u32 zeroes1;
807 struct chsc_header response;
808 u32 zeroes2;
809 struct channel_path_desc desc;
810 } __attribute__ ((packed)) *scpd_area;
811
812 scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
813 if (!scpd_area)
814 return -ENOMEM;
815
816 scpd_area->request.length = 0x0010;
817 scpd_area->request.code = 0x0002;
818
819 scpd_area->first_chpid = chpid.id;
820 scpd_area->last_chpid = chpid.id;
821
822 ccode = chsc(scpd_area);
823 if (ccode > 0) {
824 ret = (ccode == 3) ? -ENODEV : -EBUSY;
825 goto out;
826 }
827
828 ret = chsc_error_from_response(scpd_area->response.code);
829 if (ret == 0)
830 /* Success. */
831 memcpy(desc, &scpd_area->desc,
832 sizeof(struct channel_path_desc));
833 else
834 CIO_CRW_EVENT(2, "chsc: scpd failed (rc=%04x)\n",
835 scpd_area->response.code);
836 out:
837 free_page((unsigned long)scpd_area);
838 return ret;
839 }
840
841 static void
842 chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
843 struct cmg_chars *chars)
844 {
845 switch (chp->cmg) {
846 case 2:
847 case 3:
848 chp->cmg_chars = kmalloc(sizeof(struct cmg_chars),
849 GFP_KERNEL);
850 if (chp->cmg_chars) {
851 int i, mask;
852 struct cmg_chars *cmg_chars;
853
854 cmg_chars = chp->cmg_chars;
855 for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
856 mask = 0x80 >> (i + 3);
857 if (cmcv & mask)
858 cmg_chars->values[i] = chars->values[i];
859 else
860 cmg_chars->values[i] = 0;
861 }
862 }
863 break;
864 default:
865 /* No cmg-dependent data. */
866 break;
867 }
868 }
869
870 int chsc_get_channel_measurement_chars(struct channel_path *chp)
871 {
872 int ccode, ret;
873
874 struct {
875 struct chsc_header request;
876 u32 : 24;
877 u32 first_chpid : 8;
878 u32 : 24;
879 u32 last_chpid : 8;
880 u32 zeroes1;
881 struct chsc_header response;
882 u32 zeroes2;
883 u32 not_valid : 1;
884 u32 shared : 1;
885 u32 : 22;
886 u32 chpid : 8;
887 u32 cmcv : 5;
888 u32 : 11;
889 u32 cmgq : 8;
890 u32 cmg : 8;
891 u32 zeroes3;
892 u32 data[NR_MEASUREMENT_CHARS];
893 } __attribute__ ((packed)) *scmc_area;
894
895 scmc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
896 if (!scmc_area)
897 return -ENOMEM;
898
899 scmc_area->request.length = 0x0010;
900 scmc_area->request.code = 0x0022;
901
902 scmc_area->first_chpid = chp->chpid.id;
903 scmc_area->last_chpid = chp->chpid.id;
904
905 ccode = chsc(scmc_area);
906 if (ccode > 0) {
907 ret = (ccode == 3) ? -ENODEV : -EBUSY;
908 goto out;
909 }
910
911 ret = chsc_error_from_response(scmc_area->response.code);
912 if (ret == 0) {
913 /* Success. */
914 if (!scmc_area->not_valid) {
915 chp->cmg = scmc_area->cmg;
916 chp->shared = scmc_area->shared;
917 chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
918 (struct cmg_chars *)
919 &scmc_area->data);
920 } else {
921 chp->cmg = -1;
922 chp->shared = -1;
923 }
924 } else {
925 CIO_CRW_EVENT(2, "chsc: scmc failed (rc=%04x)\n",
926 scmc_area->response.code);
927 }
928 out:
929 free_page((unsigned long)scmc_area);
930 return ret;
931 }
932
933 int __init chsc_alloc_sei_area(void)
934 {
935 sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
936 if (!sei_page)
937 CIO_MSG_EVENT(0, "Can't allocate page for processing of "
938 "chsc machine checks!\n");
939 return (sei_page ? 0 : -ENOMEM);
940 }
941
942 void __init chsc_free_sei_area(void)
943 {
944 kfree(sei_page);
945 }
946
947 int __init
948 chsc_enable_facility(int operation_code)
949 {
950 int ret;
951 struct {
952 struct chsc_header request;
953 u8 reserved1:4;
954 u8 format:4;
955 u8 reserved2;
956 u16 operation_code;
957 u32 reserved3;
958 u32 reserved4;
959 u32 operation_data_area[252];
960 struct chsc_header response;
961 u32 reserved5:4;
962 u32 format2:4;
963 u32 reserved6:24;
964 } __attribute__ ((packed)) *sda_area;
965
966 sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
967 if (!sda_area)
968 return -ENOMEM;
969 sda_area->request.length = 0x0400;
970 sda_area->request.code = 0x0031;
971 sda_area->operation_code = operation_code;
972
973 ret = chsc(sda_area);
974 if (ret > 0) {
975 ret = (ret == 3) ? -ENODEV : -EBUSY;
976 goto out;
977 }
978
979 switch (sda_area->response.code) {
980 case 0x0101:
981 ret = -EOPNOTSUPP;
982 break;
983 default:
984 ret = chsc_error_from_response(sda_area->response.code);
985 }
986 if (ret != 0)
987 CIO_CRW_EVENT(2, "chsc: sda (oc=%x) failed (rc=%04x)\n",
988 operation_code, sda_area->response.code);
989 out:
990 free_page((unsigned long)sda_area);
991 return ret;
992 }
993
994 struct css_general_char css_general_characteristics;
995 struct css_chsc_char css_chsc_characteristics;
996
997 int __init
998 chsc_determine_css_characteristics(void)
999 {
1000 int result;
1001 struct {
1002 struct chsc_header request;
1003 u32 reserved1;
1004 u32 reserved2;
1005 u32 reserved3;
1006 struct chsc_header response;
1007 u32 reserved4;
1008 u32 general_char[510];
1009 u32 chsc_char[518];
1010 } __attribute__ ((packed)) *scsc_area;
1011
1012 scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1013 if (!scsc_area)
1014 return -ENOMEM;
1015
1016 scsc_area->request.length = 0x0010;
1017 scsc_area->request.code = 0x0010;
1018
1019 result = chsc(scsc_area);
1020 if (result) {
1021 result = (result == 3) ? -ENODEV : -EBUSY;
1022 goto exit;
1023 }
1024
1025 result = chsc_error_from_response(scsc_area->response.code);
1026 if (result == 0) {
1027 memcpy(&css_general_characteristics, scsc_area->general_char,
1028 sizeof(css_general_characteristics));
1029 memcpy(&css_chsc_characteristics, scsc_area->chsc_char,
1030 sizeof(css_chsc_characteristics));
1031 } else
1032 CIO_CRW_EVENT(2, "chsc: scsc failed (rc=%04x)\n",
1033 scsc_area->response.code);
1034 exit:
1035 free_page ((unsigned long) scsc_area);
1036 return result;
1037 }
1038
1039 EXPORT_SYMBOL_GPL(css_general_characteristics);
1040 EXPORT_SYMBOL_GPL(css_chsc_characteristics);
WRT350N Kernel Patches