]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * drivers/s390/cio/css.c | |
3 | * driver for channel subsystem | |
1da177e4 LT |
4 | * |
5 | * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH, | |
6 | * IBM Corporation | |
7 | * Author(s): Arnd Bergmann (arndb@de.ibm.com) | |
4ce3b30c | 8 | * Cornelia Huck (cornelia.huck@de.ibm.com) |
1da177e4 LT |
9 | */ |
10 | #include <linux/module.h> | |
11 | #include <linux/init.h> | |
12 | #include <linux/device.h> | |
13 | #include <linux/slab.h> | |
14 | #include <linux/errno.h> | |
15 | #include <linux/list.h> | |
a55360df | 16 | #include <linux/reboot.h> |
1da177e4 LT |
17 | |
18 | #include "css.h" | |
19 | #include "cio.h" | |
20 | #include "cio_debug.h" | |
21 | #include "ioasm.h" | |
22 | #include "chsc.h" | |
40154b82 | 23 | #include "device.h" |
83b3370c | 24 | #include "idset.h" |
7ad6a249 | 25 | #include "chp.h" |
1da177e4 | 26 | |
1da177e4 | 27 | int css_init_done = 0; |
40154b82 | 28 | static int need_reprobe = 0; |
fb6958a5 | 29 | static int max_ssid = 0; |
1da177e4 | 30 | |
7c9f4e3a | 31 | struct channel_subsystem *channel_subsystems[__MAX_CSSID + 1]; |
1da177e4 | 32 | |
a28c6944 | 33 | int css_characteristics_avail = 0; |
1da177e4 | 34 | |
4d284cac | 35 | int |
f97a56fb CH |
36 | for_each_subchannel(int(*fn)(struct subchannel_id, void *), void *data) |
37 | { | |
38 | struct subchannel_id schid; | |
39 | int ret; | |
40 | ||
41 | init_subchannel_id(&schid); | |
42 | ret = -ENODEV; | |
43 | do { | |
fb6958a5 CH |
44 | do { |
45 | ret = fn(schid, data); | |
46 | if (ret) | |
47 | break; | |
48 | } while (schid.sch_no++ < __MAX_SUBCHANNEL); | |
49 | schid.sch_no = 0; | |
50 | } while (schid.ssid++ < max_ssid); | |
f97a56fb CH |
51 | return ret; |
52 | } | |
53 | ||
1da177e4 | 54 | static struct subchannel * |
a8237fc4 | 55 | css_alloc_subchannel(struct subchannel_id schid) |
1da177e4 LT |
56 | { |
57 | struct subchannel *sch; | |
58 | int ret; | |
59 | ||
60 | sch = kmalloc (sizeof (*sch), GFP_KERNEL | GFP_DMA); | |
61 | if (sch == NULL) | |
62 | return ERR_PTR(-ENOMEM); | |
a8237fc4 | 63 | ret = cio_validate_subchannel (sch, schid); |
1da177e4 LT |
64 | if (ret < 0) { |
65 | kfree(sch); | |
66 | return ERR_PTR(ret); | |
67 | } | |
1da177e4 LT |
68 | |
69 | if (sch->st != SUBCHANNEL_TYPE_IO) { | |
70 | /* For now we ignore all non-io subchannels. */ | |
71 | kfree(sch); | |
72 | return ERR_PTR(-EINVAL); | |
73 | } | |
74 | ||
75 | /* | |
76 | * Set intparm to subchannel address. | |
77 | * This is fine even on 64bit since the subchannel is always located | |
78 | * under 2G. | |
79 | */ | |
80 | sch->schib.pmcw.intparm = (__u32)(unsigned long)sch; | |
81 | ret = cio_modify(sch); | |
82 | if (ret) { | |
5693ce6f | 83 | kfree(sch->lock); |
1da177e4 LT |
84 | kfree(sch); |
85 | return ERR_PTR(ret); | |
86 | } | |
87 | return sch; | |
88 | } | |
89 | ||
90 | static void | |
91 | css_free_subchannel(struct subchannel *sch) | |
92 | { | |
93 | if (sch) { | |
94 | /* Reset intparm to zeroes. */ | |
95 | sch->schib.pmcw.intparm = 0; | |
96 | cio_modify(sch); | |
2ec22984 | 97 | kfree(sch->lock); |
1da177e4 LT |
98 | kfree(sch); |
99 | } | |
1da177e4 LT |
100 | } |
101 | ||
102 | static void | |
103 | css_subchannel_release(struct device *dev) | |
104 | { | |
105 | struct subchannel *sch; | |
106 | ||
107 | sch = to_subchannel(dev); | |
2ec22984 CH |
108 | if (!cio_is_console(sch->schid)) { |
109 | kfree(sch->lock); | |
1da177e4 | 110 | kfree(sch); |
2ec22984 | 111 | } |
1da177e4 LT |
112 | } |
113 | ||
07c6a338 | 114 | static int css_sch_device_register(struct subchannel *sch) |
6ab4879a CH |
115 | { |
116 | int ret; | |
117 | ||
118 | mutex_lock(&sch->reg_mutex); | |
119 | ret = device_register(&sch->dev); | |
120 | mutex_unlock(&sch->reg_mutex); | |
121 | return ret; | |
122 | } | |
123 | ||
124 | void css_sch_device_unregister(struct subchannel *sch) | |
125 | { | |
126 | mutex_lock(&sch->reg_mutex); | |
127 | device_unregister(&sch->dev); | |
128 | mutex_unlock(&sch->reg_mutex); | |
129 | } | |
130 | ||
7ad6a249 PO |
131 | static void ssd_from_pmcw(struct chsc_ssd_info *ssd, struct pmcw *pmcw) |
132 | { | |
133 | int i; | |
134 | int mask; | |
135 | ||
136 | memset(ssd, 0, sizeof(struct chsc_ssd_info)); | |
137 | ssd->path_mask = pmcw->pim; | |
138 | for (i = 0; i < 8; i++) { | |
139 | mask = 0x80 >> i; | |
140 | if (pmcw->pim & mask) { | |
141 | chp_id_init(&ssd->chpid[i]); | |
142 | ssd->chpid[i].id = pmcw->chpid[i]; | |
143 | } | |
144 | } | |
145 | } | |
146 | ||
147 | static void ssd_register_chpids(struct chsc_ssd_info *ssd) | |
148 | { | |
149 | int i; | |
150 | int mask; | |
151 | ||
152 | for (i = 0; i < 8; i++) { | |
153 | mask = 0x80 >> i; | |
154 | if (ssd->path_mask & mask) | |
155 | if (!chp_is_registered(ssd->chpid[i])) | |
156 | chp_new(ssd->chpid[i]); | |
157 | } | |
158 | } | |
159 | ||
160 | void css_update_ssd_info(struct subchannel *sch) | |
161 | { | |
162 | int ret; | |
163 | ||
164 | if (cio_is_console(sch->schid)) { | |
165 | /* Console is initialized too early for functions requiring | |
166 | * memory allocation. */ | |
167 | ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw); | |
168 | } else { | |
169 | ret = chsc_get_ssd_info(sch->schid, &sch->ssd_info); | |
170 | if (ret) | |
171 | ssd_from_pmcw(&sch->ssd_info, &sch->schib.pmcw); | |
172 | ssd_register_chpids(&sch->ssd_info); | |
173 | } | |
174 | } | |
175 | ||
176 | static int css_register_subchannel(struct subchannel *sch) | |
1da177e4 LT |
177 | { |
178 | int ret; | |
179 | ||
180 | /* Initialize the subchannel structure */ | |
7c9f4e3a | 181 | sch->dev.parent = &channel_subsystems[0]->device; |
1da177e4 LT |
182 | sch->dev.bus = &css_bus_type; |
183 | sch->dev.release = &css_subchannel_release; | |
529192f3 | 184 | sch->dev.groups = subch_attr_groups; |
7ad6a249 | 185 | css_update_ssd_info(sch); |
1da177e4 | 186 | /* make it known to the system */ |
6ab4879a | 187 | ret = css_sch_device_register(sch); |
7674da77 | 188 | if (ret) { |
e556bbbd CH |
189 | CIO_MSG_EVENT(0, "Could not register sch 0.%x.%04x: %d\n", |
190 | sch->schid.ssid, sch->schid.sch_no, ret); | |
7674da77 CH |
191 | return ret; |
192 | } | |
1da177e4 LT |
193 | return ret; |
194 | } | |
195 | ||
f7e5d67c | 196 | static int css_probe_device(struct subchannel_id schid) |
1da177e4 LT |
197 | { |
198 | int ret; | |
199 | struct subchannel *sch; | |
200 | ||
a8237fc4 | 201 | sch = css_alloc_subchannel(schid); |
1da177e4 LT |
202 | if (IS_ERR(sch)) |
203 | return PTR_ERR(sch); | |
204 | ret = css_register_subchannel(sch); | |
205 | if (ret) | |
206 | css_free_subchannel(sch); | |
207 | return ret; | |
208 | } | |
209 | ||
b0744bd2 CH |
210 | static int |
211 | check_subchannel(struct device * dev, void * data) | |
212 | { | |
213 | struct subchannel *sch; | |
a8237fc4 | 214 | struct subchannel_id *schid = data; |
b0744bd2 CH |
215 | |
216 | sch = to_subchannel(dev); | |
a8237fc4 | 217 | return schid_equal(&sch->schid, schid); |
b0744bd2 CH |
218 | } |
219 | ||
1da177e4 | 220 | struct subchannel * |
a8237fc4 | 221 | get_subchannel_by_schid(struct subchannel_id schid) |
1da177e4 | 222 | { |
1da177e4 LT |
223 | struct device *dev; |
224 | ||
b0744bd2 | 225 | dev = bus_find_device(&css_bus_type, NULL, |
12975aef | 226 | &schid, check_subchannel); |
1da177e4 | 227 | |
b0744bd2 | 228 | return dev ? to_subchannel(dev) : NULL; |
1da177e4 LT |
229 | } |
230 | ||
4d284cac | 231 | static int css_get_subchannel_status(struct subchannel *sch) |
1da177e4 LT |
232 | { |
233 | struct schib schib; | |
1da177e4 | 234 | |
564337f3 | 235 | if (stsch(sch->schid, &schib) || !schib.pmcw.dnv) |
1da177e4 | 236 | return CIO_GONE; |
564337f3 | 237 | if (sch->schib.pmcw.dnv && (schib.pmcw.dev != sch->schib.pmcw.dev)) |
1da177e4 | 238 | return CIO_REVALIDATE; |
564337f3 | 239 | if (!sch->lpm) |
1da177e4 LT |
240 | return CIO_NO_PATH; |
241 | return CIO_OPER; | |
242 | } | |
564337f3 PO |
243 | |
244 | static int css_evaluate_known_subchannel(struct subchannel *sch, int slow) | |
1da177e4 LT |
245 | { |
246 | int event, ret, disc; | |
1da177e4 | 247 | unsigned long flags; |
564337f3 | 248 | enum { NONE, UNREGISTER, UNREGISTER_PROBE, REPROBE } action; |
1da177e4 | 249 | |
2ec22984 | 250 | spin_lock_irqsave(sch->lock, flags); |
564337f3 | 251 | disc = device_is_disconnected(sch); |
1da177e4 | 252 | if (disc && slow) { |
564337f3 | 253 | /* Disconnected devices are evaluated directly only.*/ |
2ec22984 | 254 | spin_unlock_irqrestore(sch->lock, flags); |
564337f3 | 255 | return 0; |
1da177e4 | 256 | } |
564337f3 PO |
257 | /* No interrupt after machine check - kill pending timers. */ |
258 | device_kill_pending_timer(sch); | |
1da177e4 | 259 | if (!disc && !slow) { |
564337f3 | 260 | /* Non-disconnected devices are evaluated on the slow path. */ |
2ec22984 | 261 | spin_unlock_irqrestore(sch->lock, flags); |
564337f3 | 262 | return -EAGAIN; |
1da177e4 | 263 | } |
564337f3 | 264 | event = css_get_subchannel_status(sch); |
fb6958a5 | 265 | CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, %s, %s path.\n", |
564337f3 PO |
266 | sch->schid.ssid, sch->schid.sch_no, event, |
267 | disc ? "disconnected" : "normal", | |
268 | slow ? "slow" : "fast"); | |
269 | /* Analyze subchannel status. */ | |
270 | action = NONE; | |
1da177e4 LT |
271 | switch (event) { |
272 | case CIO_NO_PATH: | |
564337f3 PO |
273 | if (disc) { |
274 | /* Check if paths have become available. */ | |
275 | action = REPROBE; | |
1da177e4 LT |
276 | break; |
277 | } | |
564337f3 PO |
278 | /* fall through */ |
279 | case CIO_GONE: | |
280 | /* Prevent unwanted effects when opening lock. */ | |
281 | cio_disable_subchannel(sch); | |
282 | device_set_disconnected(sch); | |
283 | /* Ask driver what to do with device. */ | |
284 | action = UNREGISTER; | |
285 | if (sch->driver && sch->driver->notify) { | |
2ec22984 | 286 | spin_unlock_irqrestore(sch->lock, flags); |
564337f3 | 287 | ret = sch->driver->notify(&sch->dev, event); |
2ec22984 | 288 | spin_lock_irqsave(sch->lock, flags); |
564337f3 PO |
289 | if (ret) |
290 | action = NONE; | |
1da177e4 | 291 | } |
1da177e4 LT |
292 | break; |
293 | case CIO_REVALIDATE: | |
564337f3 PO |
294 | /* Device will be removed, so no notify necessary. */ |
295 | if (disc) | |
296 | /* Reprobe because immediate unregister might block. */ | |
297 | action = REPROBE; | |
298 | else | |
299 | action = UNREGISTER_PROBE; | |
1da177e4 LT |
300 | break; |
301 | case CIO_OPER: | |
564337f3 | 302 | if (disc) |
1da177e4 | 303 | /* Get device operational again. */ |
564337f3 PO |
304 | action = REPROBE; |
305 | break; | |
306 | } | |
307 | /* Perform action. */ | |
308 | ret = 0; | |
309 | switch (action) { | |
310 | case UNREGISTER: | |
311 | case UNREGISTER_PROBE: | |
312 | /* Unregister device (will use subchannel lock). */ | |
2ec22984 | 313 | spin_unlock_irqrestore(sch->lock, flags); |
564337f3 | 314 | css_sch_device_unregister(sch); |
2ec22984 | 315 | spin_lock_irqsave(sch->lock, flags); |
564337f3 PO |
316 | |
317 | /* Reset intparm to zeroes. */ | |
318 | sch->schib.pmcw.intparm = 0; | |
319 | cio_modify(sch); | |
564337f3 PO |
320 | break; |
321 | case REPROBE: | |
322 | device_trigger_reprobe(sch); | |
1da177e4 LT |
323 | break; |
324 | default: | |
564337f3 PO |
325 | break; |
326 | } | |
2ec22984 | 327 | spin_unlock_irqrestore(sch->lock, flags); |
c2b1449b CH |
328 | /* Probe if necessary. */ |
329 | if (action == UNREGISTER_PROBE) | |
330 | ret = css_probe_device(sch->schid); | |
564337f3 PO |
331 | |
332 | return ret; | |
333 | } | |
334 | ||
335 | static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow) | |
336 | { | |
337 | struct schib schib; | |
338 | ||
339 | if (!slow) { | |
340 | /* Will be done on the slow path. */ | |
341 | return -EAGAIN; | |
342 | } | |
758976f9 | 343 | if (stsch_err(schid, &schib) || !schib.pmcw.dnv) { |
564337f3 PO |
344 | /* Unusable - ignore. */ |
345 | return 0; | |
1da177e4 | 346 | } |
564337f3 PO |
347 | CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, unknown, " |
348 | "slow path.\n", schid.ssid, schid.sch_no, CIO_OPER); | |
349 | ||
350 | return css_probe_device(schid); | |
351 | } | |
352 | ||
83b3370c | 353 | static void css_evaluate_subchannel(struct subchannel_id schid, int slow) |
564337f3 PO |
354 | { |
355 | struct subchannel *sch; | |
356 | int ret; | |
357 | ||
358 | sch = get_subchannel_by_schid(schid); | |
359 | if (sch) { | |
360 | ret = css_evaluate_known_subchannel(sch, slow); | |
361 | put_device(&sch->dev); | |
362 | } else | |
363 | ret = css_evaluate_new_subchannel(schid, slow); | |
83b3370c PO |
364 | if (ret == -EAGAIN) |
365 | css_schedule_eval(schid); | |
1da177e4 LT |
366 | } |
367 | ||
83b3370c PO |
368 | static struct idset *slow_subchannel_set; |
369 | static spinlock_t slow_subchannel_lock; | |
370 | ||
371 | static int __init slow_subchannel_init(void) | |
1da177e4 | 372 | { |
83b3370c PO |
373 | spin_lock_init(&slow_subchannel_lock); |
374 | slow_subchannel_set = idset_sch_new(); | |
375 | if (!slow_subchannel_set) { | |
e556bbbd | 376 | CIO_MSG_EVENT(0, "could not allocate slow subchannel set\n"); |
83b3370c PO |
377 | return -ENOMEM; |
378 | } | |
379 | return 0; | |
1da177e4 LT |
380 | } |
381 | ||
83b3370c | 382 | static void css_slow_path_func(struct work_struct *unused) |
1da177e4 | 383 | { |
83b3370c | 384 | struct subchannel_id schid; |
1da177e4 | 385 | |
83b3370c | 386 | CIO_TRACE_EVENT(4, "slowpath"); |
1da177e4 | 387 | spin_lock_irq(&slow_subchannel_lock); |
83b3370c PO |
388 | init_subchannel_id(&schid); |
389 | while (idset_sch_get_first(slow_subchannel_set, &schid)) { | |
390 | idset_sch_del(slow_subchannel_set, schid); | |
1da177e4 | 391 | spin_unlock_irq(&slow_subchannel_lock); |
83b3370c | 392 | css_evaluate_subchannel(schid, 1); |
1da177e4 | 393 | spin_lock_irq(&slow_subchannel_lock); |
1da177e4 LT |
394 | } |
395 | spin_unlock_irq(&slow_subchannel_lock); | |
396 | } | |
397 | ||
83b3370c | 398 | static DECLARE_WORK(slow_path_work, css_slow_path_func); |
1da177e4 LT |
399 | struct workqueue_struct *slow_path_wq; |
400 | ||
83b3370c PO |
401 | void css_schedule_eval(struct subchannel_id schid) |
402 | { | |
403 | unsigned long flags; | |
404 | ||
405 | spin_lock_irqsave(&slow_subchannel_lock, flags); | |
406 | idset_sch_add(slow_subchannel_set, schid); | |
407 | queue_work(slow_path_wq, &slow_path_work); | |
408 | spin_unlock_irqrestore(&slow_subchannel_lock, flags); | |
409 | } | |
410 | ||
411 | void css_schedule_eval_all(void) | |
412 | { | |
413 | unsigned long flags; | |
414 | ||
415 | spin_lock_irqsave(&slow_subchannel_lock, flags); | |
416 | idset_fill(slow_subchannel_set); | |
417 | queue_work(slow_path_wq, &slow_path_work); | |
418 | spin_unlock_irqrestore(&slow_subchannel_lock, flags); | |
419 | } | |
420 | ||
40154b82 PO |
421 | /* Reprobe subchannel if unregistered. */ |
422 | static int reprobe_subchannel(struct subchannel_id schid, void *data) | |
423 | { | |
424 | struct subchannel *sch; | |
425 | int ret; | |
426 | ||
e556bbbd CH |
427 | CIO_MSG_EVENT(6, "cio: reprobe 0.%x.%04x\n", |
428 | schid.ssid, schid.sch_no); | |
40154b82 PO |
429 | if (need_reprobe) |
430 | return -EAGAIN; | |
431 | ||
432 | sch = get_subchannel_by_schid(schid); | |
433 | if (sch) { | |
434 | /* Already known. */ | |
435 | put_device(&sch->dev); | |
436 | return 0; | |
437 | } | |
438 | ||
439 | ret = css_probe_device(schid); | |
440 | switch (ret) { | |
441 | case 0: | |
442 | break; | |
443 | case -ENXIO: | |
444 | case -ENOMEM: | |
445 | /* These should abort looping */ | |
446 | break; | |
447 | default: | |
448 | ret = 0; | |
449 | } | |
450 | ||
451 | return ret; | |
452 | } | |
453 | ||
454 | /* Work function used to reprobe all unregistered subchannels. */ | |
4927b3f7 | 455 | static void reprobe_all(struct work_struct *unused) |
40154b82 PO |
456 | { |
457 | int ret; | |
458 | ||
459 | CIO_MSG_EVENT(2, "reprobe start\n"); | |
460 | ||
461 | need_reprobe = 0; | |
462 | /* Make sure initial subchannel scan is done. */ | |
463 | wait_event(ccw_device_init_wq, | |
464 | atomic_read(&ccw_device_init_count) == 0); | |
465 | ret = for_each_subchannel(reprobe_subchannel, NULL); | |
466 | ||
467 | CIO_MSG_EVENT(2, "reprobe done (rc=%d, need_reprobe=%d)\n", ret, | |
468 | need_reprobe); | |
469 | } | |
470 | ||
2b67fc46 | 471 | static DECLARE_WORK(css_reprobe_work, reprobe_all); |
40154b82 PO |
472 | |
473 | /* Schedule reprobing of all unregistered subchannels. */ | |
474 | void css_schedule_reprobe(void) | |
475 | { | |
476 | need_reprobe = 1; | |
477 | queue_work(ccw_device_work, &css_reprobe_work); | |
478 | } | |
479 | ||
480 | EXPORT_SYMBOL_GPL(css_schedule_reprobe); | |
481 | ||
1da177e4 LT |
482 | /* |
483 | * Called from the machine check handler for subchannel report words. | |
484 | */ | |
83b3370c | 485 | void css_process_crw(int rsid1, int rsid2) |
1da177e4 | 486 | { |
a8237fc4 | 487 | struct subchannel_id mchk_schid; |
1da177e4 | 488 | |
fb6958a5 CH |
489 | CIO_CRW_EVENT(2, "source is subchannel %04X, subsystem id %x\n", |
490 | rsid1, rsid2); | |
a8237fc4 | 491 | init_subchannel_id(&mchk_schid); |
fb6958a5 CH |
492 | mchk_schid.sch_no = rsid1; |
493 | if (rsid2 != 0) | |
494 | mchk_schid.ssid = (rsid2 >> 8) & 3; | |
495 | ||
1da177e4 LT |
496 | /* |
497 | * Since we are always presented with IPI in the CRW, we have to | |
498 | * use stsch() to find out if the subchannel in question has come | |
499 | * or gone. | |
500 | */ | |
83b3370c | 501 | css_evaluate_subchannel(mchk_schid, 0); |
1da177e4 LT |
502 | } |
503 | ||
f97a56fb CH |
504 | static int __init |
505 | __init_channel_subsystem(struct subchannel_id schid, void *data) | |
506 | { | |
507 | struct subchannel *sch; | |
508 | int ret; | |
509 | ||
510 | if (cio_is_console(schid)) | |
511 | sch = cio_get_console_subchannel(); | |
512 | else { | |
513 | sch = css_alloc_subchannel(schid); | |
514 | if (IS_ERR(sch)) | |
515 | ret = PTR_ERR(sch); | |
516 | else | |
517 | ret = 0; | |
518 | switch (ret) { | |
519 | case 0: | |
520 | break; | |
521 | case -ENOMEM: | |
522 | panic("Out of memory in init_channel_subsystem\n"); | |
523 | /* -ENXIO: no more subchannels. */ | |
524 | case -ENXIO: | |
525 | return ret; | |
e843e280 GS |
526 | /* -EIO: this subchannel set not supported. */ |
527 | case -EIO: | |
528 | return ret; | |
f97a56fb CH |
529 | default: |
530 | return 0; | |
531 | } | |
532 | } | |
533 | /* | |
534 | * We register ALL valid subchannels in ioinfo, even those | |
535 | * that have been present before init_channel_subsystem. | |
536 | * These subchannels can't have been registered yet (kmalloc | |
537 | * not working) so we do it now. This is true e.g. for the | |
538 | * console subchannel. | |
539 | */ | |
540 | css_register_subchannel(sch); | |
541 | return 0; | |
542 | } | |
543 | ||
1da177e4 | 544 | static void __init |
a28c6944 | 545 | css_generate_pgid(struct channel_subsystem *css, u32 tod_high) |
1da177e4 | 546 | { |
a28c6944 CH |
547 | if (css_characteristics_avail && css_general_characteristics.mcss) { |
548 | css->global_pgid.pgid_high.ext_cssid.version = 0x80; | |
549 | css->global_pgid.pgid_high.ext_cssid.cssid = css->cssid; | |
550 | } else { | |
1da177e4 | 551 | #ifdef CONFIG_SMP |
a28c6944 | 552 | css->global_pgid.pgid_high.cpu_addr = hard_smp_processor_id(); |
1da177e4 | 553 | #else |
a28c6944 | 554 | css->global_pgid.pgid_high.cpu_addr = 0; |
1da177e4 LT |
555 | #endif |
556 | } | |
a28c6944 CH |
557 | css->global_pgid.cpu_id = ((cpuid_t *) __LC_CPUID)->ident; |
558 | css->global_pgid.cpu_model = ((cpuid_t *) __LC_CPUID)->machine; | |
559 | css->global_pgid.tod_high = tod_high; | |
560 | ||
561 | } | |
562 | ||
3b793060 CH |
563 | static void |
564 | channel_subsystem_release(struct device *dev) | |
565 | { | |
566 | struct channel_subsystem *css; | |
567 | ||
568 | css = to_css(dev); | |
495a5b45 | 569 | mutex_destroy(&css->mutex); |
3b793060 CH |
570 | kfree(css); |
571 | } | |
572 | ||
495a5b45 CH |
573 | static ssize_t |
574 | css_cm_enable_show(struct device *dev, struct device_attribute *attr, | |
575 | char *buf) | |
576 | { | |
577 | struct channel_subsystem *css = to_css(dev); | |
578 | ||
579 | if (!css) | |
580 | return 0; | |
581 | return sprintf(buf, "%x\n", css->cm_enabled); | |
582 | } | |
583 | ||
584 | static ssize_t | |
585 | css_cm_enable_store(struct device *dev, struct device_attribute *attr, | |
586 | const char *buf, size_t count) | |
587 | { | |
588 | struct channel_subsystem *css = to_css(dev); | |
589 | int ret; | |
590 | ||
591 | switch (buf[0]) { | |
592 | case '0': | |
593 | ret = css->cm_enabled ? chsc_secm(css, 0) : 0; | |
594 | break; | |
595 | case '1': | |
596 | ret = css->cm_enabled ? 0 : chsc_secm(css, 1); | |
597 | break; | |
598 | default: | |
599 | ret = -EINVAL; | |
600 | } | |
601 | return ret < 0 ? ret : count; | |
602 | } | |
603 | ||
604 | static DEVICE_ATTR(cm_enable, 0644, css_cm_enable_show, css_cm_enable_store); | |
605 | ||
4d284cac | 606 | static int __init setup_css(int nr) |
a28c6944 CH |
607 | { |
608 | u32 tod_high; | |
d7b5a4c9 | 609 | int ret; |
7c9f4e3a | 610 | struct channel_subsystem *css; |
a28c6944 | 611 | |
7c9f4e3a CH |
612 | css = channel_subsystems[nr]; |
613 | memset(css, 0, sizeof(struct channel_subsystem)); | |
614 | css->pseudo_subchannel = | |
615 | kzalloc(sizeof(*css->pseudo_subchannel), GFP_KERNEL); | |
616 | if (!css->pseudo_subchannel) | |
d7b5a4c9 | 617 | return -ENOMEM; |
7c9f4e3a CH |
618 | css->pseudo_subchannel->dev.parent = &css->device; |
619 | css->pseudo_subchannel->dev.release = css_subchannel_release; | |
620 | sprintf(css->pseudo_subchannel->dev.bus_id, "defunct"); | |
621 | ret = cio_create_sch_lock(css->pseudo_subchannel); | |
d7b5a4c9 | 622 | if (ret) { |
7c9f4e3a | 623 | kfree(css->pseudo_subchannel); |
d7b5a4c9 CH |
624 | return ret; |
625 | } | |
7c9f4e3a CH |
626 | mutex_init(&css->mutex); |
627 | css->valid = 1; | |
628 | css->cssid = nr; | |
629 | sprintf(css->device.bus_id, "css%x", nr); | |
630 | css->device.release = channel_subsystem_release; | |
a28c6944 | 631 | tod_high = (u32) (get_clock() >> 32); |
7c9f4e3a | 632 | css_generate_pgid(css, tod_high); |
d7b5a4c9 | 633 | return 0; |
1da177e4 LT |
634 | } |
635 | ||
a55360df CH |
636 | static int css_reboot_event(struct notifier_block *this, |
637 | unsigned long event, | |
638 | void *ptr) | |
639 | { | |
640 | int ret, i; | |
641 | ||
642 | ret = NOTIFY_DONE; | |
643 | for (i = 0; i <= __MAX_CSSID; i++) { | |
644 | struct channel_subsystem *css; | |
645 | ||
646 | css = channel_subsystems[i]; | |
647 | if (css->cm_enabled) | |
648 | if (chsc_secm(css, 0)) | |
649 | ret = NOTIFY_BAD; | |
650 | } | |
651 | ||
652 | return ret; | |
653 | } | |
654 | ||
655 | static struct notifier_block css_reboot_notifier = { | |
656 | .notifier_call = css_reboot_event, | |
657 | }; | |
658 | ||
1da177e4 LT |
659 | /* |
660 | * Now that the driver core is running, we can setup our channel subsystem. | |
661 | * The struct subchannel's are created during probing (except for the | |
662 | * static console subchannel). | |
663 | */ | |
664 | static int __init | |
665 | init_channel_subsystem (void) | |
666 | { | |
a28c6944 | 667 | int ret, i; |
1da177e4 | 668 | |
4434a38c CH |
669 | ret = chsc_determine_css_characteristics(); |
670 | if (ret == -ENOMEM) | |
671 | goto out; /* No need to continue. */ | |
672 | if (ret == 0) | |
1da177e4 LT |
673 | css_characteristics_avail = 1; |
674 | ||
4434a38c CH |
675 | ret = chsc_alloc_sei_area(); |
676 | if (ret) | |
677 | goto out; | |
678 | ||
679 | ret = slow_subchannel_init(); | |
680 | if (ret) | |
681 | goto out; | |
682 | ||
1da177e4 LT |
683 | if ((ret = bus_register(&css_bus_type))) |
684 | goto out; | |
1da177e4 | 685 | |
fb6958a5 CH |
686 | /* Try to enable MSS. */ |
687 | ret = chsc_enable_facility(CHSC_SDA_OC_MSS); | |
688 | switch (ret) { | |
689 | case 0: /* Success. */ | |
690 | max_ssid = __MAX_SSID; | |
691 | break; | |
692 | case -ENOMEM: | |
693 | goto out_bus; | |
694 | default: | |
695 | max_ssid = 0; | |
696 | } | |
a28c6944 CH |
697 | /* Setup css structure. */ |
698 | for (i = 0; i <= __MAX_CSSID; i++) { | |
7c9f4e3a CH |
699 | struct channel_subsystem *css; |
700 | ||
701 | css = kmalloc(sizeof(struct channel_subsystem), GFP_KERNEL); | |
702 | if (!css) { | |
a28c6944 | 703 | ret = -ENOMEM; |
fb6958a5 | 704 | goto out_unregister; |
a28c6944 | 705 | } |
7c9f4e3a | 706 | channel_subsystems[i] = css; |
d7b5a4c9 | 707 | ret = setup_css(i); |
a28c6944 CH |
708 | if (ret) |
709 | goto out_free; | |
7c9f4e3a | 710 | ret = device_register(&css->device); |
d7b5a4c9 CH |
711 | if (ret) |
712 | goto out_free_all; | |
7e560814 CH |
713 | if (css_characteristics_avail && |
714 | css_chsc_characteristics.secm) { | |
7c9f4e3a | 715 | ret = device_create_file(&css->device, |
7e560814 CH |
716 | &dev_attr_cm_enable); |
717 | if (ret) | |
718 | goto out_device; | |
719 | } | |
7c9f4e3a | 720 | ret = device_register(&css->pseudo_subchannel->dev); |
d7b5a4c9 CH |
721 | if (ret) |
722 | goto out_file; | |
a28c6944 | 723 | } |
a55360df CH |
724 | ret = register_reboot_notifier(&css_reboot_notifier); |
725 | if (ret) | |
726 | goto out_pseudo; | |
1da177e4 LT |
727 | css_init_done = 1; |
728 | ||
729 | ctl_set_bit(6, 28); | |
730 | ||
f97a56fb | 731 | for_each_subchannel(__init_channel_subsystem, NULL); |
1da177e4 | 732 | return 0; |
a55360df CH |
733 | out_pseudo: |
734 | device_unregister(&channel_subsystems[i]->pseudo_subchannel->dev); | |
d7b5a4c9 | 735 | out_file: |
7c9f4e3a CH |
736 | device_remove_file(&channel_subsystems[i]->device, |
737 | &dev_attr_cm_enable); | |
7e560814 | 738 | out_device: |
7c9f4e3a | 739 | device_unregister(&channel_subsystems[i]->device); |
d7b5a4c9 | 740 | out_free_all: |
7c9f4e3a CH |
741 | kfree(channel_subsystems[i]->pseudo_subchannel->lock); |
742 | kfree(channel_subsystems[i]->pseudo_subchannel); | |
a28c6944 | 743 | out_free: |
7c9f4e3a | 744 | kfree(channel_subsystems[i]); |
fb6958a5 | 745 | out_unregister: |
a28c6944 | 746 | while (i > 0) { |
7c9f4e3a CH |
747 | struct channel_subsystem *css; |
748 | ||
a28c6944 | 749 | i--; |
7c9f4e3a CH |
750 | css = channel_subsystems[i]; |
751 | device_unregister(&css->pseudo_subchannel->dev); | |
495a5b45 | 752 | if (css_characteristics_avail && css_chsc_characteristics.secm) |
7c9f4e3a | 753 | device_remove_file(&css->device, |
495a5b45 | 754 | &dev_attr_cm_enable); |
7c9f4e3a | 755 | device_unregister(&css->device); |
a28c6944 | 756 | } |
fb6958a5 | 757 | out_bus: |
1da177e4 LT |
758 | bus_unregister(&css_bus_type); |
759 | out: | |
4434a38c CH |
760 | chsc_free_sei_area(); |
761 | kfree(slow_subchannel_set); | |
762 | printk(KERN_WARNING"cio: failed to initialize css driver (%d)!\n", | |
763 | ret); | |
1da177e4 LT |
764 | return ret; |
765 | } | |
766 | ||
d7b5a4c9 CH |
767 | int sch_is_pseudo_sch(struct subchannel *sch) |
768 | { | |
769 | return sch == to_css(sch->dev.parent)->pseudo_subchannel; | |
770 | } | |
771 | ||
1da177e4 LT |
772 | /* |
773 | * find a driver for a subchannel. They identify by the subchannel | |
774 | * type with the exception that the console subchannel driver has its own | |
775 | * subchannel type although the device is an i/o subchannel | |
776 | */ | |
777 | static int | |
778 | css_bus_match (struct device *dev, struct device_driver *drv) | |
779 | { | |
780 | struct subchannel *sch = container_of (dev, struct subchannel, dev); | |
781 | struct css_driver *driver = container_of (drv, struct css_driver, drv); | |
782 | ||
783 | if (sch->st == driver->subchannel_type) | |
784 | return 1; | |
785 | ||
786 | return 0; | |
787 | } | |
788 | ||
8bbace7e CH |
789 | static int |
790 | css_probe (struct device *dev) | |
791 | { | |
792 | struct subchannel *sch; | |
793 | ||
794 | sch = to_subchannel(dev); | |
795 | sch->driver = container_of (dev->driver, struct css_driver, drv); | |
796 | return (sch->driver->probe ? sch->driver->probe(sch) : 0); | |
797 | } | |
798 | ||
799 | static int | |
800 | css_remove (struct device *dev) | |
801 | { | |
802 | struct subchannel *sch; | |
803 | ||
804 | sch = to_subchannel(dev); | |
805 | return (sch->driver->remove ? sch->driver->remove(sch) : 0); | |
806 | } | |
807 | ||
808 | static void | |
809 | css_shutdown (struct device *dev) | |
810 | { | |
811 | struct subchannel *sch; | |
812 | ||
813 | sch = to_subchannel(dev); | |
814 | if (sch->driver->shutdown) | |
815 | sch->driver->shutdown(sch); | |
816 | } | |
817 | ||
1da177e4 | 818 | struct bus_type css_bus_type = { |
8bbace7e CH |
819 | .name = "css", |
820 | .match = css_bus_match, | |
821 | .probe = css_probe, | |
822 | .remove = css_remove, | |
823 | .shutdown = css_shutdown, | |
1da177e4 LT |
824 | }; |
825 | ||
826 | subsys_initcall(init_channel_subsystem); | |
827 | ||
1da177e4 LT |
828 | MODULE_LICENSE("GPL"); |
829 | EXPORT_SYMBOL(css_bus_type); | |
1da177e4 | 830 | EXPORT_SYMBOL_GPL(css_characteristics_avail); |