projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[S390] cio: Clean up online_store.
[linux-2.6-block.git] / drivers / s390 / cio / device_fsm.c
CommitLineData
1da177e4
LT		 1/*
2 * drivers/s390/cio/device_fsm.c
3 * finite state machine for device handling
4 *
5 * Copyright (C) 2002 IBM Deutschland Entwicklung GmbH,
6 * IBM Corporation
4ce3b30c 7 * Author(s): Cornelia Huck (cornelia.huck@de.ibm.com)
1da177e4
LT		 8 * Martin Schwidefsky (schwidefsky@de.ibm.com)
9 */
10
11#include <linux/module.h>
1da177e4 12#include <linux/init.h>
4e57b681
TS		 13#include <linux/jiffies.h>
14#include <linux/string.h>
1da177e4
LT		 15
16#include <asm/ccwdev.h>
4c24da79 17#include <asm/cio.h>
1da177e4
LT		 18
19#include "cio.h"
20#include "cio_debug.h"
21#include "css.h"
22#include "device.h"
23#include "chsc.h"
24#include "ioasm.h"
f86635fa 25#include "chpid.h"
e6b6e10a 26#include "chp.h"
1da177e4
LT		 27
28int
29device_is_online(struct subchannel *sch)
30{
31 struct ccw_device *cdev;
32
33 if (!sch->dev.driver_data)
34 return 0;
35 cdev = sch->dev.driver_data;
36 return (cdev->private->state == DEV_STATE_ONLINE);
37}
38
39int
40device_is_disconnected(struct subchannel *sch)
41{
42 struct ccw_device *cdev;
43
44 if (!sch->dev.driver_data)
45 return 0;
46 cdev = sch->dev.driver_data;
47 return (cdev->private->state == DEV_STATE_DISCONNECTED ||
48 cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID);
49}
50
51void
52device_set_disconnected(struct subchannel *sch)
53{
54 struct ccw_device *cdev;
55
56 if (!sch->dev.driver_data)
57 return;
58 cdev = sch->dev.driver_data;
59 ccw_device_set_timeout(cdev, 0);
60 cdev->private->flags.fake_irb = 0;
61 cdev->private->state = DEV_STATE_DISCONNECTED;
62}
63
d23861ff
CH		 64void device_set_intretry(struct subchannel *sch)
65{
66 struct ccw_device *cdev;
67
68 cdev = sch->dev.driver_data;
69 if (!cdev)
70 return;
71 cdev->private->flags.intretry = 1;
72}
73
24cb5b48
CH		 74int device_trigger_verify(struct subchannel *sch)
75{
76 struct ccw_device *cdev;
77
78 cdev = sch->dev.driver_data;
79 if (!cdev || !cdev->online)
80 return -EINVAL;
81 dev_fsm_event(cdev, DEV_EVENT_VERIFY);
82 return 0;
83}
84
1da177e4
LT		 85/*
86 * Timeout function. It just triggers a DEV_EVENT_TIMEOUT.
87 */
88static void
89ccw_device_timeout(unsigned long data)
90{
91 struct ccw_device *cdev;
92
93 cdev = (struct ccw_device *) data;
94 spin_lock_irq(cdev->ccwlock);
95 dev_fsm_event(cdev, DEV_EVENT_TIMEOUT);
96 spin_unlock_irq(cdev->ccwlock);
97}
98
99/*
100 * Set timeout
101 */
102void
103ccw_device_set_timeout(struct ccw_device *cdev, int expires)
104{
105 if (expires == 0) {
106 del_timer(&cdev->private->timer);
107 return;
108 }
109 if (timer_pending(&cdev->private->timer)) {
110 if (mod_timer(&cdev->private->timer, jiffies + expires))
111 return;
112 }
113 cdev->private->timer.function = ccw_device_timeout;
114 cdev->private->timer.data = (unsigned long) cdev;
115 cdev->private->timer.expires = jiffies + expires;
116 add_timer(&cdev->private->timer);
117}
118
119/* Kill any pending timers after machine check. */
120void
121device_kill_pending_timer(struct subchannel *sch)
122{
123 struct ccw_device *cdev;
124
125 if (!sch->dev.driver_data)
126 return;
127 cdev = sch->dev.driver_data;
128 ccw_device_set_timeout(cdev, 0);
129}
130
131/*
132 * Cancel running i/o. This is called repeatedly since halt/clear are
133 * asynchronous operations. We do one try with cio_cancel, two tries
134 * with cio_halt, 255 tries with cio_clear. If everythings fails panic.
135 * Returns 0 if device now idle, -ENODEV for device not operational and
136 * -EBUSY if an interrupt is expected (either from halt/clear or from a
137 * status pending).
138 */
139int
140ccw_device_cancel_halt_clear(struct ccw_device *cdev)
141{
142 struct subchannel *sch;
143 int ret;
144
145 sch = to_subchannel(cdev->dev.parent);
a8237fc4 146 ret = stsch(sch->schid, &sch->schib);
1da177e4
LT		 147 if (ret || !sch->schib.pmcw.dnv)
148 return -ENODEV;
2470b648
CH		 149 if (!sch->schib.pmcw.ena)
150 /* Not operational -> done. */
1da177e4
LT		 151 return 0;
152 /* Stage 1: cancel io. */
153 if (!(sch->schib.scsw.actl & SCSW_ACTL_HALT_PEND) &&
154 !(sch->schib.scsw.actl & SCSW_ACTL_CLEAR_PEND)) {
155 ret = cio_cancel(sch);
156 if (ret != -EINVAL)
157 return ret;
158 /* cancel io unsuccessful. From now on it is asynchronous. */
159 cdev->private->iretry = 3; /* 3 halt retries. */
160 }
161 if (!(sch->schib.scsw.actl & SCSW_ACTL_CLEAR_PEND)) {
162 /* Stage 2: halt io. */
163 if (cdev->private->iretry) {
164 cdev->private->iretry--;
165 ret = cio_halt(sch);
ba4ba8a6
PO		 166 if (ret != -EBUSY)
167 return (ret == 0) ? -EBUSY : ret;
1da177e4
LT		 168 }
169 /* halt io unsuccessful. */
170 cdev->private->iretry = 255; /* 255 clear retries. */
171 }
172 /* Stage 3: clear io. */
173 if (cdev->private->iretry) {
174 cdev->private->iretry--;
175 ret = cio_clear (sch);
176 return (ret == 0) ? -EBUSY : ret;
177 }
178 panic("Can't stop i/o on subchannel.\n");
179}
180
181static int
182ccw_device_handle_oper(struct ccw_device *cdev)
183{
184 struct subchannel *sch;
185
186 sch = to_subchannel(cdev->dev.parent);
187 cdev->private->flags.recog_done = 1;
188 /*
189 * Check if cu type and device type still match. If
190 * not, it is certainly another device and we have to
d7b5a4c9 191 * de- and re-register.
1da177e4
LT		 192 */
193 if (cdev->id.cu_type != cdev->private->senseid.cu_type ||
194 cdev->id.cu_model != cdev->private->senseid.cu_model ||
195 cdev->id.dev_type != cdev->private->senseid.dev_type ||
d7b5a4c9 196 cdev->id.dev_model != cdev->private->senseid.dev_model) {
1da177e4 197 PREPARE_WORK(&cdev->private->kick_work,
c1637532 198 ccw_device_do_unreg_rereg);
1da177e4
LT		 199 queue_work(ccw_device_work, &cdev->private->kick_work);
200 return 0;
201 }
202 cdev->private->flags.donotify = 1;
203 return 1;
204}
205
206/*
207 * The machine won't give us any notification by machine check if a chpid has
208 * been varied online on the SE so we have to find out by magic (i. e. driving
209 * the channel subsystem to device selection and updating our path masks).
210 */
4d284cac 211static void
1da177e4
LT		 212__recover_lost_chpids(struct subchannel *sch, int old_lpm)
213{
214 int mask, i;
f86635fa 215 struct chp_id chpid;
1da177e4 216
f86635fa 217 chp_id_init(&chpid);
1da177e4
LT		 218 for (i = 0; i<8; i++) {
219 mask = 0x80 >> i;
220 if (!(sch->lpm & mask))
221 continue;
222 if (old_lpm & mask)
223 continue;
f86635fa 224 chpid.id = sch->schib.pmcw.chpid[i];
e6b6e10a
PO		 225 if (!chp_is_registered(chpid)) {
226 need_rescan = 1;
227 queue_work(slow_path_wq, &slow_path_work);
228 }
1da177e4
LT		 229 }
230}
231
232/*
233 * Stop device recognition.
234 */
235static void
236ccw_device_recog_done(struct ccw_device *cdev, int state)
237{
238 struct subchannel *sch;
239 int notify, old_lpm, same_dev;
240
241 sch = to_subchannel(cdev->dev.parent);
242
243 ccw_device_set_timeout(cdev, 0);
244 cio_disable_subchannel(sch);
245 /*
246 * Now that we tried recognition, we have performed device selection
247 * through ssch() and the path information is up to date.
248 */
249 old_lpm = sch->lpm;
a8237fc4 250 stsch(sch->schid, &sch->schib);
28bdc6f6 251 sch->lpm = sch->schib.pmcw.pam & sch->opm;
4ffa9234
CH		 252 /* Check since device may again have become not operational. */
253 if (!sch->schib.pmcw.dnv)
254 state = DEV_STATE_NOT_OPER;
1da177e4
LT		 255 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID)
256 /* Force reprobe on all chpids. */
257 old_lpm = 0;
258 if (sch->lpm != old_lpm)
259 __recover_lost_chpids(sch, old_lpm);
260 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
261 if (state == DEV_STATE_NOT_OPER) {
262 cdev->private->flags.recog_done = 1;
263 cdev->private->state = DEV_STATE_DISCONNECTED;
264 return;
265 }
266 /* Boxed devices don't need extra treatment. */
267 }
268 notify = 0;
269 same_dev = 0; /* Keep the compiler quiet... */
270 switch (state) {
271 case DEV_STATE_NOT_OPER:
272 CIO_DEBUG(KERN_WARNING, 2,
fb6958a5 273 "SenseID : unknown device %04x on subchannel "
78964268 274 "0.%x.%04x\n", cdev->private->dev_id.devno,
fb6958a5 275 sch->schid.ssid, sch->schid.sch_no);
1da177e4
LT		 276 break;
277 case DEV_STATE_OFFLINE:
278 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
279 same_dev = ccw_device_handle_oper(cdev);
280 notify = 1;
281 }
282 /* fill out sense information */
81388d2a 283 memset(&cdev->id, 0, sizeof(cdev->id));
292888c8
HC		 284 cdev->id.cu_type = cdev->private->senseid.cu_type;
285 cdev->id.cu_model = cdev->private->senseid.cu_model;
286 cdev->id.dev_type = cdev->private->senseid.dev_type;
287 cdev->id.dev_model = cdev->private->senseid.dev_model;
1da177e4
LT		 288 if (notify) {
289 cdev->private->state = DEV_STATE_OFFLINE;
290 if (same_dev) {
291 /* Get device online again. */
292 ccw_device_online(cdev);
293 wake_up(&cdev->private->wait_q);
294 }
295 return;
296 }
297 /* Issue device info message. */
fb6958a5 298 CIO_DEBUG(KERN_INFO, 2, "SenseID : device 0.%x.%04x reports: "
1da177e4 299 "CU Type/Mod = %04X/%02X, Dev Type/Mod = "
fb6958a5 300 "%04X/%02X\n",
78964268
CH		 301 cdev->private->dev_id.ssid,
302 cdev->private->dev_id.devno,
1da177e4
LT		 303 cdev->id.cu_type, cdev->id.cu_model,
304 cdev->id.dev_type, cdev->id.dev_model);
305 break;
306 case DEV_STATE_BOXED:
307 CIO_DEBUG(KERN_WARNING, 2,
fb6958a5 308 "SenseID : boxed device %04x on subchannel "
78964268 309 "0.%x.%04x\n", cdev->private->dev_id.devno,
fb6958a5 310 sch->schid.ssid, sch->schid.sch_no);
1da177e4
LT		 311 break;
312 }
313 cdev->private->state = state;
314 io_subchannel_recog_done(cdev);
315 if (state != DEV_STATE_NOT_OPER)
316 wake_up(&cdev->private->wait_q);
317}
318
319/*
320 * Function called from device_id.c after sense id has completed.
321 */
322void
323ccw_device_sense_id_done(struct ccw_device *cdev, int err)
324{
325 switch (err) {
326 case 0:
327 ccw_device_recog_done(cdev, DEV_STATE_OFFLINE);
328 break;
329 case -ETIME: /* Sense id stopped by timeout. */
330 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
331 break;
332 default:
333 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
334 break;
335 }
336}
337
338static void
c1637532 339ccw_device_oper_notify(struct work_struct *work)
1da177e4 340{
c1637532 341 struct ccw_device_private *priv;
1da177e4
LT		 342 struct ccw_device *cdev;
343 struct subchannel *sch;
344 int ret;
ee04bbcc 345 unsigned long flags;
1da177e4 346
c1637532
MS		 347 priv = container_of(work, struct ccw_device_private, kick_work);
348 cdev = priv->cdev;
ee04bbcc 349 spin_lock_irqsave(cdev->ccwlock, flags);
1da177e4 350 sch = to_subchannel(cdev->dev.parent);
ee04bbcc
CH		 351 if (sch->driver && sch->driver->notify) {
352 spin_unlock_irqrestore(cdev->ccwlock, flags);
353 ret = sch->driver->notify(&sch->dev, CIO_OPER);
354 spin_lock_irqsave(cdev->ccwlock, flags);
355 } else
356 ret = 0;
357 if (ret) {
94bb0633 358 /* Reenable channel measurements, if needed. */
ee04bbcc 359 spin_unlock_irqrestore(cdev->ccwlock, flags);
94bb0633 360 cmf_reenable(cdev);
ee04bbcc 361 spin_lock_irqsave(cdev->ccwlock, flags);
1da177e4 362 wake_up(&cdev->private->wait_q);
94bb0633 363 }
ee04bbcc
CH		 364 spin_unlock_irqrestore(cdev->ccwlock, flags);
365 if (!ret)
366 /* Driver doesn't want device back. */
367 ccw_device_do_unreg_rereg(work);
1da177e4
LT		 368}
369
370/*
371 * Finished with online/offline processing.
372 */
373static void
374ccw_device_done(struct ccw_device *cdev, int state)
375{
376 struct subchannel *sch;
377
378 sch = to_subchannel(cdev->dev.parent);
379
f1ee3281
CH		 380 ccw_device_set_timeout(cdev, 0);
381
1da177e4
LT		 382 if (state != DEV_STATE_ONLINE)
383 cio_disable_subchannel(sch);
384
385 /* Reset device status. */
386 memset(&cdev->private->irb, 0, sizeof(struct irb));
387
388 cdev->private->state = state;
389
390
391 if (state == DEV_STATE_BOXED)
392 CIO_DEBUG(KERN_WARNING, 2,
393 "Boxed device %04x on subchannel %04x\n",
78964268 394 cdev->private->dev_id.devno, sch->schid.sch_no);
1da177e4
LT		 395
396 if (cdev->private->flags.donotify) {
397 cdev->private->flags.donotify = 0;
c1637532 398 PREPARE_WORK(&cdev->private->kick_work, ccw_device_oper_notify);
1da177e4
LT		 399 queue_work(ccw_device_notify_work, &cdev->private->kick_work);
400 }
401 wake_up(&cdev->private->wait_q);
402
403 if (css_init_done && state != DEV_STATE_ONLINE)
404 put_device (&cdev->dev);
405}
406
4d284cac 407static int cmp_pgid(struct pgid *p1, struct pgid *p2)
7e560814
CH		 408{
409 char *c1;
410 char *c2;
411
412 c1 = (char *)p1;
413 c2 = (char *)p2;
414
415 return memcmp(c1 + 1, c2 + 1, sizeof(struct pgid) - 1);
416}
417
418static void __ccw_device_get_common_pgid(struct ccw_device *cdev)
419{
420 int i;
421 int last;
422
423 last = 0;
424 for (i = 0; i < 8; i++) {
425 if (cdev->private->pgid[i].inf.ps.state1 == SNID_STATE1_RESET)
426 /* No PGID yet */
427 continue;
428 if (cdev->private->pgid[last].inf.ps.state1 ==
429 SNID_STATE1_RESET) {
430 /* First non-zero PGID */
431 last = i;
432 continue;
433 }
434 if (cmp_pgid(&cdev->private->pgid[i],
435 &cdev->private->pgid[last]) == 0)
436 /* Non-conflicting PGIDs */
437 continue;
438
439 /* PGID mismatch, can't pathgroup. */
440 CIO_MSG_EVENT(0, "SNID - pgid mismatch for device "
441 "0.%x.%04x, can't pathgroup\n",
78964268
CH		 442 cdev->private->dev_id.ssid,
443 cdev->private->dev_id.devno);
7e560814
CH		 444 cdev->private->options.pgroup = 0;
445 return;
446 }
447 if (cdev->private->pgid[last].inf.ps.state1 ==
448 SNID_STATE1_RESET)
449 /* No previous pgid found */
450 memcpy(&cdev->private->pgid[0], &css[0]->global_pgid,
451 sizeof(struct pgid));
452 else
453 /* Use existing pgid */
454 memcpy(&cdev->private->pgid[0], &cdev->private->pgid[last],
455 sizeof(struct pgid));
456}
457
1da177e4
LT		 458/*
459 * Function called from device_pgid.c after sense path ground has completed.
460 */
461void
462ccw_device_sense_pgid_done(struct ccw_device *cdev, int err)
463{
464 struct subchannel *sch;
465
466 sch = to_subchannel(cdev->dev.parent);
467 switch (err) {
7e560814
CH		 468 case -EOPNOTSUPP: /* path grouping not supported, use nop instead. */
469 cdev->private->options.pgroup = 0;
470 break;
471 case 0: /* success */
472 case -EACCES: /* partial success, some paths not operational */
473 /* Check if all pgids are equal or 0. */
474 __ccw_device_get_common_pgid(cdev);
1da177e4
LT		 475 break;
476 case -ETIME: /* Sense path group id stopped by timeout. */
477 case -EUSERS: /* device is reserved for someone else. */
478 ccw_device_done(cdev, DEV_STATE_BOXED);
7e560814 479 return;
1da177e4
LT		 480 default:
481 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
7e560814 482 return;
1da177e4 483 }
7e560814 484 /* Start Path Group verification. */
7e560814 485 cdev->private->state = DEV_STATE_VERIFY;
28bdc6f6 486 cdev->private->flags.doverify = 0;
7e560814 487 ccw_device_verify_start(cdev);
1da177e4
LT		 488}
489
490/*
491 * Start device recognition.
492 */
493int
494ccw_device_recognition(struct ccw_device *cdev)
495{
496 struct subchannel *sch;
497 int ret;
498
499 if ((cdev->private->state != DEV_STATE_NOT_OPER) &&
500 (cdev->private->state != DEV_STATE_BOXED))
501 return -EINVAL;
502 sch = to_subchannel(cdev->dev.parent);
503 ret = cio_enable_subchannel(sch, sch->schib.pmcw.isc);
504 if (ret != 0)
505 /* Couldn't enable the subchannel for i/o. Sick device. */
506 return ret;
507
508 /* After 60s the device recognition is considered to have failed. */
509 ccw_device_set_timeout(cdev, 60*HZ);
510
511 /*
512 * We used to start here with a sense pgid to find out whether a device
513 * is locked by someone else. Unfortunately, the sense pgid command
514 * code has other meanings on devices predating the path grouping
515 * algorithm, so we start with sense id and box the device after an
516 * timeout (or if sense pgid during path verification detects the device
517 * is locked, as may happen on newer devices).
518 */
519 cdev->private->flags.recog_done = 0;
520 cdev->private->state = DEV_STATE_SENSE_ID;
521 ccw_device_sense_id_start(cdev);
522 return 0;
523}
524
525/*
526 * Handle timeout in device recognition.
527 */
528static void
529ccw_device_recog_timeout(struct ccw_device *cdev, enum dev_event dev_event)
530{
531 int ret;
532
533 ret = ccw_device_cancel_halt_clear(cdev);
534 switch (ret) {
535 case 0:
536 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
537 break;
538 case -ENODEV:
539 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
540 break;
541 default:
542 ccw_device_set_timeout(cdev, 3*HZ);
543 }
544}
545
546
547static void
c1637532 548ccw_device_nopath_notify(struct work_struct *work)
1da177e4 549{
c1637532 550 struct ccw_device_private *priv;
1da177e4
LT		 551 struct ccw_device *cdev;
552 struct subchannel *sch;
553 int ret;
ee04bbcc 554 unsigned long flags;
1da177e4 555
c1637532
MS		 556 priv = container_of(work, struct ccw_device_private, kick_work);
557 cdev = priv->cdev;
ee04bbcc 558 spin_lock_irqsave(cdev->ccwlock, flags);
1da177e4
LT		 559 sch = to_subchannel(cdev->dev.parent);
560 /* Extra sanity. */
561 if (sch->lpm)
ee04bbcc
CH		 562 goto out_unlock;
563 if (sch->driver && sch->driver->notify) {
564 spin_unlock_irqrestore(cdev->ccwlock, flags);
565 ret = sch->driver->notify(&sch->dev, CIO_NO_PATH);
566 spin_lock_irqsave(cdev->ccwlock, flags);
567 } else
568 ret = 0;
1da177e4
LT		 569 if (!ret) {
570 if (get_device(&sch->dev)) {
571 /* Driver doesn't want to keep device. */
572 cio_disable_subchannel(sch);
573 if (get_device(&cdev->dev)) {
574 PREPARE_WORK(&cdev->private->kick_work,
c1637532 575 ccw_device_call_sch_unregister);
1da177e4
LT		 576 queue_work(ccw_device_work,
577 &cdev->private->kick_work);
578 } else
579 put_device(&sch->dev);
580 }
581 } else {
582 cio_disable_subchannel(sch);
583 ccw_device_set_timeout(cdev, 0);
584 cdev->private->flags.fake_irb = 0;
585 cdev->private->state = DEV_STATE_DISCONNECTED;
586 wake_up(&cdev->private->wait_q);
587 }
ee04bbcc
CH		 588out_unlock:
589 spin_unlock_irqrestore(cdev->ccwlock, flags);
1da177e4
LT		 590}
591
592void
593ccw_device_verify_done(struct ccw_device *cdev, int err)
594{
28bdc6f6
PO		 595 struct subchannel *sch;
596
597 sch = to_subchannel(cdev->dev.parent);
598 /* Update schib - pom may have changed. */
599 stsch(sch->schid, &sch->schib);
600 /* Update lpm with verified path mask. */
601 sch->lpm = sch->vpm;
602 /* Repeat path verification? */
603 if (cdev->private->flags.doverify) {
604 cdev->private->flags.doverify = 0;
605 ccw_device_verify_start(cdev);
606 return;
607 }
1da177e4
LT		 608 switch (err) {
609 case -EOPNOTSUPP: /* path grouping not supported, just set online. */
610 cdev->private->options.pgroup = 0;
611 case 0:
612 ccw_device_done(cdev, DEV_STATE_ONLINE);
613 /* Deliver fake irb to device driver, if needed. */
614 if (cdev->private->flags.fake_irb) {
615 memset(&cdev->private->irb, 0, sizeof(struct irb));
292888c8
HC		 616 cdev->private->irb.scsw.cc = 1;
617 cdev->private->irb.scsw.fctl = SCSW_FCTL_START_FUNC;
618 cdev->private->irb.scsw.actl = SCSW_ACTL_START_PEND;
619 cdev->private->irb.scsw.stctl = SCSW_STCTL_STATUS_PEND;
1da177e4
LT		 620 cdev->private->flags.fake_irb = 0;
621 if (cdev->handler)
622 cdev->handler(cdev, cdev->private->intparm,
623 &cdev->private->irb);
624 memset(&cdev->private->irb, 0, sizeof(struct irb));
625 }
626 break;
627 case -ETIME:
8b42f5c2
PO		 628 /* Reset oper notify indication after verify error. */
629 cdev->private->flags.donotify = 0;
1da177e4
LT		 630 ccw_device_done(cdev, DEV_STATE_BOXED);
631 break;
632 default:
8b42f5c2
PO		 633 /* Reset oper notify indication after verify error. */
634 cdev->private->flags.donotify = 0;
ee04bbcc
CH		 635 if (cdev->online) {
636 PREPARE_WORK(&cdev->private->kick_work,
637 ccw_device_nopath_notify);
638 queue_work(ccw_device_notify_work,
639 &cdev->private->kick_work);
640 } else
641 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
1da177e4
LT		 642 break;
643 }
644}
645
646/*
647 * Get device online.
648 */
649int
650ccw_device_online(struct ccw_device *cdev)
651{
652 struct subchannel *sch;
653 int ret;
654
655 if ((cdev->private->state != DEV_STATE_OFFLINE) &&
656 (cdev->private->state != DEV_STATE_BOXED))
657 return -EINVAL;
658 sch = to_subchannel(cdev->dev.parent);
659 if (css_init_done && !get_device(&cdev->dev))
660 return -ENODEV;
661 ret = cio_enable_subchannel(sch, sch->schib.pmcw.isc);
662 if (ret != 0) {
663 /* Couldn't enable the subchannel for i/o. Sick device. */
664 if (ret == -ENODEV)
665 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
666 return ret;
667 }
668 /* Do we want to do path grouping? */
669 if (!cdev->private->options.pgroup) {
7e560814
CH		 670 /* Start initial path verification. */
671 cdev->private->state = DEV_STATE_VERIFY;
28bdc6f6 672 cdev->private->flags.doverify = 0;
7e560814 673 ccw_device_verify_start(cdev);
1da177e4
LT		 674 return 0;
675 }
676 /* Do a SensePGID first. */
677 cdev->private->state = DEV_STATE_SENSE_PGID;
678 ccw_device_sense_pgid_start(cdev);
679 return 0;
680}
681
682void
683ccw_device_disband_done(struct ccw_device *cdev, int err)
684{
685 switch (err) {
686 case 0:
687 ccw_device_done(cdev, DEV_STATE_OFFLINE);
688 break;
689 case -ETIME:
690 ccw_device_done(cdev, DEV_STATE_BOXED);
691 break;
692 default:
693 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
694 break;
695 }
696}
697
698/*
699 * Shutdown device.
700 */
701int
702ccw_device_offline(struct ccw_device *cdev)
703{
704 struct subchannel *sch;
705
d7b5a4c9
CH		 706 if (ccw_device_is_orphan(cdev)) {
707 ccw_device_done(cdev, DEV_STATE_OFFLINE);
708 return 0;
709 }
1da177e4 710 sch = to_subchannel(cdev->dev.parent);
a8237fc4 711 if (stsch(sch->schid, &sch->schib) || !sch->schib.pmcw.dnv)
1da177e4
LT		 712 return -ENODEV;
713 if (cdev->private->state != DEV_STATE_ONLINE) {
714 if (sch->schib.scsw.actl != 0)
715 return -EBUSY;
716 return -EINVAL;
717 }
718 if (sch->schib.scsw.actl != 0)
719 return -EBUSY;
720 /* Are we doing path grouping? */
721 if (!cdev->private->options.pgroup) {
722 /* No, set state offline immediately. */
723 ccw_device_done(cdev, DEV_STATE_OFFLINE);
724 return 0;
725 }
726 /* Start Set Path Group commands. */
727 cdev->private->state = DEV_STATE_DISBAND_PGID;
728 ccw_device_disband_start(cdev);
729 return 0;
730}
731
732/*
733 * Handle timeout in device online/offline process.
734 */
735static void
736ccw_device_onoff_timeout(struct ccw_device *cdev, enum dev_event dev_event)
737{
738 int ret;
739
740 ret = ccw_device_cancel_halt_clear(cdev);
741 switch (ret) {
742 case 0:
743 ccw_device_done(cdev, DEV_STATE_BOXED);
744 break;
745 case -ENODEV:
746 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
747 break;
748 default:
749 ccw_device_set_timeout(cdev, 3*HZ);
750 }
751}
752
753/*
754 * Handle not oper event in device recognition.
755 */
756static void
757ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event)
758{
759 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
760}
761
762/*
763 * Handle not operational event while offline.
764 */
765static void
766ccw_device_offline_notoper(struct ccw_device *cdev, enum dev_event dev_event)
767{
768 struct subchannel *sch;
769
770 cdev->private->state = DEV_STATE_NOT_OPER;
771 sch = to_subchannel(cdev->dev.parent);
772 if (get_device(&cdev->dev)) {
773 PREPARE_WORK(&cdev->private->kick_work,
c1637532 774 ccw_device_call_sch_unregister);
1da177e4
LT		 775 queue_work(ccw_device_work, &cdev->private->kick_work);
776 }
777 wake_up(&cdev->private->wait_q);
778}
779
780/*
781 * Handle not operational event while online.
782 */
783static void
784ccw_device_online_notoper(struct ccw_device *cdev, enum dev_event dev_event)
785{
786 struct subchannel *sch;
ee04bbcc 787 int ret;
1da177e4
LT		 788
789 sch = to_subchannel(cdev->dev.parent);
ee04bbcc
CH		 790 if (sch->driver->notify) {
791 spin_unlock_irq(cdev->ccwlock);
792 ret = sch->driver->notify(&sch->dev,
793 sch->lpm ? CIO_GONE : CIO_NO_PATH);
794 spin_lock_irq(cdev->ccwlock);
795 } else
796 ret = 0;
797 if (ret) {
798 ccw_device_set_timeout(cdev, 0);
799 cdev->private->flags.fake_irb = 0;
800 cdev->private->state = DEV_STATE_DISCONNECTED;
801 wake_up(&cdev->private->wait_q);
802 return;
1da177e4
LT		 803 }
804 cdev->private->state = DEV_STATE_NOT_OPER;
805 cio_disable_subchannel(sch);
806 if (sch->schib.scsw.actl != 0) {
807 // FIXME: not-oper indication to device driver ?
808 ccw_device_call_handler(cdev);
809 }
810 if (get_device(&cdev->dev)) {
811 PREPARE_WORK(&cdev->private->kick_work,
c1637532 812 ccw_device_call_sch_unregister);
1da177e4
LT		 813 queue_work(ccw_device_work, &cdev->private->kick_work);
814 }
815 wake_up(&cdev->private->wait_q);
816}
817
818/*
819 * Handle path verification event.
820 */
821static void
822ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
823{
824 struct subchannel *sch;
825
1da177e4
LT		 826 if (cdev->private->state == DEV_STATE_W4SENSE) {
827 cdev->private->flags.doverify = 1;
828 return;
829 }
830 sch = to_subchannel(cdev->dev.parent);
831 /*
832 * Since we might not just be coming from an interrupt from the
833 * subchannel we have to update the schib.
834 */
a8237fc4 835 stsch(sch->schid, &sch->schib);
1da177e4
LT		 836
837 if (sch->schib.scsw.actl != 0 ||
65200c29 838 (sch->schib.scsw.stctl & SCSW_STCTL_STATUS_PEND) ||
1da177e4
LT		 839 (cdev->private->irb.scsw.stctl & SCSW_STCTL_STATUS_PEND)) {
840 /*
841 * No final status yet or final status not yet delivered
842 * to the device driver. Can't do path verfication now,
843 * delay until final status was delivered.
844 */
845 cdev->private->flags.doverify = 1;
846 return;
847 }
848 /* Device is idle, we can do the path verification. */
849 cdev->private->state = DEV_STATE_VERIFY;
28bdc6f6 850 cdev->private->flags.doverify = 0;
1da177e4
LT		 851 ccw_device_verify_start(cdev);
852}
853
854/*
855 * Got an interrupt for a normal io (state online).
856 */
857static void
858ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
859{
860 struct irb *irb;
861
862 irb = (struct irb *) __LC_IRB;
863 /* Check for unsolicited interrupt. */
864 if ((irb->scsw.stctl ==
865 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS))
866 && (!irb->scsw.cc)) {
867 if ((irb->scsw.dstat & DEV_STAT_UNIT_CHECK) &&
868 !irb->esw.esw0.erw.cons) {
869 /* Unit check but no sense data. Need basic sense. */
870 if (ccw_device_do_sense(cdev, irb) != 0)
871 goto call_handler_unsol;
e0ec5749 872 memcpy(&cdev->private->irb, irb, sizeof(struct irb));
1da177e4
LT		 873 cdev->private->state = DEV_STATE_W4SENSE;
874 cdev->private->intparm = 0;
875 return;
876 }
877call_handler_unsol:
878 if (cdev->handler)
879 cdev->handler (cdev, 0, irb);
18374d37
CH		 880 if (cdev->private->flags.doverify)
881 ccw_device_online_verify(cdev, 0);
1da177e4
LT		 882 return;
883 }
884 /* Accumulate status and find out if a basic sense is needed. */
885 ccw_device_accumulate_irb(cdev, irb);
886 if (cdev->private->flags.dosense) {
887 if (ccw_device_do_sense(cdev, irb) == 0) {
888 cdev->private->state = DEV_STATE_W4SENSE;
889 }
890 return;
891 }
892 /* Call the handler. */
893 if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
894 /* Start delayed path verification. */
895 ccw_device_online_verify(cdev, 0);
896}
897
898/*
899 * Got an timeout in online state.
900 */
901static void
902ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
903{
904 int ret;
905
906 ccw_device_set_timeout(cdev, 0);
907 ret = ccw_device_cancel_halt_clear(cdev);
908 if (ret == -EBUSY) {
909 ccw_device_set_timeout(cdev, 3*HZ);
910 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
911 return;
912 }
913 if (ret == -ENODEV) {
914 struct subchannel *sch;
915
916 sch = to_subchannel(cdev->dev.parent);
917 if (!sch->lpm) {
918 PREPARE_WORK(&cdev->private->kick_work,
c1637532 919 ccw_device_nopath_notify);
1da177e4
LT		 920 queue_work(ccw_device_notify_work,
921 &cdev->private->kick_work);
922 } else
923 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
924 } else if (cdev->handler)
925 cdev->handler(cdev, cdev->private->intparm,
926 ERR_PTR(-ETIMEDOUT));
927}
928
929/*
930 * Got an interrupt for a basic sense.
931 */
2b67fc46 932static void
1da177e4
LT		 933ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
934{
935 struct irb *irb;
936
937 irb = (struct irb *) __LC_IRB;
938 /* Check for unsolicited interrupt. */
939 if (irb->scsw.stctl ==
940 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
941 if (irb->scsw.cc == 1)
942 /* Basic sense hasn't started. Try again. */
943 ccw_device_do_sense(cdev, irb);
944 else {
08983787
CH		 945 printk(KERN_INFO "Huh? %s(%s): unsolicited "
946 "interrupt...\n",
1da177e4
LT		 947 __FUNCTION__, cdev->dev.bus_id);
948 if (cdev->handler)
949 cdev->handler (cdev, 0, irb);
950 }
951 return;
952 }
3ba1998e
CH		 953 /*
954 * Check if a halt or clear has been issued in the meanwhile. If yes,
955 * only deliver the halt/clear interrupt to the device driver as if it
956 * had killed the original request.
957 */
958 if (irb->scsw.fctl & (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) {
d23861ff
CH		 959 /* Retry Basic Sense if requested. */
960 if (cdev->private->flags.intretry) {
961 cdev->private->flags.intretry = 0;
962 ccw_device_do_sense(cdev, irb);
963 return;
964 }
3ba1998e
CH		 965 cdev->private->flags.dosense = 0;
966 memset(&cdev->private->irb, 0, sizeof(struct irb));
967 ccw_device_accumulate_irb(cdev, irb);
968 goto call_handler;
969 }
1da177e4
LT		 970 /* Add basic sense info to irb. */
971 ccw_device_accumulate_basic_sense(cdev, irb);
972 if (cdev->private->flags.dosense) {
973 /* Another basic sense is needed. */
974 ccw_device_do_sense(cdev, irb);
975 return;
976 }
3ba1998e 977call_handler:
1da177e4
LT		 978 cdev->private->state = DEV_STATE_ONLINE;
979 /* Call the handler. */
980 if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
981 /* Start delayed path verification. */
982 ccw_device_online_verify(cdev, 0);
983}
984
985static void
986ccw_device_clear_verify(struct ccw_device *cdev, enum dev_event dev_event)
987{
988 struct irb *irb;
989
990 irb = (struct irb *) __LC_IRB;
991 /* Accumulate status. We don't do basic sense. */
992 ccw_device_accumulate_irb(cdev, irb);
b4f7b1ee
CH		 993 /* Remember to clear irb to avoid residuals. */
994 memset(&cdev->private->irb, 0, sizeof(struct irb));
1da177e4
LT		 995 /* Try to start delayed device verification. */
996 ccw_device_online_verify(cdev, 0);
997 /* Note: Don't call handler for cio initiated clear! */
998}
999
1000static void
1001ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
1002{
1003 struct subchannel *sch;
1004
1005 sch = to_subchannel(cdev->dev.parent);
1006 ccw_device_set_timeout(cdev, 0);
7c8427c3
CH		 1007 /* Start delayed path verification. */
1008 ccw_device_online_verify(cdev, 0);
1da177e4 1009 /* OK, i/o is dead now. Call interrupt handler. */
1da177e4
LT		 1010 if (cdev->handler)
1011 cdev->handler(cdev, cdev->private->intparm,
e7769b48 1012 ERR_PTR(-EIO));
1da177e4
LT		 1013}
1014
1015static void
1016ccw_device_killing_timeout(struct ccw_device *cdev, enum dev_event dev_event)
1017{
1018 int ret;
1019
1020 ret = ccw_device_cancel_halt_clear(cdev);
1021 if (ret == -EBUSY) {
1022 ccw_device_set_timeout(cdev, 3*HZ);
1023 return;
1024 }
7c8427c3
CH		 1025 /* Start delayed path verification. */
1026 ccw_device_online_verify(cdev, 0);
1da177e4
LT		 1027 if (cdev->handler)
1028 cdev->handler(cdev, cdev->private->intparm,
e7769b48 1029 ERR_PTR(-EIO));
1da177e4
LT		 1030}
1031
e7769b48 1032void device_kill_io(struct subchannel *sch)
1da177e4
LT		 1033{
1034 int ret;
e7769b48 1035 struct ccw_device *cdev;
1da177e4 1036
e7769b48 1037 cdev = sch->dev.driver_data;
1da177e4
LT		 1038 ret = ccw_device_cancel_halt_clear(cdev);
1039 if (ret == -EBUSY) {
1040 ccw_device_set_timeout(cdev, 3*HZ);
1041 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
1042 return;
1043 }
7c8427c3
CH		 1044 /* Start delayed path verification. */
1045 ccw_device_online_verify(cdev, 0);
1da177e4
LT		 1046 if (cdev->handler)
1047 cdev->handler(cdev, cdev->private->intparm,
e7769b48 1048 ERR_PTR(-EIO));
1da177e4
LT		 1049}
1050
1051static void
28bdc6f6 1052ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
1da177e4 1053{
28bdc6f6 1054 /* Start verification after current task finished. */
7e560814 1055 cdev->private->flags.doverify = 1;
1da177e4
LT		 1056}
1057
1058static void
1059ccw_device_stlck_done(struct ccw_device *cdev, enum dev_event dev_event)
1060{
1061 struct irb *irb;
1062
1063 switch (dev_event) {
1064 case DEV_EVENT_INTERRUPT:
1065 irb = (struct irb *) __LC_IRB;
1066 /* Check for unsolicited interrupt. */
1067 if ((irb->scsw.stctl ==
1068 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) &&
1069 (!irb->scsw.cc))
1070 /* FIXME: we should restart stlck here, but this
1071 * is extremely unlikely ... */
1072 goto out_wakeup;
1073
1074 ccw_device_accumulate_irb(cdev, irb);
1075 /* We don't care about basic sense etc. */
1076 break;
1077 default: /* timeout */
1078 break;
1079 }
1080out_wakeup:
1081 wake_up(&cdev->private->wait_q);
1082}
1083
1084static void
1085ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
1086{
1087 struct subchannel *sch;
1088
1089 sch = to_subchannel(cdev->dev.parent);
1090 if (cio_enable_subchannel(sch, sch->schib.pmcw.isc) != 0)
1091 /* Couldn't enable the subchannel for i/o. Sick device. */
1092 return;
1093
1094 /* After 60s the device recognition is considered to have failed. */
1095 ccw_device_set_timeout(cdev, 60*HZ);
1096
1097 cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID;
1098 ccw_device_sense_id_start(cdev);
1099}
1100
1101void
1102device_trigger_reprobe(struct subchannel *sch)
1103{
1104 struct ccw_device *cdev;
1105
1106 if (!sch->dev.driver_data)
1107 return;
1108 cdev = sch->dev.driver_data;
1109 if (cdev->private->state != DEV_STATE_DISCONNECTED)
1110 return;
1111
1112 /* Update some values. */
a8237fc4 1113 if (stsch(sch->schid, &sch->schib))
1da177e4 1114 return;
7674da77
CH		 1115 if (!sch->schib.pmcw.dnv)
1116 return;
1da177e4
LT		 1117 /*
1118 * The pim, pam, pom values may not be accurate, but they are the best
1119 * we have before performing device selection :/
1120 */
28bdc6f6 1121 sch->lpm = sch->schib.pmcw.pam & sch->opm;
1da177e4
LT		 1122 /* Re-set some bits in the pmcw that were lost. */
1123 sch->schib.pmcw.isc = 3;
1124 sch->schib.pmcw.csense = 1;
1125 sch->schib.pmcw.ena = 0;
1126 if ((sch->lpm & (sch->lpm - 1)) != 0)
1127 sch->schib.pmcw.mp = 1;
1128 sch->schib.pmcw.intparm = (__u32)(unsigned long)sch;
1129 /* We should also udate ssd info, but this has to wait. */
d7b5a4c9
CH		 1130 /* Check if this is another device which appeared on the same sch. */
1131 if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
1132 PREPARE_WORK(&cdev->private->kick_work,
1133 ccw_device_move_to_orphanage);
1134 queue_work(ccw_device_work, &cdev->private->kick_work);
1135 } else
1136 ccw_device_start_id(cdev, 0);
1da177e4
LT		 1137}
1138
1139static void
1140ccw_device_offline_irq(struct ccw_device *cdev, enum dev_event dev_event)
1141{
1142 struct subchannel *sch;
1143
1144 sch = to_subchannel(cdev->dev.parent);
1145 /*
1146 * An interrupt in state offline means a previous disable was not
1147 * successful. Try again.
1148 */
1149 cio_disable_subchannel(sch);
1150}
1151
1152static void
1153ccw_device_change_cmfstate(struct ccw_device *cdev, enum dev_event dev_event)
1154{
1155 retry_set_schib(cdev);
1156 cdev->private->state = DEV_STATE_ONLINE;
1157 dev_fsm_event(cdev, dev_event);
1158}
1159
94bb0633
CH		 1160static void ccw_device_update_cmfblock(struct ccw_device *cdev,
1161 enum dev_event dev_event)
1162{
1163 cmf_retry_copy_block(cdev);
1164 cdev->private->state = DEV_STATE_ONLINE;
1165 dev_fsm_event(cdev, dev_event);
1166}
1da177e4
LT		 1167
1168static void
1169ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event)
1170{
1171 ccw_device_set_timeout(cdev, 0);
1172 if (dev_event == DEV_EVENT_NOTOPER)
1173 cdev->private->state = DEV_STATE_NOT_OPER;
1174 else
1175 cdev->private->state = DEV_STATE_OFFLINE;
1176 wake_up(&cdev->private->wait_q);
1177}
1178
1179static void
1180ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event)
1181{
1182 int ret;
1183
1184 ret = ccw_device_cancel_halt_clear(cdev);
1185 switch (ret) {
1186 case 0:
1187 cdev->private->state = DEV_STATE_OFFLINE;
1188 wake_up(&cdev->private->wait_q);
1189 break;
1190 case -ENODEV:
1191 cdev->private->state = DEV_STATE_NOT_OPER;
1192 wake_up(&cdev->private->wait_q);
1193 break;
1194 default:
1195 ccw_device_set_timeout(cdev, HZ/10);
1196 }
1197}
1198
1199/*
1200 * No operation action. This is used e.g. to ignore a timeout event in
1201 * state offline.
1202 */
1203static void
1204ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
1205{
1206}
1207
1208/*
1209 * Bug operation action.
1210 */
1211static void
1212ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event)
1213{
1214 printk(KERN_EMERG "dev_jumptable[%i][%i] == NULL\n",
1215 cdev->private->state, dev_event);
1216 BUG();
1217}
1218
1219/*
1220 * device statemachine
1221 */
1222fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
1223 [DEV_STATE_NOT_OPER] = {
1224 [DEV_EVENT_NOTOPER] = ccw_device_nop,
1225 [DEV_EVENT_INTERRUPT] = ccw_device_bug,
1226 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1227 [DEV_EVENT_VERIFY] = ccw_device_nop,
1228 },
1229 [DEV_STATE_SENSE_PGID] = {
1230 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
1231 [DEV_EVENT_INTERRUPT] = ccw_device_sense_pgid_irq,
1232 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
1233 [DEV_EVENT_VERIFY] = ccw_device_nop,
1234 },
1235 [DEV_STATE_SENSE_ID] = {
1236 [DEV_EVENT_NOTOPER] = ccw_device_recog_notoper,
1237 [DEV_EVENT_INTERRUPT] = ccw_device_sense_id_irq,
1238 [DEV_EVENT_TIMEOUT] = ccw_device_recog_timeout,
1239 [DEV_EVENT_VERIFY] = ccw_device_nop,
1240 },
1241 [DEV_STATE_OFFLINE] = {
1242 [DEV_EVENT_NOTOPER] = ccw_device_offline_notoper,
1243 [DEV_EVENT_INTERRUPT] = ccw_device_offline_irq,
1244 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1245 [DEV_EVENT_VERIFY] = ccw_device_nop,
1246 },
1247 [DEV_STATE_VERIFY] = {
1248 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
1249 [DEV_EVENT_INTERRUPT] = ccw_device_verify_irq,
1250 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
28bdc6f6 1251 [DEV_EVENT_VERIFY] = ccw_device_delay_verify,
1da177e4
LT		 1252 },
1253 [DEV_STATE_ONLINE] = {
1254 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
1255 [DEV_EVENT_INTERRUPT] = ccw_device_irq,
1256 [DEV_EVENT_TIMEOUT] = ccw_device_online_timeout,
1257 [DEV_EVENT_VERIFY] = ccw_device_online_verify,
1258 },
1259 [DEV_STATE_W4SENSE] = {
1260 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
1261 [DEV_EVENT_INTERRUPT] = ccw_device_w4sense,
1262 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1263 [DEV_EVENT_VERIFY] = ccw_device_online_verify,
1264 },
1265 [DEV_STATE_DISBAND_PGID] = {
1266 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
1267 [DEV_EVENT_INTERRUPT] = ccw_device_disband_irq,
1268 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
1269 [DEV_EVENT_VERIFY] = ccw_device_nop,
1270 },
1271 [DEV_STATE_BOXED] = {
1272 [DEV_EVENT_NOTOPER] = ccw_device_offline_notoper,
1273 [DEV_EVENT_INTERRUPT] = ccw_device_stlck_done,
1274 [DEV_EVENT_TIMEOUT] = ccw_device_stlck_done,
1275 [DEV_EVENT_VERIFY] = ccw_device_nop,
1276 },
1277 /* states to wait for i/o completion before doing something */
1278 [DEV_STATE_CLEAR_VERIFY] = {
1279 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
1280 [DEV_EVENT_INTERRUPT] = ccw_device_clear_verify,
1281 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1282 [DEV_EVENT_VERIFY] = ccw_device_nop,
1283 },
1284 [DEV_STATE_TIMEOUT_KILL] = {
1285 [DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
1286 [DEV_EVENT_INTERRUPT] = ccw_device_killing_irq,
1287 [DEV_EVENT_TIMEOUT] = ccw_device_killing_timeout,
1288 [DEV_EVENT_VERIFY] = ccw_device_nop, //FIXME
1289 },
1da177e4
LT		 1290 [DEV_STATE_QUIESCE] = {
1291 [DEV_EVENT_NOTOPER] = ccw_device_quiesce_done,
1292 [DEV_EVENT_INTERRUPT] = ccw_device_quiesce_done,
1293 [DEV_EVENT_TIMEOUT] = ccw_device_quiesce_timeout,
1294 [DEV_EVENT_VERIFY] = ccw_device_nop,
1295 },
1296 /* special states for devices gone not operational */
1297 [DEV_STATE_DISCONNECTED] = {
1298 [DEV_EVENT_NOTOPER] = ccw_device_nop,
1299 [DEV_EVENT_INTERRUPT] = ccw_device_start_id,
1300 [DEV_EVENT_TIMEOUT] = ccw_device_bug,
28bdc6f6 1301 [DEV_EVENT_VERIFY] = ccw_device_start_id,
1da177e4
LT		 1302 },
1303 [DEV_STATE_DISCONNECTED_SENSE_ID] = {
1304 [DEV_EVENT_NOTOPER] = ccw_device_recog_notoper,
1305 [DEV_EVENT_INTERRUPT] = ccw_device_sense_id_irq,
1306 [DEV_EVENT_TIMEOUT] = ccw_device_recog_timeout,
1307 [DEV_EVENT_VERIFY] = ccw_device_nop,
1308 },
1309 [DEV_STATE_CMFCHANGE] = {
1310 [DEV_EVENT_NOTOPER] = ccw_device_change_cmfstate,
1311 [DEV_EVENT_INTERRUPT] = ccw_device_change_cmfstate,
1312 [DEV_EVENT_TIMEOUT] = ccw_device_change_cmfstate,
1313 [DEV_EVENT_VERIFY] = ccw_device_change_cmfstate,
1314 },
94bb0633
CH		 1315 [DEV_STATE_CMFUPDATE] = {
1316 [DEV_EVENT_NOTOPER] = ccw_device_update_cmfblock,
1317 [DEV_EVENT_INTERRUPT] = ccw_device_update_cmfblock,
1318 [DEV_EVENT_TIMEOUT] = ccw_device_update_cmfblock,
1319 [DEV_EVENT_VERIFY] = ccw_device_update_cmfblock,
1320 },
1da177e4
LT		 1321};
1322
1323/*
1324 * io_subchannel_irq is called for "real" interrupts or for status
1325 * pending conditions on msch.
1326 */
1327void
1328io_subchannel_irq (struct device *pdev)
1329{
1330 struct ccw_device *cdev;
1331
1332 cdev = to_subchannel(pdev)->dev.driver_data;
1333
1334 CIO_TRACE_EVENT (3, "IRQ");
1335 CIO_TRACE_EVENT (3, pdev->bus_id);
1336 if (cdev)
1337 dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);
1338}
1339
1340EXPORT_SYMBOL_GPL(ccw_device_set_timeout);
Linux 6.x block layer and io_uring tree(s)