1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107#define PT_VERSION "1.04"
108#define PT_MAJOR 96
109#define PT_NAME "pt"
110#define PT_UNITS 4
111
112#include <linux/types.h>
113
114
115
116
117
118
119
120static bool verbose = 0;
121static int major = PT_MAJOR;
122static char *name = PT_NAME;
123static int disable = 0;
124
125static int drive0[6] = { 0, 0, 0, -1, -1, -1 };
126static int drive1[6] = { 0, 0, 0, -1, -1, -1 };
127static int drive2[6] = { 0, 0, 0, -1, -1, -1 };
128static int drive3[6] = { 0, 0, 0, -1, -1, -1 };
129
130static int (*drives[4])[6] = {&drive0, &drive1, &drive2, &drive3};
131
132#define D_PRT 0
133#define D_PRO 1
134#define D_UNI 2
135#define D_MOD 3
136#define D_SLV 4
137#define D_DLY 5
138
139#define DU (*drives[unit])
140
141
142
143#include <linux/module.h>
144#include <linux/init.h>
145#include <linux/fs.h>
146#include <linux/delay.h>
147#include <linux/slab.h>
148#include <linux/mtio.h>
149#include <linux/device.h>
150#include <linux/sched.h>
151#include <linux/mutex.h>
152
153#include <asm/uaccess.h>
154
155module_param(verbose, bool, 0);
156module_param(major, int, 0);
157module_param(name, charp, 0);
158module_param_array(drive0, int, NULL, 0);
159module_param_array(drive1, int, NULL, 0);
160module_param_array(drive2, int, NULL, 0);
161module_param_array(drive3, int, NULL, 0);
162
163#include "paride.h"
164
165#define PT_MAX_RETRIES 5
166#define PT_TMO 3000
167#define PT_SPIN_DEL 50
168#define PT_RESET_TMO 30
169#define PT_READY_TMO 60
170#define PT_REWIND_TMO 1200
171
172#define PT_SPIN ((1000000/(HZ*PT_SPIN_DEL))*PT_TMO)
173
174#define STAT_ERR 0x00001
175#define STAT_INDEX 0x00002
176#define STAT_ECC 0x00004
177#define STAT_DRQ 0x00008
178#define STAT_SEEK 0x00010
179#define STAT_WRERR 0x00020
180#define STAT_READY 0x00040
181#define STAT_BUSY 0x00080
182#define STAT_SENSE 0x1f000
183
184#define ATAPI_TEST_READY 0x00
185#define ATAPI_REWIND 0x01
186#define ATAPI_REQ_SENSE 0x03
187#define ATAPI_READ_6 0x08
188#define ATAPI_WRITE_6 0x0a
189#define ATAPI_WFM 0x10
190#define ATAPI_IDENTIFY 0x12
191#define ATAPI_MODE_SENSE 0x1a
192#define ATAPI_LOG_SENSE 0x4d
193
194static DEFINE_MUTEX(pt_mutex);
195static int pt_open(struct inode *inode, struct file *file);
196static long pt_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
197static int pt_release(struct inode *inode, struct file *file);
198static ssize_t pt_read(struct file *filp, char __user *buf,
199 size_t count, loff_t * ppos);
200static ssize_t pt_write(struct file *filp, const char __user *buf,
201 size_t count, loff_t * ppos);
202static int pt_detect(void);
203
204
205
206#define PT_MEDIA 1
207#define PT_WRITE_OK 2
208#define PT_REWIND 4
209#define PT_WRITING 8
210#define PT_READING 16
211#define PT_EOF 32
212
213#define PT_NAMELEN 8
214#define PT_BUFSIZE 16384
215
216struct pt_unit {
217 struct pi_adapter pia;
218 struct pi_adapter *pi;
219 int flags;
220 int last_sense;
221 int drive;
222 atomic_t available;
223 int bs;
224 int capacity;
225 int present;
226 char *bufptr;
227 char name[PT_NAMELEN];
228};
229
230static int pt_identify(struct pt_unit *tape);
231
232static struct pt_unit pt[PT_UNITS];
233
234static char pt_scratch[512];
235
236
237
238static const struct file_operations pt_fops = {
239 .owner = THIS_MODULE,
240 .read = pt_read,
241 .write = pt_write,
242 .unlocked_ioctl = pt_ioctl,
243 .open = pt_open,
244 .release = pt_release,
245 .llseek = noop_llseek,
246};
247
248
249static struct class *pt_class;
250
251static inline int status_reg(struct pi_adapter *pi)
252{
253 return pi_read_regr(pi, 1, 6);
254}
255
256static inline int read_reg(struct pi_adapter *pi, int reg)
257{
258 return pi_read_regr(pi, 0, reg);
259}
260
261static inline void write_reg(struct pi_adapter *pi, int reg, int val)
262{
263 pi_write_regr(pi, 0, reg, val);
264}
265
266static inline u8 DRIVE(struct pt_unit *tape)
267{
268 return 0xa0+0x10*tape->drive;
269}
270
271static int pt_wait(struct pt_unit *tape, int go, int stop, char *fun, char *msg)
272{
273 int j, r, e, s, p;
274 struct pi_adapter *pi = tape->pi;
275
276 j = 0;
277 while ((((r = status_reg(pi)) & go) || (stop && (!(r & stop))))
278 && (j++ < PT_SPIN))
279 udelay(PT_SPIN_DEL);
280
281 if ((r & (STAT_ERR & stop)) || (j > PT_SPIN)) {
282 s = read_reg(pi, 7);
283 e = read_reg(pi, 1);
284 p = read_reg(pi, 2);
285 if (j > PT_SPIN)
286 e |= 0x100;
287 if (fun)
288 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
289 " loop=%d phase=%d\n",
290 tape->name, fun, msg, r, s, e, j, p);
291 return (e << 8) + s;
292 }
293 return 0;
294}
295
296static int pt_command(struct pt_unit *tape, char *cmd, int dlen, char *fun)
297{
298 struct pi_adapter *pi = tape->pi;
299 pi_connect(pi);
300
301 write_reg(pi, 6, DRIVE(tape));
302
303 if (pt_wait(tape, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
304 pi_disconnect(pi);
305 return -1;
306 }
307
308 write_reg(pi, 4, dlen % 256);
309 write_reg(pi, 5, dlen / 256);
310 write_reg(pi, 7, 0xa0);
311
312 if (pt_wait(tape, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
313 pi_disconnect(pi);
314 return -1;
315 }
316
317 if (read_reg(pi, 2) != 1) {
318 printk("%s: %s: command phase error\n", tape->name, fun);
319 pi_disconnect(pi);
320 return -1;
321 }
322
323 pi_write_block(pi, cmd, 12);
324
325 return 0;
326}
327
328static int pt_completion(struct pt_unit *tape, char *buf, char *fun)
329{
330 struct pi_adapter *pi = tape->pi;
331 int r, s, n, p;
332
333 r = pt_wait(tape, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
334 fun, "completion");
335
336 if (read_reg(pi, 7) & STAT_DRQ) {
337 n = (((read_reg(pi, 4) + 256 * read_reg(pi, 5)) +
338 3) & 0xfffc);
339 p = read_reg(pi, 2) & 3;
340 if (p == 0)
341 pi_write_block(pi, buf, n);
342 if (p == 2)
343 pi_read_block(pi, buf, n);
344 }
345
346 s = pt_wait(tape, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
347
348 pi_disconnect(pi);
349
350 return (r ? r : s);
351}
352
353static void pt_req_sense(struct pt_unit *tape, int quiet)
354{
355 char rs_cmd[12] = { ATAPI_REQ_SENSE, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
356 char buf[16];
357 int r;
358
359 r = pt_command(tape, rs_cmd, 16, "Request sense");
360 mdelay(1);
361 if (!r)
362 pt_completion(tape, buf, "Request sense");
363
364 tape->last_sense = -1;
365 if (!r) {
366 if (!quiet)
367 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
368 tape->name, buf[2] & 0xf, buf[12], buf[13]);
369 tape->last_sense = (buf[2] & 0xf) | ((buf[12] & 0xff) << 8)
370 | ((buf[13] & 0xff) << 16);
371 }
372}
373
374static int pt_atapi(struct pt_unit *tape, char *cmd, int dlen, char *buf, char *fun)
375{
376 int r;
377
378 r = pt_command(tape, cmd, dlen, fun);
379 mdelay(1);
380 if (!r)
381 r = pt_completion(tape, buf, fun);
382 if (r)
383 pt_req_sense(tape, !fun);
384
385 return r;
386}
387
388static void pt_sleep(int cs)
389{
390 schedule_timeout_interruptible(cs);
391}
392
393static int pt_poll_dsc(struct pt_unit *tape, int pause, int tmo, char *msg)
394{
395 struct pi_adapter *pi = tape->pi;
396 int k, e, s;
397
398 k = 0;
399 e = 0;
400 s = 0;
401 while (k < tmo) {
402 pt_sleep(pause);
403 k++;
404 pi_connect(pi);
405 write_reg(pi, 6, DRIVE(tape));
406 s = read_reg(pi, 7);
407 e = read_reg(pi, 1);
408 pi_disconnect(pi);
409 if (s & (STAT_ERR | STAT_SEEK))
410 break;
411 }
412 if ((k >= tmo) || (s & STAT_ERR)) {
413 if (k >= tmo)
414 printk("%s: %s DSC timeout\n", tape->name, msg);
415 else
416 printk("%s: %s stat=0x%x err=0x%x\n", tape->name, msg, s,
417 e);
418 pt_req_sense(tape, 0);
419 return 0;
420 }
421 return 1;
422}
423
424static void pt_media_access_cmd(struct pt_unit *tape, int tmo, char *cmd, char *fun)
425{
426 if (pt_command(tape, cmd, 0, fun)) {
427 pt_req_sense(tape, 0);
428 return;
429 }
430 pi_disconnect(tape->pi);
431 pt_poll_dsc(tape, HZ, tmo, fun);
432}
433
434static void pt_rewind(struct pt_unit *tape)
435{
436 char rw_cmd[12] = { ATAPI_REWIND, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
437
438 pt_media_access_cmd(tape, PT_REWIND_TMO, rw_cmd, "rewind");
439}
440
441static void pt_write_fm(struct pt_unit *tape)
442{
443 char wm_cmd[12] = { ATAPI_WFM, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 };
444
445 pt_media_access_cmd(tape, PT_TMO, wm_cmd, "write filemark");
446}
447
448#define DBMSG(msg) ((verbose>1)?(msg):NULL)
449
450static int pt_reset(struct pt_unit *tape)
451{
452 struct pi_adapter *pi = tape->pi;
453 int i, k, flg;
454 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
455
456 pi_connect(pi);
457 write_reg(pi, 6, DRIVE(tape));
458 write_reg(pi, 7, 8);
459
460 pt_sleep(20 * HZ / 1000);
461
462 k = 0;
463 while ((k++ < PT_RESET_TMO) && (status_reg(pi) & STAT_BUSY))
464 pt_sleep(HZ / 10);
465
466 flg = 1;
467 for (i = 0; i < 5; i++)
468 flg &= (read_reg(pi, i + 1) == expect[i]);
469
470 if (verbose) {
471 printk("%s: Reset (%d) signature = ", tape->name, k);
472 for (i = 0; i < 5; i++)
473 printk("%3x", read_reg(pi, i + 1));
474 if (!flg)
475 printk(" (incorrect)");
476 printk("\n");
477 }
478
479 pi_disconnect(pi);
480 return flg - 1;
481}
482
483static int pt_ready_wait(struct pt_unit *tape, int tmo)
484{
485 char tr_cmd[12] = { ATAPI_TEST_READY, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
486 int k, p;
487
488 k = 0;
489 while (k < tmo) {
490 tape->last_sense = 0;
491 pt_atapi(tape, tr_cmd, 0, NULL, DBMSG("test unit ready"));
492 p = tape->last_sense;
493 if (!p)
494 return 0;
495 if (!(((p & 0xffff) == 0x0402) || ((p & 0xff) == 6)))
496 return p;
497 k++;
498 pt_sleep(HZ);
499 }
500 return 0x000020;
501}
502
503static void xs(char *buf, char *targ, int offs, int len)
504{
505 int j, k, l;
506
507 j = 0;
508 l = 0;
509 for (k = 0; k < len; k++)
510 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
511 l = targ[j++] = buf[k + offs];
512 if (l == 0x20)
513 j--;
514 targ[j] = 0;
515}
516
517static int xn(char *buf, int offs, int size)
518{
519 int v, k;
520
521 v = 0;
522 for (k = 0; k < size; k++)
523 v = v * 256 + (buf[k + offs] & 0xff);
524 return v;
525}
526
527static int pt_identify(struct pt_unit *tape)
528{
529 int dt, s;
530 char *ms[2] = { "master", "slave" };
531 char mf[10], id[18];
532 char id_cmd[12] = { ATAPI_IDENTIFY, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
533 char ms_cmd[12] =
534 { ATAPI_MODE_SENSE, 0, 0x2a, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
535 char ls_cmd[12] =
536 { ATAPI_LOG_SENSE, 0, 0x71, 0, 0, 0, 0, 0, 36, 0, 0, 0 };
537 char buf[36];
538
539 s = pt_atapi(tape, id_cmd, 36, buf, "identify");
540 if (s)
541 return -1;
542
543 dt = buf[0] & 0x1f;
544 if (dt != 1) {
545 if (verbose)
546 printk("%s: Drive %d, unsupported type %d\n",
547 tape->name, tape->drive, dt);
548 return -1;
549 }
550
551 xs(buf, mf, 8, 8);
552 xs(buf, id, 16, 16);
553
554 tape->flags = 0;
555 tape->capacity = 0;
556 tape->bs = 0;
557
558 if (!pt_ready_wait(tape, PT_READY_TMO))
559 tape->flags |= PT_MEDIA;
560
561 if (!pt_atapi(tape, ms_cmd, 36, buf, "mode sense")) {
562 if (!(buf[2] & 0x80))
563 tape->flags |= PT_WRITE_OK;
564 tape->bs = xn(buf, 10, 2);
565 }
566
567 if (!pt_atapi(tape, ls_cmd, 36, buf, "log sense"))
568 tape->capacity = xn(buf, 24, 4);
569
570 printk("%s: %s %s, %s", tape->name, mf, id, ms[tape->drive]);
571 if (!(tape->flags & PT_MEDIA))
572 printk(", no media\n");
573 else {
574 if (!(tape->flags & PT_WRITE_OK))
575 printk(", RO");
576 printk(", blocksize %d, %d MB\n", tape->bs, tape->capacity / 1024);
577 }
578
579 return 0;
580}
581
582
583
584
585
586
587static int pt_probe(struct pt_unit *tape)
588{
589 if (tape->drive == -1) {
590 for (tape->drive = 0; tape->drive <= 1; tape->drive++)
591 if (!pt_reset(tape))
592 return pt_identify(tape);
593 } else {
594 if (!pt_reset(tape))
595 return pt_identify(tape);
596 }
597 return -1;
598}
599
600static int pt_detect(void)
601{
602 struct pt_unit *tape;
603 int specified = 0, found = 0;
604 int unit;
605
606 printk("%s: %s version %s, major %d\n", name, name, PT_VERSION, major);
607
608 specified = 0;
609 for (unit = 0; unit < PT_UNITS; unit++) {
610 struct pt_unit *tape = &pt[unit];
611 tape->pi = &tape->pia;
612 atomic_set(&tape->available, 1);
613 tape->flags = 0;
614 tape->last_sense = 0;
615 tape->present = 0;
616 tape->bufptr = NULL;
617 tape->drive = DU[D_SLV];
618 snprintf(tape->name, PT_NAMELEN, "%s%d", name, unit);
619 if (!DU[D_PRT])
620 continue;
621 specified++;
622 if (pi_init(tape->pi, 0, DU[D_PRT], DU[D_MOD], DU[D_UNI],
623 DU[D_PRO], DU[D_DLY], pt_scratch, PI_PT,
624 verbose, tape->name)) {
625 if (!pt_probe(tape)) {
626 tape->present = 1;
627 found++;
628 } else
629 pi_release(tape->pi);
630 }
631 }
632 if (specified == 0) {
633 tape = pt;
634 if (pi_init(tape->pi, 1, -1, -1, -1, -1, -1, pt_scratch,
635 PI_PT, verbose, tape->name)) {
636 if (!pt_probe(tape)) {
637 tape->present = 1;
638 found++;
639 } else
640 pi_release(tape->pi);
641 }
642
643 }
644 if (found)
645 return 0;
646
647 printk("%s: No ATAPI tape drive detected\n", name);
648 return -1;
649}
650
651static int pt_open(struct inode *inode, struct file *file)
652{
653 int unit = iminor(inode) & 0x7F;
654 struct pt_unit *tape = pt + unit;
655 int err;
656
657 mutex_lock(&pt_mutex);
658 if (unit >= PT_UNITS || (!tape->present)) {
659 mutex_unlock(&pt_mutex);
660 return -ENODEV;
661 }
662
663 err = -EBUSY;
664 if (!atomic_dec_and_test(&tape->available))
665 goto out;
666
667 pt_identify(tape);
668
669 err = -ENODEV;
670 if (!(tape->flags & PT_MEDIA))
671 goto out;
672
673 err = -EROFS;
674 if ((!(tape->flags & PT_WRITE_OK)) && (file->f_mode & FMODE_WRITE))
675 goto out;
676
677 if (!(iminor(inode) & 128))
678 tape->flags |= PT_REWIND;
679
680 err = -ENOMEM;
681 tape->bufptr = kmalloc(PT_BUFSIZE, GFP_KERNEL);
682 if (tape->bufptr == NULL) {
683 printk("%s: buffer allocation failed\n", tape->name);
684 goto out;
685 }
686
687 file->private_data = tape;
688 mutex_unlock(&pt_mutex);
689 return 0;
690
691out:
692 atomic_inc(&tape->available);
693 mutex_unlock(&pt_mutex);
694 return err;
695}
696
697static long pt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
698{
699 struct pt_unit *tape = file->private_data;
700 struct mtop __user *p = (void __user *)arg;
701 struct mtop mtop;
702
703 switch (cmd) {
704 case MTIOCTOP:
705 if (copy_from_user(&mtop, p, sizeof(struct mtop)))
706 return -EFAULT;
707
708 switch (mtop.mt_op) {
709
710 case MTREW:
711 mutex_lock(&pt_mutex);
712 pt_rewind(tape);
713 mutex_unlock(&pt_mutex);
714 return 0;
715
716 case MTWEOF:
717 mutex_lock(&pt_mutex);
718 pt_write_fm(tape);
719 mutex_unlock(&pt_mutex);
720 return 0;
721
722 default:
723
724 printk(KERN_DEBUG "%s: Unimplemented mt_op %d\n", tape->name,
725 mtop.mt_op);
726 return -EINVAL;
727 }
728
729 default:
730 return -ENOTTY;
731 }
732}
733
734static int
735pt_release(struct inode *inode, struct file *file)
736{
737 struct pt_unit *tape = file->private_data;
738
739 if (atomic_read(&tape->available) > 1)
740 return -EINVAL;
741
742 if (tape->flags & PT_WRITING)
743 pt_write_fm(tape);
744
745 if (tape->flags & PT_REWIND)
746 pt_rewind(tape);
747
748 kfree(tape->bufptr);
749 tape->bufptr = NULL;
750
751 atomic_inc(&tape->available);
752
753 return 0;
754
755}
756
757static ssize_t pt_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
758{
759 struct pt_unit *tape = filp->private_data;
760 struct pi_adapter *pi = tape->pi;
761 char rd_cmd[12] = { ATAPI_READ_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
762 int k, n, r, p, s, t, b;
763
764 if (!(tape->flags & (PT_READING | PT_WRITING))) {
765 tape->flags |= PT_READING;
766 if (pt_atapi(tape, rd_cmd, 0, NULL, "start read-ahead"))
767 return -EIO;
768 } else if (tape->flags & PT_WRITING)
769 return -EIO;
770
771 if (tape->flags & PT_EOF)
772 return 0;
773
774 t = 0;
775
776 while (count > 0) {
777
778 if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "read"))
779 return -EIO;
780
781 n = count;
782 if (n > 32768)
783 n = 32768;
784 b = (n - 1 + tape->bs) / tape->bs;
785 n = b * tape->bs;
786
787 rd_cmd[4] = b;
788
789 r = pt_command(tape, rd_cmd, n, "read");
790
791 mdelay(1);
792
793 if (r) {
794 pt_req_sense(tape, 0);
795 return -EIO;
796 }
797
798 while (1) {
799
800 r = pt_wait(tape, STAT_BUSY,
801 STAT_DRQ | STAT_ERR | STAT_READY,
802 DBMSG("read DRQ"), "");
803
804 if (r & STAT_SENSE) {
805 pi_disconnect(pi);
806 pt_req_sense(tape, 0);
807 return -EIO;
808 }
809
810 if (r)
811 tape->flags |= PT_EOF;
812
813 s = read_reg(pi, 7);
814
815 if (!(s & STAT_DRQ))
816 break;
817
818 n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
819 p = (read_reg(pi, 2) & 3);
820 if (p != 2) {
821 pi_disconnect(pi);
822 printk("%s: Phase error on read: %d\n", tape->name,
823 p);
824 return -EIO;
825 }
826
827 while (n > 0) {
828 k = n;
829 if (k > PT_BUFSIZE)
830 k = PT_BUFSIZE;
831 pi_read_block(pi, tape->bufptr, k);
832 n -= k;
833 b = k;
834 if (b > count)
835 b = count;
836 if (copy_to_user(buf + t, tape->bufptr, b)) {
837 pi_disconnect(pi);
838 return -EFAULT;
839 }
840 t += b;
841 count -= b;
842 }
843
844 }
845 pi_disconnect(pi);
846 if (tape->flags & PT_EOF)
847 break;
848 }
849
850 return t;
851
852}
853
854static ssize_t pt_write(struct file *filp, const char __user *buf, size_t count, loff_t * ppos)
855{
856 struct pt_unit *tape = filp->private_data;
857 struct pi_adapter *pi = tape->pi;
858 char wr_cmd[12] = { ATAPI_WRITE_6, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
859 int k, n, r, p, s, t, b;
860
861 if (!(tape->flags & PT_WRITE_OK))
862 return -EROFS;
863
864 if (!(tape->flags & (PT_READING | PT_WRITING))) {
865 tape->flags |= PT_WRITING;
866 if (pt_atapi
867 (tape, wr_cmd, 0, NULL, "start buffer-available mode"))
868 return -EIO;
869 } else if (tape->flags & PT_READING)
870 return -EIO;
871
872 if (tape->flags & PT_EOF)
873 return -ENOSPC;
874
875 t = 0;
876
877 while (count > 0) {
878
879 if (!pt_poll_dsc(tape, HZ / 100, PT_TMO, "write"))
880 return -EIO;
881
882 n = count;
883 if (n > 32768)
884 n = 32768;
885 b = (n - 1 + tape->bs) / tape->bs;
886 n = b * tape->bs;
887
888 wr_cmd[4] = b;
889
890 r = pt_command(tape, wr_cmd, n, "write");
891
892 mdelay(1);
893
894 if (r) {
895 pt_req_sense(tape, 0);
896 return -EIO;
897 }
898
899 while (1) {
900
901 r = pt_wait(tape, STAT_BUSY,
902 STAT_DRQ | STAT_ERR | STAT_READY,
903 DBMSG("write DRQ"), NULL);
904
905 if (r & STAT_SENSE) {
906 pi_disconnect(pi);
907 pt_req_sense(tape, 0);
908 return -EIO;
909 }
910
911 if (r)
912 tape->flags |= PT_EOF;
913
914 s = read_reg(pi, 7);
915
916 if (!(s & STAT_DRQ))
917 break;
918
919 n = (read_reg(pi, 4) + 256 * read_reg(pi, 5));
920 p = (read_reg(pi, 2) & 3);
921 if (p != 0) {
922 pi_disconnect(pi);
923 printk("%s: Phase error on write: %d \n",
924 tape->name, p);
925 return -EIO;
926 }
927
928 while (n > 0) {
929 k = n;
930 if (k > PT_BUFSIZE)
931 k = PT_BUFSIZE;
932 b = k;
933 if (b > count)
934 b = count;
935 if (copy_from_user(tape->bufptr, buf + t, b)) {
936 pi_disconnect(pi);
937 return -EFAULT;
938 }
939 pi_write_block(pi, tape->bufptr, k);
940 t += b;
941 count -= b;
942 n -= k;
943 }
944
945 }
946 pi_disconnect(pi);
947 if (tape->flags & PT_EOF)
948 break;
949 }
950
951 return t;
952}
953
954static int __init pt_init(void)
955{
956 int unit;
957 int err;
958
959 if (disable) {
960 err = -EINVAL;
961 goto out;
962 }
963
964 if (pt_detect()) {
965 err = -ENODEV;
966 goto out;
967 }
968
969 err = register_chrdev(major, name, &pt_fops);
970 if (err < 0) {
971 printk("pt_init: unable to get major number %d\n", major);
972 for (unit = 0; unit < PT_UNITS; unit++)
973 if (pt[unit].present)
974 pi_release(pt[unit].pi);
975 goto out;
976 }
977 major = err;
978 pt_class = class_create(THIS_MODULE, "pt");
979 if (IS_ERR(pt_class)) {
980 err = PTR_ERR(pt_class);
981 goto out_chrdev;
982 }
983
984 for (unit = 0; unit < PT_UNITS; unit++)
985 if (pt[unit].present) {
986 device_create(pt_class, NULL, MKDEV(major, unit), NULL,
987 "pt%d", unit);
988 device_create(pt_class, NULL, MKDEV(major, unit + 128),
989 NULL, "pt%dn", unit);
990 }
991 goto out;
992
993out_chrdev:
994 unregister_chrdev(major, "pt");
995out:
996 return err;
997}
998
999static void __exit pt_exit(void)
1000{
1001 int unit;
1002 for (unit = 0; unit < PT_UNITS; unit++)
1003 if (pt[unit].present) {
1004 device_destroy(pt_class, MKDEV(major, unit));
1005 device_destroy(pt_class, MKDEV(major, unit + 128));
1006 }
1007 class_destroy(pt_class);
1008 unregister_chrdev(major, name);
1009 for (unit = 0; unit < PT_UNITS; unit++)
1010 if (pt[unit].present)
1011 pi_release(pt[unit].pi);
1012}
1013
1014MODULE_LICENSE("GPL");
1015module_init(pt_init)
1016module_exit(pt_exit)
1017