2 * File...........: linux/drivers/s390/block/dasd_diag.c
3 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
4 * Based on.......: linux/drivers/s390/block/mdisk.c
5 * ...............: by Hartmunt Penner <hpenner@de.ibm.com>
6 * Bugreports.to..: <Linux390@de.ibm.com>
7 * (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999,2000
11 #define KMSG_COMPONENT "dasd"
13 #include <linux/stddef.h>
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/hdreg.h>
17 #include <linux/bio.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/jiffies.h>
23 #include <asm/debug.h>
24 #include <asm/ebcdic.h>
26 #include <asm/s390_ext.h>
31 #include "dasd_diag.h"
33 #define PRINTK_HEADER "dasd(diag):"
35 MODULE_LICENSE("GPL");
37 /* The maximum number of blocks per request (max_blocks) is dependent on the
38 * amount of storage that is available in the static I/O buffer for each
39 * device. Currently each device gets 2 pages. We want to fit two requests
40 * into the available memory so that we can immediately start the next if one
42 #define DIAG_MAX_BLOCKS (((2 * PAGE_SIZE - sizeof(struct dasd_ccw_req) - \
43 sizeof(struct dasd_diag_req)) / \
44 sizeof(struct dasd_diag_bio)) / 2)
45 #define DIAG_MAX_RETRIES 32
46 #define DIAG_TIMEOUT 50
48 static struct dasd_discipline dasd_diag_discipline
;
50 struct dasd_diag_private
{
51 struct dasd_diag_characteristics rdc_data
;
52 struct dasd_diag_rw_io iob
;
53 struct dasd_diag_init_io iib
;
55 struct ccw_dev_id dev_id
;
58 struct dasd_diag_req
{
59 unsigned int block_count
;
60 struct dasd_diag_bio bio
[0];
63 static const u8 DASD_DIAG_CMS1
[] = { 0xc3, 0xd4, 0xe2, 0xf1 };/* EBCDIC CMS1 */
65 /* Perform DIAG250 call with block I/O parameter list iob (input and output)
66 * and function code cmd.
67 * In case of an exception return 3. Otherwise return result of bitwise OR of
68 * resulting condition code and DIAG return code. */
69 static inline int dia250(void *iob
, int cmd
)
71 register unsigned long reg2
asm ("2") = (unsigned long) iob
;
73 struct dasd_diag_init_io init_io
;
74 struct dasd_diag_rw_io rw_io
;
86 : "+d" (rc
), "=m" (*(addr_type
*) iob
)
87 : "d" (cmd
), "d" (reg2
), "m" (*(addr_type
*) iob
)
92 /* Initialize block I/O to DIAG device using the specified blocksize and
93 * block offset. On success, return zero and set end_block to contain the
94 * number of blocks on the device minus the specified offset. Return non-zero
97 mdsk_init_io(struct dasd_device
*device
, unsigned int blocksize
,
98 blocknum_t offset
, blocknum_t
*end_block
)
100 struct dasd_diag_private
*private;
101 struct dasd_diag_init_io
*iib
;
104 private = (struct dasd_diag_private
*) device
->private;
106 memset(iib
, 0, sizeof (struct dasd_diag_init_io
));
108 iib
->dev_nr
= private->dev_id
.devno
;
109 iib
->block_size
= blocksize
;
110 iib
->offset
= offset
;
111 iib
->flaga
= DASD_DIAG_FLAGA_DEFAULT
;
113 rc
= dia250(iib
, INIT_BIO
);
115 if ((rc
& 3) == 0 && end_block
)
116 *end_block
= iib
->end_block
;
121 /* Remove block I/O environment for device. Return zero on success, non-zero
124 mdsk_term_io(struct dasd_device
* device
)
126 struct dasd_diag_private
*private;
127 struct dasd_diag_init_io
*iib
;
130 private = (struct dasd_diag_private
*) device
->private;
132 memset(iib
, 0, sizeof (struct dasd_diag_init_io
));
133 iib
->dev_nr
= private->dev_id
.devno
;
134 rc
= dia250(iib
, TERM_BIO
);
138 /* Error recovery for failed DIAG requests - try to reestablish the DIAG
141 dasd_diag_erp(struct dasd_device
*device
)
145 mdsk_term_io(device
);
146 rc
= mdsk_init_io(device
, device
->block
->bp_block
, 0, NULL
);
148 if (!(test_and_set_bit(DASD_FLAG_DEVICE_RO
, &device
->flags
)))
149 pr_warning("%s: The access mode of a DIAG device "
150 "changed to read-only\n",
151 dev_name(&device
->cdev
->dev
));
155 pr_warning("%s: DIAG ERP failed with "
156 "rc=%d\n", dev_name(&device
->cdev
->dev
), rc
);
159 /* Start a given request at the device. Return zero on success, non-zero
162 dasd_start_diag(struct dasd_ccw_req
* cqr
)
164 struct dasd_device
*device
;
165 struct dasd_diag_private
*private;
166 struct dasd_diag_req
*dreq
;
169 device
= cqr
->startdev
;
170 if (cqr
->retries
< 0) {
171 DBF_DEV_EVENT(DBF_ERR
, device
, "DIAG start_IO: request %p "
172 "- no retry left)", cqr
);
173 cqr
->status
= DASD_CQR_ERROR
;
176 private = (struct dasd_diag_private
*) device
->private;
177 dreq
= (struct dasd_diag_req
*) cqr
->data
;
179 private->iob
.dev_nr
= private->dev_id
.devno
;
180 private->iob
.key
= 0;
181 private->iob
.flags
= DASD_DIAG_RWFLAG_ASYNC
;
182 private->iob
.block_count
= dreq
->block_count
;
183 private->iob
.interrupt_params
= (addr_t
) cqr
;
184 private->iob
.bio_list
= dreq
->bio
;
185 private->iob
.flaga
= DASD_DIAG_FLAGA_DEFAULT
;
187 cqr
->startclk
= get_clock();
188 cqr
->starttime
= jiffies
;
191 rc
= dia250(&private->iob
, RW_BIO
);
193 case 0: /* Synchronous I/O finished successfully */
194 cqr
->stopclk
= get_clock();
195 cqr
->status
= DASD_CQR_SUCCESS
;
196 /* Indicate to calling function that only a dasd_schedule_bh()
197 and no timer is needed */
200 case 8: /* Asynchronous I/O was started */
201 cqr
->status
= DASD_CQR_IN_IO
;
204 default: /* Error condition */
205 cqr
->status
= DASD_CQR_QUEUED
;
206 DBF_DEV_EVENT(DBF_WARNING
, device
, "dia250 returned rc=%d", rc
);
207 dasd_diag_erp(device
);
215 /* Terminate given request at the device. */
217 dasd_diag_term_IO(struct dasd_ccw_req
* cqr
)
219 struct dasd_device
*device
;
221 device
= cqr
->startdev
;
222 mdsk_term_io(device
);
223 mdsk_init_io(device
, device
->block
->bp_block
, 0, NULL
);
224 cqr
->status
= DASD_CQR_CLEAR_PENDING
;
225 cqr
->stopclk
= get_clock();
226 dasd_schedule_device_bh(device
);
230 /* Handle external interruption. */
232 dasd_ext_handler(__u16 code
)
234 struct dasd_ccw_req
*cqr
, *next
;
235 struct dasd_device
*device
;
236 unsigned long long expires
;
242 int_code
= *((u8
*) DASD_DIAG_LC_INT_CODE
);
243 status
= *((u8
*) DASD_DIAG_LC_INT_STATUS
);
245 case DASD_DIAG_CODE_31BIT
:
246 ip
= (addr_t
) *((u32
*) DASD_DIAG_LC_INT_PARM_31BIT
);
248 case DASD_DIAG_CODE_64BIT
:
249 ip
= (addr_t
) *((u64
*) DASD_DIAG_LC_INT_PARM_64BIT
);
254 if (!ip
) { /* no intparm: unsolicited interrupt */
255 DBF_EVENT(DBF_NOTICE
, "%s", "caught unsolicited "
259 cqr
= (struct dasd_ccw_req
*) ip
;
260 device
= (struct dasd_device
*) cqr
->startdev
;
261 if (strncmp(device
->discipline
->ebcname
, (char *) &cqr
->magic
, 4)) {
262 DBF_DEV_EVENT(DBF_WARNING
, device
,
263 " magic number of dasd_ccw_req 0x%08X doesn't"
264 " match discipline 0x%08X",
265 cqr
->magic
, *(int *) (&device
->discipline
->name
));
269 /* get irq lock to modify request queue */
270 spin_lock_irqsave(get_ccwdev_lock(device
->cdev
), flags
);
272 /* Check for a pending clear operation */
273 if (cqr
->status
== DASD_CQR_CLEAR_PENDING
) {
274 cqr
->status
= DASD_CQR_CLEARED
;
275 dasd_device_clear_timer(device
);
276 dasd_schedule_device_bh(device
);
277 spin_unlock_irqrestore(get_ccwdev_lock(device
->cdev
), flags
);
281 cqr
->stopclk
= get_clock();
285 cqr
->status
= DASD_CQR_SUCCESS
;
286 /* Start first request on queue if possible -> fast_io. */
287 if (!list_empty(&device
->ccw_queue
)) {
288 next
= list_entry(device
->ccw_queue
.next
,
289 struct dasd_ccw_req
, devlist
);
290 if (next
->status
== DASD_CQR_QUEUED
) {
291 rc
= dasd_start_diag(next
);
293 expires
= next
->expires
;
297 cqr
->status
= DASD_CQR_QUEUED
;
298 DBF_DEV_EVENT(DBF_DEBUG
, device
, "interrupt status for "
299 "request %p was %d (%d retries left)", cqr
, status
,
301 dasd_diag_erp(device
);
305 dasd_device_set_timer(device
, expires
);
307 dasd_device_clear_timer(device
);
308 dasd_schedule_device_bh(device
);
310 spin_unlock_irqrestore(get_ccwdev_lock(device
->cdev
), flags
);
313 /* Check whether device can be controlled by DIAG discipline. Return zero on
314 * success, non-zero otherwise. */
316 dasd_diag_check_device(struct dasd_device
*device
)
318 struct dasd_block
*block
;
319 struct dasd_diag_private
*private;
320 struct dasd_diag_characteristics
*rdc_data
;
321 struct dasd_diag_bio bio
;
322 struct vtoc_cms_label
*label
;
323 blocknum_t end_block
;
324 unsigned int sb
, bsize
;
327 private = (struct dasd_diag_private
*) device
->private;
328 if (private == NULL
) {
329 private = kzalloc(sizeof(struct dasd_diag_private
),GFP_KERNEL
);
330 if (private == NULL
) {
331 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
332 "Allocating memory for private DASD data "
336 ccw_device_get_id(device
->cdev
, &private->dev_id
);
337 device
->private = (void *) private;
339 block
= dasd_alloc_block();
341 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
342 "could not allocate dasd block structure");
343 device
->private = NULL
;
345 return PTR_ERR(block
);
347 device
->block
= block
;
348 block
->base
= device
;
350 /* Read Device Characteristics */
351 rdc_data
= (void *) &(private->rdc_data
);
352 rdc_data
->dev_nr
= private->dev_id
.devno
;
353 rdc_data
->rdc_len
= sizeof (struct dasd_diag_characteristics
);
355 rc
= diag210((struct diag210
*) rdc_data
);
357 DBF_DEV_EVENT(DBF_WARNING
, device
, "failed to retrieve device "
358 "information (rc=%d)", rc
);
363 device
->default_expires
= DIAG_TIMEOUT
;
365 /* Figure out position of label block */
366 switch (private->rdc_data
.vdev_class
) {
368 private->pt_block
= 1;
371 private->pt_block
= 2;
374 pr_warning("%s: Device type %d is not supported "
375 "in DIAG mode\n", dev_name(&device
->cdev
->dev
),
376 private->rdc_data
.vdev_class
);
381 DBF_DEV_EVENT(DBF_INFO
, device
,
382 "%04X: %04X on real %04X/%02X",
385 rdc_data
->rdev_type
, rdc_data
->rdev_model
);
387 /* terminate all outstanding operations */
388 mdsk_term_io(device
);
390 /* figure out blocksize of device */
391 label
= (struct vtoc_cms_label
*) get_zeroed_page(GFP_KERNEL
);
393 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
394 "No memory to allocate initialization request");
400 /* try all sizes - needed for ECKD devices */
401 for (bsize
= 512; bsize
<= PAGE_SIZE
; bsize
<<= 1) {
402 mdsk_init_io(device
, bsize
, 0, &end_block
);
403 memset(&bio
, 0, sizeof (struct dasd_diag_bio
));
404 bio
.type
= MDSK_READ_REQ
;
405 bio
.block_number
= private->pt_block
+ 1;
407 memset(&private->iob
, 0, sizeof (struct dasd_diag_rw_io
));
408 private->iob
.dev_nr
= rdc_data
->dev_nr
;
409 private->iob
.key
= 0;
410 private->iob
.flags
= 0; /* do synchronous io */
411 private->iob
.block_count
= 1;
412 private->iob
.interrupt_params
= 0;
413 private->iob
.bio_list
= &bio
;
414 private->iob
.flaga
= DASD_DIAG_FLAGA_DEFAULT
;
415 rc
= dia250(&private->iob
, RW_BIO
);
417 pr_warning("%s: A 64-bit DIAG call failed\n",
418 dev_name(&device
->cdev
->dev
));
422 mdsk_term_io(device
);
426 if (bsize
> PAGE_SIZE
) {
427 pr_warning("%s: Accessing the DASD failed because of an "
428 "incorrect format (rc=%d)\n",
429 dev_name(&device
->cdev
->dev
), rc
);
433 /* check for label block */
434 if (memcmp(label
->label_id
, DASD_DIAG_CMS1
,
435 sizeof(DASD_DIAG_CMS1
)) == 0) {
436 /* get formatted blocksize from label block */
437 bsize
= (unsigned int) label
->block_size
;
438 block
->blocks
= (unsigned long) label
->block_count
;
440 block
->blocks
= end_block
;
441 block
->bp_block
= bsize
;
442 block
->s2b_shift
= 0; /* bits to shift 512 to get a block */
443 for (sb
= 512; sb
< bsize
; sb
= sb
<< 1)
445 rc
= mdsk_init_io(device
, block
->bp_block
, 0, NULL
);
446 if (rc
&& (rc
!= 4)) {
447 pr_warning("%s: DIAG initialization failed with rc=%d\n",
448 dev_name(&device
->cdev
->dev
), rc
);
452 set_bit(DASD_FLAG_DEVICE_RO
, &device
->flags
);
453 pr_info("%s: New DASD with %ld byte/block, total size %ld "
454 "KB%s\n", dev_name(&device
->cdev
->dev
),
455 (unsigned long) block
->bp_block
,
456 (unsigned long) (block
->blocks
<<
457 block
->s2b_shift
) >> 1,
458 (rc
== 4) ? ", read-only device" : "");
462 free_page((long) label
);
465 device
->block
= NULL
;
466 dasd_free_block(block
);
467 device
->private = NULL
;
473 /* Fill in virtual disk geometry for device. Return zero on success, non-zero
476 dasd_diag_fill_geometry(struct dasd_block
*block
, struct hd_geometry
*geo
)
478 if (dasd_check_blocksize(block
->bp_block
) != 0)
480 geo
->cylinders
= (block
->blocks
<< block
->s2b_shift
) >> 10;
482 geo
->sectors
= 128 >> block
->s2b_shift
;
487 dasd_diag_erp_action(struct dasd_ccw_req
* cqr
)
489 return dasd_default_erp_action
;
493 dasd_diag_erp_postaction(struct dasd_ccw_req
* cqr
)
495 return dasd_default_erp_postaction
;
498 /* Create DASD request from block device request. Return pointer to new
499 * request on success, ERR_PTR otherwise. */
500 static struct dasd_ccw_req
*dasd_diag_build_cp(struct dasd_device
*memdev
,
501 struct dasd_block
*block
,
504 struct dasd_ccw_req
*cqr
;
505 struct dasd_diag_req
*dreq
;
506 struct dasd_diag_bio
*dbio
;
507 struct req_iterator iter
;
510 unsigned int count
, datasize
;
511 sector_t recid
, first_rec
, last_rec
;
512 unsigned int blksize
, off
;
513 unsigned char rw_cmd
;
515 if (rq_data_dir(req
) == READ
)
516 rw_cmd
= MDSK_READ_REQ
;
517 else if (rq_data_dir(req
) == WRITE
)
518 rw_cmd
= MDSK_WRITE_REQ
;
520 return ERR_PTR(-EINVAL
);
521 blksize
= block
->bp_block
;
522 /* Calculate record id of first and last block. */
523 first_rec
= blk_rq_pos(req
) >> block
->s2b_shift
;
525 (blk_rq_pos(req
) + blk_rq_sectors(req
) - 1) >> block
->s2b_shift
;
526 /* Check struct bio and count the number of blocks for the request. */
528 rq_for_each_segment(bv
, req
, iter
) {
529 if (bv
->bv_len
& (blksize
- 1))
530 /* Fba can only do full blocks. */
531 return ERR_PTR(-EINVAL
);
532 count
+= bv
->bv_len
>> (block
->s2b_shift
+ 9);
535 if (count
!= last_rec
- first_rec
+ 1)
536 return ERR_PTR(-EINVAL
);
537 /* Build the request */
538 datasize
= sizeof(struct dasd_diag_req
) +
539 count
*sizeof(struct dasd_diag_bio
);
540 cqr
= dasd_smalloc_request(DASD_DIAG_MAGIC
, 0, datasize
, memdev
);
544 dreq
= (struct dasd_diag_req
*) cqr
->data
;
545 dreq
->block_count
= count
;
548 rq_for_each_segment(bv
, req
, iter
) {
549 dst
= page_address(bv
->bv_page
) + bv
->bv_offset
;
550 for (off
= 0; off
< bv
->bv_len
; off
+= blksize
) {
551 memset(dbio
, 0, sizeof (struct dasd_diag_bio
));
553 dbio
->block_number
= recid
+ 1;
560 cqr
->retries
= DIAG_MAX_RETRIES
;
561 cqr
->buildclk
= get_clock();
562 if (blk_noretry_request(req
) ||
563 block
->base
->features
& DASD_FEATURE_FAILFAST
)
564 set_bit(DASD_CQR_FLAGS_FAILFAST
, &cqr
->flags
);
565 cqr
->startdev
= memdev
;
566 cqr
->memdev
= memdev
;
568 cqr
->expires
= memdev
->default_expires
* HZ
;
569 cqr
->status
= DASD_CQR_FILLED
;
573 /* Release DASD request. Return non-zero if request was successful, zero
576 dasd_diag_free_cp(struct dasd_ccw_req
*cqr
, struct request
*req
)
580 status
= cqr
->status
== DASD_CQR_DONE
;
581 dasd_sfree_request(cqr
, cqr
->memdev
);
585 static void dasd_diag_handle_terminated_request(struct dasd_ccw_req
*cqr
)
587 cqr
->status
= DASD_CQR_FILLED
;
590 /* Fill in IOCTL data for device. */
592 dasd_diag_fill_info(struct dasd_device
* device
,
593 struct dasd_information2_t
* info
)
595 struct dasd_diag_private
*private;
597 private = (struct dasd_diag_private
*) device
->private;
598 info
->label_block
= (unsigned int) private->pt_block
;
599 info
->FBA_layout
= 1;
600 info
->format
= DASD_FORMAT_LDL
;
601 info
->characteristics_size
= sizeof (struct dasd_diag_characteristics
);
602 memcpy(info
->characteristics
,
603 &((struct dasd_diag_private
*) device
->private)->rdc_data
,
604 sizeof (struct dasd_diag_characteristics
));
605 info
->confdata_size
= 0;
610 dasd_diag_dump_sense(struct dasd_device
*device
, struct dasd_ccw_req
* req
,
613 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
614 "dump sense not available for DIAG data");
617 static struct dasd_discipline dasd_diag_discipline
= {
618 .owner
= THIS_MODULE
,
621 .max_blocks
= DIAG_MAX_BLOCKS
,
622 .check_device
= dasd_diag_check_device
,
623 .fill_geometry
= dasd_diag_fill_geometry
,
624 .start_IO
= dasd_start_diag
,
625 .term_IO
= dasd_diag_term_IO
,
626 .handle_terminated_request
= dasd_diag_handle_terminated_request
,
627 .erp_action
= dasd_diag_erp_action
,
628 .erp_postaction
= dasd_diag_erp_postaction
,
629 .build_cp
= dasd_diag_build_cp
,
630 .free_cp
= dasd_diag_free_cp
,
631 .dump_sense
= dasd_diag_dump_sense
,
632 .fill_info
= dasd_diag_fill_info
,
638 if (!MACHINE_IS_VM
) {
639 pr_info("Discipline %s cannot be used without z/VM\n",
640 dasd_diag_discipline
.name
);
643 ASCEBC(dasd_diag_discipline
.ebcname
, 4);
646 register_external_interrupt(0x2603, dasd_ext_handler
);
647 dasd_diag_discipline_pointer
= &dasd_diag_discipline
;
652 dasd_diag_cleanup(void)
654 unregister_external_interrupt(0x2603, dasd_ext_handler
);
656 dasd_diag_discipline_pointer
= NULL
;
659 module_init(dasd_diag_init
);
660 module_exit(dasd_diag_cleanup
);