Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 34aec07c170b972a29c954b37047184bd0f9f294

Authored by Sebastian Ott 2010-10-25 22:10:28 +0800

Committed by Martin Schwidefsky 2010-10-25 22:10:18 +0800

Exists in master and in 7 other branches

[S390] chsc: initialization fixes

This patch fixes:
 * kfree vs. free_page usage
 * structure definition for determine_css_characteristics
 * naming convention for the chsc init function
 * deregistration of crw handlers in the cleanup path

Signed-off-by: Sebastian Ott <sebott@linux.vnet.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

Showing 3 changed files with 17 additions and 17 deletions Inline Diff

drivers/s390/cio/chsc.c
drivers/s390/cio/chsc.h
drivers/s390/cio/css.c

drivers/s390/cio/chsc.c

Diff comments View file @ 34aec07

1	/*	1	/*
2	* drivers/s390/cio/chsc.c	2	* drivers/s390/cio/chsc.c
3	* S/390 common I/O routines -- channel subsystem call	3	* S/390 common I/O routines -- channel subsystem call
4	*	4	*
5	* Copyright IBM Corp. 1999,2008	5	* Copyright IBM Corp. 1999,2010
6	* Author(s): Ingo Adlung (adlung@de.ibm.com)	6	* Author(s): Ingo Adlung (adlung@de.ibm.com)
7	* Cornelia Huck (cornelia.huck@de.ibm.com)	7	* Cornelia Huck (cornelia.huck@de.ibm.com)
8	* Arnd Bergmann (arndb@de.ibm.com)	8	* Arnd Bergmann (arndb@de.ibm.com)
9	*/	9	*/
10		10
11	#define KMSG_COMPONENT "cio"	11	#define KMSG_COMPONENT "cio"
12	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt	12	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13		13
14	#include <linux/module.h>	14	#include <linux/module.h>
15	#include <linux/slab.h>	15	#include <linux/slab.h>
16	#include <linux/init.h>	16	#include <linux/init.h>
17	#include <linux/device.h>	17	#include <linux/device.h>
18		18
19	#include <asm/cio.h>	19	#include <asm/cio.h>
20	#include <asm/chpid.h>	20	#include <asm/chpid.h>
21	#include <asm/chsc.h>	21	#include <asm/chsc.h>
22	#include <asm/crw.h>	22	#include <asm/crw.h>
23		23
24	#include "css.h"	24	#include "css.h"
25	#include "cio.h"	25	#include "cio.h"
26	#include "cio_debug.h"	26	#include "cio_debug.h"
27	#include "ioasm.h"	27	#include "ioasm.h"
28	#include "chp.h"	28	#include "chp.h"
29	#include "chsc.h"	29	#include "chsc.h"
30		30
31	static void *sei_page;	31	static void *sei_page;
32	static DEFINE_SPINLOCK(siosl_lock);	32	static DEFINE_SPINLOCK(siosl_lock);
33	static DEFINE_SPINLOCK(sda_lock);	33	static DEFINE_SPINLOCK(sda_lock);
34		34
35	/**	35	/**
36	* chsc_error_from_response() - convert a chsc response to an error	36	* chsc_error_from_response() - convert a chsc response to an error
37	* @response: chsc response code	37	* @response: chsc response code
38	*	38	*
39	* Returns an appropriate Linux error code for @response.	39	* Returns an appropriate Linux error code for @response.
40	*/	40	*/
41	int chsc_error_from_response(int response)	41	int chsc_error_from_response(int response)
42	{	42	{
43	switch (response) {	43	switch (response) {
44	case 0x0001:	44	case 0x0001:
45	return 0;	45	return 0;
46	case 0x0002:	46	case 0x0002:
47	case 0x0003:	47	case 0x0003:
48	case 0x0006:	48	case 0x0006:
49	case 0x0007:	49	case 0x0007:
50	case 0x0008:	50	case 0x0008:
51	case 0x000a:	51	case 0x000a:
52	case 0x0104:	52	case 0x0104:
53	return -EINVAL;	53	return -EINVAL;
54	case 0x0004:	54	case 0x0004:
55	return -EOPNOTSUPP;	55	return -EOPNOTSUPP;
56	default:	56	default:
57	return -EIO;	57	return -EIO;
58	}	58	}
59	}	59	}
60	EXPORT_SYMBOL_GPL(chsc_error_from_response);	60	EXPORT_SYMBOL_GPL(chsc_error_from_response);
61		61
62	struct chsc_ssd_area {	62	struct chsc_ssd_area {
63	struct chsc_header request;	63	struct chsc_header request;
64	u16 :10;	64	u16 :10;
65	u16 ssid:2;	65	u16 ssid:2;
66	u16 :4;	66	u16 :4;
67	u16 f_sch; /* first subchannel */	67	u16 f_sch; /* first subchannel */
68	u16 :16;	68	u16 :16;
69	u16 l_sch; /* last subchannel */	69	u16 l_sch; /* last subchannel */
70	u32 :32;	70	u32 :32;
71	struct chsc_header response;	71	struct chsc_header response;
72	u32 :32;	72	u32 :32;
73	u8 sch_valid : 1;	73	u8 sch_valid : 1;
74	u8 dev_valid : 1;	74	u8 dev_valid : 1;
75	u8 st : 3; /* subchannel type */	75	u8 st : 3; /* subchannel type */
76	u8 zeroes : 3;	76	u8 zeroes : 3;
77	u8 unit_addr; /* unit address */	77	u8 unit_addr; /* unit address */
78	u16 devno; /* device number */	78	u16 devno; /* device number */
79	u8 path_mask;	79	u8 path_mask;
80	u8 fla_valid_mask;	80	u8 fla_valid_mask;
81	u16 sch; /* subchannel */	81	u16 sch; /* subchannel */
82	u8 chpid[8]; /* chpids 0-7 */	82	u8 chpid[8]; /* chpids 0-7 */
83	u16 fla[8]; /* full link addresses 0-7 */	83	u16 fla[8]; /* full link addresses 0-7 */
84	} __attribute__ ((packed));	84	} __attribute__ ((packed));
85		85
86	int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd)	86	int chsc_get_ssd_info(struct subchannel_id schid, struct chsc_ssd_info *ssd)
87	{	87	{
88	unsigned long page;	88	unsigned long page;
89	struct chsc_ssd_area *ssd_area;	89	struct chsc_ssd_area *ssd_area;
90	int ccode;	90	int ccode;
91	int ret;	91	int ret;
92	int i;	92	int i;
93	int mask;	93	int mask;
94		94
95	page = get_zeroed_page(GFP_KERNEL \| GFP_DMA);	95	page = get_zeroed_page(GFP_KERNEL \| GFP_DMA);
96	if (!page)	96	if (!page)
97	return -ENOMEM;	97	return -ENOMEM;
98	ssd_area = (struct chsc_ssd_area *) page;	98	ssd_area = (struct chsc_ssd_area *) page;
99	ssd_area->request.length = 0x0010;	99	ssd_area->request.length = 0x0010;
100	ssd_area->request.code = 0x0004;	100	ssd_area->request.code = 0x0004;
101	ssd_area->ssid = schid.ssid;	101	ssd_area->ssid = schid.ssid;
102	ssd_area->f_sch = schid.sch_no;	102	ssd_area->f_sch = schid.sch_no;
103	ssd_area->l_sch = schid.sch_no;	103	ssd_area->l_sch = schid.sch_no;
104		104
105	ccode = chsc(ssd_area);	105	ccode = chsc(ssd_area);
106	/* Check response. */	106	/* Check response. */
107	if (ccode > 0) {	107	if (ccode > 0) {
108	ret = (ccode == 3) ? -ENODEV : -EBUSY;	108	ret = (ccode == 3) ? -ENODEV : -EBUSY;
109	goto out_free;	109	goto out_free;
110	}	110	}
111	ret = chsc_error_from_response(ssd_area->response.code);	111	ret = chsc_error_from_response(ssd_area->response.code);
112	if (ret != 0) {	112	if (ret != 0) {
113	CIO_MSG_EVENT(2, "chsc: ssd failed for 0.%x.%04x (rc=%04x)\n",	113	CIO_MSG_EVENT(2, "chsc: ssd failed for 0.%x.%04x (rc=%04x)\n",
114	schid.ssid, schid.sch_no,	114	schid.ssid, schid.sch_no,
115	ssd_area->response.code);	115	ssd_area->response.code);
116	goto out_free;	116	goto out_free;
117	}	117	}
118	if (!ssd_area->sch_valid) {	118	if (!ssd_area->sch_valid) {
119	ret = -ENODEV;	119	ret = -ENODEV;
120	goto out_free;	120	goto out_free;
121	}	121	}
122	/* Copy data */	122	/* Copy data */
123	ret = 0;	123	ret = 0;
124	memset(ssd, 0, sizeof(struct chsc_ssd_info));	124	memset(ssd, 0, sizeof(struct chsc_ssd_info));
125	if ((ssd_area->st != SUBCHANNEL_TYPE_IO) &&	125	if ((ssd_area->st != SUBCHANNEL_TYPE_IO) &&
126	(ssd_area->st != SUBCHANNEL_TYPE_MSG))	126	(ssd_area->st != SUBCHANNEL_TYPE_MSG))
127	goto out_free;	127	goto out_free;
128	ssd->path_mask = ssd_area->path_mask;	128	ssd->path_mask = ssd_area->path_mask;
129	ssd->fla_valid_mask = ssd_area->fla_valid_mask;	129	ssd->fla_valid_mask = ssd_area->fla_valid_mask;
130	for (i = 0; i < 8; i++) {	130	for (i = 0; i < 8; i++) {
131	mask = 0x80 >> i;	131	mask = 0x80 >> i;
132	if (ssd_area->path_mask & mask) {	132	if (ssd_area->path_mask & mask) {
133	chp_id_init(&ssd->chpid[i]);	133	chp_id_init(&ssd->chpid[i]);
134	ssd->chpid[i].id = ssd_area->chpid[i];	134	ssd->chpid[i].id = ssd_area->chpid[i];
135	}	135	}
136	if (ssd_area->fla_valid_mask & mask)	136	if (ssd_area->fla_valid_mask & mask)
137	ssd->fla[i] = ssd_area->fla[i];	137	ssd->fla[i] = ssd_area->fla[i];
138	}	138	}
139	out_free:	139	out_free:
140	free_page(page);	140	free_page(page);
141	return ret;	141	return ret;
142	}	142	}
143		143
144	static int s390_subchannel_remove_chpid(struct subchannel sch, void data)	144	static int s390_subchannel_remove_chpid(struct subchannel sch, void data)
145	{	145	{
146	spin_lock_irq(sch->lock);	146	spin_lock_irq(sch->lock);
147	if (sch->driver && sch->driver->chp_event)	147	if (sch->driver && sch->driver->chp_event)
148	if (sch->driver->chp_event(sch, data, CHP_OFFLINE) != 0)	148	if (sch->driver->chp_event(sch, data, CHP_OFFLINE) != 0)
149	goto out_unreg;	149	goto out_unreg;
150	spin_unlock_irq(sch->lock);	150	spin_unlock_irq(sch->lock);
151	return 0;	151	return 0;
152		152
153	out_unreg:	153	out_unreg:
154	sch->lpm = 0;	154	sch->lpm = 0;
155	spin_unlock_irq(sch->lock);	155	spin_unlock_irq(sch->lock);
156	css_schedule_eval(sch->schid);	156	css_schedule_eval(sch->schid);
157	return 0;	157	return 0;
158	}	158	}
159		159
160	void chsc_chp_offline(struct chp_id chpid)	160	void chsc_chp_offline(struct chp_id chpid)
161	{	161	{
162	char dbf_txt[15];	162	char dbf_txt[15];
163	struct chp_link link;	163	struct chp_link link;
164		164
165	sprintf(dbf_txt, "chpr%x.%02x", chpid.cssid, chpid.id);	165	sprintf(dbf_txt, "chpr%x.%02x", chpid.cssid, chpid.id);
166	CIO_TRACE_EVENT(2, dbf_txt);	166	CIO_TRACE_EVENT(2, dbf_txt);
167		167
168	if (chp_get_status(chpid) <= 0)	168	if (chp_get_status(chpid) <= 0)
169	return;	169	return;
170	memset(&link, 0, sizeof(struct chp_link));	170	memset(&link, 0, sizeof(struct chp_link));
171	link.chpid = chpid;	171	link.chpid = chpid;
172	/* Wait until previous actions have settled. */	172	/* Wait until previous actions have settled. */
173	css_wait_for_slow_path();	173	css_wait_for_slow_path();
174	for_each_subchannel_staged(s390_subchannel_remove_chpid, NULL, &link);	174	for_each_subchannel_staged(s390_subchannel_remove_chpid, NULL, &link);
175	}	175	}
176		176
177	static int s390_process_res_acc_new_sch(struct subchannel_id schid, void *data)	177	static int s390_process_res_acc_new_sch(struct subchannel_id schid, void *data)
178	{	178	{
179	struct schib schib;	179	struct schib schib;
180	/*	180	/*
181	* We don't know the device yet, but since a path	181	* We don't know the device yet, but since a path
182	* may be available now to the device we'll have	182	* may be available now to the device we'll have
183	* to do recognition again.	183	* to do recognition again.
184	* Since we don't have any idea about which chpid	184	* Since we don't have any idea about which chpid
185	* that beast may be on we'll have to do a stsch	185	* that beast may be on we'll have to do a stsch
186	* on all devices, grr...	186	* on all devices, grr...
187	*/	187	*/
188	if (stsch_err(schid, &schib))	188	if (stsch_err(schid, &schib))
189	/* We're through */	189	/* We're through */
190	return -ENXIO;	190	return -ENXIO;
191		191
192	/* Put it on the slow path. */	192	/* Put it on the slow path. */
193	css_schedule_eval(schid);	193	css_schedule_eval(schid);
194	return 0;	194	return 0;
195	}	195	}
196		196
197	static int __s390_process_res_acc(struct subchannel sch, void data)	197	static int __s390_process_res_acc(struct subchannel sch, void data)
198	{	198	{
199	spin_lock_irq(sch->lock);	199	spin_lock_irq(sch->lock);
200	if (sch->driver && sch->driver->chp_event)	200	if (sch->driver && sch->driver->chp_event)
201	sch->driver->chp_event(sch, data, CHP_ONLINE);	201	sch->driver->chp_event(sch, data, CHP_ONLINE);
202	spin_unlock_irq(sch->lock);	202	spin_unlock_irq(sch->lock);
203		203
204	return 0;	204	return 0;
205	}	205	}
206		206
207	static void s390_process_res_acc(struct chp_link *link)	207	static void s390_process_res_acc(struct chp_link *link)
208	{	208	{
209	char dbf_txt[15];	209	char dbf_txt[15];
210		210
211	sprintf(dbf_txt, "accpr%x.%02x", link->chpid.cssid,	211	sprintf(dbf_txt, "accpr%x.%02x", link->chpid.cssid,
212	link->chpid.id);	212	link->chpid.id);
213	CIO_TRACE_EVENT( 2, dbf_txt);	213	CIO_TRACE_EVENT( 2, dbf_txt);
214	if (link->fla != 0) {	214	if (link->fla != 0) {
215	sprintf(dbf_txt, "fla%x", link->fla);	215	sprintf(dbf_txt, "fla%x", link->fla);
216	CIO_TRACE_EVENT( 2, dbf_txt);	216	CIO_TRACE_EVENT( 2, dbf_txt);
217	}	217	}
218	/* Wait until previous actions have settled. */	218	/* Wait until previous actions have settled. */
219	css_wait_for_slow_path();	219	css_wait_for_slow_path();
220	/*	220	/*
221	* I/O resources may have become accessible.	221	* I/O resources may have become accessible.
222	* Scan through all subchannels that may be concerned and	222	* Scan through all subchannels that may be concerned and
223	* do a validation on those.	223	* do a validation on those.
224	* The more information we have (info), the less scanning	224	* The more information we have (info), the less scanning
225	* will we have to do.	225	* will we have to do.
226	*/	226	*/
227	for_each_subchannel_staged(__s390_process_res_acc,	227	for_each_subchannel_staged(__s390_process_res_acc,
228	s390_process_res_acc_new_sch, link);	228	s390_process_res_acc_new_sch, link);
229	}	229	}
230		230
231	static int	231	static int
232	__get_chpid_from_lir(void *data)	232	__get_chpid_from_lir(void *data)
233	{	233	{
234	struct lir {	234	struct lir {
235	u8 iq;	235	u8 iq;
236	u8 ic;	236	u8 ic;
237	u16 sci;	237	u16 sci;
238	/* incident-node descriptor */	238	/* incident-node descriptor */
239	u32 indesc[28];	239	u32 indesc[28];
240	/* attached-node descriptor */	240	/* attached-node descriptor */
241	u32 andesc[28];	241	u32 andesc[28];
242	/* incident-specific information */	242	/* incident-specific information */
243	u32 isinfo[28];	243	u32 isinfo[28];
244	} __attribute__ ((packed)) *lir;	244	} __attribute__ ((packed)) *lir;
245		245
246	lir = data;	246	lir = data;
247	if (!(lir->iq&0x80))	247	if (!(lir->iq&0x80))
248	/* NULL link incident record */	248	/* NULL link incident record */
249	return -EINVAL;	249	return -EINVAL;
250	if (!(lir->indesc[0]&0xc0000000))	250	if (!(lir->indesc[0]&0xc0000000))
251	/* node descriptor not valid */	251	/* node descriptor not valid */
252	return -EINVAL;	252	return -EINVAL;
253	if (!(lir->indesc[0]&0x10000000))	253	if (!(lir->indesc[0]&0x10000000))
254	/* don't handle device-type nodes - FIXME */	254	/* don't handle device-type nodes - FIXME */
255	return -EINVAL;	255	return -EINVAL;
256	/* Byte 3 contains the chpid. Could also be CTCA, but we don't care */	256	/* Byte 3 contains the chpid. Could also be CTCA, but we don't care */
257		257
258	return (u16) (lir->indesc[0]&0x000000ff);	258	return (u16) (lir->indesc[0]&0x000000ff);
259	}	259	}
260		260
261	struct chsc_sei_area {	261	struct chsc_sei_area {
262	struct chsc_header request;	262	struct chsc_header request;
263	u32 reserved1;	263	u32 reserved1;
264	u32 reserved2;	264	u32 reserved2;
265	u32 reserved3;	265	u32 reserved3;
266	struct chsc_header response;	266	struct chsc_header response;
267	u32 reserved4;	267	u32 reserved4;
268	u8 flags;	268	u8 flags;
269	u8 vf; /* validity flags */	269	u8 vf; /* validity flags */
270	u8 rs; /* reporting source */	270	u8 rs; /* reporting source */
271	u8 cc; /* content code */	271	u8 cc; /* content code */
272	u16 fla; /* full link address */	272	u16 fla; /* full link address */
273	u16 rsid; /* reporting source id */	273	u16 rsid; /* reporting source id */
274	u32 reserved5;	274	u32 reserved5;
275	u32 reserved6;	275	u32 reserved6;
276	u8 ccdf[4096 - 16 - 24]; /* content-code dependent field */	276	u8 ccdf[4096 - 16 - 24]; /* content-code dependent field */
277	/* ccdf has to be big enough for a link-incident record */	277	/* ccdf has to be big enough for a link-incident record */
278	} __attribute__ ((packed));	278	} __attribute__ ((packed));
279		279
280	static void chsc_process_sei_link_incident(struct chsc_sei_area *sei_area)	280	static void chsc_process_sei_link_incident(struct chsc_sei_area *sei_area)
281	{	281	{
282	struct chp_id chpid;	282	struct chp_id chpid;
283	int id;	283	int id;
284		284
285	CIO_CRW_EVENT(4, "chsc: link incident (rs=%02x, rs_id=%04x)\n",	285	CIO_CRW_EVENT(4, "chsc: link incident (rs=%02x, rs_id=%04x)\n",
286	sei_area->rs, sei_area->rsid);	286	sei_area->rs, sei_area->rsid);
287	if (sei_area->rs != 4)	287	if (sei_area->rs != 4)
288	return;	288	return;
289	id = __get_chpid_from_lir(sei_area->ccdf);	289	id = __get_chpid_from_lir(sei_area->ccdf);
290	if (id < 0)	290	if (id < 0)
291	CIO_CRW_EVENT(4, "chsc: link incident - invalid LIR\n");	291	CIO_CRW_EVENT(4, "chsc: link incident - invalid LIR\n");
292	else {	292	else {
293	chp_id_init(&chpid);	293	chp_id_init(&chpid);
294	chpid.id = id;	294	chpid.id = id;
295	chsc_chp_offline(chpid);	295	chsc_chp_offline(chpid);
296	}	296	}
297	}	297	}
298		298
299	static void chsc_process_sei_res_acc(struct chsc_sei_area *sei_area)	299	static void chsc_process_sei_res_acc(struct chsc_sei_area *sei_area)
300	{	300	{
301	struct chp_link link;	301	struct chp_link link;
302	struct chp_id chpid;	302	struct chp_id chpid;
303	int status;	303	int status;
304		304
305	CIO_CRW_EVENT(4, "chsc: resource accessibility event (rs=%02x, "	305	CIO_CRW_EVENT(4, "chsc: resource accessibility event (rs=%02x, "
306	"rs_id=%04x)\n", sei_area->rs, sei_area->rsid);	306	"rs_id=%04x)\n", sei_area->rs, sei_area->rsid);
307	if (sei_area->rs != 4)	307	if (sei_area->rs != 4)
308	return;	308	return;
309	chp_id_init(&chpid);	309	chp_id_init(&chpid);
310	chpid.id = sei_area->rsid;	310	chpid.id = sei_area->rsid;
311	/* allocate a new channel path structure, if needed */	311	/* allocate a new channel path structure, if needed */
312	status = chp_get_status(chpid);	312	status = chp_get_status(chpid);
313	if (status < 0)	313	if (status < 0)
314	chp_new(chpid);	314	chp_new(chpid);
315	else if (!status)	315	else if (!status)
316	return;	316	return;
317	memset(&link, 0, sizeof(struct chp_link));	317	memset(&link, 0, sizeof(struct chp_link));
318	link.chpid = chpid;	318	link.chpid = chpid;
319	if ((sei_area->vf & 0xc0) != 0) {	319	if ((sei_area->vf & 0xc0) != 0) {
320	link.fla = sei_area->fla;	320	link.fla = sei_area->fla;
321	if ((sei_area->vf & 0xc0) == 0xc0)	321	if ((sei_area->vf & 0xc0) == 0xc0)
322	/* full link address */	322	/* full link address */
323	link.fla_mask = 0xffff;	323	link.fla_mask = 0xffff;
324	else	324	else
325	/* link address */	325	/* link address */
326	link.fla_mask = 0xff00;	326	link.fla_mask = 0xff00;
327	}	327	}
328	s390_process_res_acc(&link);	328	s390_process_res_acc(&link);
329	}	329	}
330		330
331	struct chp_config_data {	331	struct chp_config_data {
332	u8 map[32];	332	u8 map[32];
333	u8 op;	333	u8 op;
334	u8 pc;	334	u8 pc;
335	};	335	};
336		336
337	static void chsc_process_sei_chp_config(struct chsc_sei_area *sei_area)	337	static void chsc_process_sei_chp_config(struct chsc_sei_area *sei_area)
338	{	338	{
339	struct chp_config_data *data;	339	struct chp_config_data *data;
340	struct chp_id chpid;	340	struct chp_id chpid;
341	int num;	341	int num;
342	char *events[3] = {"configure", "deconfigure", "cancel deconfigure"};	342	char *events[3] = {"configure", "deconfigure", "cancel deconfigure"};
343		343
344	CIO_CRW_EVENT(4, "chsc: channel-path-configuration notification\n");	344	CIO_CRW_EVENT(4, "chsc: channel-path-configuration notification\n");
345	if (sei_area->rs != 0)	345	if (sei_area->rs != 0)
346	return;	346	return;
347	data = (struct chp_config_data *) &(sei_area->ccdf);	347	data = (struct chp_config_data *) &(sei_area->ccdf);
348	chp_id_init(&chpid);	348	chp_id_init(&chpid);
349	for (num = 0; num <= __MAX_CHPID; num++) {	349	for (num = 0; num <= __MAX_CHPID; num++) {
350	if (!chp_test_bit(data->map, num))	350	if (!chp_test_bit(data->map, num))
351	continue;	351	continue;
352	chpid.id = num;	352	chpid.id = num;
353	pr_notice("Processing %s for channel path %x.%02x\n",	353	pr_notice("Processing %s for channel path %x.%02x\n",
354	events[data->op], chpid.cssid, chpid.id);	354	events[data->op], chpid.cssid, chpid.id);
355	switch (data->op) {	355	switch (data->op) {
356	case 0:	356	case 0:
357	chp_cfg_schedule(chpid, 1);	357	chp_cfg_schedule(chpid, 1);
358	break;	358	break;
359	case 1:	359	case 1:
360	chp_cfg_schedule(chpid, 0);	360	chp_cfg_schedule(chpid, 0);
361	break;	361	break;
362	case 2:	362	case 2:
363	chp_cfg_cancel_deconfigure(chpid);	363	chp_cfg_cancel_deconfigure(chpid);
364	break;	364	break;
365	}	365	}
366	}	366	}
367	}	367	}
368		368
369	static void chsc_process_sei(struct chsc_sei_area *sei_area)	369	static void chsc_process_sei(struct chsc_sei_area *sei_area)
370	{	370	{
371	/* Check if we might have lost some information. */	371	/* Check if we might have lost some information. */
372	if (sei_area->flags & 0x40) {	372	if (sei_area->flags & 0x40) {
373	CIO_CRW_EVENT(2, "chsc: event overflow\n");	373	CIO_CRW_EVENT(2, "chsc: event overflow\n");
374	css_schedule_eval_all();	374	css_schedule_eval_all();
375	}	375	}
376	/* which kind of information was stored? */	376	/* which kind of information was stored? */
377	switch (sei_area->cc) {	377	switch (sei_area->cc) {
378	case 1: /* link incident*/	378	case 1: /* link incident*/
379	chsc_process_sei_link_incident(sei_area);	379	chsc_process_sei_link_incident(sei_area);
380	break;	380	break;
381	case 2: /* i/o resource accessibiliy */	381	case 2: /* i/o resource accessibiliy */
382	chsc_process_sei_res_acc(sei_area);	382	chsc_process_sei_res_acc(sei_area);
383	break;	383	break;
384	case 8: /* channel-path-configuration notification */	384	case 8: /* channel-path-configuration notification */
385	chsc_process_sei_chp_config(sei_area);	385	chsc_process_sei_chp_config(sei_area);
386	break;	386	break;
387	default: /* other stuff */	387	default: /* other stuff */
388	CIO_CRW_EVENT(4, "chsc: unhandled sei content code %d\n",	388	CIO_CRW_EVENT(4, "chsc: unhandled sei content code %d\n",
389	sei_area->cc);	389	sei_area->cc);
390	break;	390	break;
391	}	391	}
392	}	392	}
393		393
394	static void chsc_process_crw(struct crw crw0, struct crw crw1, int overflow)	394	static void chsc_process_crw(struct crw crw0, struct crw crw1, int overflow)
395	{	395	{
396	struct chsc_sei_area *sei_area;	396	struct chsc_sei_area *sei_area;
397		397
398	if (overflow) {	398	if (overflow) {
399	css_schedule_eval_all();	399	css_schedule_eval_all();
400	return;	400	return;
401	}	401	}
402	CIO_CRW_EVENT(2, "CRW reports slct=%d, oflw=%d, "	402	CIO_CRW_EVENT(2, "CRW reports slct=%d, oflw=%d, "
403	"chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",	403	"chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
404	crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,	404	crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
405	crw0->erc, crw0->rsid);	405	crw0->erc, crw0->rsid);
406	if (!sei_page)	406	if (!sei_page)
407	return;	407	return;
408	/* Access to sei_page is serialized through machine check handler	408	/* Access to sei_page is serialized through machine check handler
409	* thread, so no need for locking. */	409	* thread, so no need for locking. */
410	sei_area = sei_page;	410	sei_area = sei_page;
411		411
412	CIO_TRACE_EVENT(2, "prcss");	412	CIO_TRACE_EVENT(2, "prcss");
413	do {	413	do {
414	memset(sei_area, 0, sizeof(*sei_area));	414	memset(sei_area, 0, sizeof(*sei_area));
415	sei_area->request.length = 0x0010;	415	sei_area->request.length = 0x0010;
416	sei_area->request.code = 0x000e;	416	sei_area->request.code = 0x000e;
417	if (chsc(sei_area))	417	if (chsc(sei_area))
418	break;	418	break;
419		419
420	if (sei_area->response.code == 0x0001) {	420	if (sei_area->response.code == 0x0001) {
421	CIO_CRW_EVENT(4, "chsc: sei successful\n");	421	CIO_CRW_EVENT(4, "chsc: sei successful\n");
422	chsc_process_sei(sei_area);	422	chsc_process_sei(sei_area);
423	} else {	423	} else {
424	CIO_CRW_EVENT(2, "chsc: sei failed (rc=%04x)\n",	424	CIO_CRW_EVENT(2, "chsc: sei failed (rc=%04x)\n",
425	sei_area->response.code);	425	sei_area->response.code);
426	break;	426	break;
427	}	427	}
428	} while (sei_area->flags & 0x80);	428	} while (sei_area->flags & 0x80);
429	}	429	}
430		430
431	void chsc_chp_online(struct chp_id chpid)	431	void chsc_chp_online(struct chp_id chpid)
432	{	432	{
433	char dbf_txt[15];	433	char dbf_txt[15];
434	struct chp_link link;	434	struct chp_link link;
435		435
436	sprintf(dbf_txt, "cadd%x.%02x", chpid.cssid, chpid.id);	436	sprintf(dbf_txt, "cadd%x.%02x", chpid.cssid, chpid.id);
437	CIO_TRACE_EVENT(2, dbf_txt);	437	CIO_TRACE_EVENT(2, dbf_txt);
438		438
439	if (chp_get_status(chpid) != 0) {	439	if (chp_get_status(chpid) != 0) {
440	memset(&link, 0, sizeof(struct chp_link));	440	memset(&link, 0, sizeof(struct chp_link));
441	link.chpid = chpid;	441	link.chpid = chpid;
442	/* Wait until previous actions have settled. */	442	/* Wait until previous actions have settled. */
443	css_wait_for_slow_path();	443	css_wait_for_slow_path();
444	for_each_subchannel_staged(__s390_process_res_acc, NULL,	444	for_each_subchannel_staged(__s390_process_res_acc, NULL,
445	&link);	445	&link);
446	}	446	}
447	}	447	}
448		448
449	static void __s390_subchannel_vary_chpid(struct subchannel *sch,	449	static void __s390_subchannel_vary_chpid(struct subchannel *sch,
450	struct chp_id chpid, int on)	450	struct chp_id chpid, int on)
451	{	451	{
452	unsigned long flags;	452	unsigned long flags;
453	struct chp_link link;	453	struct chp_link link;
454		454
455	memset(&link, 0, sizeof(struct chp_link));	455	memset(&link, 0, sizeof(struct chp_link));
456	link.chpid = chpid;	456	link.chpid = chpid;
457	spin_lock_irqsave(sch->lock, flags);	457	spin_lock_irqsave(sch->lock, flags);
458	if (sch->driver && sch->driver->chp_event)	458	if (sch->driver && sch->driver->chp_event)
459	sch->driver->chp_event(sch, &link,	459	sch->driver->chp_event(sch, &link,
460	on ? CHP_VARY_ON : CHP_VARY_OFF);	460	on ? CHP_VARY_ON : CHP_VARY_OFF);
461	spin_unlock_irqrestore(sch->lock, flags);	461	spin_unlock_irqrestore(sch->lock, flags);
462	}	462	}
463		463
464	static int s390_subchannel_vary_chpid_off(struct subchannel sch, void data)	464	static int s390_subchannel_vary_chpid_off(struct subchannel sch, void data)
465	{	465	{
466	struct chp_id *chpid = data;	466	struct chp_id *chpid = data;
467		467
468	__s390_subchannel_vary_chpid(sch, *chpid, 0);	468	__s390_subchannel_vary_chpid(sch, *chpid, 0);
469	return 0;	469	return 0;
470	}	470	}
471		471
472	static int s390_subchannel_vary_chpid_on(struct subchannel sch, void data)	472	static int s390_subchannel_vary_chpid_on(struct subchannel sch, void data)
473	{	473	{
474	struct chp_id *chpid = data;	474	struct chp_id *chpid = data;
475		475
476	__s390_subchannel_vary_chpid(sch, *chpid, 1);	476	__s390_subchannel_vary_chpid(sch, *chpid, 1);
477	return 0;	477	return 0;
478	}	478	}
479		479
480	static int	480	static int
481	__s390_vary_chpid_on(struct subchannel_id schid, void *data)	481	__s390_vary_chpid_on(struct subchannel_id schid, void *data)
482	{	482	{
483	struct schib schib;	483	struct schib schib;
484		484
485	if (stsch_err(schid, &schib))	485	if (stsch_err(schid, &schib))
486	/* We're through */	486	/* We're through */
487	return -ENXIO;	487	return -ENXIO;
488	/* Put it on the slow path. */	488	/* Put it on the slow path. */
489	css_schedule_eval(schid);	489	css_schedule_eval(schid);
490	return 0;	490	return 0;
491	}	491	}
492		492
493	/**	493	/**
494	* chsc_chp_vary - propagate channel-path vary operation to subchannels	494	* chsc_chp_vary - propagate channel-path vary operation to subchannels
495	* @chpid: channl-path ID	495	* @chpid: channl-path ID
496	* @on: non-zero for vary online, zero for vary offline	496	* @on: non-zero for vary online, zero for vary offline
497	*/	497	*/
498	int chsc_chp_vary(struct chp_id chpid, int on)	498	int chsc_chp_vary(struct chp_id chpid, int on)
499	{	499	{
500	struct chp_link link;	500	struct chp_link link;
501		501
502	memset(&link, 0, sizeof(struct chp_link));	502	memset(&link, 0, sizeof(struct chp_link));
503	link.chpid = chpid;	503	link.chpid = chpid;
504	/* Wait until previous actions have settled. */	504	/* Wait until previous actions have settled. */
505	css_wait_for_slow_path();	505	css_wait_for_slow_path();
506	/*	506	/*
507	* Redo PathVerification on the devices the chpid connects to	507	* Redo PathVerification on the devices the chpid connects to
508	*/	508	*/
509		509
510	if (on)	510	if (on)
511	for_each_subchannel_staged(s390_subchannel_vary_chpid_on,	511	for_each_subchannel_staged(s390_subchannel_vary_chpid_on,
512	__s390_vary_chpid_on, &link);	512	__s390_vary_chpid_on, &link);
513	else	513	else
514	for_each_subchannel_staged(s390_subchannel_vary_chpid_off,	514	for_each_subchannel_staged(s390_subchannel_vary_chpid_off,
515	NULL, &link);	515	NULL, &link);
516		516
517	return 0;	517	return 0;
518	}	518	}
519		519
520	static void	520	static void
521	chsc_remove_cmg_attr(struct channel_subsystem *css)	521	chsc_remove_cmg_attr(struct channel_subsystem *css)
522	{	522	{
523	int i;	523	int i;
524		524
525	for (i = 0; i <= __MAX_CHPID; i++) {	525	for (i = 0; i <= __MAX_CHPID; i++) {
526	if (!css->chps[i])	526	if (!css->chps[i])
527	continue;	527	continue;
528	chp_remove_cmg_attr(css->chps[i]);	528	chp_remove_cmg_attr(css->chps[i]);
529	}	529	}
530	}	530	}
531		531
532	static int	532	static int
533	chsc_add_cmg_attr(struct channel_subsystem *css)	533	chsc_add_cmg_attr(struct channel_subsystem *css)
534	{	534	{
535	int i, ret;	535	int i, ret;
536		536
537	ret = 0;	537	ret = 0;
538	for (i = 0; i <= __MAX_CHPID; i++) {	538	for (i = 0; i <= __MAX_CHPID; i++) {
539	if (!css->chps[i])	539	if (!css->chps[i])
540	continue;	540	continue;
541	ret = chp_add_cmg_attr(css->chps[i]);	541	ret = chp_add_cmg_attr(css->chps[i]);
542	if (ret)	542	if (ret)
543	goto cleanup;	543	goto cleanup;
544	}	544	}
545	return ret;	545	return ret;
546	cleanup:	546	cleanup:
547	for (--i; i >= 0; i--) {	547	for (--i; i >= 0; i--) {
548	if (!css->chps[i])	548	if (!css->chps[i])
549	continue;	549	continue;
550	chp_remove_cmg_attr(css->chps[i]);	550	chp_remove_cmg_attr(css->chps[i]);
551	}	551	}
552	return ret;	552	return ret;
553	}	553	}
554		554
555	int __chsc_do_secm(struct channel_subsystem css, int enable, void page)	555	int __chsc_do_secm(struct channel_subsystem css, int enable, void page)
556	{	556	{
557	struct {	557	struct {
558	struct chsc_header request;	558	struct chsc_header request;
559	u32 operation_code : 2;	559	u32 operation_code : 2;
560	u32 : 30;	560	u32 : 30;
561	u32 key : 4;	561	u32 key : 4;
562	u32 : 28;	562	u32 : 28;
563	u32 zeroes1;	563	u32 zeroes1;
564	u32 cub_addr1;	564	u32 cub_addr1;
565	u32 zeroes2;	565	u32 zeroes2;
566	u32 cub_addr2;	566	u32 cub_addr2;
567	u32 reserved[13];	567	u32 reserved[13];
568	struct chsc_header response;	568	struct chsc_header response;
569	u32 status : 8;	569	u32 status : 8;
570	u32 : 4;	570	u32 : 4;
571	u32 fmt : 4;	571	u32 fmt : 4;
572	u32 : 16;	572	u32 : 16;
573	} __attribute__ ((packed)) *secm_area;	573	} __attribute__ ((packed)) *secm_area;
574	int ret, ccode;	574	int ret, ccode;
575		575
576	secm_area = page;	576	secm_area = page;
577	secm_area->request.length = 0x0050;	577	secm_area->request.length = 0x0050;
578	secm_area->request.code = 0x0016;	578	secm_area->request.code = 0x0016;
579		579
580	secm_area->key = PAGE_DEFAULT_KEY >> 4;	580	secm_area->key = PAGE_DEFAULT_KEY >> 4;
581	secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;	581	secm_area->cub_addr1 = (u64)(unsigned long)css->cub_addr1;
582	secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;	582	secm_area->cub_addr2 = (u64)(unsigned long)css->cub_addr2;
583		583
584	secm_area->operation_code = enable ? 0 : 1;	584	secm_area->operation_code = enable ? 0 : 1;
585		585
586	ccode = chsc(secm_area);	586	ccode = chsc(secm_area);
587	if (ccode > 0)	587	if (ccode > 0)
588	return (ccode == 3) ? -ENODEV : -EBUSY;	588	return (ccode == 3) ? -ENODEV : -EBUSY;
589		589
590	switch (secm_area->response.code) {	590	switch (secm_area->response.code) {
591	case 0x0102:	591	case 0x0102:
592	case 0x0103:	592	case 0x0103:
593	ret = -EINVAL;	593	ret = -EINVAL;
594	break;	594	break;
595	default:	595	default:
596	ret = chsc_error_from_response(secm_area->response.code);	596	ret = chsc_error_from_response(secm_area->response.code);
597	}	597	}
598	if (ret != 0)	598	if (ret != 0)
599	CIO_CRW_EVENT(2, "chsc: secm failed (rc=%04x)\n",	599	CIO_CRW_EVENT(2, "chsc: secm failed (rc=%04x)\n",
600	secm_area->response.code);	600	secm_area->response.code);
601	return ret;	601	return ret;
602	}	602	}
603		603
604	int	604	int
605	chsc_secm(struct channel_subsystem *css, int enable)	605	chsc_secm(struct channel_subsystem *css, int enable)
606	{	606	{
607	void *secm_area;	607	void *secm_area;
608	int ret;	608	int ret;
609		609
610	secm_area = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);	610	secm_area = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);
611	if (!secm_area)	611	if (!secm_area)
612	return -ENOMEM;	612	return -ENOMEM;
613		613
614	if (enable && !css->cm_enabled) {	614	if (enable && !css->cm_enabled) {
615	css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);	615	css->cub_addr1 = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);
616	css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);	616	css->cub_addr2 = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);
617	if (!css->cub_addr1 \|\| !css->cub_addr2) {	617	if (!css->cub_addr1 \|\| !css->cub_addr2) {
618	free_page((unsigned long)css->cub_addr1);	618	free_page((unsigned long)css->cub_addr1);
619	free_page((unsigned long)css->cub_addr2);	619	free_page((unsigned long)css->cub_addr2);
620	free_page((unsigned long)secm_area);	620	free_page((unsigned long)secm_area);
621	return -ENOMEM;	621	return -ENOMEM;
622	}	622	}
623	}	623	}
624	ret = __chsc_do_secm(css, enable, secm_area);	624	ret = __chsc_do_secm(css, enable, secm_area);
625	if (!ret) {	625	if (!ret) {
626	css->cm_enabled = enable;	626	css->cm_enabled = enable;
627	if (css->cm_enabled) {	627	if (css->cm_enabled) {
628	ret = chsc_add_cmg_attr(css);	628	ret = chsc_add_cmg_attr(css);
629	if (ret) {	629	if (ret) {
630	memset(secm_area, 0, PAGE_SIZE);	630	memset(secm_area, 0, PAGE_SIZE);
631	__chsc_do_secm(css, 0, secm_area);	631	__chsc_do_secm(css, 0, secm_area);
632	css->cm_enabled = 0;	632	css->cm_enabled = 0;
633	}	633	}
634	} else	634	} else
635	chsc_remove_cmg_attr(css);	635	chsc_remove_cmg_attr(css);
636	}	636	}
637	if (!css->cm_enabled) {	637	if (!css->cm_enabled) {
638	free_page((unsigned long)css->cub_addr1);	638	free_page((unsigned long)css->cub_addr1);
639	free_page((unsigned long)css->cub_addr2);	639	free_page((unsigned long)css->cub_addr2);
640	}	640	}
641	free_page((unsigned long)secm_area);	641	free_page((unsigned long)secm_area);
642	return ret;	642	return ret;
643	}	643	}
644		644
645	int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt,	645	int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt,
646	int c, int m,	646	int c, int m,
647	struct chsc_response_struct *resp)	647	struct chsc_response_struct *resp)
648	{	648	{
649	int ccode, ret;	649	int ccode, ret;
650		650
651	struct {	651	struct {
652	struct chsc_header request;	652	struct chsc_header request;
653	u32 : 2;	653	u32 : 2;
654	u32 m : 1;	654	u32 m : 1;
655	u32 c : 1;	655	u32 c : 1;
656	u32 fmt : 4;	656	u32 fmt : 4;
657	u32 cssid : 8;	657	u32 cssid : 8;
658	u32 : 4;	658	u32 : 4;
659	u32 rfmt : 4;	659	u32 rfmt : 4;
660	u32 first_chpid : 8;	660	u32 first_chpid : 8;
661	u32 : 24;	661	u32 : 24;
662	u32 last_chpid : 8;	662	u32 last_chpid : 8;
663	u32 zeroes1;	663	u32 zeroes1;
664	struct chsc_header response;	664	struct chsc_header response;
665	u8 data[PAGE_SIZE - 20];	665	u8 data[PAGE_SIZE - 20];
666	} __attribute__ ((packed)) *scpd_area;	666	} __attribute__ ((packed)) *scpd_area;
667		667
668	if ((rfmt == 1) && !css_general_characteristics.fcs)	668	if ((rfmt == 1) && !css_general_characteristics.fcs)
669	return -EINVAL;	669	return -EINVAL;
670	if ((rfmt == 2) && !css_general_characteristics.cib)	670	if ((rfmt == 2) && !css_general_characteristics.cib)
671	return -EINVAL;	671	return -EINVAL;
672	scpd_area = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);	672	scpd_area = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);
673	if (!scpd_area)	673	if (!scpd_area)
674	return -ENOMEM;	674	return -ENOMEM;
675		675
676	scpd_area->request.length = 0x0010;	676	scpd_area->request.length = 0x0010;
677	scpd_area->request.code = 0x0002;	677	scpd_area->request.code = 0x0002;
678		678
679	scpd_area->cssid = chpid.cssid;	679	scpd_area->cssid = chpid.cssid;
680	scpd_area->first_chpid = chpid.id;	680	scpd_area->first_chpid = chpid.id;
681	scpd_area->last_chpid = chpid.id;	681	scpd_area->last_chpid = chpid.id;
682	scpd_area->m = m;	682	scpd_area->m = m;
683	scpd_area->c = c;	683	scpd_area->c = c;
684	scpd_area->fmt = fmt;	684	scpd_area->fmt = fmt;
685	scpd_area->rfmt = rfmt;	685	scpd_area->rfmt = rfmt;
686		686
687	ccode = chsc(scpd_area);	687	ccode = chsc(scpd_area);
688	if (ccode > 0) {	688	if (ccode > 0) {
689	ret = (ccode == 3) ? -ENODEV : -EBUSY;	689	ret = (ccode == 3) ? -ENODEV : -EBUSY;
690	goto out;	690	goto out;
691	}	691	}
692		692
693	ret = chsc_error_from_response(scpd_area->response.code);	693	ret = chsc_error_from_response(scpd_area->response.code);
694	if (ret == 0)	694	if (ret == 0)
695	/* Success. */	695	/* Success. */
696	memcpy(resp, &scpd_area->response, scpd_area->response.length);	696	memcpy(resp, &scpd_area->response, scpd_area->response.length);
697	else	697	else
698	CIO_CRW_EVENT(2, "chsc: scpd failed (rc=%04x)\n",	698	CIO_CRW_EVENT(2, "chsc: scpd failed (rc=%04x)\n",
699	scpd_area->response.code);	699	scpd_area->response.code);
700	out:	700	out:
701	free_page((unsigned long)scpd_area);	701	free_page((unsigned long)scpd_area);
702	return ret;	702	return ret;
703	}	703	}
704	EXPORT_SYMBOL_GPL(chsc_determine_channel_path_desc);	704	EXPORT_SYMBOL_GPL(chsc_determine_channel_path_desc);
705		705
706	int chsc_determine_base_channel_path_desc(struct chp_id chpid,	706	int chsc_determine_base_channel_path_desc(struct chp_id chpid,
707	struct channel_path_desc *desc)	707	struct channel_path_desc *desc)
708	{	708	{
709	struct chsc_response_struct *chsc_resp;	709	struct chsc_response_struct *chsc_resp;
710	int ret;	710	int ret;
711		711
712	chsc_resp = kzalloc(sizeof(*chsc_resp), GFP_KERNEL);	712	chsc_resp = kzalloc(sizeof(*chsc_resp), GFP_KERNEL);
713	if (!chsc_resp)	713	if (!chsc_resp)
714	return -ENOMEM;	714	return -ENOMEM;
715	ret = chsc_determine_channel_path_desc(chpid, 0, 0, 0, 0, chsc_resp);	715	ret = chsc_determine_channel_path_desc(chpid, 0, 0, 0, 0, chsc_resp);
716	if (ret)	716	if (ret)
717	goto out_free;	717	goto out_free;
718	memcpy(desc, &chsc_resp->data, sizeof(*desc));	718	memcpy(desc, &chsc_resp->data, sizeof(*desc));
719	out_free:	719	out_free:
720	kfree(chsc_resp);	720	kfree(chsc_resp);
721	return ret;	721	return ret;
722	}	722	}
723		723
724	static void	724	static void
725	chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,	725	chsc_initialize_cmg_chars(struct channel_path *chp, u8 cmcv,
726	struct cmg_chars *chars)	726	struct cmg_chars *chars)
727	{	727	{
728	switch (chp->cmg) {	728	switch (chp->cmg) {
729	case 2:	729	case 2:
730	case 3:	730	case 3:
731	chp->cmg_chars = kmalloc(sizeof(struct cmg_chars),	731	chp->cmg_chars = kmalloc(sizeof(struct cmg_chars),
732	GFP_KERNEL);	732	GFP_KERNEL);
733	if (chp->cmg_chars) {	733	if (chp->cmg_chars) {
734	int i, mask;	734	int i, mask;
735	struct cmg_chars *cmg_chars;	735	struct cmg_chars *cmg_chars;
736		736
737	cmg_chars = chp->cmg_chars;	737	cmg_chars = chp->cmg_chars;
738	for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {	738	for (i = 0; i < NR_MEASUREMENT_CHARS; i++) {
739	mask = 0x80 >> (i + 3);	739	mask = 0x80 >> (i + 3);
740	if (cmcv & mask)	740	if (cmcv & mask)
741	cmg_chars->values[i] = chars->values[i];	741	cmg_chars->values[i] = chars->values[i];
742	else	742	else
743	cmg_chars->values[i] = 0;	743	cmg_chars->values[i] = 0;
744	}	744	}
745	}	745	}
746	break;	746	break;
747	default:	747	default:
748	/* No cmg-dependent data. */	748	/* No cmg-dependent data. */
749	break;	749	break;
750	}	750	}
751	}	751	}
752		752
753	int chsc_get_channel_measurement_chars(struct channel_path *chp)	753	int chsc_get_channel_measurement_chars(struct channel_path *chp)
754	{	754	{
755	int ccode, ret;	755	int ccode, ret;
756		756
757	struct {	757	struct {
758	struct chsc_header request;	758	struct chsc_header request;
759	u32 : 24;	759	u32 : 24;
760	u32 first_chpid : 8;	760	u32 first_chpid : 8;
761	u32 : 24;	761	u32 : 24;
762	u32 last_chpid : 8;	762	u32 last_chpid : 8;
763	u32 zeroes1;	763	u32 zeroes1;
764	struct chsc_header response;	764	struct chsc_header response;
765	u32 zeroes2;	765	u32 zeroes2;
766	u32 not_valid : 1;	766	u32 not_valid : 1;
767	u32 shared : 1;	767	u32 shared : 1;
768	u32 : 22;	768	u32 : 22;
769	u32 chpid : 8;	769	u32 chpid : 8;
770	u32 cmcv : 5;	770	u32 cmcv : 5;
771	u32 : 11;	771	u32 : 11;
772	u32 cmgq : 8;	772	u32 cmgq : 8;
773	u32 cmg : 8;	773	u32 cmg : 8;
774	u32 zeroes3;	774	u32 zeroes3;
775	u32 data[NR_MEASUREMENT_CHARS];	775	u32 data[NR_MEASUREMENT_CHARS];
776	} __attribute__ ((packed)) *scmc_area;	776	} __attribute__ ((packed)) *scmc_area;
777		777
778	scmc_area = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);	778	scmc_area = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);
779	if (!scmc_area)	779	if (!scmc_area)
780	return -ENOMEM;	780	return -ENOMEM;
781		781
782	scmc_area->request.length = 0x0010;	782	scmc_area->request.length = 0x0010;
783	scmc_area->request.code = 0x0022;	783	scmc_area->request.code = 0x0022;
784		784
785	scmc_area->first_chpid = chp->chpid.id;	785	scmc_area->first_chpid = chp->chpid.id;
786	scmc_area->last_chpid = chp->chpid.id;	786	scmc_area->last_chpid = chp->chpid.id;
787		787
788	ccode = chsc(scmc_area);	788	ccode = chsc(scmc_area);
789	if (ccode > 0) {	789	if (ccode > 0) {
790	ret = (ccode == 3) ? -ENODEV : -EBUSY;	790	ret = (ccode == 3) ? -ENODEV : -EBUSY;
791	goto out;	791	goto out;
792	}	792	}
793		793
794	ret = chsc_error_from_response(scmc_area->response.code);	794	ret = chsc_error_from_response(scmc_area->response.code);
795	if (ret == 0) {	795	if (ret == 0) {
796	/* Success. */	796	/* Success. */
797	if (!scmc_area->not_valid) {	797	if (!scmc_area->not_valid) {
798	chp->cmg = scmc_area->cmg;	798	chp->cmg = scmc_area->cmg;
799	chp->shared = scmc_area->shared;	799	chp->shared = scmc_area->shared;
800	chsc_initialize_cmg_chars(chp, scmc_area->cmcv,	800	chsc_initialize_cmg_chars(chp, scmc_area->cmcv,
801	(struct cmg_chars *)	801	(struct cmg_chars *)
802	&scmc_area->data);	802	&scmc_area->data);
803	} else {	803	} else {
804	chp->cmg = -1;	804	chp->cmg = -1;
805	chp->shared = -1;	805	chp->shared = -1;
806	}	806	}
807	} else {	807	} else {
808	CIO_CRW_EVENT(2, "chsc: scmc failed (rc=%04x)\n",	808	CIO_CRW_EVENT(2, "chsc: scmc failed (rc=%04x)\n",
809	scmc_area->response.code);	809	scmc_area->response.code);
810	}	810	}
811	out:	811	out:
812	free_page((unsigned long)scmc_area);	812	free_page((unsigned long)scmc_area);
813	return ret;	813	return ret;
814	}	814	}
815		815
816	int __init chsc_alloc_sei_area(void)	816	int __init chsc_init(void)
817	{	817	{
818	int ret;	818	int ret;
819		819
820	sei_page = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);	820	sei_page = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);
821	if (!sei_page) {	821	if (!sei_page) {
822	CIO_MSG_EVENT(0, "Can't allocate page for processing of "	822	CIO_MSG_EVENT(0, "Can't allocate page for processing of "
823	"chsc machine checks!\n");	823	"chsc machine checks!\n");
824	return -ENOMEM;	824	return -ENOMEM;
825	}	825	}
826	ret = crw_register_handler(CRW_RSC_CSS, chsc_process_crw);	826	ret = crw_register_handler(CRW_RSC_CSS, chsc_process_crw);
827	if (ret)	827	if (ret)
828	kfree(sei_page);	828	free_page((unsigned long)sei_page);
829	return ret;	829	return ret;
830	}	830	}
831		831
832	void __init chsc_free_sei_area(void)	832	void __init chsc_init_cleanup(void)
833	{	833	{
834	crw_unregister_handler(CRW_RSC_CSS);	834	crw_unregister_handler(CRW_RSC_CSS);
835	kfree(sei_page);	835	free_page((unsigned long)sei_page);
836	}	836	}
837		837
838	int chsc_enable_facility(int operation_code)	838	int chsc_enable_facility(int operation_code)
839	{	839	{
840	int ret;	840	int ret;
841	static struct {	841	static struct {
842	struct chsc_header request;	842	struct chsc_header request;
843	u8 reserved1:4;	843	u8 reserved1:4;
844	u8 format:4;	844	u8 format:4;
845	u8 reserved2;	845	u8 reserved2;
846	u16 operation_code;	846	u16 operation_code;
847	u32 reserved3;	847	u32 reserved3;
848	u32 reserved4;	848	u32 reserved4;
849	u32 operation_data_area[252];	849	u32 operation_data_area[252];
850	struct chsc_header response;	850	struct chsc_header response;
851	u32 reserved5:4;	851	u32 reserved5:4;
852	u32 format2:4;	852	u32 format2:4;
853	u32 reserved6:24;	853	u32 reserved6:24;
854	} __attribute__ ((packed, aligned(4096))) sda_area;	854	} __attribute__ ((packed, aligned(4096))) sda_area;
855		855
856	spin_lock(&sda_lock);	856	spin_lock(&sda_lock);
857	memset(&sda_area, 0, sizeof(sda_area));	857	memset(&sda_area, 0, sizeof(sda_area));
858	sda_area.request.length = 0x0400;	858	sda_area.request.length = 0x0400;
859	sda_area.request.code = 0x0031;	859	sda_area.request.code = 0x0031;
860	sda_area.operation_code = operation_code;	860	sda_area.operation_code = operation_code;
861		861
862	ret = chsc(&sda_area);	862	ret = chsc(&sda_area);
863	if (ret > 0) {	863	if (ret > 0) {
864	ret = (ret == 3) ? -ENODEV : -EBUSY;	864	ret = (ret == 3) ? -ENODEV : -EBUSY;
865	goto out;	865	goto out;
866	}	866	}
867		867
868	switch (sda_area.response.code) {	868	switch (sda_area.response.code) {
869	case 0x0101:	869	case 0x0101:
870	ret = -EOPNOTSUPP;	870	ret = -EOPNOTSUPP;
871	break;	871	break;
872	default:	872	default:
873	ret = chsc_error_from_response(sda_area.response.code);	873	ret = chsc_error_from_response(sda_area.response.code);
874	}	874	}
875	if (ret != 0)	875	if (ret != 0)
876	CIO_CRW_EVENT(2, "chsc: sda (oc=%x) failed (rc=%04x)\n",	876	CIO_CRW_EVENT(2, "chsc: sda (oc=%x) failed (rc=%04x)\n",
877	operation_code, sda_area.response.code);	877	operation_code, sda_area.response.code);
878	out:	878	out:
879	spin_unlock(&sda_lock);	879	spin_unlock(&sda_lock);
880	return ret;	880	return ret;
881	}	881	}
882		882
883	struct css_general_char css_general_characteristics;	883	struct css_general_char css_general_characteristics;
884	struct css_chsc_char css_chsc_characteristics;	884	struct css_chsc_char css_chsc_characteristics;
885		885
886	int __init	886	int __init
887	chsc_determine_css_characteristics(void)	887	chsc_determine_css_characteristics(void)
888	{	888	{
889	int result;	889	int result;
890	struct {	890	struct {
891	struct chsc_header request;	891	struct chsc_header request;
892	u32 reserved1;	892	u32 reserved1;
893	u32 reserved2;	893	u32 reserved2;
894	u32 reserved3;	894	u32 reserved3;
895	struct chsc_header response;	895	struct chsc_header response;
896	u32 reserved4;	896	u32 reserved4;
897	u32 general_char[510];	897	u32 general_char[510];
898	u32 chsc_char[518];	898	u32 chsc_char[508];
899	} __attribute__ ((packed)) *scsc_area;	899	} __attribute__ ((packed)) *scsc_area;
900		900
901	scsc_area = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);	901	scsc_area = (void *)get_zeroed_page(GFP_KERNEL \| GFP_DMA);
902	if (!scsc_area)	902	if (!scsc_area)
903	return -ENOMEM;	903	return -ENOMEM;
904		904
905	scsc_area->request.length = 0x0010;	905	scsc_area->request.length = 0x0010;
906	scsc_area->request.code = 0x0010;	906	scsc_area->request.code = 0x0010;
907		907
908	result = chsc(scsc_area);	908	result = chsc(scsc_area);
909	if (result) {	909	if (result) {
910	result = (result == 3) ? -ENODEV : -EBUSY;	910	result = (result == 3) ? -ENODEV : -EBUSY;
911	goto exit;	911	goto exit;
912	}	912	}
913		913
914	result = chsc_error_from_response(scsc_area->response.code);	914	result = chsc_error_from_response(scsc_area->response.code);
915	if (result == 0) {	915	if (result == 0) {
916	memcpy(&css_general_characteristics, scsc_area->general_char,	916	memcpy(&css_general_characteristics, scsc_area->general_char,
917	sizeof(css_general_characteristics));	917	sizeof(css_general_characteristics));
918	memcpy(&css_chsc_characteristics, scsc_area->chsc_char,	918	memcpy(&css_chsc_characteristics, scsc_area->chsc_char,
919	sizeof(css_chsc_characteristics));	919	sizeof(css_chsc_characteristics));
920	} else	920	} else
921	CIO_CRW_EVENT(2, "chsc: scsc failed (rc=%04x)\n",	921	CIO_CRW_EVENT(2, "chsc: scsc failed (rc=%04x)\n",
922	scsc_area->response.code);	922	scsc_area->response.code);
923	exit:	923	exit:
924	free_page ((unsigned long) scsc_area);	924	free_page ((unsigned long) scsc_area);
925	return result;	925	return result;
926	}	926	}
927		927
928	EXPORT_SYMBOL_GPL(css_general_characteristics);	928	EXPORT_SYMBOL_GPL(css_general_characteristics);
929	EXPORT_SYMBOL_GPL(css_chsc_characteristics);	929	EXPORT_SYMBOL_GPL(css_chsc_characteristics);
930		930
931	int chsc_sstpc(void *page, unsigned int op, u16 ctrl)	931	int chsc_sstpc(void *page, unsigned int op, u16 ctrl)
932	{	932	{
933	struct {	933	struct {
934	struct chsc_header request;	934	struct chsc_header request;
935	unsigned int rsvd0;	935	unsigned int rsvd0;
936	unsigned int op : 8;	936	unsigned int op : 8;
937	unsigned int rsvd1 : 8;	937	unsigned int rsvd1 : 8;
938	unsigned int ctrl : 16;	938	unsigned int ctrl : 16;
939	unsigned int rsvd2[5];	939	unsigned int rsvd2[5];
940	struct chsc_header response;	940	struct chsc_header response;
941	unsigned int rsvd3[7];	941	unsigned int rsvd3[7];
942	} __attribute__ ((packed)) *rr;	942	} __attribute__ ((packed)) *rr;
943	int rc;	943	int rc;
944		944
945	memset(page, 0, PAGE_SIZE);	945	memset(page, 0, PAGE_SIZE);
946	rr = page;	946	rr = page;
947	rr->request.length = 0x0020;	947	rr->request.length = 0x0020;
948	rr->request.code = 0x0033;	948	rr->request.code = 0x0033;
949	rr->op = op;	949	rr->op = op;
950	rr->ctrl = ctrl;	950	rr->ctrl = ctrl;
951	rc = chsc(rr);	951	rc = chsc(rr);
952	if (rc)	952	if (rc)
953	return -EIO;	953	return -EIO;
954	rc = (rr->response.code == 0x0001) ? 0 : -EIO;	954	rc = (rr->response.code == 0x0001) ? 0 : -EIO;
955	return rc;	955	return rc;
956	}	956	}
957		957
958	int chsc_sstpi(void page, void result, size_t size)	958	int chsc_sstpi(void page, void result, size_t size)
959	{	959	{
960	struct {	960	struct {
961	struct chsc_header request;	961	struct chsc_header request;
962	unsigned int rsvd0[3];	962	unsigned int rsvd0[3];
963	struct chsc_header response;	963	struct chsc_header response;
964	char data[size];	964	char data[size];
965	} __attribute__ ((packed)) *rr;	965	} __attribute__ ((packed)) *rr;
966	int rc;	966	int rc;
967		967
968	memset(page, 0, PAGE_SIZE);	968	memset(page, 0, PAGE_SIZE);
969	rr = page;	969	rr = page;
970	rr->request.length = 0x0010;	970	rr->request.length = 0x0010;
971	rr->request.code = 0x0038;	971	rr->request.code = 0x0038;
972	rc = chsc(rr);	972	rc = chsc(rr);
973	if (rc)	973	if (rc)
974	return -EIO;	974	return -EIO;
975	memcpy(result, &rr->data, size);	975	memcpy(result, &rr->data, size);
976	return (rr->response.code == 0x0001) ? 0 : -EIO;	976	return (rr->response.code == 0x0001) ? 0 : -EIO;
977	}	977	}
978		978
979	static struct {	979	static struct {
980	struct chsc_header request;	980	struct chsc_header request;
981	u32 word1;	981	u32 word1;
982	struct subchannel_id sid;	982	struct subchannel_id sid;
983	u32 word3;	983	u32 word3;
984	struct chsc_header response;	984	struct chsc_header response;
985	u32 word[11];	985	u32 word[11];
986	} __attribute__ ((packed)) siosl_area __attribute__ ((__aligned__(PAGE_SIZE)));	986	} __attribute__ ((packed)) siosl_area __attribute__ ((__aligned__(PAGE_SIZE)));
987		987
988	int chsc_siosl(struct subchannel_id schid)	988	int chsc_siosl(struct subchannel_id schid)
989	{	989	{
990	unsigned long flags;	990	unsigned long flags;
991	int ccode;	991	int ccode;
992	int rc;	992	int rc;
993		993
994	spin_lock_irqsave(&siosl_lock, flags);	994	spin_lock_irqsave(&siosl_lock, flags);
995	memset(&siosl_area, 0, sizeof(siosl_area));	995	memset(&siosl_area, 0, sizeof(siosl_area));
996	siosl_area.request.length = 0x0010;	996	siosl_area.request.length = 0x0010;
997	siosl_area.request.code = 0x0046;	997	siosl_area.request.code = 0x0046;
998	siosl_area.word1 = 0x80000000;	998	siosl_area.word1 = 0x80000000;
999	siosl_area.sid = schid;	999	siosl_area.sid = schid;
1000		1000
1001	ccode = chsc(&siosl_area);	1001	ccode = chsc(&siosl_area);
1002	if (ccode > 0) {	1002	if (ccode > 0) {
1003	if (ccode == 3)	1003	if (ccode == 3)
1004	rc = -ENODEV;	1004	rc = -ENODEV;
1005	else	1005	else
1006	rc = -EBUSY;	1006	rc = -EBUSY;
1007	CIO_MSG_EVENT(2, "chsc: chsc failed for 0.%x.%04x (ccode=%d)\n",	1007	CIO_MSG_EVENT(2, "chsc: chsc failed for 0.%x.%04x (ccode=%d)\n",
1008	schid.ssid, schid.sch_no, ccode);	1008	schid.ssid, schid.sch_no, ccode);
1009	goto out;	1009	goto out;
1010	}	1010	}
1011	rc = chsc_error_from_response(siosl_area.response.code);	1011	rc = chsc_error_from_response(siosl_area.response.code);
1012	if (rc)	1012	if (rc)
1013	CIO_MSG_EVENT(2, "chsc: siosl failed for 0.%x.%04x (rc=%04x)\n",	1013	CIO_MSG_EVENT(2, "chsc: siosl failed for 0.%x.%04x (rc=%04x)\n",
1014	schid.ssid, schid.sch_no,	1014	schid.ssid, schid.sch_no,
1015	siosl_area.response.code);	1015	siosl_area.response.code);
1016	else	1016	else
1017	CIO_MSG_EVENT(4, "chsc: siosl succeeded for 0.%x.%04x\n",	1017	CIO_MSG_EVENT(4, "chsc: siosl succeeded for 0.%x.%04x\n",
1018	schid.ssid, schid.sch_no);	1018	schid.ssid, schid.sch_no);
1019	out:	1019	out:
1020	spin_unlock_irqrestore(&siosl_lock, flags);	1020	spin_unlock_irqrestore(&siosl_lock, flags);
1021		1021
1022	return rc;	1022	return rc;
1023	}	1023	}
1024	EXPORT_SYMBOL_GPL(chsc_siosl);	1024	EXPORT_SYMBOL_GPL(chsc_siosl);
1025		1025

drivers/s390/cio/chsc.h

Diff comments View file @ 34aec07

1	#ifndef S390_CHSC_H	1	#ifndef S390_CHSC_H
2	#define S390_CHSC_H	2	#define S390_CHSC_H
3		3
4	#include <linux/types.h>	4	#include <linux/types.h>
5	#include <linux/device.h>	5	#include <linux/device.h>
6	#include <asm/chpid.h>	6	#include <asm/chpid.h>
7	#include <asm/chsc.h>	7	#include <asm/chsc.h>
8	#include <asm/schid.h>	8	#include <asm/schid.h>
9		9
10	#define CHSC_SDA_OC_MSS 0x2	10	#define CHSC_SDA_OC_MSS 0x2
11		11
12	struct chsc_header {	12	struct chsc_header {
13	u16 length;	13	u16 length;
14	u16 code;	14	u16 code;
15	} __attribute__ ((packed));	15	} __attribute__ ((packed));
16		16
17	#define NR_MEASUREMENT_CHARS 5	17	#define NR_MEASUREMENT_CHARS 5
18	struct cmg_chars {	18	struct cmg_chars {
19	u32 values[NR_MEASUREMENT_CHARS];	19	u32 values[NR_MEASUREMENT_CHARS];
20	} __attribute__ ((packed));	20	} __attribute__ ((packed));
21		21
22	#define NR_MEASUREMENT_ENTRIES 8	22	#define NR_MEASUREMENT_ENTRIES 8
23	struct cmg_entry {	23	struct cmg_entry {
24	u32 values[NR_MEASUREMENT_ENTRIES];	24	u32 values[NR_MEASUREMENT_ENTRIES];
25	} __attribute__ ((packed));	25	} __attribute__ ((packed));
26		26
27	struct channel_path_desc {	27	struct channel_path_desc {
28	u8 flags;	28	u8 flags;
29	u8 lsn;	29	u8 lsn;
30	u8 desc;	30	u8 desc;
31	u8 chpid;	31	u8 chpid;
32	u8 swla;	32	u8 swla;
33	u8 zeroes;	33	u8 zeroes;
34	u8 chla;	34	u8 chla;
35	u8 chpp;	35	u8 chpp;
36	} __attribute__ ((packed));	36	} __attribute__ ((packed));
37		37
38	struct channel_path;	38	struct channel_path;
39		39
40	struct css_chsc_char {	40	struct css_chsc_char {
41	u64 res;	41	u64 res;
42	u64 : 20;	42	u64 : 20;
43	u32 secm : 1; /* bit 84 */	43	u32 secm : 1; /* bit 84 */
44	u32 : 1;	44	u32 : 1;
45	u32 scmc : 1; /* bit 86 */	45	u32 scmc : 1; /* bit 86 */
46	u32 : 20;	46	u32 : 20;
47	u32 scssc : 1; /* bit 107 */	47	u32 scssc : 1; /* bit 107 */
48	u32 scsscf : 1; /* bit 108 */	48	u32 scsscf : 1; /* bit 108 */
49	u32 : 19;	49	u32 : 19;
50	}__attribute__((packed));	50	}__attribute__((packed));
51		51
52	extern struct css_chsc_char css_chsc_characteristics;	52	extern struct css_chsc_char css_chsc_characteristics;
53		53
54	struct chsc_ssd_info {	54	struct chsc_ssd_info {
55	u8 path_mask;	55	u8 path_mask;
56	u8 fla_valid_mask;	56	u8 fla_valid_mask;
57	struct chp_id chpid[8];	57	struct chp_id chpid[8];
58	u16 fla[8];	58	u16 fla[8];
59	};	59	};
60	extern int chsc_get_ssd_info(struct subchannel_id schid,	60	extern int chsc_get_ssd_info(struct subchannel_id schid,
61	struct chsc_ssd_info *ssd);	61	struct chsc_ssd_info *ssd);
62	extern int chsc_determine_css_characteristics(void);	62	extern int chsc_determine_css_characteristics(void);
63	extern int chsc_alloc_sei_area(void);	63	extern int chsc_init(void);
64	extern void chsc_free_sei_area(void);	64	extern void chsc_init_cleanup(void);
65		65
66	extern int chsc_enable_facility(int);	66	extern int chsc_enable_facility(int);
67	struct channel_subsystem;	67	struct channel_subsystem;
68	extern int chsc_secm(struct channel_subsystem *, int);	68	extern int chsc_secm(struct channel_subsystem *, int);
69	int __chsc_do_secm(struct channel_subsystem css, int enable, void page);	69	int __chsc_do_secm(struct channel_subsystem css, int enable, void page);
70		70
71	int chsc_chp_vary(struct chp_id chpid, int on);	71	int chsc_chp_vary(struct chp_id chpid, int on);
72	int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt,	72	int chsc_determine_channel_path_desc(struct chp_id chpid, int fmt, int rfmt,
73	int c, int m,	73	int c, int m,
74	struct chsc_response_struct *resp);	74	struct chsc_response_struct *resp);
75	int chsc_determine_base_channel_path_desc(struct chp_id chpid,	75	int chsc_determine_base_channel_path_desc(struct chp_id chpid,
76	struct channel_path_desc *desc);	76	struct channel_path_desc *desc);
77	void chsc_chp_online(struct chp_id chpid);	77	void chsc_chp_online(struct chp_id chpid);
78	void chsc_chp_offline(struct chp_id chpid);	78	void chsc_chp_offline(struct chp_id chpid);
79	int chsc_get_channel_measurement_chars(struct channel_path *chp);	79	int chsc_get_channel_measurement_chars(struct channel_path *chp);
80		80
81	int chsc_error_from_response(int response);	81	int chsc_error_from_response(int response);
82		82
83	int chsc_siosl(struct subchannel_id schid);	83	int chsc_siosl(struct subchannel_id schid);
84		84
85	#endif	85	#endif
86		86

drivers/s390/cio/css.c

Diff comments View file @ 34aec07

 /*
  * driver for channel subsystem
  *
- * Copyright IBM Corp. 2002, 2009
+ * Copyright IBM Corp. 2002, 2010
  *
  * Author(s): Arnd Bergmann (arndb@de.ibm.com)
  *	      Cornelia Huck (cornelia.huck@de.ibm.com)
  */
 #define KMSG_COMPONENT "cio"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/list.h>
 #include <linux/reboot.h>
 #include <linux/suspend.h>
 #include <linux/proc_fs.h>
 #include <asm/isc.h>
 #include <asm/crw.h>
 #include "css.h"
 #include "cio.h"
 #include "cio_debug.h"
 #include "ioasm.h"
 #include "chsc.h"
 #include "device.h"
 #include "idset.h"
 #include "chp.h"
 int css_init_done = 0;
 int max_ssid;
 struct channel_subsystem *channel_subsystems[__MAX_CSSID + 1];
 int
 for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data)
 {
 	struct subchannel_id schid;
 	int ret;
 	init_subchannel_id(&schid);
 	ret = -ENODEV;
 	do {
 		do {
 			ret = fn(schid, data);
 			if (ret)
 				break;
 		} while (schid.sch_no++ < __MAX_SUBCHANNEL);
 		schid.sch_no = 0;
 	} while (schid.ssid++ < max_ssid);
 	return ret;
 }
 struct cb_data {
 	void *data;
 	struct idset *set;
 	int (*fn_known_sch)(struct subchannel *, void *);
 	int (*fn_unknown_sch)(struct subchannel_id, void *);
 };
 static int call_fn_known_sch(struct device *dev, void *data)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	struct cb_data *cb = data;
 	int rc = 0;
 	idset_sch_del(cb->set, sch->schid);
 	if (cb->fn_known_sch)
 		rc = cb->fn_known_sch(sch, cb->data);
 	return rc;
 }
 static int call_fn_unknown_sch(struct subchannel_id schid, void *data)
 {
 	struct cb_data *cb = data;
 	int rc = 0;
 	if (idset_sch_contains(cb->set, schid))
 		rc = cb->fn_unknown_sch(schid, cb->data);
 	return rc;
 }
 static int call_fn_all_sch(struct subchannel_id schid, void *data)
 {
 	struct cb_data *cb = data;
 	struct subchannel *sch;
 	int rc = 0;
 	sch = get_subchannel_by_schid(schid);
 	if (sch) {
 		if (cb->fn_known_sch)
 			rc = cb->fn_known_sch(sch, cb->data);
 		put_device(&sch->dev);
 	} else {
 		if (cb->fn_unknown_sch)
 			rc = cb->fn_unknown_sch(schid, cb->data);
 	}
 	return rc;
 }
 int for_each_subchannel_staged(int (*fn_known)(struct subchannel *, void *),
 			       int (*fn_unknown)(struct subchannel_id,
 			       void *), void *data)
 {
 	struct cb_data cb;
 	int rc;
 	cb.data = data;
 	cb.fn_known_sch = fn_known;
 	cb.fn_unknown_sch = fn_unknown;
 	cb.set = idset_sch_new();
 	if (!cb.set)
 		/* fall back to brute force scanning in case of oom */
 		return for_each_subchannel(call_fn_all_sch, &cb);
 	idset_fill(cb.set);
 	/* Process registered subchannels. */
 	rc = bus_for_each_dev(&css_bus_type, NULL, &cb, call_fn_known_sch);
 	if (rc)
 		goto out;
 	/* Process unregistered subchannels. */
 	if (fn_unknown)
 		rc = for_each_subchannel(call_fn_unknown_sch, &cb);
 out:
 	idset_free(cb.set);
 	return rc;
 }
 static void css_sch_todo(struct work_struct *work);
 static struct subchannel *
 css_alloc_subchannel(struct subchannel_id schid)
 {
 	struct subchannel *sch;
 	int ret;
 	sch = kmalloc (sizeof (*sch), GFP_KERNEL | GFP_DMA);
 	if (sch == NULL)
 		return ERR_PTR(-ENOMEM);
 	ret = cio_validate_subchannel (sch, schid);
 	if (ret < 0) {
 		kfree(sch);
 		return ERR_PTR(ret);
 	}
 	INIT_WORK(&sch->todo_work, css_sch_todo);
 	return sch;
 }
 static void
 css_subchannel_release(struct device *dev)
 {
 	struct subchannel *sch;
 	sch = to_subchannel(dev);
 	if (!cio_is_console(sch->schid)) {
 		/* Reset intparm to zeroes. */
 		sch->config.intparm = 0;
 		cio_commit_config(sch);
 		kfree(sch->lock);
 		kfree(sch);
 	}
 }
 static int css_sch_device_register(struct subchannel *sch)
 {
 	int ret;
 	mutex_lock(&sch->reg_mutex);
 	dev_set_name(&sch->dev, "0.%x.%04x", sch->schid.ssid,
 		     sch->schid.sch_no);
 	ret = device_register(&sch->dev);
 	mutex_unlock(&sch->reg_mutex);
 	return ret;
 }
 /**
  * css_sch_device_unregister - unregister a subchannel
  * @sch: subchannel to be unregistered
  */
 void css_sch_device_unregister(struct subchannel *sch)
 {
 	mutex_lock(&sch->reg_mutex);
 	if (device_is_registered(&sch->dev))
 		device_unregister(&sch->dev);
 	mutex_unlock(&sch->reg_mutex);
 }
 EXPORT_SYMBOL_GPL(css_sch_device_unregister);
 static void css_sch_todo(struct work_struct *work)
 {
 	struct subchannel *sch;
 	enum sch_todo todo;
 	sch = container_of(work, struct subchannel, todo_work);
 	/* Find out todo. */
 	spin_lock_irq(sch->lock);
 	todo = sch->todo;
 	CIO_MSG_EVENT(4, "sch_todo: sch=0.%x.%04x, todo=%d\n", sch->schid.ssid,
 		      sch->schid.sch_no, todo);
 	sch->todo = SCH_TODO_NOTHING;
 	spin_unlock_irq(sch->lock);
 	/* Perform todo. */
 	if (todo == SCH_TODO_UNREG)
 		css_sch_device_unregister(sch);
 	/* Release workqueue ref. */
 	put_device(&sch->dev);
 }
 /**
  * css_sched_sch_todo - schedule a subchannel operation
  * @sch: subchannel
  * @todo: todo
  *
  * Schedule the operation identified by @todo to be performed on the slow path
  * workqueue. Do nothing if another operation with higher priority is already
  * scheduled. Needs to be called with subchannel lock held.
  */
 void css_sched_sch_todo(struct subchannel *sch, enum sch_todo todo)
 {
 	CIO_MSG_EVENT(4, "sch_todo: sched sch=0.%x.%04x todo=%d\n",
 		      sch->schid.ssid, sch->schid.sch_no, todo);
 	if (sch->todo >= todo)
 		return;
 	/* Get workqueue ref. */
 	if (!get_device(&sch->dev))
 		return;
 	sch->todo = todo;
 	if (!queue_work(cio_work_q, &sch->todo_work)) {
 		/* Already queued, release workqueue ref. */
 		put_device(&sch->dev);
 	}
 }
 static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw)
 {
 	int i;
 	int mask;
 	memset(ssd, 0, sizeof(struct chsc_ssd_info));
 	ssd->path_mask = pmcw->pim;
 	for (i = 0; i < 8; i++) {
 		mask = 0x80 >> i;
 		if (pmcw->pim & mask) {
 			chp_id_init(&ssd->chpid[i]);
 			ssd->chpid[i].id = pmcw->chpid[i];
 		}
 	}
 }
 static void ssd_register_chpids(struct chsc_ssd_info *ssd)
 {
 	int i;
 	int mask;
 	for (i = 0; i < 8; i++) {
 		mask = 0x80 >> i;
 		if (ssd->path_mask & mask)
 			if (!chp_is_registered(ssd->chpid[i]))
 				chp_new(ssd->chpid[i]);
 	}
 }
 void css_update_ssd_info(struct subchannel *sch)
 {
 	int ret;
 	if (cio_is_console(sch->schid)) {
 		/* Console is initialized too early for functions requiring
 		 * memory allocation. */
 		ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
 	} else {
 		ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info);
 		if (ret)
 			ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw);
 		ssd_register_chpids(&sch->ssd_info);
 	}
 }
 static ssize_t type_show(struct device *dev, struct device_attribute *attr,
 			 char *buf)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	return sprintf(buf, "%01x\n", sch->st);
 }
 static DEVICE_ATTR(type, 0444, type_show, NULL);
 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 			     char *buf)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	return sprintf(buf, "css:t%01X\n", sch->st);
 }
 static DEVICE_ATTR(modalias, 0444, modalias_show, NULL);
 static struct attribute *subch_attrs[] = {
 	&dev_attr_type.attr,
 	&dev_attr_modalias.attr,
 	NULL,
 };
 static struct attribute_group subch_attr_group = {
 	.attrs = subch_attrs,
 };
 static const struct attribute_group *default_subch_attr_groups[] = {
 	&subch_attr_group,
 	NULL,
 };
 static int css_register_subchannel(struct subchannel *sch)
 {
 	int ret;
 	/* Initialize the subchannel structure */
 	sch->dev.parent = &channel_subsystems[0]->device;
 	sch->dev.bus = &css_bus_type;
 	sch->dev.release = &css_subchannel_release;
 	sch->dev.groups = default_subch_attr_groups;
 	/*
 	 * We don't want to generate uevents for I/O subchannels that don't
 	 * have a working ccw device behind them since they will be
 	 * unregistered before they can be used anyway, so we delay the add
 	 * uevent until after device recognition was successful.
 	 * Note that we suppress the uevent for all subchannel types;
 	 * the subchannel driver can decide itself when it wants to inform
 	 * userspace of its existence.
 	 */
 	dev_set_uevent_suppress(&sch->dev, 1);
 	css_update_ssd_info(sch);
 	/* make it known to the system */
 	ret = css_sch_device_register(sch);
 	if (ret) {
 		CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n",
 			      sch->schid.ssid, sch->schid.sch_no, ret);
 		return ret;
 	}
 	if (!sch->driver) {
 		/*
 		 * No driver matched. Generate the uevent now so that
 		 * a fitting driver module may be loaded based on the
 		 * modalias.
 		 */
 		dev_set_uevent_suppress(&sch->dev, 0);
 		kobject_uevent(&sch->dev.kobj, KOBJ_ADD);
 	}
 	return ret;
 }
 int css_probe_device(struct subchannel_id schid)
 {
 	int ret;
 	struct subchannel *sch;
 	if (cio_is_console(schid))
 		sch = cio_get_console_subchannel();
 	else {
 		sch = css_alloc_subchannel(schid);
 		if (IS_ERR(sch))
 			return PTR_ERR(sch);
 	}
 	ret = css_register_subchannel(sch);
 	if (ret) {
 		if (!cio_is_console(schid))
 			put_device(&sch->dev);
 	}
 	return ret;
 }
 static int
 check_subchannel(struct device * dev, void * data)
 {
 	struct subchannel *sch;
 	struct subchannel_id *schid = data;
 	sch = to_subchannel(dev);
 	return schid_equal(&sch->schid, schid);
 }
 struct subchannel *
 get_subchannel_by_schid(struct subchannel_id schid)
 {
 	struct device *dev;
 	dev = bus_find_device(&css_bus_type, NULL,
 			      &schid, check_subchannel);
 	return dev ? to_subchannel(dev) : NULL;
 }
 /**
  * css_sch_is_valid() - check if a subchannel is valid
  * @schib: subchannel information block for the subchannel
  */
 int css_sch_is_valid(struct schib *schib)
 {
 	if ((schib->pmcw.st == SUBCHANNEL_TYPE_IO) && !schib->pmcw.dnv)
 		return 0;
 	if ((schib->pmcw.st == SUBCHANNEL_TYPE_MSG) && !schib->pmcw.w)
 		return 0;
 	return 1;
 }
 EXPORT_SYMBOL_GPL(css_sch_is_valid);
 static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
 {
 	struct schib schib;
 	if (!slow) {
 		/* Will be done on the slow path. */
 		return -EAGAIN;
 	}
 	if (stsch_err(schid, &schib) || !css_sch_is_valid(&schib)) {
 		/* Unusable - ignore. */
 		return 0;
 	}
 	CIO_MSG_EVENT(4, "event: sch 0.%x.%04x, new\n", schid.ssid,
 		      schid.sch_no);
 	return css_probe_device(schid);
 }
 static int css_evaluate_known_subchannel(struct subchannel *sch, int slow)
 {
 	int ret = 0;
 	if (sch->driver) {
 		if (sch->driver->sch_event)
 			ret = sch->driver->sch_event(sch, slow);
 		else
 			dev_dbg(&sch->dev,
 				"Got subchannel machine check but "
 				"no sch_event handler provided.\n");
 	}
 	if (ret != 0 && ret != -EAGAIN) {
 		CIO_MSG_EVENT(2, "eval: sch 0.%x.%04x, rc=%d\n",
 			      sch->schid.ssid, sch->schid.sch_no, ret);
 	}
 	return ret;
 }
 static void css_evaluate_subchannel(struct subchannel_id schid, int slow)
 {
 	struct subchannel *sch;
 	int ret;
 	sch = get_subchannel_by_schid(schid);
 	if (sch) {
 		ret = css_evaluate_known_subchannel(sch, slow);
 		put_device(&sch->dev);
 	} else
 		ret = css_evaluate_new_subchannel(schid, slow);
 	if (ret == -EAGAIN)
 		css_schedule_eval(schid);
 }
 static struct idset *slow_subchannel_set;
 static spinlock_t slow_subchannel_lock;
 static wait_queue_head_t css_eval_wq;
 static atomic_t css_eval_scheduled;
 static int __init slow_subchannel_init(void)
 {
 	spin_lock_init(&slow_subchannel_lock);
 	atomic_set(&css_eval_scheduled, 0);
 	init_waitqueue_head(&css_eval_wq);
 	slow_subchannel_set = idset_sch_new();
 	if (!slow_subchannel_set) {
 		CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n");
 		return -ENOMEM;
 	}
 	return 0;
 }
 static int slow_eval_known_fn(struct subchannel *sch, void *data)
 {
 	int eval;
 	int rc;
 	spin_lock_irq(&slow_subchannel_lock);
 	eval = idset_sch_contains(slow_subchannel_set, sch->schid);
 	idset_sch_del(slow_subchannel_set, sch->schid);
 	spin_unlock_irq(&slow_subchannel_lock);
 	if (eval) {
 		rc = css_evaluate_known_subchannel(sch, 1);
 		if (rc == -EAGAIN)
 			css_schedule_eval(sch->schid);
 	}
 	return 0;
 }
 static int slow_eval_unknown_fn(struct subchannel_id schid, void *data)
 {
 	int eval;
 	int rc = 0;
 	spin_lock_irq(&slow_subchannel_lock);
 	eval = idset_sch_contains(slow_subchannel_set, schid);
 	idset_sch_del(slow_subchannel_set, schid);
 	spin_unlock_irq(&slow_subchannel_lock);
 	if (eval) {
 		rc = css_evaluate_new_subchannel(schid, 1);
 		switch (rc) {
 		case -EAGAIN:
 			css_schedule_eval(schid);
 			rc = 0;
 			break;
 		case -ENXIO:
 		case -ENOMEM:
 		case -EIO:
 			/* These should abort looping */
 			break;
 		default:
 			rc = 0;
 		}
 	}
 	return rc;
 }
 static void css_slow_path_func(struct work_struct *unused)
 {
 	unsigned long flags;
 	CIO_TRACE_EVENT(4, "slowpath");
 	for_each_subchannel_staged(slow_eval_known_fn, slow_eval_unknown_fn,
 				   NULL);
 	spin_lock_irqsave(&slow_subchannel_lock, flags);
 	if (idset_is_empty(slow_subchannel_set)) {
 		atomic_set(&css_eval_scheduled, 0);
 		wake_up(&css_eval_wq);
 	}
 	spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 }
 static DECLARE_WORK(slow_path_work, css_slow_path_func);
 struct workqueue_struct *cio_work_q;
 void css_schedule_eval(struct subchannel_id schid)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&slow_subchannel_lock, flags);
 	idset_sch_add(slow_subchannel_set, schid);
 	atomic_set(&css_eval_scheduled, 1);
 	queue_work(cio_work_q, &slow_path_work);
 	spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 }
 void css_schedule_eval_all(void)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&slow_subchannel_lock, flags);
 	idset_fill(slow_subchannel_set);
 	atomic_set(&css_eval_scheduled, 1);
 	queue_work(cio_work_q, &slow_path_work);
 	spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 }
 static int __unset_registered(struct device *dev, void *data)
 {
 	struct idset *set = data;
 	struct subchannel *sch = to_subchannel(dev);
 	idset_sch_del(set, sch->schid);
 	return 0;
 }
 static void css_schedule_eval_all_unreg(void)
 {
 	unsigned long flags;
 	struct idset *unreg_set;
 	/* Find unregistered subchannels. */
 	unreg_set = idset_sch_new();
 	if (!unreg_set) {
 		/* Fallback. */
 		css_schedule_eval_all();
 		return;
 	}
 	idset_fill(unreg_set);
 	bus_for_each_dev(&css_bus_type, NULL, unreg_set, __unset_registered);
 	/* Apply to slow_subchannel_set. */
 	spin_lock_irqsave(&slow_subchannel_lock, flags);
 	idset_add_set(slow_subchannel_set, unreg_set);
 	atomic_set(&css_eval_scheduled, 1);
 	queue_work(cio_work_q, &slow_path_work);
 	spin_unlock_irqrestore(&slow_subchannel_lock, flags);
 	idset_free(unreg_set);
 }
 void css_wait_for_slow_path(void)
 {
 	flush_workqueue(cio_work_q);
 }
 /* Schedule reprobing of all unregistered subchannels. */
 void css_schedule_reprobe(void)
 {
 	css_schedule_eval_all_unreg();
 }
 EXPORT_SYMBOL_GPL(css_schedule_reprobe);
 /*
  * Called from the machine check handler for subchannel report words.
  */
 static void css_process_crw(struct crw *crw0, struct crw *crw1, int overflow)
 {
 	struct subchannel_id mchk_schid;
 	if (overflow) {
 		css_schedule_eval_all();
 		return;
 	}
 	CIO_CRW_EVENT(2, "CRW0 reports slct=%d, oflw=%d, "
 		      "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
 		      crw0->slct, crw0->oflw, crw0->chn, crw0->rsc, crw0->anc,
 		      crw0->erc, crw0->rsid);
 	if (crw1)
 		CIO_CRW_EVENT(2, "CRW1 reports slct=%d, oflw=%d, "
 			      "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
 			      crw1->slct, crw1->oflw, crw1->chn, crw1->rsc,
 			      crw1->anc, crw1->erc, crw1->rsid);
 	init_subchannel_id(&mchk_schid);
 	mchk_schid.sch_no = crw0->rsid;
 	if (crw1)
 		mchk_schid.ssid = (crw1->rsid >> 8) & 3;
 	/*
 	 * Since we are always presented with IPI in the CRW, we have to
 	 * use stsch() to find out if the subchannel in question has come
 	 * or gone.
 	 */
 	css_evaluate_subchannel(mchk_schid, 0);
 }
 static void __init
 css_generate_pgid(struct channel_subsystem *css, u32 tod_high)
 {
 	struct cpuid cpu_id;
 	if (css_general_characteristics.mcss) {
 		css->global_pgid.pgid_high.ext_cssid.version = 0x80;
 		css->global_pgid.pgid_high.ext_cssid.cssid = css->cssid;
 	} else {
 #ifdef CONFIG_SMP
 		css->global_pgid.pgid_high.cpu_addr = stap();
 #else
 		css->global_pgid.pgid_high.cpu_addr = 0;
 #endif
 	}
 	get_cpu_id(&cpu_id);
 	css->global_pgid.cpu_id = cpu_id.ident;
 	css->global_pgid.cpu_model = cpu_id.machine;
 	css->global_pgid.tod_high = tod_high;
 }
 static void
 channel_subsystem_release(struct device *dev)
 {
 	struct channel_subsystem *css;
 	css = to_css(dev);
 	mutex_destroy(&css->mutex);
 	if (css->pseudo_subchannel) {
 		/* Implies that it has been generated but never registered. */
 		css_subchannel_release(&css->pseudo_subchannel->dev);
 		css->pseudo_subchannel = NULL;
 	}
 	kfree(css);
 }
 static ssize_t
 css_cm_enable_show(struct device *dev, struct device_attribute *attr,
 		   char *buf)
 {
 	struct channel_subsystem *css = to_css(dev);
 	int ret;
 	if (!css)
 		return 0;
 	mutex_lock(&css->mutex);
 	ret = sprintf(buf, "%x\n", css->cm_enabled);
 	mutex_unlock(&css->mutex);
 	return ret;
 }
 static ssize_t
 css_cm_enable_store(struct device *dev, struct device_attribute *attr,
 		    const char *buf, size_t count)
 {
 	struct channel_subsystem *css = to_css(dev);
 	int ret;
 	unsigned long val;
 	ret = strict_strtoul(buf, 16, &val);
 	if (ret)
 		return ret;
 	mutex_lock(&css->mutex);
 	switch (val) {
 	case 0:
 		ret = css->cm_enabled ? chsc_secm(css, 0) : 0;
 		break;
 	case 1:
 		ret = css->cm_enabled ? 0 : chsc_secm(css, 1);
 		break;
 	default:
 		ret = -EINVAL;
 	}
 	mutex_unlock(&css->mutex);
 	return ret < 0 ? ret : count;
 }
 static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store);
 static int __init setup_css(int nr)
 {
 	u32 tod_high;
 	int ret;
 	struct channel_subsystem *css;
 	css = channel_subsystems[nr];
 	memset(css, 0, sizeof(struct channel_subsystem));
 	css->pseudo_subchannel =
 		kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL);
 	if (!css->pseudo_subchannel)
 		return -ENOMEM;
 	css->pseudo_subchannel->dev.parent = &css->device;
 	css->pseudo_subchannel->dev.release = css_subchannel_release;
 	dev_set_name(&css->pseudo_subchannel->dev, "defunct");
 	mutex_init(&css->pseudo_subchannel->reg_mutex);
 	ret = cio_create_sch_lock(css->pseudo_subchannel);
 	if (ret) {
 		kfree(css->pseudo_subchannel);
 		return ret;
 	}
 	mutex_init(&css->mutex);
 	css->valid = 1;
 	css->cssid = nr;
 	dev_set_name(&css->device, "css%x", nr);
 	css->device.release = channel_subsystem_release;
 	tod_high = (u32) (get_clock() >> 32);
 	css_generate_pgid(css, tod_high);
 	return 0;
 }
 static int css_reboot_event(struct notifier_block *this,
 			    unsigned long event,
 			    void *ptr)
 {
 	int ret, i;
 	ret = NOTIFY_DONE;
 	for (i = 0; i <= __MAX_CSSID; i++) {
 		struct channel_subsystem *css;
 		css = channel_subsystems[i];
 		mutex_lock(&css->mutex);
 		if (css->cm_enabled)
 			if (chsc_secm(css, 0))
 				ret = NOTIFY_BAD;
 		mutex_unlock(&css->mutex);
 	}
 	return ret;
 }
 static struct notifier_block css_reboot_notifier = {
 	.notifier_call = css_reboot_event,
 };
 /*
  * Since the css devices are neither on a bus nor have a class
  * nor have a special device type, we cannot stop/restart channel
  * path measurements via the normal suspend/resume callbacks, but have
  * to use notifiers.
  */
 static int css_power_event(struct notifier_block *this, unsigned long event,
 			   void *ptr)
 {
 	void *secm_area;
 	int ret, i;
 	switch (event) {
 	case PM_HIBERNATION_PREPARE:
 	case PM_SUSPEND_PREPARE:
 		ret = NOTIFY_DONE;
 		for (i = 0; i <= __MAX_CSSID; i++) {
 			struct channel_subsystem *css;
 			css = channel_subsystems[i];
 			mutex_lock(&css->mutex);
 			if (!css->cm_enabled) {
 				mutex_unlock(&css->mutex);
 				continue;
 			}
 			secm_area = (void *)get_zeroed_page(GFP_KERNEL |
 							    GFP_DMA);
 			if (secm_area) {
 				if (__chsc_do_secm(css, 0, secm_area))
 					ret = NOTIFY_BAD;
 				free_page((unsigned long)secm_area);
 			} else
 				ret = NOTIFY_BAD;
 			mutex_unlock(&css->mutex);
 		}
 		break;
 	case PM_POST_HIBERNATION:
 	case PM_POST_SUSPEND:
 		ret = NOTIFY_DONE;
 		for (i = 0; i <= __MAX_CSSID; i++) {
 			struct channel_subsystem *css;
 			css = channel_subsystems[i];
 			mutex_lock(&css->mutex);
 			if (!css->cm_enabled) {
 				mutex_unlock(&css->mutex);
 				continue;
 			}
 			secm_area = (void *)get_zeroed_page(GFP_KERNEL |
 							    GFP_DMA);
 			if (secm_area) {
 				if (__chsc_do_secm(css, 1, secm_area))
 					ret = NOTIFY_BAD;
 				free_page((unsigned long)secm_area);
 			} else
 				ret = NOTIFY_BAD;
 			mutex_unlock(&css->mutex);
 		}
 		/* search for subchannels, which appeared during hibernation */
 		css_schedule_reprobe();
 		break;
 	default:
 		ret = NOTIFY_DONE;
 	}
 	return ret;
 }
 static struct notifier_block css_power_notifier = {
 	.notifier_call = css_power_event,
 };
 /*
  * Now that the driver core is running, we can setup our channel subsystem.
  * The struct subchannel's are created during probing (except for the
  * static console subchannel).
  */
 static int __init css_bus_init(void)
 {
 	int ret, i;
+	ret = chsc_init();
+	if (ret)
+		return ret;
 	ret = chsc_determine_css_characteristics();
 	if (ret == -ENOMEM)
 		goto out;
-	ret = chsc_alloc_sei_area();
-	if (ret)
-		goto out;
 	/* Try to enable MSS. */
 	ret = chsc_enable_facility(CHSC_SDA_OC_MSS);
 	if (ret)
 		max_ssid = 0;
 	else /* Success. */
 		max_ssid = __MAX_SSID;
 	ret = slow_subchannel_init();
 	if (ret)
 		goto out;
 	ret = crw_register_handler(CRW_RSC_SCH, css_process_crw);
 	if (ret)
 		goto out;
 	if ((ret = bus_register(&css_bus_type)))
 		goto out;
 	/* Setup css structure. */
 	for (i = 0; i <= __MAX_CSSID; i++) {
 		struct channel_subsystem *css;
 		css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL);
 		if (!css) {
 			ret = -ENOMEM;
 			goto out_unregister;
 		}
 		channel_subsystems[i] = css;
 		ret = setup_css(i);
 		if (ret) {
 			kfree(channel_subsystems[i]);
 			goto out_unregister;
 		}
 		ret = device_register(&css->device);
 		if (ret) {
 			put_device(&css->device);
 			goto out_unregister;
 		}
 		if (css_chsc_characteristics.secm) {
 			ret = device_create_file(&css->device,
 						 &dev_attr_cm_enable);
 			if (ret)
 				goto out_device;
 		}
 		ret = device_register(&css->pseudo_subchannel->dev);
 		if (ret) {
 			put_device(&css->pseudo_subchannel->dev);
 			goto out_file;
 		}
 	}
 	ret = register_reboot_notifier(&css_reboot_notifier);
 	if (ret)
 		goto out_unregister;
 	ret = register_pm_notifier(&css_power_notifier);
 	if (ret) {
 		unregister_reboot_notifier(&css_reboot_notifier);
 		goto out_unregister;
 	}
 	css_init_done = 1;
 	/* Enable default isc for I/O subchannels. */
 	isc_register(IO_SCH_ISC);
 	return 0;
 out_file:
 	if (css_chsc_characteristics.secm)
 		device_remove_file(&channel_subsystems[i]->device,
 				   &dev_attr_cm_enable);
 out_device:
 	device_unregister(&channel_subsystems[i]->device);
 out_unregister:
 	while (i > 0) {
 		struct channel_subsystem *css;
 		i--;
 		css = channel_subsystems[i];
 		device_unregister(&css->pseudo_subchannel->dev);
 		css->pseudo_subchannel = NULL;
 		if (css_chsc_characteristics.secm)
 			device_remove_file(&css->device,
 					   &dev_attr_cm_enable);
 		device_unregister(&css->device);
 	}
 	bus_unregister(&css_bus_type);
 out:
-	crw_unregister_handler(CRW_RSC_CSS);
+	crw_unregister_handler(CRW_RSC_SCH);
-	chsc_free_sei_area();
 	idset_free(slow_subchannel_set);
+	chsc_init_cleanup();
 	pr_alert("The CSS device driver initialization failed with "
 		 "errno=%d\n", ret);
 	return ret;
 }
 static void __init css_bus_cleanup(void)
 {
 	struct channel_subsystem *css;
 	int i;
 	for (i = 0; i <= __MAX_CSSID; i++) {
 		css = channel_subsystems[i];
 		device_unregister(&css->pseudo_subchannel->dev);
 		css->pseudo_subchannel = NULL;
 		if (css_chsc_characteristics.secm)
 			device_remove_file(&css->device, &dev_attr_cm_enable);
 		device_unregister(&css->device);
 	}
 	bus_unregister(&css_bus_type);
-	crw_unregister_handler(CRW_RSC_CSS);
+	crw_unregister_handler(CRW_RSC_SCH);
-	chsc_free_sei_area();
 	idset_free(slow_subchannel_set);
+	chsc_init_cleanup();
 	isc_unregister(IO_SCH_ISC);
 }
 static int __init channel_subsystem_init(void)
 {
 	int ret;
 	ret = css_bus_init();
 	if (ret)
 		return ret;
 	cio_work_q = create_singlethread_workqueue("cio");
 	if (!cio_work_q) {
 		ret = -ENOMEM;
 		goto out_bus;
 	}
 	ret = io_subchannel_init();
 	if (ret)
 		goto out_wq;
 	return ret;
 out_wq:
 	destroy_workqueue(cio_work_q);
 out_bus:
 	css_bus_cleanup();
 	return ret;
 }
 subsys_initcall(channel_subsystem_init);
 static int css_settle(struct device_driver *drv, void *unused)
 {
 	struct css_driver *cssdrv = to_cssdriver(drv);
 	if (cssdrv->settle)
 		return cssdrv->settle();
 	return 0;
 }
 int css_complete_work(void)
 {
 	int ret;
 	/* Wait for the evaluation of subchannels to finish. */
 	ret = wait_event_interruptible(css_eval_wq,
 				       atomic_read(&css_eval_scheduled) == 0);
 	if (ret)
 		return -EINTR;
 	flush_workqueue(cio_work_q);
 	/* Wait for the subchannel type specific initialization to finish */
 	return bus_for_each_drv(&css_bus_type, NULL, NULL, css_settle);
 }
 /*
  * Wait for the initialization of devices to finish, to make sure we are
  * done with our setup if the search for the root device starts.
  */
 static int __init channel_subsystem_init_sync(void)
 {
 	/* Start initial subchannel evaluation. */
 	css_schedule_eval_all();
 	css_complete_work();
 	return 0;
 }
 subsys_initcall_sync(channel_subsystem_init_sync);
 void channel_subsystem_reinit(void)
 {
 	chsc_enable_facility(CHSC_SDA_OC_MSS);
 }
 #ifdef CONFIG_PROC_FS
 static ssize_t cio_settle_write(struct file *file, const char __user *buf,
 				size_t count, loff_t *ppos)
 {
 	int ret;
 	/* Handle pending CRW's. */
 	crw_wait_for_channel_report();
 	ret = css_complete_work();
 	return ret ? ret : count;
 }
 static const struct file_operations cio_settle_proc_fops = {
 	.open = nonseekable_open,
 	.write = cio_settle_write,
 	.llseek = no_llseek,
 };
 static int __init cio_settle_init(void)
 {
 	struct proc_dir_entry *entry;
 	entry = proc_create("cio_settle", S_IWUSR, NULL,
 			    &cio_settle_proc_fops);
 	if (!entry)
 		return -ENOMEM;
 	return 0;
 }
 device_initcall(cio_settle_init);
 #endif /*CONFIG_PROC_FS*/
 int sch_is_pseudo_sch(struct subchannel *sch)
 {
 	return sch == to_css(sch->dev.parent)->pseudo_subchannel;
 }
 static int css_bus_match(struct device *dev, struct device_driver *drv)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	struct css_driver *driver = to_cssdriver(drv);
 	struct css_device_id *id;
 	for (id = driver->subchannel_type; id->match_flags; id++) {
 		if (sch->st == id->type)
 			return 1;
 	}
 	return 0;
 }
 static int css_probe(struct device *dev)
 {
 	struct subchannel *sch;
 	int ret;
 	sch = to_subchannel(dev);
 	sch->driver = to_cssdriver(dev->driver);
 	ret = sch->driver->probe ? sch->driver->probe(sch) : 0;
 	if (ret)
 		sch->driver = NULL;
 	return ret;
 }
 static int css_remove(struct device *dev)
 {
 	struct subchannel *sch;
 	int ret;
 	sch = to_subchannel(dev);
 	ret = sch->driver->remove ? sch->driver->remove(sch) : 0;
 	sch->driver = NULL;
 	return ret;
 }
 static void css_shutdown(struct device *dev)
 {
 	struct subchannel *sch;
 	sch = to_subchannel(dev);
 	if (sch->driver && sch->driver->shutdown)
 		sch->driver->shutdown(sch);
 }
 static int css_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	int ret;
 	ret = add_uevent_var(env, "ST=%01X", sch->st);
 	if (ret)
 		return ret;
 	ret = add_uevent_var(env, "MODALIAS=css:t%01X", sch->st);
 	return ret;
 }
 static int css_pm_prepare(struct device *dev)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	struct css_driver *drv;
 	if (mutex_is_locked(&sch->reg_mutex))
 		return -EAGAIN;
 	if (!sch->dev.driver)
 		return 0;
 	drv = to_cssdriver(sch->dev.driver);
 	/* Notify drivers that they may not register children. */
 	return drv->prepare ? drv->prepare(sch) : 0;
 }
 static void css_pm_complete(struct device *dev)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	struct css_driver *drv;
 	if (!sch->dev.driver)
 		return;
 	drv = to_cssdriver(sch->dev.driver);
 	if (drv->complete)
 		drv->complete(sch);
 }
 static int css_pm_freeze(struct device *dev)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	struct css_driver *drv;
 	if (!sch->dev.driver)
 		return 0;
 	drv = to_cssdriver(sch->dev.driver);
 	return drv->freeze ? drv->freeze(sch) : 0;
 }
 static int css_pm_thaw(struct device *dev)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	struct css_driver *drv;
 	if (!sch->dev.driver)
 		return 0;
 	drv = to_cssdriver(sch->dev.driver);
 	return drv->thaw ? drv->thaw(sch) : 0;
 }
 static int css_pm_restore(struct device *dev)
 {
 	struct subchannel *sch = to_subchannel(dev);
 	struct css_driver *drv;
 	if (!sch->dev.driver)
 		return 0;
 	drv = to_cssdriver(sch->dev.driver);
 	return drv->restore ? drv->restore(sch) : 0;
 }
 static const struct dev_pm_ops css_pm_ops = {
 	.prepare = css_pm_prepare,
 	.complete = css_pm_complete,
 	.freeze = css_pm_freeze,
 	.thaw = css_pm_thaw,
 	.restore = css_pm_restore,
 };
 struct bus_type css_bus_type = {
 	.name     = "css",
 	.match    = css_bus_match,
 	.probe    = css_probe,
 	.remove   = css_remove,
 	.shutdown = css_shutdown,
 	.uevent   = css_uevent,
 	.pm = &css_pm_ops,
 };
 /**
  * css_driver_register - register a css driver
  * @cdrv: css driver to register
  *
  * This is mainly a wrapper around driver_register that sets name
  * and bus_type in the embedded struct device_driver correctly.
  */
 int css_driver_register(struct css_driver *cdrv)
 {
 	cdrv->drv.name = cdrv->name;
 	cdrv->drv.bus = &css_bus_type;
 	cdrv->drv.owner = cdrv->owner;
 	return driver_register(&cdrv->drv);
 }
 EXPORT_SYMBOL_GPL(css_driver_register);
 /**
  * css_driver_unregister - unregister a css driver
  * @cdrv: css driver to unregister
  *
  * This is a wrapper around driver_unregister.
  */
 void css_driver_unregister(struct css_driver *cdrv)
 {
 	driver_unregister(&cdrv->drv);