1
2
3
4
5
6
7
8
9
10
11#define KMSG_COMPONENT "dasd-diag"
12
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>
21
22#include <asm/dasd.h>
23#include <asm/debug.h>
24#include <asm/ebcdic.h>
25#include <asm/io.h>
26#include <asm/s390_ext.h>
27#include <asm/todclk.h>
28#include <asm/vtoc.h>
29#include <asm/diag.h>
30
31#include "dasd_int.h"
32#include "dasd_diag.h"
33
34#define PRINTK_HEADER "dasd(diag):"
35
36MODULE_LICENSE("GPL");
37
38
39
40
41
42
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 * HZ
48
49static struct dasd_discipline dasd_diag_discipline;
50
51struct dasd_diag_private {
52 struct dasd_diag_characteristics rdc_data;
53 struct dasd_diag_rw_io iob;
54 struct dasd_diag_init_io iib;
55 blocknum_t pt_block;
56 struct ccw_dev_id dev_id;
57};
58
59struct dasd_diag_req {
60 unsigned int block_count;
61 struct dasd_diag_bio bio[0];
62};
63
64static const u8 DASD_DIAG_CMS1[] = { 0xc3, 0xd4, 0xe2, 0xf1 };
65
66
67
68
69
70static inline int dia250(void *iob, int cmd)
71{
72 register unsigned long reg2 asm ("2") = (unsigned long) iob;
73 typedef union {
74 struct dasd_diag_init_io init_io;
75 struct dasd_diag_rw_io rw_io;
76 } addr_type;
77 int rc;
78
79 rc = 3;
80 asm volatile(
81 " diag 2,%2,0x250\n"
82 "0: ipm %0\n"
83 " srl %0,28\n"
84 " or %0,3\n"
85 "1:\n"
86 EX_TABLE(0b,1b)
87 : "+d" (rc), "=m" (*(addr_type *) iob)
88 : "d" (cmd), "d" (reg2), "m" (*(addr_type *) iob)
89 : "3", "cc");
90 return rc;
91}
92
93
94
95
96
97static inline int
98mdsk_init_io(struct dasd_device *device, unsigned int blocksize,
99 blocknum_t offset, blocknum_t *end_block)
100{
101 struct dasd_diag_private *private;
102 struct dasd_diag_init_io *iib;
103 int rc;
104
105 private = (struct dasd_diag_private *) device->private;
106 iib = &private->iib;
107 memset(iib, 0, sizeof (struct dasd_diag_init_io));
108
109 iib->dev_nr = private->dev_id.devno;
110 iib->block_size = blocksize;
111 iib->offset = offset;
112 iib->flaga = DASD_DIAG_FLAGA_DEFAULT;
113
114 rc = dia250(iib, INIT_BIO);
115
116 if ((rc & 3) == 0 && end_block)
117 *end_block = iib->end_block;
118
119 return rc;
120}
121
122
123
124static inline int
125mdsk_term_io(struct dasd_device * device)
126{
127 struct dasd_diag_private *private;
128 struct dasd_diag_init_io *iib;
129 int rc;
130
131 private = (struct dasd_diag_private *) device->private;
132 iib = &private->iib;
133 memset(iib, 0, sizeof (struct dasd_diag_init_io));
134 iib->dev_nr = private->dev_id.devno;
135 rc = dia250(iib, TERM_BIO);
136 return rc;
137}
138
139
140
141static void
142dasd_diag_erp(struct dasd_device *device)
143{
144 int rc;
145
146 mdsk_term_io(device);
147 rc = mdsk_init_io(device, device->block->bp_block, 0, NULL);
148 if (rc)
149 dev_warn(&device->cdev->dev, "DIAG ERP failed with "
150 "rc=%d\n", rc);
151}
152
153
154
155static int
156dasd_start_diag(struct dasd_ccw_req * cqr)
157{
158 struct dasd_device *device;
159 struct dasd_diag_private *private;
160 struct dasd_diag_req *dreq;
161 int rc;
162
163 device = cqr->startdev;
164 if (cqr->retries < 0) {
165 DBF_DEV_EVENT(DBF_ERR, device, "DIAG start_IO: request %p "
166 "- no retry left)", cqr);
167 cqr->status = DASD_CQR_ERROR;
168 return -EIO;
169 }
170 private = (struct dasd_diag_private *) device->private;
171 dreq = (struct dasd_diag_req *) cqr->data;
172
173 private->iob.dev_nr = private->dev_id.devno;
174 private->iob.key = 0;
175 private->iob.flags = DASD_DIAG_RWFLAG_ASYNC;
176 private->iob.block_count = dreq->block_count;
177 private->iob.interrupt_params = (addr_t) cqr;
178 private->iob.bio_list = dreq->bio;
179 private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;
180
181 cqr->startclk = get_clock();
182 cqr->starttime = jiffies;
183 cqr->retries--;
184
185 rc = dia250(&private->iob, RW_BIO);
186 switch (rc) {
187 case 0:
188 cqr->stopclk = get_clock();
189 cqr->status = DASD_CQR_SUCCESS;
190
191
192 rc = -EACCES;
193 break;
194 case 8:
195 cqr->status = DASD_CQR_IN_IO;
196 rc = 0;
197 break;
198 default:
199 cqr->status = DASD_CQR_QUEUED;
200 DBF_DEV_EVENT(DBF_WARNING, device, "dia250 returned rc=%d", rc);
201 dasd_diag_erp(device);
202 rc = -EIO;
203 break;
204 }
205 cqr->intrc = rc;
206 return rc;
207}
208
209
210static int
211dasd_diag_term_IO(struct dasd_ccw_req * cqr)
212{
213 struct dasd_device *device;
214
215 device = cqr->startdev;
216 mdsk_term_io(device);
217 mdsk_init_io(device, device->block->bp_block, 0, NULL);
218 cqr->status = DASD_CQR_CLEAR_PENDING;
219 cqr->stopclk = get_clock();
220 dasd_schedule_device_bh(device);
221 return 0;
222}
223
224
225static void
226dasd_ext_handler(__u16 code)
227{
228 struct dasd_ccw_req *cqr, *next;
229 struct dasd_device *device;
230 unsigned long long expires;
231 unsigned long flags;
232 u8 int_code, status;
233 addr_t ip;
234 int rc;
235
236 int_code = *((u8 *) DASD_DIAG_LC_INT_CODE);
237 status = *((u8 *) DASD_DIAG_LC_INT_STATUS);
238 switch (int_code) {
239 case DASD_DIAG_CODE_31BIT:
240 ip = (addr_t) *((u32 *) DASD_DIAG_LC_INT_PARM_31BIT);
241 break;
242 case DASD_DIAG_CODE_64BIT:
243 ip = (addr_t) *((u64 *) DASD_DIAG_LC_INT_PARM_64BIT);
244 break;
245 default:
246 return;
247 }
248 if (!ip) {
249 DBF_EVENT(DBF_NOTICE, "%s", "caught unsolicited "
250 "interrupt");
251 return;
252 }
253 cqr = (struct dasd_ccw_req *) ip;
254 device = (struct dasd_device *) cqr->startdev;
255 if (strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
256 DBF_DEV_EVENT(DBF_WARNING, device,
257 " magic number of dasd_ccw_req 0x%08X doesn't"
258 " match discipline 0x%08X",
259 cqr->magic, *(int *) (&device->discipline->name));
260 return;
261 }
262
263
264 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
265
266
267 if (cqr->status == DASD_CQR_CLEAR_PENDING) {
268 cqr->status = DASD_CQR_CLEARED;
269 dasd_device_clear_timer(device);
270 dasd_schedule_device_bh(device);
271 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
272 return;
273 }
274
275 cqr->stopclk = get_clock();
276
277 expires = 0;
278 if (status == 0) {
279 cqr->status = DASD_CQR_SUCCESS;
280
281 if (!list_empty(&device->ccw_queue)) {
282 next = list_entry(device->ccw_queue.next,
283 struct dasd_ccw_req, devlist);
284 if (next->status == DASD_CQR_QUEUED) {
285 rc = dasd_start_diag(next);
286 if (rc == 0)
287 expires = next->expires;
288 }
289 }
290 } else {
291 cqr->status = DASD_CQR_QUEUED;
292 DBF_DEV_EVENT(DBF_DEBUG, device, "interrupt status for "
293 "request %p was %d (%d retries left)", cqr, status,
294 cqr->retries);
295 dasd_diag_erp(device);
296 }
297
298 if (expires != 0)
299 dasd_device_set_timer(device, expires);
300 else
301 dasd_device_clear_timer(device);
302 dasd_schedule_device_bh(device);
303
304 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
305}
306
307
308
309static int
310dasd_diag_check_device(struct dasd_device *device)
311{
312 struct dasd_block *block;
313 struct dasd_diag_private *private;
314 struct dasd_diag_characteristics *rdc_data;
315 struct dasd_diag_bio bio;
316 struct vtoc_cms_label *label;
317 blocknum_t end_block;
318 unsigned int sb, bsize;
319 int rc;
320
321 private = (struct dasd_diag_private *) device->private;
322 if (private == NULL) {
323 private = kzalloc(sizeof(struct dasd_diag_private),GFP_KERNEL);
324 if (private == NULL) {
325 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
326 "Allocating memory for private DASD data "
327 "failed\n");
328 return -ENOMEM;
329 }
330 ccw_device_get_id(device->cdev, &private->dev_id);
331 device->private = (void *) private;
332 }
333 block = dasd_alloc_block();
334 if (IS_ERR(block)) {
335 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
336 "could not allocate dasd block structure");
337 device->private = NULL;
338 kfree(private);
339 return PTR_ERR(block);
340 }
341 device->block = block;
342 block->base = device;
343
344
345 rdc_data = (void *) &(private->rdc_data);
346 rdc_data->dev_nr = private->dev_id.devno;
347 rdc_data->rdc_len = sizeof (struct dasd_diag_characteristics);
348
349 rc = diag210((struct diag210 *) rdc_data);
350 if (rc) {
351 DBF_DEV_EVENT(DBF_WARNING, device, "failed to retrieve device "
352 "information (rc=%d)", rc);
353 rc = -EOPNOTSUPP;
354 goto out;
355 }
356
357
358 switch (private->rdc_data.vdev_class) {
359 case DEV_CLASS_FBA:
360 private->pt_block = 1;
361 break;
362 case DEV_CLASS_ECKD:
363 private->pt_block = 2;
364 break;
365 default:
366 dev_warn(&device->cdev->dev, "Device type %d is not supported "
367 "in DIAG mode\n", private->rdc_data.vdev_class);
368 rc = -EOPNOTSUPP;
369 goto out;
370 }
371
372 DBF_DEV_EVENT(DBF_INFO, device,
373 "%04X: %04X on real %04X/%02X",
374 rdc_data->dev_nr,
375 rdc_data->vdev_type,
376 rdc_data->rdev_type, rdc_data->rdev_model);
377
378
379 mdsk_term_io(device);
380
381
382 label = (struct vtoc_cms_label *) get_zeroed_page(GFP_KERNEL);
383 if (label == NULL) {
384 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
385 "No memory to allocate initialization request");
386 rc = -ENOMEM;
387 goto out;
388 }
389 rc = 0;
390 end_block = 0;
391
392 for (bsize = 512; bsize <= PAGE_SIZE; bsize <<= 1) {
393 mdsk_init_io(device, bsize, 0, &end_block);
394 memset(&bio, 0, sizeof (struct dasd_diag_bio));
395 bio.type = MDSK_READ_REQ;
396 bio.block_number = private->pt_block + 1;
397 bio.buffer = label;
398 memset(&private->iob, 0, sizeof (struct dasd_diag_rw_io));
399 private->iob.dev_nr = rdc_data->dev_nr;
400 private->iob.key = 0;
401 private->iob.flags = 0;
402 private->iob.block_count = 1;
403 private->iob.interrupt_params = 0;
404 private->iob.bio_list = &bio;
405 private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;
406 rc = dia250(&private->iob, RW_BIO);
407 if (rc == 3) {
408 dev_warn(&device->cdev->dev,
409 "A 64-bit DIAG call failed\n");
410 rc = -EOPNOTSUPP;
411 goto out_label;
412 }
413 mdsk_term_io(device);
414 if (rc == 0)
415 break;
416 }
417 if (bsize > PAGE_SIZE) {
418 dev_warn(&device->cdev->dev, "Accessing the DASD failed because"
419 " of an incorrect format (rc=%d)\n", rc);
420 rc = -EIO;
421 goto out_label;
422 }
423
424 if (memcmp(label->label_id, DASD_DIAG_CMS1,
425 sizeof(DASD_DIAG_CMS1)) == 0) {
426
427 bsize = (unsigned int) label->block_size;
428 block->blocks = (unsigned long) label->block_count;
429 } else
430 block->blocks = end_block;
431 block->bp_block = bsize;
432 block->s2b_shift = 0;
433 for (sb = 512; sb < bsize; sb = sb << 1)
434 block->s2b_shift++;
435 rc = mdsk_init_io(device, block->bp_block, 0, NULL);
436 if (rc) {
437 dev_warn(&device->cdev->dev, "DIAG initialization "
438 "failed with rc=%d\n", rc);
439 rc = -EIO;
440 } else {
441 dev_info(&device->cdev->dev,
442 "New DASD with %ld byte/block, total size %ld KB\n",
443 (unsigned long) block->bp_block,
444 (unsigned long) (block->blocks <<
445 block->s2b_shift) >> 1);
446 }
447out_label:
448 free_page((long) label);
449out:
450 if (rc) {
451 device->block = NULL;
452 dasd_free_block(block);
453 device->private = NULL;
454 kfree(private);
455 }
456 return rc;
457}
458
459
460
461static int
462dasd_diag_fill_geometry(struct dasd_block *block, struct hd_geometry *geo)
463{
464 if (dasd_check_blocksize(block->bp_block) != 0)
465 return -EINVAL;
466 geo->cylinders = (block->blocks << block->s2b_shift) >> 10;
467 geo->heads = 16;
468 geo->sectors = 128 >> block->s2b_shift;
469 return 0;
470}
471
472static dasd_erp_fn_t
473dasd_diag_erp_action(struct dasd_ccw_req * cqr)
474{
475 return dasd_default_erp_action;
476}
477
478static dasd_erp_fn_t
479dasd_diag_erp_postaction(struct dasd_ccw_req * cqr)
480{
481 return dasd_default_erp_postaction;
482}
483
484
485
486static struct dasd_ccw_req *dasd_diag_build_cp(struct dasd_device *memdev,
487 struct dasd_block *block,
488 struct request *req)
489{
490 struct dasd_ccw_req *cqr;
491 struct dasd_diag_req *dreq;
492 struct dasd_diag_bio *dbio;
493 struct req_iterator iter;
494 struct bio_vec *bv;
495 char *dst;
496 unsigned int count, datasize;
497 sector_t recid, first_rec, last_rec;
498 unsigned int blksize, off;
499 unsigned char rw_cmd;
500
501 if (rq_data_dir(req) == READ)
502 rw_cmd = MDSK_READ_REQ;
503 else if (rq_data_dir(req) == WRITE)
504 rw_cmd = MDSK_WRITE_REQ;
505 else
506 return ERR_PTR(-EINVAL);
507 blksize = block->bp_block;
508
509 first_rec = blk_rq_pos(req) >> block->s2b_shift;
510 last_rec =
511 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
512
513 count = 0;
514 rq_for_each_segment(bv, req, iter) {
515 if (bv->bv_len & (blksize - 1))
516
517 return ERR_PTR(-EINVAL);
518 count += bv->bv_len >> (block->s2b_shift + 9);
519 }
520
521 if (count != last_rec - first_rec + 1)
522 return ERR_PTR(-EINVAL);
523
524 datasize = sizeof(struct dasd_diag_req) +
525 count*sizeof(struct dasd_diag_bio);
526 cqr = dasd_smalloc_request(DASD_DIAG_MAGIC, 0, datasize, memdev);
527 if (IS_ERR(cqr))
528 return cqr;
529
530 dreq = (struct dasd_diag_req *) cqr->data;
531 dreq->block_count = count;
532 dbio = dreq->bio;
533 recid = first_rec;
534 rq_for_each_segment(bv, req, iter) {
535 dst = page_address(bv->bv_page) + bv->bv_offset;
536 for (off = 0; off < bv->bv_len; off += blksize) {
537 memset(dbio, 0, sizeof (struct dasd_diag_bio));
538 dbio->type = rw_cmd;
539 dbio->block_number = recid + 1;
540 dbio->buffer = dst;
541 dbio++;
542 dst += blksize;
543 recid++;
544 }
545 }
546 cqr->retries = DIAG_MAX_RETRIES;
547 cqr->buildclk = get_clock();
548 if (blk_noretry_request(req) ||
549 block->base->features & DASD_FEATURE_FAILFAST)
550 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
551 cqr->startdev = memdev;
552 cqr->memdev = memdev;
553 cqr->block = block;
554 cqr->expires = DIAG_TIMEOUT;
555 cqr->status = DASD_CQR_FILLED;
556 return cqr;
557}
558
559
560
561static int
562dasd_diag_free_cp(struct dasd_ccw_req *cqr, struct request *req)
563{
564 int status;
565
566 status = cqr->status == DASD_CQR_DONE;
567 dasd_sfree_request(cqr, cqr->memdev);
568 return status;
569}
570
571static void dasd_diag_handle_terminated_request(struct dasd_ccw_req *cqr)
572{
573 cqr->status = DASD_CQR_FILLED;
574};
575
576
577static int
578dasd_diag_fill_info(struct dasd_device * device,
579 struct dasd_information2_t * info)
580{
581 struct dasd_diag_private *private;
582
583 private = (struct dasd_diag_private *) device->private;
584 info->label_block = (unsigned int) private->pt_block;
585 info->FBA_layout = 1;
586 info->format = DASD_FORMAT_LDL;
587 info->characteristics_size = sizeof (struct dasd_diag_characteristics);
588 memcpy(info->characteristics,
589 &((struct dasd_diag_private *) device->private)->rdc_data,
590 sizeof (struct dasd_diag_characteristics));
591 info->confdata_size = 0;
592 return 0;
593}
594
595static void
596dasd_diag_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req,
597 struct irb *stat)
598{
599 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
600 "dump sense not available for DIAG data");
601}
602
603static struct dasd_discipline dasd_diag_discipline = {
604 .owner = THIS_MODULE,
605 .name = "DIAG",
606 .ebcname = "DIAG",
607 .max_blocks = DIAG_MAX_BLOCKS,
608 .check_device = dasd_diag_check_device,
609 .fill_geometry = dasd_diag_fill_geometry,
610 .start_IO = dasd_start_diag,
611 .term_IO = dasd_diag_term_IO,
612 .handle_terminated_request = dasd_diag_handle_terminated_request,
613 .erp_action = dasd_diag_erp_action,
614 .erp_postaction = dasd_diag_erp_postaction,
615 .build_cp = dasd_diag_build_cp,
616 .free_cp = dasd_diag_free_cp,
617 .dump_sense = dasd_diag_dump_sense,
618 .fill_info = dasd_diag_fill_info,
619};
620
621static int __init
622dasd_diag_init(void)
623{
624 if (!MACHINE_IS_VM) {
625 pr_info("Discipline %s cannot be used without z/VM\n",
626 dasd_diag_discipline.name);
627 return -ENODEV;
628 }
629 ASCEBC(dasd_diag_discipline.ebcname, 4);
630
631 ctl_set_bit(0, 9);
632 register_external_interrupt(0x2603, dasd_ext_handler);
633 dasd_diag_discipline_pointer = &dasd_diag_discipline;
634 return 0;
635}
636
637static void __exit
638dasd_diag_cleanup(void)
639{
640 unregister_external_interrupt(0x2603, dasd_ext_handler);
641 ctl_clear_bit(0, 9);
642 dasd_diag_discipline_pointer = NULL;
643}
644
645module_init(dasd_diag_init);
646module_exit(dasd_diag_cleanup);
647