2 pf.c (c) 1997-8 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 disk
6 drives based on chips supported by the paride module.
8 By default, the driver will autoprobe for a single parallel
9 port ATAPI disk drive, but if their individual parameters are
10 specified, the driver can handle up to 4 drives.
12 The behaviour of the pf driver can be altered by setting
13 some parameters from the insmod command line. The following
14 parameters are adjustable:
16 drive0 These four arguments can be arrays of
17 drive1 1-7 integers as follows:
19 drive3 <prt>,<pro>,<uni>,<mod>,<slv>,<lun>,<dly>
23 <prt> is the base of the parallel port address for
24 the corresponding drive. (required)
26 <pro> is the protocol number for the adapter that
27 supports this drive. These numbers are
28 logged by 'paride' when the protocol modules
29 are initialised. (0 if not given)
31 <uni> for those adapters that support chained
32 devices, this is the unit selector for the
33 chain of devices on the given port. It should
34 be zero for devices that don't support chaining.
37 <mod> this can be -1 to choose the best mode, or one
38 of the mode numbers supported by the adapter.
41 <slv> ATAPI CDroms can be jumpered to master or slave.
42 Set this to 0 to choose the master drive, 1 to
43 choose the slave, -1 (the default) to choose the
46 <lun> Some ATAPI devices support multiple LUNs.
47 One example is the ATAPI PD/CD drive from
48 Matshita/Panasonic. This device has a
49 CD drive on LUN 0 and a PD drive on LUN 1.
50 By default, the driver will search for the
51 first LUN with a supported device. Set
52 this parameter to force it to use a specific
55 <dly> some parallel ports require the driver to
56 go more slowly. -1 sets a default value that
57 should work with the chosen protocol. Otherwise,
58 set this to a small integer, the larger it is
59 the slower the port i/o. In some cases, setting
60 this to zero will speed up the device. (default -1)
62 major You may use this parameter to override the
63 default major number (47) that this driver
64 will use. Be sure to change the device
67 name This parameter is a character string that
68 contains the name the kernel will use for this
69 device (in /proc output, for instance).
72 cluster The driver will attempt to aggregate requests
73 for adjacent blocks into larger multi-block
74 clusters. The maximum cluster size (in 512
75 byte sectors) is set with this parameter.
78 verbose This parameter controls the amount of logging
79 that the driver will do. Set it to 0 for
80 normal operation, 1 to see autoprobe progress
81 messages, or 2 to see additional debugging
84 nice This parameter controls the driver's use of
85 idle CPU time, at the expense of some speed.
87 If this driver is built into the kernel, you can use the
88 following command line parameters, with the same values
89 as the corresponding module parameters listed above:
98 In addition, you can use the parameter pf.disable to disable
105 1.01 GRG 1998.05.03 Changes for SMP. Eliminate sti().
106 Fix for drives that don't clear STAT_ERR
107 until after next CDB delivered.
108 Small change in pf_completion to round
110 1.02 GRG 1998.06.16 Eliminated an Ugh
111 1.03 GRG 1998.08.16 Use HZ in loop timings, extra debugging
112 1.04 GRG 1998.09.24 Added jumbo support
116 #define PF_VERSION "1.04"
121 #include <linux/types.h>
123 /* Here are things one can override from the insmod command.
124 Most are autoprobed by paride unless set here. Verbose is off
129 static bool verbose = 0;
130 static int major = PF_MAJOR;
131 static char *name = PF_NAME;
132 static int cluster = 64;
134 static int disable = 0;
136 static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
137 static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
138 static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
139 static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
141 static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
142 static int pf_drive_count;
144 enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
146 /* end of parameters */
148 #include <linux/module.h>
149 #include <linux/init.h>
150 #include <linux/fs.h>
151 #include <linux/delay.h>
152 #include <linux/hdreg.h>
153 #include <linux/cdrom.h>
154 #include <linux/spinlock.h>
155 #include <linux/blkdev.h>
156 #include <linux/blkpg.h>
157 #include <linux/mutex.h>
158 #include <linux/uaccess.h>
160 static DEFINE_MUTEX(pf_mutex);
161 static DEFINE_SPINLOCK(pf_spin_lock);
163 module_param(verbose, bool, 0644);
164 module_param(major, int, 0);
165 module_param(name, charp, 0);
166 module_param(cluster, int, 0);
167 module_param(nice, int, 0);
168 module_param_array(drive0, int, NULL, 0);
169 module_param_array(drive1, int, NULL, 0);
170 module_param_array(drive2, int, NULL, 0);
171 module_param_array(drive3, int, NULL, 0);
176 /* constants for faking geometry numbers */
178 #define PF_FD_MAX 8192 /* use FD geometry under this size */
184 #define PF_MAX_RETRIES 5
185 #define PF_TMO 800 /* interrupt timeout in jiffies */
186 #define PF_SPIN_DEL 50 /* spin delay in micro-seconds */
188 #define PF_SPIN (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
190 #define STAT_ERR 0x00001
191 #define STAT_INDEX 0x00002
192 #define STAT_ECC 0x00004
193 #define STAT_DRQ 0x00008
194 #define STAT_SEEK 0x00010
195 #define STAT_WRERR 0x00020
196 #define STAT_READY 0x00040
197 #define STAT_BUSY 0x00080
199 #define ATAPI_REQ_SENSE 0x03
200 #define ATAPI_LOCK 0x1e
201 #define ATAPI_DOOR 0x1b
202 #define ATAPI_MODE_SENSE 0x5a
203 #define ATAPI_CAPACITY 0x25
204 #define ATAPI_IDENTIFY 0x12
205 #define ATAPI_READ_10 0x28
206 #define ATAPI_WRITE_10 0x2a
208 static int pf_open(struct block_device *bdev, fmode_t mode);
209 static void do_pf_request(struct request_queue * q);
210 static int pf_ioctl(struct block_device *bdev, fmode_t mode,
211 unsigned int cmd, unsigned long arg);
212 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
214 static void pf_release(struct gendisk *disk, fmode_t mode);
216 static int pf_detect(void);
217 static void do_pf_read(void);
218 static void do_pf_read_start(void);
219 static void do_pf_write(void);
220 static void do_pf_write_start(void);
221 static void do_pf_read_drq(void);
222 static void do_pf_write_done(void);
231 struct pi_adapter pia; /* interface to paride layer */
232 struct pi_adapter *pi;
233 int removable; /* removable media device ? */
234 int media_status; /* media present ? WP ? */
235 int drive; /* drive */
237 int access; /* count of active opens ... */
238 int present; /* device present ? */
239 char name[PF_NAMELEN]; /* pf0, pf1, ... */
240 struct gendisk *disk;
243 static struct pf_unit units[PF_UNITS];
245 static int pf_identify(struct pf_unit *pf);
246 static void pf_lock(struct pf_unit *pf, int func);
247 static void pf_eject(struct pf_unit *pf);
248 static unsigned int pf_check_events(struct gendisk *disk,
249 unsigned int clearing);
251 static char pf_scratch[512]; /* scratch block buffer */
253 /* the variables below are used mainly in the I/O request engine, which
254 processes only one request at a time.
257 static int pf_retries = 0; /* i/o error retry count */
258 static int pf_busy = 0; /* request being processed ? */
259 static struct request *pf_req; /* current request */
260 static int pf_block; /* address of next requested block */
261 static int pf_count; /* number of blocks still to do */
262 static int pf_run; /* sectors in current cluster */
263 static int pf_cmd; /* current command READ/WRITE */
264 static struct pf_unit *pf_current;/* unit of current request */
265 static int pf_mask; /* stopper for pseudo-int */
266 static char *pf_buf; /* buffer for request in progress */
267 static void *par_drv; /* reference of parport driver */
269 /* kernel glue structures */
271 static const struct block_device_operations pf_fops = {
272 .owner = THIS_MODULE,
274 .release = pf_release,
277 .check_events = pf_check_events,
280 static void __init pf_init_units(void)
286 for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
287 struct gendisk *disk = alloc_disk(1);
290 disk->queue = blk_init_queue(do_pf_request, &pf_spin_lock);
295 blk_queue_max_segments(disk->queue, cluster);
298 pf->media_status = PF_NM;
299 pf->drive = (*drives[unit])[D_SLV];
300 pf->lun = (*drives[unit])[D_LUN];
301 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
303 disk->first_minor = unit;
304 strcpy(disk->disk_name, pf->name);
305 disk->fops = &pf_fops;
306 if (!(*drives[unit])[D_PRT])
311 static int pf_open(struct block_device *bdev, fmode_t mode)
313 struct pf_unit *pf = bdev->bd_disk->private_data;
316 mutex_lock(&pf_mutex);
320 if (pf->media_status == PF_NM)
324 if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
332 mutex_unlock(&pf_mutex);
336 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
338 struct pf_unit *pf = bdev->bd_disk->private_data;
339 sector_t capacity = get_capacity(pf->disk);
341 if (capacity < PF_FD_MAX) {
342 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
343 geo->heads = PF_FD_HDS;
344 geo->sectors = PF_FD_SPT;
346 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
347 geo->heads = PF_HD_HDS;
348 geo->sectors = PF_HD_SPT;
354 static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
356 struct pf_unit *pf = bdev->bd_disk->private_data;
358 if (cmd != CDROMEJECT)
363 mutex_lock(&pf_mutex);
365 mutex_unlock(&pf_mutex);
370 static void pf_release(struct gendisk *disk, fmode_t mode)
372 struct pf_unit *pf = disk->private_data;
374 mutex_lock(&pf_mutex);
375 if (pf->access <= 0) {
376 mutex_unlock(&pf_mutex);
383 if (!pf->access && pf->removable)
386 mutex_unlock(&pf_mutex);
389 static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
391 return DISK_EVENT_MEDIA_CHANGE;
394 static inline int status_reg(struct pf_unit *pf)
396 return pi_read_regr(pf->pi, 1, 6);
399 static inline int read_reg(struct pf_unit *pf, int reg)
401 return pi_read_regr(pf->pi, 0, reg);
404 static inline void write_reg(struct pf_unit *pf, int reg, int val)
406 pi_write_regr(pf->pi, 0, reg, val);
409 static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
414 while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
418 if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
425 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
426 " loop=%d phase=%d\n",
427 pf->name, fun, msg, r, s, e, j, p);
433 static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
437 write_reg(pf, 6, 0xa0+0x10*pf->drive);
439 if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
440 pi_disconnect(pf->pi);
444 write_reg(pf, 4, dlen % 256);
445 write_reg(pf, 5, dlen / 256);
446 write_reg(pf, 7, 0xa0); /* ATAPI packet command */
448 if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
449 pi_disconnect(pf->pi);
453 if (read_reg(pf, 2) != 1) {
454 printk("%s: %s: command phase error\n", pf->name, fun);
455 pi_disconnect(pf->pi);
459 pi_write_block(pf->pi, cmd, 12);
464 static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
468 r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
471 if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
472 n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
474 pi_read_block(pf->pi, buf, n);
477 s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
479 pi_disconnect(pf->pi);
484 static void pf_req_sense(struct pf_unit *pf, int quiet)
487 { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
491 r = pf_command(pf, rs_cmd, 16, "Request sense");
494 pf_completion(pf, buf, "Request sense");
496 if ((!r) && (!quiet))
497 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
498 pf->name, buf[2] & 0xf, buf[12], buf[13]);
501 static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
505 r = pf_command(pf, cmd, dlen, fun);
508 r = pf_completion(pf, buf, fun);
510 pf_req_sense(pf, !fun);
515 static void pf_lock(struct pf_unit *pf, int func)
517 char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
519 pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
522 static void pf_eject(struct pf_unit *pf)
524 char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
527 pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
530 #define PF_RESET_TMO 30 /* in tenths of a second */
532 static void pf_sleep(int cs)
534 schedule_timeout_interruptible(cs);
537 /* the ATAPI standard actually specifies the contents of all 7 registers
538 after a reset, but the specification is ambiguous concerning the last
539 two bytes, and different drives interpret the standard differently.
542 static int pf_reset(struct pf_unit *pf)
545 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
548 write_reg(pf, 6, 0xa0+0x10*pf->drive);
551 pf_sleep(20 * HZ / 1000);
554 while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
558 for (i = 0; i < 5; i++)
559 flg &= (read_reg(pf, i + 1) == expect[i]);
562 printk("%s: Reset (%d) signature = ", pf->name, k);
563 for (i = 0; i < 5; i++)
564 printk("%3x", read_reg(pf, i + 1));
566 printk(" (incorrect)");
570 pi_disconnect(pf->pi);
574 static void pf_mode_sense(struct pf_unit *pf)
577 { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
580 pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
581 pf->media_status = PF_RW;
583 pf->media_status = PF_RO;
586 static void xs(char *buf, char *targ, int offs, int len)
592 for (k = 0; k < len; k++)
593 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
594 l = targ[j++] = buf[k + offs];
600 static int xl(char *buf, int offs)
605 for (k = 0; k < 4; k++)
606 v = v * 256 + (buf[k + offs] & 0xff);
610 static void pf_get_capacity(struct pf_unit *pf)
612 char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
616 if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
617 pf->media_status = PF_NM;
620 set_capacity(pf->disk, xl(buf, 0) + 1);
623 set_capacity(pf->disk, 0);
625 printk("%s: Drive %d, LUN %d,"
626 " unsupported block size %d\n",
627 pf->name, pf->drive, pf->lun, bs);
631 static int pf_identify(struct pf_unit *pf)
634 char *ms[2] = { "master", "slave" };
637 { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
640 s = pf_atapi(pf, id_cmd, 36, buf, "identify");
645 if ((dt != 0) && (dt != 7)) {
647 printk("%s: Drive %d, LUN %d, unsupported type %d\n",
648 pf->name, pf->drive, pf->lun, dt);
655 pf->removable = (buf[1] & 0x80);
663 printk("%s: %s %s, %s LUN %d, type %d",
664 pf->name, mf, id, ms[pf->drive], pf->lun, dt);
666 printk(", removable");
667 if (pf->media_status == PF_NM)
668 printk(", no media\n");
670 if (pf->media_status == PF_RO)
672 printk(", %llu blocks\n",
673 (unsigned long long)get_capacity(pf->disk));
678 /* returns 0, with id set if drive is detected
679 -1, if drive detection failed
681 static int pf_probe(struct pf_unit *pf)
683 if (pf->drive == -1) {
684 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
687 return pf_identify(pf);
689 for (pf->lun = 0; pf->lun < 8; pf->lun++)
690 if (!pf_identify(pf))
697 return pf_identify(pf);
698 for (pf->lun = 0; pf->lun < 8; pf->lun++)
699 if (!pf_identify(pf))
705 static int pf_detect(void)
707 struct pf_unit *pf = units;
710 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
711 name, name, PF_VERSION, major, cluster, nice);
713 par_drv = pi_register_driver(name);
715 pr_err("failed to register %s driver\n", name);
719 if (pf_drive_count == 0) {
720 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
721 verbose, pf->name)) {
722 if (!pf_probe(pf) && pf->disk) {
730 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
731 int *conf = *drives[unit];
734 if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
735 conf[D_UNI], conf[D_PRO], conf[D_DLY],
736 pf_scratch, PI_PF, verbose, pf->name)) {
737 if (pf->disk && !pf_probe(pf)) {
747 printk("%s: No ATAPI disk detected\n", name);
748 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
750 pi_unregister_driver(par_drv);
754 /* The i/o request engine */
756 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
759 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
761 for (i = 0; i < 4; i++) {
762 io_cmd[5 - i] = b & 0xff;
766 io_cmd[8] = c & 0xff;
767 io_cmd[7] = (c >> 8) & 0xff;
769 i = pf_command(pf, io_cmd, c * 512, "start i/o");
776 static int pf_ready(void)
778 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
783 static int set_next_request(void)
786 struct request_queue *q;
787 int old_pos = pf_queue;
790 pf = &units[pf_queue];
791 q = pf->present ? pf->disk->queue : NULL;
792 if (++pf_queue == PF_UNITS)
795 pf_req = blk_fetch_request(q);
799 } while (pf_queue != old_pos);
801 return pf_req != NULL;
804 static void pf_end_request(blk_status_t err)
806 if (pf_req && !__blk_end_request_cur(pf_req, err))
810 static void pf_request(void)
815 if (!pf_req && !set_next_request())
818 pf_current = pf_req->rq_disk->private_data;
819 pf_block = blk_rq_pos(pf_req);
820 pf_run = blk_rq_sectors(pf_req);
821 pf_count = blk_rq_cur_sectors(pf_req);
823 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
824 pf_end_request(BLK_STS_IOERR);
828 pf_cmd = rq_data_dir(pf_req);
829 pf_buf = bio_data(pf_req->bio);
834 pi_do_claimed(pf_current->pi, do_pf_read);
835 else if (pf_cmd == WRITE)
836 pi_do_claimed(pf_current->pi, do_pf_write);
839 pf_end_request(BLK_STS_IOERR);
844 static void do_pf_request(struct request_queue *q)
849 static int pf_next_buf(void)
851 unsigned long saved_flags;
860 spin_lock_irqsave(&pf_spin_lock, saved_flags);
862 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
865 pf_count = blk_rq_cur_sectors(pf_req);
866 pf_buf = bio_data(pf_req->bio);
871 static inline void next_request(blk_status_t err)
873 unsigned long saved_flags;
875 spin_lock_irqsave(&pf_spin_lock, saved_flags);
879 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
882 /* detach from the calling context - in case the spinlock is held */
883 static void do_pf_read(void)
885 ps_set_intr(do_pf_read_start, NULL, 0, nice);
888 static void do_pf_read_start(void)
892 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
893 pi_disconnect(pf_current->pi);
894 if (pf_retries < PF_MAX_RETRIES) {
896 pi_do_claimed(pf_current->pi, do_pf_read_start);
899 next_request(BLK_STS_IOERR);
903 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
906 static void do_pf_read_drq(void)
909 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
910 "read block", "completion") & STAT_ERR) {
911 pi_disconnect(pf_current->pi);
912 if (pf_retries < PF_MAX_RETRIES) {
913 pf_req_sense(pf_current, 0);
915 pi_do_claimed(pf_current->pi, do_pf_read_start);
918 next_request(BLK_STS_IOERR);
921 pi_read_block(pf_current->pi, pf_buf, 512);
925 pi_disconnect(pf_current->pi);
929 static void do_pf_write(void)
931 ps_set_intr(do_pf_write_start, NULL, 0, nice);
934 static void do_pf_write_start(void)
938 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
939 pi_disconnect(pf_current->pi);
940 if (pf_retries < PF_MAX_RETRIES) {
942 pi_do_claimed(pf_current->pi, do_pf_write_start);
945 next_request(BLK_STS_IOERR);
950 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
951 "write block", "data wait") & STAT_ERR) {
952 pi_disconnect(pf_current->pi);
953 if (pf_retries < PF_MAX_RETRIES) {
955 pi_do_claimed(pf_current->pi, do_pf_write_start);
958 next_request(BLK_STS_IOERR);
961 pi_write_block(pf_current->pi, pf_buf, 512);
966 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
969 static void do_pf_write_done(void)
971 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
972 pi_disconnect(pf_current->pi);
973 if (pf_retries < PF_MAX_RETRIES) {
975 pi_do_claimed(pf_current->pi, do_pf_write_start);
978 next_request(BLK_STS_IOERR);
981 pi_disconnect(pf_current->pi);
985 static int __init pf_init(void)
986 { /* preliminary initialisation */
999 if (register_blkdev(major, name)) {
1000 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
1005 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1006 struct gendisk *disk = pf->disk;
1010 disk->private_data = pf;
1016 static void __exit pf_exit(void)
1020 unregister_blkdev(major, name);
1021 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1024 del_gendisk(pf->disk);
1025 blk_cleanup_queue(pf->disk->queue);
1031 MODULE_LICENSE("GPL");
1032 module_init(pf_init)
1033 module_exit(pf_exit)