2 * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
3 * Based on.......: linux/drivers/s390/block/mdisk.c
4 * ...............: by Hartmunt Penner <hpenner@de.ibm.com>
5 * Bugreports.to..: <Linux390@de.ibm.com>
6 * Copyright IBM Corp. 1999, 2000
10 #define KMSG_COMPONENT "dasd"
12 #include <linux/kernel_stat.h>
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>
25 #include <asm/ebcdic.h>
32 #include "dasd_diag.h"
34 #define PRINTK_HEADER "dasd(diag):"
36 MODULE_LICENSE("GPL");
38 /* The maximum number of blocks per request (max_blocks) is dependent on the
39 * amount of storage that is available in the static I/O buffer for each
40 * device. Currently each device gets 2 pages. We want to fit two requests
41 * into the available memory so that we can immediately start the next if one
43 #define DIAG_MAX_BLOCKS (((2 * PAGE_SIZE - sizeof(struct dasd_ccw_req) - \
44 sizeof(struct dasd_diag_req)) / \
45 sizeof(struct dasd_diag_bio)) / 2)
46 #define DIAG_MAX_RETRIES 32
47 #define DIAG_TIMEOUT 50
49 static struct dasd_discipline dasd_diag_discipline
;
51 struct dasd_diag_private
{
52 struct dasd_diag_characteristics rdc_data
;
53 struct dasd_diag_rw_io iob
;
54 struct dasd_diag_init_io iib
;
56 struct ccw_dev_id dev_id
;
59 struct dasd_diag_req
{
60 unsigned int block_count
;
61 struct dasd_diag_bio bio
[0];
64 static const u8 DASD_DIAG_CMS1
[] = { 0xc3, 0xd4, 0xe2, 0xf1 };/* EBCDIC CMS1 */
66 /* Perform DIAG250 call with block I/O parameter list iob (input and output)
67 * and function code cmd.
68 * In case of an exception return 3. Otherwise return result of bitwise OR of
69 * resulting condition code and DIAG return code. */
70 static inline int dia250(void *iob
, int cmd
)
72 register unsigned long reg2
asm ("2") = (unsigned long) iob
;
74 struct dasd_diag_init_io init_io
;
75 struct dasd_diag_rw_io rw_io
;
80 diag_stat_inc(DIAG_STAT_X250
);
88 : "+d" (rc
), "=m" (*(addr_type
*) iob
)
89 : "d" (cmd
), "d" (reg2
), "m" (*(addr_type
*) iob
)
94 /* Initialize block I/O to DIAG device using the specified blocksize and
95 * block offset. On success, return zero and set end_block to contain the
96 * number of blocks on the device minus the specified offset. Return non-zero
99 mdsk_init_io(struct dasd_device
*device
, unsigned int blocksize
,
100 blocknum_t offset
, blocknum_t
*end_block
)
102 struct dasd_diag_private
*private;
103 struct dasd_diag_init_io
*iib
;
106 private = (struct dasd_diag_private
*) device
->private;
108 memset(iib
, 0, sizeof (struct dasd_diag_init_io
));
110 iib
->dev_nr
= private->dev_id
.devno
;
111 iib
->block_size
= blocksize
;
112 iib
->offset
= offset
;
113 iib
->flaga
= DASD_DIAG_FLAGA_DEFAULT
;
115 rc
= dia250(iib
, INIT_BIO
);
117 if ((rc
& 3) == 0 && end_block
)
118 *end_block
= iib
->end_block
;
123 /* Remove block I/O environment for device. Return zero on success, non-zero
126 mdsk_term_io(struct dasd_device
* device
)
128 struct dasd_diag_private
*private;
129 struct dasd_diag_init_io
*iib
;
132 private = (struct dasd_diag_private
*) device
->private;
134 memset(iib
, 0, sizeof (struct dasd_diag_init_io
));
135 iib
->dev_nr
= private->dev_id
.devno
;
136 rc
= dia250(iib
, TERM_BIO
);
140 /* Error recovery for failed DIAG requests - try to reestablish the DIAG
143 dasd_diag_erp(struct dasd_device
*device
)
147 mdsk_term_io(device
);
148 rc
= mdsk_init_io(device
, device
->block
->bp_block
, 0, NULL
);
150 if (!(test_and_set_bit(DASD_FLAG_DEVICE_RO
, &device
->flags
)))
151 pr_warning("%s: The access mode of a DIAG device "
152 "changed to read-only\n",
153 dev_name(&device
->cdev
->dev
));
157 pr_warning("%s: DIAG ERP failed with "
158 "rc=%d\n", dev_name(&device
->cdev
->dev
), rc
);
161 /* Start a given request at the device. Return zero on success, non-zero
164 dasd_start_diag(struct dasd_ccw_req
* cqr
)
166 struct dasd_device
*device
;
167 struct dasd_diag_private
*private;
168 struct dasd_diag_req
*dreq
;
171 device
= cqr
->startdev
;
172 if (cqr
->retries
< 0) {
173 DBF_DEV_EVENT(DBF_ERR
, device
, "DIAG start_IO: request %p "
174 "- no retry left)", cqr
);
175 cqr
->status
= DASD_CQR_ERROR
;
178 private = (struct dasd_diag_private
*) device
->private;
179 dreq
= (struct dasd_diag_req
*) cqr
->data
;
181 private->iob
.dev_nr
= private->dev_id
.devno
;
182 private->iob
.key
= 0;
183 private->iob
.flags
= DASD_DIAG_RWFLAG_ASYNC
;
184 private->iob
.block_count
= dreq
->block_count
;
185 private->iob
.interrupt_params
= (addr_t
) cqr
;
186 private->iob
.bio_list
= dreq
->bio
;
187 private->iob
.flaga
= DASD_DIAG_FLAGA_DEFAULT
;
189 cqr
->startclk
= get_tod_clock();
190 cqr
->starttime
= jiffies
;
193 rc
= dia250(&private->iob
, RW_BIO
);
195 case 0: /* Synchronous I/O finished successfully */
196 cqr
->stopclk
= get_tod_clock();
197 cqr
->status
= DASD_CQR_SUCCESS
;
198 /* Indicate to calling function that only a dasd_schedule_bh()
199 and no timer is needed */
202 case 8: /* Asynchronous I/O was started */
203 cqr
->status
= DASD_CQR_IN_IO
;
206 default: /* Error condition */
207 cqr
->status
= DASD_CQR_QUEUED
;
208 DBF_DEV_EVENT(DBF_WARNING
, device
, "dia250 returned rc=%d", rc
);
209 dasd_diag_erp(device
);
217 /* Terminate given request at the device. */
219 dasd_diag_term_IO(struct dasd_ccw_req
* cqr
)
221 struct dasd_device
*device
;
223 device
= cqr
->startdev
;
224 mdsk_term_io(device
);
225 mdsk_init_io(device
, device
->block
->bp_block
, 0, NULL
);
226 cqr
->status
= DASD_CQR_CLEAR_PENDING
;
227 cqr
->stopclk
= get_tod_clock();
228 dasd_schedule_device_bh(device
);
232 /* Handle external interruption. */
233 static void dasd_ext_handler(struct ext_code ext_code
,
234 unsigned int param32
, unsigned long param64
)
236 struct dasd_ccw_req
*cqr
, *next
;
237 struct dasd_device
*device
;
238 unsigned long long expires
;
243 switch (ext_code
.subcode
>> 8) {
244 case DASD_DIAG_CODE_31BIT
:
245 ip
= (addr_t
) param32
;
247 case DASD_DIAG_CODE_64BIT
:
248 ip
= (addr_t
) param64
;
253 inc_irq_stat(IRQEXT_DSD
);
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_tod_clock();
284 if ((ext_code
.subcode
& 0xff) == 0) {
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
,
300 ext_code
.subcode
& 0xff, cqr
->retries
);
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
;
364 device
->default_retries
= DIAG_MAX_RETRIES
;
366 /* Figure out position of label block */
367 switch (private->rdc_data
.vdev_class
) {
369 private->pt_block
= 1;
372 private->pt_block
= 2;
375 pr_warning("%s: Device type %d is not supported "
376 "in DIAG mode\n", dev_name(&device
->cdev
->dev
),
377 private->rdc_data
.vdev_class
);
382 DBF_DEV_EVENT(DBF_INFO
, device
,
383 "%04X: %04X on real %04X/%02X",
386 rdc_data
->rdev_type
, rdc_data
->rdev_model
);
388 /* terminate all outstanding operations */
389 mdsk_term_io(device
);
391 /* figure out blocksize of device */
392 label
= (struct vtoc_cms_label
*) get_zeroed_page(GFP_KERNEL
);
394 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
395 "No memory to allocate initialization request");
401 /* try all sizes - needed for ECKD devices */
402 for (bsize
= 512; bsize
<= PAGE_SIZE
; bsize
<<= 1) {
403 mdsk_init_io(device
, bsize
, 0, &end_block
);
404 memset(&bio
, 0, sizeof (struct dasd_diag_bio
));
405 bio
.type
= MDSK_READ_REQ
;
406 bio
.block_number
= private->pt_block
+ 1;
408 memset(&private->iob
, 0, sizeof (struct dasd_diag_rw_io
));
409 private->iob
.dev_nr
= rdc_data
->dev_nr
;
410 private->iob
.key
= 0;
411 private->iob
.flags
= 0; /* do synchronous io */
412 private->iob
.block_count
= 1;
413 private->iob
.interrupt_params
= 0;
414 private->iob
.bio_list
= &bio
;
415 private->iob
.flaga
= DASD_DIAG_FLAGA_DEFAULT
;
416 rc
= dia250(&private->iob
, RW_BIO
);
418 pr_warning("%s: A 64-bit DIAG call failed\n",
419 dev_name(&device
->cdev
->dev
));
423 mdsk_term_io(device
);
427 if (bsize
> PAGE_SIZE
) {
428 pr_warning("%s: Accessing the DASD failed because of an "
429 "incorrect format (rc=%d)\n",
430 dev_name(&device
->cdev
->dev
), rc
);
434 /* check for label block */
435 if (memcmp(label
->label_id
, DASD_DIAG_CMS1
,
436 sizeof(DASD_DIAG_CMS1
)) == 0) {
437 /* get formatted blocksize from label block */
438 bsize
= (unsigned int) label
->block_size
;
439 block
->blocks
= (unsigned long) label
->block_count
;
441 block
->blocks
= end_block
;
442 block
->bp_block
= bsize
;
443 block
->s2b_shift
= 0; /* bits to shift 512 to get a block */
444 for (sb
= 512; sb
< bsize
; sb
= sb
<< 1)
446 rc
= mdsk_init_io(device
, block
->bp_block
, 0, NULL
);
447 if (rc
&& (rc
!= 4)) {
448 pr_warning("%s: DIAG initialization failed with rc=%d\n",
449 dev_name(&device
->cdev
->dev
), rc
);
453 set_bit(DASD_FLAG_DEVICE_RO
, &device
->flags
);
454 pr_info("%s: New DASD with %ld byte/block, total size %ld "
455 "KB%s\n", dev_name(&device
->cdev
->dev
),
456 (unsigned long) block
->bp_block
,
457 (unsigned long) (block
->blocks
<<
458 block
->s2b_shift
) >> 1,
459 (rc
== 4) ? ", read-only device" : "");
463 free_page((long) label
);
466 device
->block
= NULL
;
467 dasd_free_block(block
);
468 device
->private = NULL
;
474 /* Fill in virtual disk geometry for device. Return zero on success, non-zero
477 dasd_diag_fill_geometry(struct dasd_block
*block
, struct hd_geometry
*geo
)
479 if (dasd_check_blocksize(block
->bp_block
) != 0)
481 geo
->cylinders
= (block
->blocks
<< block
->s2b_shift
) >> 10;
483 geo
->sectors
= 128 >> block
->s2b_shift
;
488 dasd_diag_erp_action(struct dasd_ccw_req
* cqr
)
490 return dasd_default_erp_action
;
494 dasd_diag_erp_postaction(struct dasd_ccw_req
* cqr
)
496 return dasd_default_erp_postaction
;
499 /* Create DASD request from block device request. Return pointer to new
500 * request on success, ERR_PTR otherwise. */
501 static struct dasd_ccw_req
*dasd_diag_build_cp(struct dasd_device
*memdev
,
502 struct dasd_block
*block
,
505 struct dasd_ccw_req
*cqr
;
506 struct dasd_diag_req
*dreq
;
507 struct dasd_diag_bio
*dbio
;
508 struct req_iterator iter
;
511 unsigned int count
, datasize
;
512 sector_t recid
, first_rec
, last_rec
;
513 unsigned int blksize
, off
;
514 unsigned char rw_cmd
;
516 if (rq_data_dir(req
) == READ
)
517 rw_cmd
= MDSK_READ_REQ
;
518 else if (rq_data_dir(req
) == WRITE
)
519 rw_cmd
= MDSK_WRITE_REQ
;
521 return ERR_PTR(-EINVAL
);
522 blksize
= block
->bp_block
;
523 /* Calculate record id of first and last block. */
524 first_rec
= blk_rq_pos(req
) >> block
->s2b_shift
;
526 (blk_rq_pos(req
) + blk_rq_sectors(req
) - 1) >> block
->s2b_shift
;
527 /* Check struct bio and count the number of blocks for the request. */
529 rq_for_each_segment(bv
, req
, iter
) {
530 if (bv
.bv_len
& (blksize
- 1))
531 /* Fba can only do full blocks. */
532 return ERR_PTR(-EINVAL
);
533 count
+= bv
.bv_len
>> (block
->s2b_shift
+ 9);
536 if (count
!= last_rec
- first_rec
+ 1)
537 return ERR_PTR(-EINVAL
);
538 /* Build the request */
539 datasize
= sizeof(struct dasd_diag_req
) +
540 count
*sizeof(struct dasd_diag_bio
);
541 cqr
= dasd_smalloc_request(DASD_DIAG_MAGIC
, 0, datasize
, memdev
);
545 dreq
= (struct dasd_diag_req
*) cqr
->data
;
546 dreq
->block_count
= count
;
549 rq_for_each_segment(bv
, req
, iter
) {
550 dst
= page_address(bv
.bv_page
) + bv
.bv_offset
;
551 for (off
= 0; off
< bv
.bv_len
; off
+= blksize
) {
552 memset(dbio
, 0, sizeof (struct dasd_diag_bio
));
554 dbio
->block_number
= recid
+ 1;
561 cqr
->retries
= memdev
->default_retries
;
562 cqr
->buildclk
= get_tod_clock();
563 if (blk_noretry_request(req
) ||
564 block
->base
->features
& DASD_FEATURE_FAILFAST
)
565 set_bit(DASD_CQR_FLAGS_FAILFAST
, &cqr
->flags
);
566 cqr
->startdev
= memdev
;
567 cqr
->memdev
= memdev
;
569 cqr
->expires
= memdev
->default_expires
* HZ
;
570 cqr
->status
= DASD_CQR_FILLED
;
574 /* Release DASD request. Return non-zero if request was successful, zero
577 dasd_diag_free_cp(struct dasd_ccw_req
*cqr
, struct request
*req
)
581 status
= cqr
->status
== DASD_CQR_DONE
;
582 dasd_sfree_request(cqr
, cqr
->memdev
);
586 static void dasd_diag_handle_terminated_request(struct dasd_ccw_req
*cqr
)
588 if (cqr
->retries
< 0)
589 cqr
->status
= DASD_CQR_FAILED
;
591 cqr
->status
= DASD_CQR_FILLED
;
594 /* Fill in IOCTL data for device. */
596 dasd_diag_fill_info(struct dasd_device
* device
,
597 struct dasd_information2_t
* info
)
599 struct dasd_diag_private
*private;
601 private = (struct dasd_diag_private
*) device
->private;
602 info
->label_block
= (unsigned int) private->pt_block
;
603 info
->FBA_layout
= 1;
604 info
->format
= DASD_FORMAT_LDL
;
605 info
->characteristics_size
= sizeof (struct dasd_diag_characteristics
);
606 memcpy(info
->characteristics
,
607 &((struct dasd_diag_private
*) device
->private)->rdc_data
,
608 sizeof (struct dasd_diag_characteristics
));
609 info
->confdata_size
= 0;
614 dasd_diag_dump_sense(struct dasd_device
*device
, struct dasd_ccw_req
* req
,
617 DBF_DEV_EVENT(DBF_WARNING
, device
, "%s",
618 "dump sense not available for DIAG data");
621 static struct dasd_discipline dasd_diag_discipline
= {
622 .owner
= THIS_MODULE
,
625 .max_blocks
= DIAG_MAX_BLOCKS
,
626 .check_device
= dasd_diag_check_device
,
627 .verify_path
= dasd_generic_verify_path
,
628 .fill_geometry
= dasd_diag_fill_geometry
,
629 .start_IO
= dasd_start_diag
,
630 .term_IO
= dasd_diag_term_IO
,
631 .handle_terminated_request
= dasd_diag_handle_terminated_request
,
632 .erp_action
= dasd_diag_erp_action
,
633 .erp_postaction
= dasd_diag_erp_postaction
,
634 .build_cp
= dasd_diag_build_cp
,
635 .free_cp
= dasd_diag_free_cp
,
636 .dump_sense
= dasd_diag_dump_sense
,
637 .fill_info
= dasd_diag_fill_info
,
643 if (!MACHINE_IS_VM
) {
644 pr_info("Discipline %s cannot be used without z/VM\n",
645 dasd_diag_discipline
.name
);
648 ASCEBC(dasd_diag_discipline
.ebcname
, 4);
650 irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL
);
651 register_external_irq(EXT_IRQ_CP_SERVICE
, dasd_ext_handler
);
652 dasd_diag_discipline_pointer
= &dasd_diag_discipline
;
657 dasd_diag_cleanup(void)
659 unregister_external_irq(EXT_IRQ_CP_SERVICE
, dasd_ext_handler
);
660 irq_subclass_unregister(IRQ_SUBCLASS_SERVICE_SIGNAL
);
661 dasd_diag_discipline_pointer
= NULL
;
664 module_init(dasd_diag_init
);
665 module_exit(dasd_diag_cleanup
);