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