projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[deliverable/linux.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>
e5854a58 18#include <asm/chpid.h>
1da177e4
LT		 19
20#include "cio.h"
21#include "cio_debug.h"
22#include "css.h"
23#include "device.h"
24#include "chsc.h"
25#include "ioasm.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];
83b3370c
PO		 225 if (!chp_is_registered(chpid))
226 css_schedule_eval_all();
1da177e4
LT		 227 }
228}
229
230/*
231 * Stop device recognition.
232 */
233static void
234ccw_device_recog_done(struct ccw_device *cdev, int state)
235{
236 struct subchannel *sch;
237 int notify, old_lpm, same_dev;
238
239 sch = to_subchannel(cdev->dev.parent);
240
241 ccw_device_set_timeout(cdev, 0);
242 cio_disable_subchannel(sch);
243 /*
244 * Now that we tried recognition, we have performed device selection
245 * through ssch() and the path information is up to date.
246 */
247 old_lpm = sch->lpm;
a8237fc4 248 stsch(sch->schid, &sch->schib);
28bdc6f6 249 sch->lpm = sch->schib.pmcw.pam & sch->opm;
4ffa9234
CH		 250 /* Check since device may again have become not operational. */
251 if (!sch->schib.pmcw.dnv)
252 state = DEV_STATE_NOT_OPER;
1da177e4
LT		 253 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID)
254 /* Force reprobe on all chpids. */
255 old_lpm = 0;
256 if (sch->lpm != old_lpm)
257 __recover_lost_chpids(sch, old_lpm);
258 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
259 if (state == DEV_STATE_NOT_OPER) {
260 cdev->private->flags.recog_done = 1;
261 cdev->private->state = DEV_STATE_DISCONNECTED;
262 return;
263 }
264 /* Boxed devices don't need extra treatment. */
265 }
266 notify = 0;
267 same_dev = 0; /* Keep the compiler quiet... */
268 switch (state) {
269 case DEV_STATE_NOT_OPER:
270 CIO_DEBUG(KERN_WARNING, 2,
e556bbbd 271 "cio: SenseID : unknown device %04x on subchannel "
78964268 272 "0.%x.%04x\n", cdev->private->dev_id.devno,
fb6958a5 273 sch->schid.ssid, sch->schid.sch_no);
1da177e4
LT		 274 break;
275 case DEV_STATE_OFFLINE:
276 if (cdev->private->state == DEV_STATE_DISCONNECTED_SENSE_ID) {
277 same_dev = ccw_device_handle_oper(cdev);
278 notify = 1;
279 }
280 /* fill out sense information */
81388d2a 281 memset(&cdev->id, 0, sizeof(cdev->id));
292888c8
HC		 282 cdev->id.cu_type = cdev->private->senseid.cu_type;
283 cdev->id.cu_model = cdev->private->senseid.cu_model;
284 cdev->id.dev_type = cdev->private->senseid.dev_type;
285 cdev->id.dev_model = cdev->private->senseid.dev_model;
1da177e4
LT		 286 if (notify) {
287 cdev->private->state = DEV_STATE_OFFLINE;
288 if (same_dev) {
289 /* Get device online again. */
290 ccw_device_online(cdev);
291 wake_up(&cdev->private->wait_q);
292 }
293 return;
294 }
295 /* Issue device info message. */
e556bbbd
CH		 296 CIO_DEBUG(KERN_INFO, 2,
297 "cio: SenseID : device 0.%x.%04x reports: "
1da177e4 298 "CU Type/Mod = %04X/%02X, Dev Type/Mod = "
fb6958a5 299 "%04X/%02X\n",
78964268
CH		 300 cdev->private->dev_id.ssid,
301 cdev->private->dev_id.devno,
1da177e4
LT		 302 cdev->id.cu_type, cdev->id.cu_model,
303 cdev->id.dev_type, cdev->id.dev_model);
304 break;
305 case DEV_STATE_BOXED:
306 CIO_DEBUG(KERN_WARNING, 2,
e556bbbd 307 "cio: SenseID : boxed device %04x on subchannel "
78964268 308 "0.%x.%04x\n", cdev->private->dev_id.devno,
fb6958a5 309 sch->schid.ssid, sch->schid.sch_no);
1da177e4
LT		 310 break;
311 }
312 cdev->private->state = state;
313 io_subchannel_recog_done(cdev);
314 if (state != DEV_STATE_NOT_OPER)
315 wake_up(&cdev->private->wait_q);
316}
317
318/*
319 * Function called from device_id.c after sense id has completed.
320 */
321void
322ccw_device_sense_id_done(struct ccw_device *cdev, int err)
323{
324 switch (err) {
325 case 0:
326 ccw_device_recog_done(cdev, DEV_STATE_OFFLINE);
327 break;
328 case -ETIME: /* Sense id stopped by timeout. */
329 ccw_device_recog_done(cdev, DEV_STATE_BOXED);
330 break;
331 default:
332 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
333 break;
334 }
335}
336
337static void
c1637532 338ccw_device_oper_notify(struct work_struct *work)
1da177e4 339{
c1637532 340 struct ccw_device_private *priv;
1da177e4
LT		 341 struct ccw_device *cdev;
342 struct subchannel *sch;
343 int ret;
ee04bbcc 344 unsigned long flags;
1da177e4 345
c1637532
MS		 346 priv = container_of(work, struct ccw_device_private, kick_work);
347 cdev = priv->cdev;
ee04bbcc 348 spin_lock_irqsave(cdev->ccwlock, flags);
1da177e4 349 sch = to_subchannel(cdev->dev.parent);
ee04bbcc
CH		 350 if (sch->driver && sch->driver->notify) {
351 spin_unlock_irqrestore(cdev->ccwlock, flags);
352 ret = sch->driver->notify(&sch->dev, CIO_OPER);
353 spin_lock_irqsave(cdev->ccwlock, flags);
354 } else
355 ret = 0;
356 if (ret) {
94bb0633 357 /* Reenable channel measurements, if needed. */
ee04bbcc 358 spin_unlock_irqrestore(cdev->ccwlock, flags);
94bb0633 359 cmf_reenable(cdev);
ee04bbcc 360 spin_lock_irqsave(cdev->ccwlock, flags);
1da177e4 361 wake_up(&cdev->private->wait_q);
94bb0633 362 }
ee04bbcc
CH		 363 spin_unlock_irqrestore(cdev->ccwlock, flags);
364 if (!ret)
365 /* Driver doesn't want device back. */
366 ccw_device_do_unreg_rereg(work);
1da177e4
LT		 367}
368
369/*
370 * Finished with online/offline processing.
371 */
372static void
373ccw_device_done(struct ccw_device *cdev, int state)
374{
375 struct subchannel *sch;
376
377 sch = to_subchannel(cdev->dev.parent);
378
f1ee3281
CH		 379 ccw_device_set_timeout(cdev, 0);
380
1da177e4
LT		 381 if (state != DEV_STATE_ONLINE)
382 cio_disable_subchannel(sch);
383
384 /* Reset device status. */
385 memset(&cdev->private->irb, 0, sizeof(struct irb));
386
387 cdev->private->state = state;
388
389
390 if (state == DEV_STATE_BOXED)
391 CIO_DEBUG(KERN_WARNING, 2,
e556bbbd 392 "cio: Boxed device %04x on subchannel %04x\n",
78964268 393 cdev->private->dev_id.devno, sch->schid.sch_no);
1da177e4
LT		 394
395 if (cdev->private->flags.donotify) {
396 cdev->private->flags.donotify = 0;
c1637532 397 PREPARE_WORK(&cdev->private->kick_work, ccw_device_oper_notify);
1da177e4
LT		 398 queue_work(ccw_device_notify_work, &cdev->private->kick_work);
399 }
400 wake_up(&cdev->private->wait_q);
401
402 if (css_init_done && state != DEV_STATE_ONLINE)
403 put_device (&cdev->dev);
404}
405
4d284cac 406static int cmp_pgid(struct pgid *p1, struct pgid *p2)
7e560814
CH		 407{
408 char *c1;
409 char *c2;
410
411 c1 = (char *)p1;
412 c2 = (char *)p2;
413
414 return memcmp(c1 + 1, c2 + 1, sizeof(struct pgid) - 1);
415}
416
417static void __ccw_device_get_common_pgid(struct ccw_device *cdev)
418{
419 int i;
420 int last;
421
422 last = 0;
423 for (i = 0; i < 8; i++) {
424 if (cdev->private->pgid[i].inf.ps.state1 == SNID_STATE1_RESET)
425 /* No PGID yet */
426 continue;
427 if (cdev->private->pgid[last].inf.ps.state1 ==
428 SNID_STATE1_RESET) {
429 /* First non-zero PGID */
430 last = i;
431 continue;
432 }
433 if (cmp_pgid(&cdev->private->pgid[i],
434 &cdev->private->pgid[last]) == 0)
435 /* Non-conflicting PGIDs */
436 continue;
437
438 /* PGID mismatch, can't pathgroup. */
439 CIO_MSG_EVENT(0, "SNID - pgid mismatch for device "
440 "0.%x.%04x, can't pathgroup\n",
78964268
CH		 441 cdev->private->dev_id.ssid,
442 cdev->private->dev_id.devno);
7e560814
CH		 443 cdev->private->options.pgroup = 0;
444 return;
445 }
446 if (cdev->private->pgid[last].inf.ps.state1 ==
447 SNID_STATE1_RESET)
448 /* No previous pgid found */
7c9f4e3a
CH		 449 memcpy(&cdev->private->pgid[0],
450 &channel_subsystems[0]->global_pgid,
7e560814
CH		 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
1da177e4
LT		 547void
548ccw_device_verify_done(struct ccw_device *cdev, int err)
549{
28bdc6f6
PO		 550 struct subchannel *sch;
551
552 sch = to_subchannel(cdev->dev.parent);
553 /* Update schib - pom may have changed. */
554 stsch(sch->schid, &sch->schib);
555 /* Update lpm with verified path mask. */
556 sch->lpm = sch->vpm;
557 /* Repeat path verification? */
558 if (cdev->private->flags.doverify) {
559 cdev->private->flags.doverify = 0;
560 ccw_device_verify_start(cdev);
561 return;
562 }
1da177e4
LT		 563 switch (err) {
564 case -EOPNOTSUPP: /* path grouping not supported, just set online. */
565 cdev->private->options.pgroup = 0;
566 case 0:
567 ccw_device_done(cdev, DEV_STATE_ONLINE);
568 /* Deliver fake irb to device driver, if needed. */
569 if (cdev->private->flags.fake_irb) {
570 memset(&cdev->private->irb, 0, sizeof(struct irb));
292888c8
HC		 571 cdev->private->irb.scsw.cc = 1;
572 cdev->private->irb.scsw.fctl = SCSW_FCTL_START_FUNC;
573 cdev->private->irb.scsw.actl = SCSW_ACTL_START_PEND;
574 cdev->private->irb.scsw.stctl = SCSW_STCTL_STATUS_PEND;
1da177e4
LT		 575 cdev->private->flags.fake_irb = 0;
576 if (cdev->handler)
577 cdev->handler(cdev, cdev->private->intparm,
578 &cdev->private->irb);
579 memset(&cdev->private->irb, 0, sizeof(struct irb));
580 }
581 break;
582 case -ETIME:
8b42f5c2
PO		 583 /* Reset oper notify indication after verify error. */
584 cdev->private->flags.donotify = 0;
1da177e4
LT		 585 ccw_device_done(cdev, DEV_STATE_BOXED);
586 break;
587 default:
8b42f5c2
PO		 588 /* Reset oper notify indication after verify error. */
589 cdev->private->flags.donotify = 0;
3f4cf6e7
CH		 590 if (cdev->online)
591 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
592 else
ee04bbcc 593 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
1da177e4
LT		 594 break;
595 }
596}
597
598/*
599 * Get device online.
600 */
601int
602ccw_device_online(struct ccw_device *cdev)
603{
604 struct subchannel *sch;
605 int ret;
606
607 if ((cdev->private->state != DEV_STATE_OFFLINE) &&
608 (cdev->private->state != DEV_STATE_BOXED))
609 return -EINVAL;
610 sch = to_subchannel(cdev->dev.parent);
611 if (css_init_done && !get_device(&cdev->dev))
612 return -ENODEV;
613 ret = cio_enable_subchannel(sch, sch->schib.pmcw.isc);
614 if (ret != 0) {
615 /* Couldn't enable the subchannel for i/o. Sick device. */
616 if (ret == -ENODEV)
617 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
618 return ret;
619 }
620 /* Do we want to do path grouping? */
621 if (!cdev->private->options.pgroup) {
7e560814
CH		 622 /* Start initial path verification. */
623 cdev->private->state = DEV_STATE_VERIFY;
28bdc6f6 624 cdev->private->flags.doverify = 0;
7e560814 625 ccw_device_verify_start(cdev);
1da177e4
LT		 626 return 0;
627 }
628 /* Do a SensePGID first. */
629 cdev->private->state = DEV_STATE_SENSE_PGID;
630 ccw_device_sense_pgid_start(cdev);
631 return 0;
632}
633
634void
635ccw_device_disband_done(struct ccw_device *cdev, int err)
636{
637 switch (err) {
638 case 0:
639 ccw_device_done(cdev, DEV_STATE_OFFLINE);
640 break;
641 case -ETIME:
642 ccw_device_done(cdev, DEV_STATE_BOXED);
643 break;
644 default:
3ecb0a5a 645 cdev->private->flags.donotify = 0;
3f4cf6e7 646 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
1da177e4
LT		 647 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
648 break;
649 }
650}
651
652/*
653 * Shutdown device.
654 */
655int
656ccw_device_offline(struct ccw_device *cdev)
657{
658 struct subchannel *sch;
659
d7b5a4c9
CH		 660 if (ccw_device_is_orphan(cdev)) {
661 ccw_device_done(cdev, DEV_STATE_OFFLINE);
662 return 0;
663 }
1da177e4 664 sch = to_subchannel(cdev->dev.parent);
a8237fc4 665 if (stsch(sch->schid, &sch->schib) || !sch->schib.pmcw.dnv)
1da177e4
LT		 666 return -ENODEV;
667 if (cdev->private->state != DEV_STATE_ONLINE) {
668 if (sch->schib.scsw.actl != 0)
669 return -EBUSY;
670 return -EINVAL;
671 }
672 if (sch->schib.scsw.actl != 0)
673 return -EBUSY;
674 /* Are we doing path grouping? */
675 if (!cdev->private->options.pgroup) {
676 /* No, set state offline immediately. */
677 ccw_device_done(cdev, DEV_STATE_OFFLINE);
678 return 0;
679 }
680 /* Start Set Path Group commands. */
681 cdev->private->state = DEV_STATE_DISBAND_PGID;
682 ccw_device_disband_start(cdev);
683 return 0;
684}
685
686/*
687 * Handle timeout in device online/offline process.
688 */
689static void
690ccw_device_onoff_timeout(struct ccw_device *cdev, enum dev_event dev_event)
691{
692 int ret;
693
694 ret = ccw_device_cancel_halt_clear(cdev);
695 switch (ret) {
696 case 0:
697 ccw_device_done(cdev, DEV_STATE_BOXED);
698 break;
699 case -ENODEV:
700 ccw_device_done(cdev, DEV_STATE_NOT_OPER);
701 break;
702 default:
703 ccw_device_set_timeout(cdev, 3*HZ);
704 }
705}
706
707/*
708 * Handle not oper event in device recognition.
709 */
710static void
711ccw_device_recog_notoper(struct ccw_device *cdev, enum dev_event dev_event)
712{
713 ccw_device_recog_done(cdev, DEV_STATE_NOT_OPER);
714}
715
716/*
3f4cf6e7 717 * Handle not operational event in non-special state.
1da177e4 718 */
3f4cf6e7
CH		 719static void ccw_device_generic_notoper(struct ccw_device *cdev,
720 enum dev_event dev_event)
1da177e4
LT		 721{
722 struct subchannel *sch;
723
724 cdev->private->state = DEV_STATE_NOT_OPER;
725 sch = to_subchannel(cdev->dev.parent);
3f4cf6e7 726 css_schedule_eval(sch->schid);
1da177e4
LT		 727}
728
729/*
730 * Handle path verification event.
731 */
732static void
733ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
734{
735 struct subchannel *sch;
736
1da177e4
LT		 737 if (cdev->private->state == DEV_STATE_W4SENSE) {
738 cdev->private->flags.doverify = 1;
739 return;
740 }
741 sch = to_subchannel(cdev->dev.parent);
742 /*
743 * Since we might not just be coming from an interrupt from the
744 * subchannel we have to update the schib.
745 */
a8237fc4 746 stsch(sch->schid, &sch->schib);
1da177e4
LT		 747
748 if (sch->schib.scsw.actl != 0 ||
65200c29 749 (sch->schib.scsw.stctl & SCSW_STCTL_STATUS_PEND) ||
1da177e4
LT		 750 (cdev->private->irb.scsw.stctl & SCSW_STCTL_STATUS_PEND)) {
751 /*
752 * No final status yet or final status not yet delivered
753 * to the device driver. Can't do path verfication now,
754 * delay until final status was delivered.
755 */
756 cdev->private->flags.doverify = 1;
757 return;
758 }
759 /* Device is idle, we can do the path verification. */
760 cdev->private->state = DEV_STATE_VERIFY;
28bdc6f6 761 cdev->private->flags.doverify = 0;
1da177e4
LT		 762 ccw_device_verify_start(cdev);
763}
764
765/*
766 * Got an interrupt for a normal io (state online).
767 */
768static void
769ccw_device_irq(struct ccw_device *cdev, enum dev_event dev_event)
770{
771 struct irb *irb;
772
773 irb = (struct irb *) __LC_IRB;
774 /* Check for unsolicited interrupt. */
775 if ((irb->scsw.stctl ==
776 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS))
777 && (!irb->scsw.cc)) {
778 if ((irb->scsw.dstat & DEV_STAT_UNIT_CHECK) &&
779 !irb->esw.esw0.erw.cons) {
780 /* Unit check but no sense data. Need basic sense. */
781 if (ccw_device_do_sense(cdev, irb) != 0)
782 goto call_handler_unsol;
e0ec5749 783 memcpy(&cdev->private->irb, irb, sizeof(struct irb));
1da177e4
LT		 784 cdev->private->state = DEV_STATE_W4SENSE;
785 cdev->private->intparm = 0;
786 return;
787 }
788call_handler_unsol:
789 if (cdev->handler)
790 cdev->handler (cdev, 0, irb);
18374d37
CH		 791 if (cdev->private->flags.doverify)
792 ccw_device_online_verify(cdev, 0);
1da177e4
LT		 793 return;
794 }
795 /* Accumulate status and find out if a basic sense is needed. */
796 ccw_device_accumulate_irb(cdev, irb);
797 if (cdev->private->flags.dosense) {
798 if (ccw_device_do_sense(cdev, irb) == 0) {
799 cdev->private->state = DEV_STATE_W4SENSE;
800 }
801 return;
802 }
803 /* Call the handler. */
804 if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
805 /* Start delayed path verification. */
806 ccw_device_online_verify(cdev, 0);
807}
808
809/*
810 * Got an timeout in online state.
811 */
812static void
813ccw_device_online_timeout(struct ccw_device *cdev, enum dev_event dev_event)
814{
815 int ret;
816
817 ccw_device_set_timeout(cdev, 0);
818 ret = ccw_device_cancel_halt_clear(cdev);
819 if (ret == -EBUSY) {
820 ccw_device_set_timeout(cdev, 3*HZ);
821 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
822 return;
823 }
3f4cf6e7
CH		 824 if (ret == -ENODEV)
825 dev_fsm_event(cdev, DEV_EVENT_NOTOPER);
826 else if (cdev->handler)
1da177e4
LT		 827 cdev->handler(cdev, cdev->private->intparm,
828 ERR_PTR(-ETIMEDOUT));
829}
830
831/*
832 * Got an interrupt for a basic sense.
833 */
2b67fc46 834static void
1da177e4
LT		 835ccw_device_w4sense(struct ccw_device *cdev, enum dev_event dev_event)
836{
837 struct irb *irb;
838
839 irb = (struct irb *) __LC_IRB;
840 /* Check for unsolicited interrupt. */
841 if (irb->scsw.stctl ==
842 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) {
843 if (irb->scsw.cc == 1)
844 /* Basic sense hasn't started. Try again. */
845 ccw_device_do_sense(cdev, irb);
846 else {
e556bbbd
CH		 847 CIO_MSG_EVENT(2, "Huh? 0.%x.%04x: unsolicited "
848 "interrupt during w4sense...\n",
849 cdev->private->dev_id.ssid,
850 cdev->private->dev_id.devno);
1da177e4
LT		 851 if (cdev->handler)
852 cdev->handler (cdev, 0, irb);
853 }
854 return;
855 }
3ba1998e
CH		 856 /*
857 * Check if a halt or clear has been issued in the meanwhile. If yes,
858 * only deliver the halt/clear interrupt to the device driver as if it
859 * had killed the original request.
860 */
861 if (irb->scsw.fctl & (SCSW_FCTL_CLEAR_FUNC | SCSW_FCTL_HALT_FUNC)) {
d23861ff
CH		 862 /* Retry Basic Sense if requested. */
863 if (cdev->private->flags.intretry) {
864 cdev->private->flags.intretry = 0;
865 ccw_device_do_sense(cdev, irb);
866 return;
867 }
3ba1998e
CH		 868 cdev->private->flags.dosense = 0;
869 memset(&cdev->private->irb, 0, sizeof(struct irb));
870 ccw_device_accumulate_irb(cdev, irb);
871 goto call_handler;
872 }
1da177e4
LT		 873 /* Add basic sense info to irb. */
874 ccw_device_accumulate_basic_sense(cdev, irb);
875 if (cdev->private->flags.dosense) {
876 /* Another basic sense is needed. */
877 ccw_device_do_sense(cdev, irb);
878 return;
879 }
3ba1998e 880call_handler:
1da177e4
LT		 881 cdev->private->state = DEV_STATE_ONLINE;
882 /* Call the handler. */
883 if (ccw_device_call_handler(cdev) && cdev->private->flags.doverify)
884 /* Start delayed path verification. */
885 ccw_device_online_verify(cdev, 0);
886}
887
888static void
889ccw_device_clear_verify(struct ccw_device *cdev, enum dev_event dev_event)
890{
891 struct irb *irb;
892
893 irb = (struct irb *) __LC_IRB;
894 /* Accumulate status. We don't do basic sense. */
895 ccw_device_accumulate_irb(cdev, irb);
b4f7b1ee
CH		 896 /* Remember to clear irb to avoid residuals. */
897 memset(&cdev->private->irb, 0, sizeof(struct irb));
1da177e4
LT		 898 /* Try to start delayed device verification. */
899 ccw_device_online_verify(cdev, 0);
900 /* Note: Don't call handler for cio initiated clear! */
901}
902
903static void
904ccw_device_killing_irq(struct ccw_device *cdev, enum dev_event dev_event)
905{
906 struct subchannel *sch;
907
908 sch = to_subchannel(cdev->dev.parent);
909 ccw_device_set_timeout(cdev, 0);
7c8427c3
CH		 910 /* Start delayed path verification. */
911 ccw_device_online_verify(cdev, 0);
1da177e4 912 /* OK, i/o is dead now. Call interrupt handler. */
1da177e4
LT		 913 if (cdev->handler)
914 cdev->handler(cdev, cdev->private->intparm,
e7769b48 915 ERR_PTR(-EIO));
1da177e4
LT		 916}
917
918static void
919ccw_device_killing_timeout(struct ccw_device *cdev, enum dev_event dev_event)
920{
921 int ret;
922
923 ret = ccw_device_cancel_halt_clear(cdev);
924 if (ret == -EBUSY) {
925 ccw_device_set_timeout(cdev, 3*HZ);
926 return;
927 }
7c8427c3
CH		 928 /* Start delayed path verification. */
929 ccw_device_online_verify(cdev, 0);
1da177e4
LT		 930 if (cdev->handler)
931 cdev->handler(cdev, cdev->private->intparm,
e7769b48 932 ERR_PTR(-EIO));
1da177e4
LT		 933}
934
e7769b48 935void device_kill_io(struct subchannel *sch)
1da177e4
LT		 936{
937 int ret;
e7769b48 938 struct ccw_device *cdev;
1da177e4 939
e7769b48 940 cdev = sch->dev.driver_data;
1da177e4
LT		 941 ret = ccw_device_cancel_halt_clear(cdev);
942 if (ret == -EBUSY) {
943 ccw_device_set_timeout(cdev, 3*HZ);
944 cdev->private->state = DEV_STATE_TIMEOUT_KILL;
945 return;
946 }
7c8427c3
CH		 947 /* Start delayed path verification. */
948 ccw_device_online_verify(cdev, 0);
1da177e4
LT		 949 if (cdev->handler)
950 cdev->handler(cdev, cdev->private->intparm,
e7769b48 951 ERR_PTR(-EIO));
1da177e4
LT		 952}
953
954static void
28bdc6f6 955ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
1da177e4 956{
28bdc6f6 957 /* Start verification after current task finished. */
7e560814 958 cdev->private->flags.doverify = 1;
1da177e4
LT		 959}
960
961static void
962ccw_device_stlck_done(struct ccw_device *cdev, enum dev_event dev_event)
963{
964 struct irb *irb;
965
966 switch (dev_event) {
967 case DEV_EVENT_INTERRUPT:
968 irb = (struct irb *) __LC_IRB;
969 /* Check for unsolicited interrupt. */
970 if ((irb->scsw.stctl ==
971 (SCSW_STCTL_STATUS_PEND | SCSW_STCTL_ALERT_STATUS)) &&
972 (!irb->scsw.cc))
973 /* FIXME: we should restart stlck here, but this
974 * is extremely unlikely ... */
975 goto out_wakeup;
976
977 ccw_device_accumulate_irb(cdev, irb);
978 /* We don't care about basic sense etc. */
979 break;
980 default: /* timeout */
981 break;
982 }
983out_wakeup:
984 wake_up(&cdev->private->wait_q);
985}
986
987static void
988ccw_device_start_id(struct ccw_device *cdev, enum dev_event dev_event)
989{
990 struct subchannel *sch;
991
992 sch = to_subchannel(cdev->dev.parent);
993 if (cio_enable_subchannel(sch, sch->schib.pmcw.isc) != 0)
994 /* Couldn't enable the subchannel for i/o. Sick device. */
995 return;
996
997 /* After 60s the device recognition is considered to have failed. */
998 ccw_device_set_timeout(cdev, 60*HZ);
999
1000 cdev->private->state = DEV_STATE_DISCONNECTED_SENSE_ID;
1001 ccw_device_sense_id_start(cdev);
1002}
1003
1004void
1005device_trigger_reprobe(struct subchannel *sch)
1006{
1007 struct ccw_device *cdev;
1008
1009 if (!sch->dev.driver_data)
1010 return;
1011 cdev = sch->dev.driver_data;
1012 if (cdev->private->state != DEV_STATE_DISCONNECTED)
1013 return;
1014
1015 /* Update some values. */
a8237fc4 1016 if (stsch(sch->schid, &sch->schib))
1da177e4 1017 return;
7674da77
CH		 1018 if (!sch->schib.pmcw.dnv)
1019 return;
1da177e4
LT		 1020 /*
1021 * The pim, pam, pom values may not be accurate, but they are the best
1022 * we have before performing device selection :/
1023 */
28bdc6f6 1024 sch->lpm = sch->schib.pmcw.pam & sch->opm;
1da177e4
LT		 1025 /* Re-set some bits in the pmcw that were lost. */
1026 sch->schib.pmcw.isc = 3;
1027 sch->schib.pmcw.csense = 1;
1028 sch->schib.pmcw.ena = 0;
1029 if ((sch->lpm & (sch->lpm - 1)) != 0)
1030 sch->schib.pmcw.mp = 1;
1031 sch->schib.pmcw.intparm = (__u32)(unsigned long)sch;
1032 /* We should also udate ssd info, but this has to wait. */
d7b5a4c9
CH		 1033 /* Check if this is another device which appeared on the same sch. */
1034 if (sch->schib.pmcw.dev != cdev->private->dev_id.devno) {
1035 PREPARE_WORK(&cdev->private->kick_work,
1036 ccw_device_move_to_orphanage);
1037 queue_work(ccw_device_work, &cdev->private->kick_work);
1038 } else
1039 ccw_device_start_id(cdev, 0);
1da177e4
LT		 1040}
1041
1042static void
1043ccw_device_offline_irq(struct ccw_device *cdev, enum dev_event dev_event)
1044{
1045 struct subchannel *sch;
1046
1047 sch = to_subchannel(cdev->dev.parent);
1048 /*
1049 * An interrupt in state offline means a previous disable was not
1050 * successful. Try again.
1051 */
1052 cio_disable_subchannel(sch);
1053}
1054
1055static void
1056ccw_device_change_cmfstate(struct ccw_device *cdev, enum dev_event dev_event)
1057{
1058 retry_set_schib(cdev);
1059 cdev->private->state = DEV_STATE_ONLINE;
1060 dev_fsm_event(cdev, dev_event);
1061}
1062
94bb0633
CH		 1063static void ccw_device_update_cmfblock(struct ccw_device *cdev,
1064 enum dev_event dev_event)
1065{
1066 cmf_retry_copy_block(cdev);
1067 cdev->private->state = DEV_STATE_ONLINE;
1068 dev_fsm_event(cdev, dev_event);
1069}
1da177e4
LT		 1070
1071static void
1072ccw_device_quiesce_done(struct ccw_device *cdev, enum dev_event dev_event)
1073{
1074 ccw_device_set_timeout(cdev, 0);
1075 if (dev_event == DEV_EVENT_NOTOPER)
1076 cdev->private->state = DEV_STATE_NOT_OPER;
1077 else
1078 cdev->private->state = DEV_STATE_OFFLINE;
1079 wake_up(&cdev->private->wait_q);
1080}
1081
1082static void
1083ccw_device_quiesce_timeout(struct ccw_device *cdev, enum dev_event dev_event)
1084{
1085 int ret;
1086
1087 ret = ccw_device_cancel_halt_clear(cdev);
1088 switch (ret) {
1089 case 0:
1090 cdev->private->state = DEV_STATE_OFFLINE;
1091 wake_up(&cdev->private->wait_q);
1092 break;
1093 case -ENODEV:
1094 cdev->private->state = DEV_STATE_NOT_OPER;
1095 wake_up(&cdev->private->wait_q);
1096 break;
1097 default:
1098 ccw_device_set_timeout(cdev, HZ/10);
1099 }
1100}
1101
1102/*
1103 * No operation action. This is used e.g. to ignore a timeout event in
1104 * state offline.
1105 */
1106static void
1107ccw_device_nop(struct ccw_device *cdev, enum dev_event dev_event)
1108{
1109}
1110
1111/*
1112 * Bug operation action.
1113 */
1114static void
1115ccw_device_bug(struct ccw_device *cdev, enum dev_event dev_event)
1116{
e556bbbd
CH		 1117 CIO_MSG_EVENT(0, "dev_jumptable[%i][%i] == NULL\n",
1118 cdev->private->state, dev_event);
1da177e4
LT		 1119 BUG();
1120}
1121
1122/*
1123 * device statemachine
1124 */
1125fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
1126 [DEV_STATE_NOT_OPER] = {
1127 [DEV_EVENT_NOTOPER] = ccw_device_nop,
1128 [DEV_EVENT_INTERRUPT] = ccw_device_bug,
1129 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1130 [DEV_EVENT_VERIFY] = ccw_device_nop,
1131 },
1132 [DEV_STATE_SENSE_PGID] = {
3f4cf6e7 1133 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1da177e4
LT		 1134 [DEV_EVENT_INTERRUPT] = ccw_device_sense_pgid_irq,
1135 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
1136 [DEV_EVENT_VERIFY] = ccw_device_nop,
1137 },
1138 [DEV_STATE_SENSE_ID] = {
1139 [DEV_EVENT_NOTOPER] = ccw_device_recog_notoper,
1140 [DEV_EVENT_INTERRUPT] = ccw_device_sense_id_irq,
1141 [DEV_EVENT_TIMEOUT] = ccw_device_recog_timeout,
1142 [DEV_EVENT_VERIFY] = ccw_device_nop,
1143 },
1144 [DEV_STATE_OFFLINE] = {
3f4cf6e7 1145 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1da177e4
LT		 1146 [DEV_EVENT_INTERRUPT] = ccw_device_offline_irq,
1147 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1148 [DEV_EVENT_VERIFY] = ccw_device_nop,
1149 },
1150 [DEV_STATE_VERIFY] = {
3f4cf6e7 1151 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1da177e4
LT		 1152 [DEV_EVENT_INTERRUPT] = ccw_device_verify_irq,
1153 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
28bdc6f6 1154 [DEV_EVENT_VERIFY] = ccw_device_delay_verify,
1da177e4
LT		 1155 },
1156 [DEV_STATE_ONLINE] = {
3f4cf6e7 1157 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1da177e4
LT		 1158 [DEV_EVENT_INTERRUPT] = ccw_device_irq,
1159 [DEV_EVENT_TIMEOUT] = ccw_device_online_timeout,
1160 [DEV_EVENT_VERIFY] = ccw_device_online_verify,
1161 },
1162 [DEV_STATE_W4SENSE] = {
3f4cf6e7 1163 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1da177e4
LT		 1164 [DEV_EVENT_INTERRUPT] = ccw_device_w4sense,
1165 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1166 [DEV_EVENT_VERIFY] = ccw_device_online_verify,
1167 },
1168 [DEV_STATE_DISBAND_PGID] = {
3f4cf6e7 1169 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1da177e4
LT		 1170 [DEV_EVENT_INTERRUPT] = ccw_device_disband_irq,
1171 [DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
1172 [DEV_EVENT_VERIFY] = ccw_device_nop,
1173 },
1174 [DEV_STATE_BOXED] = {
3f4cf6e7 1175 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1da177e4
LT		 1176 [DEV_EVENT_INTERRUPT] = ccw_device_stlck_done,
1177 [DEV_EVENT_TIMEOUT] = ccw_device_stlck_done,
1178 [DEV_EVENT_VERIFY] = ccw_device_nop,
1179 },
1180 /* states to wait for i/o completion before doing something */
1181 [DEV_STATE_CLEAR_VERIFY] = {
3f4cf6e7 1182 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1da177e4
LT		 1183 [DEV_EVENT_INTERRUPT] = ccw_device_clear_verify,
1184 [DEV_EVENT_TIMEOUT] = ccw_device_nop,
1185 [DEV_EVENT_VERIFY] = ccw_device_nop,
1186 },
1187 [DEV_STATE_TIMEOUT_KILL] = {
3f4cf6e7 1188 [DEV_EVENT_NOTOPER] = ccw_device_generic_notoper,
1da177e4
LT		 1189 [DEV_EVENT_INTERRUPT] = ccw_device_killing_irq,
1190 [DEV_EVENT_TIMEOUT] = ccw_device_killing_timeout,
1191 [DEV_EVENT_VERIFY] = ccw_device_nop, //FIXME
1192 },
1da177e4
LT		 1193 [DEV_STATE_QUIESCE] = {
1194 [DEV_EVENT_NOTOPER] = ccw_device_quiesce_done,
1195 [DEV_EVENT_INTERRUPT] = ccw_device_quiesce_done,
1196 [DEV_EVENT_TIMEOUT] = ccw_device_quiesce_timeout,
1197 [DEV_EVENT_VERIFY] = ccw_device_nop,
1198 },
1199 /* special states for devices gone not operational */
1200 [DEV_STATE_DISCONNECTED] = {
1201 [DEV_EVENT_NOTOPER] = ccw_device_nop,
1202 [DEV_EVENT_INTERRUPT] = ccw_device_start_id,
1203 [DEV_EVENT_TIMEOUT] = ccw_device_bug,
28bdc6f6 1204 [DEV_EVENT_VERIFY] = ccw_device_start_id,
1da177e4
LT		 1205 },
1206 [DEV_STATE_DISCONNECTED_SENSE_ID] = {
1207 [DEV_EVENT_NOTOPER] = ccw_device_recog_notoper,
1208 [DEV_EVENT_INTERRUPT] = ccw_device_sense_id_irq,
1209 [DEV_EVENT_TIMEOUT] = ccw_device_recog_timeout,
1210 [DEV_EVENT_VERIFY] = ccw_device_nop,
1211 },
1212 [DEV_STATE_CMFCHANGE] = {
1213 [DEV_EVENT_NOTOPER] = ccw_device_change_cmfstate,
1214 [DEV_EVENT_INTERRUPT] = ccw_device_change_cmfstate,
1215 [DEV_EVENT_TIMEOUT] = ccw_device_change_cmfstate,
1216 [DEV_EVENT_VERIFY] = ccw_device_change_cmfstate,
1217 },
94bb0633
CH		 1218 [DEV_STATE_CMFUPDATE] = {
1219 [DEV_EVENT_NOTOPER] = ccw_device_update_cmfblock,
1220 [DEV_EVENT_INTERRUPT] = ccw_device_update_cmfblock,
1221 [DEV_EVENT_TIMEOUT] = ccw_device_update_cmfblock,
1222 [DEV_EVENT_VERIFY] = ccw_device_update_cmfblock,
1223 },
1da177e4
LT		 1224};
1225
1226/*
1227 * io_subchannel_irq is called for "real" interrupts or for status
1228 * pending conditions on msch.
1229 */
1230void
1231io_subchannel_irq (struct device *pdev)
1232{
1233 struct ccw_device *cdev;
1234
1235 cdev = to_subchannel(pdev)->dev.driver_data;
1236
1237 CIO_TRACE_EVENT (3, "IRQ");
1238 CIO_TRACE_EVENT (3, pdev->bus_id);
1239 if (cdev)
1240 dev_fsm_event(cdev, DEV_EVENT_INTERRUPT);
1241}
1242
1243EXPORT_SYMBOL_GPL(ccw_device_set_timeout);
Linux kernel - Deliverables
This page took 0.326696 seconds and 5 git commands to generate.