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
12 #include <linux/config.h>
13 #include <linux/stddef.h>
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/hdreg.h> /* HDIO_GETGEO */
17 #include <linux/bio.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
22 #include <asm/debug.h>
23 #include <asm/ebcdic.h>
25 #include <asm/s390_ext.h>
26 #include <asm/todclk.h>
29 #include "dasd_diag.h"
33 #endif /* PRINTK_HEADER */
34 #define PRINTK_HEADER "dasd(diag):"
36 MODULE_LICENSE("GPL");
38 struct dasd_discipline dasd_diag_discipline;
40 struct dasd_diag_private {
41 struct dasd_diag_characteristics rdc_data;
42 struct dasd_diag_rw_io iob;
43 struct dasd_diag_init_io iib;
44 unsigned int pt_block;
47 struct dasd_diag_req {
49 struct dasd_diag_bio bio[0];
53 dia250(void *iob, int cmd)
57 __asm__ __volatile__(" lhi %0,3\n"
64 #ifndef CONFIG_ARCH_S390X
65 ".section __ex_table,\"a\"\n"
70 ".section __ex_table,\"a\"\n"
76 : "d" (cmd), "d" ((void *) __pa(iob))
82 mdsk_init_io(struct dasd_device * device, int blocksize, int offset, int size)
84 struct dasd_diag_private *private;
85 struct dasd_diag_init_io *iib;
88 private = (struct dasd_diag_private *) device->private;
90 memset(iib, 0, sizeof (struct dasd_diag_init_io));
92 iib->dev_nr = _ccw_device_get_device_number(device->cdev);
93 iib->block_size = blocksize;
96 iib->end_block = size;
98 rc = dia250(iib, INIT_BIO);
103 static __inline__ int
104 mdsk_term_io(struct dasd_device * device)
106 struct dasd_diag_private *private;
107 struct dasd_diag_init_io *iib;
110 private = (struct dasd_diag_private *) device->private;
112 memset(iib, 0, sizeof (struct dasd_diag_init_io));
113 iib->dev_nr = _ccw_device_get_device_number(device->cdev);
114 rc = dia250(iib, TERM_BIO);
119 dasd_start_diag(struct dasd_ccw_req * cqr)
121 struct dasd_device *device;
122 struct dasd_diag_private *private;
123 struct dasd_diag_req *dreq;
126 device = cqr->device;
127 private = (struct dasd_diag_private *) device->private;
128 dreq = (struct dasd_diag_req *) cqr->data;
130 private->iob.dev_nr = _ccw_device_get_device_number(device->cdev);
131 private->iob.key = 0;
132 private->iob.flags = 2; /* do asynchronous io */
133 private->iob.block_count = dreq->block_count;
134 private->iob.interrupt_params = (u32)(addr_t) cqr;
135 private->iob.bio_list = __pa(dreq->bio);
137 cqr->startclk = get_clock();
139 rc = dia250(&private->iob, RW_BIO);
141 MESSAGE(KERN_WARNING, "dia250 returned CC %d", rc);
142 cqr->status = DASD_CQR_ERROR;
143 } else if (rc == 0) {
144 cqr->status = DASD_CQR_DONE;
145 dasd_schedule_bh(device);
147 cqr->status = DASD_CQR_IN_IO;
154 dasd_ext_handler(struct pt_regs *regs, __u16 code)
156 struct dasd_ccw_req *cqr, *next;
157 struct dasd_device *device;
158 unsigned long long expires;
164 * Get the external interruption subcode. VM stores
165 * this in the 'cpu address' field associated with
166 * the external interrupt. For diag 250 the subcode
169 if ((S390_lowcore.cpu_addr & 0xff00) != 0x0300)
171 status = *((char *) &S390_lowcore.ext_params + 5);
172 ip = S390_lowcore.ext_params;
174 if (!ip) { /* no intparm: unsolicited interrupt */
175 MESSAGE(KERN_DEBUG, "%s", "caught unsolicited interrupt");
178 cqr = (struct dasd_ccw_req *)(addr_t) ip;
179 device = (struct dasd_device *) cqr->device;
180 if (strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
181 DEV_MESSAGE(KERN_WARNING, device,
182 " magic number of dasd_ccw_req 0x%08X doesn't"
183 " match discipline 0x%08X",
184 cqr->magic, *(int *) (&device->discipline->name));
188 /* get irq lock to modify request queue */
189 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
191 cqr->stopclk = get_clock();
195 cqr->status = DASD_CQR_DONE;
196 /* Start first request on queue if possible -> fast_io. */
197 if (!list_empty(&device->ccw_queue)) {
198 next = list_entry(device->ccw_queue.next,
199 struct dasd_ccw_req, list);
200 if (next->status == DASD_CQR_QUEUED) {
201 if (dasd_start_diag(next) == 0)
202 expires = next->expires;
204 MESSAGE(KERN_WARNING, "%s",
205 "Interrupt fastpath failed!");
209 cqr->status = DASD_CQR_FAILED;
212 dasd_set_timer(device, expires);
214 dasd_clear_timer(device);
215 dasd_schedule_bh(device);
217 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
221 dasd_diag_check_device(struct dasd_device *device)
223 struct dasd_diag_private *private;
224 struct dasd_diag_characteristics *rdc_data;
225 struct dasd_diag_bio bio;
230 private = (struct dasd_diag_private *) device->private;
231 if (private == NULL) {
232 private = kmalloc(sizeof(struct dasd_diag_private),GFP_KERNEL);
233 if (private == NULL) {
234 MESSAGE(KERN_WARNING, "%s",
235 "memory allocation failed for private data");
238 device->private = (void *) private;
240 /* Read Device Characteristics */
241 rdc_data = (void *) &(private->rdc_data);
242 rdc_data->dev_nr = _ccw_device_get_device_number(device->cdev);
243 rdc_data->rdc_len = sizeof (struct dasd_diag_characteristics);
245 rc = diag210((struct diag210 *) rdc_data);
249 /* Figure out position of label block */
250 switch (private->rdc_data.vdev_class) {
252 private->pt_block = 1;
255 private->pt_block = 2;
262 "%04X: %04X on real %04X/%02X",
265 rdc_data->rdev_type, rdc_data->rdev_model);
267 /* terminate all outstanding operations */
268 mdsk_term_io(device);
270 /* figure out blocksize of device */
271 label = (long *) get_zeroed_page(GFP_KERNEL);
273 MESSAGE(KERN_WARNING, "%s",
274 "No memory to allocate initialization request");
277 for (bsize = 512; bsize <= PAGE_SIZE; bsize <<= 1) {
278 mdsk_init_io(device, bsize, 0, 64);
279 memset(&bio, 0, sizeof (struct dasd_diag_bio));
280 bio.type = MDSK_READ_REQ;
281 bio.block_number = private->pt_block + 1;
282 bio.buffer = __pa(label);
283 memset(&private->iob, 0, sizeof (struct dasd_diag_rw_io));
284 private->iob.dev_nr = rdc_data->dev_nr;
285 private->iob.key = 0;
286 private->iob.flags = 0; /* do synchronous io */
287 private->iob.block_count = 1;
288 private->iob.interrupt_params = 0;
289 private->iob.bio_list = __pa(&bio);
290 if (dia250(&private->iob, RW_BIO) == 0)
292 mdsk_term_io(device);
294 if (bsize <= PAGE_SIZE && label[3] == bsize &&
295 label[0] == 0xc3d4e2f1) {
296 device->blocks = label[7];
297 device->bp_block = bsize;
298 device->s2b_shift = 0; /* bits to shift 512 to get a block */
299 for (sb = 512; sb < bsize; sb = sb << 1)
302 DEV_MESSAGE(KERN_INFO, device,
303 "capacity (%dkB blks): %ldkB",
304 (device->bp_block >> 10),
305 (device->blocks << device->s2b_shift) >> 1);
308 DEV_MESSAGE(KERN_WARNING, device, "%s",
309 "volume has incompatible disk layout");
312 free_page((long) label);
317 dasd_diag_fill_geometry(struct dasd_device *device, struct hd_geometry *geo)
319 if (dasd_check_blocksize(device->bp_block) != 0)
321 geo->cylinders = (device->blocks << device->s2b_shift) >> 10;
323 geo->sectors = 128 >> device->s2b_shift;
328 dasd_diag_examine_error(struct dasd_ccw_req * cqr, struct irb * stat)
330 return dasd_era_fatal;
334 dasd_diag_erp_action(struct dasd_ccw_req * cqr)
336 return dasd_default_erp_action;
340 dasd_diag_erp_postaction(struct dasd_ccw_req * cqr)
342 return dasd_default_erp_postaction;
345 static struct dasd_ccw_req *
346 dasd_diag_build_cp(struct dasd_device * device, struct request *req)
348 struct dasd_ccw_req *cqr;
349 struct dasd_diag_req *dreq;
350 struct dasd_diag_bio *dbio;
355 sector_t recid, first_rec, last_rec;
356 unsigned blksize, off;
357 unsigned char rw_cmd;
360 if (rq_data_dir(req) == READ)
361 rw_cmd = MDSK_READ_REQ;
362 else if (rq_data_dir(req) == WRITE)
363 rw_cmd = MDSK_WRITE_REQ;
365 return ERR_PTR(-EINVAL);
366 blksize = device->bp_block;
367 /* Calculate record id of first and last block. */
368 first_rec = req->sector >> device->s2b_shift;
369 last_rec = (req->sector + req->nr_sectors - 1) >> device->s2b_shift;
370 /* Check struct bio and count the number of blocks for the request. */
372 rq_for_each_bio(bio, req) {
373 bio_for_each_segment(bv, bio, i) {
374 if (bv->bv_len & (blksize - 1))
375 /* Fba can only do full blocks. */
376 return ERR_PTR(-EINVAL);
377 count += bv->bv_len >> (device->s2b_shift + 9);
381 if (count != last_rec - first_rec + 1)
382 return ERR_PTR(-EINVAL);
383 /* Build the request */
384 datasize = sizeof(struct dasd_diag_req) +
385 count*sizeof(struct dasd_diag_bio);
386 cqr = dasd_smalloc_request(dasd_diag_discipline.name, 0,
391 dreq = (struct dasd_diag_req *) cqr->data;
392 dreq->block_count = count;
395 rq_for_each_bio(bio, req) {
396 bio_for_each_segment(bv, bio, i) {
397 dst = page_address(bv->bv_page) + bv->bv_offset;
398 for (off = 0; off < bv->bv_len; off += blksize) {
399 memset(dbio, 0, sizeof (struct dasd_diag_bio));
401 dbio->block_number = recid + 1;
402 dbio->buffer = __pa(dst);
409 cqr->buildclk = get_clock();
410 cqr->device = device;
411 cqr->expires = 50 * HZ; /* 50 seconds */
412 cqr->status = DASD_CQR_FILLED;
417 dasd_diag_free_cp(struct dasd_ccw_req *cqr, struct request *req)
421 status = cqr->status == DASD_CQR_DONE;
422 dasd_sfree_request(cqr, cqr->device);
427 dasd_diag_fill_info(struct dasd_device * device,
428 struct dasd_information2_t * info)
430 struct dasd_diag_private *private;
432 private = (struct dasd_diag_private *) device->private;
433 info->label_block = private->pt_block;
434 info->FBA_layout = 1;
435 info->format = DASD_FORMAT_LDL;
436 info->characteristics_size = sizeof (struct dasd_diag_characteristics);
437 memcpy(info->characteristics,
438 &((struct dasd_diag_private *) device->private)->rdc_data,
439 sizeof (struct dasd_diag_characteristics));
440 info->confdata_size = 0;
445 dasd_diag_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req,
450 page = (char *) get_zeroed_page(GFP_KERNEL);
452 MESSAGE(KERN_ERR, "%s", "No memory to dump sense data");
455 sprintf(page, KERN_WARNING PRINTK_HEADER
456 "device %s: I/O status report:\n",
457 device->cdev->dev.bus_id);
459 MESSAGE(KERN_ERR, "Sense data:\n%s", page);
461 free_page((unsigned long) page);
465 * max_blocks is dependent on the amount of storage that is available
466 * in the static io buffer for each device. Currently each device has
467 * 8192 bytes (=2 pages). dasd diag is only relevant for 31 bit.
468 * The struct dasd_ccw_req has 96 bytes, the struct dasd_diag_req has
469 * 8 bytes and the struct dasd_diag_bio for each block has 16 bytes.
471 * (8192 - 96 - 8) / 16 = 505.5 blocks at maximum.
472 * We want to fit two into the available memory so that we can immediately
473 * start the next request if one finishes off. That makes 252.75 blocks
474 * for one request. Give a little safety and the result is 240.
476 struct dasd_discipline dasd_diag_discipline = {
477 .owner = THIS_MODULE,
481 .check_device = dasd_diag_check_device,
482 .fill_geometry = dasd_diag_fill_geometry,
483 .start_IO = dasd_start_diag,
484 .examine_error = dasd_diag_examine_error,
485 .erp_action = dasd_diag_erp_action,
486 .erp_postaction = dasd_diag_erp_postaction,
487 .build_cp = dasd_diag_build_cp,
488 .free_cp = dasd_diag_free_cp,
489 .dump_sense = dasd_diag_dump_sense,
490 .fill_info = dasd_diag_fill_info,
496 if (!MACHINE_IS_VM) {
498 "Machine is not VM: %s discipline not initializing",
499 dasd_diag_discipline.name);
502 ASCEBC(dasd_diag_discipline.ebcname, 4);
505 register_external_interrupt(0x2603, dasd_ext_handler);
506 dasd_diag_discipline_pointer = &dasd_diag_discipline;
511 dasd_diag_cleanup(void)
513 if (!MACHINE_IS_VM) {
515 "Machine is not VM: %s discipline not initializing",
516 dasd_diag_discipline.name);
519 unregister_external_interrupt(0x2603, dasd_ext_handler);
521 dasd_diag_discipline_pointer = NULL;
524 module_init(dasd_diag_init);
525 module_exit(dasd_diag_cleanup);
528 * Overrides for Emacs so that we follow Linus's tabbing style.
529 * Emacs will notice this stuff at the end of the file and automatically
530 * adjust the settings for this buffer only. This must remain at the end
532 * ---------------------------------------------------------------------------
535 * c-brace-imaginary-offset: 0
537 * c-argdecl-indent: 4
539 * c-continued-statement-offset: 4
540 * c-continued-brace-offset: 0
541 * indent-tabs-mode: 1