2 pg.c (c) 1998 Grant R. Guenther <grant@torque.net>
3 Under the terms of the GNU General Public License.
5 The pg driver provides a simple character device interface for
6 sending ATAPI commands to a device. With the exception of the
7 ATAPI reset operation, all operations are performed by a pair
8 of read and write operations to the appropriate /dev/pgN device.
9 A write operation delivers a command and any outbound data in
10 a single buffer. Normally, the write will succeed unless the
11 device is offline or malfunctioning, or there is already another
12 command pending. If the write succeeds, it should be followed
13 immediately by a read operation, to obtain any returned data and
14 status information. A read will fail if there is no operation
17 As a special case, the device can be reset with a write operation,
18 and in this case, no following read is expected, or permitted.
20 There are no ioctl() operations. Any single operation
21 may transfer at most PG_MAX_DATA bytes. Note that the driver must
22 copy the data through an internal buffer. In keeping with all
23 current ATAPI devices, command packets are assumed to be exactly
26 To permit future changes to this interface, the headers in the
27 read and write buffers contain a single character "magic" flag.
28 Currently this flag must be the character "P".
30 By default, the driver will autoprobe for a single parallel
31 port ATAPI device, but if their individual parameters are
32 specified, the driver can handle up to 4 devices.
34 To use this device, you must have the following device
35 special files defined:
42 (You'll need to change the 97 to something else if you use
43 the 'major' parameter to install the driver on a different
46 The behaviour of the pg driver can be altered by setting
47 some parameters from the insmod command line. The following
48 parameters are adjustable:
50 drive0 These four arguments can be arrays of
51 drive1 1-6 integers as follows:
53 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<dly>
57 <prt> is the base of the parallel port address for
58 the corresponding drive. (required)
60 <pro> is the protocol number for the adapter that
61 supports this drive. These numbers are
62 logged by 'paride' when the protocol modules
63 are initialised. (0 if not given)
65 <uni> for those adapters that support chained
66 devices, this is the unit selector for the
67 chain of devices on the given port. It should
68 be zero for devices that don't support chaining.
71 <mod> this can be -1 to choose the best mode, or one
72 of the mode numbers supported by the adapter.
75 <slv> ATAPI devices can be jumpered to master or slave.
76 Set this to 0 to choose the master drive, 1 to
77 choose the slave, -1 (the default) to choose the
80 <dly> some parallel ports require the driver to
81 go more slowly. -1 sets a default value that
82 should work with the chosen protocol. Otherwise,
83 set this to a small integer, the larger it is
84 the slower the port i/o. In some cases, setting
85 this to zero will speed up the device. (default -1)
87 major You may use this parameter to overide the
88 default major number (97) that this driver
89 will use. Be sure to change the device
92 name This parameter is a character string that
93 contains the name the kernel will use for this
94 device (in /proc output, for instance).
97 verbose This parameter controls the amount of logging
98 that is done by the driver. Set it to 0 for
99 quiet operation, to 1 to enable progress
100 messages while the driver probes for devices,
101 or to 2 for full debug logging. (default 0)
103 If this driver is built into the kernel, you can use
104 the following command line parameters, with the same values
105 as the corresponding module parameters listed above:
112 In addition, you can use the parameter pg.disable to disable
119 1.01 GRG 1998.06.16 Bug fixes
120 1.02 GRG 1998.09.24 Added jumbo support
124 #define PG_VERSION "1.02"
133 /* Here are things one can override from the insmod command.
134 Most are autoprobed by paride unless set here. Verbose is 0
139 static int verbose
= 0;
140 static int major
= PG_MAJOR
;
141 static char *name
= PG_NAME
;
142 static int disable
= 0;
144 static int drive0
[6] = { 0, 0, 0, -1, -1, -1 };
145 static int drive1
[6] = { 0, 0, 0, -1, -1, -1 };
146 static int drive2
[6] = { 0, 0, 0, -1, -1, -1 };
147 static int drive3
[6] = { 0, 0, 0, -1, -1, -1 };
149 static int (*drives
[4])[6] = {&drive0
, &drive1
, &drive2
, &drive3
};
150 static int pg_drive_count
;
152 enum {D_PRT
, D_PRO
, D_UNI
, D_MOD
, D_SLV
, D_DLY
};
154 /* end of parameters */
156 #include <linux/module.h>
157 #include <linux/init.h>
158 #include <linux/fs.h>
159 #include <linux/delay.h>
160 #include <linux/slab.h>
161 #include <linux/mtio.h>
162 #include <linux/pg.h>
163 #include <linux/device.h>
164 #include <linux/sched.h> /* current, TASK_* */
165 #include <linux/smp_lock.h>
166 #include <linux/jiffies.h>
168 #include <asm/uaccess.h>
170 module_param(verbose
, bool, 0644);
171 module_param(major
, int, 0);
172 module_param(name
, charp
, 0);
173 module_param_array(drive0
, int, NULL
, 0);
174 module_param_array(drive1
, int, NULL
, 0);
175 module_param_array(drive2
, int, NULL
, 0);
176 module_param_array(drive3
, int, NULL
, 0);
180 #define PG_SPIN_DEL 50 /* spin delay in micro-seconds */
183 #define PG_RESET_TMO 10*HZ
185 #define STAT_ERR 0x01
186 #define STAT_INDEX 0x02
187 #define STAT_ECC 0x04
188 #define STAT_DRQ 0x08
189 #define STAT_SEEK 0x10
190 #define STAT_WRERR 0x20
191 #define STAT_READY 0x40
192 #define STAT_BUSY 0x80
194 #define ATAPI_IDENTIFY 0x12
196 static int pg_open(struct inode
*inode
, struct file
*file
);
197 static int pg_release(struct inode
*inode
, struct file
*file
);
198 static ssize_t
pg_read(struct file
*filp
, char __user
*buf
,
199 size_t count
, loff_t
* ppos
);
200 static ssize_t
pg_write(struct file
*filp
, const char __user
*buf
,
201 size_t count
, loff_t
* ppos
);
202 static int pg_detect(void);
207 struct pi_adapter pia
; /* interface to paride layer */
208 struct pi_adapter
*pi
;
209 int busy
; /* write done, read expected */
210 int start
; /* jiffies at command start */
211 int dlen
; /* transfer size requested */
212 unsigned long timeout
; /* timeout requested */
213 int status
; /* last sense key */
214 int drive
; /* drive */
215 unsigned long access
; /* count of active opens ... */
216 int present
; /* device present ? */
218 char name
[PG_NAMELEN
]; /* pg0, pg1, ... */
221 static struct pg devices
[PG_UNITS
];
223 static int pg_identify(struct pg
*dev
, int log
);
225 static char pg_scratch
[512]; /* scratch block buffer */
227 static struct class *pg_class
;
229 /* kernel glue structures */
231 static const struct file_operations pg_fops
= {
232 .owner
= THIS_MODULE
,
236 .release
= pg_release
,
239 static void pg_init_units(void)
244 for (unit
= 0; unit
< PG_UNITS
; unit
++) {
245 int *parm
= *drives
[unit
];
246 struct pg
*dev
= &devices
[unit
];
248 clear_bit(0, &dev
->access
);
252 dev
->drive
= parm
[D_SLV
];
253 snprintf(dev
->name
, PG_NAMELEN
, "%s%c", name
, 'a'+unit
);
259 static inline int status_reg(struct pg
*dev
)
261 return pi_read_regr(dev
->pi
, 1, 6);
264 static inline int read_reg(struct pg
*dev
, int reg
)
266 return pi_read_regr(dev
->pi
, 0, reg
);
269 static inline void write_reg(struct pg
*dev
, int reg
, int val
)
271 pi_write_regr(dev
->pi
, 0, reg
, val
);
274 static inline u8
DRIVE(struct pg
*dev
)
276 return 0xa0+0x10*dev
->drive
;
279 static void pg_sleep(int cs
)
281 schedule_timeout_interruptible(cs
);
284 static int pg_wait(struct pg
*dev
, int go
, int stop
, unsigned long tmo
, char *msg
)
286 int j
, r
, e
, s
, p
, to
;
291 while ((((r
= status_reg(dev
)) & go
) || (stop
&& (!(r
& stop
))))
292 && time_before(jiffies
, tmo
)) {
299 to
= time_after_eq(jiffies
, tmo
);
301 if ((r
& (STAT_ERR
& stop
)) || to
) {
302 s
= read_reg(dev
, 7);
303 e
= read_reg(dev
, 1);
304 p
= read_reg(dev
, 2);
306 printk("%s: %s: stat=0x%x err=0x%x phase=%d%s\n",
307 dev
->name
, msg
, s
, e
, p
, to
? " timeout" : "");
310 dev
->status
= (e
>> 4) & 0xff;
316 static int pg_command(struct pg
*dev
, char *cmd
, int dlen
, unsigned long tmo
)
322 write_reg(dev
, 6, DRIVE(dev
));
324 if (pg_wait(dev
, STAT_BUSY
| STAT_DRQ
, 0, tmo
, "before command"))
327 write_reg(dev
, 4, dlen
% 256);
328 write_reg(dev
, 5, dlen
/ 256);
329 write_reg(dev
, 7, 0xa0); /* ATAPI packet command */
331 if (pg_wait(dev
, STAT_BUSY
, STAT_DRQ
, tmo
, "command DRQ"))
334 if (read_reg(dev
, 2) != 1) {
335 printk("%s: command phase error\n", dev
->name
);
339 pi_write_block(dev
->pi
, cmd
, 12);
342 printk("%s: Command sent, dlen=%d packet= ", dev
->name
, dlen
);
343 for (k
= 0; k
< 12; k
++)
344 printk("%02x ", cmd
[k
] & 0xff);
349 pi_disconnect(dev
->pi
);
353 static int pg_completion(struct pg
*dev
, char *buf
, unsigned long tmo
)
357 r
= pg_wait(dev
, STAT_BUSY
, STAT_DRQ
| STAT_READY
| STAT_ERR
,
362 while (read_reg(dev
, 7) & STAT_DRQ
) {
363 d
= (read_reg(dev
, 4) + 256 * read_reg(dev
, 5));
364 n
= ((d
+ 3) & 0xfffc);
365 p
= read_reg(dev
, 2) & 3;
367 pi_write_block(dev
->pi
, buf
, n
);
369 pi_read_block(dev
->pi
, buf
, n
);
371 printk("%s: %s %d bytes\n", dev
->name
,
372 p
? "Read" : "Write", n
);
373 dev
->dlen
+= (1 - p
) * d
;
375 r
= pg_wait(dev
, STAT_BUSY
, STAT_DRQ
| STAT_READY
| STAT_ERR
,
379 pi_disconnect(dev
->pi
);
384 static int pg_reset(struct pg
*dev
)
387 int expect
[5] = { 1, 1, 1, 0x14, 0xeb };
391 write_reg(dev
, 6, DRIVE(dev
));
392 write_reg(dev
, 7, 8);
394 pg_sleep(20 * HZ
/ 1000);
397 while ((k
++ < PG_RESET_TMO
) && (status_reg(dev
) & STAT_BUSY
))
400 for (i
= 0; i
< 5; i
++)
401 got
[i
] = read_reg(dev
, i
+ 1);
403 err
= memcmp(expect
, got
, sizeof(got
)) ? -1 : 0;
406 printk("%s: Reset (%d) signature = ", dev
->name
, k
);
407 for (i
= 0; i
< 5; i
++)
408 printk("%3x", got
[i
]);
410 printk(" (incorrect)");
414 pi_disconnect(dev
->pi
);
418 static void xs(char *buf
, char *targ
, int len
)
423 for (k
= 0; k
< len
; k
++) {
425 if (c
!= ' ' && c
!= l
)
433 static int pg_identify(struct pg
*dev
, int log
)
436 char *ms
[2] = { "master", "slave" };
438 char id_cmd
[12] = { ATAPI_IDENTIFY
, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
441 s
= pg_command(dev
, id_cmd
, 36, jiffies
+ PG_TMO
);
444 s
= pg_completion(dev
, buf
, jiffies
+ PG_TMO
);
450 xs(buf
+ 16, id
, 16);
451 printk("%s: %s %s, %s\n", dev
->name
, mf
, id
, ms
[dev
->drive
]);
458 * returns 0, with id set if drive is detected
459 * -1, if drive detection failed
461 static int pg_probe(struct pg
*dev
)
463 if (dev
->drive
== -1) {
464 for (dev
->drive
= 0; dev
->drive
<= 1; dev
->drive
++)
466 return pg_identify(dev
, 1);
469 return pg_identify(dev
, 1);
474 static int pg_detect(void)
476 struct pg
*dev
= &devices
[0];
479 printk("%s: %s version %s, major %d\n", name
, name
, PG_VERSION
, major
);
482 if (pg_drive_count
== 0) {
483 if (pi_init(dev
->pi
, 1, -1, -1, -1, -1, -1, pg_scratch
,
484 PI_PG
, verbose
, dev
->name
)) {
485 if (!pg_probe(dev
)) {
493 for (unit
= 0; unit
< PG_UNITS
; unit
++, dev
++) {
494 int *parm
= *drives
[unit
];
497 if (pi_init(dev
->pi
, 0, parm
[D_PRT
], parm
[D_MOD
],
498 parm
[D_UNI
], parm
[D_PRO
], parm
[D_DLY
],
499 pg_scratch
, PI_PG
, verbose
, dev
->name
)) {
500 if (!pg_probe(dev
)) {
511 printk("%s: No ATAPI device detected\n", name
);
515 static int pg_open(struct inode
*inode
, struct file
*file
)
517 int unit
= iminor(inode
) & 0x7f;
518 struct pg
*dev
= &devices
[unit
];
522 if ((unit
>= PG_UNITS
) || (!dev
->present
)) {
527 if (test_and_set_bit(0, &dev
->access
)) {
537 pg_identify(dev
, (verbose
> 1));
539 dev
->bufptr
= kmalloc(PG_MAX_DATA
, GFP_KERNEL
);
540 if (dev
->bufptr
== NULL
) {
541 clear_bit(0, &dev
->access
);
542 printk("%s: buffer allocation failed\n", dev
->name
);
547 file
->private_data
= dev
;
554 static int pg_release(struct inode
*inode
, struct file
*file
)
556 struct pg
*dev
= file
->private_data
;
560 clear_bit(0, &dev
->access
);
565 static ssize_t
pg_write(struct file
*filp
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
567 struct pg
*dev
= filp
->private_data
;
568 struct pg_write_hdr hdr
;
569 int hs
= sizeof (hdr
);
576 if (copy_from_user(&hdr
, buf
, hs
))
579 if (hdr
.magic
!= PG_MAGIC
)
581 if (hdr
.dlen
> PG_MAX_DATA
)
583 if ((count
- hs
) > PG_MAX_DATA
)
586 if (hdr
.func
== PG_RESET
) {
594 if (hdr
.func
!= PG_COMMAND
)
597 dev
->start
= jiffies
;
598 dev
->timeout
= hdr
.timeout
* HZ
+ HZ
/ 2 + jiffies
;
600 if (pg_command(dev
, hdr
.packet
, hdr
.dlen
, jiffies
+ PG_TMO
)) {
601 if (dev
->status
& 0x10)
608 if (copy_from_user(dev
->bufptr
, buf
+ hs
, count
- hs
))
613 static ssize_t
pg_read(struct file
*filp
, char __user
*buf
, size_t count
, loff_t
*ppos
)
615 struct pg
*dev
= filp
->private_data
;
616 struct pg_read_hdr hdr
;
617 int hs
= sizeof (hdr
);
627 if (pg_completion(dev
, dev
->bufptr
, dev
->timeout
))
628 if (dev
->status
& 0x10)
631 hdr
.magic
= PG_MAGIC
;
632 hdr
.dlen
= dev
->dlen
;
636 hdr
.dlen
= -1 * hdr
.dlen
;
638 if (copy
> (count
- hs
))
642 hdr
.duration
= (jiffies
- dev
->start
+ HZ
/ 2) / HZ
;
643 hdr
.scsi
= dev
->status
& 0x0f;
645 if (copy_to_user(buf
, &hdr
, hs
))
648 if (copy_to_user(buf
+ hs
, dev
->bufptr
, copy
))
653 static int __init
pg_init(void)
670 err
= register_chrdev(major
, name
, &pg_fops
);
672 printk("pg_init: unable to get major number %d\n", major
);
673 for (unit
= 0; unit
< PG_UNITS
; unit
++) {
674 struct pg
*dev
= &devices
[unit
];
680 major
= err
; /* In case the user specified `major=0' (dynamic) */
681 pg_class
= class_create(THIS_MODULE
, "pg");
682 if (IS_ERR(pg_class
)) {
683 err
= PTR_ERR(pg_class
);
686 for (unit
= 0; unit
< PG_UNITS
; unit
++) {
687 struct pg
*dev
= &devices
[unit
];
689 device_create(pg_class
, NULL
, MKDEV(major
, unit
), NULL
,
696 unregister_chrdev(major
, "pg");
701 static void __exit
pg_exit(void)
705 for (unit
= 0; unit
< PG_UNITS
; unit
++) {
706 struct pg
*dev
= &devices
[unit
];
708 device_destroy(pg_class
, MKDEV(major
, unit
));
710 class_destroy(pg_class
);
711 unregister_chrdev(major
, name
);
713 for (unit
= 0; unit
< PG_UNITS
; unit
++) {
714 struct pg
*dev
= &devices
[unit
];
720 MODULE_LICENSE("GPL");
This page took 0.044601 seconds and 5 git commands to generate.