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 schedule_timeout_interruptible(cs
);
389 static int pt_poll_dsc(struct pt_unit
*tape
, int pause
, int tmo
, char *msg
)
391 struct pi_adapter
*pi
= tape
->pi
;
401 write_reg(pi
, 6, DRIVE(tape
));
405 if (s
& (STAT_ERR
| STAT_SEEK
))
408 if ((k
>= tmo
) || (s
& STAT_ERR
)) {
410 printk("%s: %s DSC timeout\n", tape
->name
, msg
);
412 printk("%s: %s stat=0x%x err=0x%x\n", tape
->name
, msg
, s
,
414 pt_req_sense(tape
, 0);
420 static void pt_media_access_cmd(struct pt_unit
*tape
, int tmo
, char *cmd
, char *fun
)
422 if (pt_command(tape
, cmd
, 0, fun
)) {
423 pt_req_sense(tape
, 0);
426 pi_disconnect(tape
->pi
);
427 pt_poll_dsc(tape
, HZ
, tmo
, fun
);
430 static void pt_rewind(struct pt_unit
*tape
)
432 char rw_cmd
[12] = { ATAPI_REWIND
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
434 pt_media_access_cmd(tape
, PT_REWIND_TMO
, rw_cmd
, "rewind");
437 static void pt_write_fm(struct pt_unit
*tape
)
439 char wm_cmd
[12] = { ATAPI_WFM
, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 };
441 pt_media_access_cmd(tape
, PT_TMO
, wm_cmd
, "write filemark");
444 #define DBMSG(msg) ((verbose>1)?(msg):NULL)
446 static int pt_reset(struct pt_unit
*tape
)
448 struct pi_adapter
*pi
= tape
->pi
;
450 int expect
[5] = { 1, 1, 1, 0x14, 0xeb };
453 write_reg(pi
, 6, DRIVE(tape
));
456 pt_sleep(20 * HZ
/ 1000);
459 while ((k
++ < PT_RESET_TMO
) && (status_reg(pi
) & STAT_BUSY
))
463 for (i
= 0; i
< 5; i
++)
464 flg
&= (read_reg(pi
, i
+ 1) == expect
[i
]);
467 printk("%s: Reset (%d) signature = ", tape
->name
, k
);
468 for (i
= 0; i
< 5; i
++)
469 printk("%3x", read_reg(pi
, i
+ 1));
471 printk(" (incorrect)");
479 static int pt_ready_wait(struct pt_unit
*tape
, int tmo
)
481 char tr_cmd
[12] = { ATAPI_TEST_READY
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
486 tape
->last_sense
= 0;
487 pt_atapi(tape
, tr_cmd
, 0, NULL
, DBMSG("test unit ready"));
488 p
= tape
->last_sense
;
491 if (!(((p
& 0xffff) == 0x0402) || ((p
& 0xff) == 6)))
496 return 0x000020; /* timeout */
499 static void xs(char *buf
, char *targ
, int offs
, int len
)
505 for (k
= 0; k
< len
; k
++)
506 if ((buf
[k
+ offs
] != 0x20) || (buf
[k
+ offs
] != l
))
507 l
= targ
[j
++] = buf
[k
+ offs
];
513 static int xn(char *buf
, int offs
, int size
)
518 for (k
= 0; k
< size
; k
++)
519 v
= v
* 256 + (buf
[k
+ offs
] & 0xff);
523 static int pt_identify(struct pt_unit
*tape
)
526 char *ms
[2] = { "master", "slave" };
528 char id_cmd
[12] = { ATAPI_IDENTIFY
, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
530 { ATAPI_MODE_SENSE
, 0, 0x2a, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
532 { ATAPI_LOG_SENSE
, 0, 0x71, 0, 0, 0, 0, 0, 36, 0, 0, 0 };
535 s
= pt_atapi(tape
, id_cmd
, 36, buf
, "identify");
542 printk("%s: Drive %d, unsupported type %d\n",
543 tape
->name
, tape
->drive
, dt
);
554 if (!pt_ready_wait(tape
, PT_READY_TMO
))
555 tape
->flags
|= PT_MEDIA
;
557 if (!pt_atapi(tape
, ms_cmd
, 36, buf
, "mode sense")) {
558 if (!(buf
[2] & 0x80))
559 tape
->flags
|= PT_WRITE_OK
;
560 tape
->bs
= xn(buf
, 10, 2);
563 if (!pt_atapi(tape
, ls_cmd
, 36, buf
, "log sense"))
564 tape
->capacity
= xn(buf
, 24, 4);
566 printk("%s: %s %s, %s", tape
->name
, mf
, id
, ms
[tape
->drive
]);
567 if (!(tape
->flags
& PT_MEDIA
))
568 printk(", no media\n");
570 if (!(tape
->flags
& PT_WRITE_OK
))
572 printk(", blocksize %d, %d MB\n", tape
->bs
, tape
->capacity
/ 1024);
580 * returns 0, with id set if drive is detected
581 * -1, if drive detection failed
583 static int pt_probe(struct pt_unit
*tape
)
585 if (tape
->drive
== -1) {
586 for (tape
->drive
= 0; tape
->drive
<= 1; tape
->drive
++)
588 return pt_identify(tape
);
591 return pt_identify(tape
);
596 static int pt_detect(void)
598 struct pt_unit
*tape
;
599 int specified
= 0, found
= 0;
602 printk("%s: %s version %s, major %d\n", name
, name
, PT_VERSION
, major
);
605 for (unit
= 0; unit
< PT_UNITS
; unit
++) {
606 struct pt_unit
*tape
= &pt
[unit
];
607 tape
->pi
= &tape
->pia
;
608 atomic_set(&tape
->available
, 1);
610 tape
->last_sense
= 0;
613 tape
->drive
= DU
[D_SLV
];
614 snprintf(tape
->name
, PT_NAMELEN
, "%s%d", name
, unit
);
618 if (pi_init(tape
->pi
, 0, DU
[D_PRT
], DU
[D_MOD
], DU
[D_UNI
],
619 DU
[D_PRO
], DU
[D_DLY
], pt_scratch
, PI_PT
,
620 verbose
, tape
->name
)) {
621 if (!pt_probe(tape
)) {
625 pi_release(tape
->pi
);
628 if (specified
== 0) {
630 if (pi_init(tape
->pi
, 1, -1, -1, -1, -1, -1, pt_scratch
,
631 PI_PT
, verbose
, tape
->name
)) {
632 if (!pt_probe(tape
)) {
636 pi_release(tape
->pi
);
643 printk("%s: No ATAPI tape drive detected\n", name
);
647 static int pt_open(struct inode
*inode
, struct file
*file
)
649 int unit
= iminor(inode
) & 0x7F;
650 struct pt_unit
*tape
= pt
+ unit
;
653 if (unit
>= PT_UNITS
|| (!tape
->present
))
657 if (!atomic_dec_and_test(&tape
->available
))
663 if (!tape
->flags
& PT_MEDIA
)
667 if ((!tape
->flags
& PT_WRITE_OK
) && (file
->f_mode
& 2))
670 if (!(iminor(inode
) & 128))
671 tape
->flags
|= PT_REWIND
;
674 tape
->bufptr
= kmalloc(PT_BUFSIZE
, GFP_KERNEL
);
675 if (tape
->bufptr
== NULL
) {
676 printk("%s: buffer allocation failed\n", tape
->name
);
680 file
->private_data
= tape
;
684 atomic_inc(&tape
->available
);
688 static int pt_ioctl(struct inode
*inode
, struct file
*file
,
689 unsigned int cmd
, unsigned long arg
)
691 struct pt_unit
*tape
= file
->private_data
;
692 struct mtop __user
*p
= (void __user
*)arg
;
697 if (copy_from_user(&mtop
, p
, sizeof(struct mtop
)))
700 switch (mtop
.mt_op
) {
711 printk("%s: Unimplemented mt_op %d\n", tape
->name
,
717 printk("%s: Unimplemented ioctl 0x%x\n", tape
->name
, cmd
);
724 pt_release(struct inode
*inode
, struct file
*file
)
726 struct pt_unit
*tape
= file
->private_data
;
728 if (atomic_read(&tape
->available
) > 1)
731 if (tape
->flags
& PT_WRITING
)
734 if (tape
->flags
& PT_REWIND
)
740 atomic_inc(&tape
->available
);
746 static ssize_t
pt_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
* ppos
)
748 struct pt_unit
*tape
= filp
->private_data
;
749 struct pi_adapter
*pi
= tape
->pi
;
750 char rd_cmd
[12] = { ATAPI_READ_6
, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
751 int k
, n
, r
, p
, s
, t
, b
;
753 if (!(tape
->flags
& (PT_READING
| PT_WRITING
))) {
754 tape
->flags
|= PT_READING
;
755 if (pt_atapi(tape
, rd_cmd
, 0, NULL
, "start read-ahead"))
757 } else if (tape
->flags
& PT_WRITING
)
760 if (tape
->flags
& PT_EOF
)
767 if (!pt_poll_dsc(tape
, HZ
/ 100, PT_TMO
, "read"))
772 n
= 32768; /* max per command */
773 b
= (n
- 1 + tape
->bs
) / tape
->bs
;
774 n
= b
* tape
->bs
; /* rounded up to even block */
778 r
= pt_command(tape
, rd_cmd
, n
, "read");
783 pt_req_sense(tape
, 0);
789 r
= pt_wait(tape
, STAT_BUSY
,
790 STAT_DRQ
| STAT_ERR
| STAT_READY
,
791 DBMSG("read DRQ"), "");
793 if (r
& STAT_SENSE
) {
795 pt_req_sense(tape
, 0);
800 tape
->flags
|= PT_EOF
;
807 n
= (read_reg(pi
, 4) + 256 * read_reg(pi
, 5));
808 p
= (read_reg(pi
, 2) & 3);
811 printk("%s: Phase error on read: %d\n", tape
->name
,
820 pi_read_block(pi
, tape
->bufptr
, k
);
825 if (copy_to_user(buf
+ t
, tape
->bufptr
, b
)) {
835 if (tape
->flags
& PT_EOF
)
843 static ssize_t
pt_write(struct file
*filp
, const char __user
*buf
, size_t count
, loff_t
* ppos
)
845 struct pt_unit
*tape
= filp
->private_data
;
846 struct pi_adapter
*pi
= tape
->pi
;
847 char wr_cmd
[12] = { ATAPI_WRITE_6
, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
848 int k
, n
, r
, p
, s
, t
, b
;
850 if (!(tape
->flags
& PT_WRITE_OK
))
853 if (!(tape
->flags
& (PT_READING
| PT_WRITING
))) {
854 tape
->flags
|= PT_WRITING
;
856 (tape
, wr_cmd
, 0, NULL
, "start buffer-available mode"))
858 } else if (tape
->flags
& PT_READING
)
861 if (tape
->flags
& PT_EOF
)
868 if (!pt_poll_dsc(tape
, HZ
/ 100, PT_TMO
, "write"))
873 n
= 32768; /* max per command */
874 b
= (n
- 1 + tape
->bs
) / tape
->bs
;
875 n
= b
* tape
->bs
; /* rounded up to even block */
879 r
= pt_command(tape
, wr_cmd
, n
, "write");
883 if (r
) { /* error delivering command only */
884 pt_req_sense(tape
, 0);
890 r
= pt_wait(tape
, STAT_BUSY
,
891 STAT_DRQ
| STAT_ERR
| STAT_READY
,
892 DBMSG("write DRQ"), NULL
);
894 if (r
& STAT_SENSE
) {
896 pt_req_sense(tape
, 0);
901 tape
->flags
|= PT_EOF
;
908 n
= (read_reg(pi
, 4) + 256 * read_reg(pi
, 5));
909 p
= (read_reg(pi
, 2) & 3);
912 printk("%s: Phase error on write: %d \n",
924 if (copy_from_user(tape
->bufptr
, buf
+ t
, b
)) {
928 pi_write_block(pi
, tape
->bufptr
, k
);
936 if (tape
->flags
& PT_EOF
)
943 static int __init
pt_init(void)
957 if (register_chrdev(major
, name
, &pt_fops
)) {
958 printk("pt_init: unable to get major number %d\n", major
);
959 for (unit
= 0; unit
< PT_UNITS
; unit
++)
960 if (pt
[unit
].present
)
961 pi_release(pt
[unit
].pi
);
965 pt_class
= class_create(THIS_MODULE
, "pt");
966 if (IS_ERR(pt_class
)) {
967 err
= PTR_ERR(pt_class
);
972 for (unit
= 0; unit
< PT_UNITS
; unit
++)
973 if (pt
[unit
].present
) {
974 class_device_create(pt_class
, MKDEV(major
, unit
),
976 err
= devfs_mk_cdev(MKDEV(major
, unit
),
977 S_IFCHR
| S_IRUSR
| S_IWUSR
,
980 class_device_destroy(pt_class
, MKDEV(major
, unit
));
983 class_device_create(pt_class
, MKDEV(major
, unit
+ 128),
984 NULL
, "pt%dn", unit
);
985 err
= devfs_mk_cdev(MKDEV(major
, unit
+ 128),
986 S_IFCHR
| S_IRUSR
| S_IWUSR
,
989 class_device_destroy(pt_class
, MKDEV(major
, unit
+ 128));
996 class_destroy(pt_class
);
998 unregister_chrdev(major
, "pt");
1003 static void __exit
pt_exit(void)
1006 for (unit
= 0; unit
< PT_UNITS
; unit
++)
1007 if (pt
[unit
].present
) {
1008 class_device_destroy(pt_class
, MKDEV(major
, unit
));
1009 devfs_remove("pt/%d", unit
);
1010 class_device_destroy(pt_class
, MKDEV(major
, unit
+ 128));
1011 devfs_remove("pt/%dn", unit
);
1013 class_destroy(pt_class
);
1015 unregister_chrdev(major
, name
);
1016 for (unit
= 0; unit
< PT_UNITS
; unit
++)
1017 if (pt
[unit
].present
)
1018 pi_release(pt
[unit
].pi
);
1021 MODULE_LICENSE("GPL");
1022 module_init(pt_init
)
1023 module_exit(pt_exit
)
This page took 0.051416 seconds and 6 git commands to generate.