Commit | Line | Data |
---|---|---|
138c014d | 1 | /* |
1da177e4 LT |
2 | * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> |
3 | * Bugreports.to..: <Linux390@de.ibm.com> | |
d41dd122 | 4 | * Copyright IBM Corp. 1999, 2009 |
1da177e4 LT |
5 | */ |
6 | ||
ca99dab0 | 7 | #define KMSG_COMPONENT "dasd-fba" |
fc19f381 | 8 | |
1da177e4 LT |
9 | #include <linux/stddef.h> |
10 | #include <linux/kernel.h> | |
11 | #include <asm/debug.h> | |
12 | ||
13 | #include <linux/slab.h> | |
14 | #include <linux/hdreg.h> /* HDIO_GETGEO */ | |
15 | #include <linux/bio.h> | |
16 | #include <linux/module.h> | |
17 | #include <linux/init.h> | |
18 | ||
19 | #include <asm/idals.h> | |
20 | #include <asm/ebcdic.h> | |
21 | #include <asm/io.h> | |
1da177e4 LT |
22 | #include <asm/ccwdev.h> |
23 | ||
24 | #include "dasd_int.h" | |
25 | #include "dasd_fba.h" | |
26 | ||
27 | #ifdef PRINTK_HEADER | |
28 | #undef PRINTK_HEADER | |
29 | #endif /* PRINTK_HEADER */ | |
30 | #define PRINTK_HEADER "dasd(fba):" | |
31 | ||
1f1ee9ad HR |
32 | #define FBA_DEFAULT_RETRIES 32 |
33 | ||
1da177e4 LT |
34 | #define DASD_FBA_CCW_WRITE 0x41 |
35 | #define DASD_FBA_CCW_READ 0x42 | |
36 | #define DASD_FBA_CCW_LOCATE 0x43 | |
37 | #define DASD_FBA_CCW_DEFINE_EXTENT 0x63 | |
38 | ||
39 | MODULE_LICENSE("GPL"); | |
40 | ||
41 | static struct dasd_discipline dasd_fba_discipline; | |
42 | ||
43 | struct dasd_fba_private { | |
44 | struct dasd_fba_characteristics rdc_data; | |
45 | }; | |
46 | ||
47 | static struct ccw_device_id dasd_fba_ids[] = { | |
d2c993d8 HC |
48 | { CCW_DEVICE_DEVTYPE (0x6310, 0, 0x9336, 0), .driver_info = 0x1}, |
49 | { CCW_DEVICE_DEVTYPE (0x3880, 0, 0x3370, 0), .driver_info = 0x2}, | |
1da177e4 LT |
50 | { /* end of list */ }, |
51 | }; | |
52 | ||
53 | MODULE_DEVICE_TABLE(ccw, dasd_fba_ids); | |
54 | ||
55 | static struct ccw_driver dasd_fba_driver; /* see below */ | |
56 | static int | |
57 | dasd_fba_probe(struct ccw_device *cdev) | |
58 | { | |
40545573 | 59 | return dasd_generic_probe(cdev, &dasd_fba_discipline); |
1da177e4 LT |
60 | } |
61 | ||
62 | static int | |
63 | dasd_fba_set_online(struct ccw_device *cdev) | |
64 | { | |
40545573 | 65 | return dasd_generic_set_online(cdev, &dasd_fba_discipline); |
1da177e4 LT |
66 | } |
67 | ||
68 | static struct ccw_driver dasd_fba_driver = { | |
3bda058b SO |
69 | .driver = { |
70 | .name = "dasd-fba", | |
71 | .owner = THIS_MODULE, | |
72 | }, | |
1da177e4 LT |
73 | .ids = dasd_fba_ids, |
74 | .probe = dasd_fba_probe, | |
75 | .remove = dasd_generic_remove, | |
76 | .set_offline = dasd_generic_set_offline, | |
77 | .set_online = dasd_fba_set_online, | |
78 | .notify = dasd_generic_notify, | |
a4d26c6a | 79 | .path_event = dasd_generic_path_event, |
d41dd122 SH |
80 | .freeze = dasd_generic_pm_freeze, |
81 | .thaw = dasd_generic_restore_device, | |
82 | .restore = dasd_generic_restore_device, | |
420f42ec | 83 | .int_class = IRQIO_DAS, |
1da177e4 LT |
84 | }; |
85 | ||
4d284cac | 86 | static void |
1da177e4 LT |
87 | define_extent(struct ccw1 * ccw, struct DE_fba_data *data, int rw, |
88 | int blksize, int beg, int nr) | |
89 | { | |
90 | ccw->cmd_code = DASD_FBA_CCW_DEFINE_EXTENT; | |
91 | ccw->flags = 0; | |
92 | ccw->count = 16; | |
93 | ccw->cda = (__u32) __pa(data); | |
94 | memset(data, 0, sizeof (struct DE_fba_data)); | |
95 | if (rw == WRITE) | |
96 | (data->mask).perm = 0x0; | |
97 | else if (rw == READ) | |
98 | (data->mask).perm = 0x1; | |
99 | else | |
100 | data->mask.perm = 0x2; | |
101 | data->blk_size = blksize; | |
102 | data->ext_loc = beg; | |
103 | data->ext_end = nr - 1; | |
104 | } | |
105 | ||
4d284cac | 106 | static void |
1da177e4 LT |
107 | locate_record(struct ccw1 * ccw, struct LO_fba_data *data, int rw, |
108 | int block_nr, int block_ct) | |
109 | { | |
110 | ccw->cmd_code = DASD_FBA_CCW_LOCATE; | |
111 | ccw->flags = 0; | |
112 | ccw->count = 8; | |
113 | ccw->cda = (__u32) __pa(data); | |
114 | memset(data, 0, sizeof (struct LO_fba_data)); | |
115 | if (rw == WRITE) | |
116 | data->operation.cmd = 0x5; | |
117 | else if (rw == READ) | |
118 | data->operation.cmd = 0x6; | |
119 | else | |
120 | data->operation.cmd = 0x8; | |
121 | data->blk_nr = block_nr; | |
122 | data->blk_ct = block_ct; | |
123 | } | |
124 | ||
125 | static int | |
126 | dasd_fba_check_characteristics(struct dasd_device *device) | |
127 | { | |
543691a4 | 128 | struct dasd_fba_private *private = device->private; |
138c014d | 129 | struct ccw_device *cdev = device->cdev; |
543691a4 SO |
130 | struct dasd_block *block; |
131 | int readonly, rc; | |
1da177e4 | 132 | |
92636b15 SO |
133 | if (!private) { |
134 | private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA); | |
135 | if (!private) { | |
fc19f381 SH |
136 | dev_warn(&device->cdev->dev, |
137 | "Allocating memory for private DASD " | |
138 | "data failed\n"); | |
1da177e4 LT |
139 | return -ENOMEM; |
140 | } | |
543691a4 | 141 | device->private = private; |
92636b15 SO |
142 | } else { |
143 | memset(private, 0, sizeof(*private)); | |
1da177e4 | 144 | } |
8e09f215 SW |
145 | block = dasd_alloc_block(); |
146 | if (IS_ERR(block)) { | |
b8ed5dd5 SH |
147 | DBF_EVENT_DEVID(DBF_WARNING, cdev, "%s", "could not allocate " |
148 | "dasd block structure"); | |
7337194f CH |
149 | device->private = NULL; |
150 | kfree(private); | |
8e09f215 SW |
151 | return PTR_ERR(block); |
152 | } | |
153 | device->block = block; | |
154 | block->base = device; | |
155 | ||
1da177e4 | 156 | /* Read Device Characteristics */ |
68b781fe SH |
157 | rc = dasd_generic_read_dev_chars(device, DASD_FBA_MAGIC, |
158 | &private->rdc_data, 32); | |
1da177e4 | 159 | if (rc) { |
b8ed5dd5 SH |
160 | DBF_EVENT_DEVID(DBF_WARNING, cdev, "Read device " |
161 | "characteristics returned error %d", rc); | |
7337194f CH |
162 | device->block = NULL; |
163 | dasd_free_block(block); | |
164 | device->private = NULL; | |
165 | kfree(private); | |
1da177e4 LT |
166 | return rc; |
167 | } | |
168 | ||
7c8faa86 | 169 | device->default_expires = DASD_EXPIRES; |
1f1ee9ad | 170 | device->default_retries = FBA_DEFAULT_RETRIES; |
a4d26c6a | 171 | device->path_data.opm = LPM_ANYPATH; |
7c8faa86 | 172 | |
33b62a30 SW |
173 | readonly = dasd_device_is_ro(device); |
174 | if (readonly) | |
175 | set_bit(DASD_FLAG_DEVICE_RO, &device->flags); | |
176 | ||
fc19f381 SH |
177 | dev_info(&device->cdev->dev, |
178 | "New FBA DASD %04X/%02X (CU %04X/%02X) with %d MB " | |
33b62a30 | 179 | "and %d B/blk%s\n", |
fc19f381 SH |
180 | cdev->id.dev_type, |
181 | cdev->id.dev_model, | |
182 | cdev->id.cu_type, | |
183 | cdev->id.cu_model, | |
184 | ((private->rdc_data.blk_bdsa * | |
185 | (private->rdc_data.blk_size >> 9)) >> 11), | |
33b62a30 SW |
186 | private->rdc_data.blk_size, |
187 | readonly ? ", read-only device" : ""); | |
1da177e4 LT |
188 | return 0; |
189 | } | |
190 | ||
8e09f215 | 191 | static int dasd_fba_do_analysis(struct dasd_block *block) |
1da177e4 | 192 | { |
543691a4 | 193 | struct dasd_fba_private *private = block->base->private; |
1da177e4 LT |
194 | int sb, rc; |
195 | ||
1da177e4 LT |
196 | rc = dasd_check_blocksize(private->rdc_data.blk_size); |
197 | if (rc) { | |
fc19f381 | 198 | DBF_DEV_EVENT(DBF_WARNING, block->base, "unknown blocksize %d", |
1da177e4 LT |
199 | private->rdc_data.blk_size); |
200 | return rc; | |
201 | } | |
8e09f215 SW |
202 | block->blocks = private->rdc_data.blk_bdsa; |
203 | block->bp_block = private->rdc_data.blk_size; | |
204 | block->s2b_shift = 0; /* bits to shift 512 to get a block */ | |
1da177e4 | 205 | for (sb = 512; sb < private->rdc_data.blk_size; sb = sb << 1) |
8e09f215 | 206 | block->s2b_shift++; |
1da177e4 LT |
207 | return 0; |
208 | } | |
209 | ||
8e09f215 SW |
210 | static int dasd_fba_fill_geometry(struct dasd_block *block, |
211 | struct hd_geometry *geo) | |
1da177e4 | 212 | { |
8e09f215 | 213 | if (dasd_check_blocksize(block->bp_block) != 0) |
1da177e4 | 214 | return -EINVAL; |
8e09f215 | 215 | geo->cylinders = (block->blocks << block->s2b_shift) >> 10; |
1da177e4 | 216 | geo->heads = 16; |
8e09f215 | 217 | geo->sectors = 128 >> block->s2b_shift; |
1da177e4 LT |
218 | return 0; |
219 | } | |
220 | ||
1da177e4 LT |
221 | static dasd_erp_fn_t |
222 | dasd_fba_erp_action(struct dasd_ccw_req * cqr) | |
223 | { | |
224 | return dasd_default_erp_action; | |
225 | } | |
226 | ||
227 | static dasd_erp_fn_t | |
228 | dasd_fba_erp_postaction(struct dasd_ccw_req * cqr) | |
229 | { | |
230 | if (cqr->function == dasd_default_erp_action) | |
231 | return dasd_default_erp_postaction; | |
232 | ||
fc19f381 | 233 | DBF_DEV_EVENT(DBF_WARNING, cqr->startdev, "unknown ERP action %p", |
1da177e4 LT |
234 | cqr->function); |
235 | return NULL; | |
236 | } | |
237 | ||
5a27e60d SW |
238 | static void dasd_fba_check_for_device_change(struct dasd_device *device, |
239 | struct dasd_ccw_req *cqr, | |
240 | struct irb *irb) | |
8e09f215 SW |
241 | { |
242 | char mask; | |
243 | ||
244 | /* first of all check for state change pending interrupt */ | |
245 | mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP; | |
5a27e60d | 246 | if ((irb->scsw.cmd.dstat & mask) == mask) |
8e09f215 | 247 | dasd_generic_handle_state_change(device); |
8e09f215 SW |
248 | }; |
249 | ||
250 | static struct dasd_ccw_req *dasd_fba_build_cp(struct dasd_device * memdev, | |
251 | struct dasd_block *block, | |
252 | struct request *req) | |
1da177e4 | 253 | { |
543691a4 | 254 | struct dasd_fba_private *private = block->base->private; |
1da177e4 LT |
255 | unsigned long *idaws; |
256 | struct LO_fba_data *LO_data; | |
257 | struct dasd_ccw_req *cqr; | |
258 | struct ccw1 *ccw; | |
5705f702 | 259 | struct req_iterator iter; |
7988613b | 260 | struct bio_vec bv; |
1da177e4 LT |
261 | char *dst; |
262 | int count, cidaw, cplength, datasize; | |
263 | sector_t recid, first_rec, last_rec; | |
264 | unsigned int blksize, off; | |
265 | unsigned char cmd; | |
1da177e4 | 266 | |
1da177e4 LT |
267 | if (rq_data_dir(req) == READ) { |
268 | cmd = DASD_FBA_CCW_READ; | |
269 | } else if (rq_data_dir(req) == WRITE) { | |
270 | cmd = DASD_FBA_CCW_WRITE; | |
271 | } else | |
272 | return ERR_PTR(-EINVAL); | |
8e09f215 | 273 | blksize = block->bp_block; |
1da177e4 | 274 | /* Calculate record id of first and last block. */ |
83096ebf TH |
275 | first_rec = blk_rq_pos(req) >> block->s2b_shift; |
276 | last_rec = | |
277 | (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift; | |
1da177e4 LT |
278 | /* Check struct bio and count the number of blocks for the request. */ |
279 | count = 0; | |
280 | cidaw = 0; | |
5705f702 | 281 | rq_for_each_segment(bv, req, iter) { |
7988613b | 282 | if (bv.bv_len & (blksize - 1)) |
6c92e699 JA |
283 | /* Fba can only do full blocks. */ |
284 | return ERR_PTR(-EINVAL); | |
7988613b | 285 | count += bv.bv_len >> (block->s2b_shift + 9); |
7988613b KO |
286 | if (idal_is_needed (page_address(bv.bv_page), bv.bv_len)) |
287 | cidaw += bv.bv_len / blksize; | |
1da177e4 LT |
288 | } |
289 | /* Paranoia. */ | |
290 | if (count != last_rec - first_rec + 1) | |
291 | return ERR_PTR(-EINVAL); | |
292 | /* 1x define extent + 1x locate record + number of blocks */ | |
293 | cplength = 2 + count; | |
294 | /* 1x define extent + 1x locate record */ | |
295 | datasize = sizeof(struct DE_fba_data) + sizeof(struct LO_fba_data) + | |
296 | cidaw * sizeof(unsigned long); | |
297 | /* | |
298 | * Find out number of additional locate record ccws if the device | |
299 | * can't do data chaining. | |
300 | */ | |
301 | if (private->rdc_data.mode.bits.data_chain == 0) { | |
302 | cplength += count - 1; | |
303 | datasize += (count - 1)*sizeof(struct LO_fba_data); | |
304 | } | |
305 | /* Allocate the ccw request. */ | |
68b781fe | 306 | cqr = dasd_smalloc_request(DASD_FBA_MAGIC, cplength, datasize, memdev); |
1da177e4 LT |
307 | if (IS_ERR(cqr)) |
308 | return cqr; | |
309 | ccw = cqr->cpaddr; | |
310 | /* First ccw is define extent. */ | |
311 | define_extent(ccw++, cqr->data, rq_data_dir(req), | |
83096ebf | 312 | block->bp_block, blk_rq_pos(req), blk_rq_sectors(req)); |
1da177e4 LT |
313 | /* Build locate_record + read/write ccws. */ |
314 | idaws = (unsigned long *) (cqr->data + sizeof(struct DE_fba_data)); | |
315 | LO_data = (struct LO_fba_data *) (idaws + cidaw); | |
316 | /* Locate record for all blocks for smart devices. */ | |
317 | if (private->rdc_data.mode.bits.data_chain != 0) { | |
318 | ccw[-1].flags |= CCW_FLAG_CC; | |
319 | locate_record(ccw++, LO_data++, rq_data_dir(req), 0, count); | |
320 | } | |
321 | recid = first_rec; | |
5705f702 | 322 | rq_for_each_segment(bv, req, iter) { |
7988613b | 323 | dst = page_address(bv.bv_page) + bv.bv_offset; |
1da177e4 LT |
324 | if (dasd_page_cache) { |
325 | char *copy = kmem_cache_alloc(dasd_page_cache, | |
441e143e | 326 | GFP_DMA | __GFP_NOWARN); |
1da177e4 | 327 | if (copy && rq_data_dir(req) == WRITE) |
7988613b | 328 | memcpy(copy + bv.bv_offset, dst, bv.bv_len); |
1da177e4 | 329 | if (copy) |
7988613b | 330 | dst = copy + bv.bv_offset; |
1da177e4 | 331 | } |
7988613b | 332 | for (off = 0; off < bv.bv_len; off += blksize) { |
1da177e4 LT |
333 | /* Locate record for stupid devices. */ |
334 | if (private->rdc_data.mode.bits.data_chain == 0) { | |
335 | ccw[-1].flags |= CCW_FLAG_CC; | |
336 | locate_record(ccw, LO_data++, | |
337 | rq_data_dir(req), | |
338 | recid - first_rec, 1); | |
339 | ccw->flags = CCW_FLAG_CC; | |
340 | ccw++; | |
341 | } else { | |
342 | if (recid > first_rec) | |
343 | ccw[-1].flags |= CCW_FLAG_DC; | |
344 | else | |
345 | ccw[-1].flags |= CCW_FLAG_CC; | |
346 | } | |
347 | ccw->cmd_code = cmd; | |
8e09f215 | 348 | ccw->count = block->bp_block; |
1da177e4 LT |
349 | if (idal_is_needed(dst, blksize)) { |
350 | ccw->cda = (__u32)(addr_t) idaws; | |
351 | ccw->flags = CCW_FLAG_IDA; | |
352 | idaws = idal_create_words(idaws, dst, blksize); | |
353 | } else { | |
354 | ccw->cda = (__u32)(addr_t) dst; | |
355 | ccw->flags = 0; | |
356 | } | |
357 | ccw++; | |
358 | dst += blksize; | |
359 | recid++; | |
360 | } | |
361 | } | |
13de227b HS |
362 | if (blk_noretry_request(req) || |
363 | block->base->features & DASD_FEATURE_FAILFAST) | |
1c01b8a5 | 364 | set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); |
8e09f215 SW |
365 | cqr->startdev = memdev; |
366 | cqr->memdev = memdev; | |
367 | cqr->block = block; | |
7c8faa86 | 368 | cqr->expires = memdev->default_expires * HZ; /* default 5 minutes */ |
1f1ee9ad | 369 | cqr->retries = memdev->default_retries; |
1aae0560 | 370 | cqr->buildclk = get_tod_clock(); |
1da177e4 LT |
371 | cqr->status = DASD_CQR_FILLED; |
372 | return cqr; | |
373 | } | |
374 | ||
375 | static int | |
376 | dasd_fba_free_cp(struct dasd_ccw_req *cqr, struct request *req) | |
377 | { | |
543691a4 | 378 | struct dasd_fba_private *private = cqr->block->base->private; |
1da177e4 | 379 | struct ccw1 *ccw; |
5705f702 | 380 | struct req_iterator iter; |
7988613b | 381 | struct bio_vec bv; |
1da177e4 LT |
382 | char *dst, *cda; |
383 | unsigned int blksize, off; | |
5705f702 | 384 | int status; |
1da177e4 LT |
385 | |
386 | if (!dasd_page_cache) | |
387 | goto out; | |
8e09f215 | 388 | blksize = cqr->block->bp_block; |
1da177e4 LT |
389 | ccw = cqr->cpaddr; |
390 | /* Skip over define extent & locate record. */ | |
391 | ccw++; | |
392 | if (private->rdc_data.mode.bits.data_chain != 0) | |
393 | ccw++; | |
5705f702 | 394 | rq_for_each_segment(bv, req, iter) { |
7988613b KO |
395 | dst = page_address(bv.bv_page) + bv.bv_offset; |
396 | for (off = 0; off < bv.bv_len; off += blksize) { | |
1da177e4 LT |
397 | /* Skip locate record. */ |
398 | if (private->rdc_data.mode.bits.data_chain == 0) | |
399 | ccw++; | |
400 | if (dst) { | |
401 | if (ccw->flags & CCW_FLAG_IDA) | |
402 | cda = *((char **)((addr_t) ccw->cda)); | |
403 | else | |
404 | cda = (char *)((addr_t) ccw->cda); | |
405 | if (dst != cda) { | |
406 | if (rq_data_dir(req) == READ) | |
7988613b | 407 | memcpy(dst, cda, bv.bv_len); |
1da177e4 LT |
408 | kmem_cache_free(dasd_page_cache, |
409 | (void *)((addr_t)cda & PAGE_MASK)); | |
410 | } | |
411 | dst = NULL; | |
412 | } | |
413 | ccw++; | |
414 | } | |
415 | } | |
416 | out: | |
417 | status = cqr->status == DASD_CQR_DONE; | |
8e09f215 | 418 | dasd_sfree_request(cqr, cqr->memdev); |
1da177e4 LT |
419 | return status; |
420 | } | |
421 | ||
8e09f215 SW |
422 | static void dasd_fba_handle_terminated_request(struct dasd_ccw_req *cqr) |
423 | { | |
a2ace466 HR |
424 | if (cqr->retries < 0) |
425 | cqr->status = DASD_CQR_FAILED; | |
426 | else | |
427 | cqr->status = DASD_CQR_FILLED; | |
8e09f215 SW |
428 | }; |
429 | ||
1da177e4 LT |
430 | static int |
431 | dasd_fba_fill_info(struct dasd_device * device, | |
432 | struct dasd_information2_t * info) | |
433 | { | |
543691a4 SO |
434 | struct dasd_fba_private *private = device->private; |
435 | ||
1da177e4 LT |
436 | info->label_block = 1; |
437 | info->FBA_layout = 1; | |
438 | info->format = DASD_FORMAT_LDL; | |
543691a4 SO |
439 | info->characteristics_size = sizeof(private->rdc_data); |
440 | memcpy(info->characteristics, &private->rdc_data, | |
441 | sizeof(private->rdc_data)); | |
1da177e4 LT |
442 | info->confdata_size = 0; |
443 | return 0; | |
444 | } | |
445 | ||
fc19f381 | 446 | static void |
aeec92ca SH |
447 | dasd_fba_dump_sense_dbf(struct dasd_device *device, struct irb *irb, |
448 | char *reason) | |
fc19f381 | 449 | { |
aeec92ca SH |
450 | u64 *sense; |
451 | ||
452 | sense = (u64 *) dasd_get_sense(irb); | |
453 | if (sense) { | |
454 | DBF_DEV_EVENT(DBF_EMERG, device, | |
455 | "%s: %s %02x%02x%02x %016llx %016llx %016llx " | |
456 | "%016llx", reason, | |
457 | scsw_is_tm(&irb->scsw) ? "t" : "c", | |
458 | scsw_cc(&irb->scsw), scsw_cstat(&irb->scsw), | |
459 | scsw_dstat(&irb->scsw), sense[0], sense[1], | |
460 | sense[2], sense[3]); | |
fc19f381 SH |
461 | } else { |
462 | DBF_DEV_EVENT(DBF_EMERG, device, "%s", | |
463 | "SORRY - NO VALID SENSE AVAILABLE\n"); | |
464 | } | |
465 | } | |
466 | ||
467 | ||
1da177e4 LT |
468 | static void |
469 | dasd_fba_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req, | |
470 | struct irb *irb) | |
471 | { | |
472 | char *page; | |
473 | struct ccw1 *act, *end, *last; | |
474 | int len, sl, sct, count; | |
475 | ||
476 | page = (char *) get_zeroed_page(GFP_ATOMIC); | |
477 | if (page == NULL) { | |
fc19f381 | 478 | DBF_DEV_EVENT(DBF_WARNING, device, "%s", |
1da177e4 LT |
479 | "No memory to dump sense data"); |
480 | return; | |
481 | } | |
773bab4a | 482 | len = sprintf(page, PRINTK_HEADER |
1da177e4 | 483 | " I/O status report for device %s:\n", |
2a0217d5 | 484 | dev_name(&device->cdev->dev)); |
773bab4a | 485 | len += sprintf(page + len, PRINTK_HEADER |
1da177e4 | 486 | " in req: %p CS: 0x%02X DS: 0x%02X\n", req, |
23d805b6 | 487 | irb->scsw.cmd.cstat, irb->scsw.cmd.dstat); |
773bab4a | 488 | len += sprintf(page + len, PRINTK_HEADER |
1da177e4 | 489 | " device %s: Failing CCW: %p\n", |
2a0217d5 | 490 | dev_name(&device->cdev->dev), |
23d805b6 | 491 | (void *) (addr_t) irb->scsw.cmd.cpa); |
1da177e4 LT |
492 | if (irb->esw.esw0.erw.cons) { |
493 | for (sl = 0; sl < 4; sl++) { | |
773bab4a | 494 | len += sprintf(page + len, PRINTK_HEADER |
1da177e4 LT |
495 | " Sense(hex) %2d-%2d:", |
496 | (8 * sl), ((8 * sl) + 7)); | |
497 | ||
498 | for (sct = 0; sct < 8; sct++) { | |
499 | len += sprintf(page + len, " %02x", | |
500 | irb->ecw[8 * sl + sct]); | |
501 | } | |
502 | len += sprintf(page + len, "\n"); | |
503 | } | |
504 | } else { | |
773bab4a | 505 | len += sprintf(page + len, PRINTK_HEADER |
1da177e4 LT |
506 | " SORRY - NO VALID SENSE AVAILABLE\n"); |
507 | } | |
fc19f381 | 508 | printk(KERN_ERR "%s", page); |
1da177e4 LT |
509 | |
510 | /* dump the Channel Program */ | |
511 | /* print first CCWs (maximum 8) */ | |
512 | act = req->cpaddr; | |
513 | for (last = act; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++); | |
514 | end = min(act + 8, last); | |
773bab4a | 515 | len = sprintf(page, PRINTK_HEADER " Related CP in req: %p\n", req); |
1da177e4 | 516 | while (act <= end) { |
773bab4a | 517 | len += sprintf(page + len, PRINTK_HEADER |
1da177e4 LT |
518 | " CCW %p: %08X %08X DAT:", |
519 | act, ((int *) act)[0], ((int *) act)[1]); | |
520 | for (count = 0; count < 32 && count < act->count; | |
521 | count += sizeof(int)) | |
522 | len += sprintf(page + len, " %08X", | |
523 | ((int *) (addr_t) act->cda) | |
524 | [(count>>2)]); | |
525 | len += sprintf(page + len, "\n"); | |
526 | act++; | |
527 | } | |
fc19f381 | 528 | printk(KERN_ERR "%s", page); |
1da177e4 LT |
529 | |
530 | ||
531 | /* print failing CCW area */ | |
532 | len = 0; | |
23d805b6 PO |
533 | if (act < ((struct ccw1 *)(addr_t) irb->scsw.cmd.cpa) - 2) { |
534 | act = ((struct ccw1 *)(addr_t) irb->scsw.cmd.cpa) - 2; | |
773bab4a | 535 | len += sprintf(page + len, PRINTK_HEADER "......\n"); |
1da177e4 | 536 | } |
23d805b6 | 537 | end = min((struct ccw1 *)(addr_t) irb->scsw.cmd.cpa + 2, last); |
1da177e4 | 538 | while (act <= end) { |
773bab4a | 539 | len += sprintf(page + len, PRINTK_HEADER |
1da177e4 LT |
540 | " CCW %p: %08X %08X DAT:", |
541 | act, ((int *) act)[0], ((int *) act)[1]); | |
542 | for (count = 0; count < 32 && count < act->count; | |
543 | count += sizeof(int)) | |
544 | len += sprintf(page + len, " %08X", | |
545 | ((int *) (addr_t) act->cda) | |
546 | [(count>>2)]); | |
547 | len += sprintf(page + len, "\n"); | |
548 | act++; | |
549 | } | |
550 | ||
551 | /* print last CCWs */ | |
552 | if (act < last - 2) { | |
553 | act = last - 2; | |
773bab4a | 554 | len += sprintf(page + len, PRINTK_HEADER "......\n"); |
1da177e4 LT |
555 | } |
556 | while (act <= last) { | |
773bab4a | 557 | len += sprintf(page + len, PRINTK_HEADER |
1da177e4 LT |
558 | " CCW %p: %08X %08X DAT:", |
559 | act, ((int *) act)[0], ((int *) act)[1]); | |
560 | for (count = 0; count < 32 && count < act->count; | |
561 | count += sizeof(int)) | |
562 | len += sprintf(page + len, " %08X", | |
563 | ((int *) (addr_t) act->cda) | |
564 | [(count>>2)]); | |
565 | len += sprintf(page + len, "\n"); | |
566 | act++; | |
567 | } | |
568 | if (len > 0) | |
fc19f381 | 569 | printk(KERN_ERR "%s", page); |
1da177e4 LT |
570 | free_page((unsigned long) page); |
571 | } | |
572 | ||
573 | /* | |
574 | * max_blocks is dependent on the amount of storage that is available | |
575 | * in the static io buffer for each device. Currently each device has | |
576 | * 8192 bytes (=2 pages). For 64 bit one dasd_mchunkt_t structure has | |
577 | * 24 bytes, the struct dasd_ccw_req has 136 bytes and each block can use | |
578 | * up to 16 bytes (8 for the ccw and 8 for the idal pointer). In | |
138c014d | 579 | * addition we have one define extent ccw + 16 bytes of data and a |
1da177e4 LT |
580 | * locate record ccw for each block (stupid devices!) + 16 bytes of data. |
581 | * That makes: | |
582 | * (8192 - 24 - 136 - 8 - 16) / 40 = 200.2 blocks at maximum. | |
583 | * We want to fit two into the available memory so that we can immediately | |
584 | * start the next request if one finishes off. That makes 100.1 blocks | |
585 | * for one request. Give a little safety and the result is 96. | |
586 | */ | |
587 | static struct dasd_discipline dasd_fba_discipline = { | |
588 | .owner = THIS_MODULE, | |
589 | .name = "FBA ", | |
590 | .ebcname = "FBA ", | |
591 | .max_blocks = 96, | |
592 | .check_device = dasd_fba_check_characteristics, | |
593 | .do_analysis = dasd_fba_do_analysis, | |
a4d26c6a | 594 | .verify_path = dasd_generic_verify_path, |
1da177e4 LT |
595 | .fill_geometry = dasd_fba_fill_geometry, |
596 | .start_IO = dasd_start_IO, | |
597 | .term_IO = dasd_term_IO, | |
8e09f215 | 598 | .handle_terminated_request = dasd_fba_handle_terminated_request, |
1da177e4 LT |
599 | .erp_action = dasd_fba_erp_action, |
600 | .erp_postaction = dasd_fba_erp_postaction, | |
5a27e60d | 601 | .check_for_device_change = dasd_fba_check_for_device_change, |
1da177e4 LT |
602 | .build_cp = dasd_fba_build_cp, |
603 | .free_cp = dasd_fba_free_cp, | |
604 | .dump_sense = dasd_fba_dump_sense, | |
fc19f381 | 605 | .dump_sense_dbf = dasd_fba_dump_sense_dbf, |
1da177e4 LT |
606 | .fill_info = dasd_fba_fill_info, |
607 | }; | |
608 | ||
609 | static int __init | |
610 | dasd_fba_init(void) | |
611 | { | |
736e6ea0 SO |
612 | int ret; |
613 | ||
1da177e4 | 614 | ASCEBC(dasd_fba_discipline.ebcname, 4); |
736e6ea0 SO |
615 | ret = ccw_driver_register(&dasd_fba_driver); |
616 | if (!ret) | |
617 | wait_for_device_probe(); | |
618 | ||
619 | return ret; | |
1da177e4 LT |
620 | } |
621 | ||
622 | static void __exit | |
623 | dasd_fba_cleanup(void) | |
624 | { | |
625 | ccw_driver_unregister(&dasd_fba_driver); | |
626 | } | |
627 | ||
628 | module_init(dasd_fba_init); | |
629 | module_exit(dasd_fba_cleanup); |