This source file includes following definitions.
- devid_to_int
- tape_medium_state_show
- tape_first_minor_show
- tape_state_show
- tape_operation_show
- tape_blocksize_show
- tape_state_set
- tape_med_state_work_handler
- tape_med_state_work
- tape_med_state_set
- __tape_cancel_io
- tape_assign_minor
- tape_remove_minor
- tape_generic_online
- tape_cleanup_device
- tape_generic_pm_suspend
- tape_generic_offline
- tape_alloc_device
- tape_get_device
- tape_put_device
- tape_find_device
- tape_generic_probe
- __tape_discard_requests
- tape_generic_remove
- tape_alloc_request
- tape_free_request
- __tape_start_io
- __tape_start_next_request
- tape_delayed_next_request
- tape_long_busy_timeout
- __tape_end_request
- tape_dump_sense_dbf
- __tape_start_request
- tape_do_io_async
- __tape_wake_up
- tape_do_io
- __tape_wake_up_interruptible
- tape_do_io_interruptible
- tape_cancel_io
- __tape_do_irq
- tape_open
- tape_release
- tape_mtop
- tape_init
- tape_exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14 #define KMSG_COMPONENT "tape"
15 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
16
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/kmod.h>
20 #include <linux/spinlock.h>
21 #include <linux/vmalloc.h>
22 #include <linux/list.h>
23 #include <linux/slab.h>
24
25 #include <asm/types.h>
26
27 #define TAPE_DBF_AREA tape_core_dbf
28
29 #include "tape.h"
30 #include "tape_std.h"
31
32 #define LONG_BUSY_TIMEOUT 180
33
34 static void __tape_do_irq (struct ccw_device *, unsigned long, struct irb *);
35 static void tape_delayed_next_request(struct work_struct *);
36 static void tape_long_busy_timeout(struct timer_list *t);
37
38
39
40
41
42
43 static LIST_HEAD(tape_device_list);
44 static DEFINE_RWLOCK(tape_device_lock);
45
46
47
48
49 debug_info_t *TAPE_DBF_AREA = NULL;
50 EXPORT_SYMBOL(TAPE_DBF_AREA);
51
52
53
54
55 const char *tape_state_verbose[TS_SIZE] =
56 {
57 [TS_UNUSED] = "UNUSED",
58 [TS_IN_USE] = "IN_USE",
59 [TS_BLKUSE] = "BLKUSE",
60 [TS_INIT] = "INIT ",
61 [TS_NOT_OPER] = "NOT_OP"
62 };
63
64 const char *tape_op_verbose[TO_SIZE] =
65 {
66 [TO_BLOCK] = "BLK", [TO_BSB] = "BSB",
67 [TO_BSF] = "BSF", [TO_DSE] = "DSE",
68 [TO_FSB] = "FSB", [TO_FSF] = "FSF",
69 [TO_LBL] = "LBL", [TO_NOP] = "NOP",
70 [TO_RBA] = "RBA", [TO_RBI] = "RBI",
71 [TO_RFO] = "RFO", [TO_REW] = "REW",
72 [TO_RUN] = "RUN", [TO_WRI] = "WRI",
73 [TO_WTM] = "WTM", [TO_MSEN] = "MSN",
74 [TO_LOAD] = "LOA", [TO_READ_CONFIG] = "RCF",
75 [TO_READ_ATTMSG] = "RAT",
76 [TO_DIS] = "DIS", [TO_ASSIGN] = "ASS",
77 [TO_UNASSIGN] = "UAS", [TO_CRYPT_ON] = "CON",
78 [TO_CRYPT_OFF] = "COF", [TO_KEKL_SET] = "KLS",
79 [TO_KEKL_QUERY] = "KLQ",[TO_RDC] = "RDC",
80 };
81
82 static int devid_to_int(struct ccw_dev_id *dev_id)
83 {
84 return dev_id->devno + (dev_id->ssid << 16);
85 }
86
87
88
89
90
91
92
93 static ssize_t
94 tape_medium_state_show(struct device *dev, struct device_attribute *attr, char *buf)
95 {
96 struct tape_device *tdev;
97
98 tdev = dev_get_drvdata(dev);
99 return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->medium_state);
100 }
101
102 static
103 DEVICE_ATTR(medium_state, 0444, tape_medium_state_show, NULL);
104
105 static ssize_t
106 tape_first_minor_show(struct device *dev, struct device_attribute *attr, char *buf)
107 {
108 struct tape_device *tdev;
109
110 tdev = dev_get_drvdata(dev);
111 return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->first_minor);
112 }
113
114 static
115 DEVICE_ATTR(first_minor, 0444, tape_first_minor_show, NULL);
116
117 static ssize_t
118 tape_state_show(struct device *dev, struct device_attribute *attr, char *buf)
119 {
120 struct tape_device *tdev;
121
122 tdev = dev_get_drvdata(dev);
123 return scnprintf(buf, PAGE_SIZE, "%s\n", (tdev->first_minor < 0) ?
124 "OFFLINE" : tape_state_verbose[tdev->tape_state]);
125 }
126
127 static
128 DEVICE_ATTR(state, 0444, tape_state_show, NULL);
129
130 static ssize_t
131 tape_operation_show(struct device *dev, struct device_attribute *attr, char *buf)
132 {
133 struct tape_device *tdev;
134 ssize_t rc;
135
136 tdev = dev_get_drvdata(dev);
137 if (tdev->first_minor < 0)
138 return scnprintf(buf, PAGE_SIZE, "N/A\n");
139
140 spin_lock_irq(get_ccwdev_lock(tdev->cdev));
141 if (list_empty(&tdev->req_queue))
142 rc = scnprintf(buf, PAGE_SIZE, "---\n");
143 else {
144 struct tape_request *req;
145
146 req = list_entry(tdev->req_queue.next, struct tape_request,
147 list);
148 rc = scnprintf(buf,PAGE_SIZE, "%s\n", tape_op_verbose[req->op]);
149 }
150 spin_unlock_irq(get_ccwdev_lock(tdev->cdev));
151 return rc;
152 }
153
154 static
155 DEVICE_ATTR(operation, 0444, tape_operation_show, NULL);
156
157 static ssize_t
158 tape_blocksize_show(struct device *dev, struct device_attribute *attr, char *buf)
159 {
160 struct tape_device *tdev;
161
162 tdev = dev_get_drvdata(dev);
163
164 return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->char_data.block_size);
165 }
166
167 static
168 DEVICE_ATTR(blocksize, 0444, tape_blocksize_show, NULL);
169
170 static struct attribute *tape_attrs[] = {
171 &dev_attr_medium_state.attr,
172 &dev_attr_first_minor.attr,
173 &dev_attr_state.attr,
174 &dev_attr_operation.attr,
175 &dev_attr_blocksize.attr,
176 NULL
177 };
178
179 static const struct attribute_group tape_attr_group = {
180 .attrs = tape_attrs,
181 };
182
183
184
185
186 void
187 tape_state_set(struct tape_device *device, enum tape_state newstate)
188 {
189 const char *str;
190
191 if (device->tape_state == TS_NOT_OPER) {
192 DBF_EVENT(3, "ts_set err: not oper\n");
193 return;
194 }
195 DBF_EVENT(4, "ts. dev: %x\n", device->first_minor);
196 DBF_EVENT(4, "old ts:\t\n");
197 if (device->tape_state < TS_SIZE && device->tape_state >=0 )
198 str = tape_state_verbose[device->tape_state];
199 else
200 str = "UNKNOWN TS";
201 DBF_EVENT(4, "%s\n", str);
202 DBF_EVENT(4, "new ts:\t\n");
203 if (newstate < TS_SIZE && newstate >= 0)
204 str = tape_state_verbose[newstate];
205 else
206 str = "UNKNOWN TS";
207 DBF_EVENT(4, "%s\n", str);
208 device->tape_state = newstate;
209 wake_up(&device->state_change_wq);
210 }
211
212 struct tape_med_state_work_data {
213 struct tape_device *device;
214 enum tape_medium_state state;
215 struct work_struct work;
216 };
217
218 static void
219 tape_med_state_work_handler(struct work_struct *work)
220 {
221 static char env_state_loaded[] = "MEDIUM_STATE=LOADED";
222 static char env_state_unloaded[] = "MEDIUM_STATE=UNLOADED";
223 struct tape_med_state_work_data *p =
224 container_of(work, struct tape_med_state_work_data, work);
225 struct tape_device *device = p->device;
226 char *envp[] = { NULL, NULL };
227
228 switch (p->state) {
229 case MS_UNLOADED:
230 pr_info("%s: The tape cartridge has been successfully "
231 "unloaded\n", dev_name(&device->cdev->dev));
232 envp[0] = env_state_unloaded;
233 kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
234 break;
235 case MS_LOADED:
236 pr_info("%s: A tape cartridge has been mounted\n",
237 dev_name(&device->cdev->dev));
238 envp[0] = env_state_loaded;
239 kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
240 break;
241 default:
242 break;
243 }
244 tape_put_device(device);
245 kfree(p);
246 }
247
248 static void
249 tape_med_state_work(struct tape_device *device, enum tape_medium_state state)
250 {
251 struct tape_med_state_work_data *p;
252
253 p = kzalloc(sizeof(*p), GFP_ATOMIC);
254 if (p) {
255 INIT_WORK(&p->work, tape_med_state_work_handler);
256 p->device = tape_get_device(device);
257 p->state = state;
258 schedule_work(&p->work);
259 }
260 }
261
262 void
263 tape_med_state_set(struct tape_device *device, enum tape_medium_state newstate)
264 {
265 enum tape_medium_state oldstate;
266
267 oldstate = device->medium_state;
268 if (oldstate == newstate)
269 return;
270 device->medium_state = newstate;
271 switch(newstate){
272 case MS_UNLOADED:
273 device->tape_generic_status |= GMT_DR_OPEN(~0);
274 if (oldstate == MS_LOADED)
275 tape_med_state_work(device, MS_UNLOADED);
276 break;
277 case MS_LOADED:
278 device->tape_generic_status &= ~GMT_DR_OPEN(~0);
279 if (oldstate == MS_UNLOADED)
280 tape_med_state_work(device, MS_LOADED);
281 break;
282 default:
283 break;
284 }
285 wake_up(&device->state_change_wq);
286 }
287
288
289
290
291 static int
292 __tape_cancel_io(struct tape_device *device, struct tape_request *request)
293 {
294 int retries;
295 int rc;
296
297
298 if (request->callback == NULL)
299 return 0;
300
301 rc = 0;
302 for (retries = 0; retries < 5; retries++) {
303 rc = ccw_device_clear(device->cdev, (long) request);
304
305 switch (rc) {
306 case 0:
307 request->status = TAPE_REQUEST_DONE;
308 return 0;
309 case -EBUSY:
310 request->status = TAPE_REQUEST_CANCEL;
311 schedule_delayed_work(&device->tape_dnr, 0);
312 return 0;
313 case -ENODEV:
314 DBF_EXCEPTION(2, "device gone, retry\n");
315 break;
316 case -EIO:
317 DBF_EXCEPTION(2, "I/O error, retry\n");
318 break;
319 default:
320 BUG();
321 }
322 }
323
324 return rc;
325 }
326
327
328
329
330
331 static int
332 tape_assign_minor(struct tape_device *device)
333 {
334 struct tape_device *tmp;
335 int minor;
336
337 minor = 0;
338 write_lock(&tape_device_lock);
339 list_for_each_entry(tmp, &tape_device_list, node) {
340 if (minor < tmp->first_minor)
341 break;
342 minor += TAPE_MINORS_PER_DEV;
343 }
344 if (minor >= 256) {
345 write_unlock(&tape_device_lock);
346 return -ENODEV;
347 }
348 device->first_minor = minor;
349 list_add_tail(&device->node, &tmp->node);
350 write_unlock(&tape_device_lock);
351 return 0;
352 }
353
354
355 static void
356 tape_remove_minor(struct tape_device *device)
357 {
358 write_lock(&tape_device_lock);
359 list_del_init(&device->node);
360 device->first_minor = -1;
361 write_unlock(&tape_device_lock);
362 }
363
364
365
366
367
368
369
370
371
372 int
373 tape_generic_online(struct tape_device *device,
374 struct tape_discipline *discipline)
375 {
376 int rc;
377
378 DBF_LH(6, "tape_enable_device(%p, %p)\n", device, discipline);
379
380 if (device->tape_state != TS_INIT) {
381 DBF_LH(3, "Tapestate not INIT (%d)\n", device->tape_state);
382 return -EINVAL;
383 }
384
385 timer_setup(&device->lb_timeout, tape_long_busy_timeout, 0);
386
387
388 device->discipline = discipline;
389 if (!try_module_get(discipline->owner)) {
390 return -EINVAL;
391 }
392
393 rc = discipline->setup_device(device);
394 if (rc)
395 goto out;
396 rc = tape_assign_minor(device);
397 if (rc)
398 goto out_discipline;
399
400 rc = tapechar_setup_device(device);
401 if (rc)
402 goto out_minor;
403
404 tape_state_set(device, TS_UNUSED);
405
406 DBF_LH(3, "(%08x): Drive set online\n", device->cdev_id);
407
408 return 0;
409
410 out_minor:
411 tape_remove_minor(device);
412 out_discipline:
413 device->discipline->cleanup_device(device);
414 device->discipline = NULL;
415 out:
416 module_put(discipline->owner);
417 return rc;
418 }
419
420 static void
421 tape_cleanup_device(struct tape_device *device)
422 {
423 tapechar_cleanup_device(device);
424 device->discipline->cleanup_device(device);
425 module_put(device->discipline->owner);
426 tape_remove_minor(device);
427 tape_med_state_set(device, MS_UNKNOWN);
428 }
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443 int tape_generic_pm_suspend(struct ccw_device *cdev)
444 {
445 struct tape_device *device;
446
447 device = dev_get_drvdata(&cdev->dev);
448 if (!device) {
449 return -ENODEV;
450 }
451
452 DBF_LH(3, "(%08x): tape_generic_pm_suspend(%p)\n",
453 device->cdev_id, device);
454
455 if (device->medium_state != MS_UNLOADED) {
456 pr_err("A cartridge is loaded in tape device %s, "
457 "refusing to suspend\n", dev_name(&cdev->dev));
458 return -EBUSY;
459 }
460
461 spin_lock_irq(get_ccwdev_lock(device->cdev));
462 switch (device->tape_state) {
463 case TS_INIT:
464 case TS_NOT_OPER:
465 case TS_UNUSED:
466 spin_unlock_irq(get_ccwdev_lock(device->cdev));
467 break;
468 default:
469 pr_err("Tape device %s is busy, refusing to "
470 "suspend\n", dev_name(&cdev->dev));
471 spin_unlock_irq(get_ccwdev_lock(device->cdev));
472 return -EBUSY;
473 }
474
475 DBF_LH(3, "(%08x): Drive suspended.\n", device->cdev_id);
476 return 0;
477 }
478
479
480
481
482
483
484
485
486 int
487 tape_generic_offline(struct ccw_device *cdev)
488 {
489 struct tape_device *device;
490
491 device = dev_get_drvdata(&cdev->dev);
492 if (!device) {
493 return -ENODEV;
494 }
495
496 DBF_LH(3, "(%08x): tape_generic_offline(%p)\n",
497 device->cdev_id, device);
498
499 spin_lock_irq(get_ccwdev_lock(device->cdev));
500 switch (device->tape_state) {
501 case TS_INIT:
502 case TS_NOT_OPER:
503 spin_unlock_irq(get_ccwdev_lock(device->cdev));
504 break;
505 case TS_UNUSED:
506 tape_state_set(device, TS_INIT);
507 spin_unlock_irq(get_ccwdev_lock(device->cdev));
508 tape_cleanup_device(device);
509 break;
510 default:
511 DBF_EVENT(3, "(%08x): Set offline failed "
512 "- drive in use.\n",
513 device->cdev_id);
514 spin_unlock_irq(get_ccwdev_lock(device->cdev));
515 return -EBUSY;
516 }
517
518 DBF_LH(3, "(%08x): Drive set offline.\n", device->cdev_id);
519 return 0;
520 }
521
522
523
524
525 static struct tape_device *
526 tape_alloc_device(void)
527 {
528 struct tape_device *device;
529
530 device = kzalloc(sizeof(struct tape_device), GFP_KERNEL);
531 if (device == NULL) {
532 DBF_EXCEPTION(2, "ti:no mem\n");
533 return ERR_PTR(-ENOMEM);
534 }
535 device->modeset_byte = kmalloc(1, GFP_KERNEL | GFP_DMA);
536 if (device->modeset_byte == NULL) {
537 DBF_EXCEPTION(2, "ti:no mem\n");
538 kfree(device);
539 return ERR_PTR(-ENOMEM);
540 }
541 mutex_init(&device->mutex);
542 INIT_LIST_HEAD(&device->req_queue);
543 INIT_LIST_HEAD(&device->node);
544 init_waitqueue_head(&device->state_change_wq);
545 init_waitqueue_head(&device->wait_queue);
546 device->tape_state = TS_INIT;
547 device->medium_state = MS_UNKNOWN;
548 *device->modeset_byte = 0;
549 device->first_minor = -1;
550 atomic_set(&device->ref_count, 1);
551 INIT_DELAYED_WORK(&device->tape_dnr, tape_delayed_next_request);
552
553 return device;
554 }
555
556
557
558
559
560 struct tape_device *
561 tape_get_device(struct tape_device *device)
562 {
563 int count;
564
565 count = atomic_inc_return(&device->ref_count);
566 DBF_EVENT(4, "tape_get_device(%p) = %i\n", device, count);
567 return device;
568 }
569
570
571
572
573
574
575
576 void
577 tape_put_device(struct tape_device *device)
578 {
579 int count;
580
581 count = atomic_dec_return(&device->ref_count);
582 DBF_EVENT(4, "tape_put_device(%p) -> %i\n", device, count);
583 BUG_ON(count < 0);
584 if (count == 0) {
585 kfree(device->modeset_byte);
586 kfree(device);
587 }
588 }
589
590
591
592
593 struct tape_device *
594 tape_find_device(int devindex)
595 {
596 struct tape_device *device, *tmp;
597
598 device = ERR_PTR(-ENODEV);
599 read_lock(&tape_device_lock);
600 list_for_each_entry(tmp, &tape_device_list, node) {
601 if (tmp->first_minor / TAPE_MINORS_PER_DEV == devindex) {
602 device = tape_get_device(tmp);
603 break;
604 }
605 }
606 read_unlock(&tape_device_lock);
607 return device;
608 }
609
610
611
612
613 int
614 tape_generic_probe(struct ccw_device *cdev)
615 {
616 struct tape_device *device;
617 int ret;
618 struct ccw_dev_id dev_id;
619
620 device = tape_alloc_device();
621 if (IS_ERR(device))
622 return -ENODEV;
623 ccw_device_set_options(cdev, CCWDEV_DO_PATHGROUP |
624 CCWDEV_DO_MULTIPATH);
625 ret = sysfs_create_group(&cdev->dev.kobj, &tape_attr_group);
626 if (ret) {
627 tape_put_device(device);
628 return ret;
629 }
630 dev_set_drvdata(&cdev->dev, device);
631 cdev->handler = __tape_do_irq;
632 device->cdev = cdev;
633 ccw_device_get_id(cdev, &dev_id);
634 device->cdev_id = devid_to_int(&dev_id);
635 return ret;
636 }
637
638 static void
639 __tape_discard_requests(struct tape_device *device)
640 {
641 struct tape_request * request;
642 struct list_head * l, *n;
643
644 list_for_each_safe(l, n, &device->req_queue) {
645 request = list_entry(l, struct tape_request, list);
646 if (request->status == TAPE_REQUEST_IN_IO)
647 request->status = TAPE_REQUEST_DONE;
648 list_del(&request->list);
649
650
651 request->device = NULL;
652 tape_put_device(device);
653 request->rc = -EIO;
654 if (request->callback != NULL)
655 request->callback(request, request->callback_data);
656 }
657 }
658
659
660
661
662
663
664
665 void
666 tape_generic_remove(struct ccw_device *cdev)
667 {
668 struct tape_device * device;
669
670 device = dev_get_drvdata(&cdev->dev);
671 if (!device) {
672 return;
673 }
674 DBF_LH(3, "(%08x): tape_generic_remove(%p)\n", device->cdev_id, cdev);
675
676 spin_lock_irq(get_ccwdev_lock(device->cdev));
677 switch (device->tape_state) {
678 case TS_INIT:
679 tape_state_set(device, TS_NOT_OPER);
680
681 case TS_NOT_OPER:
682
683
684
685 spin_unlock_irq(get_ccwdev_lock(device->cdev));
686 break;
687 case TS_UNUSED:
688
689
690
691 tape_state_set(device, TS_NOT_OPER);
692 spin_unlock_irq(get_ccwdev_lock(device->cdev));
693 tape_cleanup_device(device);
694 break;
695 default:
696
697
698
699
700
701 DBF_EVENT(3, "(%08x): Drive in use vanished!\n",
702 device->cdev_id);
703 pr_warn("%s: A tape unit was detached while in use\n",
704 dev_name(&device->cdev->dev));
705 tape_state_set(device, TS_NOT_OPER);
706 __tape_discard_requests(device);
707 spin_unlock_irq(get_ccwdev_lock(device->cdev));
708 tape_cleanup_device(device);
709 }
710
711 device = dev_get_drvdata(&cdev->dev);
712 if (device) {
713 sysfs_remove_group(&cdev->dev.kobj, &tape_attr_group);
714 dev_set_drvdata(&cdev->dev, NULL);
715 tape_put_device(device);
716 }
717 }
718
719
720
721
722 struct tape_request *
723 tape_alloc_request(int cplength, int datasize)
724 {
725 struct tape_request *request;
726
727 BUG_ON(datasize > PAGE_SIZE || (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
728
729 DBF_LH(6, "tape_alloc_request(%d, %d)\n", cplength, datasize);
730
731 request = kzalloc(sizeof(struct tape_request), GFP_KERNEL);
732 if (request == NULL) {
733 DBF_EXCEPTION(1, "cqra nomem\n");
734 return ERR_PTR(-ENOMEM);
735 }
736
737 if (cplength > 0) {
738 request->cpaddr = kcalloc(cplength, sizeof(struct ccw1),
739 GFP_ATOMIC | GFP_DMA);
740 if (request->cpaddr == NULL) {
741 DBF_EXCEPTION(1, "cqra nomem\n");
742 kfree(request);
743 return ERR_PTR(-ENOMEM);
744 }
745 }
746
747 if (datasize > 0) {
748 request->cpdata = kzalloc(datasize, GFP_KERNEL | GFP_DMA);
749 if (request->cpdata == NULL) {
750 DBF_EXCEPTION(1, "cqra nomem\n");
751 kfree(request->cpaddr);
752 kfree(request);
753 return ERR_PTR(-ENOMEM);
754 }
755 }
756 DBF_LH(6, "New request %p(%p/%p)\n", request, request->cpaddr,
757 request->cpdata);
758
759 return request;
760 }
761
762
763
764
765 void
766 tape_free_request (struct tape_request * request)
767 {
768 DBF_LH(6, "Free request %p\n", request);
769
770 if (request->device)
771 tape_put_device(request->device);
772 kfree(request->cpdata);
773 kfree(request->cpaddr);
774 kfree(request);
775 }
776
777 static int
778 __tape_start_io(struct tape_device *device, struct tape_request *request)
779 {
780 int rc;
781
782 rc = ccw_device_start(
783 device->cdev,
784 request->cpaddr,
785 (unsigned long) request,
786 0x00,
787 request->options
788 );
789 if (rc == 0) {
790 request->status = TAPE_REQUEST_IN_IO;
791 } else if (rc == -EBUSY) {
792
793 request->status = TAPE_REQUEST_QUEUED;
794 schedule_delayed_work(&device->tape_dnr, 0);
795 rc = 0;
796 } else {
797
798 DBF_EVENT(1, "tape: start request failed with RC = %i\n", rc);
799 }
800 return rc;
801 }
802
803 static void
804 __tape_start_next_request(struct tape_device *device)
805 {
806 struct list_head *l, *n;
807 struct tape_request *request;
808 int rc;
809
810 DBF_LH(6, "__tape_start_next_request(%p)\n", device);
811
812
813
814
815 list_for_each_safe(l, n, &device->req_queue) {
816 request = list_entry(l, struct tape_request, list);
817
818
819
820
821
822 if (request->status == TAPE_REQUEST_IN_IO)
823 return;
824
825
826
827
828
829 if (request->status == TAPE_REQUEST_DONE)
830 return;
831
832
833
834
835
836
837
838 if (request->status == TAPE_REQUEST_CANCEL) {
839 rc = __tape_cancel_io(device, request);
840 } else {
841 rc = __tape_start_io(device, request);
842 }
843 if (rc == 0)
844 return;
845
846
847 request->rc = rc;
848 request->status = TAPE_REQUEST_DONE;
849
850
851 list_del(&request->list);
852
853
854 if (request->callback != NULL)
855 request->callback(request, request->callback_data);
856 }
857 }
858
859 static void
860 tape_delayed_next_request(struct work_struct *work)
861 {
862 struct tape_device *device =
863 container_of(work, struct tape_device, tape_dnr.work);
864
865 DBF_LH(6, "tape_delayed_next_request(%p)\n", device);
866 spin_lock_irq(get_ccwdev_lock(device->cdev));
867 __tape_start_next_request(device);
868 spin_unlock_irq(get_ccwdev_lock(device->cdev));
869 }
870
871 static void tape_long_busy_timeout(struct timer_list *t)
872 {
873 struct tape_device *device = from_timer(device, t, lb_timeout);
874 struct tape_request *request;
875
876 spin_lock_irq(get_ccwdev_lock(device->cdev));
877 request = list_entry(device->req_queue.next, struct tape_request, list);
878 BUG_ON(request->status != TAPE_REQUEST_LONG_BUSY);
879 DBF_LH(6, "%08x: Long busy timeout.\n", device->cdev_id);
880 __tape_start_next_request(device);
881 tape_put_device(device);
882 spin_unlock_irq(get_ccwdev_lock(device->cdev));
883 }
884
885 static void
886 __tape_end_request(
887 struct tape_device * device,
888 struct tape_request * request,
889 int rc)
890 {
891 DBF_LH(6, "__tape_end_request(%p, %p, %i)\n", device, request, rc);
892 if (request) {
893 request->rc = rc;
894 request->status = TAPE_REQUEST_DONE;
895
896
897 list_del(&request->list);
898
899
900 if (request->callback != NULL)
901 request->callback(request, request->callback_data);
902 }
903
904
905 if (!list_empty(&device->req_queue))
906 __tape_start_next_request(device);
907 }
908
909
910
911
912 void
913 tape_dump_sense_dbf(struct tape_device *device, struct tape_request *request,
914 struct irb *irb)
915 {
916 unsigned int *sptr;
917 const char* op;
918
919 if (request != NULL)
920 op = tape_op_verbose[request->op];
921 else
922 op = "---";
923 DBF_EVENT(3, "DSTAT : %02x CSTAT: %02x\n",
924 irb->scsw.cmd.dstat, irb->scsw.cmd.cstat);
925 DBF_EVENT(3, "DEVICE: %08x OP\t: %s\n", device->cdev_id, op);
926 sptr = (unsigned int *) irb->ecw;
927 DBF_EVENT(3, "%08x %08x\n", sptr[0], sptr[1]);
928 DBF_EVENT(3, "%08x %08x\n", sptr[2], sptr[3]);
929 DBF_EVENT(3, "%08x %08x\n", sptr[4], sptr[5]);
930 DBF_EVENT(3, "%08x %08x\n", sptr[6], sptr[7]);
931 }
932
933
934
935
936
937
938 static int
939 __tape_start_request(struct tape_device *device, struct tape_request *request)
940 {
941 int rc;
942
943 switch (request->op) {
944 case TO_MSEN:
945 case TO_ASSIGN:
946 case TO_UNASSIGN:
947 case TO_READ_ATTMSG:
948 case TO_RDC:
949 if (device->tape_state == TS_INIT)
950 break;
951 if (device->tape_state == TS_UNUSED)
952 break;
953
954 default:
955 if (device->tape_state == TS_BLKUSE)
956 break;
957 if (device->tape_state != TS_IN_USE)
958 return -ENODEV;
959 }
960
961
962 request->device = tape_get_device(device);
963
964 if (list_empty(&device->req_queue)) {
965
966 rc = __tape_start_io(device, request);
967 if (rc)
968 return rc;
969
970 DBF_LH(5, "Request %p added for execution.\n", request);
971 list_add(&request->list, &device->req_queue);
972 } else {
973 DBF_LH(5, "Request %p add to queue.\n", request);
974 request->status = TAPE_REQUEST_QUEUED;
975 list_add_tail(&request->list, &device->req_queue);
976 }
977 return 0;
978 }
979
980
981
982
983
984 int
985 tape_do_io_async(struct tape_device *device, struct tape_request *request)
986 {
987 int rc;
988
989 DBF_LH(6, "tape_do_io_async(%p, %p)\n", device, request);
990
991 spin_lock_irq(get_ccwdev_lock(device->cdev));
992
993 rc = __tape_start_request(device, request);
994 spin_unlock_irq(get_ccwdev_lock(device->cdev));
995 return rc;
996 }
997
998
999
1000
1001
1002
1003 static void
1004 __tape_wake_up(struct tape_request *request, void *data)
1005 {
1006 request->callback = NULL;
1007 wake_up((wait_queue_head_t *) data);
1008 }
1009
1010 int
1011 tape_do_io(struct tape_device *device, struct tape_request *request)
1012 {
1013 int rc;
1014
1015 spin_lock_irq(get_ccwdev_lock(device->cdev));
1016
1017 request->callback = __tape_wake_up;
1018 request->callback_data = &device->wait_queue;
1019
1020 rc = __tape_start_request(device, request);
1021 spin_unlock_irq(get_ccwdev_lock(device->cdev));
1022 if (rc)
1023 return rc;
1024
1025 wait_event(device->wait_queue, (request->callback == NULL));
1026
1027 return request->rc;
1028 }
1029
1030
1031
1032
1033
1034
1035 static void
1036 __tape_wake_up_interruptible(struct tape_request *request, void *data)
1037 {
1038 request->callback = NULL;
1039 wake_up_interruptible((wait_queue_head_t *) data);
1040 }
1041
1042 int
1043 tape_do_io_interruptible(struct tape_device *device,
1044 struct tape_request *request)
1045 {
1046 int rc;
1047
1048 spin_lock_irq(get_ccwdev_lock(device->cdev));
1049
1050 request->callback = __tape_wake_up_interruptible;
1051 request->callback_data = &device->wait_queue;
1052 rc = __tape_start_request(device, request);
1053 spin_unlock_irq(get_ccwdev_lock(device->cdev));
1054 if (rc)
1055 return rc;
1056
1057 rc = wait_event_interruptible(device->wait_queue,
1058 (request->callback == NULL));
1059 if (rc != -ERESTARTSYS)
1060
1061 return request->rc;
1062
1063
1064 spin_lock_irq(get_ccwdev_lock(device->cdev));
1065 rc = __tape_cancel_io(device, request);
1066 spin_unlock_irq(get_ccwdev_lock(device->cdev));
1067 if (rc == 0) {
1068
1069 do {
1070 rc = wait_event_interruptible(
1071 device->wait_queue,
1072 (request->callback == NULL)
1073 );
1074 } while (rc == -ERESTARTSYS);
1075
1076 DBF_EVENT(3, "IO stopped on %08x\n", device->cdev_id);
1077 rc = -ERESTARTSYS;
1078 }
1079 return rc;
1080 }
1081
1082
1083
1084
1085 int
1086 tape_cancel_io(struct tape_device *device, struct tape_request *request)
1087 {
1088 int rc;
1089
1090 spin_lock_irq(get_ccwdev_lock(device->cdev));
1091 rc = __tape_cancel_io(device, request);
1092 spin_unlock_irq(get_ccwdev_lock(device->cdev));
1093 return rc;
1094 }
1095
1096
1097
1098
1099 static void
1100 __tape_do_irq (struct ccw_device *cdev, unsigned long intparm, struct irb *irb)
1101 {
1102 struct tape_device *device;
1103 struct tape_request *request;
1104 int rc;
1105
1106 device = dev_get_drvdata(&cdev->dev);
1107 if (device == NULL) {
1108 return;
1109 }
1110 request = (struct tape_request *) intparm;
1111
1112 DBF_LH(6, "__tape_do_irq(device=%p, request=%p)\n", device, request);
1113
1114
1115 if (IS_ERR(irb)) {
1116
1117 switch (PTR_ERR(irb)) {
1118 case -ETIMEDOUT:
1119 DBF_LH(1, "(%08x): Request timed out\n",
1120 device->cdev_id);
1121
1122 case -EIO:
1123 __tape_end_request(device, request, -EIO);
1124 break;
1125 default:
1126 DBF_LH(1, "(%08x): Unexpected i/o error %li\n",
1127 device->cdev_id, PTR_ERR(irb));
1128 }
1129 return;
1130 }
1131
1132
1133
1134
1135
1136
1137
1138
1139 if (irb->scsw.cmd.cc != 0 &&
1140 (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
1141 (request->status == TAPE_REQUEST_IN_IO)) {
1142 DBF_EVENT(3,"(%08x): deferred cc=%i, fctl=%i. restarting\n",
1143 device->cdev_id, irb->scsw.cmd.cc, irb->scsw.cmd.fctl);
1144 request->status = TAPE_REQUEST_QUEUED;
1145 schedule_delayed_work(&device->tape_dnr, HZ);
1146 return;
1147 }
1148
1149
1150 if(request != NULL)
1151 request->rescnt = irb->scsw.cmd.count;
1152 else if ((irb->scsw.cmd.dstat == 0x85 || irb->scsw.cmd.dstat == 0x80) &&
1153 !list_empty(&device->req_queue)) {
1154
1155 struct tape_request *req;
1156 req = list_entry(device->req_queue.next,
1157 struct tape_request, list);
1158 if (req->status == TAPE_REQUEST_LONG_BUSY) {
1159 DBF_EVENT(3, "(%08x): del timer\n", device->cdev_id);
1160 if (del_timer(&device->lb_timeout)) {
1161 tape_put_device(device);
1162 __tape_start_next_request(device);
1163 }
1164 return;
1165 }
1166 }
1167 if (irb->scsw.cmd.dstat != 0x0c) {
1168
1169 if(*(((__u8 *) irb->ecw) + 1) & SENSE_DRIVE_ONLINE)
1170 device->tape_generic_status |= GMT_ONLINE(~0);
1171 else
1172 device->tape_generic_status &= ~GMT_ONLINE(~0);
1173
1174
1175
1176
1177
1178 DBF_EVENT(3,"-- Tape Interrupthandler --\n");
1179 tape_dump_sense_dbf(device, request, irb);
1180 } else {
1181
1182 device->tape_generic_status |= GMT_ONLINE(~0);
1183 }
1184 if (device->tape_state == TS_NOT_OPER) {
1185 DBF_EVENT(6, "tape:device is not operational\n");
1186 return;
1187 }
1188
1189
1190
1191
1192
1193 if(request != NULL && request->status == TAPE_REQUEST_DONE) {
1194 __tape_end_request(device, request, -EIO);
1195 return;
1196 }
1197
1198 rc = device->discipline->irq(device, request, irb);
1199
1200
1201
1202
1203
1204
1205
1206 switch (rc) {
1207 case TAPE_IO_SUCCESS:
1208
1209 device->tape_generic_status |= GMT_ONLINE(~0);
1210 __tape_end_request(device, request, rc);
1211 break;
1212 case TAPE_IO_PENDING:
1213 break;
1214 case TAPE_IO_LONG_BUSY:
1215 device->lb_timeout.expires = jiffies +
1216 LONG_BUSY_TIMEOUT * HZ;
1217 DBF_EVENT(3, "(%08x): add timer\n", device->cdev_id);
1218 add_timer(&device->lb_timeout);
1219 request->status = TAPE_REQUEST_LONG_BUSY;
1220 break;
1221 case TAPE_IO_RETRY:
1222 rc = __tape_start_io(device, request);
1223 if (rc)
1224 __tape_end_request(device, request, rc);
1225 break;
1226 case TAPE_IO_STOP:
1227 rc = __tape_cancel_io(device, request);
1228 if (rc)
1229 __tape_end_request(device, request, rc);
1230 break;
1231 default:
1232 if (rc > 0) {
1233 DBF_EVENT(6, "xunknownrc\n");
1234 __tape_end_request(device, request, -EIO);
1235 } else {
1236 __tape_end_request(device, request, rc);
1237 }
1238 break;
1239 }
1240 }
1241
1242
1243
1244
1245 int
1246 tape_open(struct tape_device *device)
1247 {
1248 int rc;
1249
1250 spin_lock_irq(get_ccwdev_lock(device->cdev));
1251 if (device->tape_state == TS_NOT_OPER) {
1252 DBF_EVENT(6, "TAPE:nodev\n");
1253 rc = -ENODEV;
1254 } else if (device->tape_state == TS_IN_USE) {
1255 DBF_EVENT(6, "TAPE:dbusy\n");
1256 rc = -EBUSY;
1257 } else if (device->tape_state == TS_BLKUSE) {
1258 DBF_EVENT(6, "TAPE:dbusy\n");
1259 rc = -EBUSY;
1260 } else if (device->discipline != NULL &&
1261 !try_module_get(device->discipline->owner)) {
1262 DBF_EVENT(6, "TAPE:nodisc\n");
1263 rc = -ENODEV;
1264 } else {
1265 tape_state_set(device, TS_IN_USE);
1266 rc = 0;
1267 }
1268 spin_unlock_irq(get_ccwdev_lock(device->cdev));
1269 return rc;
1270 }
1271
1272
1273
1274
1275 int
1276 tape_release(struct tape_device *device)
1277 {
1278 spin_lock_irq(get_ccwdev_lock(device->cdev));
1279 if (device->tape_state == TS_IN_USE)
1280 tape_state_set(device, TS_UNUSED);
1281 module_put(device->discipline->owner);
1282 spin_unlock_irq(get_ccwdev_lock(device->cdev));
1283 return 0;
1284 }
1285
1286
1287
1288
1289 int
1290 tape_mtop(struct tape_device *device, int mt_op, int mt_count)
1291 {
1292 tape_mtop_fn fn;
1293 int rc;
1294
1295 DBF_EVENT(6, "TAPE:mtio\n");
1296 DBF_EVENT(6, "TAPE:ioop: %x\n", mt_op);
1297 DBF_EVENT(6, "TAPE:arg: %x\n", mt_count);
1298
1299 if (mt_op < 0 || mt_op >= TAPE_NR_MTOPS)
1300 return -EINVAL;
1301 fn = device->discipline->mtop_array[mt_op];
1302 if (fn == NULL)
1303 return -EINVAL;
1304
1305
1306 if (mt_op == MTBSR || mt_op == MTFSR || mt_op == MTFSF ||
1307 mt_op == MTBSF || mt_op == MTFSFM || mt_op == MTBSFM) {
1308 rc = 0;
1309 for (; mt_count > 500; mt_count -= 500)
1310 if ((rc = fn(device, 500)) != 0)
1311 break;
1312 if (rc == 0)
1313 rc = fn(device, mt_count);
1314 } else
1315 rc = fn(device, mt_count);
1316 return rc;
1317
1318 }
1319
1320
1321
1322
1323 static int
1324 tape_init (void)
1325 {
1326 TAPE_DBF_AREA = debug_register ( "tape", 2, 2, 4*sizeof(long));
1327 debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
1328 #ifdef DBF_LIKE_HELL
1329 debug_set_level(TAPE_DBF_AREA, 6);
1330 #endif
1331 DBF_EVENT(3, "tape init\n");
1332 tape_proc_init();
1333 tapechar_init ();
1334 return 0;
1335 }
1336
1337
1338
1339
1340 static void
1341 tape_exit(void)
1342 {
1343 DBF_EVENT(6, "tape exit\n");
1344
1345
1346 tapechar_exit();
1347 tape_proc_cleanup();
1348 debug_unregister (TAPE_DBF_AREA);
1349 }
1350
1351 MODULE_AUTHOR("(C) 2001 IBM Deutschland Entwicklung GmbH by Carsten Otte and "
1352 "Michael Holzheu (cotte@de.ibm.com,holzheu@de.ibm.com)");
1353 MODULE_DESCRIPTION("Linux on zSeries channel attached tape device driver");
1354 MODULE_LICENSE("GPL");
1355
1356 module_init(tape_init);
1357 module_exit(tape_exit);
1358
1359 EXPORT_SYMBOL(tape_generic_remove);
1360 EXPORT_SYMBOL(tape_generic_probe);
1361 EXPORT_SYMBOL(tape_generic_online);
1362 EXPORT_SYMBOL(tape_generic_offline);
1363 EXPORT_SYMBOL(tape_generic_pm_suspend);
1364 EXPORT_SYMBOL(tape_put_device);
1365 EXPORT_SYMBOL(tape_get_device);
1366 EXPORT_SYMBOL(tape_state_verbose);
1367 EXPORT_SYMBOL(tape_op_verbose);
1368 EXPORT_SYMBOL(tape_state_set);
1369 EXPORT_SYMBOL(tape_med_state_set);
1370 EXPORT_SYMBOL(tape_alloc_request);
1371 EXPORT_SYMBOL(tape_free_request);
1372 EXPORT_SYMBOL(tape_dump_sense_dbf);
1373 EXPORT_SYMBOL(tape_do_io);
1374 EXPORT_SYMBOL(tape_do_io_async);
1375 EXPORT_SYMBOL(tape_do_io_interruptible);
1376 EXPORT_SYMBOL(tape_cancel_io);
1377 EXPORT_SYMBOL(tape_mtop);