tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

s390/dasd: use new address translation helpers

Use virt_to_dma32() and friends to properly convert virtual to physical and
physical to virtual addresses so that "make C=1" does not generate any
warnings anymore.

Reviewed-by: Stefan Haberland <sth@linux.ibm.com>
Signed-off-by: Heiko Carstens <hca@linux.ibm.com>

Heiko Carstens c0bd3960 bdd0ab97

+76 -76
+2 -2
drivers/s390/block/dasd.c
··· 3976 3976 3977 3977 ccw = cqr->cpaddr; 3978 3978 ccw->cmd_code = CCW_CMD_RDC; 3979 - ccw->cda = (__u32)virt_to_phys(cqr->data); 3979 + ccw->cda = virt_to_dma32(cqr->data); 3980 3980 ccw->flags = 0; 3981 3981 ccw->count = rdc_buffer_size; 3982 3982 cqr->startdev = device; ··· 4020 4020 4021 4021 if (scsw_is_tm(&irb->scsw) && (irb->scsw.tm.fcxs == 0x01)) { 4022 4022 if (irb->scsw.tm.tcw) 4023 - tsb = tcw_get_tsb(phys_to_virt(irb->scsw.tm.tcw)); 4023 + tsb = tcw_get_tsb(dma32_to_virt(irb->scsw.tm.tcw)); 4024 4024 if (tsb && tsb->length == 64 && tsb->flags) 4025 4025 switch (tsb->flags & 0x07) { 4026 4026 case 1: /* tsa_iostat */
+7 -7
drivers/s390/block/dasd_3990_erp.c
··· 216 216 memset(ccw, 0, sizeof(struct ccw1)); 217 217 ccw->cmd_code = CCW_CMD_DCTL; 218 218 ccw->count = 4; 219 - ccw->cda = (__u32)virt_to_phys(DCTL_data); 219 + ccw->cda = virt_to_dma32(DCTL_data); 220 220 dctl_cqr->flags = erp->flags; 221 221 dctl_cqr->function = dasd_3990_erp_DCTL; 222 222 dctl_cqr->refers = erp; ··· 1589 1589 { 1590 1590 1591 1591 struct dasd_device *device = default_erp->startdev; 1592 - __u32 cpa = 0; 1592 + dma32_t cpa = 0; 1593 1593 struct dasd_ccw_req *cqr; 1594 1594 struct dasd_ccw_req *erp; 1595 1595 struct DE_eckd_data *DE_data; ··· 1693 1693 ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT; 1694 1694 ccw->flags = CCW_FLAG_CC; 1695 1695 ccw->count = 16; 1696 - ccw->cda = (__u32)virt_to_phys(DE_data); 1696 + ccw->cda = virt_to_dma32(DE_data); 1697 1697 1698 1698 /* create LO ccw */ 1699 1699 ccw++; ··· 1701 1701 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD; 1702 1702 ccw->flags = CCW_FLAG_CC; 1703 1703 ccw->count = 16; 1704 - ccw->cda = (__u32)virt_to_phys(LO_data); 1704 + ccw->cda = virt_to_dma32(LO_data); 1705 1705 1706 1706 /* TIC to the failed ccw */ 1707 1707 ccw++; ··· 1747 1747 { 1748 1748 1749 1749 struct dasd_device *device = previous_erp->startdev; 1750 - __u32 cpa = 0; 1750 + dma32_t cpa = 0; 1751 1751 struct dasd_ccw_req *cqr; 1752 1752 struct dasd_ccw_req *erp; 1753 1753 char *LO_data; /* struct LO_eckd_data */ ··· 2386 2386 tcw = erp->cpaddr; 2387 2387 tsb = (struct tsb *) &tcw[1]; 2388 2388 *tcw = *((struct tcw *)cqr->cpaddr); 2389 - tcw->tsb = virt_to_phys(tsb); 2389 + tcw->tsb = virt_to_dma64(tsb); 2390 2390 } else if (ccw->cmd_code == DASD_ECKD_CCW_PSF) { 2391 2391 /* PSF cannot be chained from NOOP/TIC */ 2392 2392 erp->cpaddr = cqr->cpaddr; ··· 2397 2397 ccw->flags = CCW_FLAG_CC; 2398 2398 ccw++; 2399 2399 ccw->cmd_code = CCW_CMD_TIC; 2400 - ccw->cda = (__u32)virt_to_phys(cqr->cpaddr); 2400 + ccw->cda = virt_to_dma32(cqr->cpaddr); 2401 2401 } 2402 2402 2403 2403 erp->flags = cqr->flags;
+3 -3
drivers/s390/block/dasd_alias.c
··· 435 435 ccw->cmd_code = DASD_ECKD_CCW_PSF; 436 436 ccw->count = sizeof(struct dasd_psf_prssd_data); 437 437 ccw->flags |= CCW_FLAG_CC; 438 - ccw->cda = (__u32)virt_to_phys(prssdp); 438 + ccw->cda = virt_to_dma32(prssdp); 439 439 440 440 /* Read Subsystem Data - feature codes */ 441 441 memset(lcu->uac, 0, sizeof(*(lcu->uac))); ··· 443 443 ccw++; 444 444 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 445 445 ccw->count = sizeof(*(lcu->uac)); 446 - ccw->cda = (__u32)virt_to_phys(lcu->uac); 446 + ccw->cda = virt_to_dma32(lcu->uac); 447 447 448 448 cqr->buildclk = get_tod_clock(); 449 449 cqr->status = DASD_CQR_FILLED; ··· 739 739 ccw->cmd_code = DASD_ECKD_CCW_RSCK; 740 740 ccw->flags = CCW_FLAG_SLI; 741 741 ccw->count = 16; 742 - ccw->cda = (__u32)virt_to_phys(cqr->data); 742 + ccw->cda = virt_to_dma32(cqr->data); 743 743 ((char *)cqr->data)[0] = reason; 744 744 745 745 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
+49 -49
drivers/s390/block/dasd_eckd.c
··· 283 283 ccw->cmd_code = DASD_ECKD_CCW_DEFINE_EXTENT; 284 284 ccw->flags = 0; 285 285 ccw->count = 16; 286 - ccw->cda = (__u32)virt_to_phys(data); 286 + ccw->cda = virt_to_dma32(data); 287 287 } 288 288 289 289 memset(data, 0, sizeof(struct DE_eckd_data)); ··· 393 393 ccw->count = 22; 394 394 else 395 395 ccw->count = 20; 396 - ccw->cda = (__u32)virt_to_phys(data); 396 + ccw->cda = virt_to_dma32(data); 397 397 } 398 398 399 399 memset(data, 0, sizeof(*data)); ··· 539 539 ccw->flags = 0; 540 540 if (cmd == DASD_ECKD_CCW_WRITE_FULL_TRACK) { 541 541 ccw->count = sizeof(*pfxdata) + 2; 542 - ccw->cda = (__u32)virt_to_phys(pfxdata); 542 + ccw->cda = virt_to_dma32(pfxdata); 543 543 memset(pfxdata, 0, sizeof(*pfxdata) + 2); 544 544 } else { 545 545 ccw->count = sizeof(*pfxdata); 546 - ccw->cda = (__u32)virt_to_phys(pfxdata); 546 + ccw->cda = virt_to_dma32(pfxdata); 547 547 memset(pfxdata, 0, sizeof(*pfxdata)); 548 548 } 549 549 ··· 610 610 ccw->cmd_code = DASD_ECKD_CCW_LOCATE_RECORD; 611 611 ccw->flags = 0; 612 612 ccw->count = 16; 613 - ccw->cda = (__u32)virt_to_phys(data); 613 + ccw->cda = virt_to_dma32(data); 614 614 615 615 memset(data, 0, sizeof(struct LO_eckd_data)); 616 616 sector = 0; ··· 825 825 ccw = cqr->cpaddr; 826 826 ccw->cmd_code = DASD_ECKD_CCW_RCD; 827 827 ccw->flags = 0; 828 - ccw->cda = (__u32)virt_to_phys(rcd_buffer); 828 + ccw->cda = virt_to_dma32(rcd_buffer); 829 829 ccw->count = DASD_ECKD_RCD_DATA_SIZE; 830 830 cqr->magic = DASD_ECKD_MAGIC; 831 831 ··· 853 853 854 854 if (cqr->status != DASD_CQR_DONE) { 855 855 ccw = cqr->cpaddr; 856 - rcd_buffer = phys_to_virt(ccw->cda); 856 + rcd_buffer = dma32_to_virt(ccw->cda); 857 857 memset(rcd_buffer, 0, sizeof(*rcd_buffer)); 858 858 859 859 rcd_buffer[0] = 0xE5; ··· 1534 1534 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1535 1535 ccw->count = sizeof(struct dasd_psf_prssd_data); 1536 1536 ccw->flags |= CCW_FLAG_CC; 1537 - ccw->cda = (__u32)virt_to_phys(prssdp); 1537 + ccw->cda = virt_to_dma32(prssdp); 1538 1538 1539 1539 /* Read Subsystem Data - feature codes */ 1540 1540 features = (struct dasd_rssd_features *) (prssdp + 1); ··· 1543 1543 ccw++; 1544 1544 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 1545 1545 ccw->count = sizeof(struct dasd_rssd_features); 1546 - ccw->cda = (__u32)virt_to_phys(features); 1546 + ccw->cda = virt_to_dma32(features); 1547 1547 1548 1548 cqr->buildclk = get_tod_clock(); 1549 1549 cqr->status = DASD_CQR_FILLED; ··· 1603 1603 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1604 1604 ccw->count = sizeof(*prssdp); 1605 1605 ccw->flags |= CCW_FLAG_CC; 1606 - ccw->cda = (__u32)virt_to_phys(prssdp); 1606 + ccw->cda = virt_to_dma32(prssdp); 1607 1607 1608 1608 /* Read Subsystem Data - Volume Storage Query */ 1609 1609 vsq = (struct dasd_rssd_vsq *)(prssdp + 1); ··· 1613 1613 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 1614 1614 ccw->count = sizeof(*vsq); 1615 1615 ccw->flags |= CCW_FLAG_SLI; 1616 - ccw->cda = (__u32)virt_to_phys(vsq); 1616 + ccw->cda = virt_to_dma32(vsq); 1617 1617 1618 1618 cqr->buildclk = get_tod_clock(); 1619 1619 cqr->status = DASD_CQR_FILLED; ··· 1788 1788 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1789 1789 ccw->count = sizeof(*prssdp); 1790 1790 ccw->flags |= CCW_FLAG_CC; 1791 - ccw->cda = (__u32)virt_to_phys(prssdp); 1791 + ccw->cda = virt_to_dma32(prssdp); 1792 1792 1793 1793 lcq = (struct dasd_rssd_lcq *)(prssdp + 1); 1794 1794 memset(lcq, 0, sizeof(*lcq)); ··· 1797 1797 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 1798 1798 ccw->count = sizeof(*lcq); 1799 1799 ccw->flags |= CCW_FLAG_SLI; 1800 - ccw->cda = (__u32)virt_to_phys(lcq); 1800 + ccw->cda = virt_to_dma32(lcq); 1801 1801 1802 1802 cqr->buildclk = get_tod_clock(); 1803 1803 cqr->status = DASD_CQR_FILLED; ··· 1894 1894 } 1895 1895 ccw = cqr->cpaddr; 1896 1896 ccw->cmd_code = DASD_ECKD_CCW_PSF; 1897 - ccw->cda = (__u32)virt_to_phys(psf_ssc_data); 1897 + ccw->cda = virt_to_dma32(psf_ssc_data); 1898 1898 ccw->count = 66; 1899 1899 1900 1900 cqr->startdev = device; ··· 2250 2250 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 2251 2251 ccw->flags = 0; 2252 2252 ccw->count = 8; 2253 - ccw->cda = (__u32)virt_to_phys(count_data); 2253 + ccw->cda = virt_to_dma32(count_data); 2254 2254 ccw++; 2255 2255 count_data++; 2256 2256 } ··· 2264 2264 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 2265 2265 ccw->flags = 0; 2266 2266 ccw->count = 8; 2267 - ccw->cda = (__u32)virt_to_phys(count_data); 2267 + ccw->cda = virt_to_dma32(count_data); 2268 2268 2269 2269 cqr->block = NULL; 2270 2270 cqr->startdev = device; ··· 2635 2635 ccw->cmd_code = DASD_ECKD_CCW_READ_COUNT; 2636 2636 ccw->flags = CCW_FLAG_SLI; 2637 2637 ccw->count = 8; 2638 - ccw->cda = (__u32)virt_to_phys(fmt_buffer); 2638 + ccw->cda = virt_to_dma32(fmt_buffer); 2639 2639 ccw++; 2640 2640 fmt_buffer++; 2641 2641 } ··· 2845 2845 ccw->cmd_code = DASD_ECKD_CCW_WRITE_RECORD_ZERO; 2846 2846 ccw->flags = CCW_FLAG_SLI; 2847 2847 ccw->count = 8; 2848 - ccw->cda = (__u32)virt_to_phys(ect); 2848 + ccw->cda = virt_to_dma32(ect); 2849 2849 ccw++; 2850 2850 } 2851 2851 if ((intensity & ~0x08) & 0x04) { /* erase track */ ··· 2860 2860 ccw->cmd_code = DASD_ECKD_CCW_WRITE_CKD; 2861 2861 ccw->flags = CCW_FLAG_SLI; 2862 2862 ccw->count = 8; 2863 - ccw->cda = (__u32)virt_to_phys(ect); 2863 + ccw->cda = virt_to_dma32(ect); 2864 2864 } else { /* write remaining records */ 2865 2865 for (i = 0; i < rpt; i++) { 2866 2866 ect = (struct eckd_count *) data; ··· 2895 2895 DASD_ECKD_CCW_WRITE_CKD_MT; 2896 2896 ccw->flags = CCW_FLAG_SLI; 2897 2897 ccw->count = 8; 2898 - ccw->cda = (__u32)virt_to_phys(ect); 2898 + ccw->cda = virt_to_dma32(ect); 2899 2899 ccw++; 2900 2900 } 2901 2901 } ··· 3836 3836 } 3837 3837 3838 3838 ccw = cqr->cpaddr; 3839 - ccw->cda = (__u32)virt_to_phys(cqr->data); 3839 + ccw->cda = virt_to_dma32(cqr->data); 3840 3840 ccw->cmd_code = DASD_ECKD_CCW_DSO; 3841 3841 ccw->count = size; 3842 3842 ··· 4105 4105 ccw->cmd_code = rcmd; 4106 4106 ccw->count = count; 4107 4107 if (idal_is_needed(dst, blksize)) { 4108 - ccw->cda = (__u32)virt_to_phys(idaws); 4108 + ccw->cda = virt_to_dma32(idaws); 4109 4109 ccw->flags = CCW_FLAG_IDA; 4110 4110 idaws = idal_create_words(idaws, dst, blksize); 4111 4111 } else { 4112 - ccw->cda = (__u32)virt_to_phys(dst); 4112 + ccw->cda = virt_to_dma32(dst); 4113 4113 ccw->flags = 0; 4114 4114 } 4115 4115 ccw++; ··· 4243 4243 ccw[-1].flags |= CCW_FLAG_CC; 4244 4244 ccw->cmd_code = cmd; 4245 4245 ccw->count = len_to_track_end; 4246 - ccw->cda = (__u32)virt_to_phys(idaws); 4246 + ccw->cda = virt_to_dma32(idaws); 4247 4247 ccw->flags = CCW_FLAG_IDA; 4248 4248 ccw++; 4249 4249 recid += count; ··· 4832 4832 ccw->count = 57326; 4833 4833 /* 64k map to one track */ 4834 4834 len_to_track_end = 65536 - start_padding_sectors * 512; 4835 - ccw->cda = (__u32)virt_to_phys(idaws); 4835 + ccw->cda = virt_to_dma32(idaws); 4836 4836 ccw->flags |= CCW_FLAG_IDA; 4837 4837 ccw->flags |= CCW_FLAG_SLI; 4838 4838 ccw++; ··· 4851 4851 ccw->count = 57326; 4852 4852 /* 64k map to one track */ 4853 4853 len_to_track_end = 65536; 4854 - ccw->cda = (__u32)virt_to_phys(idaws); 4854 + ccw->cda = virt_to_dma32(idaws); 4855 4855 ccw->flags |= CCW_FLAG_IDA; 4856 4856 ccw->flags |= CCW_FLAG_SLI; 4857 4857 ccw++; ··· 4908 4908 ccw++; 4909 4909 if (dst) { 4910 4910 if (ccw->flags & CCW_FLAG_IDA) 4911 - cda = *((char **)phys_to_virt(ccw->cda)); 4911 + cda = *((char **)dma32_to_virt(ccw->cda)); 4912 4912 else 4913 - cda = phys_to_virt(ccw->cda); 4913 + cda = dma32_to_virt(ccw->cda); 4914 4914 if (dst != cda) { 4915 4915 if (rq_data_dir(req) == READ) 4916 4916 memcpy(dst, cda, bv.bv_len); ··· 5060 5060 ccw->cmd_code = DASD_ECKD_CCW_RELEASE; 5061 5061 ccw->flags |= CCW_FLAG_SLI; 5062 5062 ccw->count = 32; 5063 - ccw->cda = (__u32)virt_to_phys(cqr->data); 5063 + ccw->cda = virt_to_dma32(cqr->data); 5064 5064 cqr->startdev = device; 5065 5065 cqr->memdev = device; 5066 5066 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); ··· 5115 5115 ccw->cmd_code = DASD_ECKD_CCW_RESERVE; 5116 5116 ccw->flags |= CCW_FLAG_SLI; 5117 5117 ccw->count = 32; 5118 - ccw->cda = (__u32)virt_to_phys(cqr->data); 5118 + ccw->cda = virt_to_dma32(cqr->data); 5119 5119 cqr->startdev = device; 5120 5120 cqr->memdev = device; 5121 5121 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); ··· 5169 5169 ccw->cmd_code = DASD_ECKD_CCW_SLCK; 5170 5170 ccw->flags |= CCW_FLAG_SLI; 5171 5171 ccw->count = 32; 5172 - ccw->cda = (__u32)virt_to_phys(cqr->data); 5172 + ccw->cda = virt_to_dma32(cqr->data); 5173 5173 cqr->startdev = device; 5174 5174 cqr->memdev = device; 5175 5175 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); ··· 5230 5230 ccw->cmd_code = DASD_ECKD_CCW_SNID; 5231 5231 ccw->flags |= CCW_FLAG_SLI; 5232 5232 ccw->count = 12; 5233 - ccw->cda = (__u32)virt_to_phys(cqr->data); 5233 + ccw->cda = virt_to_dma32(cqr->data); 5234 5234 cqr->startdev = device; 5235 5235 cqr->memdev = device; 5236 5236 clear_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags); ··· 5297 5297 ccw->cmd_code = DASD_ECKD_CCW_PSF; 5298 5298 ccw->count = sizeof(struct dasd_psf_prssd_data); 5299 5299 ccw->flags |= CCW_FLAG_CC; 5300 - ccw->cda = (__u32)virt_to_phys(prssdp); 5300 + ccw->cda = virt_to_dma32(prssdp); 5301 5301 5302 5302 /* Read Subsystem Data - Performance Statistics */ 5303 5303 stats = (struct dasd_rssd_perf_stats_t *) (prssdp + 1); ··· 5306 5306 ccw++; 5307 5307 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 5308 5308 ccw->count = sizeof(struct dasd_rssd_perf_stats_t); 5309 - ccw->cda = (__u32)virt_to_phys(stats); 5309 + ccw->cda = virt_to_dma32(stats); 5310 5310 5311 5311 cqr->buildclk = get_tod_clock(); 5312 5312 cqr->status = DASD_CQR_FILLED; ··· 5450 5450 ccw->cmd_code = DASD_ECKD_CCW_PSF; 5451 5451 ccw->count = usrparm.psf_data_len; 5452 5452 ccw->flags |= CCW_FLAG_CC; 5453 - ccw->cda = (__u32)virt_to_phys(psf_data); 5453 + ccw->cda = virt_to_dma32(psf_data); 5454 5454 5455 5455 ccw++; 5456 5456 ··· 5458 5458 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 5459 5459 ccw->count = usrparm.rssd_result_len; 5460 5460 ccw->flags = CCW_FLAG_SLI ; 5461 - ccw->cda = (__u32)virt_to_phys(rssd_result); 5461 + ccw->cda = virt_to_dma32(rssd_result); 5462 5462 5463 5463 rc = dasd_sleep_on(cqr); 5464 5464 if (rc) ··· 5527 5527 5528 5528 /* get pointer to data (consider IDALs) */ 5529 5529 if (from->flags & CCW_FLAG_IDA) 5530 - datap = (char *)*((addr_t *)phys_to_virt(from->cda)); 5530 + datap = (char *)*((addr_t *)dma32_to_virt(from->cda)); 5531 5531 else 5532 - datap = phys_to_virt(from->cda); 5532 + datap = dma32_to_virt(from->cda); 5533 5533 5534 5534 /* dump data (max 128 bytes) */ 5535 5535 for (count = 0; count < from->count && count < 128; count++) { ··· 5598 5598 scsw_dstat(&irb->scsw), scsw_cstat(&irb->scsw), 5599 5599 req ? req->intrc : 0); 5600 5600 len += sprintf(page + len, "Failing CCW: %px\n", 5601 - phys_to_virt(irb->scsw.cmd.cpa)); 5601 + dma32_to_virt(irb->scsw.cmd.cpa)); 5602 5602 if (irb->esw.esw0.erw.cons) { 5603 5603 for (sl = 0; sl < 4; sl++) { 5604 5604 len += sprintf(page + len, "Sense(hex) %2d-%2d:", ··· 5641 5641 /* print failing CCW area (maximum 4) */ 5642 5642 /* scsw->cda is either valid or zero */ 5643 5643 from = ++to; 5644 - fail = phys_to_virt(irb->scsw.cmd.cpa); /* failing CCW */ 5644 + fail = dma32_to_virt(irb->scsw.cmd.cpa); /* failing CCW */ 5645 5645 if (from < fail - 2) { 5646 5646 from = fail - 2; /* there is a gap - print header */ 5647 5647 dev_err(dev, "......\n"); ··· 5691 5691 (irb->scsw.tm.ifob << 7) | irb->scsw.tm.sesq, 5692 5692 req ? req->intrc : 0); 5693 5693 len += sprintf(page + len, "Failing TCW: %px\n", 5694 - phys_to_virt(irb->scsw.tm.tcw)); 5694 + dma32_to_virt(irb->scsw.tm.tcw)); 5695 5695 5696 5696 tsb = NULL; 5697 5697 sense = NULL; 5698 5698 if (irb->scsw.tm.tcw && (irb->scsw.tm.fcxs & 0x01)) 5699 - tsb = tcw_get_tsb(phys_to_virt(irb->scsw.tm.tcw)); 5699 + tsb = tcw_get_tsb(dma32_to_virt(irb->scsw.tm.tcw)); 5700 5700 5701 5701 if (tsb) { 5702 5702 len += sprintf(page + len, "tsb->length %d\n", tsb->length); ··· 5906 5906 ccw->count = sizeof(struct dasd_psf_prssd_data); 5907 5907 ccw->flags |= CCW_FLAG_CC; 5908 5908 ccw->flags |= CCW_FLAG_SLI; 5909 - ccw->cda = (__u32)virt_to_phys(prssdp); 5909 + ccw->cda = virt_to_dma32(prssdp); 5910 5910 5911 5911 /* Read Subsystem Data - message buffer */ 5912 5912 message_buf = (struct dasd_rssd_messages *) (prssdp + 1); ··· 5916 5916 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 5917 5917 ccw->count = sizeof(struct dasd_rssd_messages); 5918 5918 ccw->flags |= CCW_FLAG_SLI; 5919 - ccw->cda = (__u32)virt_to_phys(message_buf); 5919 + ccw->cda = virt_to_dma32(message_buf); 5920 5920 5921 5921 cqr->buildclk = get_tod_clock(); 5922 5922 cqr->status = DASD_CQR_FILLED; ··· 5997 5997 ccw->count = sizeof(struct dasd_psf_prssd_data); 5998 5998 ccw->flags |= CCW_FLAG_CC; 5999 5999 ccw->flags |= CCW_FLAG_SLI; 6000 - ccw->cda = (__u32)virt_to_phys(prssdp); 6000 + ccw->cda = virt_to_dma32(prssdp); 6001 6001 6002 6002 /* Read Subsystem Data - query host access */ 6003 6003 ccw++; 6004 6004 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 6005 6005 ccw->count = sizeof(struct dasd_psf_query_host_access); 6006 6006 ccw->flags |= CCW_FLAG_SLI; 6007 - ccw->cda = (__u32)virt_to_phys(host_access); 6007 + ccw->cda = virt_to_dma32(host_access); 6008 6008 6009 6009 cqr->buildclk = get_tod_clock(); 6010 6010 cqr->status = DASD_CQR_FILLED; ··· 6239 6239 ccw->count = sizeof(struct dasd_psf_prssd_data); 6240 6240 ccw->flags |= CCW_FLAG_CC; 6241 6241 ccw->flags |= CCW_FLAG_SLI; 6242 - ccw->cda = (__u32)virt_to_phys(prssdp); 6242 + ccw->cda = virt_to_dma32(prssdp); 6243 6243 6244 6244 /* Read Subsystem Data - query host access */ 6245 6245 ccw++; 6246 6246 ccw->cmd_code = DASD_ECKD_CCW_RSSD; 6247 6247 ccw->count = sizeof(*pprc_data); 6248 6248 ccw->flags |= CCW_FLAG_SLI; 6249 - ccw->cda = (__u32)virt_to_phys(pprc_data); 6249 + ccw->cda = virt_to_dma32(pprc_data); 6250 6250 6251 6251 cqr->buildclk = get_tod_clock(); 6252 6252 cqr->status = DASD_CQR_FILLED; ··· 6340 6340 psf_cuir->ssid = device->path[pos].ssid; 6341 6341 ccw = cqr->cpaddr; 6342 6342 ccw->cmd_code = DASD_ECKD_CCW_PSF; 6343 - ccw->cda = (__u32)virt_to_phys(psf_cuir); 6343 + ccw->cda = virt_to_dma32(psf_cuir); 6344 6344 ccw->flags = CCW_FLAG_SLI; 6345 6345 ccw->count = sizeof(struct dasd_psf_cuir_response); 6346 6346
+1 -1
drivers/s390/block/dasd_eer.c
··· 485 485 ccw->cmd_code = DASD_ECKD_CCW_SNSS; 486 486 ccw->count = SNSS_DATA_SIZE; 487 487 ccw->flags = 0; 488 - ccw->cda = (__u32)virt_to_phys(cqr->data); 488 + ccw->cda = virt_to_dma32(cqr->data); 489 489 490 490 cqr->buildclk = get_tod_clock(); 491 491 cqr->status = DASD_CQR_FILLED;
+14 -14
drivers/s390/block/dasd_fba.c
··· 78 78 ccw->cmd_code = DASD_FBA_CCW_DEFINE_EXTENT; 79 79 ccw->flags = 0; 80 80 ccw->count = 16; 81 - ccw->cda = (__u32)virt_to_phys(data); 81 + ccw->cda = virt_to_dma32(data); 82 82 memset(data, 0, sizeof (struct DE_fba_data)); 83 83 if (rw == WRITE) 84 84 (data->mask).perm = 0x0; ··· 98 98 ccw->cmd_code = DASD_FBA_CCW_LOCATE; 99 99 ccw->flags = 0; 100 100 ccw->count = 8; 101 - ccw->cda = (__u32)virt_to_phys(data); 101 + ccw->cda = virt_to_dma32(data); 102 102 memset(data, 0, sizeof (struct LO_fba_data)); 103 103 if (rw == WRITE) 104 104 data->operation.cmd = 0x5; ··· 257 257 ccw->cmd_code = DASD_FBA_CCW_WRITE; 258 258 ccw->flags |= CCW_FLAG_SLI; 259 259 ccw->count = count; 260 - ccw->cda = (__u32)virt_to_phys(dasd_fba_zero_page); 260 + ccw->cda = virt_to_dma32(dasd_fba_zero_page); 261 261 } 262 262 263 263 /* ··· 523 523 ccw->cmd_code = cmd; 524 524 ccw->count = block->bp_block; 525 525 if (idal_is_needed(dst, blksize)) { 526 - ccw->cda = (__u32)virt_to_phys(idaws); 526 + ccw->cda = virt_to_dma32(idaws); 527 527 ccw->flags = CCW_FLAG_IDA; 528 528 idaws = idal_create_words(idaws, dst, blksize); 529 529 } else { 530 - ccw->cda = (__u32)virt_to_phys(dst); 530 + ccw->cda = virt_to_dma32(dst); 531 531 ccw->flags = 0; 532 532 } 533 533 ccw++; ··· 585 585 ccw++; 586 586 if (dst) { 587 587 if (ccw->flags & CCW_FLAG_IDA) 588 - cda = *((char **)phys_to_virt(ccw->cda)); 588 + cda = *((char **)dma32_to_virt(ccw->cda)); 589 589 else 590 - cda = phys_to_virt(ccw->cda); 590 + cda = dma32_to_virt(ccw->cda); 591 591 if (dst != cda) { 592 592 if (rq_data_dir(req) == READ) 593 593 memcpy(dst, cda, bv.bv_len); ··· 672 672 len += sprintf(page + len, "in req: %px CS: 0x%02X DS: 0x%02X\n", 673 673 req, irb->scsw.cmd.cstat, irb->scsw.cmd.dstat); 674 674 len += sprintf(page + len, "Failing CCW: %px\n", 675 - (void *) (addr_t) irb->scsw.cmd.cpa); 675 + (void *)(u64)dma32_to_u32(irb->scsw.cmd.cpa)); 676 676 if (irb->esw.esw0.erw.cons) { 677 677 for (sl = 0; sl < 4; sl++) { 678 678 len += sprintf(page + len, "Sense(hex) %2d-%2d:", ··· 701 701 for (count = 0; count < 32 && count < act->count; 702 702 count += sizeof(int)) 703 703 len += sprintf(page + len, " %08X", 704 - ((int *)phys_to_virt(act->cda)) 704 + ((int *)dma32_to_virt(act->cda)) 705 705 [(count>>2)]); 706 706 len += sprintf(page + len, "\n"); 707 707 act++; ··· 710 710 711 711 /* print failing CCW area */ 712 712 len = 0; 713 - if (act < ((struct ccw1 *)phys_to_virt(irb->scsw.cmd.cpa)) - 2) { 714 - act = ((struct ccw1 *)phys_to_virt(irb->scsw.cmd.cpa)) - 2; 713 + if (act < ((struct ccw1 *)dma32_to_virt(irb->scsw.cmd.cpa)) - 2) { 714 + act = ((struct ccw1 *)dma32_to_virt(irb->scsw.cmd.cpa)) - 2; 715 715 len += sprintf(page + len, "......\n"); 716 716 } 717 - end = min((struct ccw1 *)phys_to_virt(irb->scsw.cmd.cpa) + 2, last); 717 + end = min((struct ccw1 *)dma32_to_virt(irb->scsw.cmd.cpa) + 2, last); 718 718 while (act <= end) { 719 719 len += sprintf(page + len, "CCW %px: %08X %08X DAT:", 720 720 act, ((int *) act)[0], ((int *) act)[1]); 721 721 for (count = 0; count < 32 && count < act->count; 722 722 count += sizeof(int)) 723 723 len += sprintf(page + len, " %08X", 724 - ((int *)phys_to_virt(act->cda)) 724 + ((int *)dma32_to_virt(act->cda)) 725 725 [(count>>2)]); 726 726 len += sprintf(page + len, "\n"); 727 727 act++; ··· 738 738 for (count = 0; count < 32 && count < act->count; 739 739 count += sizeof(int)) 740 740 len += sprintf(page + len, " %08X", 741 - ((int *)phys_to_virt(act->cda)) 741 + ((int *)dma32_to_virt(act->cda)) 742 742 [(count>>2)]); 743 743 len += sprintf(page + len, "\n"); 744 744 act++;