~hc/RK356X_SDK_RELEASE.git

..	..	@@ -42,20 +42,6 @@
42	42	#endif /* PRINTK_HEADER */
43	43	#define PRINTK_HEADER "dasd(eckd):"
44	44
45		-#define ECKD_C0(i) (i->home_bytes)
46		-#define ECKD_F(i) (i->formula)
47		-#define ECKD_F1(i) (ECKD_F(i)==0x01?(i->factors.f_0x01.f1):\
48		- (i->factors.f_0x02.f1))
49		-#define ECKD_F2(i) (ECKD_F(i)==0x01?(i->factors.f_0x01.f2):\
50		- (i->factors.f_0x02.f2))
51		-#define ECKD_F3(i) (ECKD_F(i)==0x01?(i->factors.f_0x01.f3):\
52		- (i->factors.f_0x02.f3))
53		-#define ECKD_F4(i) (ECKD_F(i)==0x02?(i->factors.f_0x02.f4):0)
54		-#define ECKD_F5(i) (ECKD_F(i)==0x02?(i->factors.f_0x02.f5):0)
55		-#define ECKD_F6(i) (i->factor6)
56		-#define ECKD_F7(i) (i->factor7)
57		-#define ECKD_F8(i) (i->factor8)
58		-
59	45	/*
60	46	* raw track access always map to 64k in memory
61	47	* so it maps to 16 blocks of 4k per track
..	..	@@ -103,6 +89,19 @@
103	89	} *dasd_reserve_req;
104	90	static DEFINE_MUTEX(dasd_reserve_mutex);
105	91
	92	+static struct {
	93	+ struct dasd_ccw_req cqr;
	94	+ struct ccw1 ccw[2];
	95	+ char data[40];
	96	+} *dasd_vol_info_req;
	97	+static DEFINE_MUTEX(dasd_vol_info_mutex);
	98	+
	99	+struct ext_pool_exhaust_work_data {
	100	+ struct work_struct worker;
	101	+ struct dasd_device *device;
	102	+ struct dasd_device *base;
	103	+};
	104	+
106	105	/* definitions for the path verification worker */
107	106	struct path_verification_work_data {
108	107	struct work_struct worker;
..	..	@@ -122,6 +121,7 @@
122	121	__u8 lpum;
123	122	};
124	123
	124	+static int dasd_eckd_ext_pool_id(struct dasd_device *);
125	125	static int prepare_itcw(struct itcw *, unsigned int, unsigned int, int,
126	126	struct dasd_device , struct dasd_device ,
127	127	unsigned int, int, unsigned int, unsigned int,
..	..	@@ -157,15 +157,8 @@
157	157	#define LABEL_SIZE 140
158	158
159	159	/* head and record addresses of count_area read in analysis ccw */
160		-static const int count_area_head[] = { 0, 0, 0, 0, 2 };
	160	+static const int count_area_head[] = { 0, 0, 0, 0, 1 };
161	161	static const int count_area_rec[] = { 1, 2, 3, 4, 1 };
162		-
163		-static inline unsigned int
164		-round_up_multiple(unsigned int no, unsigned int mult)
165		-{
166		- int rem = no % mult;
167		- return (rem ? no - rem + mult : no);
168		-}
169	162
170	163	static inline unsigned int
171	164	ceil_quot(unsigned int d1, unsigned int d2)
..	..	@@ -212,6 +205,45 @@
212	205	geo->head = cyl >> 16;
213	206	geo->head <<= 4;
214	207	geo->head \|= head;
	208	+}
	209	+
	210	+/*
	211	+ * calculate failing track from sense data depending if
	212	+ * it is an EAV device or not
	213	+ */
	214	+static int dasd_eckd_track_from_irb(struct irb irb, struct dasd_device device,
	215	+ sector_t *track)
	216	+{
	217	+ struct dasd_eckd_private *private = device->private;
	218	+ u8 *sense = NULL;
	219	+ u32 cyl;
	220	+ u8 head;
	221	+
	222	+ sense = dasd_get_sense(irb);
	223	+ if (!sense) {
	224	+ DBF_DEV_EVENT(DBF_WARNING, device, "%s",
	225	+ "ESE error no sense data\n");
	226	+ return -EINVAL;
	227	+ }
	228	+ if (!(sense[27] & DASD_SENSE_BIT_2)) {
	229	+ DBF_DEV_EVENT(DBF_WARNING, device, "%s",
	230	+ "ESE error no valid track data\n");
	231	+ return -EINVAL;
	232	+ }
	233	+
	234	+ if (sense[27] & DASD_SENSE_BIT_3) {
	235	+ /* enhanced addressing */
	236	+ cyl = sense[30] << 20;
	237	+ cyl \|= (sense[31] & 0xF0) << 12;
	238	+ cyl \|= sense[28] << 8;
	239	+ cyl \|= sense[29];
	240	+ } else {
	241	+ cyl = sense[29] << 8;
	242	+ cyl \|= sense[30];
	243	+ }
	244	+ head = sense[31] & 0x0F;
	245	+ track = cyl private->rdc_data.trk_per_cyl + head;
	246	+ return 0;
215	247	}
216	248
217	249	static int set_timestamp(struct ccw1 ccw, struct DE_eckd_data data,
..	..	@@ -1492,6 +1524,311 @@
1492	1524	return rc;
1493	1525	}
1494	1526
	1527	+/* Read Volume Information - Volume Storage Query */
	1528	+static int dasd_eckd_read_vol_info(struct dasd_device *device)
	1529	+{
	1530	+ struct dasd_eckd_private *private = device->private;
	1531	+ struct dasd_psf_prssd_data *prssdp;
	1532	+ struct dasd_rssd_vsq *vsq;
	1533	+ struct dasd_ccw_req *cqr;
	1534	+ struct ccw1 *ccw;
	1535	+ int useglobal;
	1536	+ int rc;
	1537	+
	1538	+ /* This command cannot be executed on an alias device */
	1539	+ if (private->uid.type == UA_BASE_PAV_ALIAS \|\|
	1540	+ private->uid.type == UA_HYPER_PAV_ALIAS)
	1541	+ return 0;
	1542	+
	1543	+ useglobal = 0;
	1544	+ cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 /* PSF + RSSD */,
	1545	+ sizeof(prssdp) + sizeof(vsq), device, NULL);
	1546	+ if (IS_ERR(cqr)) {
	1547	+ DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
	1548	+ "Could not allocate initialization request");
	1549	+ mutex_lock(&dasd_vol_info_mutex);
	1550	+ useglobal = 1;
	1551	+ cqr = &dasd_vol_info_req->cqr;
	1552	+ memset(cqr, 0, sizeof(*cqr));
	1553	+ memset(dasd_vol_info_req, 0, sizeof(*dasd_vol_info_req));
	1554	+ cqr->cpaddr = &dasd_vol_info_req->ccw;
	1555	+ cqr->data = &dasd_vol_info_req->data;
	1556	+ cqr->magic = DASD_ECKD_MAGIC;
	1557	+ }
	1558	+
	1559	+ /* Prepare for Read Subsystem Data */
	1560	+ prssdp = cqr->data;
	1561	+ prssdp->order = PSF_ORDER_PRSSD;
	1562	+ prssdp->suborder = PSF_SUBORDER_VSQ; /* Volume Storage Query */
	1563	+ prssdp->lss = private->ned->ID;
	1564	+ prssdp->volume = private->ned->unit_addr;
	1565	+
	1566	+ ccw = cqr->cpaddr;
	1567	+ ccw->cmd_code = DASD_ECKD_CCW_PSF;
	1568	+ ccw->count = sizeof(*prssdp);
	1569	+ ccw->flags \|= CCW_FLAG_CC;
	1570	+ ccw->cda = (__u32)(addr_t)prssdp;
	1571	+
	1572	+ /* Read Subsystem Data - Volume Storage Query */
	1573	+ vsq = (struct dasd_rssd_vsq *)(prssdp + 1);
	1574	+ memset(vsq, 0, sizeof(*vsq));
	1575	+
	1576	+ ccw++;
	1577	+ ccw->cmd_code = DASD_ECKD_CCW_RSSD;
	1578	+ ccw->count = sizeof(*vsq);
	1579	+ ccw->flags \|= CCW_FLAG_SLI;
	1580	+ ccw->cda = (__u32)(addr_t)vsq;
	1581	+
	1582	+ cqr->buildclk = get_tod_clock();
	1583	+ cqr->status = DASD_CQR_FILLED;
	1584	+ cqr->startdev = device;
	1585	+ cqr->memdev = device;
	1586	+ cqr->block = NULL;
	1587	+ cqr->retries = 256;
	1588	+ cqr->expires = device->default_expires * HZ;
	1589	+ /* The command might not be supported. Suppress the error output */
	1590	+ __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags);
	1591	+
	1592	+ rc = dasd_sleep_on_interruptible(cqr);
	1593	+ if (rc == 0) {
	1594	+ memcpy(&private->vsq, vsq, sizeof(*vsq));
	1595	+ } else {
	1596	+ DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
	1597	+ "Reading the volume storage information failed with rc=%d", rc);
	1598	+ }
	1599	+
	1600	+ if (useglobal)
	1601	+ mutex_unlock(&dasd_vol_info_mutex);
	1602	+ else
	1603	+ dasd_sfree_request(cqr, cqr->memdev);
	1604	+
	1605	+ return rc;
	1606	+}
	1607	+
	1608	+static int dasd_eckd_is_ese(struct dasd_device *device)
	1609	+{
	1610	+ struct dasd_eckd_private *private = device->private;
	1611	+
	1612	+ return private->vsq.vol_info.ese;
	1613	+}
	1614	+
	1615	+static int dasd_eckd_ext_pool_id(struct dasd_device *device)
	1616	+{
	1617	+ struct dasd_eckd_private *private = device->private;
	1618	+
	1619	+ return private->vsq.extent_pool_id;
	1620	+}
	1621	+
	1622	+/*
	1623	+ * This value represents the total amount of available space. As more space is
	1624	+ * allocated by ESE volumes, this value will decrease.
	1625	+ * The data for this value is therefore updated on any call.
	1626	+ */
	1627	+static int dasd_eckd_space_configured(struct dasd_device *device)
	1628	+{
	1629	+ struct dasd_eckd_private *private = device->private;
	1630	+ int rc;
	1631	+
	1632	+ rc = dasd_eckd_read_vol_info(device);
	1633	+
	1634	+ return rc ? : private->vsq.space_configured;
	1635	+}
	1636	+
	1637	+/*
	1638	+ * The value of space allocated by an ESE volume may have changed and is
	1639	+ * therefore updated on any call.
	1640	+ */
	1641	+static int dasd_eckd_space_allocated(struct dasd_device *device)
	1642	+{
	1643	+ struct dasd_eckd_private *private = device->private;
	1644	+ int rc;
	1645	+
	1646	+ rc = dasd_eckd_read_vol_info(device);
	1647	+
	1648	+ return rc ? : private->vsq.space_allocated;
	1649	+}
	1650	+
	1651	+static int dasd_eckd_logical_capacity(struct dasd_device *device)
	1652	+{
	1653	+ struct dasd_eckd_private *private = device->private;
	1654	+
	1655	+ return private->vsq.logical_capacity;
	1656	+}
	1657	+
	1658	+static void dasd_eckd_ext_pool_exhaust_work(struct work_struct *work)
	1659	+{
	1660	+ struct ext_pool_exhaust_work_data *data;
	1661	+ struct dasd_device *device;
	1662	+ struct dasd_device *base;
	1663	+
	1664	+ data = container_of(work, struct ext_pool_exhaust_work_data, worker);
	1665	+ device = data->device;
	1666	+ base = data->base;
	1667	+
	1668	+ if (!base)
	1669	+ base = device;
	1670	+ if (dasd_eckd_space_configured(base) != 0) {
	1671	+ dasd_generic_space_avail(device);
	1672	+ } else {
	1673	+ dev_warn(&device->cdev->dev, "No space left in the extent pool\n");
	1674	+ DBF_DEV_EVENT(DBF_WARNING, device, "%s", "out of space");
	1675	+ }
	1676	+
	1677	+ dasd_put_device(device);
	1678	+ kfree(data);
	1679	+}
	1680	+
	1681	+static int dasd_eckd_ext_pool_exhaust(struct dasd_device *device,
	1682	+ struct dasd_ccw_req *cqr)
	1683	+{
	1684	+ struct ext_pool_exhaust_work_data *data;
	1685	+
	1686	+ data = kzalloc(sizeof(*data), GFP_ATOMIC);
	1687	+ if (!data)
	1688	+ return -ENOMEM;
	1689	+ INIT_WORK(&data->worker, dasd_eckd_ext_pool_exhaust_work);
	1690	+ dasd_get_device(device);
	1691	+ data->device = device;
	1692	+
	1693	+ if (cqr->block)
	1694	+ data->base = cqr->block->base;
	1695	+ else if (cqr->basedev)
	1696	+ data->base = cqr->basedev;
	1697	+ else
	1698	+ data->base = NULL;
	1699	+
	1700	+ schedule_work(&data->worker);
	1701	+
	1702	+ return 0;
	1703	+}
	1704	+
	1705	+static void dasd_eckd_cpy_ext_pool_data(struct dasd_device *device,
	1706	+ struct dasd_rssd_lcq *lcq)
	1707	+{
	1708	+ struct dasd_eckd_private *private = device->private;
	1709	+ int pool_id = dasd_eckd_ext_pool_id(device);
	1710	+ struct dasd_ext_pool_sum eps;
	1711	+ int i;
	1712	+
	1713	+ for (i = 0; i < lcq->pool_count; i++) {
	1714	+ eps = lcq->ext_pool_sum[i];
	1715	+ if (eps.pool_id == pool_id) {
	1716	+ memcpy(&private->eps, &eps,
	1717	+ sizeof(struct dasd_ext_pool_sum));
	1718	+ }
	1719	+ }
	1720	+}
	1721	+
	1722	+/* Read Extent Pool Information - Logical Configuration Query */
	1723	+static int dasd_eckd_read_ext_pool_info(struct dasd_device *device)
	1724	+{
	1725	+ struct dasd_eckd_private *private = device->private;
	1726	+ struct dasd_psf_prssd_data *prssdp;
	1727	+ struct dasd_rssd_lcq *lcq;
	1728	+ struct dasd_ccw_req *cqr;
	1729	+ struct ccw1 *ccw;
	1730	+ int rc;
	1731	+
	1732	+ /* This command cannot be executed on an alias device */
	1733	+ if (private->uid.type == UA_BASE_PAV_ALIAS \|\|
	1734	+ private->uid.type == UA_HYPER_PAV_ALIAS)
	1735	+ return 0;
	1736	+
	1737	+ cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 /* PSF + RSSD */,
	1738	+ sizeof(prssdp) + sizeof(lcq), device, NULL);
	1739	+ if (IS_ERR(cqr)) {
	1740	+ DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
	1741	+ "Could not allocate initialization request");
	1742	+ return PTR_ERR(cqr);
	1743	+ }
	1744	+
	1745	+ /* Prepare for Read Subsystem Data */
	1746	+ prssdp = cqr->data;
	1747	+ memset(prssdp, 0, sizeof(*prssdp));
	1748	+ prssdp->order = PSF_ORDER_PRSSD;
	1749	+ prssdp->suborder = PSF_SUBORDER_LCQ; /* Logical Configuration Query */
	1750	+
	1751	+ ccw = cqr->cpaddr;
	1752	+ ccw->cmd_code = DASD_ECKD_CCW_PSF;
	1753	+ ccw->count = sizeof(*prssdp);
	1754	+ ccw->flags \|= CCW_FLAG_CC;
	1755	+ ccw->cda = (__u32)(addr_t)prssdp;
	1756	+
	1757	+ lcq = (struct dasd_rssd_lcq *)(prssdp + 1);
	1758	+ memset(lcq, 0, sizeof(*lcq));
	1759	+
	1760	+ ccw++;
	1761	+ ccw->cmd_code = DASD_ECKD_CCW_RSSD;
	1762	+ ccw->count = sizeof(*lcq);
	1763	+ ccw->flags \|= CCW_FLAG_SLI;
	1764	+ ccw->cda = (__u32)(addr_t)lcq;
	1765	+
	1766	+ cqr->buildclk = get_tod_clock();
	1767	+ cqr->status = DASD_CQR_FILLED;
	1768	+ cqr->startdev = device;
	1769	+ cqr->memdev = device;
	1770	+ cqr->block = NULL;
	1771	+ cqr->retries = 256;
	1772	+ cqr->expires = device->default_expires * HZ;
	1773	+ /* The command might not be supported. Suppress the error output */
	1774	+ __set_bit(DASD_CQR_SUPPRESS_CR, &cqr->flags);
	1775	+
	1776	+ rc = dasd_sleep_on_interruptible(cqr);
	1777	+ if (rc == 0) {
	1778	+ dasd_eckd_cpy_ext_pool_data(device, lcq);
	1779	+ } else {
	1780	+ DBF_EVENT_DEVID(DBF_WARNING, device->cdev,
	1781	+ "Reading the logical configuration failed with rc=%d", rc);
	1782	+ }
	1783	+
	1784	+ dasd_sfree_request(cqr, cqr->memdev);
	1785	+
	1786	+ return rc;
	1787	+}
	1788	+
	1789	+/*
	1790	+ * Depending on the device type, the extent size is specified either as
	1791	+ * cylinders per extent (CKD) or size per extent (FBA)
	1792	+ * A 1GB size corresponds to 1113cyl, and 16MB to 21cyl.
	1793	+ */
	1794	+static int dasd_eckd_ext_size(struct dasd_device *device)
	1795	+{
	1796	+ struct dasd_eckd_private *private = device->private;
	1797	+ struct dasd_ext_pool_sum eps = private->eps;
	1798	+
	1799	+ if (!eps.flags.extent_size_valid)
	1800	+ return 0;
	1801	+ if (eps.extent_size.size_1G)
	1802	+ return 1113;
	1803	+ if (eps.extent_size.size_16M)
	1804	+ return 21;
	1805	+
	1806	+ return 0;
	1807	+}
	1808	+
	1809	+static int dasd_eckd_ext_pool_warn_thrshld(struct dasd_device *device)
	1810	+{
	1811	+ struct dasd_eckd_private *private = device->private;
	1812	+
	1813	+ return private->eps.warn_thrshld;
	1814	+}
	1815	+
	1816	+static int dasd_eckd_ext_pool_cap_at_warnlevel(struct dasd_device *device)
	1817	+{
	1818	+ struct dasd_eckd_private *private = device->private;
	1819	+
	1820	+ return private->eps.flags.capacity_at_warnlevel;
	1821	+}
	1822	+
	1823	+/*
	1824	+ * Extent Pool out of space
	1825	+ */
	1826	+static int dasd_eckd_ext_pool_oos(struct dasd_device *device)
	1827	+{
	1828	+ struct dasd_eckd_private *private = device->private;
	1829	+
	1830	+ return private->eps.flags.pool_oos;
	1831	+}
1495	1832
1496	1833	/*
1497	1834	* Build CP for Perform Subsystem Function - SSC.
..	..	@@ -1722,6 +2059,12 @@
1722	2059	/* Read Feature Codes */
1723	2060	dasd_eckd_read_features(device);
1724	2061
	2062	+ /* Read Volume Information */
	2063	+ dasd_eckd_read_vol_info(device);
	2064	+
	2065	+ /* Read Extent Pool Information */
	2066	+ dasd_eckd_read_ext_pool_info(device);
	2067	+
1725	2068	/* Read Device Characteristics */
1726	2069	rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
1727	2070	&private->rdc_data, 64);
..	..	@@ -1809,8 +2152,8 @@
1809	2152	if (IS_ERR(cqr))
1810	2153	return cqr;
1811	2154	ccw = cqr->cpaddr;
1812		- /* Define extent for the first 3 tracks. */
1813		- define_extent(ccw++, cqr->data, 0, 2,
	2155	+ /* Define extent for the first 2 tracks. */
	2156	+ define_extent(ccw++, cqr->data, 0, 1,
1814	2157	DASD_ECKD_CCW_READ_COUNT, device, 0);
1815	2158	LO_data = cqr->data + sizeof(struct DE_eckd_data);
1816	2159	/* Locate record for the first 4 records on track 0. */
..	..	@@ -1829,9 +2172,9 @@
1829	2172	count_data++;
1830	2173	}
1831	2174
1832		- /* Locate record for the first record on track 2. */
	2175	+ /* Locate record for the first record on track 1. */
1833	2176	ccw[-1].flags \|= CCW_FLAG_CC;
1834		- locate_record(ccw++, LO_data++, 2, 0, 1,
	2177	+ locate_record(ccw++, LO_data++, 1, 0, 1,
1835	2178	DASD_ECKD_CCW_READ_COUNT, device, 0);
1836	2179	/* Read count ccw. */
1837	2180	ccw[-1].flags \|= CCW_FLAG_CC;
..	..	@@ -1846,6 +2189,9 @@
1846	2189	cqr->retries = 255;
1847	2190	cqr->buildclk = get_tod_clock();
1848	2191	cqr->status = DASD_CQR_FILLED;
	2192	+ /* Set flags to suppress output for expected errors */
	2193	+ set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
	2194	+
1849	2195	return cqr;
1850	2196	}
1851	2197
..	..	@@ -1953,7 +2299,7 @@
1953	2299	}
1954	2300	}
1955	2301	if (i == 3)
1956		- count_area = &private->count_area[4];
	2302	+ count_area = &private->count_area[3];
1957	2303
1958	2304	if (private->uses_cdl == 0) {
1959	2305	for (i = 0; i < 5; i++) {
..	..	@@ -2085,8 +2431,7 @@
2085	2431	*/
2086	2432	itcw_size = itcw_calc_size(0, count, 0);
2087	2433
2088		- cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 0, itcw_size, startdev,
2089		- NULL);
	2434	+ cqr = dasd_fmalloc_request(DASD_ECKD_MAGIC, 0, itcw_size, startdev);
2090	2435	if (IS_ERR(cqr))
2091	2436	return cqr;
2092	2437
..	..	@@ -2179,8 +2524,7 @@
2179	2524	}
2180	2525	cplength += count;
2181	2526
2182		- cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength, datasize,
2183		- startdev, NULL);
	2527	+ cqr = dasd_fmalloc_request(DASD_ECKD_MAGIC, cplength, datasize, startdev);
2184	2528	if (IS_ERR(cqr))
2185	2529	return cqr;
2186	2530
..	..	@@ -2227,13 +2571,11 @@
2227	2571	}
2228	2572
2229	2573	static struct dasd_ccw_req *
2230		-dasd_eckd_build_format(struct dasd_device *base,
2231		- struct format_data_t *fdata,
2232		- int enable_pav)
	2574	+dasd_eckd_build_format(struct dasd_device base, struct dasd_device startdev,
	2575	+ struct format_data_t *fdata, int enable_pav)
2233	2576	{
2234	2577	struct dasd_eckd_private *base_priv;
2235	2578	struct dasd_eckd_private *start_priv;
2236		- struct dasd_device *startdev = NULL;
2237	2579	struct dasd_ccw_req *fcp;
2238	2580	struct eckd_count *ect;
2239	2581	struct ch_t address;
..	..	@@ -2324,9 +2666,8 @@
2324	2666	fdata->intensity);
2325	2667	return ERR_PTR(-EINVAL);
2326	2668	}
2327		- /* Allocate the format ccw request. */
2328		- fcp = dasd_smalloc_request(DASD_ECKD_MAGIC, cplength,
2329		- datasize, startdev, NULL);
	2669	+
	2670	+ fcp = dasd_fmalloc_request(DASD_ECKD_MAGIC, cplength, datasize, startdev);
2330	2671	if (IS_ERR(fcp))
2331	2672	return fcp;
2332	2673
..	..	@@ -2499,7 +2840,7 @@
2499	2840	struct dasd_ccw_req *ccw_req;
2500	2841
2501	2842	if (!fmt_buffer) {
2502		- ccw_req = dasd_eckd_build_format(base, fdata, enable_pav);
	2843	+ ccw_req = dasd_eckd_build_format(base, NULL, fdata, enable_pav);
2503	2844	} else {
2504	2845	if (tpm)
2505	2846	ccw_req = dasd_eckd_build_check_tcw(base, fdata,
..	..	@@ -2645,7 +2986,7 @@
2645	2986	rc = -EIO;
2646	2987	}
2647	2988	list_del_init(&cqr->blocklist);
2648		- dasd_sfree_request(cqr, device);
	2989	+ dasd_ffree_request(cqr, device);
2649	2990	private->count--;
2650	2991	}
2651	2992
..	..	@@ -2682,6 +3023,220 @@
2682	3023	{
2683	3024	return dasd_eckd_format_process_data(base, fdata, enable_pav, 0, NULL,
2684	3025	0, NULL);
	3026	+}
	3027	+
	3028	+static bool test_and_set_format_track(struct dasd_format_entry *to_format,
	3029	+ struct dasd_ccw_req *cqr)
	3030	+{
	3031	+ struct dasd_block *block = cqr->block;
	3032	+ struct dasd_format_entry *format;
	3033	+ unsigned long flags;
	3034	+ bool rc = false;
	3035	+
	3036	+ spin_lock_irqsave(&block->format_lock, flags);
	3037	+ if (cqr->trkcount != atomic_read(&block->trkcount)) {
	3038	+ /*
	3039	+ * The number of formatted tracks has changed after request
	3040	+ * start and we can not tell if the current track was involved.
	3041	+ * To avoid data corruption treat it as if the current track is
	3042	+ * involved
	3043	+ */
	3044	+ rc = true;
	3045	+ goto out;
	3046	+ }
	3047	+ list_for_each_entry(format, &block->format_list, list) {
	3048	+ if (format->track == to_format->track) {
	3049	+ rc = true;
	3050	+ goto out;
	3051	+ }
	3052	+ }
	3053	+ list_add_tail(&to_format->list, &block->format_list);
	3054	+
	3055	+out:
	3056	+ spin_unlock_irqrestore(&block->format_lock, flags);
	3057	+ return rc;
	3058	+}
	3059	+
	3060	+static void clear_format_track(struct dasd_format_entry *format,
	3061	+ struct dasd_block *block)
	3062	+{
	3063	+ unsigned long flags;
	3064	+
	3065	+ spin_lock_irqsave(&block->format_lock, flags);
	3066	+ atomic_inc(&block->trkcount);
	3067	+ list_del_init(&format->list);
	3068	+ spin_unlock_irqrestore(&block->format_lock, flags);
	3069	+}
	3070	+
	3071	+/*
	3072	+ * Callback function to free ESE format requests.
	3073	+ */
	3074	+static void dasd_eckd_ese_format_cb(struct dasd_ccw_req cqr, void data)
	3075	+{
	3076	+ struct dasd_device *device = cqr->startdev;
	3077	+ struct dasd_eckd_private *private = device->private;
	3078	+ struct dasd_format_entry *format = data;
	3079	+
	3080	+ clear_format_track(format, cqr->basedev->block);
	3081	+ private->count--;
	3082	+ dasd_ffree_request(cqr, device);
	3083	+}
	3084	+
	3085	+static struct dasd_ccw_req *
	3086	+dasd_eckd_ese_format(struct dasd_device startdev, struct dasd_ccw_req cqr,
	3087	+ struct irb *irb)
	3088	+{
	3089	+ struct dasd_eckd_private *private;
	3090	+ struct dasd_format_entry *format;
	3091	+ struct format_data_t fdata;
	3092	+ unsigned int recs_per_trk;
	3093	+ struct dasd_ccw_req *fcqr;
	3094	+ struct dasd_device *base;
	3095	+ struct dasd_block *block;
	3096	+ unsigned int blksize;
	3097	+ struct request *req;
	3098	+ sector_t first_trk;
	3099	+ sector_t last_trk;
	3100	+ sector_t curr_trk;
	3101	+ int rc;
	3102	+
	3103	+ req = dasd_get_callback_data(cqr);
	3104	+ block = cqr->block;
	3105	+ base = block->base;
	3106	+ private = base->private;
	3107	+ blksize = block->bp_block;
	3108	+ recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
	3109	+ format = &startdev->format_entry;
	3110	+
	3111	+ first_trk = blk_rq_pos(req) >> block->s2b_shift;
	3112	+ sector_div(first_trk, recs_per_trk);
	3113	+ last_trk =
	3114	+ (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
	3115	+ sector_div(last_trk, recs_per_trk);
	3116	+ rc = dasd_eckd_track_from_irb(irb, base, &curr_trk);
	3117	+ if (rc)
	3118	+ return ERR_PTR(rc);
	3119	+
	3120	+ if (curr_trk < first_trk \|\| curr_trk > last_trk) {
	3121	+ DBF_DEV_EVENT(DBF_WARNING, startdev,
	3122	+ "ESE error track %llu not within range %llu - %llu\n",
	3123	+ curr_trk, first_trk, last_trk);
	3124	+ return ERR_PTR(-EINVAL);
	3125	+ }
	3126	+ format->track = curr_trk;
	3127	+ /* test if track is already in formatting by another thread */
	3128	+ if (test_and_set_format_track(format, cqr)) {
	3129	+ /* this is no real error so do not count down retries */
	3130	+ cqr->retries++;
	3131	+ return ERR_PTR(-EEXIST);
	3132	+ }
	3133	+
	3134	+ fdata.start_unit = curr_trk;
	3135	+ fdata.stop_unit = curr_trk;
	3136	+ fdata.blksize = blksize;
	3137	+ fdata.intensity = private->uses_cdl ? DASD_FMT_INT_COMPAT : 0;
	3138	+
	3139	+ rc = dasd_eckd_format_sanity_checks(base, &fdata);
	3140	+ if (rc)
	3141	+ return ERR_PTR(-EINVAL);
	3142	+
	3143	+ /*
	3144	+ * We're building the request with PAV disabled as we're reusing
	3145	+ * the former startdev.
	3146	+ */
	3147	+ fcqr = dasd_eckd_build_format(base, startdev, &fdata, 0);
	3148	+ if (IS_ERR(fcqr))
	3149	+ return fcqr;
	3150	+
	3151	+ fcqr->callback = dasd_eckd_ese_format_cb;
	3152	+ fcqr->callback_data = (void *) format;
	3153	+
	3154	+ return fcqr;
	3155	+}
	3156	+
	3157	+/*
	3158	+ * When data is read from an unformatted area of an ESE volume, this function
	3159	+ * returns zeroed data and thereby mimics a read of zero data.
	3160	+ *
	3161	+ * The first unformatted track is the one that got the NRF error, the address is
	3162	+ * encoded in the sense data.
	3163	+ *
	3164	+ * All tracks before have returned valid data and should not be touched.
	3165	+ * All tracks after the unformatted track might be formatted or not. This is
	3166	+ * currently not known, remember the processed data and return the remainder of
	3167	+ * the request to the blocklayer in __dasd_cleanup_cqr().
	3168	+ */
	3169	+static int dasd_eckd_ese_read(struct dasd_ccw_req cqr, struct irb irb)
	3170	+{
	3171	+ struct dasd_eckd_private *private;
	3172	+ sector_t first_trk, last_trk;
	3173	+ sector_t first_blk, last_blk;
	3174	+ unsigned int blksize, off;
	3175	+ unsigned int recs_per_trk;
	3176	+ struct dasd_device *base;
	3177	+ struct req_iterator iter;
	3178	+ struct dasd_block *block;
	3179	+ unsigned int skip_block;
	3180	+ unsigned int blk_count;
	3181	+ struct request *req;
	3182	+ struct bio_vec bv;
	3183	+ sector_t curr_trk;
	3184	+ sector_t end_blk;
	3185	+ char *dst;
	3186	+ int rc;
	3187	+
	3188	+ req = (struct request *) cqr->callback_data;
	3189	+ base = cqr->block->base;
	3190	+ blksize = base->block->bp_block;
	3191	+ block = cqr->block;
	3192	+ private = base->private;
	3193	+ skip_block = 0;
	3194	+ blk_count = 0;
	3195	+
	3196	+ recs_per_trk = recs_per_track(&private->rdc_data, 0, blksize);
	3197	+ first_trk = first_blk = blk_rq_pos(req) >> block->s2b_shift;
	3198	+ sector_div(first_trk, recs_per_trk);
	3199	+ last_trk = last_blk =
	3200	+ (blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
	3201	+ sector_div(last_trk, recs_per_trk);
	3202	+ rc = dasd_eckd_track_from_irb(irb, base, &curr_trk);
	3203	+ if (rc)
	3204	+ return rc;
	3205	+
	3206	+ /* sanity check if the current track from sense data is valid */
	3207	+ if (curr_trk < first_trk \|\| curr_trk > last_trk) {
	3208	+ DBF_DEV_EVENT(DBF_WARNING, base,
	3209	+ "ESE error track %llu not within range %llu - %llu\n",
	3210	+ curr_trk, first_trk, last_trk);
	3211	+ return -EINVAL;
	3212	+ }
	3213	+
	3214	+ /*
	3215	+ * if not the first track got the NRF error we have to skip over valid
	3216	+ * blocks
	3217	+ */
	3218	+ if (curr_trk != first_trk)
	3219	+ skip_block = curr_trk * recs_per_trk - first_blk;
	3220	+
	3221	+ /* we have no information beyond the current track */
	3222	+ end_blk = (curr_trk + 1) * recs_per_trk;
	3223	+
	3224	+ rq_for_each_segment(bv, req, iter) {
	3225	+ dst = page_address(bv.bv_page) + bv.bv_offset;
	3226	+ for (off = 0; off < bv.bv_len; off += blksize) {
	3227	+ if (first_blk + blk_count >= end_blk) {
	3228	+ cqr->proc_bytes = blk_count * blksize;
	3229	+ return 0;
	3230	+ }
	3231	+ if (dst && !skip_block)
	3232	+ memset(dst, 0, blksize);
	3233	+ else
	3234	+ skip_block--;
	3235	+ dst += blksize;
	3236	+ blk_count++;
	3237	+ }
	3238	+ }
	3239	+ return 0;
2685	3240	}
2686	3241
2687	3242	/*
..	..	@@ -3019,6 +3574,269 @@
3019	3574	}
3020	3575	}
3021	3576
	3577	+static int dasd_eckd_ras_sanity_checks(struct dasd_device *device,
	3578	+ unsigned int first_trk,
	3579	+ unsigned int last_trk)
	3580	+{
	3581	+ struct dasd_eckd_private *private = device->private;
	3582	+ unsigned int trks_per_vol;
	3583	+ int rc = 0;
	3584	+
	3585	+ trks_per_vol = private->real_cyl * private->rdc_data.trk_per_cyl;
	3586	+
	3587	+ if (first_trk >= trks_per_vol) {
	3588	+ dev_warn(&device->cdev->dev,
	3589	+ "Start track number %u used in the space release command is too big\n",
	3590	+ first_trk);
	3591	+ rc = -EINVAL;
	3592	+ } else if (last_trk >= trks_per_vol) {
	3593	+ dev_warn(&device->cdev->dev,
	3594	+ "Stop track number %u used in the space release command is too big\n",
	3595	+ last_trk);
	3596	+ rc = -EINVAL;
	3597	+ } else if (first_trk > last_trk) {
	3598	+ dev_warn(&device->cdev->dev,
	3599	+ "Start track %u used in the space release command exceeds the end track\n",
	3600	+ first_trk);
	3601	+ rc = -EINVAL;
	3602	+ }
	3603	+ return rc;
	3604	+}
	3605	+
	3606	+/*
	3607	+ * Helper function to count the amount of involved extents within a given range
	3608	+ * with extent alignment in mind.
	3609	+ */
	3610	+static int count_exts(unsigned int from, unsigned int to, int trks_per_ext)
	3611	+{
	3612	+ int cur_pos = 0;
	3613	+ int count = 0;
	3614	+ int tmp;
	3615	+
	3616	+ if (from == to)
	3617	+ return 1;
	3618	+
	3619	+ /* Count first partial extent */
	3620	+ if (from % trks_per_ext != 0) {
	3621	+ tmp = from + trks_per_ext - (from % trks_per_ext) - 1;
	3622	+ if (tmp > to)
	3623	+ tmp = to;
	3624	+ cur_pos = tmp - from + 1;
	3625	+ count++;
	3626	+ }
	3627	+ /* Count full extents */
	3628	+ if (to - (from + cur_pos) + 1 >= trks_per_ext) {
	3629	+ tmp = to - ((to - trks_per_ext + 1) % trks_per_ext);
	3630	+ count += (tmp - (from + cur_pos) + 1) / trks_per_ext;
	3631	+ cur_pos = tmp;
	3632	+ }
	3633	+ /* Count last partial extent */
	3634	+ if (cur_pos < to)
	3635	+ count++;
	3636	+
	3637	+ return count;
	3638	+}
	3639	+
	3640	+/*
	3641	+ * Release allocated space for a given range or an entire volume.
	3642	+ */
	3643	+static struct dasd_ccw_req *
	3644	+dasd_eckd_dso_ras(struct dasd_device device, struct dasd_block block,
	3645	+ struct request *req, unsigned int first_trk,
	3646	+ unsigned int last_trk, int by_extent)
	3647	+{
	3648	+ struct dasd_eckd_private *private = device->private;
	3649	+ struct dasd_dso_ras_ext_range *ras_range;
	3650	+ struct dasd_rssd_features *features;
	3651	+ struct dasd_dso_ras_data *ras_data;
	3652	+ u16 heads, beg_head, end_head;
	3653	+ int cur_to_trk, cur_from_trk;
	3654	+ struct dasd_ccw_req *cqr;
	3655	+ u32 beg_cyl, end_cyl;
	3656	+ struct ccw1 *ccw;
	3657	+ int trks_per_ext;
	3658	+ size_t ras_size;
	3659	+ size_t size;
	3660	+ int nr_exts;
	3661	+ void *rq;
	3662	+ int i;
	3663	+
	3664	+ if (dasd_eckd_ras_sanity_checks(device, first_trk, last_trk))
	3665	+ return ERR_PTR(-EINVAL);
	3666	+
	3667	+ rq = req ? blk_mq_rq_to_pdu(req) : NULL;
	3668	+
	3669	+ features = &private->features;
	3670	+
	3671	+ trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl;
	3672	+ nr_exts = 0;
	3673	+ if (by_extent)
	3674	+ nr_exts = count_exts(first_trk, last_trk, trks_per_ext);
	3675	+ ras_size = sizeof(*ras_data);
	3676	+ size = ras_size + (nr_exts * sizeof(*ras_range));
	3677	+
	3678	+ cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 1, size, device, rq);
	3679	+ if (IS_ERR(cqr)) {
	3680	+ DBF_EVENT_DEVID(DBF_WARNING, device->cdev, "%s",
	3681	+ "Could not allocate RAS request");
	3682	+ return cqr;
	3683	+ }
	3684	+
	3685	+ ras_data = cqr->data;
	3686	+ memset(ras_data, 0, size);
	3687	+
	3688	+ ras_data->order = DSO_ORDER_RAS;
	3689	+ ras_data->flags.vol_type = 0; /* CKD volume */
	3690	+ /* Release specified extents or entire volume */
	3691	+ ras_data->op_flags.by_extent = by_extent;
	3692	+ /*
	3693	+ * This bit guarantees initialisation of tracks within an extent that is
	3694	+ * not fully specified, but is only supported with a certain feature
	3695	+ * subset.
	3696	+ */
	3697	+ ras_data->op_flags.guarantee_init = !!(features->feature[56] & 0x01);
	3698	+ ras_data->lss = private->ned->ID;
	3699	+ ras_data->dev_addr = private->ned->unit_addr;
	3700	+ ras_data->nr_exts = nr_exts;
	3701	+
	3702	+ if (by_extent) {
	3703	+ heads = private->rdc_data.trk_per_cyl;
	3704	+ cur_from_trk = first_trk;
	3705	+ cur_to_trk = first_trk + trks_per_ext -
	3706	+ (first_trk % trks_per_ext) - 1;
	3707	+ if (cur_to_trk > last_trk)
	3708	+ cur_to_trk = last_trk;
	3709	+ ras_range = (struct dasd_dso_ras_ext_range *)(cqr->data + ras_size);
	3710	+
	3711	+ for (i = 0; i < nr_exts; i++) {
	3712	+ beg_cyl = cur_from_trk / heads;
	3713	+ beg_head = cur_from_trk % heads;
	3714	+ end_cyl = cur_to_trk / heads;
	3715	+ end_head = cur_to_trk % heads;
	3716	+
	3717	+ set_ch_t(&ras_range->beg_ext, beg_cyl, beg_head);
	3718	+ set_ch_t(&ras_range->end_ext, end_cyl, end_head);
	3719	+
	3720	+ cur_from_trk = cur_to_trk + 1;
	3721	+ cur_to_trk = cur_from_trk + trks_per_ext - 1;
	3722	+ if (cur_to_trk > last_trk)
	3723	+ cur_to_trk = last_trk;
	3724	+ ras_range++;
	3725	+ }
	3726	+ }
	3727	+
	3728	+ ccw = cqr->cpaddr;
	3729	+ ccw->cda = (__u32)(addr_t)cqr->data;
	3730	+ ccw->cmd_code = DASD_ECKD_CCW_DSO;
	3731	+ ccw->count = size;
	3732	+
	3733	+ cqr->startdev = device;
	3734	+ cqr->memdev = device;
	3735	+ cqr->block = block;
	3736	+ cqr->retries = 256;
	3737	+ cqr->expires = device->default_expires * HZ;
	3738	+ cqr->buildclk = get_tod_clock();
	3739	+ cqr->status = DASD_CQR_FILLED;
	3740	+
	3741	+ return cqr;
	3742	+}
	3743	+
	3744	+static int dasd_eckd_release_space_full(struct dasd_device *device)
	3745	+{
	3746	+ struct dasd_ccw_req *cqr;
	3747	+ int rc;
	3748	+
	3749	+ cqr = dasd_eckd_dso_ras(device, NULL, NULL, 0, 0, 0);
	3750	+ if (IS_ERR(cqr))
	3751	+ return PTR_ERR(cqr);
	3752	+
	3753	+ rc = dasd_sleep_on_interruptible(cqr);
	3754	+
	3755	+ dasd_sfree_request(cqr, cqr->memdev);
	3756	+
	3757	+ return rc;
	3758	+}
	3759	+
	3760	+static int dasd_eckd_release_space_trks(struct dasd_device *device,
	3761	+ unsigned int from, unsigned int to)
	3762	+{
	3763	+ struct dasd_eckd_private *private = device->private;
	3764	+ struct dasd_block *block = device->block;
	3765	+ struct dasd_ccw_req cqr, n;
	3766	+ struct list_head ras_queue;
	3767	+ unsigned int device_exts;
	3768	+ int trks_per_ext;
	3769	+ int stop, step;
	3770	+ int cur_pos;
	3771	+ int rc = 0;
	3772	+ int retry;
	3773	+
	3774	+ INIT_LIST_HEAD(&ras_queue);
	3775	+
	3776	+ device_exts = private->real_cyl / dasd_eckd_ext_size(device);
	3777	+ trks_per_ext = dasd_eckd_ext_size(device) * private->rdc_data.trk_per_cyl;
	3778	+
	3779	+ /* Make sure device limits are not exceeded */
	3780	+ step = trks_per_ext * min(device_exts, DASD_ECKD_RAS_EXTS_MAX);
	3781	+ cur_pos = from;
	3782	+
	3783	+ do {
	3784	+ retry = 0;
	3785	+ while (cur_pos < to) {
	3786	+ stop = cur_pos + step -
	3787	+ ((cur_pos + step) % trks_per_ext) - 1;
	3788	+ if (stop > to)
	3789	+ stop = to;
	3790	+
	3791	+ cqr = dasd_eckd_dso_ras(device, NULL, NULL, cur_pos, stop, 1);
	3792	+ if (IS_ERR(cqr)) {
	3793	+ rc = PTR_ERR(cqr);
	3794	+ if (rc == -ENOMEM) {
	3795	+ if (list_empty(&ras_queue))
	3796	+ goto out;
	3797	+ retry = 1;
	3798	+ break;
	3799	+ }
	3800	+ goto err_out;
	3801	+ }
	3802	+
	3803	+ spin_lock_irq(&block->queue_lock);
	3804	+ list_add_tail(&cqr->blocklist, &ras_queue);
	3805	+ spin_unlock_irq(&block->queue_lock);
	3806	+ cur_pos = stop + 1;
	3807	+ }
	3808	+
	3809	+ rc = dasd_sleep_on_queue_interruptible(&ras_queue);
	3810	+
	3811	+err_out:
	3812	+ list_for_each_entry_safe(cqr, n, &ras_queue, blocklist) {
	3813	+ device = cqr->startdev;
	3814	+ private = device->private;
	3815	+
	3816	+ spin_lock_irq(&block->queue_lock);
	3817	+ list_del_init(&cqr->blocklist);
	3818	+ spin_unlock_irq(&block->queue_lock);
	3819	+ dasd_sfree_request(cqr, device);
	3820	+ private->count--;
	3821	+ }
	3822	+ } while (retry);
	3823	+
	3824	+out:
	3825	+ return rc;
	3826	+}
	3827	+
	3828	+static int dasd_eckd_release_space(struct dasd_device *device,
	3829	+ struct format_data_t *rdata)
	3830	+{
	3831	+ if (rdata->intensity & DASD_FMT_INT_ESE_FULL)
	3832	+ return dasd_eckd_release_space_full(device);
	3833	+ else if (rdata->intensity == 0)
	3834	+ return dasd_eckd_release_space_trks(device, rdata->start_unit,
	3835	+ rdata->stop_unit);
	3836	+ else
	3837	+ return -EINVAL;
	3838	+}
	3839	+
3022	3840	static struct dasd_ccw_req *dasd_eckd_build_cp_cmd_single(
3023	3841	struct dasd_device *startdev,
3024	3842	struct dasd_block *block,
..	..	@@ -3200,6 +4018,14 @@
3200	4018	cqr->retries = startdev->default_retries;
3201	4019	cqr->buildclk = get_tod_clock();
3202	4020	cqr->status = DASD_CQR_FILLED;
	4021	+
	4022	+ /* Set flags to suppress output for expected errors */
	4023	+ if (dasd_eckd_is_ese(basedev)) {
	4024	+ set_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags);
	4025	+ set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags);
	4026	+ set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
	4027	+ }
	4028	+
3203	4029	return cqr;
3204	4030	}
3205	4031
..	..	@@ -3371,6 +4197,11 @@
3371	4197	cqr->retries = startdev->default_retries;
3372	4198	cqr->buildclk = get_tod_clock();
3373	4199	cqr->status = DASD_CQR_FILLED;
	4200	+
	4201	+ /* Set flags to suppress output for expected errors */
	4202	+ if (dasd_eckd_is_ese(basedev))
	4203	+ set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
	4204	+
3374	4205	return cqr;
3375	4206	}
3376	4207
..	..	@@ -3690,6 +4521,14 @@
3690	4521	cqr->retries = startdev->default_retries;
3691	4522	cqr->buildclk = get_tod_clock();
3692	4523	cqr->status = DASD_CQR_FILLED;
	4524	+
	4525	+ /* Set flags to suppress output for expected errors */
	4526	+ if (dasd_eckd_is_ese(basedev)) {
	4527	+ set_bit(DASD_CQR_SUPPRESS_FP, &cqr->flags);
	4528	+ set_bit(DASD_CQR_SUPPRESS_IL, &cqr->flags);
	4529	+ set_bit(DASD_CQR_SUPPRESS_NRF, &cqr->flags);
	4530	+ }
	4531	+
3693	4532	return cqr;
3694	4533	out_error:
3695	4534	dasd_sfree_request(cqr, startdev);
..	..	@@ -3788,7 +4627,6 @@
3788	4627	struct dasd_device *basedev;
3789	4628	struct req_iterator iter;
3790	4629	struct dasd_ccw_req *cqr;
3791		- unsigned int first_offs;
3792	4630	unsigned int trkcount;
3793	4631	unsigned long *idaws;
3794	4632	unsigned int size;
..	..	@@ -3813,7 +4651,7 @@
3813	4651	if ((start_padding_sectors \|\| end_padding_sectors) &&
3814	4652	(rq_data_dir(req) == WRITE)) {
3815	4653	DBF_DEV_EVENT(DBF_ERR, basedev,
3816		- "raw write not track aligned (%lu,%lu) req %p",
	4654	+ "raw write not track aligned (%llu,%llu) req %p",
3817	4655	start_padding_sectors, end_padding_sectors, req);
3818	4656	return ERR_PTR(-EINVAL);
3819	4657	}
..	..	@@ -3822,7 +4660,6 @@
3822	4660	last_trk = (blk_rq_pos(req) + blk_rq_sectors(req) - 1) /
3823	4661	DASD_RAW_SECTORS_PER_TRACK;
3824	4662	trkcount = last_trk - first_trk + 1;
3825		- first_offs = 0;
3826	4663
3827	4664	if (rq_data_dir(req) == READ)
3828	4665	cmd = DASD_ECKD_CCW_READ_TRACK;
..	..	@@ -3866,13 +4703,13 @@
3866	4703
3867	4704	if (use_prefix) {
3868	4705	prefix_LRE(ccw++, data, first_trk, last_trk, cmd, basedev,
3869		- startdev, 1, first_offs + 1, trkcount, 0, 0);
	4706	+ startdev, 1, 0, trkcount, 0, 0);
3870	4707	} else {
3871	4708	define_extent(ccw++, data, first_trk, last_trk, cmd, basedev, 0);
3872	4709	ccw[-1].flags \|= CCW_FLAG_CC;
3873	4710
3874	4711	data += sizeof(struct DE_eckd_data);
3875		- locate_record_ext(ccw++, data, first_trk, first_offs + 1,
	4712	+ locate_record_ext(ccw++, data, first_trk, 0,
3876	4713	trkcount, cmd, basedev, 0, 0);
3877	4714	}
3878	4715
..	..	@@ -4951,6 +5788,12 @@
4951	5788	/* Read Feature Codes */
4952	5789	dasd_eckd_read_features(device);
4953	5790
	5791	+ /* Read Volume Information */
	5792	+ dasd_eckd_read_vol_info(device);
	5793	+
	5794	+ /* Read Extent Pool Information */
	5795	+ dasd_eckd_read_ext_pool_info(device);
	5796	+
4954	5797	/* Read Device Characteristics */
4955	5798	rc = dasd_generic_read_dev_chars(device, DASD_ECKD_MAGIC,
4956	5799	&temp_rdc_data, 64);
..	..	@@ -5621,6 +6464,73 @@
5621	6464	device->discipline->check_attention(device, lpum);
5622	6465	}
5623	6466
	6467	+static void dasd_eckd_oos_resume(struct dasd_device *device)
	6468	+{
	6469	+ struct dasd_eckd_private *private = device->private;
	6470	+ struct alias_pav_group pavgroup, tempgroup;
	6471	+ struct dasd_device dev, n;
	6472	+ unsigned long flags;
	6473	+
	6474	+ spin_lock_irqsave(&private->lcu->lock, flags);
	6475	+ list_for_each_entry_safe(dev, n, &private->lcu->active_devices,
	6476	+ alias_list) {
	6477	+ if (dev->stopped & DASD_STOPPED_NOSPC)
	6478	+ dasd_generic_space_avail(dev);
	6479	+ }
	6480	+ list_for_each_entry_safe(dev, n, &private->lcu->inactive_devices,
	6481	+ alias_list) {
	6482	+ if (dev->stopped & DASD_STOPPED_NOSPC)
	6483	+ dasd_generic_space_avail(dev);
	6484	+ }
	6485	+ /* devices in PAV groups */
	6486	+ list_for_each_entry_safe(pavgroup, tempgroup,
	6487	+ &private->lcu->grouplist,
	6488	+ group) {
	6489	+ list_for_each_entry_safe(dev, n, &pavgroup->baselist,
	6490	+ alias_list) {
	6491	+ if (dev->stopped & DASD_STOPPED_NOSPC)
	6492	+ dasd_generic_space_avail(dev);
	6493	+ }
	6494	+ list_for_each_entry_safe(dev, n, &pavgroup->aliaslist,
	6495	+ alias_list) {
	6496	+ if (dev->stopped & DASD_STOPPED_NOSPC)
	6497	+ dasd_generic_space_avail(dev);
	6498	+ }
	6499	+ }
	6500	+ spin_unlock_irqrestore(&private->lcu->lock, flags);
	6501	+}
	6502	+
	6503	+static void dasd_eckd_handle_oos(struct dasd_device device, void messages,
	6504	+ __u8 lpum)
	6505	+{
	6506	+ struct dasd_oos_message *oos = messages;
	6507	+
	6508	+ switch (oos->code) {
	6509	+ case REPO_WARN:
	6510	+ case POOL_WARN:
	6511	+ dev_warn(&device->cdev->dev,
	6512	+ "Extent pool usage has reached a critical value\n");
	6513	+ dasd_eckd_oos_resume(device);
	6514	+ break;
	6515	+ case REPO_EXHAUST:
	6516	+ case POOL_EXHAUST:
	6517	+ dev_warn(&device->cdev->dev,
	6518	+ "Extent pool is exhausted\n");
	6519	+ break;
	6520	+ case REPO_RELIEVE:
	6521	+ case POOL_RELIEVE:
	6522	+ dev_info(&device->cdev->dev,
	6523	+ "Extent pool physical space constraint has been relieved\n");
	6524	+ break;
	6525	+ }
	6526	+
	6527	+ /* In any case, update related data */
	6528	+ dasd_eckd_read_ext_pool_info(device);
	6529	+
	6530	+ /* to make sure there is no attention left schedule work again */
	6531	+ device->discipline->check_attention(device, lpum);
	6532	+}
	6533	+
5624	6534	static void dasd_eckd_check_attention_work(struct work_struct *work)
5625	6535	{
5626	6536	struct check_attention_work_data *data;
..	..	@@ -5639,9 +6549,14 @@
5639	6549	rc = dasd_eckd_read_message_buffer(device, messages, data->lpum);
5640	6550	if (rc)
5641	6551	goto out;
	6552	+
5642	6553	if (messages->length == ATTENTION_LENGTH_CUIR &&
5643	6554	messages->format == ATTENTION_FORMAT_CUIR)
5644	6555	dasd_eckd_handle_cuir(device, messages, data->lpum);
	6556	+ if (messages->length == ATTENTION_LENGTH_OOS &&
	6557	+ messages->format == ATTENTION_FORMAT_OOS)
	6558	+ dasd_eckd_handle_oos(device, messages, data->lpum);
	6559	+
5645	6560	out:
5646	6561	dasd_put_device(device);
5647	6562	kfree(messages);
..	..	@@ -5720,6 +6635,38 @@
5720	6635	dasd_schedule_requeue(device);
5721	6636	}
5722	6637
	6638	+/*
	6639	+ * Initialize block layer request queue.
	6640	+ */
	6641	+static void dasd_eckd_setup_blk_queue(struct dasd_block *block)
	6642	+{
	6643	+ unsigned int logical_block_size = block->bp_block;
	6644	+ struct request_queue *q = block->request_queue;
	6645	+ struct dasd_device *device = block->base;
	6646	+ int max;
	6647	+
	6648	+ if (device->features & DASD_FEATURE_USERAW) {
	6649	+ /*
	6650	+ * the max_blocks value for raw_track access is 256
	6651	+ * it is higher than the native ECKD value because we
	6652	+ * only need one ccw per track
	6653	+ * so the max_hw_sectors are
	6654	+ * 2048 x 512B = 1024kB = 16 tracks
	6655	+ */
	6656	+ max = DASD_ECKD_MAX_BLOCKS_RAW << block->s2b_shift;
	6657	+ } else {
	6658	+ max = DASD_ECKD_MAX_BLOCKS << block->s2b_shift;
	6659	+ }
	6660	+ blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
	6661	+ q->limits.max_dev_sectors = max;
	6662	+ blk_queue_logical_block_size(q, logical_block_size);
	6663	+ blk_queue_max_hw_sectors(q, max);
	6664	+ blk_queue_max_segments(q, USHRT_MAX);
	6665	+ /* With page sized segments each segment can be translated into one idaw/tidaw */
	6666	+ blk_queue_max_segment_size(q, PAGE_SIZE);
	6667	+ blk_queue_segment_boundary(q, PAGE_SIZE - 1);
	6668	+}
	6669	+
5723	6670	static struct ccw_driver dasd_eckd_driver = {
5724	6671	.driver = {
5725	6672	.name = "dasd-eckd",
..	..	@@ -5740,24 +6687,10 @@
5740	6687	.int_class = IRQIO_DAS,
5741	6688	};
5742	6689
5743		-/*
5744		- * max_blocks is dependent on the amount of storage that is available
5745		- * in the static io buffer for each device. Currently each device has
5746		- * 8192 bytes (=2 pages). For 64 bit one dasd_mchunkt_t structure has
5747		- * 24 bytes, the struct dasd_ccw_req has 136 bytes and each block can use
5748		- * up to 16 bytes (8 for the ccw and 8 for the idal pointer). In
5749		- * addition we have one define extent ccw + 16 bytes of data and one
5750		- * locate record ccw + 16 bytes of data. That makes:
5751		- * (8192 - 24 - 136 - 8 - 16 - 8 - 16) / 16 = 499 blocks at maximum.
5752		- * We want to fit two into the available memory so that we can immediately
5753		- * start the next request if one finishes off. That makes 249.5 blocks
5754		- * for one request. Give a little safety and the result is 240.
5755		- */
5756	6690	static struct dasd_discipline dasd_eckd_discipline = {
5757	6691	.owner = THIS_MODULE,
5758	6692	.name = "ECKD",
5759	6693	.ebcname = "ECKD",
5760		- .max_blocks = 190,
5761	6694	.check_device = dasd_eckd_check_characteristics,
5762	6695	.uncheck_device = dasd_eckd_uncheck_device,
5763	6696	.do_analysis = dasd_eckd_do_analysis,
..	..	@@ -5765,6 +6698,7 @@
5765	6698	.basic_to_ready = dasd_eckd_basic_to_ready,
5766	6699	.online_to_ready = dasd_eckd_online_to_ready,
5767	6700	.basic_to_known = dasd_eckd_basic_to_known,
	6701	+ .setup_blk_queue = dasd_eckd_setup_blk_queue,
5768	6702	.fill_geometry = dasd_eckd_fill_geometry,
5769	6703	.start_IO = dasd_start_IO,
5770	6704	.term_IO = dasd_term_IO,
..	..	@@ -5792,6 +6726,19 @@
5792	6726	.disable_hpf = dasd_eckd_disable_hpf_device,
5793	6727	.hpf_enabled = dasd_eckd_hpf_enabled,
5794	6728	.reset_path = dasd_eckd_reset_path,
	6729	+ .is_ese = dasd_eckd_is_ese,
	6730	+ .space_allocated = dasd_eckd_space_allocated,
	6731	+ .space_configured = dasd_eckd_space_configured,
	6732	+ .logical_capacity = dasd_eckd_logical_capacity,
	6733	+ .release_space = dasd_eckd_release_space,
	6734	+ .ext_pool_id = dasd_eckd_ext_pool_id,
	6735	+ .ext_size = dasd_eckd_ext_size,
	6736	+ .ext_pool_cap_at_warnlevel = dasd_eckd_ext_pool_cap_at_warnlevel,
	6737	+ .ext_pool_warn_thrshld = dasd_eckd_ext_pool_warn_thrshld,
	6738	+ .ext_pool_oos = dasd_eckd_ext_pool_oos,
	6739	+ .ext_pool_exhaust = dasd_eckd_ext_pool_exhaust,
	6740	+ .ese_format = dasd_eckd_ese_format,
	6741	+ .ese_read = dasd_eckd_ese_read,
5795	6742	};
5796	6743
5797	6744	static int __init
..	..	@@ -5804,16 +6751,22 @@
5804	6751	GFP_KERNEL \| GFP_DMA);
5805	6752	if (!dasd_reserve_req)
5806	6753	return -ENOMEM;
	6754	+ dasd_vol_info_req = kmalloc(sizeof(*dasd_vol_info_req),
	6755	+ GFP_KERNEL \| GFP_DMA);
	6756	+ if (!dasd_vol_info_req)
	6757	+ return -ENOMEM;
5807	6758	path_verification_worker = kmalloc(sizeof(*path_verification_worker),
5808	6759	GFP_KERNEL \| GFP_DMA);
5809	6760	if (!path_verification_worker) {
5810	6761	kfree(dasd_reserve_req);
	6762	+ kfree(dasd_vol_info_req);
5811	6763	return -ENOMEM;
5812	6764	}
5813	6765	rawpadpage = (void *)__get_free_page(GFP_KERNEL);
5814	6766	if (!rawpadpage) {
5815	6767	kfree(path_verification_worker);
5816	6768	kfree(dasd_reserve_req);
	6769	+ kfree(dasd_vol_info_req);
5817	6770	return -ENOMEM;
5818	6771	}
5819	6772	ret = ccw_driver_register(&dasd_eckd_driver);
..	..	@@ -5822,6 +6775,7 @@
5822	6775	else {
5823	6776	kfree(path_verification_worker);
5824	6777	kfree(dasd_reserve_req);
	6778	+ kfree(dasd_vol_info_req);
5825	6779	free_page((unsigned long)rawpadpage);
5826	6780	}
5827	6781	return ret;