11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * File...........: linux/drivers/s390/block/dasd_fba.c 31da177e4SLinus Torvalds * Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com> 41da177e4SLinus Torvalds * Bugreports.to..: <Linux390@de.ibm.com> 51da177e4SLinus Torvalds * (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999,2000 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds */ 81da177e4SLinus Torvalds 9fc19f381SStefan Haberland #define KMSG_COMPONENT "dasd" 10fc19f381SStefan Haberland 111da177e4SLinus Torvalds #include <linux/stddef.h> 121da177e4SLinus Torvalds #include <linux/kernel.h> 131da177e4SLinus Torvalds #include <asm/debug.h> 141da177e4SLinus Torvalds 151da177e4SLinus Torvalds #include <linux/slab.h> 161da177e4SLinus Torvalds #include <linux/hdreg.h> /* HDIO_GETGEO */ 171da177e4SLinus Torvalds #include <linux/bio.h> 181da177e4SLinus Torvalds #include <linux/module.h> 191da177e4SLinus Torvalds #include <linux/init.h> 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds #include <asm/idals.h> 221da177e4SLinus Torvalds #include <asm/ebcdic.h> 231da177e4SLinus Torvalds #include <asm/io.h> 241da177e4SLinus Torvalds #include <asm/todclk.h> 251da177e4SLinus Torvalds #include <asm/ccwdev.h> 261da177e4SLinus Torvalds 271da177e4SLinus Torvalds #include "dasd_int.h" 281da177e4SLinus Torvalds #include "dasd_fba.h" 291da177e4SLinus Torvalds 301da177e4SLinus Torvalds #ifdef PRINTK_HEADER 311da177e4SLinus Torvalds #undef PRINTK_HEADER 321da177e4SLinus Torvalds #endif /* PRINTK_HEADER */ 331da177e4SLinus Torvalds #define PRINTK_HEADER "dasd(fba):" 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #define DASD_FBA_CCW_WRITE 0x41 361da177e4SLinus Torvalds #define DASD_FBA_CCW_READ 0x42 371da177e4SLinus Torvalds #define DASD_FBA_CCW_LOCATE 0x43 381da177e4SLinus Torvalds #define DASD_FBA_CCW_DEFINE_EXTENT 0x63 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds static struct dasd_discipline dasd_fba_discipline; 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds struct dasd_fba_private { 451da177e4SLinus Torvalds struct dasd_fba_characteristics rdc_data; 461da177e4SLinus Torvalds }; 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds static struct ccw_device_id dasd_fba_ids[] = { 49d2c993d8SHeiko Carstens { CCW_DEVICE_DEVTYPE (0x6310, 0, 0x9336, 0), .driver_info = 0x1}, 50d2c993d8SHeiko Carstens { CCW_DEVICE_DEVTYPE (0x3880, 0, 0x3370, 0), .driver_info = 0x2}, 511da177e4SLinus Torvalds { /* end of list */ }, 521da177e4SLinus Torvalds }; 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds MODULE_DEVICE_TABLE(ccw, dasd_fba_ids); 551da177e4SLinus Torvalds 561da177e4SLinus Torvalds static struct ccw_driver dasd_fba_driver; /* see below */ 571da177e4SLinus Torvalds static int 581da177e4SLinus Torvalds dasd_fba_probe(struct ccw_device *cdev) 591da177e4SLinus Torvalds { 6040545573SHorst Hummel return dasd_generic_probe(cdev, &dasd_fba_discipline); 611da177e4SLinus Torvalds } 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds static int 641da177e4SLinus Torvalds dasd_fba_set_online(struct ccw_device *cdev) 651da177e4SLinus Torvalds { 661da177e4SLinus Torvalds return dasd_generic_set_online(cdev, &dasd_fba_discipline); 671da177e4SLinus Torvalds } 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds static struct ccw_driver dasd_fba_driver = { 701da177e4SLinus Torvalds .name = "dasd-fba", 711da177e4SLinus Torvalds .owner = THIS_MODULE, 721da177e4SLinus Torvalds .ids = dasd_fba_ids, 731da177e4SLinus Torvalds .probe = dasd_fba_probe, 741da177e4SLinus Torvalds .remove = dasd_generic_remove, 751da177e4SLinus Torvalds .set_offline = dasd_generic_set_offline, 761da177e4SLinus Torvalds .set_online = dasd_fba_set_online, 771da177e4SLinus Torvalds .notify = dasd_generic_notify, 781da177e4SLinus Torvalds }; 791da177e4SLinus Torvalds 804d284cacSHeiko Carstens static void 811da177e4SLinus Torvalds define_extent(struct ccw1 * ccw, struct DE_fba_data *data, int rw, 821da177e4SLinus Torvalds int blksize, int beg, int nr) 831da177e4SLinus Torvalds { 841da177e4SLinus Torvalds ccw->cmd_code = DASD_FBA_CCW_DEFINE_EXTENT; 851da177e4SLinus Torvalds ccw->flags = 0; 861da177e4SLinus Torvalds ccw->count = 16; 871da177e4SLinus Torvalds ccw->cda = (__u32) __pa(data); 881da177e4SLinus Torvalds memset(data, 0, sizeof (struct DE_fba_data)); 891da177e4SLinus Torvalds if (rw == WRITE) 901da177e4SLinus Torvalds (data->mask).perm = 0x0; 911da177e4SLinus Torvalds else if (rw == READ) 921da177e4SLinus Torvalds (data->mask).perm = 0x1; 931da177e4SLinus Torvalds else 941da177e4SLinus Torvalds data->mask.perm = 0x2; 951da177e4SLinus Torvalds data->blk_size = blksize; 961da177e4SLinus Torvalds data->ext_loc = beg; 971da177e4SLinus Torvalds data->ext_end = nr - 1; 981da177e4SLinus Torvalds } 991da177e4SLinus Torvalds 1004d284cacSHeiko Carstens static void 1011da177e4SLinus Torvalds locate_record(struct ccw1 * ccw, struct LO_fba_data *data, int rw, 1021da177e4SLinus Torvalds int block_nr, int block_ct) 1031da177e4SLinus Torvalds { 1041da177e4SLinus Torvalds ccw->cmd_code = DASD_FBA_CCW_LOCATE; 1051da177e4SLinus Torvalds ccw->flags = 0; 1061da177e4SLinus Torvalds ccw->count = 8; 1071da177e4SLinus Torvalds ccw->cda = (__u32) __pa(data); 1081da177e4SLinus Torvalds memset(data, 0, sizeof (struct LO_fba_data)); 1091da177e4SLinus Torvalds if (rw == WRITE) 1101da177e4SLinus Torvalds data->operation.cmd = 0x5; 1111da177e4SLinus Torvalds else if (rw == READ) 1121da177e4SLinus Torvalds data->operation.cmd = 0x6; 1131da177e4SLinus Torvalds else 1141da177e4SLinus Torvalds data->operation.cmd = 0x8; 1151da177e4SLinus Torvalds data->blk_nr = block_nr; 1161da177e4SLinus Torvalds data->blk_ct = block_ct; 1171da177e4SLinus Torvalds } 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds static int 1201da177e4SLinus Torvalds dasd_fba_check_characteristics(struct dasd_device *device) 1211da177e4SLinus Torvalds { 1228e09f215SStefan Weinhuber struct dasd_block *block; 1231da177e4SLinus Torvalds struct dasd_fba_private *private; 1241da177e4SLinus Torvalds struct ccw_device *cdev = device->cdev; 1251da177e4SLinus Torvalds int rc; 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds private = (struct dasd_fba_private *) device->private; 12892636b15SSebastian Ott if (!private) { 12992636b15SSebastian Ott private = kzalloc(sizeof(*private), GFP_KERNEL | GFP_DMA); 13092636b15SSebastian Ott if (!private) { 131fc19f381SStefan Haberland dev_warn(&device->cdev->dev, 132fc19f381SStefan Haberland "Allocating memory for private DASD " 133fc19f381SStefan Haberland "data failed\n"); 1341da177e4SLinus Torvalds return -ENOMEM; 1351da177e4SLinus Torvalds } 1361da177e4SLinus Torvalds device->private = (void *) private; 13792636b15SSebastian Ott } else { 13892636b15SSebastian Ott memset(private, 0, sizeof(*private)); 1391da177e4SLinus Torvalds } 1408e09f215SStefan Weinhuber block = dasd_alloc_block(); 1418e09f215SStefan Weinhuber if (IS_ERR(block)) { 142fc19f381SStefan Haberland DBF_EVENT(DBF_WARNING, "could not allocate dasd block " 143fc19f381SStefan Haberland "structure for device: %s", 144fc19f381SStefan Haberland dev_name(&device->cdev->dev)); 1457337194fSCornelia Huck device->private = NULL; 1467337194fSCornelia Huck kfree(private); 1478e09f215SStefan Weinhuber return PTR_ERR(block); 1488e09f215SStefan Weinhuber } 1498e09f215SStefan Weinhuber device->block = block; 1508e09f215SStefan Weinhuber block->base = device; 1518e09f215SStefan Weinhuber 1521da177e4SLinus Torvalds /* Read Device Characteristics */ 15392636b15SSebastian Ott rc = dasd_generic_read_dev_chars(device, "FBA ", &private->rdc_data, 15492636b15SSebastian Ott 32); 1551da177e4SLinus Torvalds if (rc) { 156fc19f381SStefan Haberland DBF_EVENT(DBF_WARNING, "Read device characteristics returned " 157fc19f381SStefan Haberland "error %d for device: %s", 158fc19f381SStefan Haberland rc, dev_name(&device->cdev->dev)); 1597337194fSCornelia Huck device->block = NULL; 1607337194fSCornelia Huck dasd_free_block(block); 1617337194fSCornelia Huck device->private = NULL; 1627337194fSCornelia Huck kfree(private); 1631da177e4SLinus Torvalds return rc; 1641da177e4SLinus Torvalds } 1651da177e4SLinus Torvalds 166fc19f381SStefan Haberland dev_info(&device->cdev->dev, 167fc19f381SStefan Haberland "New FBA DASD %04X/%02X (CU %04X/%02X) with %d MB " 168fc19f381SStefan Haberland "and %d B/blk\n", 1691da177e4SLinus Torvalds cdev->id.dev_type, 1701da177e4SLinus Torvalds cdev->id.dev_model, 1711da177e4SLinus Torvalds cdev->id.cu_type, 1721da177e4SLinus Torvalds cdev->id.cu_model, 1731da177e4SLinus Torvalds ((private->rdc_data.blk_bdsa * 1741da177e4SLinus Torvalds (private->rdc_data.blk_size >> 9)) >> 11), 1751da177e4SLinus Torvalds private->rdc_data.blk_size); 1761da177e4SLinus Torvalds return 0; 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds 1798e09f215SStefan Weinhuber static int dasd_fba_do_analysis(struct dasd_block *block) 1801da177e4SLinus Torvalds { 1811da177e4SLinus Torvalds struct dasd_fba_private *private; 1821da177e4SLinus Torvalds int sb, rc; 1831da177e4SLinus Torvalds 1848e09f215SStefan Weinhuber private = (struct dasd_fba_private *) block->base->private; 1851da177e4SLinus Torvalds rc = dasd_check_blocksize(private->rdc_data.blk_size); 1861da177e4SLinus Torvalds if (rc) { 187fc19f381SStefan Haberland DBF_DEV_EVENT(DBF_WARNING, block->base, "unknown blocksize %d", 1881da177e4SLinus Torvalds private->rdc_data.blk_size); 1891da177e4SLinus Torvalds return rc; 1901da177e4SLinus Torvalds } 1918e09f215SStefan Weinhuber block->blocks = private->rdc_data.blk_bdsa; 1928e09f215SStefan Weinhuber block->bp_block = private->rdc_data.blk_size; 1938e09f215SStefan Weinhuber block->s2b_shift = 0; /* bits to shift 512 to get a block */ 1941da177e4SLinus Torvalds for (sb = 512; sb < private->rdc_data.blk_size; sb = sb << 1) 1958e09f215SStefan Weinhuber block->s2b_shift++; 1961da177e4SLinus Torvalds return 0; 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds 1998e09f215SStefan Weinhuber static int dasd_fba_fill_geometry(struct dasd_block *block, 2008e09f215SStefan Weinhuber struct hd_geometry *geo) 2011da177e4SLinus Torvalds { 2028e09f215SStefan Weinhuber if (dasd_check_blocksize(block->bp_block) != 0) 2031da177e4SLinus Torvalds return -EINVAL; 2048e09f215SStefan Weinhuber geo->cylinders = (block->blocks << block->s2b_shift) >> 10; 2051da177e4SLinus Torvalds geo->heads = 16; 2068e09f215SStefan Weinhuber geo->sectors = 128 >> block->s2b_shift; 2071da177e4SLinus Torvalds return 0; 2081da177e4SLinus Torvalds } 2091da177e4SLinus Torvalds 2101da177e4SLinus Torvalds static dasd_erp_fn_t 2111da177e4SLinus Torvalds dasd_fba_erp_action(struct dasd_ccw_req * cqr) 2121da177e4SLinus Torvalds { 2131da177e4SLinus Torvalds return dasd_default_erp_action; 2141da177e4SLinus Torvalds } 2151da177e4SLinus Torvalds 2161da177e4SLinus Torvalds static dasd_erp_fn_t 2171da177e4SLinus Torvalds dasd_fba_erp_postaction(struct dasd_ccw_req * cqr) 2181da177e4SLinus Torvalds { 2191da177e4SLinus Torvalds if (cqr->function == dasd_default_erp_action) 2201da177e4SLinus Torvalds return dasd_default_erp_postaction; 2211da177e4SLinus Torvalds 222fc19f381SStefan Haberland DBF_DEV_EVENT(DBF_WARNING, cqr->startdev, "unknown ERP action %p", 2231da177e4SLinus Torvalds cqr->function); 2241da177e4SLinus Torvalds return NULL; 2251da177e4SLinus Torvalds } 2261da177e4SLinus Torvalds 2278e09f215SStefan Weinhuber static void dasd_fba_handle_unsolicited_interrupt(struct dasd_device *device, 2288e09f215SStefan Weinhuber struct irb *irb) 2298e09f215SStefan Weinhuber { 2308e09f215SStefan Weinhuber char mask; 2318e09f215SStefan Weinhuber 2328e09f215SStefan Weinhuber /* first of all check for state change pending interrupt */ 2338e09f215SStefan Weinhuber mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP; 23423d805b6SPeter Oberparleiter if ((irb->scsw.cmd.dstat & mask) == mask) { 2358e09f215SStefan Weinhuber dasd_generic_handle_state_change(device); 2368e09f215SStefan Weinhuber return; 2378e09f215SStefan Weinhuber } 2388e09f215SStefan Weinhuber 2398e09f215SStefan Weinhuber /* check for unsolicited interrupts */ 240fc19f381SStefan Haberland DBF_DEV_EVENT(DBF_WARNING, device, "%s", 2418e09f215SStefan Weinhuber "unsolicited interrupt received"); 242fc19f381SStefan Haberland device->discipline->dump_sense_dbf(device, NULL, irb, "unsolicited"); 2438e09f215SStefan Weinhuber dasd_schedule_device_bh(device); 2448e09f215SStefan Weinhuber return; 2458e09f215SStefan Weinhuber }; 2468e09f215SStefan Weinhuber 2478e09f215SStefan Weinhuber static struct dasd_ccw_req *dasd_fba_build_cp(struct dasd_device * memdev, 2488e09f215SStefan Weinhuber struct dasd_block *block, 2498e09f215SStefan Weinhuber struct request *req) 2501da177e4SLinus Torvalds { 2511da177e4SLinus Torvalds struct dasd_fba_private *private; 2521da177e4SLinus Torvalds unsigned long *idaws; 2531da177e4SLinus Torvalds struct LO_fba_data *LO_data; 2541da177e4SLinus Torvalds struct dasd_ccw_req *cqr; 2551da177e4SLinus Torvalds struct ccw1 *ccw; 2565705f702SNeilBrown struct req_iterator iter; 2571da177e4SLinus Torvalds struct bio_vec *bv; 2581da177e4SLinus Torvalds char *dst; 2591da177e4SLinus Torvalds int count, cidaw, cplength, datasize; 2601da177e4SLinus Torvalds sector_t recid, first_rec, last_rec; 2611da177e4SLinus Torvalds unsigned int blksize, off; 2621da177e4SLinus Torvalds unsigned char cmd; 2631da177e4SLinus Torvalds 2648e09f215SStefan Weinhuber private = (struct dasd_fba_private *) block->base->private; 2651da177e4SLinus Torvalds if (rq_data_dir(req) == READ) { 2661da177e4SLinus Torvalds cmd = DASD_FBA_CCW_READ; 2671da177e4SLinus Torvalds } else if (rq_data_dir(req) == WRITE) { 2681da177e4SLinus Torvalds cmd = DASD_FBA_CCW_WRITE; 2691da177e4SLinus Torvalds } else 2701da177e4SLinus Torvalds return ERR_PTR(-EINVAL); 2718e09f215SStefan Weinhuber blksize = block->bp_block; 2721da177e4SLinus Torvalds /* Calculate record id of first and last block. */ 27383096ebfSTejun Heo first_rec = blk_rq_pos(req) >> block->s2b_shift; 27483096ebfSTejun Heo last_rec = 27583096ebfSTejun Heo (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift; 2761da177e4SLinus Torvalds /* Check struct bio and count the number of blocks for the request. */ 2771da177e4SLinus Torvalds count = 0; 2781da177e4SLinus Torvalds cidaw = 0; 2795705f702SNeilBrown rq_for_each_segment(bv, req, iter) { 2801da177e4SLinus Torvalds if (bv->bv_len & (blksize - 1)) 2811da177e4SLinus Torvalds /* Fba can only do full blocks. */ 2821da177e4SLinus Torvalds return ERR_PTR(-EINVAL); 2838e09f215SStefan Weinhuber count += bv->bv_len >> (block->s2b_shift + 9); 284347a8dc3SMartin Schwidefsky #if defined(CONFIG_64BIT) 2856c92e699SJens Axboe if (idal_is_needed (page_address(bv->bv_page), bv->bv_len)) 2861da177e4SLinus Torvalds cidaw += bv->bv_len / blksize; 2871da177e4SLinus Torvalds #endif 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds /* Paranoia. */ 2901da177e4SLinus Torvalds if (count != last_rec - first_rec + 1) 2911da177e4SLinus Torvalds return ERR_PTR(-EINVAL); 2921da177e4SLinus Torvalds /* 1x define extent + 1x locate record + number of blocks */ 2931da177e4SLinus Torvalds cplength = 2 + count; 2941da177e4SLinus Torvalds /* 1x define extent + 1x locate record */ 2951da177e4SLinus Torvalds datasize = sizeof(struct DE_fba_data) + sizeof(struct LO_fba_data) + 2961da177e4SLinus Torvalds cidaw * sizeof(unsigned long); 2971da177e4SLinus Torvalds /* 2981da177e4SLinus Torvalds * Find out number of additional locate record ccws if the device 2991da177e4SLinus Torvalds * can't do data chaining. 3001da177e4SLinus Torvalds */ 3011da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain == 0) { 3021da177e4SLinus Torvalds cplength += count - 1; 3031da177e4SLinus Torvalds datasize += (count - 1)*sizeof(struct LO_fba_data); 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds /* Allocate the ccw request. */ 3061da177e4SLinus Torvalds cqr = dasd_smalloc_request(dasd_fba_discipline.name, 3078e09f215SStefan Weinhuber cplength, datasize, memdev); 3081da177e4SLinus Torvalds if (IS_ERR(cqr)) 3091da177e4SLinus Torvalds return cqr; 3101da177e4SLinus Torvalds ccw = cqr->cpaddr; 3111da177e4SLinus Torvalds /* First ccw is define extent. */ 3121da177e4SLinus Torvalds define_extent(ccw++, cqr->data, rq_data_dir(req), 31383096ebfSTejun Heo block->bp_block, blk_rq_pos(req), blk_rq_sectors(req)); 3141da177e4SLinus Torvalds /* Build locate_record + read/write ccws. */ 3151da177e4SLinus Torvalds idaws = (unsigned long *) (cqr->data + sizeof(struct DE_fba_data)); 3161da177e4SLinus Torvalds LO_data = (struct LO_fba_data *) (idaws + cidaw); 3171da177e4SLinus Torvalds /* Locate record for all blocks for smart devices. */ 3181da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain != 0) { 3191da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_CC; 3201da177e4SLinus Torvalds locate_record(ccw++, LO_data++, rq_data_dir(req), 0, count); 3211da177e4SLinus Torvalds } 3221da177e4SLinus Torvalds recid = first_rec; 3235705f702SNeilBrown rq_for_each_segment(bv, req, iter) { 3241da177e4SLinus Torvalds dst = page_address(bv->bv_page) + bv->bv_offset; 3251da177e4SLinus Torvalds if (dasd_page_cache) { 3261da177e4SLinus Torvalds char *copy = kmem_cache_alloc(dasd_page_cache, 327441e143eSChristoph Lameter GFP_DMA | __GFP_NOWARN); 3281da177e4SLinus Torvalds if (copy && rq_data_dir(req) == WRITE) 3291da177e4SLinus Torvalds memcpy(copy + bv->bv_offset, dst, bv->bv_len); 3301da177e4SLinus Torvalds if (copy) 3311da177e4SLinus Torvalds dst = copy + bv->bv_offset; 3321da177e4SLinus Torvalds } 3331da177e4SLinus Torvalds for (off = 0; off < bv->bv_len; off += blksize) { 3341da177e4SLinus Torvalds /* Locate record for stupid devices. */ 3351da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain == 0) { 3361da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_CC; 3371da177e4SLinus Torvalds locate_record(ccw, LO_data++, 3381da177e4SLinus Torvalds rq_data_dir(req), 3391da177e4SLinus Torvalds recid - first_rec, 1); 3401da177e4SLinus Torvalds ccw->flags = CCW_FLAG_CC; 3411da177e4SLinus Torvalds ccw++; 3421da177e4SLinus Torvalds } else { 3431da177e4SLinus Torvalds if (recid > first_rec) 3441da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_DC; 3451da177e4SLinus Torvalds else 3461da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_CC; 3471da177e4SLinus Torvalds } 3481da177e4SLinus Torvalds ccw->cmd_code = cmd; 3498e09f215SStefan Weinhuber ccw->count = block->bp_block; 3501da177e4SLinus Torvalds if (idal_is_needed(dst, blksize)) { 3511da177e4SLinus Torvalds ccw->cda = (__u32)(addr_t) idaws; 3521da177e4SLinus Torvalds ccw->flags = CCW_FLAG_IDA; 3531da177e4SLinus Torvalds idaws = idal_create_words(idaws, dst, blksize); 3541da177e4SLinus Torvalds } else { 3551da177e4SLinus Torvalds ccw->cda = (__u32)(addr_t) dst; 3561da177e4SLinus Torvalds ccw->flags = 0; 3571da177e4SLinus Torvalds } 3581da177e4SLinus Torvalds ccw++; 3591da177e4SLinus Torvalds dst += blksize; 3601da177e4SLinus Torvalds recid++; 3611da177e4SLinus Torvalds } 3621da177e4SLinus Torvalds } 36313de227bSHolger Smolinski if (blk_noretry_request(req) || 36413de227bSHolger Smolinski block->base->features & DASD_FEATURE_FAILFAST) 3651c01b8a5SHorst Hummel set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 3668e09f215SStefan Weinhuber cqr->startdev = memdev; 3678e09f215SStefan Weinhuber cqr->memdev = memdev; 3688e09f215SStefan Weinhuber cqr->block = block; 3691da177e4SLinus Torvalds cqr->expires = 5 * 60 * HZ; /* 5 minutes */ 370d61f6f3dSHorst Hummel cqr->retries = 32; 371d61f6f3dSHorst Hummel cqr->buildclk = get_clock(); 3721da177e4SLinus Torvalds cqr->status = DASD_CQR_FILLED; 3731da177e4SLinus Torvalds return cqr; 3741da177e4SLinus Torvalds } 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds static int 3771da177e4SLinus Torvalds dasd_fba_free_cp(struct dasd_ccw_req *cqr, struct request *req) 3781da177e4SLinus Torvalds { 3791da177e4SLinus Torvalds struct dasd_fba_private *private; 3801da177e4SLinus Torvalds struct ccw1 *ccw; 3815705f702SNeilBrown struct req_iterator iter; 3821da177e4SLinus Torvalds struct bio_vec *bv; 3831da177e4SLinus Torvalds char *dst, *cda; 3841da177e4SLinus Torvalds unsigned int blksize, off; 3855705f702SNeilBrown int status; 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds if (!dasd_page_cache) 3881da177e4SLinus Torvalds goto out; 3898e09f215SStefan Weinhuber private = (struct dasd_fba_private *) cqr->block->base->private; 3908e09f215SStefan Weinhuber blksize = cqr->block->bp_block; 3911da177e4SLinus Torvalds ccw = cqr->cpaddr; 3921da177e4SLinus Torvalds /* Skip over define extent & locate record. */ 3931da177e4SLinus Torvalds ccw++; 3941da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain != 0) 3951da177e4SLinus Torvalds ccw++; 3965705f702SNeilBrown rq_for_each_segment(bv, req, iter) { 3971da177e4SLinus Torvalds dst = page_address(bv->bv_page) + bv->bv_offset; 3981da177e4SLinus Torvalds for (off = 0; off < bv->bv_len; off += blksize) { 3991da177e4SLinus Torvalds /* Skip locate record. */ 4001da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain == 0) 4011da177e4SLinus Torvalds ccw++; 4021da177e4SLinus Torvalds if (dst) { 4031da177e4SLinus Torvalds if (ccw->flags & CCW_FLAG_IDA) 4041da177e4SLinus Torvalds cda = *((char **)((addr_t) ccw->cda)); 4051da177e4SLinus Torvalds else 4061da177e4SLinus Torvalds cda = (char *)((addr_t) ccw->cda); 4071da177e4SLinus Torvalds if (dst != cda) { 4081da177e4SLinus Torvalds if (rq_data_dir(req) == READ) 4091da177e4SLinus Torvalds memcpy(dst, cda, bv->bv_len); 4101da177e4SLinus Torvalds kmem_cache_free(dasd_page_cache, 4111da177e4SLinus Torvalds (void *)((addr_t)cda & PAGE_MASK)); 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds dst = NULL; 4141da177e4SLinus Torvalds } 4151da177e4SLinus Torvalds ccw++; 4161da177e4SLinus Torvalds } 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds out: 4191da177e4SLinus Torvalds status = cqr->status == DASD_CQR_DONE; 4208e09f215SStefan Weinhuber dasd_sfree_request(cqr, cqr->memdev); 4211da177e4SLinus Torvalds return status; 4221da177e4SLinus Torvalds } 4231da177e4SLinus Torvalds 4248e09f215SStefan Weinhuber static void dasd_fba_handle_terminated_request(struct dasd_ccw_req *cqr) 4258e09f215SStefan Weinhuber { 4268e09f215SStefan Weinhuber cqr->status = DASD_CQR_FILLED; 4278e09f215SStefan Weinhuber }; 4288e09f215SStefan Weinhuber 4291da177e4SLinus Torvalds static int 4301da177e4SLinus Torvalds dasd_fba_fill_info(struct dasd_device * device, 4311da177e4SLinus Torvalds struct dasd_information2_t * info) 4321da177e4SLinus Torvalds { 4331da177e4SLinus Torvalds info->label_block = 1; 4341da177e4SLinus Torvalds info->FBA_layout = 1; 4351da177e4SLinus Torvalds info->format = DASD_FORMAT_LDL; 4361da177e4SLinus Torvalds info->characteristics_size = sizeof(struct dasd_fba_characteristics); 4371da177e4SLinus Torvalds memcpy(info->characteristics, 4381da177e4SLinus Torvalds &((struct dasd_fba_private *) device->private)->rdc_data, 4391da177e4SLinus Torvalds sizeof (struct dasd_fba_characteristics)); 4401da177e4SLinus Torvalds info->confdata_size = 0; 4411da177e4SLinus Torvalds return 0; 4421da177e4SLinus Torvalds } 4431da177e4SLinus Torvalds 4441da177e4SLinus Torvalds static void 445fc19f381SStefan Haberland dasd_fba_dump_sense_dbf(struct dasd_device *device, struct dasd_ccw_req *req, 446fc19f381SStefan Haberland struct irb *irb, char *reason) 447fc19f381SStefan Haberland { 448fc19f381SStefan Haberland int sl; 449fc19f381SStefan Haberland if (irb->esw.esw0.erw.cons) { 450fc19f381SStefan Haberland for (sl = 0; sl < 4; sl++) { 451fc19f381SStefan Haberland DBF_DEV_EVENT(DBF_EMERG, device, 452fc19f381SStefan Haberland "%s: %08x %08x %08x %08x", 453fc19f381SStefan Haberland reason, irb->ecw[8 * 0], irb->ecw[8 * 1], 454fc19f381SStefan Haberland irb->ecw[8 * 2], irb->ecw[8 * 3]); 455fc19f381SStefan Haberland } 456fc19f381SStefan Haberland } else { 457fc19f381SStefan Haberland DBF_DEV_EVENT(DBF_EMERG, device, "%s", 458fc19f381SStefan Haberland "SORRY - NO VALID SENSE AVAILABLE\n"); 459fc19f381SStefan Haberland } 460fc19f381SStefan Haberland } 461fc19f381SStefan Haberland 462fc19f381SStefan Haberland 463fc19f381SStefan Haberland static void 4641da177e4SLinus Torvalds dasd_fba_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req, 4651da177e4SLinus Torvalds struct irb *irb) 4661da177e4SLinus Torvalds { 4671da177e4SLinus Torvalds char *page; 4681da177e4SLinus Torvalds struct ccw1 *act, *end, *last; 4691da177e4SLinus Torvalds int len, sl, sct, count; 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds page = (char *) get_zeroed_page(GFP_ATOMIC); 4721da177e4SLinus Torvalds if (page == NULL) { 473fc19f381SStefan Haberland DBF_DEV_EVENT(DBF_WARNING, device, "%s", 4741da177e4SLinus Torvalds "No memory to dump sense data"); 4751da177e4SLinus Torvalds return; 4761da177e4SLinus Torvalds } 4771da177e4SLinus Torvalds len = sprintf(page, KERN_ERR PRINTK_HEADER 4781da177e4SLinus Torvalds " I/O status report for device %s:\n", 4792a0217d5SKay Sievers dev_name(&device->cdev->dev)); 4801da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4811da177e4SLinus Torvalds " in req: %p CS: 0x%02X DS: 0x%02X\n", req, 48223d805b6SPeter Oberparleiter irb->scsw.cmd.cstat, irb->scsw.cmd.dstat); 4831da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4841da177e4SLinus Torvalds " device %s: Failing CCW: %p\n", 4852a0217d5SKay Sievers dev_name(&device->cdev->dev), 48623d805b6SPeter Oberparleiter (void *) (addr_t) irb->scsw.cmd.cpa); 4871da177e4SLinus Torvalds if (irb->esw.esw0.erw.cons) { 4881da177e4SLinus Torvalds for (sl = 0; sl < 4; sl++) { 4891da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4901da177e4SLinus Torvalds " Sense(hex) %2d-%2d:", 4911da177e4SLinus Torvalds (8 * sl), ((8 * sl) + 7)); 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds for (sct = 0; sct < 8; sct++) { 4941da177e4SLinus Torvalds len += sprintf(page + len, " %02x", 4951da177e4SLinus Torvalds irb->ecw[8 * sl + sct]); 4961da177e4SLinus Torvalds } 4971da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 4981da177e4SLinus Torvalds } 4991da177e4SLinus Torvalds } else { 5001da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 5011da177e4SLinus Torvalds " SORRY - NO VALID SENSE AVAILABLE\n"); 5021da177e4SLinus Torvalds } 503fc19f381SStefan Haberland printk(KERN_ERR "%s", page); 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds /* dump the Channel Program */ 5061da177e4SLinus Torvalds /* print first CCWs (maximum 8) */ 5071da177e4SLinus Torvalds act = req->cpaddr; 5081da177e4SLinus Torvalds for (last = act; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++); 5091da177e4SLinus Torvalds end = min(act + 8, last); 5101da177e4SLinus Torvalds len = sprintf(page, KERN_ERR PRINTK_HEADER 5111da177e4SLinus Torvalds " Related CP in req: %p\n", req); 5121da177e4SLinus Torvalds while (act <= end) { 5131da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 5141da177e4SLinus Torvalds " CCW %p: %08X %08X DAT:", 5151da177e4SLinus Torvalds act, ((int *) act)[0], ((int *) act)[1]); 5161da177e4SLinus Torvalds for (count = 0; count < 32 && count < act->count; 5171da177e4SLinus Torvalds count += sizeof(int)) 5181da177e4SLinus Torvalds len += sprintf(page + len, " %08X", 5191da177e4SLinus Torvalds ((int *) (addr_t) act->cda) 5201da177e4SLinus Torvalds [(count>>2)]); 5211da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 5221da177e4SLinus Torvalds act++; 5231da177e4SLinus Torvalds } 524fc19f381SStefan Haberland printk(KERN_ERR "%s", page); 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds /* print failing CCW area */ 5281da177e4SLinus Torvalds len = 0; 52923d805b6SPeter Oberparleiter if (act < ((struct ccw1 *)(addr_t) irb->scsw.cmd.cpa) - 2) { 53023d805b6SPeter Oberparleiter act = ((struct ccw1 *)(addr_t) irb->scsw.cmd.cpa) - 2; 5311da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER "......\n"); 5321da177e4SLinus Torvalds } 53323d805b6SPeter Oberparleiter end = min((struct ccw1 *)(addr_t) irb->scsw.cmd.cpa + 2, last); 5341da177e4SLinus Torvalds while (act <= end) { 5351da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 5361da177e4SLinus Torvalds " CCW %p: %08X %08X DAT:", 5371da177e4SLinus Torvalds act, ((int *) act)[0], ((int *) act)[1]); 5381da177e4SLinus Torvalds for (count = 0; count < 32 && count < act->count; 5391da177e4SLinus Torvalds count += sizeof(int)) 5401da177e4SLinus Torvalds len += sprintf(page + len, " %08X", 5411da177e4SLinus Torvalds ((int *) (addr_t) act->cda) 5421da177e4SLinus Torvalds [(count>>2)]); 5431da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 5441da177e4SLinus Torvalds act++; 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds /* print last CCWs */ 5481da177e4SLinus Torvalds if (act < last - 2) { 5491da177e4SLinus Torvalds act = last - 2; 5501da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER "......\n"); 5511da177e4SLinus Torvalds } 5521da177e4SLinus Torvalds while (act <= last) { 5531da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 5541da177e4SLinus Torvalds " CCW %p: %08X %08X DAT:", 5551da177e4SLinus Torvalds act, ((int *) act)[0], ((int *) act)[1]); 5561da177e4SLinus Torvalds for (count = 0; count < 32 && count < act->count; 5571da177e4SLinus Torvalds count += sizeof(int)) 5581da177e4SLinus Torvalds len += sprintf(page + len, " %08X", 5591da177e4SLinus Torvalds ((int *) (addr_t) act->cda) 5601da177e4SLinus Torvalds [(count>>2)]); 5611da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 5621da177e4SLinus Torvalds act++; 5631da177e4SLinus Torvalds } 5641da177e4SLinus Torvalds if (len > 0) 565fc19f381SStefan Haberland printk(KERN_ERR "%s", page); 5661da177e4SLinus Torvalds free_page((unsigned long) page); 5671da177e4SLinus Torvalds } 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds /* 5701da177e4SLinus Torvalds * max_blocks is dependent on the amount of storage that is available 5711da177e4SLinus Torvalds * in the static io buffer for each device. Currently each device has 5721da177e4SLinus Torvalds * 8192 bytes (=2 pages). For 64 bit one dasd_mchunkt_t structure has 5731da177e4SLinus Torvalds * 24 bytes, the struct dasd_ccw_req has 136 bytes and each block can use 5741da177e4SLinus Torvalds * up to 16 bytes (8 for the ccw and 8 for the idal pointer). In 5751da177e4SLinus Torvalds * addition we have one define extent ccw + 16 bytes of data and a 5761da177e4SLinus Torvalds * locate record ccw for each block (stupid devices!) + 16 bytes of data. 5771da177e4SLinus Torvalds * That makes: 5781da177e4SLinus Torvalds * (8192 - 24 - 136 - 8 - 16) / 40 = 200.2 blocks at maximum. 5791da177e4SLinus Torvalds * We want to fit two into the available memory so that we can immediately 5801da177e4SLinus Torvalds * start the next request if one finishes off. That makes 100.1 blocks 5811da177e4SLinus Torvalds * for one request. Give a little safety and the result is 96. 5821da177e4SLinus Torvalds */ 5831da177e4SLinus Torvalds static struct dasd_discipline dasd_fba_discipline = { 5841da177e4SLinus Torvalds .owner = THIS_MODULE, 5851da177e4SLinus Torvalds .name = "FBA ", 5861da177e4SLinus Torvalds .ebcname = "FBA ", 5871da177e4SLinus Torvalds .max_blocks = 96, 5881da177e4SLinus Torvalds .check_device = dasd_fba_check_characteristics, 5891da177e4SLinus Torvalds .do_analysis = dasd_fba_do_analysis, 5901da177e4SLinus Torvalds .fill_geometry = dasd_fba_fill_geometry, 5911da177e4SLinus Torvalds .start_IO = dasd_start_IO, 5921da177e4SLinus Torvalds .term_IO = dasd_term_IO, 5938e09f215SStefan Weinhuber .handle_terminated_request = dasd_fba_handle_terminated_request, 5941da177e4SLinus Torvalds .erp_action = dasd_fba_erp_action, 5951da177e4SLinus Torvalds .erp_postaction = dasd_fba_erp_postaction, 5968e09f215SStefan Weinhuber .handle_unsolicited_interrupt = dasd_fba_handle_unsolicited_interrupt, 5971da177e4SLinus Torvalds .build_cp = dasd_fba_build_cp, 5981da177e4SLinus Torvalds .free_cp = dasd_fba_free_cp, 5991da177e4SLinus Torvalds .dump_sense = dasd_fba_dump_sense, 600fc19f381SStefan Haberland .dump_sense_dbf = dasd_fba_dump_sense_dbf, 6011da177e4SLinus Torvalds .fill_info = dasd_fba_fill_info, 6021da177e4SLinus Torvalds }; 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds static int __init 6051da177e4SLinus Torvalds dasd_fba_init(void) 6061da177e4SLinus Torvalds { 607736e6ea0SSebastian Ott int ret; 608736e6ea0SSebastian Ott 6091da177e4SLinus Torvalds ASCEBC(dasd_fba_discipline.ebcname, 4); 610736e6ea0SSebastian Ott ret = ccw_driver_register(&dasd_fba_driver); 611736e6ea0SSebastian Ott if (!ret) 612736e6ea0SSebastian Ott wait_for_device_probe(); 613736e6ea0SSebastian Ott 614736e6ea0SSebastian Ott return ret; 6151da177e4SLinus Torvalds } 6161da177e4SLinus Torvalds 6171da177e4SLinus Torvalds static void __exit 6181da177e4SLinus Torvalds dasd_fba_cleanup(void) 6191da177e4SLinus Torvalds { 6201da177e4SLinus Torvalds ccw_driver_unregister(&dasd_fba_driver); 6211da177e4SLinus Torvalds } 6221da177e4SLinus Torvalds 6231da177e4SLinus Torvalds module_init(dasd_fba_init); 6241da177e4SLinus Torvalds module_exit(dasd_fba_cleanup); 625