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