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 91da177e4SLinus Torvalds #include <linux/stddef.h> 101da177e4SLinus Torvalds #include <linux/kernel.h> 111da177e4SLinus Torvalds #include <asm/debug.h> 121da177e4SLinus Torvalds 131da177e4SLinus Torvalds #include <linux/slab.h> 141da177e4SLinus Torvalds #include <linux/hdreg.h> /* HDIO_GETGEO */ 151da177e4SLinus Torvalds #include <linux/bio.h> 161da177e4SLinus Torvalds #include <linux/module.h> 171da177e4SLinus Torvalds #include <linux/init.h> 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds #include <asm/idals.h> 201da177e4SLinus Torvalds #include <asm/ebcdic.h> 211da177e4SLinus Torvalds #include <asm/io.h> 221da177e4SLinus Torvalds #include <asm/todclk.h> 231da177e4SLinus Torvalds #include <asm/ccwdev.h> 241da177e4SLinus Torvalds 251da177e4SLinus Torvalds #include "dasd_int.h" 261da177e4SLinus Torvalds #include "dasd_fba.h" 271da177e4SLinus Torvalds 281da177e4SLinus Torvalds #ifdef PRINTK_HEADER 291da177e4SLinus Torvalds #undef PRINTK_HEADER 301da177e4SLinus Torvalds #endif /* PRINTK_HEADER */ 311da177e4SLinus Torvalds #define PRINTK_HEADER "dasd(fba):" 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds #define DASD_FBA_CCW_WRITE 0x41 341da177e4SLinus Torvalds #define DASD_FBA_CCW_READ 0x42 351da177e4SLinus Torvalds #define DASD_FBA_CCW_LOCATE 0x43 361da177e4SLinus Torvalds #define DASD_FBA_CCW_DEFINE_EXTENT 0x63 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds static struct dasd_discipline dasd_fba_discipline; 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds struct dasd_fba_private { 431da177e4SLinus Torvalds struct dasd_fba_characteristics rdc_data; 441da177e4SLinus Torvalds }; 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds static struct ccw_device_id dasd_fba_ids[] = { 47d2c993d8SHeiko Carstens { CCW_DEVICE_DEVTYPE (0x6310, 0, 0x9336, 0), .driver_info = 0x1}, 48d2c993d8SHeiko Carstens { CCW_DEVICE_DEVTYPE (0x3880, 0, 0x3370, 0), .driver_info = 0x2}, 491da177e4SLinus Torvalds { /* end of list */ }, 501da177e4SLinus Torvalds }; 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds MODULE_DEVICE_TABLE(ccw, dasd_fba_ids); 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds static struct ccw_driver dasd_fba_driver; /* see below */ 551da177e4SLinus Torvalds static int 561da177e4SLinus Torvalds dasd_fba_probe(struct ccw_device *cdev) 571da177e4SLinus Torvalds { 5840545573SHorst Hummel return dasd_generic_probe(cdev, &dasd_fba_discipline); 591da177e4SLinus Torvalds } 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds static int 621da177e4SLinus Torvalds dasd_fba_set_online(struct ccw_device *cdev) 631da177e4SLinus Torvalds { 641da177e4SLinus Torvalds return dasd_generic_set_online(cdev, &dasd_fba_discipline); 651da177e4SLinus Torvalds } 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds static struct ccw_driver dasd_fba_driver = { 681da177e4SLinus Torvalds .name = "dasd-fba", 691da177e4SLinus Torvalds .owner = THIS_MODULE, 701da177e4SLinus Torvalds .ids = dasd_fba_ids, 711da177e4SLinus Torvalds .probe = dasd_fba_probe, 721da177e4SLinus Torvalds .remove = dasd_generic_remove, 731da177e4SLinus Torvalds .set_offline = dasd_generic_set_offline, 741da177e4SLinus Torvalds .set_online = dasd_fba_set_online, 751da177e4SLinus Torvalds .notify = dasd_generic_notify, 761da177e4SLinus Torvalds }; 771da177e4SLinus Torvalds 784d284cacSHeiko Carstens static void 791da177e4SLinus Torvalds define_extent(struct ccw1 * ccw, struct DE_fba_data *data, int rw, 801da177e4SLinus Torvalds int blksize, int beg, int nr) 811da177e4SLinus Torvalds { 821da177e4SLinus Torvalds ccw->cmd_code = DASD_FBA_CCW_DEFINE_EXTENT; 831da177e4SLinus Torvalds ccw->flags = 0; 841da177e4SLinus Torvalds ccw->count = 16; 851da177e4SLinus Torvalds ccw->cda = (__u32) __pa(data); 861da177e4SLinus Torvalds memset(data, 0, sizeof (struct DE_fba_data)); 871da177e4SLinus Torvalds if (rw == WRITE) 881da177e4SLinus Torvalds (data->mask).perm = 0x0; 891da177e4SLinus Torvalds else if (rw == READ) 901da177e4SLinus Torvalds (data->mask).perm = 0x1; 911da177e4SLinus Torvalds else 921da177e4SLinus Torvalds data->mask.perm = 0x2; 931da177e4SLinus Torvalds data->blk_size = blksize; 941da177e4SLinus Torvalds data->ext_loc = beg; 951da177e4SLinus Torvalds data->ext_end = nr - 1; 961da177e4SLinus Torvalds } 971da177e4SLinus Torvalds 984d284cacSHeiko Carstens static void 991da177e4SLinus Torvalds locate_record(struct ccw1 * ccw, struct LO_fba_data *data, int rw, 1001da177e4SLinus Torvalds int block_nr, int block_ct) 1011da177e4SLinus Torvalds { 1021da177e4SLinus Torvalds ccw->cmd_code = DASD_FBA_CCW_LOCATE; 1031da177e4SLinus Torvalds ccw->flags = 0; 1041da177e4SLinus Torvalds ccw->count = 8; 1051da177e4SLinus Torvalds ccw->cda = (__u32) __pa(data); 1061da177e4SLinus Torvalds memset(data, 0, sizeof (struct LO_fba_data)); 1071da177e4SLinus Torvalds if (rw == WRITE) 1081da177e4SLinus Torvalds data->operation.cmd = 0x5; 1091da177e4SLinus Torvalds else if (rw == READ) 1101da177e4SLinus Torvalds data->operation.cmd = 0x6; 1111da177e4SLinus Torvalds else 1121da177e4SLinus Torvalds data->operation.cmd = 0x8; 1131da177e4SLinus Torvalds data->blk_nr = block_nr; 1141da177e4SLinus Torvalds data->blk_ct = block_ct; 1151da177e4SLinus Torvalds } 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds static int 1181da177e4SLinus Torvalds dasd_fba_check_characteristics(struct dasd_device *device) 1191da177e4SLinus Torvalds { 1208e09f215SStefan Weinhuber struct dasd_block *block; 1211da177e4SLinus Torvalds struct dasd_fba_private *private; 1221da177e4SLinus Torvalds struct ccw_device *cdev = device->cdev; 1231da177e4SLinus Torvalds void *rdc_data; 1241da177e4SLinus Torvalds int rc; 1251da177e4SLinus Torvalds 1261da177e4SLinus Torvalds private = (struct dasd_fba_private *) device->private; 1271da177e4SLinus Torvalds if (private == NULL) { 12800966c0aSStefan Haberland private = kzalloc(sizeof(struct dasd_fba_private), 12900966c0aSStefan Haberland GFP_KERNEL | GFP_DMA); 1301da177e4SLinus Torvalds if (private == NULL) { 1311da177e4SLinus Torvalds DEV_MESSAGE(KERN_WARNING, device, "%s", 1321da177e4SLinus Torvalds "memory allocation failed for private " 1331da177e4SLinus Torvalds "data"); 1341da177e4SLinus Torvalds return -ENOMEM; 1351da177e4SLinus Torvalds } 1361da177e4SLinus Torvalds device->private = (void *) private; 1371da177e4SLinus Torvalds } 1388e09f215SStefan Weinhuber block = dasd_alloc_block(); 1398e09f215SStefan Weinhuber if (IS_ERR(block)) { 1408e09f215SStefan Weinhuber DEV_MESSAGE(KERN_WARNING, device, "%s", 1418e09f215SStefan Weinhuber "could not allocate dasd block structure"); 1427337194fSCornelia Huck device->private = NULL; 1437337194fSCornelia Huck kfree(private); 1448e09f215SStefan Weinhuber return PTR_ERR(block); 1458e09f215SStefan Weinhuber } 1468e09f215SStefan Weinhuber device->block = block; 1478e09f215SStefan Weinhuber block->base = device; 1488e09f215SStefan Weinhuber 1491da177e4SLinus Torvalds /* Read Device Characteristics */ 1501da177e4SLinus Torvalds rdc_data = (void *) &(private->rdc_data); 15117283b56SCornelia Huck rc = dasd_generic_read_dev_chars(device, "FBA ", &rdc_data, 32); 1521da177e4SLinus Torvalds if (rc) { 1531da177e4SLinus Torvalds DEV_MESSAGE(KERN_WARNING, device, 1541da177e4SLinus Torvalds "Read device characteristics returned error %d", 1551da177e4SLinus Torvalds rc); 1567337194fSCornelia Huck device->block = NULL; 1577337194fSCornelia Huck dasd_free_block(block); 1587337194fSCornelia Huck device->private = NULL; 1597337194fSCornelia Huck kfree(private); 1601da177e4SLinus Torvalds return rc; 1611da177e4SLinus Torvalds } 1621da177e4SLinus Torvalds 1631da177e4SLinus Torvalds DEV_MESSAGE(KERN_INFO, device, 1641da177e4SLinus Torvalds "%04X/%02X(CU:%04X/%02X) %dMB at(%d B/blk)", 1651da177e4SLinus Torvalds cdev->id.dev_type, 1661da177e4SLinus Torvalds cdev->id.dev_model, 1671da177e4SLinus Torvalds cdev->id.cu_type, 1681da177e4SLinus Torvalds cdev->id.cu_model, 1691da177e4SLinus Torvalds ((private->rdc_data.blk_bdsa * 1701da177e4SLinus Torvalds (private->rdc_data.blk_size >> 9)) >> 11), 1711da177e4SLinus Torvalds private->rdc_data.blk_size); 1721da177e4SLinus Torvalds return 0; 1731da177e4SLinus Torvalds } 1741da177e4SLinus Torvalds 1758e09f215SStefan Weinhuber static int dasd_fba_do_analysis(struct dasd_block *block) 1761da177e4SLinus Torvalds { 1771da177e4SLinus Torvalds struct dasd_fba_private *private; 1781da177e4SLinus Torvalds int sb, rc; 1791da177e4SLinus Torvalds 1808e09f215SStefan Weinhuber private = (struct dasd_fba_private *) block->base->private; 1811da177e4SLinus Torvalds rc = dasd_check_blocksize(private->rdc_data.blk_size); 1821da177e4SLinus Torvalds if (rc) { 1838e09f215SStefan Weinhuber DEV_MESSAGE(KERN_INFO, block->base, "unknown blocksize %d", 1841da177e4SLinus Torvalds private->rdc_data.blk_size); 1851da177e4SLinus Torvalds return rc; 1861da177e4SLinus Torvalds } 1878e09f215SStefan Weinhuber block->blocks = private->rdc_data.blk_bdsa; 1888e09f215SStefan Weinhuber block->bp_block = private->rdc_data.blk_size; 1898e09f215SStefan Weinhuber block->s2b_shift = 0; /* bits to shift 512 to get a block */ 1901da177e4SLinus Torvalds for (sb = 512; sb < private->rdc_data.blk_size; sb = sb << 1) 1918e09f215SStefan Weinhuber block->s2b_shift++; 1921da177e4SLinus Torvalds return 0; 1931da177e4SLinus Torvalds } 1941da177e4SLinus Torvalds 1958e09f215SStefan Weinhuber static int dasd_fba_fill_geometry(struct dasd_block *block, 1968e09f215SStefan Weinhuber struct hd_geometry *geo) 1971da177e4SLinus Torvalds { 1988e09f215SStefan Weinhuber if (dasd_check_blocksize(block->bp_block) != 0) 1991da177e4SLinus Torvalds return -EINVAL; 2008e09f215SStefan Weinhuber geo->cylinders = (block->blocks << block->s2b_shift) >> 10; 2011da177e4SLinus Torvalds geo->heads = 16; 2028e09f215SStefan Weinhuber geo->sectors = 128 >> block->s2b_shift; 2031da177e4SLinus Torvalds return 0; 2041da177e4SLinus Torvalds } 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds static dasd_erp_fn_t 2071da177e4SLinus Torvalds dasd_fba_erp_action(struct dasd_ccw_req * cqr) 2081da177e4SLinus Torvalds { 2091da177e4SLinus Torvalds return dasd_default_erp_action; 2101da177e4SLinus Torvalds } 2111da177e4SLinus Torvalds 2121da177e4SLinus Torvalds static dasd_erp_fn_t 2131da177e4SLinus Torvalds dasd_fba_erp_postaction(struct dasd_ccw_req * cqr) 2141da177e4SLinus Torvalds { 2151da177e4SLinus Torvalds if (cqr->function == dasd_default_erp_action) 2161da177e4SLinus Torvalds return dasd_default_erp_postaction; 2171da177e4SLinus Torvalds 2188e09f215SStefan Weinhuber DEV_MESSAGE(KERN_WARNING, cqr->startdev, "unknown ERP action %p", 2191da177e4SLinus Torvalds cqr->function); 2201da177e4SLinus Torvalds return NULL; 2211da177e4SLinus Torvalds } 2221da177e4SLinus Torvalds 2238e09f215SStefan Weinhuber static void dasd_fba_handle_unsolicited_interrupt(struct dasd_device *device, 2248e09f215SStefan Weinhuber struct irb *irb) 2258e09f215SStefan Weinhuber { 2268e09f215SStefan Weinhuber char mask; 2278e09f215SStefan Weinhuber 2288e09f215SStefan Weinhuber /* first of all check for state change pending interrupt */ 2298e09f215SStefan Weinhuber mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP; 23023d805b6SPeter Oberparleiter if ((irb->scsw.cmd.dstat & mask) == mask) { 2318e09f215SStefan Weinhuber dasd_generic_handle_state_change(device); 2328e09f215SStefan Weinhuber return; 2338e09f215SStefan Weinhuber } 2348e09f215SStefan Weinhuber 2358e09f215SStefan Weinhuber /* check for unsolicited interrupts */ 2368e09f215SStefan Weinhuber DEV_MESSAGE(KERN_DEBUG, device, "%s", 2378e09f215SStefan Weinhuber "unsolicited interrupt received"); 2388e09f215SStefan Weinhuber device->discipline->dump_sense(device, NULL, irb); 2398e09f215SStefan Weinhuber dasd_schedule_device_bh(device); 2408e09f215SStefan Weinhuber return; 2418e09f215SStefan Weinhuber }; 2428e09f215SStefan Weinhuber 2438e09f215SStefan Weinhuber static struct dasd_ccw_req *dasd_fba_build_cp(struct dasd_device * memdev, 2448e09f215SStefan Weinhuber struct dasd_block *block, 2458e09f215SStefan Weinhuber struct request *req) 2461da177e4SLinus Torvalds { 2471da177e4SLinus Torvalds struct dasd_fba_private *private; 2481da177e4SLinus Torvalds unsigned long *idaws; 2491da177e4SLinus Torvalds struct LO_fba_data *LO_data; 2501da177e4SLinus Torvalds struct dasd_ccw_req *cqr; 2511da177e4SLinus Torvalds struct ccw1 *ccw; 2525705f702SNeilBrown struct req_iterator iter; 2531da177e4SLinus Torvalds struct bio_vec *bv; 2541da177e4SLinus Torvalds char *dst; 2551da177e4SLinus Torvalds int count, cidaw, cplength, datasize; 2561da177e4SLinus Torvalds sector_t recid, first_rec, last_rec; 2571da177e4SLinus Torvalds unsigned int blksize, off; 2581da177e4SLinus Torvalds unsigned char cmd; 2591da177e4SLinus Torvalds 2608e09f215SStefan Weinhuber private = (struct dasd_fba_private *) block->base->private; 2611da177e4SLinus Torvalds if (rq_data_dir(req) == READ) { 2621da177e4SLinus Torvalds cmd = DASD_FBA_CCW_READ; 2631da177e4SLinus Torvalds } else if (rq_data_dir(req) == WRITE) { 2641da177e4SLinus Torvalds cmd = DASD_FBA_CCW_WRITE; 2651da177e4SLinus Torvalds } else 2661da177e4SLinus Torvalds return ERR_PTR(-EINVAL); 2678e09f215SStefan Weinhuber blksize = block->bp_block; 2681da177e4SLinus Torvalds /* Calculate record id of first and last block. */ 2698e09f215SStefan Weinhuber first_rec = req->sector >> block->s2b_shift; 2708e09f215SStefan Weinhuber last_rec = (req->sector + req->nr_sectors - 1) >> block->s2b_shift; 2711da177e4SLinus Torvalds /* Check struct bio and count the number of blocks for the request. */ 2721da177e4SLinus Torvalds count = 0; 2731da177e4SLinus Torvalds cidaw = 0; 2745705f702SNeilBrown rq_for_each_segment(bv, req, iter) { 2751da177e4SLinus Torvalds if (bv->bv_len & (blksize - 1)) 2761da177e4SLinus Torvalds /* Fba can only do full blocks. */ 2771da177e4SLinus Torvalds return ERR_PTR(-EINVAL); 2788e09f215SStefan Weinhuber count += bv->bv_len >> (block->s2b_shift + 9); 279347a8dc3SMartin Schwidefsky #if defined(CONFIG_64BIT) 2806c92e699SJens Axboe if (idal_is_needed (page_address(bv->bv_page), bv->bv_len)) 2811da177e4SLinus Torvalds cidaw += bv->bv_len / blksize; 2821da177e4SLinus Torvalds #endif 2831da177e4SLinus Torvalds } 2841da177e4SLinus Torvalds /* Paranoia. */ 2851da177e4SLinus Torvalds if (count != last_rec - first_rec + 1) 2861da177e4SLinus Torvalds return ERR_PTR(-EINVAL); 2871da177e4SLinus Torvalds /* 1x define extent + 1x locate record + number of blocks */ 2881da177e4SLinus Torvalds cplength = 2 + count; 2891da177e4SLinus Torvalds /* 1x define extent + 1x locate record */ 2901da177e4SLinus Torvalds datasize = sizeof(struct DE_fba_data) + sizeof(struct LO_fba_data) + 2911da177e4SLinus Torvalds cidaw * sizeof(unsigned long); 2921da177e4SLinus Torvalds /* 2931da177e4SLinus Torvalds * Find out number of additional locate record ccws if the device 2941da177e4SLinus Torvalds * can't do data chaining. 2951da177e4SLinus Torvalds */ 2961da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain == 0) { 2971da177e4SLinus Torvalds cplength += count - 1; 2981da177e4SLinus Torvalds datasize += (count - 1)*sizeof(struct LO_fba_data); 2991da177e4SLinus Torvalds } 3001da177e4SLinus Torvalds /* Allocate the ccw request. */ 3011da177e4SLinus Torvalds cqr = dasd_smalloc_request(dasd_fba_discipline.name, 3028e09f215SStefan Weinhuber cplength, datasize, memdev); 3031da177e4SLinus Torvalds if (IS_ERR(cqr)) 3041da177e4SLinus Torvalds return cqr; 3051da177e4SLinus Torvalds ccw = cqr->cpaddr; 3061da177e4SLinus Torvalds /* First ccw is define extent. */ 3071da177e4SLinus Torvalds define_extent(ccw++, cqr->data, rq_data_dir(req), 3088e09f215SStefan Weinhuber block->bp_block, req->sector, req->nr_sectors); 3091da177e4SLinus Torvalds /* Build locate_record + read/write ccws. */ 3101da177e4SLinus Torvalds idaws = (unsigned long *) (cqr->data + sizeof(struct DE_fba_data)); 3111da177e4SLinus Torvalds LO_data = (struct LO_fba_data *) (idaws + cidaw); 3121da177e4SLinus Torvalds /* Locate record for all blocks for smart devices. */ 3131da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain != 0) { 3141da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_CC; 3151da177e4SLinus Torvalds locate_record(ccw++, LO_data++, rq_data_dir(req), 0, count); 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds recid = first_rec; 3185705f702SNeilBrown rq_for_each_segment(bv, req, iter) { 3191da177e4SLinus Torvalds dst = page_address(bv->bv_page) + bv->bv_offset; 3201da177e4SLinus Torvalds if (dasd_page_cache) { 3211da177e4SLinus Torvalds char *copy = kmem_cache_alloc(dasd_page_cache, 322441e143eSChristoph Lameter GFP_DMA | __GFP_NOWARN); 3231da177e4SLinus Torvalds if (copy && rq_data_dir(req) == WRITE) 3241da177e4SLinus Torvalds memcpy(copy + bv->bv_offset, dst, bv->bv_len); 3251da177e4SLinus Torvalds if (copy) 3261da177e4SLinus Torvalds dst = copy + bv->bv_offset; 3271da177e4SLinus Torvalds } 3281da177e4SLinus Torvalds for (off = 0; off < bv->bv_len; off += blksize) { 3291da177e4SLinus Torvalds /* Locate record for stupid devices. */ 3301da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain == 0) { 3311da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_CC; 3321da177e4SLinus Torvalds locate_record(ccw, LO_data++, 3331da177e4SLinus Torvalds rq_data_dir(req), 3341da177e4SLinus Torvalds recid - first_rec, 1); 3351da177e4SLinus Torvalds ccw->flags = CCW_FLAG_CC; 3361da177e4SLinus Torvalds ccw++; 3371da177e4SLinus Torvalds } else { 3381da177e4SLinus Torvalds if (recid > first_rec) 3391da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_DC; 3401da177e4SLinus Torvalds else 3411da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_CC; 3421da177e4SLinus Torvalds } 3431da177e4SLinus Torvalds ccw->cmd_code = cmd; 3448e09f215SStefan Weinhuber ccw->count = block->bp_block; 3451da177e4SLinus Torvalds if (idal_is_needed(dst, blksize)) { 3461da177e4SLinus Torvalds ccw->cda = (__u32)(addr_t) idaws; 3471da177e4SLinus Torvalds ccw->flags = CCW_FLAG_IDA; 3481da177e4SLinus Torvalds idaws = idal_create_words(idaws, dst, blksize); 3491da177e4SLinus Torvalds } else { 3501da177e4SLinus Torvalds ccw->cda = (__u32)(addr_t) dst; 3511da177e4SLinus Torvalds ccw->flags = 0; 3521da177e4SLinus Torvalds } 3531da177e4SLinus Torvalds ccw++; 3541da177e4SLinus Torvalds dst += blksize; 3551da177e4SLinus Torvalds recid++; 3561da177e4SLinus Torvalds } 3571da177e4SLinus Torvalds } 35813de227bSHolger Smolinski if (blk_noretry_request(req) || 35913de227bSHolger Smolinski block->base->features & DASD_FEATURE_FAILFAST) 3601c01b8a5SHorst Hummel set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 3618e09f215SStefan Weinhuber cqr->startdev = memdev; 3628e09f215SStefan Weinhuber cqr->memdev = memdev; 3638e09f215SStefan Weinhuber cqr->block = block; 3641da177e4SLinus Torvalds cqr->expires = 5 * 60 * HZ; /* 5 minutes */ 365d61f6f3dSHorst Hummel cqr->retries = 32; 366d61f6f3dSHorst Hummel cqr->buildclk = get_clock(); 3671da177e4SLinus Torvalds cqr->status = DASD_CQR_FILLED; 3681da177e4SLinus Torvalds return cqr; 3691da177e4SLinus Torvalds } 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds static int 3721da177e4SLinus Torvalds dasd_fba_free_cp(struct dasd_ccw_req *cqr, struct request *req) 3731da177e4SLinus Torvalds { 3741da177e4SLinus Torvalds struct dasd_fba_private *private; 3751da177e4SLinus Torvalds struct ccw1 *ccw; 3765705f702SNeilBrown struct req_iterator iter; 3771da177e4SLinus Torvalds struct bio_vec *bv; 3781da177e4SLinus Torvalds char *dst, *cda; 3791da177e4SLinus Torvalds unsigned int blksize, off; 3805705f702SNeilBrown int status; 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds if (!dasd_page_cache) 3831da177e4SLinus Torvalds goto out; 3848e09f215SStefan Weinhuber private = (struct dasd_fba_private *) cqr->block->base->private; 3858e09f215SStefan Weinhuber blksize = cqr->block->bp_block; 3861da177e4SLinus Torvalds ccw = cqr->cpaddr; 3871da177e4SLinus Torvalds /* Skip over define extent & locate record. */ 3881da177e4SLinus Torvalds ccw++; 3891da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain != 0) 3901da177e4SLinus Torvalds ccw++; 3915705f702SNeilBrown rq_for_each_segment(bv, req, iter) { 3921da177e4SLinus Torvalds dst = page_address(bv->bv_page) + bv->bv_offset; 3931da177e4SLinus Torvalds for (off = 0; off < bv->bv_len; off += blksize) { 3941da177e4SLinus Torvalds /* Skip locate record. */ 3951da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain == 0) 3961da177e4SLinus Torvalds ccw++; 3971da177e4SLinus Torvalds if (dst) { 3981da177e4SLinus Torvalds if (ccw->flags & CCW_FLAG_IDA) 3991da177e4SLinus Torvalds cda = *((char **)((addr_t) ccw->cda)); 4001da177e4SLinus Torvalds else 4011da177e4SLinus Torvalds cda = (char *)((addr_t) ccw->cda); 4021da177e4SLinus Torvalds if (dst != cda) { 4031da177e4SLinus Torvalds if (rq_data_dir(req) == READ) 4041da177e4SLinus Torvalds memcpy(dst, cda, bv->bv_len); 4051da177e4SLinus Torvalds kmem_cache_free(dasd_page_cache, 4061da177e4SLinus Torvalds (void *)((addr_t)cda & PAGE_MASK)); 4071da177e4SLinus Torvalds } 4081da177e4SLinus Torvalds dst = NULL; 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds ccw++; 4111da177e4SLinus Torvalds } 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds out: 4141da177e4SLinus Torvalds status = cqr->status == DASD_CQR_DONE; 4158e09f215SStefan Weinhuber dasd_sfree_request(cqr, cqr->memdev); 4161da177e4SLinus Torvalds return status; 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds 4198e09f215SStefan Weinhuber static void dasd_fba_handle_terminated_request(struct dasd_ccw_req *cqr) 4208e09f215SStefan Weinhuber { 4218e09f215SStefan Weinhuber cqr->status = DASD_CQR_FILLED; 4228e09f215SStefan Weinhuber }; 4238e09f215SStefan Weinhuber 4241da177e4SLinus Torvalds static int 4251da177e4SLinus Torvalds dasd_fba_fill_info(struct dasd_device * device, 4261da177e4SLinus Torvalds struct dasd_information2_t * info) 4271da177e4SLinus Torvalds { 4281da177e4SLinus Torvalds info->label_block = 1; 4291da177e4SLinus Torvalds info->FBA_layout = 1; 4301da177e4SLinus Torvalds info->format = DASD_FORMAT_LDL; 4311da177e4SLinus Torvalds info->characteristics_size = sizeof(struct dasd_fba_characteristics); 4321da177e4SLinus Torvalds memcpy(info->characteristics, 4331da177e4SLinus Torvalds &((struct dasd_fba_private *) device->private)->rdc_data, 4341da177e4SLinus Torvalds sizeof (struct dasd_fba_characteristics)); 4351da177e4SLinus Torvalds info->confdata_size = 0; 4361da177e4SLinus Torvalds return 0; 4371da177e4SLinus Torvalds } 4381da177e4SLinus Torvalds 4391da177e4SLinus Torvalds static void 4401da177e4SLinus Torvalds dasd_fba_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req, 4411da177e4SLinus Torvalds struct irb *irb) 4421da177e4SLinus Torvalds { 4431da177e4SLinus Torvalds char *page; 4441da177e4SLinus Torvalds struct ccw1 *act, *end, *last; 4451da177e4SLinus Torvalds int len, sl, sct, count; 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds page = (char *) get_zeroed_page(GFP_ATOMIC); 4481da177e4SLinus Torvalds if (page == NULL) { 4491da177e4SLinus Torvalds DEV_MESSAGE(KERN_ERR, device, " %s", 4501da177e4SLinus Torvalds "No memory to dump sense data"); 4511da177e4SLinus Torvalds return; 4521da177e4SLinus Torvalds } 4531da177e4SLinus Torvalds len = sprintf(page, KERN_ERR PRINTK_HEADER 4541da177e4SLinus Torvalds " I/O status report for device %s:\n", 4552a0217d5SKay Sievers dev_name(&device->cdev->dev)); 4561da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4571da177e4SLinus Torvalds " in req: %p CS: 0x%02X DS: 0x%02X\n", req, 45823d805b6SPeter Oberparleiter irb->scsw.cmd.cstat, irb->scsw.cmd.dstat); 4591da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4601da177e4SLinus Torvalds " device %s: Failing CCW: %p\n", 4612a0217d5SKay Sievers dev_name(&device->cdev->dev), 46223d805b6SPeter Oberparleiter (void *) (addr_t) irb->scsw.cmd.cpa); 4631da177e4SLinus Torvalds if (irb->esw.esw0.erw.cons) { 4641da177e4SLinus Torvalds for (sl = 0; sl < 4; sl++) { 4651da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4661da177e4SLinus Torvalds " Sense(hex) %2d-%2d:", 4671da177e4SLinus Torvalds (8 * sl), ((8 * sl) + 7)); 4681da177e4SLinus Torvalds 4691da177e4SLinus Torvalds for (sct = 0; sct < 8; sct++) { 4701da177e4SLinus Torvalds len += sprintf(page + len, " %02x", 4711da177e4SLinus Torvalds irb->ecw[8 * sl + sct]); 4721da177e4SLinus Torvalds } 4731da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds } else { 4761da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4771da177e4SLinus Torvalds " SORRY - NO VALID SENSE AVAILABLE\n"); 4781da177e4SLinus Torvalds } 4791da177e4SLinus Torvalds MESSAGE_LOG(KERN_ERR, "%s", 4801da177e4SLinus Torvalds page + sizeof(KERN_ERR PRINTK_HEADER)); 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds /* dump the Channel Program */ 4831da177e4SLinus Torvalds /* print first CCWs (maximum 8) */ 4841da177e4SLinus Torvalds act = req->cpaddr; 4851da177e4SLinus Torvalds for (last = act; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++); 4861da177e4SLinus Torvalds end = min(act + 8, last); 4871da177e4SLinus Torvalds len = sprintf(page, KERN_ERR PRINTK_HEADER 4881da177e4SLinus Torvalds " Related CP in req: %p\n", req); 4891da177e4SLinus Torvalds while (act <= end) { 4901da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4911da177e4SLinus Torvalds " CCW %p: %08X %08X DAT:", 4921da177e4SLinus Torvalds act, ((int *) act)[0], ((int *) act)[1]); 4931da177e4SLinus Torvalds for (count = 0; count < 32 && count < act->count; 4941da177e4SLinus Torvalds count += sizeof(int)) 4951da177e4SLinus Torvalds len += sprintf(page + len, " %08X", 4961da177e4SLinus Torvalds ((int *) (addr_t) act->cda) 4971da177e4SLinus Torvalds [(count>>2)]); 4981da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 4991da177e4SLinus Torvalds act++; 5001da177e4SLinus Torvalds } 5011da177e4SLinus Torvalds MESSAGE_LOG(KERN_ERR, "%s", 5021da177e4SLinus Torvalds page + sizeof(KERN_ERR PRINTK_HEADER)); 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds /* print failing CCW area */ 5061da177e4SLinus Torvalds len = 0; 50723d805b6SPeter Oberparleiter if (act < ((struct ccw1 *)(addr_t) irb->scsw.cmd.cpa) - 2) { 50823d805b6SPeter Oberparleiter act = ((struct ccw1 *)(addr_t) irb->scsw.cmd.cpa) - 2; 5091da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER "......\n"); 5101da177e4SLinus Torvalds } 51123d805b6SPeter Oberparleiter end = min((struct ccw1 *)(addr_t) irb->scsw.cmd.cpa + 2, last); 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 } 5241da177e4SLinus Torvalds 5251da177e4SLinus Torvalds /* print last CCWs */ 5261da177e4SLinus Torvalds if (act < last - 2) { 5271da177e4SLinus Torvalds act = last - 2; 5281da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER "......\n"); 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds while (act <= last) { 5311da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 5321da177e4SLinus Torvalds " CCW %p: %08X %08X DAT:", 5331da177e4SLinus Torvalds act, ((int *) act)[0], ((int *) act)[1]); 5341da177e4SLinus Torvalds for (count = 0; count < 32 && count < act->count; 5351da177e4SLinus Torvalds count += sizeof(int)) 5361da177e4SLinus Torvalds len += sprintf(page + len, " %08X", 5371da177e4SLinus Torvalds ((int *) (addr_t) act->cda) 5381da177e4SLinus Torvalds [(count>>2)]); 5391da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 5401da177e4SLinus Torvalds act++; 5411da177e4SLinus Torvalds } 5421da177e4SLinus Torvalds if (len > 0) 5431da177e4SLinus Torvalds MESSAGE_LOG(KERN_ERR, "%s", 5441da177e4SLinus Torvalds page + sizeof(KERN_ERR PRINTK_HEADER)); 5451da177e4SLinus Torvalds free_page((unsigned long) page); 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds 5481da177e4SLinus Torvalds /* 5491da177e4SLinus Torvalds * max_blocks is dependent on the amount of storage that is available 5501da177e4SLinus Torvalds * in the static io buffer for each device. Currently each device has 5511da177e4SLinus Torvalds * 8192 bytes (=2 pages). For 64 bit one dasd_mchunkt_t structure has 5521da177e4SLinus Torvalds * 24 bytes, the struct dasd_ccw_req has 136 bytes and each block can use 5531da177e4SLinus Torvalds * up to 16 bytes (8 for the ccw and 8 for the idal pointer). In 5541da177e4SLinus Torvalds * addition we have one define extent ccw + 16 bytes of data and a 5551da177e4SLinus Torvalds * locate record ccw for each block (stupid devices!) + 16 bytes of data. 5561da177e4SLinus Torvalds * That makes: 5571da177e4SLinus Torvalds * (8192 - 24 - 136 - 8 - 16) / 40 = 200.2 blocks at maximum. 5581da177e4SLinus Torvalds * We want to fit two into the available memory so that we can immediately 5591da177e4SLinus Torvalds * start the next request if one finishes off. That makes 100.1 blocks 5601da177e4SLinus Torvalds * for one request. Give a little safety and the result is 96. 5611da177e4SLinus Torvalds */ 5621da177e4SLinus Torvalds static struct dasd_discipline dasd_fba_discipline = { 5631da177e4SLinus Torvalds .owner = THIS_MODULE, 5641da177e4SLinus Torvalds .name = "FBA ", 5651da177e4SLinus Torvalds .ebcname = "FBA ", 5661da177e4SLinus Torvalds .max_blocks = 96, 5671da177e4SLinus Torvalds .check_device = dasd_fba_check_characteristics, 5681da177e4SLinus Torvalds .do_analysis = dasd_fba_do_analysis, 5691da177e4SLinus Torvalds .fill_geometry = dasd_fba_fill_geometry, 5701da177e4SLinus Torvalds .start_IO = dasd_start_IO, 5711da177e4SLinus Torvalds .term_IO = dasd_term_IO, 5728e09f215SStefan Weinhuber .handle_terminated_request = dasd_fba_handle_terminated_request, 5731da177e4SLinus Torvalds .erp_action = dasd_fba_erp_action, 5741da177e4SLinus Torvalds .erp_postaction = dasd_fba_erp_postaction, 5758e09f215SStefan Weinhuber .handle_unsolicited_interrupt = dasd_fba_handle_unsolicited_interrupt, 5761da177e4SLinus Torvalds .build_cp = dasd_fba_build_cp, 5771da177e4SLinus Torvalds .free_cp = dasd_fba_free_cp, 5781da177e4SLinus Torvalds .dump_sense = dasd_fba_dump_sense, 5791da177e4SLinus Torvalds .fill_info = dasd_fba_fill_info, 5801da177e4SLinus Torvalds }; 5811da177e4SLinus Torvalds 5821da177e4SLinus Torvalds static int __init 5831da177e4SLinus Torvalds dasd_fba_init(void) 5841da177e4SLinus Torvalds { 5851da177e4SLinus Torvalds ASCEBC(dasd_fba_discipline.ebcname, 4); 58640545573SHorst Hummel return ccw_driver_register(&dasd_fba_driver); 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds static void __exit 5901da177e4SLinus Torvalds dasd_fba_cleanup(void) 5911da177e4SLinus Torvalds { 5921da177e4SLinus Torvalds ccw_driver_unregister(&dasd_fba_driver); 5931da177e4SLinus Torvalds } 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds module_init(dasd_fba_init); 5961da177e4SLinus Torvalds module_exit(dasd_fba_cleanup); 597