2 pt.c (c) 1998 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
5 This is the high-level driver for parallel port ATAPI tape
6 drives based on chips supported by the paride module.
8 The driver implements both rewinding and non-rewinding
9 devices, filemarks, and the rewind ioctl. It allocates
10 a small internal "bounce buffer" for each open device, but
11 otherwise expects buffering and blocking to be done at the
12 user level. As with most block-structured tapes, short
13 writes are padded to full tape blocks, so reading back a file
14 may return more data than was actually written.
16 By default, the driver will autoprobe for a single parallel
17 port ATAPI tape drive, but if their individual parameters are
18 specified, the driver can handle up to 4 drives.
20 The rewinding devices are named /dev/pt0, /dev/pt1, ...
21 while the non-rewinding devices are /dev/npt0, /dev/npt1, etc.
23 The behaviour of the pt driver can be altered by setting
24 some parameters from the insmod command line. The following
25 parameters are adjustable:
27 drive0 These four arguments can be arrays of
28 drive1 1-6 integers as follows:
30 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<dly>
34 <prt> is the base of the parallel port address for
35 the corresponding drive. (required)
37 <pro> is the protocol number for the adapter that
38 supports this drive. These numbers are
39 logged by 'paride' when the protocol modules
40 are initialised. (0 if not given)
42 <uni> for those adapters that support chained
43 devices, this is the unit selector for the
44 chain of devices on the given port. It should
45 be zero for devices that don't support chaining.
48 <mod> this can be -1 to choose the best mode, or one
49 of the mode numbers supported by the adapter.
52 <slv> ATAPI devices can be jumpered to master or slave.
53 Set this to 0 to choose the master drive, 1 to
54 choose the slave, -1 (the default) to choose the
57 <dly> some parallel ports require the driver to
58 go more slowly. -1 sets a default value that
59 should work with the chosen protocol. Otherwise,
60 set this to a small integer, the larger it is
61 the slower the port i/o. In some cases, setting
62 this to zero will speed up the device. (default -1)
64 major You may use this parameter to overide the
65 default major number (96) that this driver
66 will use. Be sure to change the device
69 name This parameter is a character string that
70 contains the name the kernel will use for this
71 device (in /proc output, for instance).
74 verbose This parameter controls the amount of logging
75 that the driver will do. Set it to 0 for
76 normal operation, 1 to see autoprobe progress
77 messages, or 2 to see additional debugging
80 If this driver is built into the kernel, you can use
81 the following command line parameters, with the same values
82 as the corresponding module parameters listed above:
89 In addition, you can use the parameter pt.disable to disable
96 1.01 GRG 1998.05.06 Round up transfer size, fix ready_wait,
97 loosed interpretation of ATAPI standard
98 for clearing error status.
100 1.02 GRG 1998.06.16 Eliminate an Ugh.
101 1.03 GRG 1998.08.15 Adjusted PT_TMO, use HZ in loop timing,
103 1.04 GRG 1998.09.24 Repair minor coding error, added jumbo support
107 #define PT_VERSION "1.04"
112 /* Here are things one can override from the insmod command.
113 Most are autoprobed by paride unless set here. Verbose is on
118 static int verbose
= 0;
119 static int major
= PT_MAJOR
;
120 static char *name
= PT_NAME
;
121 static int disable
= 0;
123 static int drive0
[6] = { 0, 0, 0, -1, -1, -1 };
124 static int drive1
[6] = { 0, 0, 0, -1, -1, -1 };
125 static int drive2
[6] = { 0, 0, 0, -1, -1, -1 };
126 static int drive3
[6] = { 0, 0, 0, -1, -1, -1 };
128 static int (*drives
[4])[6] = {&drive0
, &drive1
, &drive2
, &drive3
};
137 #define DU (*drives[unit])
139 /* end of parameters */
141 #include <linux/module.h>
142 #include <linux/init.h>
143 #include <linux/fs.h>
144 #include <linux/devfs_fs_kernel.h>
145 #include <linux/delay.h>
146 #include <linux/slab.h>
147 #include <linux/mtio.h>
148 #include <linux/device.h>
150 #include <asm/uaccess.h>
152 module_param(verbose
, bool, 0);
153 module_param(major
, int, 0);
154 module_param(name
, charp
, 0);
155 module_param_array(drive0
, int, NULL
, 0);
156 module_param_array(drive1
, int, NULL
, 0);
157 module_param_array(drive2
, int, NULL
, 0);
158 module_param_array(drive3
, int, NULL
, 0);
162 #define PT_MAX_RETRIES 5
163 #define PT_TMO 3000 /* interrupt timeout in jiffies */
164 #define PT_SPIN_DEL 50 /* spin delay in micro-seconds */
165 #define PT_RESET_TMO 30 /* 30 seconds */
166 #define PT_READY_TMO 60 /* 60 seconds */
167 #define PT_REWIND_TMO 1200 /* 20 minutes */
169 #define PT_SPIN ((1000000/(HZ*PT_SPIN_DEL))*PT_TMO)
171 #define STAT_ERR 0x00001
172 #define STAT_INDEX 0x00002
173 #define STAT_ECC 0x00004
174 #define STAT_DRQ 0x00008
175 #define STAT_SEEK 0x00010
176 #define STAT_WRERR 0x00020
177 #define STAT_READY 0x00040
178 #define STAT_BUSY 0x00080
179 #define STAT_SENSE 0x1f000
181 #define ATAPI_TEST_READY 0x00
182 #define ATAPI_REWIND 0x01
183 #define ATAPI_REQ_SENSE 0x03
184 #define ATAPI_READ_6 0x08
185 #define ATAPI_WRITE_6 0x0a
186 #define ATAPI_WFM 0x10
187 #define ATAPI_IDENTIFY 0x12
188 #define ATAPI_MODE_SENSE 0x1a
189 #define ATAPI_LOG_SENSE 0x4d
191 static int pt_open(struct inode
*inode
, struct file
*file
);
192 static int pt_ioctl(struct inode
*inode
, struct file
*file
,
193 unsigned int cmd
, unsigned long arg
);
194 static int pt_release(struct inode
*inode
, struct file
*file
);
195 static ssize_t
pt_read(struct file
*filp
, char __user
*buf
,
196 size_t count
, loff_t
* ppos
);
197 static ssize_t
pt_write(struct file
*filp
, const char __user
*buf
,
198 size_t count
, loff_t
* ppos
);
199 static int pt_detect(void);
201 /* bits in tape->flags */
204 #define PT_WRITE_OK 2
207 #define PT_READING 16
211 #define PT_BUFSIZE 16384
214 struct pi_adapter pia
; /* interface to paride layer */
215 struct pi_adapter
*pi
;
216 int flags
; /* various state flags */
217 int last_sense
; /* result of last request sense */
218 int drive
; /* drive */
219 atomic_t available
; /* 1 if access is available 0 otherwise */
220 int bs
; /* block size */
221 int capacity
; /* Size of tape in KB */
222 int present
; /* device present ? */
224 char name
[PT_NAMELEN
]; /* pf0, pf1, ... */
227 static int pt_identify(struct pt_unit
*tape
);
229 static struct pt_unit pt
[PT_UNITS
];
231 static char pt_scratch
[512]; /* scratch block buffer */
233 /* kernel glue structures */
235 static struct file_operations pt_fops
= {
236 .owner
= THIS_MODULE
,
241 .release
= pt_release
,
244 /* sysfs class support */
245 static struct class *pt_class
;
247 static inline int status_reg(struct pi_adapter
*pi
)
249 return pi_read_regr(pi
, 1, 6);
252 static inline int read_reg(struct pi_adapter
*pi
, int reg
)
254 return pi_read_regr(pi
, 0, reg
);
257 static inline void write_reg(struct pi_adapter
*pi
, int reg
, int val
)
259 pi_write_regr(pi
, 0, reg
, val
);
262 static inline u8
DRIVE(struct pt_unit
*tape
)
264 return 0xa0+0x10*tape
->drive
;
267 static int pt_wait(struct pt_unit
*tape
, int go
, int stop
, char *fun
, char *msg
)
270 struct pi_adapter
*pi
= tape
->pi
;
273 while ((((r
= status_reg(pi
)) & go
) || (stop
&& (!(r
& stop
))))
277 if ((r
& (STAT_ERR
& stop
)) || (j
>= PT_SPIN
)) {
284 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
285 " loop=%d phase=%d\n",
286 tape
->name
, fun
, msg
, r
, s
, e
, j
, p
);
292 static int pt_command(struct pt_unit
*tape
, char *cmd
, int dlen
, char *fun
)
294 struct pi_adapter
*pi
= tape
->pi
;
297 write_reg(pi
, 6, DRIVE(tape
));
299 if (pt_wait(tape
, STAT_BUSY
| STAT_DRQ
, 0, fun
, "before command")) {
304 write_reg(pi
, 4, dlen
% 256);
305 write_reg(pi
, 5, dlen
/ 256);
306 write_reg(pi
, 7, 0xa0); /* ATAPI packet command */
308 if (pt_wait(tape
, STAT_BUSY
, STAT_DRQ
, fun
, "command DRQ")) {
313 if (read_reg(pi
, 2) != 1) {
314 printk("%s: %s: command phase error\n", tape
->name
, fun
);
319 pi_write_block(pi
, cmd
, 12);
324 static int pt_completion(struct pt_unit
*tape
, char *buf
, char *fun
)
326 struct pi_adapter
*pi
= tape
->pi
;
329 r
= pt_wait(tape
, STAT_BUSY
, STAT_DRQ
| STAT_READY
| STAT_ERR
,
332 if (read_reg(pi
, 7) & STAT_DRQ
) {
333 n
= (((read_reg(pi
, 4) + 256 * read_reg(pi
, 5)) +
335 p
= read_reg(pi
, 2) & 3;
337 pi_write_block(pi
, buf
, n
);
339 pi_read_block(pi
, buf
, n
);
342 s
= pt_wait(tape
, STAT_BUSY
, STAT_READY
| STAT_ERR
, fun
, "data done");
349 static void pt_req_sense(struct pt_unit
*tape
, int quiet
)
351 char rs_cmd
[12] = { ATAPI_REQ_SENSE
, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
355 r
= pt_command(tape
, rs_cmd
, 16, "Request sense");
358 pt_completion(tape
, buf
, "Request sense");
360 tape
->last_sense
= -1;
363 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
364 tape
->name
, buf
[2] & 0xf, buf
[12], buf
[13]);
365 tape
->last_sense
= (buf
[2] & 0xf) | ((buf
[12] & 0xff) << 8)
366 | ((buf
[13] & 0xff) << 16);
370 static int pt_atapi(struct pt_unit
*tape
, char *cmd
, int dlen
, char *buf
, char *fun
)
374 r
= pt_command(tape
, cmd
, dlen
, fun
);
377 r
= pt_completion(tape
, buf
, fun
);
379 pt_req_sense(tape
, !fun
);
384 static void pt_sleep(int cs
)
386 current
->state
= TASK_INTERRUPTIBLE
;
387 schedule_timeout(cs
);
390 static int pt_poll_dsc(struct pt_unit
*tape
, int pause
, int tmo
, char *msg
)
392 struct pi_adapter
*pi
= tape
->pi
;
402 write_reg(pi
, 6, DRIVE(tape
));
406 if (s
& (STAT_ERR
| STAT_SEEK
))
409 if ((k
>= tmo
) || (s
& STAT_ERR
)) {
411 printk("%s: %s DSC timeout\n", tape
->name
, msg
);
413 printk("%s: %s stat=0x%x err=0x%x\n", tape
->name
, msg
, s
,
415 pt_req_sense(tape
, 0);
421 static void pt_media_access_cmd(struct pt_unit
*tape
, int tmo
, char *cmd
, char *fun
)
423 if (pt_command(tape
, cmd
, 0, fun
)) {
424 pt_req_sense(tape
, 0);
427 pi_disconnect(tape
->pi
);
428 pt_poll_dsc(tape
, HZ
, tmo
, fun
);
431 static void pt_rewind(struct pt_unit
*tape
)
433 char rw_cmd
[12] = { ATAPI_REWIND
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
435 pt_media_access_cmd(tape
, PT_REWIND_TMO
, rw_cmd
, "rewind");
438 static void pt_write_fm(struct pt_unit
*tape
)
440 char wm_cmd
[12] = { ATAPI_WFM
, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 };
442 pt_media_access_cmd(tape
, PT_TMO
, wm_cmd
, "write filemark");
445 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
447 static int pt_reset(struct pt_unit
*tape
)
449 struct pi_adapter
*pi
= tape
->pi
;
451 int expect
[5] = { 1, 1, 1, 0x14, 0xeb };
454 write_reg(pi
, 6, DRIVE(tape
));
457 pt_sleep(20 * HZ
/ 1000);
460 while ((k
++ < PT_RESET_TMO
) && (status_reg(pi
) & STAT_BUSY
))
464 for (i
= 0; i
< 5; i
++)
465 flg
&= (read_reg(pi
, i
+ 1) == expect
[i
]);
468 printk("%s: Reset (%d) signature = ", tape
->name
, k
);
469 for (i
= 0; i
< 5; i
++)
470 printk("%3x", read_reg(pi
, i
+ 1));
472 printk(" (incorrect)");
480 static int pt_ready_wait(struct pt_unit
*tape
, int tmo
)
482 char tr_cmd
[12] = { ATAPI_TEST_READY
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
487 tape
->last_sense
= 0;
488 pt_atapi(tape
, tr_cmd
, 0, NULL
, DBMSG("test unit ready"));
489 p
= tape
->last_sense
;
492 if (!(((p
& 0xffff) == 0x0402) || ((p
& 0xff) == 6)))
497 return 0x000020; /* timeout */
500 static void xs(char *buf
, char *targ
, int offs
, int len
)
506 for (k
= 0; k
< len
; k
++)
507 if ((buf
[k
+ offs
] != 0x20) || (buf
[k
+ offs
] != l
))
508 l
= targ
[j
++] = buf
[k
+ offs
];
514 static int xn(char *buf
, int offs
, int size
)
519 for (k
= 0; k
< size
; k
++)
520 v
= v
* 256 + (buf
[k
+ offs
] & 0xff);
524 static int pt_identify(struct pt_unit
*tape
)
527 char *ms
[2] = { "master", "slave" };
529 char id_cmd
[12] = { ATAPI_IDENTIFY
, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
531 { ATAPI_MODE_SENSE
, 0, 0x2a, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
533 { ATAPI_LOG_SENSE
, 0, 0x71, 0, 0, 0, 0, 0, 36, 0, 0, 0 };
536 s
= pt_atapi(tape
, id_cmd
, 36, buf
, "identify");
543 printk("%s: Drive %d, unsupported type %d\n",
544 tape
->name
, tape
->drive
, dt
);
555 if (!pt_ready_wait(tape
, PT_READY_TMO
))
556 tape
->flags
|= PT_MEDIA
;
558 if (!pt_atapi(tape
, ms_cmd
, 36, buf
, "mode sense")) {
559 if (!(buf
[2] & 0x80))
560 tape
->flags
|= PT_WRITE_OK
;
561 tape
->bs
= xn(buf
, 10, 2);
564 if (!pt_atapi(tape
, ls_cmd
, 36, buf
, "log sense"))
565 tape
->capacity
= xn(buf
, 24, 4);
567 printk("%s: %s %s, %s", tape
->name
, mf
, id
, ms
[tape
->drive
]);
568 if (!(tape
->flags
& PT_MEDIA
))
569 printk(", no media\n");
571 if (!(tape
->flags
& PT_WRITE_OK
))
573 printk(", blocksize %d, %d MB\n", tape
->bs
, tape
->capacity
/ 1024);
581 * returns 0, with id set if drive is detected
582 * -1, if drive detection failed
584 static int pt_probe(struct pt_unit
*tape
)
586 if (tape
->drive
== -1) {
587 for (tape
->drive
= 0; tape
->drive
<= 1; tape
->drive
++)
589 return pt_identify(tape
);
592 return pt_identify(tape
);
597 static int pt_detect(void)
599 struct pt_unit
*tape
;
600 int specified
= 0, found
= 0;
603 printk("%s: %s version %s, major %d\n", name
, name
, PT_VERSION
, major
);
606 for (unit
= 0; unit
< PT_UNITS
; unit
++) {
607 struct pt_unit
*tape
= &pt
[unit
];
608 tape
->pi
= &tape
->pia
;
609 atomic_set(&tape
->available
, 1);
611 tape
->last_sense
= 0;
614 tape
->drive
= DU
[D_SLV
];
615 snprintf(tape
->name
, PT_NAMELEN
, "%s%d", name
, unit
);
619 if (pi_init(tape
->pi
, 0, DU
[D_PRT
], DU
[D_MOD
], DU
[D_UNI
],
620 DU
[D_PRO
], DU
[D_DLY
], pt_scratch
, PI_PT
,
621 verbose
, tape
->name
)) {
622 if (!pt_probe(tape
)) {
626 pi_release(tape
->pi
);
629 if (specified
== 0) {
631 if (pi_init(tape
->pi
, 1, -1, -1, -1, -1, -1, pt_scratch
,
632 PI_PT
, verbose
, tape
->name
)) {
633 if (!pt_probe(tape
)) {
637 pi_release(tape
->pi
);
644 printk("%s: No ATAPI tape drive detected\n", name
);
648 static int pt_open(struct inode
*inode
, struct file
*file
)
650 int unit
= iminor(inode
) & 0x7F;
651 struct pt_unit
*tape
= pt
+ unit
;
654 if (unit
>= PT_UNITS
|| (!tape
->present
))
658 if (!atomic_dec_and_test(&tape
->available
))
664 if (!tape
->flags
& PT_MEDIA
)
668 if ((!tape
->flags
& PT_WRITE_OK
) && (file
->f_mode
& 2))
671 if (!(iminor(inode
) & 128))
672 tape
->flags
|= PT_REWIND
;
675 tape
->bufptr
= kmalloc(PT_BUFSIZE
, GFP_KERNEL
);
676 if (tape
->bufptr
== NULL
) {
677 printk("%s: buffer allocation failed\n", tape
->name
);
681 file
->private_data
= tape
;
685 atomic_inc(&tape
->available
);
689 static int pt_ioctl(struct inode
*inode
, struct file
*file
,
690 unsigned int cmd
, unsigned long arg
)
692 struct pt_unit
*tape
= file
->private_data
;
693 struct mtop __user
*p
= (void __user
*)arg
;
698 if (copy_from_user(&mtop
, p
, sizeof(struct mtop
)))
701 switch (mtop
.mt_op
) {
712 printk("%s: Unimplemented mt_op %d\n", tape
->name
,
718 printk("%s: Unimplemented ioctl 0x%x\n", tape
->name
, cmd
);
725 pt_release(struct inode
*inode
, struct file
*file
)
727 struct pt_unit
*tape
= file
->private_data
;
729 if (atomic_read(&tape
->available
) > 1)
732 if (tape
->flags
& PT_WRITING
)
735 if (tape
->flags
& PT_REWIND
)
741 atomic_inc(&tape
->available
);
747 static ssize_t
pt_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
* ppos
)
749 struct pt_unit
*tape
= filp
->private_data
;
750 struct pi_adapter
*pi
= tape
->pi
;
751 char rd_cmd
[12] = { ATAPI_READ_6
, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
752 int k
, n
, r
, p
, s
, t
, b
;
754 if (!(tape
->flags
& (PT_READING
| PT_WRITING
))) {
755 tape
->flags
|= PT_READING
;
756 if (pt_atapi(tape
, rd_cmd
, 0, NULL
, "start read-ahead"))
758 } else if (tape
->flags
& PT_WRITING
)
761 if (tape
->flags
& PT_EOF
)
768 if (!pt_poll_dsc(tape
, HZ
/ 100, PT_TMO
, "read"))
773 n
= 32768; /* max per command */
774 b
= (n
- 1 + tape
->bs
) / tape
->bs
;
775 n
= b
* tape
->bs
; /* rounded up to even block */
779 r
= pt_command(tape
, rd_cmd
, n
, "read");
784 pt_req_sense(tape
, 0);
790 r
= pt_wait(tape
, STAT_BUSY
,
791 STAT_DRQ
| STAT_ERR
| STAT_READY
,
792 DBMSG("read DRQ"), "");
794 if (r
& STAT_SENSE
) {
796 pt_req_sense(tape
, 0);
801 tape
->flags
|= PT_EOF
;
808 n
= (read_reg(pi
, 4) + 256 * read_reg(pi
, 5));
809 p
= (read_reg(pi
, 2) & 3);
812 printk("%s: Phase error on read: %d\n", tape
->name
,
821 pi_read_block(pi
, tape
->bufptr
, k
);
826 if (copy_to_user(buf
+ t
, tape
->bufptr
, b
)) {
836 if (tape
->flags
& PT_EOF
)
844 static ssize_t
pt_write(struct file
*filp
, const char __user
*buf
, size_t count
, loff_t
* ppos
)
846 struct pt_unit
*tape
= filp
->private_data
;
847 struct pi_adapter
*pi
= tape
->pi
;
848 char wr_cmd
[12] = { ATAPI_WRITE_6
, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
849 int k
, n
, r
, p
, s
, t
, b
;
851 if (!(tape
->flags
& PT_WRITE_OK
))
854 if (!(tape
->flags
& (PT_READING
| PT_WRITING
))) {
855 tape
->flags
|= PT_WRITING
;
857 (tape
, wr_cmd
, 0, NULL
, "start buffer-available mode"))
859 } else if (tape
->flags
& PT_READING
)
862 if (tape
->flags
& PT_EOF
)
869 if (!pt_poll_dsc(tape
, HZ
/ 100, PT_TMO
, "write"))
874 n
= 32768; /* max per command */
875 b
= (n
- 1 + tape
->bs
) / tape
->bs
;
876 n
= b
* tape
->bs
; /* rounded up to even block */
880 r
= pt_command(tape
, wr_cmd
, n
, "write");
884 if (r
) { /* error delivering command only */
885 pt_req_sense(tape
, 0);
891 r
= pt_wait(tape
, STAT_BUSY
,
892 STAT_DRQ
| STAT_ERR
| STAT_READY
,
893 DBMSG("write DRQ"), NULL
);
895 if (r
& STAT_SENSE
) {
897 pt_req_sense(tape
, 0);
902 tape
->flags
|= PT_EOF
;
909 n
= (read_reg(pi
, 4) + 256 * read_reg(pi
, 5));
910 p
= (read_reg(pi
, 2) & 3);
913 printk("%s: Phase error on write: %d \n",
925 if (copy_from_user(tape
->bufptr
, buf
+ t
, b
)) {
929 pi_write_block(pi
, tape
->bufptr
, k
);
937 if (tape
->flags
& PT_EOF
)
944 static int __init
pt_init(void)
958 if (register_chrdev(major
, name
, &pt_fops
)) {
959 printk("pt_init: unable to get major number %d\n", major
);
960 for (unit
= 0; unit
< PT_UNITS
; unit
++)
961 if (pt
[unit
].present
)
962 pi_release(pt
[unit
].pi
);
966 pt_class
= class_create(THIS_MODULE
, "pt");
967 if (IS_ERR(pt_class
)) {
968 err
= PTR_ERR(pt_class
);
973 for (unit
= 0; unit
< PT_UNITS
; unit
++)
974 if (pt
[unit
].present
) {
975 class_device_create(pt_class
, MKDEV(major
, unit
),
977 err
= devfs_mk_cdev(MKDEV(major
, unit
),
978 S_IFCHR
| S_IRUSR
| S_IWUSR
,
981 class_device_destroy(pt_class
, MKDEV(major
, unit
));
984 class_device_create(pt_class
, MKDEV(major
, unit
+ 128),
985 NULL
, "pt%dn", unit
);
986 err
= devfs_mk_cdev(MKDEV(major
, unit
+ 128),
987 S_IFCHR
| S_IRUSR
| S_IWUSR
,
990 class_device_destroy(pt_class
, MKDEV(major
, unit
+ 128));
997 class_destroy(pt_class
);
999 unregister_chrdev(major
, "pt");
1004 static void __exit
pt_exit(void)
1007 for (unit
= 0; unit
< PT_UNITS
; unit
++)
1008 if (pt
[unit
].present
) {
1009 class_device_destroy(pt_class
, MKDEV(major
, unit
));
1010 devfs_remove("pt/%d", unit
);
1011 class_device_destroy(pt_class
, MKDEV(major
, unit
+ 128));
1012 devfs_remove("pt/%dn", unit
);
1014 class_destroy(pt_class
);
1016 unregister_chrdev(major
, name
);
1017 for (unit
= 0; unit
< PT_UNITS
; unit
++)
1018 if (pt
[unit
].present
)
1019 pi_release(pt
[unit
].pi
);
1022 MODULE_LICENSE("GPL");
1023 module_init(pt_init
)
1024 module_exit(pt_exit
)
This page took 0.05091 seconds and 6 git commands to generate.