]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - drivers/s390/block/dasd.c
[S390] dasd: ignore unsolicited interrupts for DIAG
[~shefty/rdma-dev.git] / drivers / s390 / block / dasd.c
1 /*
2  * File...........: linux/drivers/s390/block/dasd.c
3  * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
4  *                  Horst Hummel <Horst.Hummel@de.ibm.com>
5  *                  Carsten Otte <Cotte@de.ibm.com>
6  *                  Martin Schwidefsky <schwidefsky@de.ibm.com>
7  * Bugreports.to..: <Linux390@de.ibm.com>
8  * Copyright IBM Corp. 1999, 2009
9  */
10
11 #define KMSG_COMPONENT "dasd"
12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13
14 #include <linux/kmod.h>
15 #include <linux/init.h>
16 #include <linux/interrupt.h>
17 #include <linux/ctype.h>
18 #include <linux/major.h>
19 #include <linux/slab.h>
20 #include <linux/buffer_head.h>
21 #include <linux/hdreg.h>
22 #include <linux/async.h>
23 #include <linux/mutex.h>
24
25 #include <asm/ccwdev.h>
26 #include <asm/ebcdic.h>
27 #include <asm/idals.h>
28 #include <asm/itcw.h>
29 #include <asm/diag.h>
30
31 /* This is ugly... */
32 #define PRINTK_HEADER "dasd:"
33
34 #include "dasd_int.h"
35 /*
36  * SECTION: Constant definitions to be used within this file
37  */
38 #define DASD_CHANQ_MAX_SIZE 4
39
40 #define DASD_SLEEPON_START_TAG  (void *) 1
41 #define DASD_SLEEPON_END_TAG    (void *) 2
42
43 /*
44  * SECTION: exported variables of dasd.c
45  */
46 debug_info_t *dasd_debug_area;
47 struct dasd_discipline *dasd_diag_discipline_pointer;
48 void dasd_int_handler(struct ccw_device *, unsigned long, struct irb *);
49
50 MODULE_AUTHOR("Holger Smolinski <Holger.Smolinski@de.ibm.com>");
51 MODULE_DESCRIPTION("Linux on S/390 DASD device driver,"
52                    " Copyright 2000 IBM Corporation");
53 MODULE_SUPPORTED_DEVICE("dasd");
54 MODULE_LICENSE("GPL");
55
56 /*
57  * SECTION: prototypes for static functions of dasd.c
58  */
59 static int  dasd_alloc_queue(struct dasd_block *);
60 static void dasd_setup_queue(struct dasd_block *);
61 static void dasd_free_queue(struct dasd_block *);
62 static void dasd_flush_request_queue(struct dasd_block *);
63 static int dasd_flush_block_queue(struct dasd_block *);
64 static void dasd_device_tasklet(struct dasd_device *);
65 static void dasd_block_tasklet(struct dasd_block *);
66 static void do_kick_device(struct work_struct *);
67 static void do_restore_device(struct work_struct *);
68 static void do_reload_device(struct work_struct *);
69 static void dasd_return_cqr_cb(struct dasd_ccw_req *, void *);
70 static void dasd_device_timeout(unsigned long);
71 static void dasd_block_timeout(unsigned long);
72 static void __dasd_process_erp(struct dasd_device *, struct dasd_ccw_req *);
73
74 /*
75  * SECTION: Operations on the device structure.
76  */
77 static wait_queue_head_t dasd_init_waitq;
78 static wait_queue_head_t dasd_flush_wq;
79 static wait_queue_head_t generic_waitq;
80
81 /*
82  * Allocate memory for a new device structure.
83  */
84 struct dasd_device *dasd_alloc_device(void)
85 {
86         struct dasd_device *device;
87
88         device = kzalloc(sizeof(struct dasd_device), GFP_ATOMIC);
89         if (!device)
90                 return ERR_PTR(-ENOMEM);
91
92         /* Get two pages for normal block device operations. */
93         device->ccw_mem = (void *) __get_free_pages(GFP_ATOMIC | GFP_DMA, 1);
94         if (!device->ccw_mem) {
95                 kfree(device);
96                 return ERR_PTR(-ENOMEM);
97         }
98         /* Get one page for error recovery. */
99         device->erp_mem = (void *) get_zeroed_page(GFP_ATOMIC | GFP_DMA);
100         if (!device->erp_mem) {
101                 free_pages((unsigned long) device->ccw_mem, 1);
102                 kfree(device);
103                 return ERR_PTR(-ENOMEM);
104         }
105
106         dasd_init_chunklist(&device->ccw_chunks, device->ccw_mem, PAGE_SIZE*2);
107         dasd_init_chunklist(&device->erp_chunks, device->erp_mem, PAGE_SIZE);
108         spin_lock_init(&device->mem_lock);
109         atomic_set(&device->tasklet_scheduled, 0);
110         tasklet_init(&device->tasklet,
111                      (void (*)(unsigned long)) dasd_device_tasklet,
112                      (unsigned long) device);
113         INIT_LIST_HEAD(&device->ccw_queue);
114         init_timer(&device->timer);
115         device->timer.function = dasd_device_timeout;
116         device->timer.data = (unsigned long) device;
117         INIT_WORK(&device->kick_work, do_kick_device);
118         INIT_WORK(&device->restore_device, do_restore_device);
119         INIT_WORK(&device->reload_device, do_reload_device);
120         device->state = DASD_STATE_NEW;
121         device->target = DASD_STATE_NEW;
122         mutex_init(&device->state_mutex);
123
124         return device;
125 }
126
127 /*
128  * Free memory of a device structure.
129  */
130 void dasd_free_device(struct dasd_device *device)
131 {
132         kfree(device->private);
133         free_page((unsigned long) device->erp_mem);
134         free_pages((unsigned long) device->ccw_mem, 1);
135         kfree(device);
136 }
137
138 /*
139  * Allocate memory for a new device structure.
140  */
141 struct dasd_block *dasd_alloc_block(void)
142 {
143         struct dasd_block *block;
144
145         block = kzalloc(sizeof(*block), GFP_ATOMIC);
146         if (!block)
147                 return ERR_PTR(-ENOMEM);
148         /* open_count = 0 means device online but not in use */
149         atomic_set(&block->open_count, -1);
150
151         spin_lock_init(&block->request_queue_lock);
152         atomic_set(&block->tasklet_scheduled, 0);
153         tasklet_init(&block->tasklet,
154                      (void (*)(unsigned long)) dasd_block_tasklet,
155                      (unsigned long) block);
156         INIT_LIST_HEAD(&block->ccw_queue);
157         spin_lock_init(&block->queue_lock);
158         init_timer(&block->timer);
159         block->timer.function = dasd_block_timeout;
160         block->timer.data = (unsigned long) block;
161
162         return block;
163 }
164
165 /*
166  * Free memory of a device structure.
167  */
168 void dasd_free_block(struct dasd_block *block)
169 {
170         kfree(block);
171 }
172
173 /*
174  * Make a new device known to the system.
175  */
176 static int dasd_state_new_to_known(struct dasd_device *device)
177 {
178         int rc;
179
180         /*
181          * As long as the device is not in state DASD_STATE_NEW we want to
182          * keep the reference count > 0.
183          */
184         dasd_get_device(device);
185
186         if (device->block) {
187                 rc = dasd_alloc_queue(device->block);
188                 if (rc) {
189                         dasd_put_device(device);
190                         return rc;
191                 }
192         }
193         device->state = DASD_STATE_KNOWN;
194         return 0;
195 }
196
197 /*
198  * Let the system forget about a device.
199  */
200 static int dasd_state_known_to_new(struct dasd_device *device)
201 {
202         /* Disable extended error reporting for this device. */
203         dasd_eer_disable(device);
204         /* Forget the discipline information. */
205         if (device->discipline) {
206                 if (device->discipline->uncheck_device)
207                         device->discipline->uncheck_device(device);
208                 module_put(device->discipline->owner);
209         }
210         device->discipline = NULL;
211         if (device->base_discipline)
212                 module_put(device->base_discipline->owner);
213         device->base_discipline = NULL;
214         device->state = DASD_STATE_NEW;
215
216         if (device->block)
217                 dasd_free_queue(device->block);
218
219         /* Give up reference we took in dasd_state_new_to_known. */
220         dasd_put_device(device);
221         return 0;
222 }
223
224 /*
225  * Request the irq line for the device.
226  */
227 static int dasd_state_known_to_basic(struct dasd_device *device)
228 {
229         int rc;
230
231         /* Allocate and register gendisk structure. */
232         if (device->block) {
233                 rc = dasd_gendisk_alloc(device->block);
234                 if (rc)
235                         return rc;
236         }
237         /* register 'device' debug area, used for all DBF_DEV_XXX calls */
238         device->debug_area = debug_register(dev_name(&device->cdev->dev), 4, 1,
239                                             8 * sizeof(long));
240         debug_register_view(device->debug_area, &debug_sprintf_view);
241         debug_set_level(device->debug_area, DBF_WARNING);
242         DBF_DEV_EVENT(DBF_EMERG, device, "%s", "debug area created");
243
244         device->state = DASD_STATE_BASIC;
245         return 0;
246 }
247
248 /*
249  * Release the irq line for the device. Terminate any running i/o.
250  */
251 static int dasd_state_basic_to_known(struct dasd_device *device)
252 {
253         int rc;
254         if (device->block) {
255                 dasd_gendisk_free(device->block);
256                 dasd_block_clear_timer(device->block);
257         }
258         rc = dasd_flush_device_queue(device);
259         if (rc)
260                 return rc;
261         dasd_device_clear_timer(device);
262
263         DBF_DEV_EVENT(DBF_EMERG, device, "%p debug area deleted", device);
264         if (device->debug_area != NULL) {
265                 debug_unregister(device->debug_area);
266                 device->debug_area = NULL;
267         }
268         device->state = DASD_STATE_KNOWN;
269         return 0;
270 }
271
272 /*
273  * Do the initial analysis. The do_analysis function may return
274  * -EAGAIN in which case the device keeps the state DASD_STATE_BASIC
275  * until the discipline decides to continue the startup sequence
276  * by calling the function dasd_change_state. The eckd disciplines
277  * uses this to start a ccw that detects the format. The completion
278  * interrupt for this detection ccw uses the kernel event daemon to
279  * trigger the call to dasd_change_state. All this is done in the
280  * discipline code, see dasd_eckd.c.
281  * After the analysis ccw is done (do_analysis returned 0) the block
282  * device is setup.
283  * In case the analysis returns an error, the device setup is stopped
284  * (a fake disk was already added to allow formatting).
285  */
286 static int dasd_state_basic_to_ready(struct dasd_device *device)
287 {
288         int rc;
289         struct dasd_block *block;
290
291         rc = 0;
292         block = device->block;
293         /* make disk known with correct capacity */
294         if (block) {
295                 if (block->base->discipline->do_analysis != NULL)
296                         rc = block->base->discipline->do_analysis(block);
297                 if (rc) {
298                         if (rc != -EAGAIN)
299                                 device->state = DASD_STATE_UNFMT;
300                         return rc;
301                 }
302                 dasd_setup_queue(block);
303                 set_capacity(block->gdp,
304                              block->blocks << block->s2b_shift);
305                 device->state = DASD_STATE_READY;
306                 rc = dasd_scan_partitions(block);
307                 if (rc)
308                         device->state = DASD_STATE_BASIC;
309         } else {
310                 device->state = DASD_STATE_READY;
311         }
312         return rc;
313 }
314
315 /*
316  * Remove device from block device layer. Destroy dirty buffers.
317  * Forget format information. Check if the target level is basic
318  * and if it is create fake disk for formatting.
319  */
320 static int dasd_state_ready_to_basic(struct dasd_device *device)
321 {
322         int rc;
323
324         device->state = DASD_STATE_BASIC;
325         if (device->block) {
326                 struct dasd_block *block = device->block;
327                 rc = dasd_flush_block_queue(block);
328                 if (rc) {
329                         device->state = DASD_STATE_READY;
330                         return rc;
331                 }
332                 dasd_flush_request_queue(block);
333                 dasd_destroy_partitions(block);
334                 block->blocks = 0;
335                 block->bp_block = 0;
336                 block->s2b_shift = 0;
337         }
338         return 0;
339 }
340
341 /*
342  * Back to basic.
343  */
344 static int dasd_state_unfmt_to_basic(struct dasd_device *device)
345 {
346         device->state = DASD_STATE_BASIC;
347         return 0;
348 }
349
350 /*
351  * Make the device online and schedule the bottom half to start
352  * the requeueing of requests from the linux request queue to the
353  * ccw queue.
354  */
355 static int
356 dasd_state_ready_to_online(struct dasd_device * device)
357 {
358         int rc;
359         struct gendisk *disk;
360         struct disk_part_iter piter;
361         struct hd_struct *part;
362
363         if (device->discipline->ready_to_online) {
364                 rc = device->discipline->ready_to_online(device);
365                 if (rc)
366                         return rc;
367         }
368         device->state = DASD_STATE_ONLINE;
369         if (device->block) {
370                 dasd_schedule_block_bh(device->block);
371                 disk = device->block->bdev->bd_disk;
372                 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
373                 while ((part = disk_part_iter_next(&piter)))
374                         kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE);
375                 disk_part_iter_exit(&piter);
376         }
377         return 0;
378 }
379
380 /*
381  * Stop the requeueing of requests again.
382  */
383 static int dasd_state_online_to_ready(struct dasd_device *device)
384 {
385         int rc;
386         struct gendisk *disk;
387         struct disk_part_iter piter;
388         struct hd_struct *part;
389
390         if (device->discipline->online_to_ready) {
391                 rc = device->discipline->online_to_ready(device);
392                 if (rc)
393                         return rc;
394         }
395         device->state = DASD_STATE_READY;
396         if (device->block) {
397                 disk = device->block->bdev->bd_disk;
398                 disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
399                 while ((part = disk_part_iter_next(&piter)))
400                         kobject_uevent(&part_to_dev(part)->kobj, KOBJ_CHANGE);
401                 disk_part_iter_exit(&piter);
402         }
403         return 0;
404 }
405
406 /*
407  * Device startup state changes.
408  */
409 static int dasd_increase_state(struct dasd_device *device)
410 {
411         int rc;
412
413         rc = 0;
414         if (device->state == DASD_STATE_NEW &&
415             device->target >= DASD_STATE_KNOWN)
416                 rc = dasd_state_new_to_known(device);
417
418         if (!rc &&
419             device->state == DASD_STATE_KNOWN &&
420             device->target >= DASD_STATE_BASIC)
421                 rc = dasd_state_known_to_basic(device);
422
423         if (!rc &&
424             device->state == DASD_STATE_BASIC &&
425             device->target >= DASD_STATE_READY)
426                 rc = dasd_state_basic_to_ready(device);
427
428         if (!rc &&
429             device->state == DASD_STATE_UNFMT &&
430             device->target > DASD_STATE_UNFMT)
431                 rc = -EPERM;
432
433         if (!rc &&
434             device->state == DASD_STATE_READY &&
435             device->target >= DASD_STATE_ONLINE)
436                 rc = dasd_state_ready_to_online(device);
437
438         return rc;
439 }
440
441 /*
442  * Device shutdown state changes.
443  */
444 static int dasd_decrease_state(struct dasd_device *device)
445 {
446         int rc;
447
448         rc = 0;
449         if (device->state == DASD_STATE_ONLINE &&
450             device->target <= DASD_STATE_READY)
451                 rc = dasd_state_online_to_ready(device);
452
453         if (!rc &&
454             device->state == DASD_STATE_READY &&
455             device->target <= DASD_STATE_BASIC)
456                 rc = dasd_state_ready_to_basic(device);
457
458         if (!rc &&
459             device->state == DASD_STATE_UNFMT &&
460             device->target <= DASD_STATE_BASIC)
461                 rc = dasd_state_unfmt_to_basic(device);
462
463         if (!rc &&
464             device->state == DASD_STATE_BASIC &&
465             device->target <= DASD_STATE_KNOWN)
466                 rc = dasd_state_basic_to_known(device);
467
468         if (!rc &&
469             device->state == DASD_STATE_KNOWN &&
470             device->target <= DASD_STATE_NEW)
471                 rc = dasd_state_known_to_new(device);
472
473         return rc;
474 }
475
476 /*
477  * This is the main startup/shutdown routine.
478  */
479 static void dasd_change_state(struct dasd_device *device)
480 {
481         int rc;
482
483         if (device->state == device->target)
484                 /* Already where we want to go today... */
485                 return;
486         if (device->state < device->target)
487                 rc = dasd_increase_state(device);
488         else
489                 rc = dasd_decrease_state(device);
490         if (rc == -EAGAIN)
491                 return;
492         if (rc)
493                 device->target = device->state;
494
495         if (device->state == device->target)
496                 wake_up(&dasd_init_waitq);
497
498         /* let user-space know that the device status changed */
499         kobject_uevent(&device->cdev->dev.kobj, KOBJ_CHANGE);
500 }
501
502 /*
503  * Kick starter for devices that did not complete the startup/shutdown
504  * procedure or were sleeping because of a pending state.
505  * dasd_kick_device will schedule a call do do_kick_device to the kernel
506  * event daemon.
507  */
508 static void do_kick_device(struct work_struct *work)
509 {
510         struct dasd_device *device = container_of(work, struct dasd_device, kick_work);
511         mutex_lock(&device->state_mutex);
512         dasd_change_state(device);
513         mutex_unlock(&device->state_mutex);
514         dasd_schedule_device_bh(device);
515         dasd_put_device(device);
516 }
517
518 void dasd_kick_device(struct dasd_device *device)
519 {
520         dasd_get_device(device);
521         /* queue call to dasd_kick_device to the kernel event daemon. */
522         schedule_work(&device->kick_work);
523 }
524
525 /*
526  * dasd_reload_device will schedule a call do do_reload_device to the kernel
527  * event daemon.
528  */
529 static void do_reload_device(struct work_struct *work)
530 {
531         struct dasd_device *device = container_of(work, struct dasd_device,
532                                                   reload_device);
533         device->discipline->reload(device);
534         dasd_put_device(device);
535 }
536
537 void dasd_reload_device(struct dasd_device *device)
538 {
539         dasd_get_device(device);
540         /* queue call to dasd_reload_device to the kernel event daemon. */
541         schedule_work(&device->reload_device);
542 }
543 EXPORT_SYMBOL(dasd_reload_device);
544
545 /*
546  * dasd_restore_device will schedule a call do do_restore_device to the kernel
547  * event daemon.
548  */
549 static void do_restore_device(struct work_struct *work)
550 {
551         struct dasd_device *device = container_of(work, struct dasd_device,
552                                                   restore_device);
553         device->cdev->drv->restore(device->cdev);
554         dasd_put_device(device);
555 }
556
557 void dasd_restore_device(struct dasd_device *device)
558 {
559         dasd_get_device(device);
560         /* queue call to dasd_restore_device to the kernel event daemon. */
561         schedule_work(&device->restore_device);
562 }
563
564 /*
565  * Set the target state for a device and starts the state change.
566  */
567 void dasd_set_target_state(struct dasd_device *device, int target)
568 {
569         dasd_get_device(device);
570         mutex_lock(&device->state_mutex);
571         /* If we are in probeonly mode stop at DASD_STATE_READY. */
572         if (dasd_probeonly && target > DASD_STATE_READY)
573                 target = DASD_STATE_READY;
574         if (device->target != target) {
575                 if (device->state == target)
576                         wake_up(&dasd_init_waitq);
577                 device->target = target;
578         }
579         if (device->state != device->target)
580                 dasd_change_state(device);
581         mutex_unlock(&device->state_mutex);
582         dasd_put_device(device);
583 }
584
585 /*
586  * Enable devices with device numbers in [from..to].
587  */
588 static inline int _wait_for_device(struct dasd_device *device)
589 {
590         return (device->state == device->target);
591 }
592
593 void dasd_enable_device(struct dasd_device *device)
594 {
595         dasd_set_target_state(device, DASD_STATE_ONLINE);
596         if (device->state <= DASD_STATE_KNOWN)
597                 /* No discipline for device found. */
598                 dasd_set_target_state(device, DASD_STATE_NEW);
599         /* Now wait for the devices to come up. */
600         wait_event(dasd_init_waitq, _wait_for_device(device));
601 }
602
603 /*
604  * SECTION: device operation (interrupt handler, start i/o, term i/o ...)
605  */
606 #ifdef CONFIG_DASD_PROFILE
607
608 struct dasd_profile_info_t dasd_global_profile;
609 unsigned int dasd_profile_level = DASD_PROFILE_OFF;
610
611 /*
612  * Increments counter in global and local profiling structures.
613  */
614 #define dasd_profile_counter(value, counter, block) \
615 { \
616         int index; \
617         for (index = 0; index < 31 && value >> (2+index); index++); \
618         dasd_global_profile.counter[index]++; \
619         block->profile.counter[index]++; \
620 }
621
622 /*
623  * Add profiling information for cqr before execution.
624  */
625 static void dasd_profile_start(struct dasd_block *block,
626                                struct dasd_ccw_req *cqr,
627                                struct request *req)
628 {
629         struct list_head *l;
630         unsigned int counter;
631
632         if (dasd_profile_level != DASD_PROFILE_ON)
633                 return;
634
635         /* count the length of the chanq for statistics */
636         counter = 0;
637         list_for_each(l, &block->ccw_queue)
638                 if (++counter >= 31)
639                         break;
640         dasd_global_profile.dasd_io_nr_req[counter]++;
641         block->profile.dasd_io_nr_req[counter]++;
642 }
643
644 /*
645  * Add profiling information for cqr after execution.
646  */
647 static void dasd_profile_end(struct dasd_block *block,
648                              struct dasd_ccw_req *cqr,
649                              struct request *req)
650 {
651         long strtime, irqtime, endtime, tottime;        /* in microseconds */
652         long tottimeps, sectors;
653
654         if (dasd_profile_level != DASD_PROFILE_ON)
655                 return;
656
657         sectors = blk_rq_sectors(req);
658         if (!cqr->buildclk || !cqr->startclk ||
659             !cqr->stopclk || !cqr->endclk ||
660             !sectors)
661                 return;
662
663         strtime = ((cqr->startclk - cqr->buildclk) >> 12);
664         irqtime = ((cqr->stopclk - cqr->startclk) >> 12);
665         endtime = ((cqr->endclk - cqr->stopclk) >> 12);
666         tottime = ((cqr->endclk - cqr->buildclk) >> 12);
667         tottimeps = tottime / sectors;
668
669         if (!dasd_global_profile.dasd_io_reqs)
670                 memset(&dasd_global_profile, 0,
671                        sizeof(struct dasd_profile_info_t));
672         dasd_global_profile.dasd_io_reqs++;
673         dasd_global_profile.dasd_io_sects += sectors;
674
675         if (!block->profile.dasd_io_reqs)
676                 memset(&block->profile, 0,
677                        sizeof(struct dasd_profile_info_t));
678         block->profile.dasd_io_reqs++;
679         block->profile.dasd_io_sects += sectors;
680
681         dasd_profile_counter(sectors, dasd_io_secs, block);
682         dasd_profile_counter(tottime, dasd_io_times, block);
683         dasd_profile_counter(tottimeps, dasd_io_timps, block);
684         dasd_profile_counter(strtime, dasd_io_time1, block);
685         dasd_profile_counter(irqtime, dasd_io_time2, block);
686         dasd_profile_counter(irqtime / sectors, dasd_io_time2ps, block);
687         dasd_profile_counter(endtime, dasd_io_time3, block);
688 }
689 #else
690 #define dasd_profile_start(block, cqr, req) do {} while (0)
691 #define dasd_profile_end(block, cqr, req) do {} while (0)
692 #endif                          /* CONFIG_DASD_PROFILE */
693
694 /*
695  * Allocate memory for a channel program with 'cplength' channel
696  * command words and 'datasize' additional space. There are two
697  * variantes: 1) dasd_kmalloc_request uses kmalloc to get the needed
698  * memory and 2) dasd_smalloc_request uses the static ccw memory
699  * that gets allocated for each device.
700  */
701 struct dasd_ccw_req *dasd_kmalloc_request(int magic, int cplength,
702                                           int datasize,
703                                           struct dasd_device *device)
704 {
705         struct dasd_ccw_req *cqr;
706
707         /* Sanity checks */
708         BUG_ON(datasize > PAGE_SIZE ||
709              (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
710
711         cqr = kzalloc(sizeof(struct dasd_ccw_req), GFP_ATOMIC);
712         if (cqr == NULL)
713                 return ERR_PTR(-ENOMEM);
714         cqr->cpaddr = NULL;
715         if (cplength > 0) {
716                 cqr->cpaddr = kcalloc(cplength, sizeof(struct ccw1),
717                                       GFP_ATOMIC | GFP_DMA);
718                 if (cqr->cpaddr == NULL) {
719                         kfree(cqr);
720                         return ERR_PTR(-ENOMEM);
721                 }
722         }
723         cqr->data = NULL;
724         if (datasize > 0) {
725                 cqr->data = kzalloc(datasize, GFP_ATOMIC | GFP_DMA);
726                 if (cqr->data == NULL) {
727                         kfree(cqr->cpaddr);
728                         kfree(cqr);
729                         return ERR_PTR(-ENOMEM);
730                 }
731         }
732         cqr->magic =  magic;
733         set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
734         dasd_get_device(device);
735         return cqr;
736 }
737
738 struct dasd_ccw_req *dasd_smalloc_request(int magic, int cplength,
739                                           int datasize,
740                                           struct dasd_device *device)
741 {
742         unsigned long flags;
743         struct dasd_ccw_req *cqr;
744         char *data;
745         int size;
746
747         /* Sanity checks */
748         BUG_ON(datasize > PAGE_SIZE ||
749              (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
750
751         size = (sizeof(struct dasd_ccw_req) + 7L) & -8L;
752         if (cplength > 0)
753                 size += cplength * sizeof(struct ccw1);
754         if (datasize > 0)
755                 size += datasize;
756         spin_lock_irqsave(&device->mem_lock, flags);
757         cqr = (struct dasd_ccw_req *)
758                 dasd_alloc_chunk(&device->ccw_chunks, size);
759         spin_unlock_irqrestore(&device->mem_lock, flags);
760         if (cqr == NULL)
761                 return ERR_PTR(-ENOMEM);
762         memset(cqr, 0, sizeof(struct dasd_ccw_req));
763         data = (char *) cqr + ((sizeof(struct dasd_ccw_req) + 7L) & -8L);
764         cqr->cpaddr = NULL;
765         if (cplength > 0) {
766                 cqr->cpaddr = (struct ccw1 *) data;
767                 data += cplength*sizeof(struct ccw1);
768                 memset(cqr->cpaddr, 0, cplength*sizeof(struct ccw1));
769         }
770         cqr->data = NULL;
771         if (datasize > 0) {
772                 cqr->data = data;
773                 memset(cqr->data, 0, datasize);
774         }
775         cqr->magic = magic;
776         set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
777         dasd_get_device(device);
778         return cqr;
779 }
780
781 /*
782  * Free memory of a channel program. This function needs to free all the
783  * idal lists that might have been created by dasd_set_cda and the
784  * struct dasd_ccw_req itself.
785  */
786 void dasd_kfree_request(struct dasd_ccw_req *cqr, struct dasd_device *device)
787 {
788 #ifdef CONFIG_64BIT
789         struct ccw1 *ccw;
790
791         /* Clear any idals used for the request. */
792         ccw = cqr->cpaddr;
793         do {
794                 clear_normalized_cda(ccw);
795         } while (ccw++->flags & (CCW_FLAG_CC | CCW_FLAG_DC));
796 #endif
797         kfree(cqr->cpaddr);
798         kfree(cqr->data);
799         kfree(cqr);
800         dasd_put_device(device);
801 }
802
803 void dasd_sfree_request(struct dasd_ccw_req *cqr, struct dasd_device *device)
804 {
805         unsigned long flags;
806
807         spin_lock_irqsave(&device->mem_lock, flags);
808         dasd_free_chunk(&device->ccw_chunks, cqr);
809         spin_unlock_irqrestore(&device->mem_lock, flags);
810         dasd_put_device(device);
811 }
812
813 /*
814  * Check discipline magic in cqr.
815  */
816 static inline int dasd_check_cqr(struct dasd_ccw_req *cqr)
817 {
818         struct dasd_device *device;
819
820         if (cqr == NULL)
821                 return -EINVAL;
822         device = cqr->startdev;
823         if (strncmp((char *) &cqr->magic, device->discipline->ebcname, 4)) {
824                 DBF_DEV_EVENT(DBF_WARNING, device,
825                             " dasd_ccw_req 0x%08x magic doesn't match"
826                             " discipline 0x%08x",
827                             cqr->magic,
828                             *(unsigned int *) device->discipline->name);
829                 return -EINVAL;
830         }
831         return 0;
832 }
833
834 /*
835  * Terminate the current i/o and set the request to clear_pending.
836  * Timer keeps device runnig.
837  * ccw_device_clear can fail if the i/o subsystem
838  * is in a bad mood.
839  */
840 int dasd_term_IO(struct dasd_ccw_req *cqr)
841 {
842         struct dasd_device *device;
843         int retries, rc;
844         char errorstring[ERRORLENGTH];
845
846         /* Check the cqr */
847         rc = dasd_check_cqr(cqr);
848         if (rc)
849                 return rc;
850         retries = 0;
851         device = (struct dasd_device *) cqr->startdev;
852         while ((retries < 5) && (cqr->status == DASD_CQR_IN_IO)) {
853                 rc = ccw_device_clear(device->cdev, (long) cqr);
854                 switch (rc) {
855                 case 0: /* termination successful */
856                         cqr->retries--;
857                         cqr->status = DASD_CQR_CLEAR_PENDING;
858                         cqr->stopclk = get_clock();
859                         cqr->starttime = 0;
860                         DBF_DEV_EVENT(DBF_DEBUG, device,
861                                       "terminate cqr %p successful",
862                                       cqr);
863                         break;
864                 case -ENODEV:
865                         DBF_DEV_EVENT(DBF_ERR, device, "%s",
866                                       "device gone, retry");
867                         break;
868                 case -EIO:
869                         DBF_DEV_EVENT(DBF_ERR, device, "%s",
870                                       "I/O error, retry");
871                         break;
872                 case -EINVAL:
873                 case -EBUSY:
874                         DBF_DEV_EVENT(DBF_ERR, device, "%s",
875                                       "device busy, retry later");
876                         break;
877                 default:
878                         /* internal error 10 - unknown rc*/
879                         snprintf(errorstring, ERRORLENGTH, "10 %d", rc);
880                         dev_err(&device->cdev->dev, "An error occurred in the "
881                                 "DASD device driver, reason=%s\n", errorstring);
882                         BUG();
883                         break;
884                 }
885                 retries++;
886         }
887         dasd_schedule_device_bh(device);
888         return rc;
889 }
890
891 /*
892  * Start the i/o. This start_IO can fail if the channel is really busy.
893  * In that case set up a timer to start the request later.
894  */
895 int dasd_start_IO(struct dasd_ccw_req *cqr)
896 {
897         struct dasd_device *device;
898         int rc;
899         char errorstring[ERRORLENGTH];
900
901         /* Check the cqr */
902         rc = dasd_check_cqr(cqr);
903         if (rc) {
904                 cqr->intrc = rc;
905                 return rc;
906         }
907         device = (struct dasd_device *) cqr->startdev;
908         if (cqr->retries < 0) {
909                 /* internal error 14 - start_IO run out of retries */
910                 sprintf(errorstring, "14 %p", cqr);
911                 dev_err(&device->cdev->dev, "An error occurred in the DASD "
912                         "device driver, reason=%s\n", errorstring);
913                 cqr->status = DASD_CQR_ERROR;
914                 return -EIO;
915         }
916         cqr->startclk = get_clock();
917         cqr->starttime = jiffies;
918         cqr->retries--;
919         if (cqr->cpmode == 1) {
920                 rc = ccw_device_tm_start(device->cdev, cqr->cpaddr,
921                                          (long) cqr, cqr->lpm);
922         } else {
923                 rc = ccw_device_start(device->cdev, cqr->cpaddr,
924                                       (long) cqr, cqr->lpm, 0);
925         }
926         switch (rc) {
927         case 0:
928                 cqr->status = DASD_CQR_IN_IO;
929                 break;
930         case -EBUSY:
931                 DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
932                               "start_IO: device busy, retry later");
933                 break;
934         case -ETIMEDOUT:
935                 DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
936                               "start_IO: request timeout, retry later");
937                 break;
938         case -EACCES:
939                 /* -EACCES indicates that the request used only a
940                  * subset of the available pathes and all these
941                  * pathes are gone.
942                  * Do a retry with all available pathes.
943                  */
944                 cqr->lpm = LPM_ANYPATH;
945                 DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
946                               "start_IO: selected pathes gone,"
947                               " retry on all pathes");
948                 break;
949         case -ENODEV:
950                 DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
951                               "start_IO: -ENODEV device gone, retry");
952                 break;
953         case -EIO:
954                 DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
955                               "start_IO: -EIO device gone, retry");
956                 break;
957         case -EINVAL:
958                 /* most likely caused in power management context */
959                 DBF_DEV_EVENT(DBF_DEBUG, device, "%s",
960                               "start_IO: -EINVAL device currently "
961                               "not accessible");
962                 break;
963         default:
964                 /* internal error 11 - unknown rc */
965                 snprintf(errorstring, ERRORLENGTH, "11 %d", rc);
966                 dev_err(&device->cdev->dev,
967                         "An error occurred in the DASD device driver, "
968                         "reason=%s\n", errorstring);
969                 BUG();
970                 break;
971         }
972         cqr->intrc = rc;
973         return rc;
974 }
975
976 /*
977  * Timeout function for dasd devices. This is used for different purposes
978  *  1) missing interrupt handler for normal operation
979  *  2) delayed start of request where start_IO failed with -EBUSY
980  *  3) timeout for missing state change interrupts
981  * The head of the ccw queue will have status DASD_CQR_IN_IO for 1),
982  * DASD_CQR_QUEUED for 2) and 3).
983  */
984 static void dasd_device_timeout(unsigned long ptr)
985 {
986         unsigned long flags;
987         struct dasd_device *device;
988
989         device = (struct dasd_device *) ptr;
990         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
991         /* re-activate request queue */
992         dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING);
993         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
994         dasd_schedule_device_bh(device);
995 }
996
997 /*
998  * Setup timeout for a device in jiffies.
999  */
1000 void dasd_device_set_timer(struct dasd_device *device, int expires)
1001 {
1002         if (expires == 0)
1003                 del_timer(&device->timer);
1004         else
1005                 mod_timer(&device->timer, jiffies + expires);
1006 }
1007
1008 /*
1009  * Clear timeout for a device.
1010  */
1011 void dasd_device_clear_timer(struct dasd_device *device)
1012 {
1013         del_timer(&device->timer);
1014 }
1015
1016 static void dasd_handle_killed_request(struct ccw_device *cdev,
1017                                        unsigned long intparm)
1018 {
1019         struct dasd_ccw_req *cqr;
1020         struct dasd_device *device;
1021
1022         if (!intparm)
1023                 return;
1024         cqr = (struct dasd_ccw_req *) intparm;
1025         if (cqr->status != DASD_CQR_IN_IO) {
1026                 DBF_EVENT_DEVID(DBF_DEBUG, cdev,
1027                                 "invalid status in handle_killed_request: "
1028                                 "%02x", cqr->status);
1029                 return;
1030         }
1031
1032         device = dasd_device_from_cdev_locked(cdev);
1033         if (IS_ERR(device)) {
1034                 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
1035                                 "unable to get device from cdev");
1036                 return;
1037         }
1038
1039         if (!cqr->startdev ||
1040             device != cqr->startdev ||
1041             strncmp(cqr->startdev->discipline->ebcname,
1042                     (char *) &cqr->magic, 4)) {
1043                 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
1044                                 "invalid device in request");
1045                 dasd_put_device(device);
1046                 return;
1047         }
1048
1049         /* Schedule request to be retried. */
1050         cqr->status = DASD_CQR_QUEUED;
1051
1052         dasd_device_clear_timer(device);
1053         dasd_schedule_device_bh(device);
1054         dasd_put_device(device);
1055 }
1056
1057 void dasd_generic_handle_state_change(struct dasd_device *device)
1058 {
1059         /* First of all start sense subsystem status request. */
1060         dasd_eer_snss(device);
1061
1062         dasd_device_remove_stop_bits(device, DASD_STOPPED_PENDING);
1063         dasd_schedule_device_bh(device);
1064         if (device->block)
1065                 dasd_schedule_block_bh(device->block);
1066 }
1067
1068 /*
1069  * Interrupt handler for "normal" ssch-io based dasd devices.
1070  */
1071 void dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
1072                       struct irb *irb)
1073 {
1074         struct dasd_ccw_req *cqr, *next;
1075         struct dasd_device *device;
1076         unsigned long long now;
1077         int expires;
1078
1079         if (IS_ERR(irb)) {
1080                 switch (PTR_ERR(irb)) {
1081                 case -EIO:
1082                         break;
1083                 case -ETIMEDOUT:
1084                         DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: "
1085                                         "request timed out\n", __func__);
1086                         break;
1087                 default:
1088                         DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s: "
1089                                         "unknown error %ld\n", __func__,
1090                                         PTR_ERR(irb));
1091                 }
1092                 dasd_handle_killed_request(cdev, intparm);
1093                 return;
1094         }
1095
1096         now = get_clock();
1097
1098         /* check for unsolicited interrupts */
1099         cqr = (struct dasd_ccw_req *) intparm;
1100         if (!cqr || ((scsw_cc(&irb->scsw) == 1) &&
1101                      (scsw_fctl(&irb->scsw) & SCSW_FCTL_START_FUNC) &&
1102                      ((scsw_stctl(&irb->scsw) == SCSW_STCTL_STATUS_PEND) ||
1103                       (scsw_stctl(&irb->scsw) == (SCSW_STCTL_STATUS_PEND |
1104                                                   SCSW_STCTL_ALERT_STATUS))))) {
1105                 if (cqr && cqr->status == DASD_CQR_IN_IO)
1106                         cqr->status = DASD_CQR_QUEUED;
1107                 if (cqr)
1108                         memcpy(&cqr->irb, irb, sizeof(*irb));
1109                 device = dasd_device_from_cdev_locked(cdev);
1110                 if (IS_ERR(device))
1111                         return;
1112                 /* ignore unsolicited interrupts for DIAG discipline */
1113                 if (device->discipline == dasd_diag_discipline_pointer) {
1114                         dasd_put_device(device);
1115                         return;
1116                 }
1117                 device->discipline->dump_sense_dbf(device, irb,
1118                                                    "unsolicited");
1119                 if ((device->features & DASD_FEATURE_ERPLOG))
1120                         device->discipline->dump_sense(device, cqr,
1121                                                        irb);
1122                 dasd_device_clear_timer(device);
1123                 device->discipline->handle_unsolicited_interrupt(device,
1124                                                                  irb);
1125                 dasd_put_device(device);
1126                 return;
1127         }
1128
1129         device = (struct dasd_device *) cqr->startdev;
1130         if (!device ||
1131             strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
1132                 DBF_EVENT_DEVID(DBF_DEBUG, cdev, "%s",
1133                                 "invalid device in request");
1134                 return;
1135         }
1136
1137         /* Check for clear pending */
1138         if (cqr->status == DASD_CQR_CLEAR_PENDING &&
1139             scsw_fctl(&irb->scsw) & SCSW_FCTL_CLEAR_FUNC) {
1140                 cqr->status = DASD_CQR_CLEARED;
1141                 dasd_device_clear_timer(device);
1142                 wake_up(&dasd_flush_wq);
1143                 dasd_schedule_device_bh(device);
1144                 return;
1145         }
1146
1147         /* check status - the request might have been killed by dyn detach */
1148         if (cqr->status != DASD_CQR_IN_IO) {
1149                 DBF_DEV_EVENT(DBF_DEBUG, device, "invalid status: bus_id %s, "
1150                               "status %02x", dev_name(&cdev->dev), cqr->status);
1151                 return;
1152         }
1153
1154         next = NULL;
1155         expires = 0;
1156         if (scsw_dstat(&irb->scsw) == (DEV_STAT_CHN_END | DEV_STAT_DEV_END) &&
1157             scsw_cstat(&irb->scsw) == 0) {
1158                 /* request was completed successfully */
1159                 cqr->status = DASD_CQR_SUCCESS;
1160                 cqr->stopclk = now;
1161                 /* Start first request on queue if possible -> fast_io. */
1162                 if (cqr->devlist.next != &device->ccw_queue) {
1163                         next = list_entry(cqr->devlist.next,
1164                                           struct dasd_ccw_req, devlist);
1165                 }
1166         } else {  /* error */
1167                 memcpy(&cqr->irb, irb, sizeof(struct irb));
1168                 /* log sense for every failed I/O to s390 debugfeature */
1169                 dasd_log_sense_dbf(cqr, irb);
1170                 if (device->features & DASD_FEATURE_ERPLOG) {
1171                         dasd_log_sense(cqr, irb);
1172                 }
1173
1174                 /*
1175                  * If we don't want complex ERP for this request, then just
1176                  * reset this and retry it in the fastpath
1177                  */
1178                 if (!test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags) &&
1179                     cqr->retries > 0) {
1180                         if (cqr->lpm == LPM_ANYPATH)
1181                                 DBF_DEV_EVENT(DBF_DEBUG, device,
1182                                               "default ERP in fastpath "
1183                                               "(%i retries left)",
1184                                               cqr->retries);
1185                         cqr->lpm    = LPM_ANYPATH;
1186                         cqr->status = DASD_CQR_QUEUED;
1187                         next = cqr;
1188                 } else
1189                         cqr->status = DASD_CQR_ERROR;
1190         }
1191         if (next && (next->status == DASD_CQR_QUEUED) &&
1192             (!device->stopped)) {
1193                 if (device->discipline->start_IO(next) == 0)
1194                         expires = next->expires;
1195         }
1196         if (expires != 0)
1197                 dasd_device_set_timer(device, expires);
1198         else
1199                 dasd_device_clear_timer(device);
1200         dasd_schedule_device_bh(device);
1201 }
1202
1203 enum uc_todo dasd_generic_uc_handler(struct ccw_device *cdev, struct irb *irb)
1204 {
1205         struct dasd_device *device;
1206
1207         device = dasd_device_from_cdev_locked(cdev);
1208
1209         if (IS_ERR(device))
1210                 goto out;
1211         if (test_bit(DASD_FLAG_OFFLINE, &device->flags) ||
1212            device->state != device->target ||
1213            !device->discipline->handle_unsolicited_interrupt){
1214                 dasd_put_device(device);
1215                 goto out;
1216         }
1217
1218         dasd_device_clear_timer(device);
1219         device->discipline->handle_unsolicited_interrupt(device, irb);
1220         dasd_put_device(device);
1221 out:
1222         return UC_TODO_RETRY;
1223 }
1224 EXPORT_SYMBOL_GPL(dasd_generic_uc_handler);
1225
1226 /*
1227  * If we have an error on a dasd_block layer request then we cancel
1228  * and return all further requests from the same dasd_block as well.
1229  */
1230 static void __dasd_device_recovery(struct dasd_device *device,
1231                                    struct dasd_ccw_req *ref_cqr)
1232 {
1233         struct list_head *l, *n;
1234         struct dasd_ccw_req *cqr;
1235
1236         /*
1237          * only requeue request that came from the dasd_block layer
1238          */
1239         if (!ref_cqr->block)
1240                 return;
1241
1242         list_for_each_safe(l, n, &device->ccw_queue) {
1243                 cqr = list_entry(l, struct dasd_ccw_req, devlist);
1244                 if (cqr->status == DASD_CQR_QUEUED &&
1245                     ref_cqr->block == cqr->block) {
1246                         cqr->status = DASD_CQR_CLEARED;
1247                 }
1248         }
1249 };
1250
1251 /*
1252  * Remove those ccw requests from the queue that need to be returned
1253  * to the upper layer.
1254  */
1255 static void __dasd_device_process_ccw_queue(struct dasd_device *device,
1256                                             struct list_head *final_queue)
1257 {
1258         struct list_head *l, *n;
1259         struct dasd_ccw_req *cqr;
1260
1261         /* Process request with final status. */
1262         list_for_each_safe(l, n, &device->ccw_queue) {
1263                 cqr = list_entry(l, struct dasd_ccw_req, devlist);
1264
1265                 /* Stop list processing at the first non-final request. */
1266                 if (cqr->status == DASD_CQR_QUEUED ||
1267                     cqr->status == DASD_CQR_IN_IO ||
1268                     cqr->status == DASD_CQR_CLEAR_PENDING)
1269                         break;
1270                 if (cqr->status == DASD_CQR_ERROR) {
1271                         __dasd_device_recovery(device, cqr);
1272                 }
1273                 /* Rechain finished requests to final queue */
1274                 list_move_tail(&cqr->devlist, final_queue);
1275         }
1276 }
1277
1278 /*
1279  * the cqrs from the final queue are returned to the upper layer
1280  * by setting a dasd_block state and calling the callback function
1281  */
1282 static void __dasd_device_process_final_queue(struct dasd_device *device,
1283                                               struct list_head *final_queue)
1284 {
1285         struct list_head *l, *n;
1286         struct dasd_ccw_req *cqr;
1287         struct dasd_block *block;
1288         void (*callback)(struct dasd_ccw_req *, void *data);
1289         void *callback_data;
1290         char errorstring[ERRORLENGTH];
1291
1292         list_for_each_safe(l, n, final_queue) {
1293                 cqr = list_entry(l, struct dasd_ccw_req, devlist);
1294                 list_del_init(&cqr->devlist);
1295                 block = cqr->block;
1296                 callback = cqr->callback;
1297                 callback_data = cqr->callback_data;
1298                 if (block)
1299                         spin_lock_bh(&block->queue_lock);
1300                 switch (cqr->status) {
1301                 case DASD_CQR_SUCCESS:
1302                         cqr->status = DASD_CQR_DONE;
1303                         break;
1304                 case DASD_CQR_ERROR:
1305                         cqr->status = DASD_CQR_NEED_ERP;
1306                         break;
1307                 case DASD_CQR_CLEARED:
1308                         cqr->status = DASD_CQR_TERMINATED;
1309                         break;
1310                 default:
1311                         /* internal error 12 - wrong cqr status*/
1312                         snprintf(errorstring, ERRORLENGTH, "12 %p %x02", cqr, cqr->status);
1313                         dev_err(&device->cdev->dev,
1314                                 "An error occurred in the DASD device driver, "
1315                                 "reason=%s\n", errorstring);
1316                         BUG();
1317                 }
1318                 if (cqr->callback != NULL)
1319                         (callback)(cqr, callback_data);
1320                 if (block)
1321                         spin_unlock_bh(&block->queue_lock);
1322         }
1323 }
1324
1325 /*
1326  * Take a look at the first request on the ccw queue and check
1327  * if it reached its expire time. If so, terminate the IO.
1328  */
1329 static void __dasd_device_check_expire(struct dasd_device *device)
1330 {
1331         struct dasd_ccw_req *cqr;
1332
1333         if (list_empty(&device->ccw_queue))
1334                 return;
1335         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist);
1336         if ((cqr->status == DASD_CQR_IN_IO && cqr->expires != 0) &&
1337             (time_after_eq(jiffies, cqr->expires + cqr->starttime))) {
1338                 if (device->discipline->term_IO(cqr) != 0) {
1339                         /* Hmpf, try again in 5 sec */
1340                         dev_err(&device->cdev->dev,
1341                                 "cqr %p timed out (%lus) but cannot be "
1342                                 "ended, retrying in 5 s\n",
1343                                 cqr, (cqr->expires/HZ));
1344                         cqr->expires += 5*HZ;
1345                         dasd_device_set_timer(device, 5*HZ);
1346                 } else {
1347                         dev_err(&device->cdev->dev,
1348                                 "cqr %p timed out (%lus), %i retries "
1349                                 "remaining\n", cqr, (cqr->expires/HZ),
1350                                 cqr->retries);
1351                 }
1352         }
1353 }
1354
1355 /*
1356  * Take a look at the first request on the ccw queue and check
1357  * if it needs to be started.
1358  */
1359 static void __dasd_device_start_head(struct dasd_device *device)
1360 {
1361         struct dasd_ccw_req *cqr;
1362         int rc;
1363
1364         if (list_empty(&device->ccw_queue))
1365                 return;
1366         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist);
1367         if (cqr->status != DASD_CQR_QUEUED)
1368                 return;
1369         /* when device is stopped, return request to previous layer */
1370         if (device->stopped) {
1371                 cqr->status = DASD_CQR_CLEARED;
1372                 dasd_schedule_device_bh(device);
1373                 return;
1374         }
1375
1376         rc = device->discipline->start_IO(cqr);
1377         if (rc == 0)
1378                 dasd_device_set_timer(device, cqr->expires);
1379         else if (rc == -EACCES) {
1380                 dasd_schedule_device_bh(device);
1381         } else
1382                 /* Hmpf, try again in 1/2 sec */
1383                 dasd_device_set_timer(device, 50);
1384 }
1385
1386 /*
1387  * Go through all request on the dasd_device request queue,
1388  * terminate them on the cdev if necessary, and return them to the
1389  * submitting layer via callback.
1390  * Note:
1391  * Make sure that all 'submitting layers' still exist when
1392  * this function is called!. In other words, when 'device' is a base
1393  * device then all block layer requests must have been removed before
1394  * via dasd_flush_block_queue.
1395  */
1396 int dasd_flush_device_queue(struct dasd_device *device)
1397 {
1398         struct dasd_ccw_req *cqr, *n;
1399         int rc;
1400         struct list_head flush_queue;
1401
1402         INIT_LIST_HEAD(&flush_queue);
1403         spin_lock_irq(get_ccwdev_lock(device->cdev));
1404         rc = 0;
1405         list_for_each_entry_safe(cqr, n, &device->ccw_queue, devlist) {
1406                 /* Check status and move request to flush_queue */
1407                 switch (cqr->status) {
1408                 case DASD_CQR_IN_IO:
1409                         rc = device->discipline->term_IO(cqr);
1410                         if (rc) {
1411                                 /* unable to terminate requeust */
1412                                 dev_err(&device->cdev->dev,
1413                                         "Flushing the DASD request queue "
1414                                         "failed for request %p\n", cqr);
1415                                 /* stop flush processing */
1416                                 goto finished;
1417                         }
1418                         break;
1419                 case DASD_CQR_QUEUED:
1420                         cqr->stopclk = get_clock();
1421                         cqr->status = DASD_CQR_CLEARED;
1422                         break;
1423                 default: /* no need to modify the others */
1424                         break;
1425                 }
1426                 list_move_tail(&cqr->devlist, &flush_queue);
1427         }
1428 finished:
1429         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1430         /*
1431          * After this point all requests must be in state CLEAR_PENDING,
1432          * CLEARED, SUCCESS or ERROR. Now wait for CLEAR_PENDING to become
1433          * one of the others.
1434          */
1435         list_for_each_entry_safe(cqr, n, &flush_queue, devlist)
1436                 wait_event(dasd_flush_wq,
1437                            (cqr->status != DASD_CQR_CLEAR_PENDING));
1438         /*
1439          * Now set each request back to TERMINATED, DONE or NEED_ERP
1440          * and call the callback function of flushed requests
1441          */
1442         __dasd_device_process_final_queue(device, &flush_queue);
1443         return rc;
1444 }
1445
1446 /*
1447  * Acquire the device lock and process queues for the device.
1448  */
1449 static void dasd_device_tasklet(struct dasd_device *device)
1450 {
1451         struct list_head final_queue;
1452
1453         atomic_set (&device->tasklet_scheduled, 0);
1454         INIT_LIST_HEAD(&final_queue);
1455         spin_lock_irq(get_ccwdev_lock(device->cdev));
1456         /* Check expire time of first request on the ccw queue. */
1457         __dasd_device_check_expire(device);
1458         /* find final requests on ccw queue */
1459         __dasd_device_process_ccw_queue(device, &final_queue);
1460         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1461         /* Now call the callback function of requests with final status */
1462         __dasd_device_process_final_queue(device, &final_queue);
1463         spin_lock_irq(get_ccwdev_lock(device->cdev));
1464         /* Now check if the head of the ccw queue needs to be started. */
1465         __dasd_device_start_head(device);
1466         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1467         dasd_put_device(device);
1468 }
1469
1470 /*
1471  * Schedules a call to dasd_tasklet over the device tasklet.
1472  */
1473 void dasd_schedule_device_bh(struct dasd_device *device)
1474 {
1475         /* Protect against rescheduling. */
1476         if (atomic_cmpxchg (&device->tasklet_scheduled, 0, 1) != 0)
1477                 return;
1478         dasd_get_device(device);
1479         tasklet_hi_schedule(&device->tasklet);
1480 }
1481
1482 void dasd_device_set_stop_bits(struct dasd_device *device, int bits)
1483 {
1484         device->stopped |= bits;
1485 }
1486 EXPORT_SYMBOL_GPL(dasd_device_set_stop_bits);
1487
1488 void dasd_device_remove_stop_bits(struct dasd_device *device, int bits)
1489 {
1490         device->stopped &= ~bits;
1491         if (!device->stopped)
1492                 wake_up(&generic_waitq);
1493 }
1494 EXPORT_SYMBOL_GPL(dasd_device_remove_stop_bits);
1495
1496 /*
1497  * Queue a request to the head of the device ccw_queue.
1498  * Start the I/O if possible.
1499  */
1500 void dasd_add_request_head(struct dasd_ccw_req *cqr)
1501 {
1502         struct dasd_device *device;
1503         unsigned long flags;
1504
1505         device = cqr->startdev;
1506         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
1507         cqr->status = DASD_CQR_QUEUED;
1508         list_add(&cqr->devlist, &device->ccw_queue);
1509         /* let the bh start the request to keep them in order */
1510         dasd_schedule_device_bh(device);
1511         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
1512 }
1513
1514 /*
1515  * Queue a request to the tail of the device ccw_queue.
1516  * Start the I/O if possible.
1517  */
1518 void dasd_add_request_tail(struct dasd_ccw_req *cqr)
1519 {
1520         struct dasd_device *device;
1521         unsigned long flags;
1522
1523         device = cqr->startdev;
1524         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
1525         cqr->status = DASD_CQR_QUEUED;
1526         list_add_tail(&cqr->devlist, &device->ccw_queue);
1527         /* let the bh start the request to keep them in order */
1528         dasd_schedule_device_bh(device);
1529         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
1530 }
1531
1532 /*
1533  * Wakeup helper for the 'sleep_on' functions.
1534  */
1535 static void dasd_wakeup_cb(struct dasd_ccw_req *cqr, void *data)
1536 {
1537         spin_lock_irq(get_ccwdev_lock(cqr->startdev->cdev));
1538         cqr->callback_data = DASD_SLEEPON_END_TAG;
1539         spin_unlock_irq(get_ccwdev_lock(cqr->startdev->cdev));
1540         wake_up(&generic_waitq);
1541 }
1542
1543 static inline int _wait_for_wakeup(struct dasd_ccw_req *cqr)
1544 {
1545         struct dasd_device *device;
1546         int rc;
1547
1548         device = cqr->startdev;
1549         spin_lock_irq(get_ccwdev_lock(device->cdev));
1550         rc = (cqr->callback_data == DASD_SLEEPON_END_TAG);
1551         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1552         return rc;
1553 }
1554
1555 /*
1556  * checks if error recovery is necessary, returns 1 if yes, 0 otherwise.
1557  */
1558 static int __dasd_sleep_on_erp(struct dasd_ccw_req *cqr)
1559 {
1560         struct dasd_device *device;
1561         dasd_erp_fn_t erp_fn;
1562
1563         if (cqr->status == DASD_CQR_FILLED)
1564                 return 0;
1565         device = cqr->startdev;
1566         if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) {
1567                 if (cqr->status == DASD_CQR_TERMINATED) {
1568                         device->discipline->handle_terminated_request(cqr);
1569                         return 1;
1570                 }
1571                 if (cqr->status == DASD_CQR_NEED_ERP) {
1572                         erp_fn = device->discipline->erp_action(cqr);
1573                         erp_fn(cqr);
1574                         return 1;
1575                 }
1576                 if (cqr->status == DASD_CQR_FAILED)
1577                         dasd_log_sense(cqr, &cqr->irb);
1578                 if (cqr->refers) {
1579                         __dasd_process_erp(device, cqr);
1580                         return 1;
1581                 }
1582         }
1583         return 0;
1584 }
1585
1586 static int __dasd_sleep_on_loop_condition(struct dasd_ccw_req *cqr)
1587 {
1588         if (test_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags)) {
1589                 if (cqr->refers) /* erp is not done yet */
1590                         return 1;
1591                 return ((cqr->status != DASD_CQR_DONE) &&
1592                         (cqr->status != DASD_CQR_FAILED));
1593         } else
1594                 return (cqr->status == DASD_CQR_FILLED);
1595 }
1596
1597 static int _dasd_sleep_on(struct dasd_ccw_req *maincqr, int interruptible)
1598 {
1599         struct dasd_device *device;
1600         int rc;
1601         struct list_head ccw_queue;
1602         struct dasd_ccw_req *cqr;
1603
1604         INIT_LIST_HEAD(&ccw_queue);
1605         maincqr->status = DASD_CQR_FILLED;
1606         device = maincqr->startdev;
1607         list_add(&maincqr->blocklist, &ccw_queue);
1608         for (cqr = maincqr;  __dasd_sleep_on_loop_condition(cqr);
1609              cqr = list_first_entry(&ccw_queue,
1610                                     struct dasd_ccw_req, blocklist)) {
1611
1612                 if (__dasd_sleep_on_erp(cqr))
1613                         continue;
1614                 if (cqr->status != DASD_CQR_FILLED) /* could be failed */
1615                         continue;
1616
1617                 /* Non-temporary stop condition will trigger fail fast */
1618                 if (device->stopped & ~DASD_STOPPED_PENDING &&
1619                     test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
1620                     (!dasd_eer_enabled(device))) {
1621                         cqr->status = DASD_CQR_FAILED;
1622                         continue;
1623                 }
1624
1625                 /* Don't try to start requests if device is stopped */
1626                 if (interruptible) {
1627                         rc = wait_event_interruptible(
1628                                 generic_waitq, !(device->stopped));
1629                         if (rc == -ERESTARTSYS) {
1630                                 cqr->status = DASD_CQR_FAILED;
1631                                 maincqr->intrc = rc;
1632                                 continue;
1633                         }
1634                 } else
1635                         wait_event(generic_waitq, !(device->stopped));
1636
1637                 cqr->callback = dasd_wakeup_cb;
1638                 cqr->callback_data = DASD_SLEEPON_START_TAG;
1639                 dasd_add_request_tail(cqr);
1640                 if (interruptible) {
1641                         rc = wait_event_interruptible(
1642                                 generic_waitq, _wait_for_wakeup(cqr));
1643                         if (rc == -ERESTARTSYS) {
1644                                 dasd_cancel_req(cqr);
1645                                 /* wait (non-interruptible) for final status */
1646                                 wait_event(generic_waitq,
1647                                            _wait_for_wakeup(cqr));
1648                                 cqr->status = DASD_CQR_FAILED;
1649                                 maincqr->intrc = rc;
1650                                 continue;
1651                         }
1652                 } else
1653                         wait_event(generic_waitq, _wait_for_wakeup(cqr));
1654         }
1655
1656         maincqr->endclk = get_clock();
1657         if ((maincqr->status != DASD_CQR_DONE) &&
1658             (maincqr->intrc != -ERESTARTSYS))
1659                 dasd_log_sense(maincqr, &maincqr->irb);
1660         if (maincqr->status == DASD_CQR_DONE)
1661                 rc = 0;
1662         else if (maincqr->intrc)
1663                 rc = maincqr->intrc;
1664         else
1665                 rc = -EIO;
1666         return rc;
1667 }
1668
1669 /*
1670  * Queue a request to the tail of the device ccw_queue and wait for
1671  * it's completion.
1672  */
1673 int dasd_sleep_on(struct dasd_ccw_req *cqr)
1674 {
1675         return _dasd_sleep_on(cqr, 0);
1676 }
1677
1678 /*
1679  * Queue a request to the tail of the device ccw_queue and wait
1680  * interruptible for it's completion.
1681  */
1682 int dasd_sleep_on_interruptible(struct dasd_ccw_req *cqr)
1683 {
1684         return _dasd_sleep_on(cqr, 1);
1685 }
1686
1687 /*
1688  * Whoa nelly now it gets really hairy. For some functions (e.g. steal lock
1689  * for eckd devices) the currently running request has to be terminated
1690  * and be put back to status queued, before the special request is added
1691  * to the head of the queue. Then the special request is waited on normally.
1692  */
1693 static inline int _dasd_term_running_cqr(struct dasd_device *device)
1694 {
1695         struct dasd_ccw_req *cqr;
1696
1697         if (list_empty(&device->ccw_queue))
1698                 return 0;
1699         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, devlist);
1700         return device->discipline->term_IO(cqr);
1701 }
1702
1703 int dasd_sleep_on_immediatly(struct dasd_ccw_req *cqr)
1704 {
1705         struct dasd_device *device;
1706         int rc;
1707
1708         device = cqr->startdev;
1709         spin_lock_irq(get_ccwdev_lock(device->cdev));
1710         rc = _dasd_term_running_cqr(device);
1711         if (rc) {
1712                 spin_unlock_irq(get_ccwdev_lock(device->cdev));
1713                 return rc;
1714         }
1715
1716         cqr->callback = dasd_wakeup_cb;
1717         cqr->callback_data = DASD_SLEEPON_START_TAG;
1718         cqr->status = DASD_CQR_QUEUED;
1719         list_add(&cqr->devlist, &device->ccw_queue);
1720
1721         /* let the bh start the request to keep them in order */
1722         dasd_schedule_device_bh(device);
1723
1724         spin_unlock_irq(get_ccwdev_lock(device->cdev));
1725
1726         wait_event(generic_waitq, _wait_for_wakeup(cqr));
1727
1728         if (cqr->status == DASD_CQR_DONE)
1729                 rc = 0;
1730         else if (cqr->intrc)
1731                 rc = cqr->intrc;
1732         else
1733                 rc = -EIO;
1734         return rc;
1735 }
1736
1737 /*
1738  * Cancels a request that was started with dasd_sleep_on_req.
1739  * This is useful to timeout requests. The request will be
1740  * terminated if it is currently in i/o.
1741  * Returns 1 if the request has been terminated.
1742  *         0 if there was no need to terminate the request (not started yet)
1743  *         negative error code if termination failed
1744  * Cancellation of a request is an asynchronous operation! The calling
1745  * function has to wait until the request is properly returned via callback.
1746  */
1747 int dasd_cancel_req(struct dasd_ccw_req *cqr)
1748 {
1749         struct dasd_device *device = cqr->startdev;
1750         unsigned long flags;
1751         int rc;
1752
1753         rc = 0;
1754         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
1755         switch (cqr->status) {
1756         case DASD_CQR_QUEUED:
1757                 /* request was not started - just set to cleared */
1758                 cqr->status = DASD_CQR_CLEARED;
1759                 break;
1760         case DASD_CQR_IN_IO:
1761                 /* request in IO - terminate IO and release again */
1762                 rc = device->discipline->term_IO(cqr);
1763                 if (rc) {
1764                         dev_err(&device->cdev->dev,
1765                                 "Cancelling request %p failed with rc=%d\n",
1766                                 cqr, rc);
1767                 } else {
1768                         cqr->stopclk = get_clock();
1769                 }
1770                 break;
1771         default: /* already finished or clear pending - do nothing */
1772                 break;
1773         }
1774         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
1775         dasd_schedule_device_bh(device);
1776         return rc;
1777 }
1778
1779
1780 /*
1781  * SECTION: Operations of the dasd_block layer.
1782  */
1783
1784 /*
1785  * Timeout function for dasd_block. This is used when the block layer
1786  * is waiting for something that may not come reliably, (e.g. a state
1787  * change interrupt)
1788  */
1789 static void dasd_block_timeout(unsigned long ptr)
1790 {
1791         unsigned long flags;
1792         struct dasd_block *block;
1793
1794         block = (struct dasd_block *) ptr;
1795         spin_lock_irqsave(get_ccwdev_lock(block->base->cdev), flags);
1796         /* re-activate request queue */
1797         dasd_device_remove_stop_bits(block->base, DASD_STOPPED_PENDING);
1798         spin_unlock_irqrestore(get_ccwdev_lock(block->base->cdev), flags);
1799         dasd_schedule_block_bh(block);
1800 }
1801
1802 /*
1803  * Setup timeout for a dasd_block in jiffies.
1804  */
1805 void dasd_block_set_timer(struct dasd_block *block, int expires)
1806 {
1807         if (expires == 0)
1808                 del_timer(&block->timer);
1809         else
1810                 mod_timer(&block->timer, jiffies + expires);
1811 }
1812
1813 /*
1814  * Clear timeout for a dasd_block.
1815  */
1816 void dasd_block_clear_timer(struct dasd_block *block)
1817 {
1818         del_timer(&block->timer);
1819 }
1820
1821 /*
1822  * Process finished error recovery ccw.
1823  */
1824 static void __dasd_process_erp(struct dasd_device *device,
1825                                struct dasd_ccw_req *cqr)
1826 {
1827         dasd_erp_fn_t erp_fn;
1828
1829         if (cqr->status == DASD_CQR_DONE)
1830                 DBF_DEV_EVENT(DBF_NOTICE, device, "%s", "ERP successful");
1831         else
1832                 dev_err(&device->cdev->dev, "ERP failed for the DASD\n");
1833         erp_fn = device->discipline->erp_postaction(cqr);
1834         erp_fn(cqr);
1835 }
1836
1837 /*
1838  * Fetch requests from the block device queue.
1839  */
1840 static void __dasd_process_request_queue(struct dasd_block *block)
1841 {
1842         struct request_queue *queue;
1843         struct request *req;
1844         struct dasd_ccw_req *cqr;
1845         struct dasd_device *basedev;
1846         unsigned long flags;
1847         queue = block->request_queue;
1848         basedev = block->base;
1849         /* No queue ? Then there is nothing to do. */
1850         if (queue == NULL)
1851                 return;
1852
1853         /*
1854          * We requeue request from the block device queue to the ccw
1855          * queue only in two states. In state DASD_STATE_READY the
1856          * partition detection is done and we need to requeue requests
1857          * for that. State DASD_STATE_ONLINE is normal block device
1858          * operation.
1859          */
1860         if (basedev->state < DASD_STATE_READY) {
1861                 while ((req = blk_fetch_request(block->request_queue)))
1862                         __blk_end_request_all(req, -EIO);
1863                 return;
1864         }
1865         /* Now we try to fetch requests from the request queue */
1866         while (!blk_queue_plugged(queue) && (req = blk_peek_request(queue))) {
1867                 if (basedev->features & DASD_FEATURE_READONLY &&
1868                     rq_data_dir(req) == WRITE) {
1869                         DBF_DEV_EVENT(DBF_ERR, basedev,
1870                                       "Rejecting write request %p",
1871                                       req);
1872                         blk_start_request(req);
1873                         __blk_end_request_all(req, -EIO);
1874                         continue;
1875                 }
1876                 cqr = basedev->discipline->build_cp(basedev, block, req);
1877                 if (IS_ERR(cqr)) {
1878                         if (PTR_ERR(cqr) == -EBUSY)
1879                                 break;  /* normal end condition */
1880                         if (PTR_ERR(cqr) == -ENOMEM)
1881                                 break;  /* terminate request queue loop */
1882                         if (PTR_ERR(cqr) == -EAGAIN) {
1883                                 /*
1884                                  * The current request cannot be build right
1885                                  * now, we have to try later. If this request
1886                                  * is the head-of-queue we stop the device
1887                                  * for 1/2 second.
1888                                  */
1889                                 if (!list_empty(&block->ccw_queue))
1890                                         break;
1891                                 spin_lock_irqsave(
1892                                         get_ccwdev_lock(basedev->cdev), flags);
1893                                 dasd_device_set_stop_bits(basedev,
1894                                                           DASD_STOPPED_PENDING);
1895                                 spin_unlock_irqrestore(
1896                                         get_ccwdev_lock(basedev->cdev), flags);
1897                                 dasd_block_set_timer(block, HZ/2);
1898                                 break;
1899                         }
1900                         DBF_DEV_EVENT(DBF_ERR, basedev,
1901                                       "CCW creation failed (rc=%ld) "
1902                                       "on request %p",
1903                                       PTR_ERR(cqr), req);
1904                         blk_start_request(req);
1905                         __blk_end_request_all(req, -EIO);
1906                         continue;
1907                 }
1908                 /*
1909                  *  Note: callback is set to dasd_return_cqr_cb in
1910                  * __dasd_block_start_head to cover erp requests as well
1911                  */
1912                 cqr->callback_data = (void *) req;
1913                 cqr->status = DASD_CQR_FILLED;
1914                 blk_start_request(req);
1915                 list_add_tail(&cqr->blocklist, &block->ccw_queue);
1916                 dasd_profile_start(block, cqr, req);
1917         }
1918 }
1919
1920 static void __dasd_cleanup_cqr(struct dasd_ccw_req *cqr)
1921 {
1922         struct request *req;
1923         int status;
1924         int error = 0;
1925
1926         req = (struct request *) cqr->callback_data;
1927         dasd_profile_end(cqr->block, cqr, req);
1928         status = cqr->block->base->discipline->free_cp(cqr, req);
1929         if (status <= 0)
1930                 error = status ? status : -EIO;
1931         __blk_end_request_all(req, error);
1932 }
1933
1934 /*
1935  * Process ccw request queue.
1936  */
1937 static void __dasd_process_block_ccw_queue(struct dasd_block *block,
1938                                            struct list_head *final_queue)
1939 {
1940         struct list_head *l, *n;
1941         struct dasd_ccw_req *cqr;
1942         dasd_erp_fn_t erp_fn;
1943         unsigned long flags;
1944         struct dasd_device *base = block->base;
1945
1946 restart:
1947         /* Process request with final status. */
1948         list_for_each_safe(l, n, &block->ccw_queue) {
1949                 cqr = list_entry(l, struct dasd_ccw_req, blocklist);
1950                 if (cqr->status != DASD_CQR_DONE &&
1951                     cqr->status != DASD_CQR_FAILED &&
1952                     cqr->status != DASD_CQR_NEED_ERP &&
1953                     cqr->status != DASD_CQR_TERMINATED)
1954                         continue;
1955
1956                 if (cqr->status == DASD_CQR_TERMINATED) {
1957                         base->discipline->handle_terminated_request(cqr);
1958                         goto restart;
1959                 }
1960
1961                 /*  Process requests that may be recovered */
1962                 if (cqr->status == DASD_CQR_NEED_ERP) {
1963                         erp_fn = base->discipline->erp_action(cqr);
1964                         if (IS_ERR(erp_fn(cqr)))
1965                                 continue;
1966                         goto restart;
1967                 }
1968
1969                 /* log sense for fatal error */
1970                 if (cqr->status == DASD_CQR_FAILED) {
1971                         dasd_log_sense(cqr, &cqr->irb);
1972                 }
1973
1974                 /* First of all call extended error reporting. */
1975                 if (dasd_eer_enabled(base) &&
1976                     cqr->status == DASD_CQR_FAILED) {
1977                         dasd_eer_write(base, cqr, DASD_EER_FATALERROR);
1978
1979                         /* restart request  */
1980                         cqr->status = DASD_CQR_FILLED;
1981                         cqr->retries = 255;
1982                         spin_lock_irqsave(get_ccwdev_lock(base->cdev), flags);
1983                         dasd_device_set_stop_bits(base, DASD_STOPPED_QUIESCE);
1984                         spin_unlock_irqrestore(get_ccwdev_lock(base->cdev),
1985                                                flags);
1986                         goto restart;
1987                 }
1988
1989                 /* Process finished ERP request. */
1990                 if (cqr->refers) {
1991                         __dasd_process_erp(base, cqr);
1992                         goto restart;
1993                 }
1994
1995                 /* Rechain finished requests to final queue */
1996                 cqr->endclk = get_clock();
1997                 list_move_tail(&cqr->blocklist, final_queue);
1998         }
1999 }
2000
2001 static void dasd_return_cqr_cb(struct dasd_ccw_req *cqr, void *data)
2002 {
2003         dasd_schedule_block_bh(cqr->block);
2004 }
2005
2006 static void __dasd_block_start_head(struct dasd_block *block)
2007 {
2008         struct dasd_ccw_req *cqr;
2009
2010         if (list_empty(&block->ccw_queue))
2011                 return;
2012         /* We allways begin with the first requests on the queue, as some
2013          * of previously started requests have to be enqueued on a
2014          * dasd_device again for error recovery.
2015          */
2016         list_for_each_entry(cqr, &block->ccw_queue, blocklist) {
2017                 if (cqr->status != DASD_CQR_FILLED)
2018                         continue;
2019                 /* Non-temporary stop condition will trigger fail fast */
2020                 if (block->base->stopped & ~DASD_STOPPED_PENDING &&
2021                     test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
2022                     (!dasd_eer_enabled(block->base))) {
2023                         cqr->status = DASD_CQR_FAILED;
2024                         dasd_schedule_block_bh(block);
2025                         continue;
2026                 }
2027                 /* Don't try to start requests if device is stopped */
2028                 if (block->base->stopped)
2029                         return;
2030
2031                 /* just a fail safe check, should not happen */
2032                 if (!cqr->startdev)
2033                         cqr->startdev = block->base;
2034
2035                 /* make sure that the requests we submit find their way back */
2036                 cqr->callback = dasd_return_cqr_cb;
2037
2038                 dasd_add_request_tail(cqr);
2039         }
2040 }
2041
2042 /*
2043  * Central dasd_block layer routine. Takes requests from the generic
2044  * block layer request queue, creates ccw requests, enqueues them on
2045  * a dasd_device and processes ccw requests that have been returned.
2046  */
2047 static void dasd_block_tasklet(struct dasd_block *block)
2048 {
2049         struct list_head final_queue;
2050         struct list_head *l, *n;
2051         struct dasd_ccw_req *cqr;
2052
2053         atomic_set(&block->tasklet_scheduled, 0);
2054         INIT_LIST_HEAD(&final_queue);
2055         spin_lock(&block->queue_lock);
2056         /* Finish off requests on ccw queue */
2057         __dasd_process_block_ccw_queue(block, &final_queue);
2058         spin_unlock(&block->queue_lock);
2059         /* Now call the callback function of requests with final status */
2060         spin_lock_irq(&block->request_queue_lock);
2061         list_for_each_safe(l, n, &final_queue) {
2062                 cqr = list_entry(l, struct dasd_ccw_req, blocklist);
2063                 list_del_init(&cqr->blocklist);
2064                 __dasd_cleanup_cqr(cqr);
2065         }
2066         spin_lock(&block->queue_lock);
2067         /* Get new request from the block device request queue */
2068         __dasd_process_request_queue(block);
2069         /* Now check if the head of the ccw queue needs to be started. */
2070         __dasd_block_start_head(block);
2071         spin_unlock(&block->queue_lock);
2072         spin_unlock_irq(&block->request_queue_lock);
2073         dasd_put_device(block->base);
2074 }
2075
2076 static void _dasd_wake_block_flush_cb(struct dasd_ccw_req *cqr, void *data)
2077 {
2078         wake_up(&dasd_flush_wq);
2079 }
2080
2081 /*
2082  * Go through all request on the dasd_block request queue, cancel them
2083  * on the respective dasd_device, and return them to the generic
2084  * block layer.
2085  */
2086 static int dasd_flush_block_queue(struct dasd_block *block)
2087 {
2088         struct dasd_ccw_req *cqr, *n;
2089         int rc, i;
2090         struct list_head flush_queue;
2091
2092         INIT_LIST_HEAD(&flush_queue);
2093         spin_lock_bh(&block->queue_lock);
2094         rc = 0;
2095 restart:
2096         list_for_each_entry_safe(cqr, n, &block->ccw_queue, blocklist) {
2097                 /* if this request currently owned by a dasd_device cancel it */
2098                 if (cqr->status >= DASD_CQR_QUEUED)
2099                         rc = dasd_cancel_req(cqr);
2100                 if (rc < 0)
2101                         break;
2102                 /* Rechain request (including erp chain) so it won't be
2103                  * touched by the dasd_block_tasklet anymore.
2104                  * Replace the callback so we notice when the request
2105                  * is returned from the dasd_device layer.
2106                  */
2107                 cqr->callback = _dasd_wake_block_flush_cb;
2108                 for (i = 0; cqr != NULL; cqr = cqr->refers, i++)
2109                         list_move_tail(&cqr->blocklist, &flush_queue);
2110                 if (i > 1)
2111                         /* moved more than one request - need to restart */
2112                         goto restart;
2113         }
2114         spin_unlock_bh(&block->queue_lock);
2115         /* Now call the callback function of flushed requests */
2116 restart_cb:
2117         list_for_each_entry_safe(cqr, n, &flush_queue, blocklist) {
2118                 wait_event(dasd_flush_wq, (cqr->status < DASD_CQR_QUEUED));
2119                 /* Process finished ERP request. */
2120                 if (cqr->refers) {
2121                         spin_lock_bh(&block->queue_lock);
2122                         __dasd_process_erp(block->base, cqr);
2123                         spin_unlock_bh(&block->queue_lock);
2124                         /* restart list_for_xx loop since dasd_process_erp
2125                          * might remove multiple elements */
2126                         goto restart_cb;
2127                 }
2128                 /* call the callback function */
2129                 spin_lock_irq(&block->request_queue_lock);
2130                 cqr->endclk = get_clock();
2131                 list_del_init(&cqr->blocklist);
2132                 __dasd_cleanup_cqr(cqr);
2133                 spin_unlock_irq(&block->request_queue_lock);
2134         }
2135         return rc;
2136 }
2137
2138 /*
2139  * Schedules a call to dasd_tasklet over the device tasklet.
2140  */
2141 void dasd_schedule_block_bh(struct dasd_block *block)
2142 {
2143         /* Protect against rescheduling. */
2144         if (atomic_cmpxchg(&block->tasklet_scheduled, 0, 1) != 0)
2145                 return;
2146         /* life cycle of block is bound to it's base device */
2147         dasd_get_device(block->base);
2148         tasklet_hi_schedule(&block->tasklet);
2149 }
2150
2151
2152 /*
2153  * SECTION: external block device operations
2154  * (request queue handling, open, release, etc.)
2155  */
2156
2157 /*
2158  * Dasd request queue function. Called from ll_rw_blk.c
2159  */
2160 static void do_dasd_request(struct request_queue *queue)
2161 {
2162         struct dasd_block *block;
2163
2164         block = queue->queuedata;
2165         spin_lock(&block->queue_lock);
2166         /* Get new request from the block device request queue */
2167         __dasd_process_request_queue(block);
2168         /* Now check if the head of the ccw queue needs to be started. */
2169         __dasd_block_start_head(block);
2170         spin_unlock(&block->queue_lock);
2171 }
2172
2173 /*
2174  * Allocate and initialize request queue and default I/O scheduler.
2175  */
2176 static int dasd_alloc_queue(struct dasd_block *block)
2177 {
2178         int rc;
2179
2180         block->request_queue = blk_init_queue(do_dasd_request,
2181                                                &block->request_queue_lock);
2182         if (block->request_queue == NULL)
2183                 return -ENOMEM;
2184
2185         block->request_queue->queuedata = block;
2186
2187         elevator_exit(block->request_queue->elevator);
2188         block->request_queue->elevator = NULL;
2189         rc = elevator_init(block->request_queue, "deadline");
2190         if (rc) {
2191                 blk_cleanup_queue(block->request_queue);
2192                 return rc;
2193         }
2194         return 0;
2195 }
2196
2197 /*
2198  * Allocate and initialize request queue.
2199  */
2200 static void dasd_setup_queue(struct dasd_block *block)
2201 {
2202         int max;
2203
2204         blk_queue_logical_block_size(block->request_queue, block->bp_block);
2205         max = block->base->discipline->max_blocks << block->s2b_shift;
2206         blk_queue_max_hw_sectors(block->request_queue, max);
2207         blk_queue_max_segments(block->request_queue, -1L);
2208         /* with page sized segments we can translate each segement into
2209          * one idaw/tidaw
2210          */
2211         blk_queue_max_segment_size(block->request_queue, PAGE_SIZE);
2212         blk_queue_segment_boundary(block->request_queue, PAGE_SIZE - 1);
2213 }
2214
2215 /*
2216  * Deactivate and free request queue.
2217  */
2218 static void dasd_free_queue(struct dasd_block *block)
2219 {
2220         if (block->request_queue) {
2221                 blk_cleanup_queue(block->request_queue);
2222                 block->request_queue = NULL;
2223         }
2224 }
2225
2226 /*
2227  * Flush request on the request queue.
2228  */
2229 static void dasd_flush_request_queue(struct dasd_block *block)
2230 {
2231         struct request *req;
2232
2233         if (!block->request_queue)
2234                 return;
2235
2236         spin_lock_irq(&block->request_queue_lock);
2237         while ((req = blk_fetch_request(block->request_queue)))
2238                 __blk_end_request_all(req, -EIO);
2239         spin_unlock_irq(&block->request_queue_lock);
2240 }
2241
2242 static int dasd_open(struct block_device *bdev, fmode_t mode)
2243 {
2244         struct dasd_block *block = bdev->bd_disk->private_data;
2245         struct dasd_device *base;
2246         int rc;
2247
2248         if (!block)
2249                 return -ENODEV;
2250
2251         base = block->base;
2252         atomic_inc(&block->open_count);
2253         if (test_bit(DASD_FLAG_OFFLINE, &base->flags)) {
2254                 rc = -ENODEV;
2255                 goto unlock;
2256         }
2257
2258         if (!try_module_get(base->discipline->owner)) {
2259                 rc = -EINVAL;
2260                 goto unlock;
2261         }
2262
2263         if (dasd_probeonly) {
2264                 dev_info(&base->cdev->dev,
2265                          "Accessing the DASD failed because it is in "
2266                          "probeonly mode\n");
2267                 rc = -EPERM;
2268                 goto out;
2269         }
2270
2271         if (base->state <= DASD_STATE_BASIC) {
2272                 DBF_DEV_EVENT(DBF_ERR, base, " %s",
2273                               " Cannot open unrecognized device");
2274                 rc = -ENODEV;
2275                 goto out;
2276         }
2277
2278         if ((mode & FMODE_WRITE) &&
2279             (test_bit(DASD_FLAG_DEVICE_RO, &base->flags) ||
2280              (base->features & DASD_FEATURE_READONLY))) {
2281                 rc = -EROFS;
2282                 goto out;
2283         }
2284
2285         return 0;
2286
2287 out:
2288         module_put(base->discipline->owner);
2289 unlock:
2290         atomic_dec(&block->open_count);
2291         return rc;
2292 }
2293
2294 static int dasd_release(struct gendisk *disk, fmode_t mode)
2295 {
2296         struct dasd_block *block = disk->private_data;
2297
2298         atomic_dec(&block->open_count);
2299         module_put(block->base->discipline->owner);
2300         return 0;
2301 }
2302
2303 /*
2304  * Return disk geometry.
2305  */
2306 static int dasd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
2307 {
2308         struct dasd_block *block;
2309         struct dasd_device *base;
2310
2311         block = bdev->bd_disk->private_data;
2312         if (!block)
2313                 return -ENODEV;
2314         base = block->base;
2315
2316         if (!base->discipline ||
2317             !base->discipline->fill_geometry)
2318                 return -EINVAL;
2319
2320         base->discipline->fill_geometry(block, geo);
2321         geo->start = get_start_sect(bdev) >> block->s2b_shift;
2322         return 0;
2323 }
2324
2325 const struct block_device_operations
2326 dasd_device_operations = {
2327         .owner          = THIS_MODULE,
2328         .open           = dasd_open,
2329         .release        = dasd_release,
2330         .ioctl          = dasd_ioctl,
2331         .compat_ioctl   = dasd_ioctl,
2332         .getgeo         = dasd_getgeo,
2333 };
2334
2335 /*******************************************************************************
2336  * end of block device operations
2337  */
2338
2339 static void
2340 dasd_exit(void)
2341 {
2342 #ifdef CONFIG_PROC_FS
2343         dasd_proc_exit();
2344 #endif
2345         dasd_eer_exit();
2346         if (dasd_page_cache != NULL) {
2347                 kmem_cache_destroy(dasd_page_cache);
2348                 dasd_page_cache = NULL;
2349         }
2350         dasd_gendisk_exit();
2351         dasd_devmap_exit();
2352         if (dasd_debug_area != NULL) {
2353                 debug_unregister(dasd_debug_area);
2354                 dasd_debug_area = NULL;
2355         }
2356 }
2357
2358 /*
2359  * SECTION: common functions for ccw_driver use
2360  */
2361
2362 /*
2363  * Is the device read-only?
2364  * Note that this function does not report the setting of the
2365  * readonly device attribute, but how it is configured in z/VM.
2366  */
2367 int dasd_device_is_ro(struct dasd_device *device)
2368 {
2369         struct ccw_dev_id dev_id;
2370         struct diag210 diag_data;
2371         int rc;
2372
2373         if (!MACHINE_IS_VM)
2374                 return 0;
2375         ccw_device_get_id(device->cdev, &dev_id);
2376         memset(&diag_data, 0, sizeof(diag_data));
2377         diag_data.vrdcdvno = dev_id.devno;
2378         diag_data.vrdclen = sizeof(diag_data);
2379         rc = diag210(&diag_data);
2380         if (rc == 0 || rc == 2) {
2381                 return diag_data.vrdcvfla & 0x80;
2382         } else {
2383                 DBF_EVENT(DBF_WARNING, "diag210 failed for dev=%04x with rc=%d",
2384                           dev_id.devno, rc);
2385                 return 0;
2386         }
2387 }
2388 EXPORT_SYMBOL_GPL(dasd_device_is_ro);
2389
2390 static void dasd_generic_auto_online(void *data, async_cookie_t cookie)
2391 {
2392         struct ccw_device *cdev = data;
2393         int ret;
2394
2395         ret = ccw_device_set_online(cdev);
2396         if (ret)
2397                 pr_warning("%s: Setting the DASD online failed with rc=%d\n",
2398                            dev_name(&cdev->dev), ret);
2399 }
2400
2401 /*
2402  * Initial attempt at a probe function. this can be simplified once
2403  * the other detection code is gone.
2404  */
2405 int dasd_generic_probe(struct ccw_device *cdev,
2406                        struct dasd_discipline *discipline)
2407 {
2408         int ret;
2409
2410         ret = dasd_add_sysfs_files(cdev);
2411         if (ret) {
2412                 DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s",
2413                                 "dasd_generic_probe: could not add "
2414                                 "sysfs entries");
2415                 return ret;
2416         }
2417         cdev->handler = &dasd_int_handler;
2418
2419         /*
2420          * Automatically online either all dasd devices (dasd_autodetect)
2421          * or all devices specified with dasd= parameters during
2422          * initial probe.
2423          */
2424         if ((dasd_get_feature(cdev, DASD_FEATURE_INITIAL_ONLINE) > 0 ) ||
2425             (dasd_autodetect && dasd_busid_known(dev_name(&cdev->dev)) != 0))
2426                 async_schedule(dasd_generic_auto_online, cdev);
2427         return 0;
2428 }
2429
2430 /*
2431  * This will one day be called from a global not_oper handler.
2432  * It is also used by driver_unregister during module unload.
2433  */
2434 void dasd_generic_remove(struct ccw_device *cdev)
2435 {
2436         struct dasd_device *device;
2437         struct dasd_block *block;
2438
2439         cdev->handler = NULL;
2440
2441         dasd_remove_sysfs_files(cdev);
2442         device = dasd_device_from_cdev(cdev);
2443         if (IS_ERR(device))
2444                 return;
2445         if (test_and_set_bit(DASD_FLAG_OFFLINE, &device->flags)) {
2446                 /* Already doing offline processing */
2447                 dasd_put_device(device);
2448                 return;
2449         }
2450         /*
2451          * This device is removed unconditionally. Set offline
2452          * flag to prevent dasd_open from opening it while it is
2453          * no quite down yet.
2454          */
2455         dasd_set_target_state(device, DASD_STATE_NEW);
2456         /* dasd_delete_device destroys the device reference. */
2457         block = device->block;
2458         device->block = NULL;
2459         dasd_delete_device(device);
2460         /*
2461          * life cycle of block is bound to device, so delete it after
2462          * device was safely removed
2463          */
2464         if (block)
2465                 dasd_free_block(block);
2466 }
2467
2468 /*
2469  * Activate a device. This is called from dasd_{eckd,fba}_probe() when either
2470  * the device is detected for the first time and is supposed to be used
2471  * or the user has started activation through sysfs.
2472  */
2473 int dasd_generic_set_online(struct ccw_device *cdev,
2474                             struct dasd_discipline *base_discipline)
2475 {
2476         struct dasd_discipline *discipline;
2477         struct dasd_device *device;
2478         int rc;
2479
2480         /* first online clears initial online feature flag */
2481         dasd_set_feature(cdev, DASD_FEATURE_INITIAL_ONLINE, 0);
2482         device = dasd_create_device(cdev);
2483         if (IS_ERR(device))
2484                 return PTR_ERR(device);
2485
2486         discipline = base_discipline;
2487         if (device->features & DASD_FEATURE_USEDIAG) {
2488                 if (!dasd_diag_discipline_pointer) {
2489                         pr_warning("%s Setting the DASD online failed because "
2490                                    "of missing DIAG discipline\n",
2491                                    dev_name(&cdev->dev));
2492                         dasd_delete_device(device);
2493                         return -ENODEV;
2494                 }
2495                 discipline = dasd_diag_discipline_pointer;
2496         }
2497         if (!try_module_get(base_discipline->owner)) {
2498                 dasd_delete_device(device);
2499                 return -EINVAL;
2500         }
2501         if (!try_module_get(discipline->owner)) {
2502                 module_put(base_discipline->owner);
2503                 dasd_delete_device(device);
2504                 return -EINVAL;
2505         }
2506         device->base_discipline = base_discipline;
2507         device->discipline = discipline;
2508
2509         /* check_device will allocate block device if necessary */
2510         rc = discipline->check_device(device);
2511         if (rc) {
2512                 pr_warning("%s Setting the DASD online with discipline %s "
2513                            "failed with rc=%i\n",
2514                            dev_name(&cdev->dev), discipline->name, rc);
2515                 module_put(discipline->owner);
2516                 module_put(base_discipline->owner);
2517                 dasd_delete_device(device);
2518                 return rc;
2519         }
2520
2521         dasd_set_target_state(device, DASD_STATE_ONLINE);
2522         if (device->state <= DASD_STATE_KNOWN) {
2523                 pr_warning("%s Setting the DASD online failed because of a "
2524                            "missing discipline\n", dev_name(&cdev->dev));
2525                 rc = -ENODEV;
2526                 dasd_set_target_state(device, DASD_STATE_NEW);
2527                 if (device->block)
2528                         dasd_free_block(device->block);
2529                 dasd_delete_device(device);
2530         } else
2531                 pr_debug("dasd_generic device %s found\n",
2532                                 dev_name(&cdev->dev));
2533
2534         wait_event(dasd_init_waitq, _wait_for_device(device));
2535
2536         dasd_put_device(device);
2537         return rc;
2538 }
2539
2540 int dasd_generic_set_offline(struct ccw_device *cdev)
2541 {
2542         struct dasd_device *device;
2543         struct dasd_block *block;
2544         int max_count, open_count;
2545
2546         device = dasd_device_from_cdev(cdev);
2547         if (IS_ERR(device))
2548                 return PTR_ERR(device);
2549         if (test_and_set_bit(DASD_FLAG_OFFLINE, &device->flags)) {
2550                 /* Already doing offline processing */
2551                 dasd_put_device(device);
2552                 return 0;
2553         }
2554         /*
2555          * We must make sure that this device is currently not in use.
2556          * The open_count is increased for every opener, that includes
2557          * the blkdev_get in dasd_scan_partitions. We are only interested
2558          * in the other openers.
2559          */
2560         if (device->block) {
2561                 max_count = device->block->bdev ? 0 : -1;
2562                 open_count = atomic_read(&device->block->open_count);
2563                 if (open_count > max_count) {
2564                         if (open_count > 0)
2565                                 pr_warning("%s: The DASD cannot be set offline "
2566                                            "with open count %i\n",
2567                                            dev_name(&cdev->dev), open_count);
2568                         else
2569                                 pr_warning("%s: The DASD cannot be set offline "
2570                                            "while it is in use\n",
2571                                            dev_name(&cdev->dev));
2572                         clear_bit(DASD_FLAG_OFFLINE, &device->flags);
2573                         dasd_put_device(device);
2574                         return -EBUSY;
2575                 }
2576         }
2577         dasd_set_target_state(device, DASD_STATE_NEW);
2578         /* dasd_delete_device destroys the device reference. */
2579         block = device->block;
2580         device->block = NULL;
2581         dasd_delete_device(device);
2582         /*
2583          * life cycle of block is bound to device, so delete it after
2584          * device was safely removed
2585          */
2586         if (block)
2587                 dasd_free_block(block);
2588         return 0;
2589 }
2590
2591 int dasd_generic_notify(struct ccw_device *cdev, int event)
2592 {
2593         struct dasd_device *device;
2594         struct dasd_ccw_req *cqr;
2595         int ret;
2596
2597         device = dasd_device_from_cdev_locked(cdev);
2598         if (IS_ERR(device))
2599                 return 0;
2600         ret = 0;
2601         switch (event) {
2602         case CIO_GONE:
2603         case CIO_BOXED:
2604         case CIO_NO_PATH:
2605                 /* First of all call extended error reporting. */
2606                 dasd_eer_write(device, NULL, DASD_EER_NOPATH);
2607
2608                 if (device->state < DASD_STATE_BASIC)
2609                         break;
2610                 /* Device is active. We want to keep it. */
2611                 list_for_each_entry(cqr, &device->ccw_queue, devlist)
2612                         if (cqr->status == DASD_CQR_IN_IO) {
2613                                 cqr->status = DASD_CQR_QUEUED;
2614                                 cqr->retries++;
2615                         }
2616                 dasd_device_set_stop_bits(device, DASD_STOPPED_DC_WAIT);
2617                 dasd_device_clear_timer(device);
2618                 dasd_schedule_device_bh(device);
2619                 ret = 1;
2620                 break;
2621         case CIO_OPER:
2622                 /* FIXME: add a sanity check. */
2623                 dasd_device_remove_stop_bits(device, DASD_STOPPED_DC_WAIT);
2624                 if (device->stopped & DASD_UNRESUMED_PM) {
2625                         dasd_device_remove_stop_bits(device, DASD_UNRESUMED_PM);
2626                         dasd_restore_device(device);
2627                         ret = 1;
2628                         break;
2629                 }
2630                 dasd_schedule_device_bh(device);
2631                 if (device->block)
2632                         dasd_schedule_block_bh(device->block);
2633                 ret = 1;
2634                 break;
2635         }
2636         dasd_put_device(device);
2637         return ret;
2638 }
2639
2640 int dasd_generic_pm_freeze(struct ccw_device *cdev)
2641 {
2642         struct dasd_ccw_req *cqr, *n;
2643         int rc;
2644         struct list_head freeze_queue;
2645         struct dasd_device *device = dasd_device_from_cdev(cdev);
2646
2647         if (IS_ERR(device))
2648                 return PTR_ERR(device);
2649         /* disallow new I/O  */
2650         dasd_device_set_stop_bits(device, DASD_STOPPED_PM);
2651         /* clear active requests */
2652         INIT_LIST_HEAD(&freeze_queue);
2653         spin_lock_irq(get_ccwdev_lock(cdev));
2654         rc = 0;
2655         list_for_each_entry_safe(cqr, n, &device->ccw_queue, devlist) {
2656                 /* Check status and move request to flush_queue */
2657                 if (cqr->status == DASD_CQR_IN_IO) {
2658                         rc = device->discipline->term_IO(cqr);
2659                         if (rc) {
2660                                 /* unable to terminate requeust */
2661                                 dev_err(&device->cdev->dev,
2662                                         "Unable to terminate request %p "
2663                                         "on suspend\n", cqr);
2664                                 spin_unlock_irq(get_ccwdev_lock(cdev));
2665                                 dasd_put_device(device);
2666                                 return rc;
2667                         }
2668                 }
2669                 list_move_tail(&cqr->devlist, &freeze_queue);
2670         }
2671
2672         spin_unlock_irq(get_ccwdev_lock(cdev));
2673
2674         list_for_each_entry_safe(cqr, n, &freeze_queue, devlist) {
2675                 wait_event(dasd_flush_wq,
2676                            (cqr->status != DASD_CQR_CLEAR_PENDING));
2677                 if (cqr->status == DASD_CQR_CLEARED)
2678                         cqr->status = DASD_CQR_QUEUED;
2679         }
2680         /* move freeze_queue to start of the ccw_queue */
2681         spin_lock_irq(get_ccwdev_lock(cdev));
2682         list_splice_tail(&freeze_queue, &device->ccw_queue);
2683         spin_unlock_irq(get_ccwdev_lock(cdev));
2684
2685         if (device->discipline->freeze)
2686                 rc = device->discipline->freeze(device);
2687
2688         dasd_put_device(device);
2689         return rc;
2690 }
2691 EXPORT_SYMBOL_GPL(dasd_generic_pm_freeze);
2692
2693 int dasd_generic_restore_device(struct ccw_device *cdev)
2694 {
2695         struct dasd_device *device = dasd_device_from_cdev(cdev);
2696         int rc = 0;
2697
2698         if (IS_ERR(device))
2699                 return PTR_ERR(device);
2700
2701         /* allow new IO again */
2702         dasd_device_remove_stop_bits(device,
2703                                      (DASD_STOPPED_PM | DASD_UNRESUMED_PM));
2704
2705         dasd_schedule_device_bh(device);
2706
2707         /*
2708          * call discipline restore function
2709          * if device is stopped do nothing e.g. for disconnected devices
2710          */
2711         if (device->discipline->restore && !(device->stopped))
2712                 rc = device->discipline->restore(device);
2713         if (rc || device->stopped)
2714                 /*
2715                  * if the resume failed for the DASD we put it in
2716                  * an UNRESUMED stop state
2717                  */
2718                 device->stopped |= DASD_UNRESUMED_PM;
2719
2720         if (device->block)
2721                 dasd_schedule_block_bh(device->block);
2722
2723         dasd_put_device(device);
2724         return 0;
2725 }
2726 EXPORT_SYMBOL_GPL(dasd_generic_restore_device);
2727
2728 static struct dasd_ccw_req *dasd_generic_build_rdc(struct dasd_device *device,
2729                                                    void *rdc_buffer,
2730                                                    int rdc_buffer_size,
2731                                                    int magic)
2732 {
2733         struct dasd_ccw_req *cqr;
2734         struct ccw1 *ccw;
2735         unsigned long *idaw;
2736
2737         cqr = dasd_smalloc_request(magic, 1 /* RDC */, rdc_buffer_size, device);
2738
2739         if (IS_ERR(cqr)) {
2740                 /* internal error 13 - Allocating the RDC request failed*/
2741                 dev_err(&device->cdev->dev,
2742                          "An error occurred in the DASD device driver, "
2743                          "reason=%s\n", "13");
2744                 return cqr;
2745         }
2746
2747         ccw = cqr->cpaddr;
2748         ccw->cmd_code = CCW_CMD_RDC;
2749         if (idal_is_needed(rdc_buffer, rdc_buffer_size)) {
2750                 idaw = (unsigned long *) (cqr->data);
2751                 ccw->cda = (__u32)(addr_t) idaw;
2752                 ccw->flags = CCW_FLAG_IDA;
2753                 idaw = idal_create_words(idaw, rdc_buffer, rdc_buffer_size);
2754         } else {
2755                 ccw->cda = (__u32)(addr_t) rdc_buffer;
2756                 ccw->flags = 0;
2757         }
2758
2759         ccw->count = rdc_buffer_size;
2760         cqr->startdev = device;
2761         cqr->memdev = device;
2762         cqr->expires = 10*HZ;
2763         cqr->retries = 256;
2764         cqr->buildclk = get_clock();
2765         cqr->status = DASD_CQR_FILLED;
2766         return cqr;
2767 }
2768
2769
2770 int dasd_generic_read_dev_chars(struct dasd_device *device, int magic,
2771                                 void *rdc_buffer, int rdc_buffer_size)
2772 {
2773         int ret;
2774         struct dasd_ccw_req *cqr;
2775
2776         cqr = dasd_generic_build_rdc(device, rdc_buffer, rdc_buffer_size,
2777                                      magic);
2778         if (IS_ERR(cqr))
2779                 return PTR_ERR(cqr);
2780
2781         ret = dasd_sleep_on(cqr);
2782         dasd_sfree_request(cqr, cqr->memdev);
2783         return ret;
2784 }
2785 EXPORT_SYMBOL_GPL(dasd_generic_read_dev_chars);
2786
2787 /*
2788  *   In command mode and transport mode we need to look for sense
2789  *   data in different places. The sense data itself is allways
2790  *   an array of 32 bytes, so we can unify the sense data access
2791  *   for both modes.
2792  */
2793 char *dasd_get_sense(struct irb *irb)
2794 {
2795         struct tsb *tsb = NULL;
2796         char *sense = NULL;
2797
2798         if (scsw_is_tm(&irb->scsw) && (irb->scsw.tm.fcxs == 0x01)) {
2799                 if (irb->scsw.tm.tcw)
2800                         tsb = tcw_get_tsb((struct tcw *)(unsigned long)
2801                                           irb->scsw.tm.tcw);
2802                 if (tsb && tsb->length == 64 && tsb->flags)
2803                         switch (tsb->flags & 0x07) {
2804                         case 1: /* tsa_iostat */
2805                                 sense = tsb->tsa.iostat.sense;
2806                                 break;
2807                         case 2: /* tsa_ddpc */
2808                                 sense = tsb->tsa.ddpc.sense;
2809                                 break;
2810                         default:
2811                                 /* currently we don't use interrogate data */
2812                                 break;
2813                         }
2814         } else if (irb->esw.esw0.erw.cons) {
2815                 sense = irb->ecw;
2816         }
2817         return sense;
2818 }
2819 EXPORT_SYMBOL_GPL(dasd_get_sense);
2820
2821 static int __init dasd_init(void)
2822 {
2823         int rc;
2824
2825         init_waitqueue_head(&dasd_init_waitq);
2826         init_waitqueue_head(&dasd_flush_wq);
2827         init_waitqueue_head(&generic_waitq);
2828
2829         /* register 'common' DASD debug area, used for all DBF_XXX calls */
2830         dasd_debug_area = debug_register("dasd", 1, 1, 8 * sizeof(long));
2831         if (dasd_debug_area == NULL) {
2832                 rc = -ENOMEM;
2833                 goto failed;
2834         }
2835         debug_register_view(dasd_debug_area, &debug_sprintf_view);
2836         debug_set_level(dasd_debug_area, DBF_WARNING);
2837
2838         DBF_EVENT(DBF_EMERG, "%s", "debug area created");
2839
2840         dasd_diag_discipline_pointer = NULL;
2841
2842         rc = dasd_devmap_init();
2843         if (rc)
2844                 goto failed;
2845         rc = dasd_gendisk_init();
2846         if (rc)
2847                 goto failed;
2848         rc = dasd_parse();
2849         if (rc)
2850                 goto failed;
2851         rc = dasd_eer_init();
2852         if (rc)
2853                 goto failed;
2854 #ifdef CONFIG_PROC_FS
2855         rc = dasd_proc_init();
2856         if (rc)
2857                 goto failed;
2858 #endif
2859
2860         return 0;
2861 failed:
2862         pr_info("The DASD device driver could not be initialized\n");
2863         dasd_exit();
2864         return rc;
2865 }
2866
2867 module_init(dasd_init);
2868 module_exit(dasd_exit);
2869
2870 EXPORT_SYMBOL(dasd_debug_area);
2871 EXPORT_SYMBOL(dasd_diag_discipline_pointer);
2872
2873 EXPORT_SYMBOL(dasd_add_request_head);
2874 EXPORT_SYMBOL(dasd_add_request_tail);
2875 EXPORT_SYMBOL(dasd_cancel_req);
2876 EXPORT_SYMBOL(dasd_device_clear_timer);
2877 EXPORT_SYMBOL(dasd_block_clear_timer);
2878 EXPORT_SYMBOL(dasd_enable_device);
2879 EXPORT_SYMBOL(dasd_int_handler);
2880 EXPORT_SYMBOL(dasd_kfree_request);
2881 EXPORT_SYMBOL(dasd_kick_device);
2882 EXPORT_SYMBOL(dasd_kmalloc_request);
2883 EXPORT_SYMBOL(dasd_schedule_device_bh);
2884 EXPORT_SYMBOL(dasd_schedule_block_bh);
2885 EXPORT_SYMBOL(dasd_set_target_state);
2886 EXPORT_SYMBOL(dasd_device_set_timer);
2887 EXPORT_SYMBOL(dasd_block_set_timer);
2888 EXPORT_SYMBOL(dasd_sfree_request);
2889 EXPORT_SYMBOL(dasd_sleep_on);
2890 EXPORT_SYMBOL(dasd_sleep_on_immediatly);
2891 EXPORT_SYMBOL(dasd_sleep_on_interruptible);
2892 EXPORT_SYMBOL(dasd_smalloc_request);
2893 EXPORT_SYMBOL(dasd_start_IO);
2894 EXPORT_SYMBOL(dasd_term_IO);
2895
2896 EXPORT_SYMBOL_GPL(dasd_generic_probe);
2897 EXPORT_SYMBOL_GPL(dasd_generic_remove);
2898 EXPORT_SYMBOL_GPL(dasd_generic_notify);
2899 EXPORT_SYMBOL_GPL(dasd_generic_set_online);
2900 EXPORT_SYMBOL_GPL(dasd_generic_set_offline);
2901 EXPORT_SYMBOL_GPL(dasd_generic_handle_state_change);
2902 EXPORT_SYMBOL_GPL(dasd_flush_device_queue);
2903 EXPORT_SYMBOL_GPL(dasd_alloc_block);
2904 EXPORT_SYMBOL_GPL(dasd_free_block);