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 * 71c01b8a5SHorst Hummel * $Revision: 1.41 $ 81da177e4SLinus Torvalds */ 91da177e4SLinus Torvalds 101da177e4SLinus Torvalds #include <linux/config.h> 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[] = { 491da177e4SLinus Torvalds { CCW_DEVICE_DEVTYPE (0x6310, 0, 0x9336, 0), driver_info: 0x1}, 501da177e4SLinus Torvalds { 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 { 601da177e4SLinus Torvalds int ret; 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds ret = dasd_generic_probe (cdev, &dasd_fba_discipline); 631da177e4SLinus Torvalds if (ret) 641da177e4SLinus Torvalds return ret; 651da177e4SLinus Torvalds ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP); 661da177e4SLinus Torvalds return 0; 671da177e4SLinus Torvalds } 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds static int 701da177e4SLinus Torvalds dasd_fba_set_online(struct ccw_device *cdev) 711da177e4SLinus Torvalds { 721da177e4SLinus Torvalds return dasd_generic_set_online (cdev, &dasd_fba_discipline); 731da177e4SLinus Torvalds } 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds static struct ccw_driver dasd_fba_driver = { 761da177e4SLinus Torvalds .name = "dasd-fba", 771da177e4SLinus Torvalds .owner = THIS_MODULE, 781da177e4SLinus Torvalds .ids = dasd_fba_ids, 791da177e4SLinus Torvalds .probe = dasd_fba_probe, 801da177e4SLinus Torvalds .remove = dasd_generic_remove, 811da177e4SLinus Torvalds .set_offline = dasd_generic_set_offline, 821da177e4SLinus Torvalds .set_online = dasd_fba_set_online, 831da177e4SLinus Torvalds .notify = dasd_generic_notify, 841da177e4SLinus Torvalds }; 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds static inline void 871da177e4SLinus Torvalds define_extent(struct ccw1 * ccw, struct DE_fba_data *data, int rw, 881da177e4SLinus Torvalds int blksize, int beg, int nr) 891da177e4SLinus Torvalds { 901da177e4SLinus Torvalds ccw->cmd_code = DASD_FBA_CCW_DEFINE_EXTENT; 911da177e4SLinus Torvalds ccw->flags = 0; 921da177e4SLinus Torvalds ccw->count = 16; 931da177e4SLinus Torvalds ccw->cda = (__u32) __pa(data); 941da177e4SLinus Torvalds memset(data, 0, sizeof (struct DE_fba_data)); 951da177e4SLinus Torvalds if (rw == WRITE) 961da177e4SLinus Torvalds (data->mask).perm = 0x0; 971da177e4SLinus Torvalds else if (rw == READ) 981da177e4SLinus Torvalds (data->mask).perm = 0x1; 991da177e4SLinus Torvalds else 1001da177e4SLinus Torvalds data->mask.perm = 0x2; 1011da177e4SLinus Torvalds data->blk_size = blksize; 1021da177e4SLinus Torvalds data->ext_loc = beg; 1031da177e4SLinus Torvalds data->ext_end = nr - 1; 1041da177e4SLinus Torvalds } 1051da177e4SLinus Torvalds 1061da177e4SLinus Torvalds static inline void 1071da177e4SLinus Torvalds locate_record(struct ccw1 * ccw, struct LO_fba_data *data, int rw, 1081da177e4SLinus Torvalds int block_nr, int block_ct) 1091da177e4SLinus Torvalds { 1101da177e4SLinus Torvalds ccw->cmd_code = DASD_FBA_CCW_LOCATE; 1111da177e4SLinus Torvalds ccw->flags = 0; 1121da177e4SLinus Torvalds ccw->count = 8; 1131da177e4SLinus Torvalds ccw->cda = (__u32) __pa(data); 1141da177e4SLinus Torvalds memset(data, 0, sizeof (struct LO_fba_data)); 1151da177e4SLinus Torvalds if (rw == WRITE) 1161da177e4SLinus Torvalds data->operation.cmd = 0x5; 1171da177e4SLinus Torvalds else if (rw == READ) 1181da177e4SLinus Torvalds data->operation.cmd = 0x6; 1191da177e4SLinus Torvalds else 1201da177e4SLinus Torvalds data->operation.cmd = 0x8; 1211da177e4SLinus Torvalds data->blk_nr = block_nr; 1221da177e4SLinus Torvalds data->blk_ct = block_ct; 1231da177e4SLinus Torvalds } 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds static int 1261da177e4SLinus Torvalds dasd_fba_check_characteristics(struct dasd_device *device) 1271da177e4SLinus Torvalds { 1281da177e4SLinus Torvalds struct dasd_fba_private *private; 1291da177e4SLinus Torvalds struct ccw_device *cdev = device->cdev; 1301da177e4SLinus Torvalds void *rdc_data; 1311da177e4SLinus Torvalds int rc; 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds private = (struct dasd_fba_private *) device->private; 1341da177e4SLinus Torvalds if (private == NULL) { 1351da177e4SLinus Torvalds private = kmalloc(sizeof(struct dasd_fba_private), GFP_KERNEL); 1361da177e4SLinus Torvalds if (private == NULL) { 1371da177e4SLinus Torvalds DEV_MESSAGE(KERN_WARNING, device, "%s", 1381da177e4SLinus Torvalds "memory allocation failed for private " 1391da177e4SLinus Torvalds "data"); 1401da177e4SLinus Torvalds return -ENOMEM; 1411da177e4SLinus Torvalds } 1421da177e4SLinus Torvalds device->private = (void *) private; 1431da177e4SLinus Torvalds } 1441da177e4SLinus Torvalds /* Read Device Characteristics */ 1451da177e4SLinus Torvalds rdc_data = (void *) &(private->rdc_data); 1461da177e4SLinus Torvalds rc = read_dev_chars(device->cdev, &rdc_data, 32); 1471da177e4SLinus Torvalds if (rc) { 1481da177e4SLinus Torvalds DEV_MESSAGE(KERN_WARNING, device, 1491da177e4SLinus Torvalds "Read device characteristics returned error %d", 1501da177e4SLinus Torvalds rc); 1511da177e4SLinus Torvalds return rc; 1521da177e4SLinus Torvalds } 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds DEV_MESSAGE(KERN_INFO, device, 1551da177e4SLinus Torvalds "%04X/%02X(CU:%04X/%02X) %dMB at(%d B/blk)", 1561da177e4SLinus Torvalds cdev->id.dev_type, 1571da177e4SLinus Torvalds cdev->id.dev_model, 1581da177e4SLinus Torvalds cdev->id.cu_type, 1591da177e4SLinus Torvalds cdev->id.cu_model, 1601da177e4SLinus Torvalds ((private->rdc_data.blk_bdsa * 1611da177e4SLinus Torvalds (private->rdc_data.blk_size >> 9)) >> 11), 1621da177e4SLinus Torvalds private->rdc_data.blk_size); 1631da177e4SLinus Torvalds return 0; 1641da177e4SLinus Torvalds } 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds static int 1671da177e4SLinus Torvalds dasd_fba_do_analysis(struct dasd_device *device) 1681da177e4SLinus Torvalds { 1691da177e4SLinus Torvalds struct dasd_fba_private *private; 1701da177e4SLinus Torvalds int sb, rc; 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds private = (struct dasd_fba_private *) device->private; 1731da177e4SLinus Torvalds rc = dasd_check_blocksize(private->rdc_data.blk_size); 1741da177e4SLinus Torvalds if (rc) { 1751da177e4SLinus Torvalds DEV_MESSAGE(KERN_INFO, device, "unknown blocksize %d", 1761da177e4SLinus Torvalds private->rdc_data.blk_size); 1771da177e4SLinus Torvalds return rc; 1781da177e4SLinus Torvalds } 1791da177e4SLinus Torvalds device->blocks = private->rdc_data.blk_bdsa; 1801da177e4SLinus Torvalds device->bp_block = private->rdc_data.blk_size; 1811da177e4SLinus Torvalds device->s2b_shift = 0; /* bits to shift 512 to get a block */ 1821da177e4SLinus Torvalds for (sb = 512; sb < private->rdc_data.blk_size; sb = sb << 1) 1831da177e4SLinus Torvalds device->s2b_shift++; 1841da177e4SLinus Torvalds return 0; 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds static int 1881da177e4SLinus Torvalds dasd_fba_fill_geometry(struct dasd_device *device, struct hd_geometry *geo) 1891da177e4SLinus Torvalds { 1901da177e4SLinus Torvalds if (dasd_check_blocksize(device->bp_block) != 0) 1911da177e4SLinus Torvalds return -EINVAL; 1921da177e4SLinus Torvalds geo->cylinders = (device->blocks << device->s2b_shift) >> 10; 1931da177e4SLinus Torvalds geo->heads = 16; 1941da177e4SLinus Torvalds geo->sectors = 128 >> device->s2b_shift; 1951da177e4SLinus Torvalds return 0; 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds static dasd_era_t 1991da177e4SLinus Torvalds dasd_fba_examine_error(struct dasd_ccw_req * cqr, struct irb * irb) 2001da177e4SLinus Torvalds { 2011da177e4SLinus Torvalds struct dasd_device *device; 2021da177e4SLinus Torvalds struct ccw_device *cdev; 2031da177e4SLinus Torvalds 2041da177e4SLinus Torvalds device = (struct dasd_device *) cqr->device; 2051da177e4SLinus Torvalds if (irb->scsw.cstat == 0x00 && 2061da177e4SLinus Torvalds irb->scsw.dstat == (DEV_STAT_CHN_END | DEV_STAT_DEV_END)) 2071da177e4SLinus Torvalds return dasd_era_none; 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds cdev = device->cdev; 2101da177e4SLinus Torvalds switch (cdev->id.dev_type) { 2111da177e4SLinus Torvalds case 0x3370: 2121da177e4SLinus Torvalds return dasd_3370_erp_examine(cqr, irb); 2131da177e4SLinus Torvalds case 0x9336: 2141da177e4SLinus Torvalds return dasd_9336_erp_examine(cqr, irb); 2151da177e4SLinus Torvalds default: 2161da177e4SLinus Torvalds return dasd_era_recover; 2171da177e4SLinus Torvalds } 2181da177e4SLinus Torvalds } 2191da177e4SLinus Torvalds 2201da177e4SLinus Torvalds static dasd_erp_fn_t 2211da177e4SLinus Torvalds dasd_fba_erp_action(struct dasd_ccw_req * cqr) 2221da177e4SLinus Torvalds { 2231da177e4SLinus Torvalds return dasd_default_erp_action; 2241da177e4SLinus Torvalds } 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds static dasd_erp_fn_t 2271da177e4SLinus Torvalds dasd_fba_erp_postaction(struct dasd_ccw_req * cqr) 2281da177e4SLinus Torvalds { 2291da177e4SLinus Torvalds if (cqr->function == dasd_default_erp_action) 2301da177e4SLinus Torvalds return dasd_default_erp_postaction; 2311da177e4SLinus Torvalds 2321da177e4SLinus Torvalds DEV_MESSAGE(KERN_WARNING, cqr->device, "unknown ERP action %p", 2331da177e4SLinus Torvalds cqr->function); 2341da177e4SLinus Torvalds return NULL; 2351da177e4SLinus Torvalds } 2361da177e4SLinus Torvalds 2371da177e4SLinus Torvalds static struct dasd_ccw_req * 2381da177e4SLinus Torvalds dasd_fba_build_cp(struct dasd_device * device, struct request *req) 2391da177e4SLinus Torvalds { 2401da177e4SLinus Torvalds struct dasd_fba_private *private; 2411da177e4SLinus Torvalds unsigned long *idaws; 2421da177e4SLinus Torvalds struct LO_fba_data *LO_data; 2431da177e4SLinus Torvalds struct dasd_ccw_req *cqr; 2441da177e4SLinus Torvalds struct ccw1 *ccw; 2451da177e4SLinus Torvalds struct bio *bio; 2461da177e4SLinus Torvalds struct bio_vec *bv; 2471da177e4SLinus Torvalds char *dst; 2481da177e4SLinus Torvalds int count, cidaw, cplength, datasize; 2491da177e4SLinus Torvalds sector_t recid, first_rec, last_rec; 2501da177e4SLinus Torvalds unsigned int blksize, off; 2511da177e4SLinus Torvalds unsigned char cmd; 2521da177e4SLinus Torvalds int i; 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds private = (struct dasd_fba_private *) device->private; 2551da177e4SLinus Torvalds if (rq_data_dir(req) == READ) { 2561da177e4SLinus Torvalds cmd = DASD_FBA_CCW_READ; 2571da177e4SLinus Torvalds } else if (rq_data_dir(req) == WRITE) { 2581da177e4SLinus Torvalds cmd = DASD_FBA_CCW_WRITE; 2591da177e4SLinus Torvalds } else 2601da177e4SLinus Torvalds return ERR_PTR(-EINVAL); 2611da177e4SLinus Torvalds blksize = device->bp_block; 2621da177e4SLinus Torvalds /* Calculate record id of first and last block. */ 2631da177e4SLinus Torvalds first_rec = req->sector >> device->s2b_shift; 2641da177e4SLinus Torvalds last_rec = (req->sector + req->nr_sectors - 1) >> device->s2b_shift; 2651da177e4SLinus Torvalds /* Check struct bio and count the number of blocks for the request. */ 2661da177e4SLinus Torvalds count = 0; 2671da177e4SLinus Torvalds cidaw = 0; 2681da177e4SLinus Torvalds rq_for_each_bio(bio, req) { 2691da177e4SLinus Torvalds bio_for_each_segment(bv, bio, i) { 2701da177e4SLinus Torvalds if (bv->bv_len & (blksize - 1)) 2711da177e4SLinus Torvalds /* Fba can only do full blocks. */ 2721da177e4SLinus Torvalds return ERR_PTR(-EINVAL); 2731da177e4SLinus Torvalds count += bv->bv_len >> (device->s2b_shift + 9); 274347a8dc3SMartin Schwidefsky #if defined(CONFIG_64BIT) 2751da177e4SLinus Torvalds if (idal_is_needed (page_address(bv->bv_page), 2761da177e4SLinus Torvalds bv->bv_len)) 2771da177e4SLinus Torvalds cidaw += bv->bv_len / blksize; 2781da177e4SLinus Torvalds #endif 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds } 2811da177e4SLinus Torvalds /* Paranoia. */ 2821da177e4SLinus Torvalds if (count != last_rec - first_rec + 1) 2831da177e4SLinus Torvalds return ERR_PTR(-EINVAL); 2841da177e4SLinus Torvalds /* 1x define extent + 1x locate record + number of blocks */ 2851da177e4SLinus Torvalds cplength = 2 + count; 2861da177e4SLinus Torvalds /* 1x define extent + 1x locate record */ 2871da177e4SLinus Torvalds datasize = sizeof(struct DE_fba_data) + sizeof(struct LO_fba_data) + 2881da177e4SLinus Torvalds cidaw * sizeof(unsigned long); 2891da177e4SLinus Torvalds /* 2901da177e4SLinus Torvalds * Find out number of additional locate record ccws if the device 2911da177e4SLinus Torvalds * can't do data chaining. 2921da177e4SLinus Torvalds */ 2931da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain == 0) { 2941da177e4SLinus Torvalds cplength += count - 1; 2951da177e4SLinus Torvalds datasize += (count - 1)*sizeof(struct LO_fba_data); 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds /* Allocate the ccw request. */ 2981da177e4SLinus Torvalds cqr = dasd_smalloc_request(dasd_fba_discipline.name, 2991da177e4SLinus Torvalds cplength, datasize, device); 3001da177e4SLinus Torvalds if (IS_ERR(cqr)) 3011da177e4SLinus Torvalds return cqr; 3021da177e4SLinus Torvalds ccw = cqr->cpaddr; 3031da177e4SLinus Torvalds /* First ccw is define extent. */ 3041da177e4SLinus Torvalds define_extent(ccw++, cqr->data, rq_data_dir(req), 3051da177e4SLinus Torvalds device->bp_block, req->sector, req->nr_sectors); 3061da177e4SLinus Torvalds /* Build locate_record + read/write ccws. */ 3071da177e4SLinus Torvalds idaws = (unsigned long *) (cqr->data + sizeof(struct DE_fba_data)); 3081da177e4SLinus Torvalds LO_data = (struct LO_fba_data *) (idaws + cidaw); 3091da177e4SLinus Torvalds /* Locate record for all blocks for smart devices. */ 3101da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain != 0) { 3111da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_CC; 3121da177e4SLinus Torvalds locate_record(ccw++, LO_data++, rq_data_dir(req), 0, count); 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds recid = first_rec; 3151da177e4SLinus Torvalds rq_for_each_bio(bio, req) bio_for_each_segment(bv, bio, i) { 3161da177e4SLinus Torvalds dst = page_address(bv->bv_page) + bv->bv_offset; 3171da177e4SLinus Torvalds if (dasd_page_cache) { 3181da177e4SLinus Torvalds char *copy = kmem_cache_alloc(dasd_page_cache, 3191da177e4SLinus Torvalds SLAB_DMA | __GFP_NOWARN); 3201da177e4SLinus Torvalds if (copy && rq_data_dir(req) == WRITE) 3211da177e4SLinus Torvalds memcpy(copy + bv->bv_offset, dst, bv->bv_len); 3221da177e4SLinus Torvalds if (copy) 3231da177e4SLinus Torvalds dst = copy + bv->bv_offset; 3241da177e4SLinus Torvalds } 3251da177e4SLinus Torvalds for (off = 0; off < bv->bv_len; off += blksize) { 3261da177e4SLinus Torvalds /* Locate record for stupid devices. */ 3271da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain == 0) { 3281da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_CC; 3291da177e4SLinus Torvalds locate_record(ccw, LO_data++, 3301da177e4SLinus Torvalds rq_data_dir(req), 3311da177e4SLinus Torvalds recid - first_rec, 1); 3321da177e4SLinus Torvalds ccw->flags = CCW_FLAG_CC; 3331da177e4SLinus Torvalds ccw++; 3341da177e4SLinus Torvalds } else { 3351da177e4SLinus Torvalds if (recid > first_rec) 3361da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_DC; 3371da177e4SLinus Torvalds else 3381da177e4SLinus Torvalds ccw[-1].flags |= CCW_FLAG_CC; 3391da177e4SLinus Torvalds } 3401da177e4SLinus Torvalds ccw->cmd_code = cmd; 3411da177e4SLinus Torvalds ccw->count = device->bp_block; 3421da177e4SLinus Torvalds if (idal_is_needed(dst, blksize)) { 3431da177e4SLinus Torvalds ccw->cda = (__u32)(addr_t) idaws; 3441da177e4SLinus Torvalds ccw->flags = CCW_FLAG_IDA; 3451da177e4SLinus Torvalds idaws = idal_create_words(idaws, dst, blksize); 3461da177e4SLinus Torvalds } else { 3471da177e4SLinus Torvalds ccw->cda = (__u32)(addr_t) dst; 3481da177e4SLinus Torvalds ccw->flags = 0; 3491da177e4SLinus Torvalds } 3501da177e4SLinus Torvalds ccw++; 3511da177e4SLinus Torvalds dst += blksize; 3521da177e4SLinus Torvalds recid++; 3531da177e4SLinus Torvalds } 3541da177e4SLinus Torvalds } 3551c01b8a5SHorst Hummel if (req->flags & REQ_FAILFAST) 3561c01b8a5SHorst Hummel set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags); 3571da177e4SLinus Torvalds cqr->device = device; 3581da177e4SLinus Torvalds cqr->expires = 5 * 60 * HZ; /* 5 minutes */ 359d61f6f3dSHorst Hummel cqr->retries = 32; 360d61f6f3dSHorst Hummel cqr->buildclk = get_clock(); 3611da177e4SLinus Torvalds cqr->status = DASD_CQR_FILLED; 3621da177e4SLinus Torvalds return cqr; 3631da177e4SLinus Torvalds } 3641da177e4SLinus Torvalds 3651da177e4SLinus Torvalds static int 3661da177e4SLinus Torvalds dasd_fba_free_cp(struct dasd_ccw_req *cqr, struct request *req) 3671da177e4SLinus Torvalds { 3681da177e4SLinus Torvalds struct dasd_fba_private *private; 3691da177e4SLinus Torvalds struct ccw1 *ccw; 3701da177e4SLinus Torvalds struct bio *bio; 3711da177e4SLinus Torvalds struct bio_vec *bv; 3721da177e4SLinus Torvalds char *dst, *cda; 3731da177e4SLinus Torvalds unsigned int blksize, off; 3741da177e4SLinus Torvalds int i, status; 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds if (!dasd_page_cache) 3771da177e4SLinus Torvalds goto out; 3781da177e4SLinus Torvalds private = (struct dasd_fba_private *) cqr->device->private; 3791da177e4SLinus Torvalds blksize = cqr->device->bp_block; 3801da177e4SLinus Torvalds ccw = cqr->cpaddr; 3811da177e4SLinus Torvalds /* Skip over define extent & locate record. */ 3821da177e4SLinus Torvalds ccw++; 3831da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain != 0) 3841da177e4SLinus Torvalds ccw++; 3851da177e4SLinus Torvalds rq_for_each_bio(bio, req) bio_for_each_segment(bv, bio, i) { 3861da177e4SLinus Torvalds dst = page_address(bv->bv_page) + bv->bv_offset; 3871da177e4SLinus Torvalds for (off = 0; off < bv->bv_len; off += blksize) { 3881da177e4SLinus Torvalds /* Skip locate record. */ 3891da177e4SLinus Torvalds if (private->rdc_data.mode.bits.data_chain == 0) 3901da177e4SLinus Torvalds ccw++; 3911da177e4SLinus Torvalds if (dst) { 3921da177e4SLinus Torvalds if (ccw->flags & CCW_FLAG_IDA) 3931da177e4SLinus Torvalds cda = *((char **)((addr_t) ccw->cda)); 3941da177e4SLinus Torvalds else 3951da177e4SLinus Torvalds cda = (char *)((addr_t) ccw->cda); 3961da177e4SLinus Torvalds if (dst != cda) { 3971da177e4SLinus Torvalds if (rq_data_dir(req) == READ) 3981da177e4SLinus Torvalds memcpy(dst, cda, bv->bv_len); 3991da177e4SLinus Torvalds kmem_cache_free(dasd_page_cache, 4001da177e4SLinus Torvalds (void *)((addr_t)cda & PAGE_MASK)); 4011da177e4SLinus Torvalds } 4021da177e4SLinus Torvalds dst = NULL; 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds ccw++; 4051da177e4SLinus Torvalds } 4061da177e4SLinus Torvalds } 4071da177e4SLinus Torvalds out: 4081da177e4SLinus Torvalds status = cqr->status == DASD_CQR_DONE; 4091da177e4SLinus Torvalds dasd_sfree_request(cqr, cqr->device); 4101da177e4SLinus Torvalds return status; 4111da177e4SLinus Torvalds } 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds static int 4141da177e4SLinus Torvalds dasd_fba_fill_info(struct dasd_device * device, 4151da177e4SLinus Torvalds struct dasd_information2_t * info) 4161da177e4SLinus Torvalds { 4171da177e4SLinus Torvalds info->label_block = 1; 4181da177e4SLinus Torvalds info->FBA_layout = 1; 4191da177e4SLinus Torvalds info->format = DASD_FORMAT_LDL; 4201da177e4SLinus Torvalds info->characteristics_size = sizeof(struct dasd_fba_characteristics); 4211da177e4SLinus Torvalds memcpy(info->characteristics, 4221da177e4SLinus Torvalds &((struct dasd_fba_private *) device->private)->rdc_data, 4231da177e4SLinus Torvalds sizeof (struct dasd_fba_characteristics)); 4241da177e4SLinus Torvalds info->confdata_size = 0; 4251da177e4SLinus Torvalds return 0; 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds static void 4291da177e4SLinus Torvalds dasd_fba_dump_sense(struct dasd_device *device, struct dasd_ccw_req * req, 4301da177e4SLinus Torvalds struct irb *irb) 4311da177e4SLinus Torvalds { 4321da177e4SLinus Torvalds char *page; 4331da177e4SLinus Torvalds struct ccw1 *act, *end, *last; 4341da177e4SLinus Torvalds int len, sl, sct, count; 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds page = (char *) get_zeroed_page(GFP_ATOMIC); 4371da177e4SLinus Torvalds if (page == NULL) { 4381da177e4SLinus Torvalds DEV_MESSAGE(KERN_ERR, device, " %s", 4391da177e4SLinus Torvalds "No memory to dump sense data"); 4401da177e4SLinus Torvalds return; 4411da177e4SLinus Torvalds } 4421da177e4SLinus Torvalds len = sprintf(page, KERN_ERR PRINTK_HEADER 4431da177e4SLinus Torvalds " I/O status report for device %s:\n", 4441da177e4SLinus Torvalds device->cdev->dev.bus_id); 4451da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4461da177e4SLinus Torvalds " in req: %p CS: 0x%02X DS: 0x%02X\n", req, 4471da177e4SLinus Torvalds irb->scsw.cstat, irb->scsw.dstat); 4481da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4491da177e4SLinus Torvalds " device %s: Failing CCW: %p\n", 4501da177e4SLinus Torvalds device->cdev->dev.bus_id, 4511da177e4SLinus Torvalds (void *) (addr_t) irb->scsw.cpa); 4521da177e4SLinus Torvalds if (irb->esw.esw0.erw.cons) { 4531da177e4SLinus Torvalds for (sl = 0; sl < 4; sl++) { 4541da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4551da177e4SLinus Torvalds " Sense(hex) %2d-%2d:", 4561da177e4SLinus Torvalds (8 * sl), ((8 * sl) + 7)); 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds for (sct = 0; sct < 8; sct++) { 4591da177e4SLinus Torvalds len += sprintf(page + len, " %02x", 4601da177e4SLinus Torvalds irb->ecw[8 * sl + sct]); 4611da177e4SLinus Torvalds } 4621da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 4631da177e4SLinus Torvalds } 4641da177e4SLinus Torvalds } else { 4651da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4661da177e4SLinus Torvalds " SORRY - NO VALID SENSE AVAILABLE\n"); 4671da177e4SLinus Torvalds } 4681da177e4SLinus Torvalds MESSAGE_LOG(KERN_ERR, "%s", 4691da177e4SLinus Torvalds page + sizeof(KERN_ERR PRINTK_HEADER)); 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds /* dump the Channel Program */ 4721da177e4SLinus Torvalds /* print first CCWs (maximum 8) */ 4731da177e4SLinus Torvalds act = req->cpaddr; 4741da177e4SLinus Torvalds for (last = act; last->flags & (CCW_FLAG_CC | CCW_FLAG_DC); last++); 4751da177e4SLinus Torvalds end = min(act + 8, last); 4761da177e4SLinus Torvalds len = sprintf(page, KERN_ERR PRINTK_HEADER 4771da177e4SLinus Torvalds " Related CP in req: %p\n", req); 4781da177e4SLinus Torvalds while (act <= end) { 4791da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 4801da177e4SLinus Torvalds " CCW %p: %08X %08X DAT:", 4811da177e4SLinus Torvalds act, ((int *) act)[0], ((int *) act)[1]); 4821da177e4SLinus Torvalds for (count = 0; count < 32 && count < act->count; 4831da177e4SLinus Torvalds count += sizeof(int)) 4841da177e4SLinus Torvalds len += sprintf(page + len, " %08X", 4851da177e4SLinus Torvalds ((int *) (addr_t) act->cda) 4861da177e4SLinus Torvalds [(count>>2)]); 4871da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 4881da177e4SLinus Torvalds act++; 4891da177e4SLinus Torvalds } 4901da177e4SLinus Torvalds MESSAGE_LOG(KERN_ERR, "%s", 4911da177e4SLinus Torvalds page + sizeof(KERN_ERR PRINTK_HEADER)); 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds /* print failing CCW area */ 4951da177e4SLinus Torvalds len = 0; 4961da177e4SLinus Torvalds if (act < ((struct ccw1 *)(addr_t) irb->scsw.cpa) - 2) { 4971da177e4SLinus Torvalds act = ((struct ccw1 *)(addr_t) irb->scsw.cpa) - 2; 4981da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER "......\n"); 4991da177e4SLinus Torvalds } 5001da177e4SLinus Torvalds end = min((struct ccw1 *)(addr_t) irb->scsw.cpa + 2, last); 5011da177e4SLinus Torvalds while (act <= end) { 5021da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 5031da177e4SLinus Torvalds " CCW %p: %08X %08X DAT:", 5041da177e4SLinus Torvalds act, ((int *) act)[0], ((int *) act)[1]); 5051da177e4SLinus Torvalds for (count = 0; count < 32 && count < act->count; 5061da177e4SLinus Torvalds count += sizeof(int)) 5071da177e4SLinus Torvalds len += sprintf(page + len, " %08X", 5081da177e4SLinus Torvalds ((int *) (addr_t) act->cda) 5091da177e4SLinus Torvalds [(count>>2)]); 5101da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 5111da177e4SLinus Torvalds act++; 5121da177e4SLinus Torvalds } 5131da177e4SLinus Torvalds 5141da177e4SLinus Torvalds /* print last CCWs */ 5151da177e4SLinus Torvalds if (act < last - 2) { 5161da177e4SLinus Torvalds act = last - 2; 5171da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER "......\n"); 5181da177e4SLinus Torvalds } 5191da177e4SLinus Torvalds while (act <= last) { 5201da177e4SLinus Torvalds len += sprintf(page + len, KERN_ERR PRINTK_HEADER 5211da177e4SLinus Torvalds " CCW %p: %08X %08X DAT:", 5221da177e4SLinus Torvalds act, ((int *) act)[0], ((int *) act)[1]); 5231da177e4SLinus Torvalds for (count = 0; count < 32 && count < act->count; 5241da177e4SLinus Torvalds count += sizeof(int)) 5251da177e4SLinus Torvalds len += sprintf(page + len, " %08X", 5261da177e4SLinus Torvalds ((int *) (addr_t) act->cda) 5271da177e4SLinus Torvalds [(count>>2)]); 5281da177e4SLinus Torvalds len += sprintf(page + len, "\n"); 5291da177e4SLinus Torvalds act++; 5301da177e4SLinus Torvalds } 5311da177e4SLinus Torvalds if (len > 0) 5321da177e4SLinus Torvalds MESSAGE_LOG(KERN_ERR, "%s", 5331da177e4SLinus Torvalds page + sizeof(KERN_ERR PRINTK_HEADER)); 5341da177e4SLinus Torvalds free_page((unsigned long) page); 5351da177e4SLinus Torvalds } 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds /* 5381da177e4SLinus Torvalds * max_blocks is dependent on the amount of storage that is available 5391da177e4SLinus Torvalds * in the static io buffer for each device. Currently each device has 5401da177e4SLinus Torvalds * 8192 bytes (=2 pages). For 64 bit one dasd_mchunkt_t structure has 5411da177e4SLinus Torvalds * 24 bytes, the struct dasd_ccw_req has 136 bytes and each block can use 5421da177e4SLinus Torvalds * up to 16 bytes (8 for the ccw and 8 for the idal pointer). In 5431da177e4SLinus Torvalds * addition we have one define extent ccw + 16 bytes of data and a 5441da177e4SLinus Torvalds * locate record ccw for each block (stupid devices!) + 16 bytes of data. 5451da177e4SLinus Torvalds * That makes: 5461da177e4SLinus Torvalds * (8192 - 24 - 136 - 8 - 16) / 40 = 200.2 blocks at maximum. 5471da177e4SLinus Torvalds * We want to fit two into the available memory so that we can immediately 5481da177e4SLinus Torvalds * start the next request if one finishes off. That makes 100.1 blocks 5491da177e4SLinus Torvalds * for one request. Give a little safety and the result is 96. 5501da177e4SLinus Torvalds */ 5511da177e4SLinus Torvalds static struct dasd_discipline dasd_fba_discipline = { 5521da177e4SLinus Torvalds .owner = THIS_MODULE, 5531da177e4SLinus Torvalds .name = "FBA ", 5541da177e4SLinus Torvalds .ebcname = "FBA ", 5551da177e4SLinus Torvalds .max_blocks = 96, 5561da177e4SLinus Torvalds .check_device = dasd_fba_check_characteristics, 5571da177e4SLinus Torvalds .do_analysis = dasd_fba_do_analysis, 5581da177e4SLinus Torvalds .fill_geometry = dasd_fba_fill_geometry, 5591da177e4SLinus Torvalds .start_IO = dasd_start_IO, 5601da177e4SLinus Torvalds .term_IO = dasd_term_IO, 5611da177e4SLinus Torvalds .examine_error = dasd_fba_examine_error, 5621da177e4SLinus Torvalds .erp_action = dasd_fba_erp_action, 5631da177e4SLinus Torvalds .erp_postaction = dasd_fba_erp_postaction, 5641da177e4SLinus Torvalds .build_cp = dasd_fba_build_cp, 5651da177e4SLinus Torvalds .free_cp = dasd_fba_free_cp, 5661da177e4SLinus Torvalds .dump_sense = dasd_fba_dump_sense, 5671da177e4SLinus Torvalds .fill_info = dasd_fba_fill_info, 5681da177e4SLinus Torvalds }; 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds static int __init 5711da177e4SLinus Torvalds dasd_fba_init(void) 5721da177e4SLinus Torvalds { 5731da177e4SLinus Torvalds int ret; 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds ASCEBC(dasd_fba_discipline.ebcname, 4); 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds ret = ccw_driver_register(&dasd_fba_driver); 5781da177e4SLinus Torvalds if (ret) 5791da177e4SLinus Torvalds return ret; 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds dasd_generic_auto_online(&dasd_fba_driver); 5821da177e4SLinus Torvalds return 0; 5831da177e4SLinus Torvalds } 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds static void __exit 5861da177e4SLinus Torvalds dasd_fba_cleanup(void) 5871da177e4SLinus Torvalds { 5881da177e4SLinus Torvalds ccw_driver_unregister(&dasd_fba_driver); 5891da177e4SLinus Torvalds } 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds module_init(dasd_fba_init); 5921da177e4SLinus Torvalds module_exit(dasd_fba_cleanup); 5931da177e4SLinus Torvalds 5941da177e4SLinus Torvalds /* 5951da177e4SLinus Torvalds * Overrides for Emacs so that we follow Linus's tabbing style. 5961da177e4SLinus Torvalds * Emacs will notice this stuff at the end of the file and automatically 5971da177e4SLinus Torvalds * adjust the settings for this buffer only. This must remain at the end 5981da177e4SLinus Torvalds * of the file. 5991da177e4SLinus Torvalds * --------------------------------------------------------------------------- 6001da177e4SLinus Torvalds * Local variables: 6011da177e4SLinus Torvalds * c-indent-level: 4 6021da177e4SLinus Torvalds * c-brace-imaginary-offset: 0 6031da177e4SLinus Torvalds * c-brace-offset: -4 6041da177e4SLinus Torvalds * c-argdecl-indent: 4 6051da177e4SLinus Torvalds * c-label-offset: -4 6061da177e4SLinus Torvalds * c-continued-statement-offset: 4 6071da177e4SLinus Torvalds * c-continued-brace-offset: 0 6081da177e4SLinus Torvalds * indent-tabs-mode: 1 6091da177e4SLinus Torvalds * tab-width: 8 6101da177e4SLinus Torvalds * End: 6111da177e4SLinus Torvalds */ 612