Merge tag 'r8169-upstream-20061204-00' of git://electric-eye.fr.zoreil.com/home/romie...
[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
19 #include "css.h"
20 #include "cio.h"
21 #include "cio_debug.h"
22 #include "ioasm.h"
23 #include "chsc.h"
24
25 static void *sei_page;
26
27 static int new_channel_path(int chpid);
28
29 static inline void
30 set_chp_logically_online(int chp, int onoff)
31 {
32         css[0]->chps[chp]->state = onoff;
33 }
34
35 static int
36 get_chp_status(int chp)
37 {
38         return (css[0]->chps[chp] ? css[0]->chps[chp]->state : -ENODEV);
39 }
40
41 void
42 chsc_validate_chpids(struct subchannel *sch)
43 {
44         int mask, chp;
45
46         for (chp = 0; chp <= 7; chp++) {
47                 mask = 0x80 >> chp;
48                 if (!get_chp_status(sch->schib.pmcw.chpid[chp]))
49                         /* disable using this path */
50                         sch->opm &= ~mask;
51         }
52 }
53
54 void
55 chpid_is_actually_online(int chp)
56 {
57         int state;
58
59         state = get_chp_status(chp);
60         if (state < 0) {
61                 need_rescan = 1;
62                 queue_work(slow_path_wq, &slow_path_work);
63         } else
64                 WARN_ON(!state);
65 }
66
67 /* FIXME: this is _always_ called for every subchannel. shouldn't we
68  *        process more than one at a time? */
69 static int
70 chsc_get_sch_desc_irq(struct subchannel *sch, void *page)
71 {
72         int ccode, j;
73
74         struct {
75                 struct chsc_header request;
76                 u16 reserved1a:10;
77                 u16 ssid:2;
78                 u16 reserved1b:4;
79                 u16 f_sch;        /* first subchannel */
80                 u16 reserved2;
81                 u16 l_sch;        /* last subchannel */
82                 u32 reserved3;
83                 struct chsc_header response;
84                 u32 reserved4;
85                 u8 sch_valid : 1;
86                 u8 dev_valid : 1;
87                 u8 st        : 3; /* subchannel type */
88                 u8 zeroes    : 3;
89                 u8  unit_addr;    /* unit address */
90                 u16 devno;        /* device number */
91                 u8 path_mask;
92                 u8 fla_valid_mask;
93                 u16 sch;          /* subchannel */
94                 u8 chpid[8];      /* chpids 0-7 */
95                 u16 fla[8];       /* full link addresses 0-7 */
96         } *ssd_area;
97
98         ssd_area = page;
99
100         ssd_area->request.length = 0x0010;
101         ssd_area->request.code = 0x0004;
102
103         ssd_area->ssid = sch->schid.ssid;
104         ssd_area->f_sch = sch->schid.sch_no;
105         ssd_area->l_sch = sch->schid.sch_no;
106
107         ccode = chsc(ssd_area);
108         if (ccode > 0) {
109                 pr_debug("chsc returned with ccode = %d\n", ccode);
110                 return (ccode == 3) ? -ENODEV : -EBUSY;
111         }
112
113         switch (ssd_area->response.code) {
114         case 0x0001: /* everything ok */
115                 break;
116         case 0x0002:
117                 CIO_CRW_EVENT(2, "Invalid command!\n");
118                 return -EINVAL;
119         case 0x0003:
120                 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
121                 return -EINVAL;
122         case 0x0004:
123                 CIO_CRW_EVENT(2, "Model does not provide ssd\n");
124                 return -EOPNOTSUPP;
125         default:
126                 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
127                               ssd_area->response.code);
128                 return -EIO;
129         }
130
131         /*
132          * ssd_area->st stores the type of the detected
133          * subchannel, with the following definitions:
134          *
135          * 0: I/O subchannel:     All fields have meaning
136          * 1: CHSC subchannel:    Only sch_val, st and sch
137          *                        have meaning
138          * 2: Message subchannel: All fields except unit_addr
139          *                        have meaning
140          * 3: ADM subchannel:     Only sch_val, st and sch
141          *                        have meaning
142          *
143          * Other types are currently undefined.
144          */
145         if (ssd_area->st > 3) { /* uhm, that looks strange... */
146                 CIO_CRW_EVENT(0, "Strange subchannel type %d"
147                               " for sch 0.%x.%04x\n", ssd_area->st,
148                               sch->schid.ssid, sch->schid.sch_no);
149                 /*
150                  * There may have been a new subchannel type defined in the
151                  * time since this code was written; since we don't know which
152                  * fields have meaning and what to do with it we just jump out
153                  */
154                 return 0;
155         } else {
156                 const char *type[4] = {"I/O", "chsc", "message", "ADM"};
157                 CIO_CRW_EVENT(6, "ssd: sch 0.%x.%04x is %s subchannel\n",
158                               sch->schid.ssid, sch->schid.sch_no,
159                               type[ssd_area->st]);
160
161                 sch->ssd_info.valid = 1;
162                 sch->ssd_info.type = ssd_area->st;
163         }
164
165         if (ssd_area->st == 0 || ssd_area->st == 2) {
166                 for (j = 0; j < 8; j++) {
167                         if (!((0x80 >> j) & ssd_area->path_mask &
168                               ssd_area->fla_valid_mask))
169                                 continue;
170                         sch->ssd_info.chpid[j] = ssd_area->chpid[j];
171                         sch->ssd_info.fla[j]   = ssd_area->fla[j];
172                 }
173         }
174         return 0;
175 }
176
177 int
178 css_get_ssd_info(struct subchannel *sch)
179 {
180         int ret;
181         void *page;
182
183         page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
184         if (!page)
185                 return -ENOMEM;
186         spin_lock_irq(&sch->lock);
187         ret = chsc_get_sch_desc_irq(sch, page);
188         if (ret) {
189                 static int cio_chsc_err_msg;
190                 
191                 if (!cio_chsc_err_msg) {
192                         printk(KERN_ERR
193                                "chsc_get_sch_descriptions:"
194                                " Error %d while doing chsc; "
195                                "processing some machine checks may "
196                                "not work\n", ret);
197                         cio_chsc_err_msg = 1;
198                 }
199         }
200         spin_unlock_irq(&sch->lock);
201         free_page((unsigned long)page);
202         if (!ret) {
203                 int j, chpid, mask;
204                 /* Allocate channel path structures, if needed. */
205                 for (j = 0; j < 8; j++) {
206                         mask = 0x80 >> j;
207                         chpid = sch->ssd_info.chpid[j];
208                         if ((sch->schib.pmcw.pim & mask) &&
209                             (get_chp_status(chpid) < 0))
210                             new_channel_path(chpid);
211                 }
212         }
213         return ret;
214 }
215
216 static int
217 s390_subchannel_remove_chpid(struct device *dev, void *data)
218 {
219         int j;
220         int mask;
221         struct subchannel *sch;
222         struct channel_path *chpid;
223         struct schib schib;
224
225         sch = to_subchannel(dev);
226         chpid = data;
227         for (j = 0; j < 8; j++) {
228                 mask = 0x80 >> j;
229                 if ((sch->schib.pmcw.pim & mask) &&
230                     (sch->schib.pmcw.chpid[j] == chpid->id))
231                         break;
232         }
233         if (j >= 8)
234                 return 0;
235
236         spin_lock_irq(&sch->lock);
237
238         stsch(sch->schid, &schib);
239         if (!schib.pmcw.dnv)
240                 goto out_unreg;
241         memcpy(&sch->schib, &schib, sizeof(struct schib));
242         /* Check for single path devices. */
243         if (sch->schib.pmcw.pim == 0x80)
244                 goto out_unreg;
245
246         if ((sch->schib.scsw.actl & SCSW_ACTL_DEVACT) &&
247             (sch->schib.scsw.actl & SCSW_ACTL_SCHACT) &&
248             (sch->schib.pmcw.lpum == mask)) {
249                 int cc;
250
251                 cc = cio_clear(sch);
252                 if (cc == -ENODEV)
253                         goto out_unreg;
254                 /* Request retry of internal operation. */
255                 device_set_intretry(sch);
256                 /* Call handler. */
257                 if (sch->driver && sch->driver->termination)
258                         sch->driver->termination(&sch->dev);
259                 goto out_unlock;
260         }
261
262         /* trigger path verification. */
263         if (sch->driver && sch->driver->verify)
264                 sch->driver->verify(&sch->dev);
265         else if (sch->lpm == mask)
266                 goto out_unreg;
267 out_unlock:
268         spin_unlock_irq(&sch->lock);
269         return 0;
270 out_unreg:
271         spin_unlock_irq(&sch->lock);
272         sch->lpm = 0;
273         if (css_enqueue_subchannel_slow(sch->schid)) {
274                 css_clear_subchannel_slow_list();
275                 need_rescan = 1;
276         }
277         return 0;
278 }
279
280 static inline void
281 s390_set_chpid_offline( __u8 chpid)
282 {
283         char dbf_txt[15];
284         struct device *dev;
285
286         sprintf(dbf_txt, "chpr%x", chpid);
287         CIO_TRACE_EVENT(2, dbf_txt);
288
289         if (get_chp_status(chpid) <= 0)
290                 return;
291         dev = get_device(&css[0]->chps[chpid]->dev);
292         bus_for_each_dev(&css_bus_type, NULL, to_channelpath(dev),
293                          s390_subchannel_remove_chpid);
294
295         if (need_rescan || css_slow_subchannels_exist())
296                 queue_work(slow_path_wq, &slow_path_work);
297         put_device(dev);
298 }
299
300 struct res_acc_data {
301         struct channel_path *chp;
302         u32 fla_mask;
303         u16 fla;
304 };
305
306 static int
307 s390_process_res_acc_sch(struct res_acc_data *res_data, struct subchannel *sch)
308 {
309         int found;
310         int chp;
311         int ccode;
312         
313         found = 0;
314         for (chp = 0; chp <= 7; chp++)
315                 /*
316                  * check if chpid is in information updated by ssd
317                  */
318                 if (sch->ssd_info.valid &&
319                     sch->ssd_info.chpid[chp] == res_data->chp->id &&
320                     (sch->ssd_info.fla[chp] & res_data->fla_mask)
321                     == res_data->fla) {
322                         found = 1;
323                         break;
324                 }
325         
326         if (found == 0)
327                 return 0;
328
329         /*
330          * Do a stsch to update our subchannel structure with the
331          * new path information and eventually check for logically
332          * offline chpids.
333          */
334         ccode = stsch(sch->schid, &sch->schib);
335         if (ccode > 0)
336                 return 0;
337
338         return 0x80 >> chp;
339 }
340
341 static inline int
342 s390_process_res_acc_new_sch(struct subchannel_id schid)
343 {
344         struct schib schib;
345         int ret;
346         /*
347          * We don't know the device yet, but since a path
348          * may be available now to the device we'll have
349          * to do recognition again.
350          * Since we don't have any idea about which chpid
351          * that beast may be on we'll have to do a stsch
352          * on all devices, grr...
353          */
354         if (stsch_err(schid, &schib))
355                 /* We're through */
356                 return need_rescan ? -EAGAIN : -ENXIO;
357
358         /* Put it on the slow path. */
359         ret = css_enqueue_subchannel_slow(schid);
360         if (ret) {
361                 css_clear_subchannel_slow_list();
362                 need_rescan = 1;
363                 return -EAGAIN;
364         }
365         return 0;
366 }
367
368 static int
369 __s390_process_res_acc(struct subchannel_id schid, void *data)
370 {
371         int chp_mask, old_lpm;
372         struct res_acc_data *res_data;
373         struct subchannel *sch;
374
375         res_data = data;
376         sch = get_subchannel_by_schid(schid);
377         if (!sch)
378                 /* Check if a subchannel is newly available. */
379                 return s390_process_res_acc_new_sch(schid);
380
381         spin_lock_irq(&sch->lock);
382
383         chp_mask = s390_process_res_acc_sch(res_data, sch);
384
385         if (chp_mask == 0) {
386                 spin_unlock_irq(&sch->lock);
387                 put_device(&sch->dev);
388                 return 0;
389         }
390         old_lpm = sch->lpm;
391         sch->lpm = ((sch->schib.pmcw.pim &
392                      sch->schib.pmcw.pam &
393                      sch->schib.pmcw.pom)
394                     | chp_mask) & sch->opm;
395         if (!old_lpm && sch->lpm)
396                 device_trigger_reprobe(sch);
397         else if (sch->driver && sch->driver->verify)
398                 sch->driver->verify(&sch->dev);
399
400         spin_unlock_irq(&sch->lock);
401         put_device(&sch->dev);
402         return 0;
403 }
404
405
406 static int
407 s390_process_res_acc (struct res_acc_data *res_data)
408 {
409         int rc;
410         char dbf_txt[15];
411
412         sprintf(dbf_txt, "accpr%x", res_data->chp->id);
413         CIO_TRACE_EVENT( 2, dbf_txt);
414         if (res_data->fla != 0) {
415                 sprintf(dbf_txt, "fla%x", res_data->fla);
416                 CIO_TRACE_EVENT( 2, dbf_txt);
417         }
418
419         /*
420          * I/O resources may have become accessible.
421          * Scan through all subchannels that may be concerned and
422          * do a validation on those.
423          * The more information we have (info), the less scanning
424          * will we have to do.
425          */
426         rc = for_each_subchannel(__s390_process_res_acc, res_data);
427         if (css_slow_subchannels_exist())
428                 rc = -EAGAIN;
429         else if (rc != -EAGAIN)
430                 rc = 0;
431         return rc;
432 }
433
434 static int
435 __get_chpid_from_lir(void *data)
436 {
437         struct lir {
438                 u8  iq;
439                 u8  ic;
440                 u16 sci;
441                 /* incident-node descriptor */
442                 u32 indesc[28];
443                 /* attached-node descriptor */
444                 u32 andesc[28];
445                 /* incident-specific information */
446                 u32 isinfo[28];
447         } *lir;
448
449         lir = data;
450         if (!(lir->iq&0x80))
451                 /* NULL link incident record */
452                 return -EINVAL;
453         if (!(lir->indesc[0]&0xc0000000))
454                 /* node descriptor not valid */
455                 return -EINVAL;
456         if (!(lir->indesc[0]&0x10000000))
457                 /* don't handle device-type nodes - FIXME */
458                 return -EINVAL;
459         /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */
460
461         return (u16) (lir->indesc[0]&0x000000ff);
462 }
463
464 int
465 chsc_process_crw(void)
466 {
467         int chpid, ret;
468         struct res_acc_data res_data;
469         struct {
470                 struct chsc_header request;
471                 u32 reserved1;
472                 u32 reserved2;
473                 u32 reserved3;
474                 struct chsc_header response;
475                 u32 reserved4;
476                 u8  flags;
477                 u8  vf;         /* validity flags */
478                 u8  rs;         /* reporting source */
479                 u8  cc;         /* content code */
480                 u16 fla;        /* full link address */
481                 u16 rsid;       /* reporting source id */
482                 u32 reserved5;
483                 u32 reserved6;
484                 u32 ccdf[96];   /* content-code dependent field */
485                 /* ccdf has to be big enough for a link-incident record */
486         } *sei_area;
487
488         if (!sei_page)
489                 return 0;
490         /*
491          * build the chsc request block for store event information
492          * and do the call
493          * This function is only called by the machine check handler thread,
494          * so we don't need locking for the sei_page.
495          */
496         sei_area = sei_page;
497
498         CIO_TRACE_EVENT( 2, "prcss");
499         ret = 0;
500         do {
501                 int ccode, status;
502                 struct device *dev;
503                 memset(sei_area, 0, sizeof(*sei_area));
504                 memset(&res_data, 0, sizeof(struct res_acc_data));
505                 sei_area->request.length = 0x0010;
506                 sei_area->request.code = 0x000e;
507
508                 ccode = chsc(sei_area);
509                 if (ccode > 0)
510                         return 0;
511
512                 switch (sei_area->response.code) {
513                         /* for debug purposes, check for problems */
514                 case 0x0001:
515                         CIO_CRW_EVENT(4, "chsc_process_crw: event information "
516                                         "successfully stored\n");
517                         break; /* everything ok */
518                 case 0x0002:
519                         CIO_CRW_EVENT(2,
520                                       "chsc_process_crw: invalid command!\n");
521                         return 0;
522                 case 0x0003:
523                         CIO_CRW_EVENT(2, "chsc_process_crw: error in chsc "
524                                       "request block!\n");
525                         return 0;
526                 case 0x0005:
527                         CIO_CRW_EVENT(2, "chsc_process_crw: no event "
528                                       "information stored\n");
529                         return 0;
530                 default:
531                         CIO_CRW_EVENT(2, "chsc_process_crw: chsc response %d\n",
532                                       sei_area->response.code);
533                         return 0;
534                 }
535
536                 /* Check if we might have lost some information. */
537                 if (sei_area->flags & 0x40)
538                         CIO_CRW_EVENT(2, "chsc_process_crw: Event information "
539                                        "has been lost due to overflow!\n");
540
541                 if (sei_area->rs != 4) {
542                         CIO_CRW_EVENT(2, "chsc_process_crw: reporting source "
543                                       "(%04X) isn't a chpid!\n",
544                                       sei_area->rsid);
545                         continue;
546                 }
547
548                 /* which kind of information was stored? */
549                 switch (sei_area->cc) {
550                 case 1: /* link incident*/
551                         CIO_CRW_EVENT(4, "chsc_process_crw: "
552                                       "channel subsystem reports link incident,"
553                                       " reporting source is chpid %x\n",
554                                       sei_area->rsid);
555                         chpid = __get_chpid_from_lir(sei_area->ccdf);
556                         if (chpid < 0)
557                                 CIO_CRW_EVENT(4, "%s: Invalid LIR, skipping\n",
558                                               __FUNCTION__);
559                         else
560                                 s390_set_chpid_offline(chpid);
561                         break;
562                         
563                 case 2: /* i/o resource accessibiliy */
564                         CIO_CRW_EVENT(4, "chsc_process_crw: "
565                                       "channel subsystem reports some I/O "
566                                       "devices may have become accessible\n");
567                         pr_debug("Data received after sei: \n");
568                         pr_debug("Validity flags: %x\n", sei_area->vf);
569                         
570                         /* allocate a new channel path structure, if needed */
571                         status = get_chp_status(sei_area->rsid);
572                         if (status < 0)
573                                 new_channel_path(sei_area->rsid);
574                         else if (!status)
575                                 break;
576                         dev = get_device(&css[0]->chps[sei_area->rsid]->dev);
577                         res_data.chp = to_channelpath(dev);
578                         pr_debug("chpid: %x", sei_area->rsid);
579                         if ((sei_area->vf & 0xc0) != 0) {
580                                 res_data.fla = sei_area->fla;
581                                 if ((sei_area->vf & 0xc0) == 0xc0) {
582                                         pr_debug(" full link addr: %x",
583                                                  sei_area->fla);
584                                         res_data.fla_mask = 0xffff;
585                                 } else {
586                                         pr_debug(" link addr: %x",
587                                                  sei_area->fla);
588                                         res_data.fla_mask = 0xff00;
589                                 }
590                         }
591                         ret = s390_process_res_acc(&res_data);
592                         pr_debug("\n\n");
593                         put_device(dev);
594                         break;
595                         
596                 default: /* other stuff */
597                         CIO_CRW_EVENT(4, "chsc_process_crw: event %d\n",
598                                       sei_area->cc);
599                         break;
600                 }
601         } while (sei_area->flags & 0x80);
602         return ret;
603 }
604
605 static inline int
606 __chp_add_new_sch(struct subchannel_id schid)
607 {
608         struct schib schib;
609         int ret;
610
611         if (stsch(schid, &schib))
612                 /* We're through */
613                 return need_rescan ? -EAGAIN : -ENXIO;
614
615         /* Put it on the slow path. */
616         ret = css_enqueue_subchannel_slow(schid);
617         if (ret) {
618                 css_clear_subchannel_slow_list();
619                 need_rescan = 1;
620                 return -EAGAIN;
621         }
622         return 0;
623 }
624
625
626 static int
627 __chp_add(struct subchannel_id schid, void *data)
628 {
629         int i, mask;
630         struct channel_path *chp;
631         struct subchannel *sch;
632
633         chp = data;
634         sch = get_subchannel_by_schid(schid);
635         if (!sch)
636                 /* Check if the subchannel is now available. */
637                 return __chp_add_new_sch(schid);
638         spin_lock_irq(&sch->lock);
639         for (i=0; i<8; i++) {
640                 mask = 0x80 >> i;
641                 if ((sch->schib.pmcw.pim & mask) &&
642                     (sch->schib.pmcw.chpid[i] == chp->id)) {
643                         if (stsch(sch->schid, &sch->schib) != 0) {
644                                 /* Endgame. */
645                                 spin_unlock_irq(&sch->lock);
646                                 return -ENXIO;
647                         }
648                         break;
649                 }
650         }
651         if (i==8) {
652                 spin_unlock_irq(&sch->lock);
653                 return 0;
654         }
655         sch->lpm = ((sch->schib.pmcw.pim &
656                      sch->schib.pmcw.pam &
657                      sch->schib.pmcw.pom)
658                     | mask) & sch->opm;
659
660         if (sch->driver && sch->driver->verify)
661                 sch->driver->verify(&sch->dev);
662
663         spin_unlock_irq(&sch->lock);
664         put_device(&sch->dev);
665         return 0;
666 }
667
668 static int
669 chp_add(int chpid)
670 {
671         int rc;
672         char dbf_txt[15];
673         struct device *dev;
674
675         if (!get_chp_status(chpid))
676                 return 0; /* no need to do the rest */
677         
678         sprintf(dbf_txt, "cadd%x", chpid);
679         CIO_TRACE_EVENT(2, dbf_txt);
680
681         dev = get_device(&css[0]->chps[chpid]->dev);
682         rc = for_each_subchannel(__chp_add, to_channelpath(dev));
683         if (css_slow_subchannels_exist())
684                 rc = -EAGAIN;
685         if (rc != -EAGAIN)
686                 rc = 0;
687         put_device(dev);
688         return rc;
689 }
690
691 /* 
692  * Handling of crw machine checks with channel path source.
693  */
694 int
695 chp_process_crw(int chpid, int on)
696 {
697         if (on == 0) {
698                 /* Path has gone. We use the link incident routine.*/
699                 s390_set_chpid_offline(chpid);
700                 return 0; /* De-register is async anyway. */
701         }
702         /*
703          * Path has come. Allocate a new channel path structure,
704          * if needed.
705          */
706         if (get_chp_status(chpid) < 0)
707                 new_channel_path(chpid);
708         /* Avoid the extra overhead in process_rec_acc. */
709         return chp_add(chpid);
710 }
711
712 static inline int check_for_io_on_path(struct subchannel *sch, int index)
713 {
714         int cc;
715
716         cc = stsch(sch->schid, &sch->schib);
717         if (cc)
718                 return 0;
719         if (sch->schib.scsw.actl && sch->schib.pmcw.lpum == (0x80 >> index))
720                 return 1;
721         return 0;
722 }
723
724 static void terminate_internal_io(struct subchannel *sch)
725 {
726         if (cio_clear(sch)) {
727                 /* Recheck device in case clear failed. */
728                 sch->lpm = 0;
729                 if (device_trigger_verify(sch) != 0) {
730                         if(css_enqueue_subchannel_slow(sch->schid)) {
731                                 css_clear_subchannel_slow_list();
732                                 need_rescan = 1;
733                         }
734                 }
735                 return;
736         }
737         /* Request retry of internal operation. */
738         device_set_intretry(sch);
739         /* Call handler. */
740         if (sch->driver && sch->driver->termination)
741                 sch->driver->termination(&sch->dev);
742 }
743
744 static inline void
745 __s390_subchannel_vary_chpid(struct subchannel *sch, __u8 chpid, int on)
746 {
747         int chp, old_lpm;
748         unsigned long flags;
749
750         if (!sch->ssd_info.valid)
751                 return;
752         
753         spin_lock_irqsave(&sch->lock, flags);
754         old_lpm = sch->lpm;
755         for (chp = 0; chp < 8; chp++) {
756                 if (sch->ssd_info.chpid[chp] != chpid)
757                         continue;
758
759                 if (on) {
760                         sch->opm |= (0x80 >> chp);
761                         sch->lpm |= (0x80 >> chp);
762                         if (!old_lpm)
763                                 device_trigger_reprobe(sch);
764                         else if (sch->driver && sch->driver->verify)
765                                 sch->driver->verify(&sch->dev);
766                         break;
767                 }
768                 sch->opm &= ~(0x80 >> chp);
769                 sch->lpm &= ~(0x80 >> chp);
770                 if (check_for_io_on_path(sch, chp)) {
771                         if (device_is_online(sch))
772                                 /* Path verification is done after killing. */
773                                 device_kill_io(sch);
774                         else
775                                 /* Kill and retry internal I/O. */
776                                 terminate_internal_io(sch);
777                 } else if (!sch->lpm) {
778                         if (device_trigger_verify(sch) != 0) {
779                                 if (css_enqueue_subchannel_slow(sch->schid)) {
780                                         css_clear_subchannel_slow_list();
781                                         need_rescan = 1;
782                                 }
783                         }
784                 } else if (sch->driver && sch->driver->verify)
785                         sch->driver->verify(&sch->dev);
786                 break;
787         }
788         spin_unlock_irqrestore(&sch->lock, flags);
789 }
790
791 static int
792 s390_subchannel_vary_chpid_off(struct device *dev, void *data)
793 {
794         struct subchannel *sch;
795         __u8 *chpid;
796
797         sch = to_subchannel(dev);
798         chpid = data;
799
800         __s390_subchannel_vary_chpid(sch, *chpid, 0);
801         return 0;
802 }
803
804 static int
805 s390_subchannel_vary_chpid_on(struct device *dev, void *data)
806 {
807         struct subchannel *sch;
808         __u8 *chpid;
809
810         sch = to_subchannel(dev);
811         chpid = data;
812
813         __s390_subchannel_vary_chpid(sch, *chpid, 1);
814         return 0;
815 }
816
817 static int
818 __s390_vary_chpid_on(struct subchannel_id schid, void *data)
819 {
820         struct schib schib;
821         struct subchannel *sch;
822
823         sch = get_subchannel_by_schid(schid);
824         if (sch) {
825                 put_device(&sch->dev);
826                 return 0;
827         }
828         if (stsch_err(schid, &schib))
829                 /* We're through */
830                 return -ENXIO;
831         /* Put it on the slow path. */
832         if (css_enqueue_subchannel_slow(schid)) {
833                 css_clear_subchannel_slow_list();
834                 need_rescan = 1;
835                 return -EAGAIN;
836         }
837         return 0;
838 }
839
840 /*
841  * Function: s390_vary_chpid
842  * Varies the specified chpid online or offline
843  */
844 static int
845 s390_vary_chpid( __u8 chpid, int on)
846 {
847         char dbf_text[15];
848         int status;
849
850         sprintf(dbf_text, on?"varyon%x":"varyoff%x", chpid);
851         CIO_TRACE_EVENT( 2, dbf_text);
852
853         status = get_chp_status(chpid);
854         if (status < 0) {
855                 printk(KERN_ERR "Can't vary unknown chpid %02X\n", chpid);
856                 return -EINVAL;
857         }
858
859         if (!on && !status) {
860                 printk(KERN_ERR "chpid %x is already offline\n", chpid);
861                 return -EINVAL;
862         }
863
864         set_chp_logically_online(chpid, on);
865
866         /*
867          * Redo PathVerification on the devices the chpid connects to
868          */
869
870         bus_for_each_dev(&css_bus_type, NULL, &chpid, on ?
871                          s390_subchannel_vary_chpid_on :
872                          s390_subchannel_vary_chpid_off);
873         if (on)
874                 /* Scan for new devices on varied on path. */
875                 for_each_subchannel(__s390_vary_chpid_on, NULL);
876         if (need_rescan || css_slow_subchannels_exist())
877                 queue_work(slow_path_wq, &slow_path_work);
878         return 0;
879 }
880
881 /*
882  * Channel measurement related functions
883  */
884 static ssize_t
885 chp_measurement_chars_read(struct kobject *kobj, char *buf, loff_t off,
886                            size_t count)
887 {
888         struct channel_path *chp;
889         unsigned int size;
890
891         chp = to_channelpath(container_of(kobj, struct device, kobj));
892         if (!chp->cmg_chars)
893                 return 0;
894
895         size = sizeof(struct cmg_chars);
896
897         if (off > size)
898                 return 0;
899         if (off + count > size)
900                 count = size - off;
901         memcpy(buf, chp->cmg_chars + off, count);
902         return count;
903 }
904
905 static struct bin_attribute chp_measurement_chars_attr = {
906         .attr = {
907                 .name = "measurement_chars",
908                 .mode = S_IRUSR,
909                 .owner = THIS_MODULE,
910         },
911         .size = sizeof(struct cmg_chars),
912         .read = chp_measurement_chars_read,
913 };
914
915 static void
916 chp_measurement_copy_block(struct cmg_entry *buf,
917                            struct channel_subsystem *css, int chpid)
918 {
919         void *area;
920         struct cmg_entry *entry, reference_buf;
921         int idx;
922
923         if (chpid < 128) {
924                 area = css->cub_addr1;
925                 idx = chpid;
926         } else {
927                 area = css->cub_addr2;
928                 idx = chpid - 128;
929         }
930         entry = area + (idx * sizeof(struct cmg_entry));
931         do {
932                 memcpy(buf, entry, sizeof(*entry));
933                 memcpy(&reference_buf, entry, sizeof(*entry));
934         } while (reference_buf.values[0] != buf->values[0]);
935 }
936
937 static ssize_t
938 chp_measurement_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
939 {
940         struct channel_path *chp;
941         struct channel_subsystem *css;
942         unsigned int size;
943
944         chp = to_channelpath(container_of(kobj, struct device, kobj));
945         css = to_css(chp->dev.parent);
946
947         size = sizeof(struct cmg_entry);
948
949         /* Only allow single reads. */
950         if (off || count < size)
951                 return 0;
952         chp_measurement_copy_block((struct cmg_entry *)buf, css, chp->id);
953         count = size;
954         return count;
955 }
956
957 static struct bin_attribute chp_measurement_attr = {
958         .attr = {
959                 .name = "measurement",
960                 .mode = S_IRUSR,
961                 .owner = THIS_MODULE,
962         },
963         .size = sizeof(struct cmg_entry),
964         .read = chp_measurement_read,
965 };
966
967 static void
968 chsc_remove_chp_cmg_attr(struct channel_path *chp)
969 {
970         sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_chars_attr);
971         sysfs_remove_bin_file(&chp->dev.kobj, &chp_measurement_attr);
972 }
973
974 static int
975 chsc_add_chp_cmg_attr(struct channel_path *chp)
976 {
977         int ret;
978
979         ret = sysfs_create_bin_file(&chp->dev.kobj,
980                                     &chp_measurement_chars_attr);
981         if (ret)
982                 return ret;
983         ret = sysfs_create_bin_file(&chp->dev.kobj, &chp_measurement_attr);
984         if (ret)
985                 sysfs_remove_bin_file(&chp->dev.kobj,
986                                       &chp_measurement_chars_attr);
987         return ret;
988 }
989
990 static void
991 chsc_remove_cmg_attr(struct channel_subsystem *css)
992 {
993         int i;
994
995         for (i = 0; i <= __MAX_CHPID; i++) {
996                 if (!css->chps[i])
997                         continue;
998                 chsc_remove_chp_cmg_attr(css->chps[i]);
999         }
1000 }
1001
1002 static int
1003 chsc_add_cmg_attr(struct channel_subsystem *css)
1004 {
1005         int i, ret;
1006
1007         ret = 0;
1008         for (i = 0; i <= __MAX_CHPID; i++) {
1009                 if (!css->chps[i])
1010                         continue;
1011                 ret = chsc_add_chp_cmg_attr(css->chps[i]);
1012                 if (ret)
1013                         goto cleanup;
1014         }
1015         return ret;
1016 cleanup:
1017         for (--i; i >= 0; i--) {
1018                 if (!css->chps[i])
1019                         continue;
1020                 chsc_remove_chp_cmg_attr(css->chps[i]);
1021         }
1022         return ret;
1023 }
1024
1025
1026 static int
1027 __chsc_do_secm(struct channel_subsystem *css, int enable, void *page)
1028 {
1029         struct {
1030                 struct chsc_header request;
1031                 u32 operation_code : 2;
1032                 u32 : 30;
1033                 u32 key : 4;
1034                 u32 : 28;
1035                 u32 zeroes1;
1036                 u32 cub_addr1;
1037                 u32 zeroes2;
1038                 u32 cub_addr2;
1039                 u32 reserved[13];
1040                 struct chsc_header response;
1041                 u32 status : 8;
1042                 u32 : 4;
1043                 u32 fmt : 4;
1044                 u32 : 16;
1045         } *secm_area;
1046         int ret, ccode;
1047
1048         secm_area = page;
1049         secm_area->request.length = 0x0050;
1050         secm_area->request.code = 0x0016;
1051
1052         secm_area->key = PAGE_DEFAULT_KEY;
1053         secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
1054         secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
1055
1056         secm_area->operation_code = enable ? 0 : 1;
1057
1058         ccode = chsc(secm_area);
1059         if (ccode > 0)
1060                 return (ccode == 3) ? -ENODEV : -EBUSY;
1061
1062         switch (secm_area->response.code) {
1063         case 0x0001: /* Success. */
1064                 ret = 0;
1065                 break;
1066         case 0x0003: /* Invalid block. */
1067         case 0x0007: /* Invalid format. */
1068         case 0x0008: /* Other invalid block. */
1069                 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
1070                 ret = -EINVAL;
1071                 break;
1072         case 0x0004: /* Command not provided in model. */
1073                 CIO_CRW_EVENT(2, "Model does not provide secm\n");
1074                 ret = -EOPNOTSUPP;
1075                 break;
1076         case 0x0102: /* cub adresses incorrect */
1077                 CIO_CRW_EVENT(2, "Invalid addresses in chsc request block\n");
1078                 ret = -EINVAL;
1079                 break;
1080         case 0x0103: /* key error */
1081                 CIO_CRW_EVENT(2, "Access key error in secm\n");
1082                 ret = -EINVAL;
1083                 break;
1084         case 0x0105: /* error while starting */
1085                 CIO_CRW_EVENT(2, "Error while starting channel measurement\n");
1086                 ret = -EIO;
1087                 break;
1088         default:
1089                 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1090                               secm_area->response.code);
1091                 ret = -EIO;
1092         }
1093         return ret;
1094 }
1095
1096 int
1097 chsc_secm(struct channel_subsystem *css, int enable)
1098 {
1099         void  *secm_area;
1100         int ret;
1101
1102         secm_area = (void *)get_zeroed_page(GFP_KERNEL |  GFP_DMA);
1103         if (!secm_area)
1104                 return -ENOMEM;
1105
1106         mutex_lock(&css->mutex);
1107         if (enable && !css->cm_enabled) {
1108                 css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1109                 css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1110                 if (!css->cub_addr1 || !css->cub_addr2) {
1111                         free_page((unsigned long)css->cub_addr1);
1112                         free_page((unsigned long)css->cub_addr2);
1113                         free_page((unsigned long)secm_area);
1114                         mutex_unlock(&css->mutex);
1115                         return -ENOMEM;
1116                 }
1117         }
1118         ret = __chsc_do_secm(css, enable, secm_area);
1119         if (!ret) {
1120                 css->cm_enabled = enable;
1121                 if (css->cm_enabled) {
1122                         ret = chsc_add_cmg_attr(css);
1123                         if (ret) {
1124                                 memset(secm_area, 0, PAGE_SIZE);
1125                                 __chsc_do_secm(css, 0, secm_area);
1126                                 css->cm_enabled = 0;
1127                         }
1128                 } else
1129                         chsc_remove_cmg_attr(css);
1130         }
1131         if (enable && !css->cm_enabled) {
1132                 free_page((unsigned long)css->cub_addr1);
1133                 free_page((unsigned long)css->cub_addr2);
1134         }
1135         mutex_unlock(&css->mutex);
1136         free_page((unsigned long)secm_area);
1137         return ret;
1138 }
1139
1140 /*
1141  * Files for the channel path entries.
1142  */
1143 static ssize_t
1144 chp_status_show(struct device *dev, struct device_attribute *attr, char *buf)
1145 {
1146         struct channel_path *chp = container_of(dev, struct channel_path, dev);
1147
1148         if (!chp)
1149                 return 0;
1150         return (get_chp_status(chp->id) ? sprintf(buf, "online\n") :
1151                 sprintf(buf, "offline\n"));
1152 }
1153
1154 static ssize_t
1155 chp_status_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
1156 {
1157         struct channel_path *cp = container_of(dev, struct channel_path, dev);
1158         char cmd[10];
1159         int num_args;
1160         int error;
1161
1162         num_args = sscanf(buf, "%5s", cmd);
1163         if (!num_args)
1164                 return count;
1165
1166         if (!strnicmp(cmd, "on", 2))
1167                 error = s390_vary_chpid(cp->id, 1);
1168         else if (!strnicmp(cmd, "off", 3))
1169                 error = s390_vary_chpid(cp->id, 0);
1170         else
1171                 error = -EINVAL;
1172
1173         return error < 0 ? error : count;
1174
1175 }
1176
1177 static DEVICE_ATTR(status, 0644, chp_status_show, chp_status_write);
1178
1179 static ssize_t
1180 chp_type_show(struct device *dev, struct device_attribute *attr, char *buf)
1181 {
1182         struct channel_path *chp = container_of(dev, struct channel_path, dev);
1183
1184         if (!chp)
1185                 return 0;
1186         return sprintf(buf, "%x\n", chp->desc.desc);
1187 }
1188
1189 static DEVICE_ATTR(type, 0444, chp_type_show, NULL);
1190
1191 static ssize_t
1192 chp_cmg_show(struct device *dev, struct device_attribute *attr, char *buf)
1193 {
1194         struct channel_path *chp = to_channelpath(dev);
1195
1196         if (!chp)
1197                 return 0;
1198         if (chp->cmg == -1) /* channel measurements not available */
1199                 return sprintf(buf, "unknown\n");
1200         return sprintf(buf, "%x\n", chp->cmg);
1201 }
1202
1203 static DEVICE_ATTR(cmg, 0444, chp_cmg_show, NULL);
1204
1205 static ssize_t
1206 chp_shared_show(struct device *dev, struct device_attribute *attr, char *buf)
1207 {
1208         struct channel_path *chp = to_channelpath(dev);
1209
1210         if (!chp)
1211                 return 0;
1212         if (chp->shared == -1) /* channel measurements not available */
1213                 return sprintf(buf, "unknown\n");
1214         return sprintf(buf, "%x\n", chp->shared);
1215 }
1216
1217 static DEVICE_ATTR(shared, 0444, chp_shared_show, NULL);
1218
1219 static struct attribute * chp_attrs[] = {
1220         &dev_attr_status.attr,
1221         &dev_attr_type.attr,
1222         &dev_attr_cmg.attr,
1223         &dev_attr_shared.attr,
1224         NULL,
1225 };
1226
1227 static struct attribute_group chp_attr_group = {
1228         .attrs = chp_attrs,
1229 };
1230
1231 static void
1232 chp_release(struct device *dev)
1233 {
1234         struct channel_path *cp;
1235         
1236         cp = container_of(dev, struct channel_path, dev);
1237         kfree(cp);
1238 }
1239
1240 static int
1241 chsc_determine_channel_path_description(int chpid,
1242                                         struct channel_path_desc *desc)
1243 {
1244         int ccode, ret;
1245
1246         struct {
1247                 struct chsc_header request;
1248                 u32 : 24;
1249                 u32 first_chpid : 8;
1250                 u32 : 24;
1251                 u32 last_chpid : 8;
1252                 u32 zeroes1;
1253                 struct chsc_header response;
1254                 u32 zeroes2;
1255                 struct channel_path_desc desc;
1256         } *scpd_area;
1257
1258         scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1259         if (!scpd_area)
1260                 return -ENOMEM;
1261
1262         scpd_area->request.length = 0x0010;
1263         scpd_area->request.code = 0x0002;
1264
1265         scpd_area->first_chpid = chpid;
1266         scpd_area->last_chpid = chpid;
1267
1268         ccode = chsc(scpd_area);
1269         if (ccode > 0) {
1270                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
1271                 goto out;
1272         }
1273
1274         switch (scpd_area->response.code) {
1275         case 0x0001: /* Success. */
1276                 memcpy(desc, &scpd_area->desc,
1277                        sizeof(struct channel_path_desc));
1278                 ret = 0;
1279                 break;
1280         case 0x0003: /* Invalid block. */
1281         case 0x0007: /* Invalid format. */
1282         case 0x0008: /* Other invalid block. */
1283                 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
1284                 ret = -EINVAL;
1285                 break;
1286         case 0x0004: /* Command not provided in model. */
1287                 CIO_CRW_EVENT(2, "Model does not provide scpd\n");
1288                 ret = -EOPNOTSUPP;
1289                 break;
1290         default:
1291                 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1292                               scpd_area->response.code);
1293                 ret = -EIO;
1294         }
1295 out:
1296         free_page((unsigned long)scpd_area);
1297         return ret;
1298 }
1299
1300 static void
1301 chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
1302                           struct cmg_chars *chars)
1303 {
1304         switch (chp->cmg) {
1305         case 2:
1306         case 3:
1307                 chp->cmg_chars = kmalloc(sizeof(struct cmg_chars),
1308                                          GFP_KERNEL);
1309                 if (chp->cmg_chars) {
1310                         int i, mask;
1311                         struct cmg_chars *cmg_chars;
1312
1313                         cmg_chars = chp->cmg_chars;
1314                         for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
1315                                 mask = 0x80 >> (i + 3);
1316                                 if (cmcv & mask)
1317                                         cmg_chars->values[i] = chars->values[i];
1318                                 else
1319                                         cmg_chars->values[i] = 0;
1320                         }
1321                 }
1322                 break;
1323         default:
1324                 /* No cmg-dependent data. */
1325                 break;
1326         }
1327 }
1328
1329 static int
1330 chsc_get_channel_measurement_chars(struct channel_path *chp)
1331 {
1332         int ccode, ret;
1333
1334         struct {
1335                 struct chsc_header request;
1336                 u32 : 24;
1337                 u32 first_chpid : 8;
1338                 u32 : 24;
1339                 u32 last_chpid : 8;
1340                 u32 zeroes1;
1341                 struct chsc_header response;
1342                 u32 zeroes2;
1343                 u32 not_valid : 1;
1344                 u32 shared : 1;
1345                 u32 : 22;
1346                 u32 chpid : 8;
1347                 u32 cmcv : 5;
1348                 u32 : 11;
1349                 u32 cmgq : 8;
1350                 u32 cmg : 8;
1351                 u32 zeroes3;
1352                 u32 data[NR_MEASUREMENT_CHARS];
1353         } *scmc_area;
1354
1355         scmc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1356         if (!scmc_area)
1357                 return -ENOMEM;
1358
1359         scmc_area->request.length = 0x0010;
1360         scmc_area->request.code = 0x0022;
1361
1362         scmc_area->first_chpid = chp->id;
1363         scmc_area->last_chpid = chp->id;
1364
1365         ccode = chsc(scmc_area);
1366         if (ccode > 0) {
1367                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
1368                 goto out;
1369         }
1370
1371         switch (scmc_area->response.code) {
1372         case 0x0001: /* Success. */
1373                 if (!scmc_area->not_valid) {
1374                         chp->cmg = scmc_area->cmg;
1375                         chp->shared = scmc_area->shared;
1376                         chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
1377                                                   (struct cmg_chars *)
1378                                                   &scmc_area->data);
1379                 } else {
1380                         chp->cmg = -1;
1381                         chp->shared = -1;
1382                 }
1383                 ret = 0;
1384                 break;
1385         case 0x0003: /* Invalid block. */
1386         case 0x0007: /* Invalid format. */
1387         case 0x0008: /* Invalid bit combination. */
1388                 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
1389                 ret = -EINVAL;
1390                 break;
1391         case 0x0004: /* Command not provided. */
1392                 CIO_CRW_EVENT(2, "Model does not provide scmc\n");
1393                 ret = -EOPNOTSUPP;
1394                 break;
1395         default:
1396                 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1397                               scmc_area->response.code);
1398                 ret = -EIO;
1399         }
1400 out:
1401         free_page((unsigned long)scmc_area);
1402         return ret;
1403 }
1404
1405 /*
1406  * Entries for chpids on the system bus.
1407  * This replaces /proc/chpids.
1408  */
1409 static int
1410 new_channel_path(int chpid)
1411 {
1412         struct channel_path *chp;
1413         int ret;
1414
1415         chp = kzalloc(sizeof(struct channel_path), GFP_KERNEL);
1416         if (!chp)
1417                 return -ENOMEM;
1418
1419         /* fill in status, etc. */
1420         chp->id = chpid;
1421         chp->state = 1;
1422         chp->dev.parent = &css[0]->device;
1423         chp->dev.release = chp_release;
1424         snprintf(chp->dev.bus_id, BUS_ID_SIZE, "chp0.%x", chpid);
1425
1426         /* Obtain channel path description and fill it in. */
1427         ret = chsc_determine_channel_path_description(chpid, &chp->desc);
1428         if (ret)
1429                 goto out_free;
1430         /* Get channel-measurement characteristics. */
1431         if (css_characteristics_avail && css_chsc_characteristics.scmc
1432             && css_chsc_characteristics.secm) {
1433                 ret = chsc_get_channel_measurement_chars(chp);
1434                 if (ret)
1435                         goto out_free;
1436         } else {
1437                 static int msg_done;
1438
1439                 if (!msg_done) {
1440                         printk(KERN_WARNING "cio: Channel measurements not "
1441                                "available, continuing.\n");
1442                         msg_done = 1;
1443                 }
1444                 chp->cmg = -1;
1445         }
1446
1447         /* make it known to the system */
1448         ret = device_register(&chp->dev);
1449         if (ret) {
1450                 printk(KERN_WARNING "%s: could not register %02x\n",
1451                        __func__, chpid);
1452                 goto out_free;
1453         }
1454         ret = sysfs_create_group(&chp->dev.kobj, &chp_attr_group);
1455         if (ret) {
1456                 device_unregister(&chp->dev);
1457                 goto out_free;
1458         }
1459         mutex_lock(&css[0]->mutex);
1460         if (css[0]->cm_enabled) {
1461                 ret = chsc_add_chp_cmg_attr(chp);
1462                 if (ret) {
1463                         sysfs_remove_group(&chp->dev.kobj, &chp_attr_group);
1464                         device_unregister(&chp->dev);
1465                         mutex_unlock(&css[0]->mutex);
1466                         goto out_free;
1467                 }
1468         }
1469         css[0]->chps[chpid] = chp;
1470         mutex_unlock(&css[0]->mutex);
1471         return ret;
1472 out_free:
1473         kfree(chp);
1474         return ret;
1475 }
1476
1477 void *
1478 chsc_get_chp_desc(struct subchannel *sch, int chp_no)
1479 {
1480         struct channel_path *chp;
1481         struct channel_path_desc *desc;
1482
1483         chp = css[0]->chps[sch->schib.pmcw.chpid[chp_no]];
1484         if (!chp)
1485                 return NULL;
1486         desc = kmalloc(sizeof(struct channel_path_desc), GFP_KERNEL);
1487         if (!desc)
1488                 return NULL;
1489         memcpy(desc, &chp->desc, sizeof(struct channel_path_desc));
1490         return desc;
1491 }
1492
1493 static int __init
1494 chsc_alloc_sei_area(void)
1495 {
1496         sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1497         if (!sei_page)
1498                 printk(KERN_WARNING"Can't allocate page for processing of " \
1499                        "chsc machine checks!\n");
1500         return (sei_page ? 0 : -ENOMEM);
1501 }
1502
1503 int __init
1504 chsc_enable_facility(int operation_code)
1505 {
1506         int ret;
1507         struct {
1508                 struct chsc_header request;
1509                 u8 reserved1:4;
1510                 u8 format:4;
1511                 u8 reserved2;
1512                 u16 operation_code;
1513                 u32 reserved3;
1514                 u32 reserved4;
1515                 u32 operation_data_area[252];
1516                 struct chsc_header response;
1517                 u32 reserved5:4;
1518                 u32 format2:4;
1519                 u32 reserved6:24;
1520         } *sda_area;
1521
1522         sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
1523         if (!sda_area)
1524                 return -ENOMEM;
1525         sda_area->request.length = 0x0400;
1526         sda_area->request.code = 0x0031;
1527         sda_area->operation_code = operation_code;
1528
1529         ret = chsc(sda_area);
1530         if (ret > 0) {
1531                 ret = (ret == 3) ? -ENODEV : -EBUSY;
1532                 goto out;
1533         }
1534         switch (sda_area->response.code) {
1535         case 0x0001: /* everything ok */
1536                 ret = 0;
1537                 break;
1538         case 0x0003: /* invalid request block */
1539         case 0x0007:
1540                 ret = -EINVAL;
1541                 break;
1542         case 0x0004: /* command not provided */
1543         case 0x0101: /* facility not provided */
1544                 ret = -EOPNOTSUPP;
1545                 break;
1546         default: /* something went wrong */
1547                 ret = -EIO;
1548         }
1549  out:
1550         free_page((unsigned long)sda_area);
1551         return ret;
1552 }
1553
1554 subsys_initcall(chsc_alloc_sei_area);
1555
1556 struct css_general_char css_general_characteristics;
1557 struct css_chsc_char css_chsc_characteristics;
1558
1559 int __init
1560 chsc_determine_css_characteristics(void)
1561 {
1562         int result;
1563         struct {
1564                 struct chsc_header request;
1565                 u32 reserved1;
1566                 u32 reserved2;
1567                 u32 reserved3;
1568                 struct chsc_header response;
1569                 u32 reserved4;
1570                 u32 general_char[510];
1571                 u32 chsc_char[518];
1572         } *scsc_area;
1573
1574         scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1575         if (!scsc_area) {
1576                 printk(KERN_WARNING"cio: Was not able to determine available" \
1577                        "CHSCs due to no memory.\n");
1578                 return -ENOMEM;
1579         }
1580
1581         scsc_area->request.length = 0x0010;
1582         scsc_area->request.code = 0x0010;
1583
1584         result = chsc(scsc_area);
1585         if (result) {
1586                 printk(KERN_WARNING"cio: Was not able to determine " \
1587                        "available CHSCs, cc=%i.\n", result);
1588                 result = -EIO;
1589                 goto exit;
1590         }
1591
1592         if (scsc_area->response.code != 1) {
1593                 printk(KERN_WARNING"cio: Was not able to determine " \
1594                        "available CHSCs.\n");
1595                 result = -EIO;
1596                 goto exit;
1597         }
1598         memcpy(&css_general_characteristics, scsc_area->general_char,
1599                sizeof(css_general_characteristics));
1600         memcpy(&css_chsc_characteristics, scsc_area->chsc_char,
1601                sizeof(css_chsc_characteristics));
1602 exit:
1603         free_page ((unsigned long) scsc_area);
1604         return result;
1605 }
1606
1607 EXPORT_SYMBOL_GPL(css_general_characteristics);
1608 EXPORT_SYMBOL_GPL(css_chsc_characteristics);