1
2
3
4
5
6
7
8
9
10
11
12
13#define KMSG_COMPONENT "tape"
14#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
15
16#include <linux/module.h>
17#include <linux/init.h>
18#include <linux/kmod.h>
19#include <linux/spinlock.h>
20#include <linux/vmalloc.h>
21#include <linux/list.h>
22#include <linux/slab.h>
23
24#include <asm/types.h>
25
26#define TAPE_DBF_AREA tape_core_dbf
27
28#include "tape.h"
29#include "tape_std.h"
30
31#define LONG_BUSY_TIMEOUT 180
32
33static void __tape_do_irq (struct ccw_device *, unsigned long, struct irb *);
34static void tape_delayed_next_request(struct work_struct *);
35static void tape_long_busy_timeout(unsigned long data);
36
37
38
39
40
41
42static LIST_HEAD(tape_device_list);
43static DEFINE_RWLOCK(tape_device_lock);
44
45
46
47
48debug_info_t *TAPE_DBF_AREA = NULL;
49EXPORT_SYMBOL(TAPE_DBF_AREA);
50
51
52
53
54const char *tape_state_verbose[TS_SIZE] =
55{
56 [TS_UNUSED] = "UNUSED",
57 [TS_IN_USE] = "IN_USE",
58 [TS_BLKUSE] = "BLKUSE",
59 [TS_INIT] = "INIT ",
60 [TS_NOT_OPER] = "NOT_OP"
61};
62
63const char *tape_op_verbose[TO_SIZE] =
64{
65 [TO_BLOCK] = "BLK", [TO_BSB] = "BSB",
66 [TO_BSF] = "BSF", [TO_DSE] = "DSE",
67 [TO_FSB] = "FSB", [TO_FSF] = "FSF",
68 [TO_LBL] = "LBL", [TO_NOP] = "NOP",
69 [TO_RBA] = "RBA", [TO_RBI] = "RBI",
70 [TO_RFO] = "RFO", [TO_REW] = "REW",
71 [TO_RUN] = "RUN", [TO_WRI] = "WRI",
72 [TO_WTM] = "WTM", [TO_MSEN] = "MSN",
73 [TO_LOAD] = "LOA", [TO_READ_CONFIG] = "RCF",
74 [TO_READ_ATTMSG] = "RAT",
75 [TO_DIS] = "DIS", [TO_ASSIGN] = "ASS",
76 [TO_UNASSIGN] = "UAS", [TO_CRYPT_ON] = "CON",
77 [TO_CRYPT_OFF] = "COF", [TO_KEKL_SET] = "KLS",
78 [TO_KEKL_QUERY] = "KLQ",[TO_RDC] = "RDC",
79};
80
81static int devid_to_int(struct ccw_dev_id *dev_id)
82{
83 return dev_id->devno + (dev_id->ssid << 16);
84}
85
86
87
88
89
90
91
92static ssize_t
93tape_medium_state_show(struct device *dev, struct device_attribute *attr, char *buf)
94{
95 struct tape_device *tdev;
96
97 tdev = dev_get_drvdata(dev);
98 return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->medium_state);
99}
100
101static
102DEVICE_ATTR(medium_state, 0444, tape_medium_state_show, NULL);
103
104static ssize_t
105tape_first_minor_show(struct device *dev, struct device_attribute *attr, char *buf)
106{
107 struct tape_device *tdev;
108
109 tdev = dev_get_drvdata(dev);
110 return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->first_minor);
111}
112
113static
114DEVICE_ATTR(first_minor, 0444, tape_first_minor_show, NULL);
115
116static ssize_t
117tape_state_show(struct device *dev, struct device_attribute *attr, char *buf)
118{
119 struct tape_device *tdev;
120
121 tdev = dev_get_drvdata(dev);
122 return scnprintf(buf, PAGE_SIZE, "%s\n", (tdev->first_minor < 0) ?
123 "OFFLINE" : tape_state_verbose[tdev->tape_state]);
124}
125
126static
127DEVICE_ATTR(state, 0444, tape_state_show, NULL);
128
129static ssize_t
130tape_operation_show(struct device *dev, struct device_attribute *attr, char *buf)
131{
132 struct tape_device *tdev;
133 ssize_t rc;
134
135 tdev = dev_get_drvdata(dev);
136 if (tdev->first_minor < 0)
137 return scnprintf(buf, PAGE_SIZE, "N/A\n");
138
139 spin_lock_irq(get_ccwdev_lock(tdev->cdev));
140 if (list_empty(&tdev->req_queue))
141 rc = scnprintf(buf, PAGE_SIZE, "---\n");
142 else {
143 struct tape_request *req;
144
145 req = list_entry(tdev->req_queue.next, struct tape_request,
146 list);
147 rc = scnprintf(buf,PAGE_SIZE, "%s\n", tape_op_verbose[req->op]);
148 }
149 spin_unlock_irq(get_ccwdev_lock(tdev->cdev));
150 return rc;
151}
152
153static
154DEVICE_ATTR(operation, 0444, tape_operation_show, NULL);
155
156static ssize_t
157tape_blocksize_show(struct device *dev, struct device_attribute *attr, char *buf)
158{
159 struct tape_device *tdev;
160
161 tdev = dev_get_drvdata(dev);
162
163 return scnprintf(buf, PAGE_SIZE, "%i\n", tdev->char_data.block_size);
164}
165
166static
167DEVICE_ATTR(blocksize, 0444, tape_blocksize_show, NULL);
168
169static struct attribute *tape_attrs[] = {
170 &dev_attr_medium_state.attr,
171 &dev_attr_first_minor.attr,
172 &dev_attr_state.attr,
173 &dev_attr_operation.attr,
174 &dev_attr_blocksize.attr,
175 NULL
176};
177
178static struct attribute_group tape_attr_group = {
179 .attrs = tape_attrs,
180};
181
182
183
184
185void
186tape_state_set(struct tape_device *device, enum tape_state newstate)
187{
188 const char *str;
189
190 if (device->tape_state == TS_NOT_OPER) {
191 DBF_EVENT(3, "ts_set err: not oper\n");
192 return;
193 }
194 DBF_EVENT(4, "ts. dev: %x\n", device->first_minor);
195 DBF_EVENT(4, "old ts:\t\n");
196 if (device->tape_state < TS_SIZE && device->tape_state >=0 )
197 str = tape_state_verbose[device->tape_state];
198 else
199 str = "UNKNOWN TS";
200 DBF_EVENT(4, "%s\n", str);
201 DBF_EVENT(4, "new ts:\t\n");
202 if (newstate < TS_SIZE && newstate >= 0)
203 str = tape_state_verbose[newstate];
204 else
205 str = "UNKNOWN TS";
206 DBF_EVENT(4, "%s\n", str);
207 device->tape_state = newstate;
208 wake_up(&device->state_change_wq);
209}
210
211struct tape_med_state_work_data {
212 struct tape_device *device;
213 enum tape_medium_state state;
214 struct work_struct work;
215};
216
217static void
218tape_med_state_work_handler(struct work_struct *work)
219{
220 static char env_state_loaded[] = "MEDIUM_STATE=LOADED";
221 static char env_state_unloaded[] = "MEDIUM_STATE=UNLOADED";
222 struct tape_med_state_work_data *p =
223 container_of(work, struct tape_med_state_work_data, work);
224 struct tape_device *device = p->device;
225 char *envp[] = { NULL, NULL };
226
227 switch (p->state) {
228 case MS_UNLOADED:
229 pr_info("%s: The tape cartridge has been successfully "
230 "unloaded\n", dev_name(&device->cdev->dev));
231 envp[0] = env_state_unloaded;
232 kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
233 break;
234 case MS_LOADED:
235 pr_info("%s: A tape cartridge has been mounted\n",
236 dev_name(&device->cdev->dev));
237 envp[0] = env_state_loaded;
238 kobject_uevent_env(&device->cdev->dev.kobj, KOBJ_CHANGE, envp);
239 break;
240 default:
241 break;
242 }
243 tape_put_device(device);
244 kfree(p);
245}
246
247static void
248tape_med_state_work(struct tape_device *device, enum tape_medium_state state)
249{
250 struct tape_med_state_work_data *p;
251
252 p = kzalloc(sizeof(*p), GFP_ATOMIC);
253 if (p) {
254 INIT_WORK(&p->work, tape_med_state_work_handler);
255 p->device = tape_get_device(device);
256 p->state = state;
257 schedule_work(&p->work);
258 }
259}
260
261void
262tape_med_state_set(struct tape_device *device, enum tape_medium_state newstate)
263{
264 enum tape_medium_state oldstate;
265
266 oldstate = device->medium_state;
267 if (oldstate == newstate)
268 return;
269 device->medium_state = newstate;
270 switch(newstate){
271 case MS_UNLOADED:
272 device->tape_generic_status |= GMT_DR_OPEN(~0);
273 if (oldstate == MS_LOADED)
274 tape_med_state_work(device, MS_UNLOADED);
275 break;
276 case MS_LOADED:
277 device->tape_generic_status &= ~GMT_DR_OPEN(~0);
278 if (oldstate == MS_UNLOADED)
279 tape_med_state_work(device, MS_LOADED);
280 break;
281 default:
282 break;
283 }
284 wake_up(&device->state_change_wq);
285}
286
287
288
289
290static int
291__tape_cancel_io(struct tape_device *device, struct tape_request *request)
292{
293 int retries;
294 int rc;
295
296
297 if (request->callback == NULL)
298 return 0;
299
300 rc = 0;
301 for (retries = 0; retries < 5; retries++) {
302 rc = ccw_device_clear(device->cdev, (long) request);
303
304 switch (rc) {
305 case 0:
306 request->status = TAPE_REQUEST_DONE;
307 return 0;
308 case -EBUSY:
309 request->status = TAPE_REQUEST_CANCEL;
310 schedule_delayed_work(&device->tape_dnr, 0);
311 return 0;
312 case -ENODEV:
313 DBF_EXCEPTION(2, "device gone, retry\n");
314 break;
315 case -EIO:
316 DBF_EXCEPTION(2, "I/O error, retry\n");
317 break;
318 default:
319 BUG();
320 }
321 }
322
323 return rc;
324}
325
326
327
328
329
330static int
331tape_assign_minor(struct tape_device *device)
332{
333 struct tape_device *tmp;
334 int minor;
335
336 minor = 0;
337 write_lock(&tape_device_lock);
338 list_for_each_entry(tmp, &tape_device_list, node) {
339 if (minor < tmp->first_minor)
340 break;
341 minor += TAPE_MINORS_PER_DEV;
342 }
343 if (minor >= 256) {
344 write_unlock(&tape_device_lock);
345 return -ENODEV;
346 }
347 device->first_minor = minor;
348 list_add_tail(&device->node, &tmp->node);
349 write_unlock(&tape_device_lock);
350 return 0;
351}
352
353
354static void
355tape_remove_minor(struct tape_device *device)
356{
357 write_lock(&tape_device_lock);
358 list_del_init(&device->node);
359 device->first_minor = -1;
360 write_unlock(&tape_device_lock);
361}
362
363
364
365
366
367
368
369
370
371int
372tape_generic_online(struct tape_device *device,
373 struct tape_discipline *discipline)
374{
375 int rc;
376
377 DBF_LH(6, "tape_enable_device(%p, %p)\n", device, discipline);
378
379 if (device->tape_state != TS_INIT) {
380 DBF_LH(3, "Tapestate not INIT (%d)\n", device->tape_state);
381 return -EINVAL;
382 }
383
384 init_timer(&device->lb_timeout);
385 device->lb_timeout.function = tape_long_busy_timeout;
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
410out_minor:
411 tape_remove_minor(device);
412out_discipline:
413 device->discipline->cleanup_device(device);
414 device->discipline = NULL;
415out:
416 module_put(discipline->owner);
417 return rc;
418}
419
420static void
421tape_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
443int 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
486int
487tape_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
525static struct tape_device *
526tape_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
560struct tape_device *
561tape_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
576void
577tape_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
593struct tape_device *
594tape_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
613int
614tape_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
638static 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
665void
666tape_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 case TS_NOT_OPER:
681
682
683
684 spin_unlock_irq(get_ccwdev_lock(device->cdev));
685 break;
686 case TS_UNUSED:
687
688
689
690 tape_state_set(device, TS_NOT_OPER);
691 spin_unlock_irq(get_ccwdev_lock(device->cdev));
692 tape_cleanup_device(device);
693 break;
694 default:
695
696
697
698
699
700 DBF_EVENT(3, "(%08x): Drive in use vanished!\n",
701 device->cdev_id);
702 pr_warn("%s: A tape unit was detached while in use\n",
703 dev_name(&device->cdev->dev));
704 tape_state_set(device, TS_NOT_OPER);
705 __tape_discard_requests(device);
706 spin_unlock_irq(get_ccwdev_lock(device->cdev));
707 tape_cleanup_device(device);
708 }
709
710 device = dev_get_drvdata(&cdev->dev);
711 if (device) {
712 sysfs_remove_group(&cdev->dev.kobj, &tape_attr_group);
713 dev_set_drvdata(&cdev->dev, NULL);
714 tape_put_device(device);
715 }
716}
717
718
719
720
721struct tape_request *
722tape_alloc_request(int cplength, int datasize)
723{
724 struct tape_request *request;
725
726 BUG_ON(datasize > PAGE_SIZE || (cplength*sizeof(struct ccw1)) > PAGE_SIZE);
727
728 DBF_LH(6, "tape_alloc_request(%d, %d)\n", cplength, datasize);
729
730 request = kzalloc(sizeof(struct tape_request), GFP_KERNEL);
731 if (request == NULL) {
732 DBF_EXCEPTION(1, "cqra nomem\n");
733 return ERR_PTR(-ENOMEM);
734 }
735
736 if (cplength > 0) {
737 request->cpaddr = kcalloc(cplength, sizeof(struct ccw1),
738 GFP_ATOMIC | GFP_DMA);
739 if (request->cpaddr == NULL) {
740 DBF_EXCEPTION(1, "cqra nomem\n");
741 kfree(request);
742 return ERR_PTR(-ENOMEM);
743 }
744 }
745
746 if (datasize > 0) {
747 request->cpdata = kzalloc(datasize, GFP_KERNEL | GFP_DMA);
748 if (request->cpdata == NULL) {
749 DBF_EXCEPTION(1, "cqra nomem\n");
750 kfree(request->cpaddr);
751 kfree(request);
752 return ERR_PTR(-ENOMEM);
753 }
754 }
755 DBF_LH(6, "New request %p(%p/%p)\n", request, request->cpaddr,
756 request->cpdata);
757
758 return request;
759}
760
761
762
763
764void
765tape_free_request (struct tape_request * request)
766{
767 DBF_LH(6, "Free request %p\n", request);
768
769 if (request->device)
770 tape_put_device(request->device);
771 kfree(request->cpdata);
772 kfree(request->cpaddr);
773 kfree(request);
774}
775
776static int
777__tape_start_io(struct tape_device *device, struct tape_request *request)
778{
779 int rc;
780
781 rc = ccw_device_start(
782 device->cdev,
783 request->cpaddr,
784 (unsigned long) request,
785 0x00,
786 request->options
787 );
788 if (rc == 0) {
789 request->status = TAPE_REQUEST_IN_IO;
790 } else if (rc == -EBUSY) {
791
792 request->status = TAPE_REQUEST_QUEUED;
793 schedule_delayed_work(&device->tape_dnr, 0);
794 rc = 0;
795 } else {
796
797 DBF_EVENT(1, "tape: start request failed with RC = %i\n", rc);
798 }
799 return rc;
800}
801
802static void
803__tape_start_next_request(struct tape_device *device)
804{
805 struct list_head *l, *n;
806 struct tape_request *request;
807 int rc;
808
809 DBF_LH(6, "__tape_start_next_request(%p)\n", device);
810
811
812
813
814 list_for_each_safe(l, n, &device->req_queue) {
815 request = list_entry(l, struct tape_request, list);
816
817
818
819
820
821 if (request->status == TAPE_REQUEST_IN_IO)
822 return;
823
824
825
826
827
828 if (request->status == TAPE_REQUEST_DONE)
829 return;
830
831
832
833
834
835
836
837 if (request->status == TAPE_REQUEST_CANCEL) {
838 rc = __tape_cancel_io(device, request);
839 } else {
840 rc = __tape_start_io(device, request);
841 }
842 if (rc == 0)
843 return;
844
845
846 request->rc = rc;
847 request->status = TAPE_REQUEST_DONE;
848
849
850 list_del(&request->list);
851
852
853 if (request->callback != NULL)
854 request->callback(request, request->callback_data);
855 }
856}
857
858static void
859tape_delayed_next_request(struct work_struct *work)
860{
861 struct tape_device *device =
862 container_of(work, struct tape_device, tape_dnr.work);
863
864 DBF_LH(6, "tape_delayed_next_request(%p)\n", device);
865 spin_lock_irq(get_ccwdev_lock(device->cdev));
866 __tape_start_next_request(device);
867 spin_unlock_irq(get_ccwdev_lock(device->cdev));
868}
869
870static void tape_long_busy_timeout(unsigned long data)
871{
872 struct tape_request *request;
873 struct tape_device *device;
874
875 device = (struct tape_device *) data;
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 device->lb_timeout.data = 0UL;
882 tape_put_device(device);
883 spin_unlock_irq(get_ccwdev_lock(device->cdev));
884}
885
886static void
887__tape_end_request(
888 struct tape_device * device,
889 struct tape_request * request,
890 int rc)
891{
892 DBF_LH(6, "__tape_end_request(%p, %p, %i)\n", device, request, rc);
893 if (request) {
894 request->rc = rc;
895 request->status = TAPE_REQUEST_DONE;
896
897
898 list_del(&request->list);
899
900
901 if (request->callback != NULL)
902 request->callback(request, request->callback_data);
903 }
904
905
906 if (!list_empty(&device->req_queue))
907 __tape_start_next_request(device);
908}
909
910
911
912
913void
914tape_dump_sense_dbf(struct tape_device *device, struct tape_request *request,
915 struct irb *irb)
916{
917 unsigned int *sptr;
918 const char* op;
919
920 if (request != NULL)
921 op = tape_op_verbose[request->op];
922 else
923 op = "---";
924 DBF_EVENT(3, "DSTAT : %02x CSTAT: %02x\n",
925 irb->scsw.cmd.dstat, irb->scsw.cmd.cstat);
926 DBF_EVENT(3, "DEVICE: %08x OP\t: %s\n", device->cdev_id, op);
927 sptr = (unsigned int *) irb->ecw;
928 DBF_EVENT(3, "%08x %08x\n", sptr[0], sptr[1]);
929 DBF_EVENT(3, "%08x %08x\n", sptr[2], sptr[3]);
930 DBF_EVENT(3, "%08x %08x\n", sptr[4], sptr[5]);
931 DBF_EVENT(3, "%08x %08x\n", sptr[6], sptr[7]);
932}
933
934
935
936
937
938
939static int
940__tape_start_request(struct tape_device *device, struct tape_request *request)
941{
942 int rc;
943
944 switch (request->op) {
945 case TO_MSEN:
946 case TO_ASSIGN:
947 case TO_UNASSIGN:
948 case TO_READ_ATTMSG:
949 case TO_RDC:
950 if (device->tape_state == TS_INIT)
951 break;
952 if (device->tape_state == TS_UNUSED)
953 break;
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
984int
985tape_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
1003static 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
1010int
1011tape_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
1035static 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
1042int
1043tape_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
1085int
1086tape_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
1099static 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 case -EIO:
1122 __tape_end_request(device, request, -EIO);
1123 break;
1124 default:
1125 DBF_LH(1, "(%08x): Unexpected i/o error %li\n",
1126 device->cdev_id, PTR_ERR(irb));
1127 }
1128 return;
1129 }
1130
1131
1132
1133
1134
1135
1136
1137
1138 if (irb->scsw.cmd.cc != 0 &&
1139 (irb->scsw.cmd.fctl & SCSW_FCTL_START_FUNC) &&
1140 (request->status == TAPE_REQUEST_IN_IO)) {
1141 DBF_EVENT(3,"(%08x): deferred cc=%i, fctl=%i. restarting\n",
1142 device->cdev_id, irb->scsw.cmd.cc, irb->scsw.cmd.fctl);
1143 request->status = TAPE_REQUEST_QUEUED;
1144 schedule_delayed_work(&device->tape_dnr, HZ);
1145 return;
1146 }
1147
1148
1149 if(request != NULL)
1150 request->rescnt = irb->scsw.cmd.count;
1151 else if ((irb->scsw.cmd.dstat == 0x85 || irb->scsw.cmd.dstat == 0x80) &&
1152 !list_empty(&device->req_queue)) {
1153
1154 struct tape_request *req;
1155 req = list_entry(device->req_queue.next,
1156 struct tape_request, list);
1157 if (req->status == TAPE_REQUEST_LONG_BUSY) {
1158 DBF_EVENT(3, "(%08x): del timer\n", device->cdev_id);
1159 if (del_timer(&device->lb_timeout)) {
1160 device->lb_timeout.data = 0UL;
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.data =
1216 (unsigned long) tape_get_device(device);
1217 device->lb_timeout.expires = jiffies +
1218 LONG_BUSY_TIMEOUT * HZ;
1219 DBF_EVENT(3, "(%08x): add timer\n", device->cdev_id);
1220 add_timer(&device->lb_timeout);
1221 request->status = TAPE_REQUEST_LONG_BUSY;
1222 break;
1223 case TAPE_IO_RETRY:
1224 rc = __tape_start_io(device, request);
1225 if (rc)
1226 __tape_end_request(device, request, rc);
1227 break;
1228 case TAPE_IO_STOP:
1229 rc = __tape_cancel_io(device, request);
1230 if (rc)
1231 __tape_end_request(device, request, rc);
1232 break;
1233 default:
1234 if (rc > 0) {
1235 DBF_EVENT(6, "xunknownrc\n");
1236 __tape_end_request(device, request, -EIO);
1237 } else {
1238 __tape_end_request(device, request, rc);
1239 }
1240 break;
1241 }
1242}
1243
1244
1245
1246
1247int
1248tape_open(struct tape_device *device)
1249{
1250 int rc;
1251
1252 spin_lock_irq(get_ccwdev_lock(device->cdev));
1253 if (device->tape_state == TS_NOT_OPER) {
1254 DBF_EVENT(6, "TAPE:nodev\n");
1255 rc = -ENODEV;
1256 } else if (device->tape_state == TS_IN_USE) {
1257 DBF_EVENT(6, "TAPE:dbusy\n");
1258 rc = -EBUSY;
1259 } else if (device->tape_state == TS_BLKUSE) {
1260 DBF_EVENT(6, "TAPE:dbusy\n");
1261 rc = -EBUSY;
1262 } else if (device->discipline != NULL &&
1263 !try_module_get(device->discipline->owner)) {
1264 DBF_EVENT(6, "TAPE:nodisc\n");
1265 rc = -ENODEV;
1266 } else {
1267 tape_state_set(device, TS_IN_USE);
1268 rc = 0;
1269 }
1270 spin_unlock_irq(get_ccwdev_lock(device->cdev));
1271 return rc;
1272}
1273
1274
1275
1276
1277int
1278tape_release(struct tape_device *device)
1279{
1280 spin_lock_irq(get_ccwdev_lock(device->cdev));
1281 if (device->tape_state == TS_IN_USE)
1282 tape_state_set(device, TS_UNUSED);
1283 module_put(device->discipline->owner);
1284 spin_unlock_irq(get_ccwdev_lock(device->cdev));
1285 return 0;
1286}
1287
1288
1289
1290
1291int
1292tape_mtop(struct tape_device *device, int mt_op, int mt_count)
1293{
1294 tape_mtop_fn fn;
1295 int rc;
1296
1297 DBF_EVENT(6, "TAPE:mtio\n");
1298 DBF_EVENT(6, "TAPE:ioop: %x\n", mt_op);
1299 DBF_EVENT(6, "TAPE:arg: %x\n", mt_count);
1300
1301 if (mt_op < 0 || mt_op >= TAPE_NR_MTOPS)
1302 return -EINVAL;
1303 fn = device->discipline->mtop_array[mt_op];
1304 if (fn == NULL)
1305 return -EINVAL;
1306
1307
1308 if (mt_op == MTBSR || mt_op == MTFSR || mt_op == MTFSF ||
1309 mt_op == MTBSF || mt_op == MTFSFM || mt_op == MTBSFM) {
1310 rc = 0;
1311 for (; mt_count > 500; mt_count -= 500)
1312 if ((rc = fn(device, 500)) != 0)
1313 break;
1314 if (rc == 0)
1315 rc = fn(device, mt_count);
1316 } else
1317 rc = fn(device, mt_count);
1318 return rc;
1319
1320}
1321
1322
1323
1324
1325static int
1326tape_init (void)
1327{
1328 TAPE_DBF_AREA = debug_register ( "tape", 2, 2, 4*sizeof(long));
1329 debug_register_view(TAPE_DBF_AREA, &debug_sprintf_view);
1330#ifdef DBF_LIKE_HELL
1331 debug_set_level(TAPE_DBF_AREA, 6);
1332#endif
1333 DBF_EVENT(3, "tape init\n");
1334 tape_proc_init();
1335 tapechar_init ();
1336 return 0;
1337}
1338
1339
1340
1341
1342static void
1343tape_exit(void)
1344{
1345 DBF_EVENT(6, "tape exit\n");
1346
1347
1348 tapechar_exit();
1349 tape_proc_cleanup();
1350 debug_unregister (TAPE_DBF_AREA);
1351}
1352
1353MODULE_AUTHOR("(C) 2001 IBM Deutschland Entwicklung GmbH by Carsten Otte and "
1354 "Michael Holzheu (cotte@de.ibm.com,holzheu@de.ibm.com)");
1355MODULE_DESCRIPTION("Linux on zSeries channel attached tape device driver");
1356MODULE_LICENSE("GPL");
1357
1358module_init(tape_init);
1359module_exit(tape_exit);
1360
1361EXPORT_SYMBOL(tape_generic_remove);
1362EXPORT_SYMBOL(tape_generic_probe);
1363EXPORT_SYMBOL(tape_generic_online);
1364EXPORT_SYMBOL(tape_generic_offline);
1365EXPORT_SYMBOL(tape_generic_pm_suspend);
1366EXPORT_SYMBOL(tape_put_device);
1367EXPORT_SYMBOL(tape_get_device);
1368EXPORT_SYMBOL(tape_state_verbose);
1369EXPORT_SYMBOL(tape_op_verbose);
1370EXPORT_SYMBOL(tape_state_set);
1371EXPORT_SYMBOL(tape_med_state_set);
1372EXPORT_SYMBOL(tape_alloc_request);
1373EXPORT_SYMBOL(tape_free_request);
1374EXPORT_SYMBOL(tape_dump_sense_dbf);
1375EXPORT_SYMBOL(tape_do_io);
1376EXPORT_SYMBOL(tape_do_io_async);
1377EXPORT_SYMBOL(tape_do_io_interruptible);
1378EXPORT_SYMBOL(tape_cancel_io);
1379EXPORT_SYMBOL(tape_mtop);
1380