[PATCH] s390: improve response code handling in chsc_enable_facility()
[linux-2.6.git] / 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/config.h>
14 #include <linux/slab.h>
15 #include <linux/init.h>
16 #include <linux/device.h>
17
18 #include <asm/cio.h>
19
20 #include "css.h"
21 #include "cio.h"
22 #include "cio_debug.h"
23 #include "ioasm.h"
24 #include "chsc.h"
25
26 static void *sei_page;
27
28 static int new_channel_path(int chpid);
29
30 static inline void
31 set_chp_logically_online(int chp, int onoff)
32 {
33         css[0]->chps[chp]->state = onoff;
34 }
35
36 static int
37 get_chp_status(int chp)
38 {
39         return (css[0]->chps[chp] ? css[0]->chps[chp]->state : -ENODEV);
40 }
41
42 void
43 chsc_validate_chpids(struct subchannel *sch)
44 {
45         int mask, chp;
46
47         for (chp = 0; chp <= 7; chp++) {
48                 mask = 0x80 >> chp;
49                 if (!get_chp_status(sch->schib.pmcw.chpid[chp]))
50                         /* disable using this path */
51                         sch->opm &= ~mask;
52         }
53 }
54
55 void
56 chpid_is_actually_online(int chp)
57 {
58         int state;
59
60         state = get_chp_status(chp);
61         if (state < 0) {
62                 need_rescan = 1;
63                 queue_work(slow_path_wq, &slow_path_work);
64         } else
65                 WARN_ON(!state);
66 }
67
68 /* FIXME: this is _always_ called for every subchannel. shouldn't we
69  *        process more than one at a time? */
70 static int
71 chsc_get_sch_desc_irq(struct subchannel *sch, void *page)
72 {
73         int ccode, j;
74
75         struct {
76                 struct chsc_header request;
77                 u16 reserved1a:10;
78                 u16 ssid:2;
79                 u16 reserved1b:4;
80                 u16 f_sch;        /* first subchannel */
81                 u16 reserved2;
82                 u16 l_sch;        /* last subchannel */
83                 u32 reserved3;
84                 struct chsc_header response;
85                 u32 reserved4;
86                 u8 sch_valid : 1;
87                 u8 dev_valid : 1;
88                 u8 st        : 3; /* subchannel type */
89                 u8 zeroes    : 3;
90                 u8  unit_addr;    /* unit address */
91                 u16 devno;        /* device number */
92                 u8 path_mask;
93                 u8 fla_valid_mask;
94                 u16 sch;          /* subchannel */
95                 u8 chpid[8];      /* chpids 0-7 */
96                 u16 fla[8];       /* full link addresses 0-7 */
97         } *ssd_area;
98
99         ssd_area = page;
100
101         ssd_area->request = (struct chsc_header) {
102                 .length = 0x0010,
103                 .code   = 0x0004,
104         };
105
106         ssd_area->ssid = sch->schid.ssid;
107         ssd_area->f_sch = sch->schid.sch_no;
108         ssd_area->l_sch = sch->schid.sch_no;
109
110         ccode = chsc(ssd_area);
111         if (ccode > 0) {
112                 pr_debug("chsc returned with ccode = %d\n", ccode);
113                 return (ccode == 3) ? -ENODEV : -EBUSY;
114         }
115
116         switch (ssd_area->response.code) {
117         case 0x0001: /* everything ok */
118                 break;
119         case 0x0002:
120                 CIO_CRW_EVENT(2, "Invalid command!\n");
121                 return -EINVAL;
122         case 0x0003:
123                 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
124                 return -EINVAL;
125         case 0x0004:
126                 CIO_CRW_EVENT(2, "Model does not provide ssd\n");
127                 return -EOPNOTSUPP;
128         default:
129                 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
130                               ssd_area->response.code);
131                 return -EIO;
132         }
133
134         /*
135          * ssd_area->st stores the type of the detected
136          * subchannel, with the following definitions:
137          *
138          * 0: I/O subchannel:     All fields have meaning
139          * 1: CHSC subchannel:    Only sch_val, st and sch
140          *                        have meaning
141          * 2: Message subchannel: All fields except unit_addr
142          *                        have meaning
143          * 3: ADM subchannel:     Only sch_val, st and sch
144          *                        have meaning
145          *
146          * Other types are currently undefined.
147          */
148         if (ssd_area->st > 3) { /* uhm, that looks strange... */
149                 CIO_CRW_EVENT(0, "Strange subchannel type %d"
150                               " for sch 0.%x.%04x\n", ssd_area->st,
151                               sch->schid.ssid, sch->schid.sch_no);
152                 /*
153                  * There may have been a new subchannel type defined in the
154                  * time since this code was written; since we don't know which
155                  * fields have meaning and what to do with it we just jump out
156                  */
157                 return 0;
158         } else {
159                 const char *type[4] = {"I/O", "chsc", "message", "ADM"};
160                 CIO_CRW_EVENT(6, "ssd: sch 0.%x.%04x is %s subchannel\n",
161                               sch->schid.ssid, sch->schid.sch_no,
162                               type[ssd_area->st]);
163
164                 sch->ssd_info.valid = 1;
165                 sch->ssd_info.type = ssd_area->st;
166         }
167
168         if (ssd_area->st == 0 || ssd_area->st == 2) {
169                 for (j = 0; j < 8; j++) {
170                         if (!((0x80 >> j) & ssd_area->path_mask &
171                               ssd_area->fla_valid_mask))
172                                 continue;
173                         sch->ssd_info.chpid[j] = ssd_area->chpid[j];
174                         sch->ssd_info.fla[j]   = ssd_area->fla[j];
175                 }
176         }
177         return 0;
178 }
179
180 int
181 css_get_ssd_info(struct subchannel *sch)
182 {
183         int ret;
184         void *page;
185
186         page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
187         if (!page)
188                 return -ENOMEM;
189         spin_lock_irq(&sch->lock);
190         ret = chsc_get_sch_desc_irq(sch, page);
191         if (ret) {
192                 static int cio_chsc_err_msg;
193                 
194                 if (!cio_chsc_err_msg) {
195                         printk(KERN_ERR
196                                "chsc_get_sch_descriptions:"
197                                " Error %d while doing chsc; "
198                                "processing some machine checks may "
199                                "not work\n", ret);
200                         cio_chsc_err_msg = 1;
201                 }
202         }
203         spin_unlock_irq(&sch->lock);
204         free_page((unsigned long)page);
205         if (!ret) {
206                 int j, chpid;
207                 /* Allocate channel path structures, if needed. */
208                 for (j = 0; j < 8; j++) {
209                         chpid = sch->ssd_info.chpid[j];
210                         if (chpid && (get_chp_status(chpid) < 0))
211                             new_channel_path(chpid);
212                 }
213         }
214         return ret;
215 }
216
217 static int
218 s390_subchannel_remove_chpid(struct device *dev, void *data)
219 {
220         int j;
221         int mask;
222         struct subchannel *sch;
223         struct channel_path *chpid;
224         struct schib schib;
225
226         sch = to_subchannel(dev);
227         chpid = data;
228         for (j = 0; j < 8; j++)
229                 if (sch->schib.pmcw.chpid[j] == chpid->id)
230                         break;
231         if (j >= 8)
232                 return 0;
233
234         mask = 0x80 >> j;
235         spin_lock_irq(&sch->lock);
236
237         stsch(sch->schid, &schib);
238         if (!schib.pmcw.dnv)
239                 goto out_unreg;
240         memcpy(&sch->schib, &schib, sizeof(struct schib));
241         /* Check for single path devices. */
242         if (sch->schib.pmcw.pim == 0x80)
243                 goto out_unreg;
244         if (sch->vpm == mask)
245                 goto out_unreg;
246
247         if ((sch->schib.scsw.actl & (SCSW_ACTL_CLEAR_PEND |
248                                      SCSW_ACTL_HALT_PEND |
249                                      SCSW_ACTL_START_PEND |
250                                      SCSW_ACTL_RESUME_PEND)) &&
251             (sch->schib.pmcw.lpum == mask)) {
252                 int cc = cio_cancel(sch);
253                 
254                 if (cc == -ENODEV)
255                         goto out_unreg;
256
257                 if (cc == -EINVAL) {
258                         cc = cio_clear(sch);
259                         if (cc == -ENODEV)
260                                 goto out_unreg;
261                         /* Call handler. */
262                         if (sch->driver && sch->driver->termination)
263                                 sch->driver->termination(&sch->dev);
264                         goto out_unlock;
265                 }
266         } else if ((sch->schib.scsw.actl & SCSW_ACTL_DEVACT) &&
267                    (sch->schib.scsw.actl & SCSW_ACTL_SCHACT) &&
268                    (sch->schib.pmcw.lpum == mask)) {
269                 int cc;
270
271                 cc = cio_clear(sch);
272                 if (cc == -ENODEV)
273                         goto out_unreg;
274                 /* Call handler. */
275                 if (sch->driver && sch->driver->termination)
276                         sch->driver->termination(&sch->dev);
277                 goto out_unlock;
278         }
279
280         /* trigger path verification. */
281         if (sch->driver && sch->driver->verify)
282                 sch->driver->verify(&sch->dev);
283 out_unlock:
284         spin_unlock_irq(&sch->lock);
285         return 0;
286 out_unreg:
287         spin_unlock_irq(&sch->lock);
288         sch->lpm = 0;
289         if (css_enqueue_subchannel_slow(sch->schid)) {
290                 css_clear_subchannel_slow_list();
291                 need_rescan = 1;
292         }
293         return 0;
294 }
295
296 static inline void
297 s390_set_chpid_offline( __u8 chpid)
298 {
299         char dbf_txt[15];
300         struct device *dev;
301
302         sprintf(dbf_txt, "chpr%x", chpid);
303         CIO_TRACE_EVENT(2, dbf_txt);
304
305         if (get_chp_status(chpid) <= 0)
306                 return;
307         dev = get_device(&css[0]->chps[chpid]->dev);
308         bus_for_each_dev(&css_bus_type, NULL, to_channelpath(dev),
309                          s390_subchannel_remove_chpid);
310
311         if (need_rescan || css_slow_subchannels_exist())
312                 queue_work(slow_path_wq, &slow_path_work);
313         put_device(dev);
314 }
315
316 struct res_acc_data {
317         struct channel_path *chp;
318         u32 fla_mask;
319         u16 fla;
320 };
321
322 static int
323 s390_process_res_acc_sch(struct res_acc_data *res_data, struct subchannel *sch)
324 {
325         int found;
326         int chp;
327         int ccode;
328         
329         found = 0;
330         for (chp = 0; chp <= 7; chp++)
331                 /*
332                  * check if chpid is in information updated by ssd
333                  */
334                 if (sch->ssd_info.valid &&
335                     sch->ssd_info.chpid[chp] == res_data->chp->id &&
336                     (sch->ssd_info.fla[chp] & res_data->fla_mask)
337                     == res_data->fla) {
338                         found = 1;
339                         break;
340                 }
341         
342         if (found == 0)
343                 return 0;
344
345         /*
346          * Do a stsch to update our subchannel structure with the
347          * new path information and eventually check for logically
348          * offline chpids.
349          */
350         ccode = stsch(sch->schid, &sch->schib);
351         if (ccode > 0)
352                 return 0;
353
354         return 0x80 >> chp;
355 }
356
357 static inline int
358 s390_process_res_acc_new_sch(struct subchannel_id schid)
359 {
360         struct schib schib;
361         int ret;
362         /*
363          * We don't know the device yet, but since a path
364          * may be available now to the device we'll have
365          * to do recognition again.
366          * Since we don't have any idea about which chpid
367          * that beast may be on we'll have to do a stsch
368          * on all devices, grr...
369          */
370         if (stsch_err(schid, &schib))
371                 /* We're through */
372                 return need_rescan ? -EAGAIN : -ENXIO;
373
374         /* Put it on the slow path. */
375         ret = css_enqueue_subchannel_slow(schid);
376         if (ret) {
377                 css_clear_subchannel_slow_list();
378                 need_rescan = 1;
379                 return -EAGAIN;
380         }
381         return 0;
382 }
383
384 static int
385 __s390_process_res_acc(struct subchannel_id schid, void *data)
386 {
387         int chp_mask, old_lpm;
388         struct res_acc_data *res_data;
389         struct subchannel *sch;
390
391         res_data = (struct res_acc_data *)data;
392         sch = get_subchannel_by_schid(schid);
393         if (!sch)
394                 /* Check if a subchannel is newly available. */
395                 return s390_process_res_acc_new_sch(schid);
396
397         spin_lock_irq(&sch->lock);
398
399         chp_mask = s390_process_res_acc_sch(res_data, sch);
400
401         if (chp_mask == 0) {
402                 spin_unlock_irq(&sch->lock);
403                 return 0;
404         }
405         old_lpm = sch->lpm;
406         sch->lpm = ((sch->schib.pmcw.pim &
407                      sch->schib.pmcw.pam &
408                      sch->schib.pmcw.pom)
409                     | chp_mask) & sch->opm;
410         if (!old_lpm && sch->lpm)
411                 device_trigger_reprobe(sch);
412         else if (sch->driver && sch->driver->verify)
413                 sch->driver->verify(&sch->dev);
414
415         spin_unlock_irq(&sch->lock);
416         put_device(&sch->dev);
417         return (res_data->fla_mask == 0xffff) ? -ENODEV : 0;
418 }
419
420
421 static int
422 s390_process_res_acc (struct res_acc_data *res_data)
423 {
424         int rc;
425         char dbf_txt[15];
426
427         sprintf(dbf_txt, "accpr%x", res_data->chp->id);
428         CIO_TRACE_EVENT( 2, dbf_txt);
429         if (res_data->fla != 0) {
430                 sprintf(dbf_txt, "fla%x", res_data->fla);
431                 CIO_TRACE_EVENT( 2, dbf_txt);
432         }
433
434         /*
435          * I/O resources may have become accessible.
436          * Scan through all subchannels that may be concerned and
437          * do a validation on those.
438          * The more information we have (info), the less scanning
439          * will we have to do.
440          */
441         rc = for_each_subchannel(__s390_process_res_acc, res_data);
442         if (css_slow_subchannels_exist())
443                 rc = -EAGAIN;
444         else if (rc != -EAGAIN)
445                 rc = 0;
446         return rc;
447 }
448
449 static int
450 __get_chpid_from_lir(void *data)
451 {
452         struct lir {
453                 u8  iq;
454                 u8  ic;
455                 u16 sci;
456                 /* incident-node descriptor */
457                 u32 indesc[28];
458                 /* attached-node descriptor */
459                 u32 andesc[28];
460                 /* incident-specific information */
461                 u32 isinfo[28];
462         } *lir;
463
464         lir = (struct lir*) data;
465         if (!(lir->iq&0x80))
466                 /* NULL link incident record */
467                 return -EINVAL;
468         if (!(lir->indesc[0]&0xc0000000))
469                 /* node descriptor not valid */
470                 return -EINVAL;
471         if (!(lir->indesc[0]&0x10000000))
472                 /* don't handle device-type nodes - FIXME */
473                 return -EINVAL;
474         /* Byte 3 contains the chpid. Could also be CTCA, but we don't care */
475
476         return (u16) (lir->indesc[0]&0x000000ff);
477 }
478
479 int
480 chsc_process_crw(void)
481 {
482         int chpid, ret;
483         struct res_acc_data res_data;
484         struct {
485                 struct chsc_header request;
486                 u32 reserved1;
487                 u32 reserved2;
488                 u32 reserved3;
489                 struct chsc_header response;
490                 u32 reserved4;
491                 u8  flags;
492                 u8  vf;         /* validity flags */
493                 u8  rs;         /* reporting source */
494                 u8  cc;         /* content code */
495                 u16 fla;        /* full link address */
496                 u16 rsid;       /* reporting source id */
497                 u32 reserved5;
498                 u32 reserved6;
499                 u32 ccdf[96];   /* content-code dependent field */
500                 /* ccdf has to be big enough for a link-incident record */
501         } *sei_area;
502
503         if (!sei_page)
504                 return 0;
505         /*
506          * build the chsc request block for store event information
507          * and do the call
508          * This function is only called by the machine check handler thread,
509          * so we don't need locking for the sei_page.
510          */
511         sei_area = sei_page;
512
513         CIO_TRACE_EVENT( 2, "prcss");
514         ret = 0;
515         do {
516                 int ccode, status;
517                 struct device *dev;
518                 memset(sei_area, 0, sizeof(*sei_area));
519                 memset(&res_data, 0, sizeof(struct res_acc_data));
520                 sei_area->request = (struct chsc_header) {
521                         .length = 0x0010,
522                         .code   = 0x000e,
523                 };
524
525                 ccode = chsc(sei_area);
526                 if (ccode > 0)
527                         return 0;
528
529                 switch (sei_area->response.code) {
530                         /* for debug purposes, check for problems */
531                 case 0x0001:
532                         CIO_CRW_EVENT(4, "chsc_process_crw: event information "
533                                         "successfully stored\n");
534                         break; /* everything ok */
535                 case 0x0002:
536                         CIO_CRW_EVENT(2,
537                                       "chsc_process_crw: invalid command!\n");
538                         return 0;
539                 case 0x0003:
540                         CIO_CRW_EVENT(2, "chsc_process_crw: error in chsc "
541                                       "request block!\n");
542                         return 0;
543                 case 0x0005:
544                         CIO_CRW_EVENT(2, "chsc_process_crw: no event "
545                                       "information stored\n");
546                         return 0;
547                 default:
548                         CIO_CRW_EVENT(2, "chsc_process_crw: chsc response %d\n",
549                                       sei_area->response.code);
550                         return 0;
551                 }
552
553                 /* Check if we might have lost some information. */
554                 if (sei_area->flags & 0x40)
555                         CIO_CRW_EVENT(2, "chsc_process_crw: Event information "
556                                        "has been lost due to overflow!\n");
557
558                 if (sei_area->rs != 4) {
559                         CIO_CRW_EVENT(2, "chsc_process_crw: reporting source "
560                                       "(%04X) isn't a chpid!\n",
561                                       sei_area->rsid);
562                         continue;
563                 }
564
565                 /* which kind of information was stored? */
566                 switch (sei_area->cc) {
567                 case 1: /* link incident*/
568                         CIO_CRW_EVENT(4, "chsc_process_crw: "
569                                       "channel subsystem reports link incident,"
570                                       " reporting source is chpid %x\n",
571                                       sei_area->rsid);
572                         chpid = __get_chpid_from_lir(sei_area->ccdf);
573                         if (chpid < 0)
574                                 CIO_CRW_EVENT(4, "%s: Invalid LIR, skipping\n",
575                                               __FUNCTION__);
576                         else
577                                 s390_set_chpid_offline(chpid);
578                         break;
579                         
580                 case 2: /* i/o resource accessibiliy */
581                         CIO_CRW_EVENT(4, "chsc_process_crw: "
582                                       "channel subsystem reports some I/O "
583                                       "devices may have become accessible\n");
584                         pr_debug("Data received after sei: \n");
585                         pr_debug("Validity flags: %x\n", sei_area->vf);
586                         
587                         /* allocate a new channel path structure, if needed */
588                         status = get_chp_status(sei_area->rsid);
589                         if (status < 0)
590                                 new_channel_path(sei_area->rsid);
591                         else if (!status)
592                                 break;
593                         dev = get_device(&css[0]->chps[sei_area->rsid]->dev);
594                         res_data.chp = to_channelpath(dev);
595                         pr_debug("chpid: %x", sei_area->rsid);
596                         if ((sei_area->vf & 0xc0) != 0) {
597                                 res_data.fla = sei_area->fla;
598                                 if ((sei_area->vf & 0xc0) == 0xc0) {
599                                         pr_debug(" full link addr: %x",
600                                                  sei_area->fla);
601                                         res_data.fla_mask = 0xffff;
602                                 } else {
603                                         pr_debug(" link addr: %x",
604                                                  sei_area->fla);
605                                         res_data.fla_mask = 0xff00;
606                                 }
607                         }
608                         ret = s390_process_res_acc(&res_data);
609                         pr_debug("\n\n");
610                         put_device(dev);
611                         break;
612                         
613                 default: /* other stuff */
614                         CIO_CRW_EVENT(4, "chsc_process_crw: event %d\n",
615                                       sei_area->cc);
616                         break;
617                 }
618         } while (sei_area->flags & 0x80);
619         return ret;
620 }
621
622 static inline int
623 __chp_add_new_sch(struct subchannel_id schid)
624 {
625         struct schib schib;
626         int ret;
627
628         if (stsch(schid, &schib))
629                 /* We're through */
630                 return need_rescan ? -EAGAIN : -ENXIO;
631
632         /* Put it on the slow path. */
633         ret = css_enqueue_subchannel_slow(schid);
634         if (ret) {
635                 css_clear_subchannel_slow_list();
636                 need_rescan = 1;
637                 return -EAGAIN;
638         }
639         return 0;
640 }
641
642
643 static int
644 __chp_add(struct subchannel_id schid, void *data)
645 {
646         int i;
647         struct channel_path *chp;
648         struct subchannel *sch;
649
650         chp = (struct channel_path *)data;
651         sch = get_subchannel_by_schid(schid);
652         if (!sch)
653                 /* Check if the subchannel is now available. */
654                 return __chp_add_new_sch(schid);
655         spin_lock_irq(&sch->lock);
656         for (i=0; i<8; i++)
657                 if (sch->schib.pmcw.chpid[i] == chp->id) {
658                         if (stsch(sch->schid, &sch->schib) != 0) {
659                                 /* Endgame. */
660                                 spin_unlock(&sch->lock);
661                                 return -ENXIO;
662                         }
663                         break;
664                 }
665         if (i==8) {
666                 spin_unlock(&sch->lock);
667                 return 0;
668         }
669         sch->lpm = ((sch->schib.pmcw.pim &
670                      sch->schib.pmcw.pam &
671                      sch->schib.pmcw.pom)
672                     | 0x80 >> i) & sch->opm;
673
674         if (sch->driver && sch->driver->verify)
675                 sch->driver->verify(&sch->dev);
676
677         spin_unlock_irq(&sch->lock);
678         put_device(&sch->dev);
679         return 0;
680 }
681
682 static int
683 chp_add(int chpid)
684 {
685         int rc;
686         char dbf_txt[15];
687         struct device *dev;
688
689         if (!get_chp_status(chpid))
690                 return 0; /* no need to do the rest */
691         
692         sprintf(dbf_txt, "cadd%x", chpid);
693         CIO_TRACE_EVENT(2, dbf_txt);
694
695         dev = get_device(&css[0]->chps[chpid]->dev);
696         rc = for_each_subchannel(__chp_add, to_channelpath(dev));
697         if (css_slow_subchannels_exist())
698                 rc = -EAGAIN;
699         if (rc != -EAGAIN)
700                 rc = 0;
701         put_device(dev);
702         return rc;
703 }
704
705 /* 
706  * Handling of crw machine checks with channel path source.
707  */
708 int
709 chp_process_crw(int chpid, int on)
710 {
711         if (on == 0) {
712                 /* Path has gone. We use the link incident routine.*/
713                 s390_set_chpid_offline(chpid);
714                 return 0; /* De-register is async anyway. */
715         }
716         /*
717          * Path has come. Allocate a new channel path structure,
718          * if needed.
719          */
720         if (get_chp_status(chpid) < 0)
721                 new_channel_path(chpid);
722         /* Avoid the extra overhead in process_rec_acc. */
723         return chp_add(chpid);
724 }
725
726 static inline int
727 __check_for_io_and_kill(struct subchannel *sch, int index)
728 {
729         int cc;
730
731         if (!device_is_online(sch))
732                 /* cio could be doing I/O. */
733                 return 0;
734         cc = stsch(sch->schid, &sch->schib);
735         if (cc)
736                 return 0;
737         if (sch->schib.scsw.actl && sch->schib.pmcw.lpum == (0x80 >> index)) {
738                 device_set_waiting(sch);
739                 return 1;
740         }
741         return 0;
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                 } else {
767                         sch->opm &= ~(0x80 >> chp);
768                         sch->lpm &= ~(0x80 >> chp);
769                         /*
770                          * Give running I/O a grace period in which it
771                          * can successfully terminate, even using the
772                          * just varied off path. Then kill it.
773                          */
774                         if (!__check_for_io_and_kill(sch, chp) && !sch->lpm) {
775                                 if (css_enqueue_subchannel_slow(sch->schid)) {
776                                         css_clear_subchannel_slow_list();
777                                         need_rescan = 1;
778                                 }
779                         } else if (sch->driver && sch->driver->verify)
780                                 sch->driver->verify(&sch->dev);
781                 }
782                 break;
783         }
784         spin_unlock_irqrestore(&sch->lock, flags);
785 }
786
787 static int
788 s390_subchannel_vary_chpid_off(struct device *dev, void *data)
789 {
790         struct subchannel *sch;
791         __u8 *chpid;
792
793         sch = to_subchannel(dev);
794         chpid = data;
795
796         __s390_subchannel_vary_chpid(sch, *chpid, 0);
797         return 0;
798 }
799
800 static int
801 s390_subchannel_vary_chpid_on(struct device *dev, void *data)
802 {
803         struct subchannel *sch;
804         __u8 *chpid;
805
806         sch = to_subchannel(dev);
807         chpid = data;
808
809         __s390_subchannel_vary_chpid(sch, *chpid, 1);
810         return 0;
811 }
812
813 static int
814 __s390_vary_chpid_on(struct subchannel_id schid, void *data)
815 {
816         struct schib schib;
817         struct subchannel *sch;
818
819         sch = get_subchannel_by_schid(schid);
820         if (sch) {
821                 put_device(&sch->dev);
822                 return 0;
823         }
824         if (stsch_err(schid, &schib))
825                 /* We're through */
826                 return -ENXIO;
827         /* Put it on the slow path. */
828         if (css_enqueue_subchannel_slow(schid)) {
829                 css_clear_subchannel_slow_list();
830                 need_rescan = 1;
831                 return -EAGAIN;
832         }
833         return 0;
834 }
835
836 /*
837  * Function: s390_vary_chpid
838  * Varies the specified chpid online or offline
839  */
840 static int
841 s390_vary_chpid( __u8 chpid, int on)
842 {
843         char dbf_text[15];
844         int status;
845
846         sprintf(dbf_text, on?"varyon%x":"varyoff%x", chpid);
847         CIO_TRACE_EVENT( 2, dbf_text);
848
849         status = get_chp_status(chpid);
850         if (status < 0) {
851                 printk(KERN_ERR "Can't vary unknown chpid %02X\n", chpid);
852                 return -EINVAL;
853         }
854
855         if (!on && !status) {
856                 printk(KERN_ERR "chpid %x is already offline\n", chpid);
857                 return -EINVAL;
858         }
859
860         set_chp_logically_online(chpid, on);
861
862         /*
863          * Redo PathVerification on the devices the chpid connects to
864          */
865
866         bus_for_each_dev(&css_bus_type, NULL, &chpid, on ?
867                          s390_subchannel_vary_chpid_on :
868                          s390_subchannel_vary_chpid_off);
869         if (on)
870                 /* Scan for new devices on varied on path. */
871                 for_each_subchannel(__s390_vary_chpid_on, NULL);
872         if (need_rescan || css_slow_subchannels_exist())
873                 queue_work(slow_path_wq, &slow_path_work);
874         return 0;
875 }
876
877 /*
878  * Files for the channel path entries.
879  */
880 static ssize_t
881 chp_status_show(struct device *dev, struct device_attribute *attr, char *buf)
882 {
883         struct channel_path *chp = container_of(dev, struct channel_path, dev);
884
885         if (!chp)
886                 return 0;
887         return (get_chp_status(chp->id) ? sprintf(buf, "online\n") :
888                 sprintf(buf, "offline\n"));
889 }
890
891 static ssize_t
892 chp_status_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
893 {
894         struct channel_path *cp = container_of(dev, struct channel_path, dev);
895         char cmd[10];
896         int num_args;
897         int error;
898
899         num_args = sscanf(buf, "%5s", cmd);
900         if (!num_args)
901                 return count;
902
903         if (!strnicmp(cmd, "on", 2))
904                 error = s390_vary_chpid(cp->id, 1);
905         else if (!strnicmp(cmd, "off", 3))
906                 error = s390_vary_chpid(cp->id, 0);
907         else
908                 error = -EINVAL;
909
910         return error < 0 ? error : count;
911
912 }
913
914 static DEVICE_ATTR(status, 0644, chp_status_show, chp_status_write);
915
916 static ssize_t
917 chp_type_show(struct device *dev, struct device_attribute *attr, char *buf)
918 {
919         struct channel_path *chp = container_of(dev, struct channel_path, dev);
920
921         if (!chp)
922                 return 0;
923         return sprintf(buf, "%x\n", chp->desc.desc);
924 }
925
926 static DEVICE_ATTR(type, 0444, chp_type_show, NULL);
927
928 static struct attribute * chp_attrs[] = {
929         &dev_attr_status.attr,
930         &dev_attr_type.attr,
931         NULL,
932 };
933
934 static struct attribute_group chp_attr_group = {
935         .attrs = chp_attrs,
936 };
937
938 static void
939 chp_release(struct device *dev)
940 {
941         struct channel_path *cp;
942         
943         cp = container_of(dev, struct channel_path, dev);
944         kfree(cp);
945 }
946
947 static int
948 chsc_determine_channel_path_description(int chpid,
949                                         struct channel_path_desc *desc)
950 {
951         int ccode, ret;
952
953         struct {
954                 struct chsc_header request;
955                 u32 : 24;
956                 u32 first_chpid : 8;
957                 u32 : 24;
958                 u32 last_chpid : 8;
959                 u32 zeroes1;
960                 struct chsc_header response;
961                 u32 zeroes2;
962                 struct channel_path_desc desc;
963         } *scpd_area;
964
965         scpd_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
966         if (!scpd_area)
967                 return -ENOMEM;
968
969         scpd_area->request = (struct chsc_header) {
970                 .length = 0x0010,
971                 .code   = 0x0002,
972         };
973
974         scpd_area->first_chpid = chpid;
975         scpd_area->last_chpid = chpid;
976
977         ccode = chsc(scpd_area);
978         if (ccode > 0) {
979                 ret = (ccode == 3) ? -ENODEV : -EBUSY;
980                 goto out;
981         }
982
983         switch (scpd_area->response.code) {
984         case 0x0001: /* Success. */
985                 memcpy(desc, &scpd_area->desc,
986                        sizeof(struct channel_path_desc));
987                 ret = 0;
988                 break;
989         case 0x0003: /* Invalid block. */
990         case 0x0007: /* Invalid format. */
991         case 0x0008: /* Other invalid block. */
992                 CIO_CRW_EVENT(2, "Error in chsc request block!\n");
993                 ret = -EINVAL;
994                 break;
995         case 0x0004: /* Command not provided in model. */
996                 CIO_CRW_EVENT(2, "Model does not provide scpd\n");
997                 ret = -EOPNOTSUPP;
998                 break;
999         default:
1000                 CIO_CRW_EVENT(2, "Unknown CHSC response %d\n",
1001                               scpd_area->response.code);
1002                 ret = -EIO;
1003         }
1004 out:
1005         free_page((unsigned long)scpd_area);
1006         return ret;
1007 }
1008
1009 /*
1010  * Entries for chpids on the system bus.
1011  * This replaces /proc/chpids.
1012  */
1013 static int
1014 new_channel_path(int chpid)
1015 {
1016         struct channel_path *chp;
1017         int ret;
1018
1019         chp = kmalloc(sizeof(struct channel_path), GFP_KERNEL);
1020         if (!chp)
1021                 return -ENOMEM;
1022         memset(chp, 0, sizeof(struct channel_path));
1023
1024         /* fill in status, etc. */
1025         chp->id = chpid;
1026         chp->state = 1;
1027         chp->dev = (struct device) {
1028                 .parent  = &css[0]->device,
1029                 .release = chp_release,
1030         };
1031         snprintf(chp->dev.bus_id, BUS_ID_SIZE, "chp0.%x", chpid);
1032
1033         /* Obtain channel path description and fill it in. */
1034         ret = chsc_determine_channel_path_description(chpid, &chp->desc);
1035         if (ret)
1036                 goto out_free;
1037
1038         /* make it known to the system */
1039         ret = device_register(&chp->dev);
1040         if (ret) {
1041                 printk(KERN_WARNING "%s: could not register %02x\n",
1042                        __func__, chpid);
1043                 goto out_free;
1044         }
1045         ret = sysfs_create_group(&chp->dev.kobj, &chp_attr_group);
1046         if (ret) {
1047                 device_unregister(&chp->dev);
1048                 goto out_free;
1049         } else
1050                 css[0]->chps[chpid] = chp;
1051         return ret;
1052 out_free:
1053         kfree(chp);
1054         return ret;
1055 }
1056
1057 void *
1058 chsc_get_chp_desc(struct subchannel *sch, int chp_no)
1059 {
1060         struct channel_path *chp;
1061         struct channel_path_desc *desc;
1062
1063         chp = css[0]->chps[sch->schib.pmcw.chpid[chp_no]];
1064         if (!chp)
1065                 return NULL;
1066         desc = kmalloc(sizeof(struct channel_path_desc), GFP_KERNEL);
1067         if (!desc)
1068                 return NULL;
1069         memcpy(desc, &chp->desc, sizeof(struct channel_path_desc));
1070         return desc;
1071 }
1072
1073
1074 static int __init
1075 chsc_alloc_sei_area(void)
1076 {
1077         sei_page = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1078         if (!sei_page)
1079                 printk(KERN_WARNING"Can't allocate page for processing of " \
1080                        "chsc machine checks!\n");
1081         return (sei_page ? 0 : -ENOMEM);
1082 }
1083
1084 int __init
1085 chsc_enable_facility(int operation_code)
1086 {
1087         int ret;
1088         struct {
1089                 struct chsc_header request;
1090                 u8 reserved1:4;
1091                 u8 format:4;
1092                 u8 reserved2;
1093                 u16 operation_code;
1094                 u32 reserved3;
1095                 u32 reserved4;
1096                 u32 operation_data_area[252];
1097                 struct chsc_header response;
1098                 u32 reserved5:4;
1099                 u32 format2:4;
1100                 u32 reserved6:24;
1101         } *sda_area;
1102
1103         sda_area = (void *)get_zeroed_page(GFP_KERNEL|GFP_DMA);
1104         if (!sda_area)
1105                 return -ENOMEM;
1106         sda_area->request = (struct chsc_header) {
1107                 .length = 0x0400,
1108                 .code = 0x0031,
1109         };
1110         sda_area->operation_code = operation_code;
1111
1112         ret = chsc(sda_area);
1113         if (ret > 0) {
1114                 ret = (ret == 3) ? -ENODEV : -EBUSY;
1115                 goto out;
1116         }
1117         switch (sda_area->response.code) {
1118         case 0x0001: /* everything ok */
1119                 ret = 0;
1120                 break;
1121         case 0x0003: /* invalid request block */
1122         case 0x0007:
1123                 ret = -EINVAL;
1124                 break;
1125         case 0x0004: /* command not provided */
1126         case 0x0101: /* facility not provided */
1127                 ret = -EOPNOTSUPP;
1128                 break;
1129         default: /* something went wrong */
1130                 ret = -EIO;
1131         }
1132  out:
1133         free_page((unsigned long)sda_area);
1134         return ret;
1135 }
1136
1137 subsys_initcall(chsc_alloc_sei_area);
1138
1139 struct css_general_char css_general_characteristics;
1140 struct css_chsc_char css_chsc_characteristics;
1141
1142 int __init
1143 chsc_determine_css_characteristics(void)
1144 {
1145         int result;
1146         struct {
1147                 struct chsc_header request;
1148                 u32 reserved1;
1149                 u32 reserved2;
1150                 u32 reserved3;
1151                 struct chsc_header response;
1152                 u32 reserved4;
1153                 u32 general_char[510];
1154                 u32 chsc_char[518];
1155         } *scsc_area;
1156
1157         scsc_area = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
1158         if (!scsc_area) {
1159                 printk(KERN_WARNING"cio: Was not able to determine available" \
1160                        "CHSCs due to no memory.\n");
1161                 return -ENOMEM;
1162         }
1163
1164         scsc_area->request = (struct chsc_header) {
1165                 .length = 0x0010,
1166                 .code   = 0x0010,
1167         };
1168
1169         result = chsc(scsc_area);
1170         if (result) {
1171                 printk(KERN_WARNING"cio: Was not able to determine " \
1172                        "available CHSCs, cc=%i.\n", result);
1173                 result = -EIO;
1174                 goto exit;
1175         }
1176
1177         if (scsc_area->response.code != 1) {
1178                 printk(KERN_WARNING"cio: Was not able to determine " \
1179                        "available CHSCs.\n");
1180                 result = -EIO;
1181                 goto exit;
1182         }
1183         memcpy(&css_general_characteristics, scsc_area->general_char,
1184                sizeof(css_general_characteristics));
1185         memcpy(&css_chsc_characteristics, scsc_area->chsc_char,
1186                sizeof(css_chsc_characteristics));
1187 exit:
1188         free_page ((unsigned long) scsc_area);
1189         return result;
1190 }
1191
1192 EXPORT_SYMBOL_GPL(css_general_characteristics);
1193 EXPORT_SYMBOL_GPL(css_chsc_characteristics);