blob: c062f1620c58d419514af3ce7b81da8952e11546 [file] [log] [blame]
Horst Hummel138c0142006-06-29 14:58:12 +02001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * 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>
Heiko Carstensa53c8fa2012-07-20 11:15:04 +02006 * Copyright IBM Corp. 1999, 2000
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 */
9
Stefan Haberlandea058542009-12-18 17:43:16 +010010#define KMSG_COMPONENT "dasd"
Stefan Haberlandfc19f382009-03-26 15:23:49 +010011
Heiko Carstens052ff462011-01-05 12:47:28 +010012#include <linux/kernel_stat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/stddef.h>
14#include <linux/kernel.h>
15#include <linux/slab.h>
Horst Hummelfd49f412005-09-03 15:58:00 -070016#include <linux/hdreg.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/bio.h>
18#include <linux/module.h>
19#include <linux/init.h>
Horst Hummelfd49f412005-09-03 15:58:00 -070020#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22#include <asm/dasd.h>
23#include <asm/debug.h>
24#include <asm/ebcdic.h>
25#include <asm/io.h>
Heiko Carstensd7b250e2011-05-26 09:48:24 +020026#include <asm/irq.h>
Peter Oberparleiter56dc6a82006-01-06 00:19:09 -080027#include <asm/vtoc.h>
Michael Holzheu0a87c5c2007-08-22 13:51:40 +020028#include <asm/diag.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
30#include "dasd_int.h"
31#include "dasd_diag.h"
32
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#define PRINTK_HEADER "dasd(diag):"
34
35MODULE_LICENSE("GPL");
36
Horst Hummelfd49f412005-09-03 15:58:00 -070037/* 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
41 * finishes. */
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
Stefan Haberland7c8faa82010-08-09 18:13:00 +020046#define DIAG_TIMEOUT 50
Horst Hummelfd49f412005-09-03 15:58:00 -070047
Heiko Carstens2b67fc42007-02-05 21:16:47 +010048static struct dasd_discipline dasd_diag_discipline;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50struct dasd_diag_private {
51 struct dasd_diag_characteristics rdc_data;
52 struct dasd_diag_rw_io iob;
53 struct dasd_diag_init_io iib;
Horst Hummelfd49f412005-09-03 15:58:00 -070054 blocknum_t pt_block;
Cornelia Huck9a92fe42007-05-10 15:45:42 +020055 struct ccw_dev_id dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -070056};
57
58struct dasd_diag_req {
Horst Hummelfd49f412005-09-03 15:58:00 -070059 unsigned int block_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 struct dasd_diag_bio bio[0];
61};
62
Horst Hummelfd49f412005-09-03 15:58:00 -070063static const u8 DASD_DIAG_CMS1[] = { 0xc3, 0xd4, 0xe2, 0xf1 };/* EBCDIC CMS1 */
64
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. */
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +020069static inline int dia250(void *iob, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
Peter Oberparleiter04439692007-03-26 20:42:38 +020071 register unsigned long reg2 asm ("2") = (unsigned long) iob;
Peter Oberparleiter86b368a2005-11-07 00:59:08 -080072 typedef union {
73 struct dasd_diag_init_io init_io;
74 struct dasd_diag_rw_io rw_io;
Horst Hummelfd49f412005-09-03 15:58:00 -070075 } addr_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 int rc;
77
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +020078 rc = 3;
79 asm volatile(
Peter Oberparleiter04439692007-03-26 20:42:38 +020080 " diag 2,%2,0x250\n"
Horst Hummelfd49f412005-09-03 15:58:00 -070081 "0: ipm %0\n"
82 " srl %0,28\n"
Peter Oberparleiter04439692007-03-26 20:42:38 +020083 " or %0,3\n"
Horst Hummelfd49f412005-09-03 15:58:00 -070084 "1:\n"
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +020085 EX_TABLE(0b,1b)
86 : "+d" (rc), "=m" (*(addr_type *) iob)
Peter Oberparleiter04439692007-03-26 20:42:38 +020087 : "d" (cmd), "d" (reg2), "m" (*(addr_type *) iob)
88 : "3", "cc");
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 return rc;
90}
91
Horst Hummelfd49f412005-09-03 15:58:00 -070092/* 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
95 * otherwise. */
Heiko Carstens4d284ca2007-02-05 21:18:53 +010096static inline int
Horst Hummelfd49f412005-09-03 15:58:00 -070097mdsk_init_io(struct dasd_device *device, unsigned int blocksize,
98 blocknum_t offset, blocknum_t *end_block)
Linus Torvalds1da177e2005-04-16 15:20:36 -070099{
100 struct dasd_diag_private *private;
101 struct dasd_diag_init_io *iib;
102 int rc;
103
104 private = (struct dasd_diag_private *) device->private;
105 iib = &private->iib;
106 memset(iib, 0, sizeof (struct dasd_diag_init_io));
107
Cornelia Huck9a92fe42007-05-10 15:45:42 +0200108 iib->dev_nr = private->dev_id.devno;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 iib->block_size = blocksize;
110 iib->offset = offset;
Horst Hummelfd49f412005-09-03 15:58:00 -0700111 iib->flaga = DASD_DIAG_FLAGA_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112
113 rc = dia250(iib, INIT_BIO);
114
Horst Hummelfd49f412005-09-03 15:58:00 -0700115 if ((rc & 3) == 0 && end_block)
116 *end_block = iib->end_block;
117
118 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119}
120
Horst Hummelfd49f412005-09-03 15:58:00 -0700121/* Remove block I/O environment for device. Return zero on success, non-zero
122 * otherwise. */
Heiko Carstens4d284ca2007-02-05 21:18:53 +0100123static inline int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124mdsk_term_io(struct dasd_device * device)
125{
126 struct dasd_diag_private *private;
127 struct dasd_diag_init_io *iib;
128 int rc;
129
130 private = (struct dasd_diag_private *) device->private;
131 iib = &private->iib;
132 memset(iib, 0, sizeof (struct dasd_diag_init_io));
Cornelia Huck9a92fe42007-05-10 15:45:42 +0200133 iib->dev_nr = private->dev_id.devno;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 rc = dia250(iib, TERM_BIO);
Horst Hummelfd49f412005-09-03 15:58:00 -0700135 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
137
Horst Hummelfd49f412005-09-03 15:58:00 -0700138/* Error recovery for failed DIAG requests - try to reestablish the DIAG
139 * environment. */
140static void
141dasd_diag_erp(struct dasd_device *device)
142{
143 int rc;
144
145 mdsk_term_io(device);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100146 rc = mdsk_init_io(device, device->block->bp_block, 0, NULL);
Stefan Weinhuber22825ab2009-12-07 12:51:48 +0100147 if (rc == 4) {
Stefan Weinhuber33b62a32010-03-08 12:26:24 +0100148 if (!(test_and_set_bit(DASD_FLAG_DEVICE_RO, &device->flags)))
Stefan Haberlandea058542009-12-18 17:43:16 +0100149 pr_warning("%s: The access mode of a DIAG device "
150 "changed to read-only\n",
151 dev_name(&device->cdev->dev));
Stefan Weinhuber22825ab2009-12-07 12:51:48 +0100152 rc = 0;
153 }
Horst Hummelfd49f412005-09-03 15:58:00 -0700154 if (rc)
Stefan Haberlandea058542009-12-18 17:43:16 +0100155 pr_warning("%s: DIAG ERP failed with "
156 "rc=%d\n", dev_name(&device->cdev->dev), rc);
Horst Hummelfd49f412005-09-03 15:58:00 -0700157}
158
159/* Start a given request at the device. Return zero on success, non-zero
160 * otherwise. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161static int
162dasd_start_diag(struct dasd_ccw_req * cqr)
163{
164 struct dasd_device *device;
165 struct dasd_diag_private *private;
166 struct dasd_diag_req *dreq;
167 int rc;
168
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100169 device = cqr->startdev;
Horst Hummelfd49f412005-09-03 15:58:00 -0700170 if (cqr->retries < 0) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100171 DBF_DEV_EVENT(DBF_ERR, device, "DIAG start_IO: request %p "
Horst Hummelfd49f412005-09-03 15:58:00 -0700172 "- no retry left)", cqr);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100173 cqr->status = DASD_CQR_ERROR;
Horst Hummelfd49f412005-09-03 15:58:00 -0700174 return -EIO;
175 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 private = (struct dasd_diag_private *) device->private;
177 dreq = (struct dasd_diag_req *) cqr->data;
178
Cornelia Huck9a92fe42007-05-10 15:45:42 +0200179 private->iob.dev_nr = private->dev_id.devno;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 private->iob.key = 0;
Horst Hummelfd49f412005-09-03 15:58:00 -0700181 private->iob.flags = DASD_DIAG_RWFLAG_ASYNC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 private->iob.block_count = dreq->block_count;
Horst Hummelfd49f412005-09-03 15:58:00 -0700183 private->iob.interrupt_params = (addr_t) cqr;
Peter Oberparleiter86b368a2005-11-07 00:59:08 -0800184 private->iob.bio_list = dreq->bio;
Horst Hummelfd49f412005-09-03 15:58:00 -0700185 private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Heiko Carstens1aae0562013-01-30 09:49:40 +0100187 cqr->startclk = get_tod_clock();
Horst Hummelfd49f412005-09-03 15:58:00 -0700188 cqr->starttime = jiffies;
189 cqr->retries--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
191 rc = dia250(&private->iob, RW_BIO);
Horst Hummelfd49f412005-09-03 15:58:00 -0700192 switch (rc) {
193 case 0: /* Synchronous I/O finished successfully */
Heiko Carstens1aae0562013-01-30 09:49:40 +0100194 cqr->stopclk = get_tod_clock();
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100195 cqr->status = DASD_CQR_SUCCESS;
Horst Hummelfd49f412005-09-03 15:58:00 -0700196 /* Indicate to calling function that only a dasd_schedule_bh()
197 and no timer is needed */
198 rc = -EACCES;
199 break;
200 case 8: /* Asynchronous I/O was started */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 cqr->status = DASD_CQR_IN_IO;
202 rc = 0;
Horst Hummelfd49f412005-09-03 15:58:00 -0700203 break;
204 default: /* Error condition */
205 cqr->status = DASD_CQR_QUEUED;
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100206 DBF_DEV_EVENT(DBF_WARNING, device, "dia250 returned rc=%d", rc);
Horst Hummelfd49f412005-09-03 15:58:00 -0700207 dasd_diag_erp(device);
208 rc = -EIO;
209 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 }
Stefan Weinhuber6cc7f162009-06-12 10:26:39 +0200211 cqr->intrc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 return rc;
213}
214
Horst Hummelfd49f412005-09-03 15:58:00 -0700215/* Terminate given request at the device. */
216static int
217dasd_diag_term_IO(struct dasd_ccw_req * cqr)
218{
219 struct dasd_device *device;
220
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100221 device = cqr->startdev;
Horst Hummelfd49f412005-09-03 15:58:00 -0700222 mdsk_term_io(device);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100223 mdsk_init_io(device, device->block->bp_block, 0, NULL);
224 cqr->status = DASD_CQR_CLEAR_PENDING;
Heiko Carstens1aae0562013-01-30 09:49:40 +0100225 cqr->stopclk = get_tod_clock();
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100226 dasd_schedule_device_bh(device);
Horst Hummelfd49f412005-09-03 15:58:00 -0700227 return 0;
228}
229
230/* Handle external interruption. */
Heiko Carstensfde15c32012-03-11 11:59:31 -0400231static void dasd_ext_handler(struct ext_code ext_code,
Martin Schwidefskyf6649a72010-10-25 16:10:38 +0200232 unsigned int param32, unsigned long param64)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
234 struct dasd_ccw_req *cqr, *next;
235 struct dasd_device *device;
236 unsigned long long expires;
237 unsigned long flags;
Horst Hummelfd49f412005-09-03 15:58:00 -0700238 addr_t ip;
239 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
Heiko Carstensfde15c32012-03-11 11:59:31 -0400241 switch (ext_code.subcode >> 8) {
Horst Hummelfd49f412005-09-03 15:58:00 -0700242 case DASD_DIAG_CODE_31BIT:
Martin Schwidefskyf6649a72010-10-25 16:10:38 +0200243 ip = (addr_t) param32;
Horst Hummelfd49f412005-09-03 15:58:00 -0700244 break;
245 case DASD_DIAG_CODE_64BIT:
Martin Schwidefskyf6649a72010-10-25 16:10:38 +0200246 ip = (addr_t) param64;
Horst Hummelfd49f412005-09-03 15:58:00 -0700247 break;
248 default:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 return;
Horst Hummelfd49f412005-09-03 15:58:00 -0700250 }
Heiko Carstens420f42e2013-01-02 15:18:18 +0100251 inc_irq_stat(IRQEXT_DSD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 if (!ip) { /* no intparm: unsolicited interrupt */
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100253 DBF_EVENT(DBF_NOTICE, "%s", "caught unsolicited "
254 "interrupt");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 return;
256 }
Horst Hummelfd49f412005-09-03 15:58:00 -0700257 cqr = (struct dasd_ccw_req *) ip;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100258 device = (struct dasd_device *) cqr->startdev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 if (strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100260 DBF_DEV_EVENT(DBF_WARNING, device,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 " magic number of dasd_ccw_req 0x%08X doesn't"
262 " match discipline 0x%08X",
263 cqr->magic, *(int *) (&device->discipline->name));
264 return;
265 }
266
267 /* get irq lock to modify request queue */
268 spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
269
Horst Hummelfd49f412005-09-03 15:58:00 -0700270 /* Check for a pending clear operation */
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100271 if (cqr->status == DASD_CQR_CLEAR_PENDING) {
272 cqr->status = DASD_CQR_CLEARED;
273 dasd_device_clear_timer(device);
274 dasd_schedule_device_bh(device);
Horst Hummelfd49f412005-09-03 15:58:00 -0700275 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
276 return;
277 }
278
Heiko Carstens1aae0562013-01-30 09:49:40 +0100279 cqr->stopclk = get_tod_clock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
281 expires = 0;
Heiko Carstensfde15c32012-03-11 11:59:31 -0400282 if ((ext_code.subcode & 0xff) == 0) {
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100283 cqr->status = DASD_CQR_SUCCESS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 /* Start first request on queue if possible -> fast_io. */
285 if (!list_empty(&device->ccw_queue)) {
286 next = list_entry(device->ccw_queue.next,
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100287 struct dasd_ccw_req, devlist);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 if (next->status == DASD_CQR_QUEUED) {
Horst Hummelfd49f412005-09-03 15:58:00 -0700289 rc = dasd_start_diag(next);
290 if (rc == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 expires = next->expires;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 }
293 }
Horst Hummelfd49f412005-09-03 15:58:00 -0700294 } else {
295 cqr->status = DASD_CQR_QUEUED;
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100296 DBF_DEV_EVENT(DBF_DEBUG, device, "interrupt status for "
Martin Schwidefskyf6649a72010-10-25 16:10:38 +0200297 "request %p was %d (%d retries left)", cqr,
Heiko Carstensfde15c32012-03-11 11:59:31 -0400298 ext_code.subcode & 0xff, cqr->retries);
Horst Hummelfd49f412005-09-03 15:58:00 -0700299 dasd_diag_erp(device);
300 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302 if (expires != 0)
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100303 dasd_device_set_timer(device, expires);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 else
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100305 dasd_device_clear_timer(device);
306 dasd_schedule_device_bh(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
308 spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
309}
310
Horst Hummelfd49f412005-09-03 15:58:00 -0700311/* Check whether device can be controlled by DIAG discipline. Return zero on
312 * success, non-zero otherwise. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313static int
314dasd_diag_check_device(struct dasd_device *device)
315{
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100316 struct dasd_block *block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 struct dasd_diag_private *private;
318 struct dasd_diag_characteristics *rdc_data;
319 struct dasd_diag_bio bio;
Peter Oberparleiter56dc6a82006-01-06 00:19:09 -0800320 struct vtoc_cms_label *label;
Horst Hummelfd49f412005-09-03 15:58:00 -0700321 blocknum_t end_block;
322 unsigned int sb, bsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 int rc;
324
325 private = (struct dasd_diag_private *) device->private;
326 if (private == NULL) {
Horst Hummel138c0142006-06-29 14:58:12 +0200327 private = kzalloc(sizeof(struct dasd_diag_private),GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 if (private == NULL) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100329 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
330 "Allocating memory for private DASD data "
331 "failed\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 return -ENOMEM;
333 }
Cornelia Huck9a92fe42007-05-10 15:45:42 +0200334 ccw_device_get_id(device->cdev, &private->dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 device->private = (void *) private;
336 }
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100337 block = dasd_alloc_block();
338 if (IS_ERR(block)) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100339 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100340 "could not allocate dasd block structure");
Cornelia Huck73371942008-07-17 17:16:43 +0200341 device->private = NULL;
342 kfree(private);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100343 return PTR_ERR(block);
344 }
345 device->block = block;
346 block->base = device;
347
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 /* Read Device Characteristics */
349 rdc_data = (void *) &(private->rdc_data);
Cornelia Huck9a92fe42007-05-10 15:45:42 +0200350 rdc_data->dev_nr = private->dev_id.devno;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 rdc_data->rdc_len = sizeof (struct dasd_diag_characteristics);
352
353 rc = diag210((struct diag210 *) rdc_data);
Horst Hummelfd49f412005-09-03 15:58:00 -0700354 if (rc) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100355 DBF_DEV_EVENT(DBF_WARNING, device, "failed to retrieve device "
Horst Hummelfd49f412005-09-03 15:58:00 -0700356 "information (rc=%d)", rc);
Stefan Haberland8586cb62008-07-17 17:16:49 +0200357 rc = -EOPNOTSUPP;
Cornelia Huck73371942008-07-17 17:16:43 +0200358 goto out;
Horst Hummelfd49f412005-09-03 15:58:00 -0700359 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Stefan Haberland7c8faa82010-08-09 18:13:00 +0200361 device->default_expires = DIAG_TIMEOUT;
Hannes Reinecke1f1ee9a2013-01-30 09:26:12 +0000362 device->default_retries = DIAG_MAX_RETRIES;
Stefan Haberland7c8faa82010-08-09 18:13:00 +0200363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 /* Figure out position of label block */
365 switch (private->rdc_data.vdev_class) {
366 case DEV_CLASS_FBA:
367 private->pt_block = 1;
368 break;
369 case DEV_CLASS_ECKD:
370 private->pt_block = 2;
371 break;
372 default:
Stefan Haberlandea058542009-12-18 17:43:16 +0100373 pr_warning("%s: Device type %d is not supported "
374 "in DIAG mode\n", dev_name(&device->cdev->dev),
375 private->rdc_data.vdev_class);
Stefan Haberland8586cb62008-07-17 17:16:49 +0200376 rc = -EOPNOTSUPP;
Cornelia Huck73371942008-07-17 17:16:43 +0200377 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 }
379
380 DBF_DEV_EVENT(DBF_INFO, device,
381 "%04X: %04X on real %04X/%02X",
382 rdc_data->dev_nr,
383 rdc_data->vdev_type,
384 rdc_data->rdev_type, rdc_data->rdev_model);
385
386 /* terminate all outstanding operations */
387 mdsk_term_io(device);
388
389 /* figure out blocksize of device */
Peter Oberparleiter56dc6a82006-01-06 00:19:09 -0800390 label = (struct vtoc_cms_label *) get_zeroed_page(GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 if (label == NULL) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100392 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 "No memory to allocate initialization request");
Cornelia Huck73371942008-07-17 17:16:43 +0200394 rc = -ENOMEM;
395 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
Horst Hummelfd49f412005-09-03 15:58:00 -0700397 rc = 0;
398 end_block = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 /* try all sizes - needed for ECKD devices */
400 for (bsize = 512; bsize <= PAGE_SIZE; bsize <<= 1) {
Horst Hummelfd49f412005-09-03 15:58:00 -0700401 mdsk_init_io(device, bsize, 0, &end_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 memset(&bio, 0, sizeof (struct dasd_diag_bio));
403 bio.type = MDSK_READ_REQ;
404 bio.block_number = private->pt_block + 1;
Peter Oberparleiter86b368a2005-11-07 00:59:08 -0800405 bio.buffer = label;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 memset(&private->iob, 0, sizeof (struct dasd_diag_rw_io));
407 private->iob.dev_nr = rdc_data->dev_nr;
408 private->iob.key = 0;
409 private->iob.flags = 0; /* do synchronous io */
410 private->iob.block_count = 1;
411 private->iob.interrupt_params = 0;
Peter Oberparleiter86b368a2005-11-07 00:59:08 -0800412 private->iob.bio_list = &bio;
Horst Hummelfd49f412005-09-03 15:58:00 -0700413 private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;
414 rc = dia250(&private->iob, RW_BIO);
Peter Oberparleiter1e0291b2005-11-07 00:59:08 -0800415 if (rc == 3) {
Stefan Haberlandea058542009-12-18 17:43:16 +0100416 pr_warning("%s: A 64-bit DIAG call failed\n",
417 dev_name(&device->cdev->dev));
Peter Oberparleiter1e0291b2005-11-07 00:59:08 -0800418 rc = -EOPNOTSUPP;
Cornelia Huck73371942008-07-17 17:16:43 +0200419 goto out_label;
Peter Oberparleiter1e0291b2005-11-07 00:59:08 -0800420 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 mdsk_term_io(device);
Peter Oberparleiter1e0291b2005-11-07 00:59:08 -0800422 if (rc == 0)
423 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 }
Peter Oberparleiter1e0291b2005-11-07 00:59:08 -0800425 if (bsize > PAGE_SIZE) {
Stefan Haberlandea058542009-12-18 17:43:16 +0100426 pr_warning("%s: Accessing the DASD failed because of an "
427 "incorrect format (rc=%d)\n",
428 dev_name(&device->cdev->dev), rc);
Horst Hummelfd49f412005-09-03 15:58:00 -0700429 rc = -EIO;
Cornelia Huck73371942008-07-17 17:16:43 +0200430 goto out_label;
Peter Oberparleiter1e0291b2005-11-07 00:59:08 -0800431 }
432 /* check for label block */
433 if (memcmp(label->label_id, DASD_DIAG_CMS1,
434 sizeof(DASD_DIAG_CMS1)) == 0) {
435 /* get formatted blocksize from label block */
436 bsize = (unsigned int) label->block_size;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100437 block->blocks = (unsigned long) label->block_count;
Peter Oberparleiter1e0291b2005-11-07 00:59:08 -0800438 } else
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100439 block->blocks = end_block;
440 block->bp_block = bsize;
441 block->s2b_shift = 0; /* bits to shift 512 to get a block */
Peter Oberparleiter1e0291b2005-11-07 00:59:08 -0800442 for (sb = 512; sb < bsize; sb = sb << 1)
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100443 block->s2b_shift++;
444 rc = mdsk_init_io(device, block->bp_block, 0, NULL);
Stefan Weinhuber22825ab2009-12-07 12:51:48 +0100445 if (rc && (rc != 4)) {
Stefan Haberlandea058542009-12-18 17:43:16 +0100446 pr_warning("%s: DIAG initialization failed with rc=%d\n",
447 dev_name(&device->cdev->dev), rc);
Peter Oberparleiter1e0291b2005-11-07 00:59:08 -0800448 rc = -EIO;
Horst Hummelfd49f412005-09-03 15:58:00 -0700449 } else {
Stefan Weinhuber22825ab2009-12-07 12:51:48 +0100450 if (rc == 4)
Stefan Weinhuber33b62a32010-03-08 12:26:24 +0100451 set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
Stefan Haberlandea058542009-12-18 17:43:16 +0100452 pr_info("%s: New DASD with %ld byte/block, total size %ld "
453 "KB%s\n", dev_name(&device->cdev->dev),
454 (unsigned long) block->bp_block,
455 (unsigned long) (block->blocks <<
456 block->s2b_shift) >> 1,
457 (rc == 4) ? ", read-only device" : "");
Stefan Weinhuber22825ab2009-12-07 12:51:48 +0100458 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 }
Cornelia Huck73371942008-07-17 17:16:43 +0200460out_label:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 free_page((long) label);
Cornelia Huck73371942008-07-17 17:16:43 +0200462out:
463 if (rc) {
464 device->block = NULL;
465 dasd_free_block(block);
466 device->private = NULL;
467 kfree(private);
468 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 return rc;
470}
471
Horst Hummelfd49f412005-09-03 15:58:00 -0700472/* Fill in virtual disk geometry for device. Return zero on success, non-zero
473 * otherwise. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474static int
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100475dasd_diag_fill_geometry(struct dasd_block *block, struct hd_geometry *geo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476{
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100477 if (dasd_check_blocksize(block->bp_block) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 return -EINVAL;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100479 geo->cylinders = (block->blocks << block->s2b_shift) >> 10;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 geo->heads = 16;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100481 geo->sectors = 128 >> block->s2b_shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 return 0;
483}
484
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485static dasd_erp_fn_t
486dasd_diag_erp_action(struct dasd_ccw_req * cqr)
487{
488 return dasd_default_erp_action;
489}
490
491static dasd_erp_fn_t
492dasd_diag_erp_postaction(struct dasd_ccw_req * cqr)
493{
494 return dasd_default_erp_postaction;
495}
496
Horst Hummelfd49f412005-09-03 15:58:00 -0700497/* Create DASD request from block device request. Return pointer to new
498 * request on success, ERR_PTR otherwise. */
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100499static struct dasd_ccw_req *dasd_diag_build_cp(struct dasd_device *memdev,
500 struct dasd_block *block,
501 struct request *req)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502{
503 struct dasd_ccw_req *cqr;
504 struct dasd_diag_req *dreq;
505 struct dasd_diag_bio *dbio;
NeilBrown5705f702007-09-25 12:35:59 +0200506 struct req_iterator iter;
Kent Overstreet79886132013-11-23 17:19:00 -0800507 struct bio_vec bv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 char *dst;
Horst Hummelfd49f412005-09-03 15:58:00 -0700509 unsigned int count, datasize;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 sector_t recid, first_rec, last_rec;
Horst Hummelfd49f412005-09-03 15:58:00 -0700511 unsigned int blksize, off;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 unsigned char rw_cmd;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
514 if (rq_data_dir(req) == READ)
515 rw_cmd = MDSK_READ_REQ;
516 else if (rq_data_dir(req) == WRITE)
517 rw_cmd = MDSK_WRITE_REQ;
518 else
519 return ERR_PTR(-EINVAL);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100520 blksize = block->bp_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 /* Calculate record id of first and last block. */
Tejun Heo83096eb2009-05-07 22:24:39 +0900522 first_rec = blk_rq_pos(req) >> block->s2b_shift;
523 last_rec =
524 (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 /* Check struct bio and count the number of blocks for the request. */
526 count = 0;
NeilBrown5705f702007-09-25 12:35:59 +0200527 rq_for_each_segment(bv, req, iter) {
Kent Overstreet79886132013-11-23 17:19:00 -0800528 if (bv.bv_len & (blksize - 1))
Jens Axboe6c92e692007-08-16 13:43:12 +0200529 /* Fba can only do full blocks. */
530 return ERR_PTR(-EINVAL);
Kent Overstreet79886132013-11-23 17:19:00 -0800531 count += bv.bv_len >> (block->s2b_shift + 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 }
533 /* Paranoia. */
534 if (count != last_rec - first_rec + 1)
535 return ERR_PTR(-EINVAL);
536 /* Build the request */
537 datasize = sizeof(struct dasd_diag_req) +
538 count*sizeof(struct dasd_diag_bio);
Stefan Haberland68b781f2009-09-11 10:28:29 +0200539 cqr = dasd_smalloc_request(DASD_DIAG_MAGIC, 0, datasize, memdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 if (IS_ERR(cqr))
541 return cqr;
Horst Hummel138c0142006-06-29 14:58:12 +0200542
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 dreq = (struct dasd_diag_req *) cqr->data;
544 dreq->block_count = count;
545 dbio = dreq->bio;
546 recid = first_rec;
NeilBrown5705f702007-09-25 12:35:59 +0200547 rq_for_each_segment(bv, req, iter) {
Kent Overstreet79886132013-11-23 17:19:00 -0800548 dst = page_address(bv.bv_page) + bv.bv_offset;
549 for (off = 0; off < bv.bv_len; off += blksize) {
Jens Axboe6c92e692007-08-16 13:43:12 +0200550 memset(dbio, 0, sizeof (struct dasd_diag_bio));
551 dbio->type = rw_cmd;
552 dbio->block_number = recid + 1;
553 dbio->buffer = dst;
554 dbio++;
555 dst += blksize;
556 recid++;
557 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 }
Hannes Reinecke1f1ee9a2013-01-30 09:26:12 +0000559 cqr->retries = memdev->default_retries;
Heiko Carstens1aae0562013-01-30 09:49:40 +0100560 cqr->buildclk = get_tod_clock();
Holger Smolinski13de2272009-01-09 12:14:51 +0100561 if (blk_noretry_request(req) ||
562 block->base->features & DASD_FEATURE_FAILFAST)
Horst Hummel1c01b8a2006-01-06 00:19:15 -0800563 set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100564 cqr->startdev = memdev;
565 cqr->memdev = memdev;
566 cqr->block = block;
Stefan Haberland7c8faa82010-08-09 18:13:00 +0200567 cqr->expires = memdev->default_expires * HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 cqr->status = DASD_CQR_FILLED;
569 return cqr;
570}
571
Horst Hummelfd49f412005-09-03 15:58:00 -0700572/* Release DASD request. Return non-zero if request was successful, zero
573 * otherwise. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574static int
575dasd_diag_free_cp(struct dasd_ccw_req *cqr, struct request *req)
576{
577 int status;
578
579 status = cqr->status == DASD_CQR_DONE;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100580 dasd_sfree_request(cqr, cqr->memdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 return status;
582}
583
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100584static void dasd_diag_handle_terminated_request(struct dasd_ccw_req *cqr)
585{
Hannes Reineckea2ace462013-01-30 09:26:14 +0000586 if (cqr->retries < 0)
587 cqr->status = DASD_CQR_FAILED;
588 else
589 cqr->status = DASD_CQR_FILLED;
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100590};
591
Horst Hummelfd49f412005-09-03 15:58:00 -0700592/* Fill in IOCTL data for device. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593static int
594dasd_diag_fill_info(struct dasd_device * device,
595 struct dasd_information2_t * info)
596{
597 struct dasd_diag_private *private;
598
599 private = (struct dasd_diag_private *) device->private;
Horst Hummelfd49f412005-09-03 15:58:00 -0700600 info->label_block = (unsigned int) private->pt_block;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 info->FBA_layout = 1;
602 info->format = DASD_FORMAT_LDL;
603 info->characteristics_size = sizeof (struct dasd_diag_characteristics);
604 memcpy(info->characteristics,
605 &((struct dasd_diag_private *) device->private)->rdc_data,
606 sizeof (struct dasd_diag_characteristics));
607 info->confdata_size = 0;
608 return 0;
609}
610
611static void
612dasd_diag_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req,
613 struct irb *stat)
614{
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100615 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 "dump sense not available for DIAG data");
617}
618
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100619static struct dasd_discipline dasd_diag_discipline = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 .owner = THIS_MODULE,
621 .name = "DIAG",
622 .ebcname = "DIAG",
Horst Hummelfd49f412005-09-03 15:58:00 -0700623 .max_blocks = DIAG_MAX_BLOCKS,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 .check_device = dasd_diag_check_device,
Stefan Weinhubera4d26c62011-01-05 12:48:03 +0100625 .verify_path = dasd_generic_verify_path,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 .fill_geometry = dasd_diag_fill_geometry,
627 .start_IO = dasd_start_diag,
Horst Hummelfd49f412005-09-03 15:58:00 -0700628 .term_IO = dasd_diag_term_IO,
Stefan Weinhuber8e09f212008-01-26 14:11:23 +0100629 .handle_terminated_request = dasd_diag_handle_terminated_request,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 .erp_action = dasd_diag_erp_action,
631 .erp_postaction = dasd_diag_erp_postaction,
632 .build_cp = dasd_diag_build_cp,
633 .free_cp = dasd_diag_free_cp,
634 .dump_sense = dasd_diag_dump_sense,
635 .fill_info = dasd_diag_fill_info,
636};
637
638static int __init
639dasd_diag_init(void)
640{
641 if (!MACHINE_IS_VM) {
Stefan Haberlandfc19f382009-03-26 15:23:49 +0100642 pr_info("Discipline %s cannot be used without z/VM\n",
643 dasd_diag_discipline.name);
Horst Hummelfd49f412005-09-03 15:58:00 -0700644 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 }
646 ASCEBC(dasd_diag_discipline.ebcname, 4);
647
Heiko Carstens82003c32013-09-04 13:35:45 +0200648 irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
Thomas Huth1dad0932014-03-31 15:24:08 +0200649 register_external_irq(EXT_IRQ_CP_SERVICE, dasd_ext_handler);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 dasd_diag_discipline_pointer = &dasd_diag_discipline;
651 return 0;
652}
653
654static void __exit
655dasd_diag_cleanup(void)
656{
Thomas Huth1dad0932014-03-31 15:24:08 +0200657 unregister_external_irq(EXT_IRQ_CP_SERVICE, dasd_ext_handler);
Heiko Carstens82003c32013-09-04 13:35:45 +0200658 irq_subclass_unregister(IRQ_SUBCLASS_SERVICE_SIGNAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 dasd_diag_discipline_pointer = NULL;
660}
661
662module_init(dasd_diag_init);
663module_exit(dasd_diag_cleanup);