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/blk-mq.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 blk_status_t pf_queue_rq(struct blk_mq_hw_ctx *hctx,
210 const struct blk_mq_queue_data *bd);
211 static int pf_ioctl(struct block_device *bdev, fmode_t mode,
212 unsigned int cmd, unsigned long arg);
213 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
215 static void pf_release(struct gendisk *disk, fmode_t mode);
217 static int pf_detect(void);
218 static void do_pf_read(void);
219 static void do_pf_read_start(void);
220 static void do_pf_write(void);
221 static void do_pf_write_start(void);
222 static void do_pf_read_drq(void);
223 static void do_pf_write_done(void);
232 struct pi_adapter pia; /* interface to paride layer */
233 struct pi_adapter *pi;
234 int removable; /* removable media device ? */
235 int media_status; /* media present ? WP ? */
236 int drive; /* drive */
238 int access; /* count of active opens ... */
239 int present; /* device present ? */
240 char name[PF_NAMELEN]; /* pf0, pf1, ... */
241 struct gendisk *disk;
242 struct blk_mq_tag_set tag_set;
243 struct list_head rq_list;
246 static struct pf_unit units[PF_UNITS];
248 static int pf_identify(struct pf_unit *pf);
249 static void pf_lock(struct pf_unit *pf, int func);
250 static void pf_eject(struct pf_unit *pf);
251 static unsigned int pf_check_events(struct gendisk *disk,
252 unsigned int clearing);
254 static char pf_scratch[512]; /* scratch block buffer */
256 /* the variables below are used mainly in the I/O request engine, which
257 processes only one request at a time.
260 static int pf_retries = 0; /* i/o error retry count */
261 static int pf_busy = 0; /* request being processed ? */
262 static struct request *pf_req; /* current request */
263 static int pf_block; /* address of next requested block */
264 static int pf_count; /* number of blocks still to do */
265 static int pf_run; /* sectors in current cluster */
266 static int pf_cmd; /* current command READ/WRITE */
267 static struct pf_unit *pf_current;/* unit of current request */
268 static int pf_mask; /* stopper for pseudo-int */
269 static char *pf_buf; /* buffer for request in progress */
270 static void *par_drv; /* reference of parport driver */
272 /* kernel glue structures */
274 static const struct block_device_operations pf_fops = {
275 .owner = THIS_MODULE,
277 .release = pf_release,
280 .check_events = pf_check_events,
283 static const struct blk_mq_ops pf_mq_ops = {
284 .queue_rq = pf_queue_rq,
287 static void __init pf_init_units(void)
293 for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
294 struct gendisk *disk;
296 disk = alloc_disk(1);
300 disk->queue = blk_mq_init_sq_queue(&pf->tag_set, &pf_mq_ops,
301 1, BLK_MQ_F_SHOULD_MERGE);
302 if (IS_ERR(disk->queue)) {
308 INIT_LIST_HEAD(&pf->rq_list);
309 disk->queue->queuedata = pf;
310 blk_queue_max_segments(disk->queue, cluster);
311 blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
314 pf->media_status = PF_NM;
315 pf->drive = (*drives[unit])[D_SLV];
316 pf->lun = (*drives[unit])[D_LUN];
317 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
319 disk->first_minor = unit;
320 strcpy(disk->disk_name, pf->name);
321 disk->fops = &pf_fops;
322 if (!(*drives[unit])[D_PRT])
327 static int pf_open(struct block_device *bdev, fmode_t mode)
329 struct pf_unit *pf = bdev->bd_disk->private_data;
332 mutex_lock(&pf_mutex);
336 if (pf->media_status == PF_NM)
340 if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
348 mutex_unlock(&pf_mutex);
352 static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
354 struct pf_unit *pf = bdev->bd_disk->private_data;
355 sector_t capacity = get_capacity(pf->disk);
357 if (capacity < PF_FD_MAX) {
358 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
359 geo->heads = PF_FD_HDS;
360 geo->sectors = PF_FD_SPT;
362 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
363 geo->heads = PF_HD_HDS;
364 geo->sectors = PF_HD_SPT;
370 static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
372 struct pf_unit *pf = bdev->bd_disk->private_data;
374 if (cmd != CDROMEJECT)
379 mutex_lock(&pf_mutex);
381 mutex_unlock(&pf_mutex);
386 static void pf_release(struct gendisk *disk, fmode_t mode)
388 struct pf_unit *pf = disk->private_data;
390 mutex_lock(&pf_mutex);
391 if (pf->access <= 0) {
392 mutex_unlock(&pf_mutex);
399 if (!pf->access && pf->removable)
402 mutex_unlock(&pf_mutex);
405 static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
407 return DISK_EVENT_MEDIA_CHANGE;
410 static inline int status_reg(struct pf_unit *pf)
412 return pi_read_regr(pf->pi, 1, 6);
415 static inline int read_reg(struct pf_unit *pf, int reg)
417 return pi_read_regr(pf->pi, 0, reg);
420 static inline void write_reg(struct pf_unit *pf, int reg, int val)
422 pi_write_regr(pf->pi, 0, reg, val);
425 static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
430 while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
434 if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
441 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
442 " loop=%d phase=%d\n",
443 pf->name, fun, msg, r, s, e, j, p);
449 static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
453 write_reg(pf, 6, 0xa0+0x10*pf->drive);
455 if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
456 pi_disconnect(pf->pi);
460 write_reg(pf, 4, dlen % 256);
461 write_reg(pf, 5, dlen / 256);
462 write_reg(pf, 7, 0xa0); /* ATAPI packet command */
464 if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
465 pi_disconnect(pf->pi);
469 if (read_reg(pf, 2) != 1) {
470 printk("%s: %s: command phase error\n", pf->name, fun);
471 pi_disconnect(pf->pi);
475 pi_write_block(pf->pi, cmd, 12);
480 static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
484 r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
487 if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
488 n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
490 pi_read_block(pf->pi, buf, n);
493 s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
495 pi_disconnect(pf->pi);
500 static void pf_req_sense(struct pf_unit *pf, int quiet)
503 { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
507 r = pf_command(pf, rs_cmd, 16, "Request sense");
510 pf_completion(pf, buf, "Request sense");
512 if ((!r) && (!quiet))
513 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
514 pf->name, buf[2] & 0xf, buf[12], buf[13]);
517 static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
521 r = pf_command(pf, cmd, dlen, fun);
524 r = pf_completion(pf, buf, fun);
526 pf_req_sense(pf, !fun);
531 static void pf_lock(struct pf_unit *pf, int func)
533 char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
535 pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
538 static void pf_eject(struct pf_unit *pf)
540 char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
543 pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
546 #define PF_RESET_TMO 30 /* in tenths of a second */
548 static void pf_sleep(int cs)
550 schedule_timeout_interruptible(cs);
553 /* the ATAPI standard actually specifies the contents of all 7 registers
554 after a reset, but the specification is ambiguous concerning the last
555 two bytes, and different drives interpret the standard differently.
558 static int pf_reset(struct pf_unit *pf)
561 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
564 write_reg(pf, 6, 0xa0+0x10*pf->drive);
567 pf_sleep(20 * HZ / 1000);
570 while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
574 for (i = 0; i < 5; i++)
575 flg &= (read_reg(pf, i + 1) == expect[i]);
578 printk("%s: Reset (%d) signature = ", pf->name, k);
579 for (i = 0; i < 5; i++)
580 printk("%3x", read_reg(pf, i + 1));
582 printk(" (incorrect)");
586 pi_disconnect(pf->pi);
590 static void pf_mode_sense(struct pf_unit *pf)
593 { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
596 pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
597 pf->media_status = PF_RW;
599 pf->media_status = PF_RO;
602 static void xs(char *buf, char *targ, int offs, int len)
608 for (k = 0; k < len; k++)
609 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
610 l = targ[j++] = buf[k + offs];
616 static int xl(char *buf, int offs)
621 for (k = 0; k < 4; k++)
622 v = v * 256 + (buf[k + offs] & 0xff);
626 static void pf_get_capacity(struct pf_unit *pf)
628 char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
632 if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
633 pf->media_status = PF_NM;
636 set_capacity(pf->disk, xl(buf, 0) + 1);
639 set_capacity(pf->disk, 0);
641 printk("%s: Drive %d, LUN %d,"
642 " unsupported block size %d\n",
643 pf->name, pf->drive, pf->lun, bs);
647 static int pf_identify(struct pf_unit *pf)
650 char *ms[2] = { "master", "slave" };
653 { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
656 s = pf_atapi(pf, id_cmd, 36, buf, "identify");
661 if ((dt != 0) && (dt != 7)) {
663 printk("%s: Drive %d, LUN %d, unsupported type %d\n",
664 pf->name, pf->drive, pf->lun, dt);
671 pf->removable = (buf[1] & 0x80);
679 printk("%s: %s %s, %s LUN %d, type %d",
680 pf->name, mf, id, ms[pf->drive], pf->lun, dt);
682 printk(", removable");
683 if (pf->media_status == PF_NM)
684 printk(", no media\n");
686 if (pf->media_status == PF_RO)
688 printk(", %llu blocks\n",
689 (unsigned long long)get_capacity(pf->disk));
694 /* returns 0, with id set if drive is detected
695 -1, if drive detection failed
697 static int pf_probe(struct pf_unit *pf)
699 if (pf->drive == -1) {
700 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
703 return pf_identify(pf);
705 for (pf->lun = 0; pf->lun < 8; pf->lun++)
706 if (!pf_identify(pf))
713 return pf_identify(pf);
714 for (pf->lun = 0; pf->lun < 8; pf->lun++)
715 if (!pf_identify(pf))
721 static int pf_detect(void)
723 struct pf_unit *pf = units;
726 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
727 name, name, PF_VERSION, major, cluster, nice);
729 par_drv = pi_register_driver(name);
731 pr_err("failed to register %s driver\n", name);
735 if (pf_drive_count == 0) {
736 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
737 verbose, pf->name)) {
738 if (!pf_probe(pf) && pf->disk) {
746 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
747 int *conf = *drives[unit];
750 if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
751 conf[D_UNI], conf[D_PRO], conf[D_DLY],
752 pf_scratch, PI_PF, verbose, pf->name)) {
753 if (pf->disk && !pf_probe(pf)) {
763 printk("%s: No ATAPI disk detected\n", name);
764 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
766 pi_unregister_driver(par_drv);
770 /* The i/o request engine */
772 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
775 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
777 for (i = 0; i < 4; i++) {
778 io_cmd[5 - i] = b & 0xff;
782 io_cmd[8] = c & 0xff;
783 io_cmd[7] = (c >> 8) & 0xff;
785 i = pf_command(pf, io_cmd, c * 512, "start i/o");
792 static int pf_ready(void)
794 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
799 static int set_next_request(void)
802 int old_pos = pf_queue;
805 pf = &units[pf_queue];
806 if (++pf_queue == PF_UNITS)
808 if (pf->present && !list_empty(&pf->rq_list)) {
809 pf_req = list_first_entry(&pf->rq_list, struct request,
811 list_del_init(&pf_req->queuelist);
812 blk_mq_start_request(pf_req);
815 } while (pf_queue != old_pos);
817 return pf_req != NULL;
820 static void pf_end_request(blk_status_t err)
824 if (!blk_update_request(pf_req, err, blk_rq_cur_bytes(pf_req))) {
825 __blk_mq_end_request(pf_req, err);
830 static void pf_request(void)
835 if (!pf_req && !set_next_request())
838 pf_current = pf_req->rq_disk->private_data;
839 pf_block = blk_rq_pos(pf_req);
840 pf_run = blk_rq_sectors(pf_req);
841 pf_count = blk_rq_cur_sectors(pf_req);
843 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
844 pf_end_request(BLK_STS_IOERR);
848 pf_cmd = rq_data_dir(pf_req);
849 pf_buf = bio_data(pf_req->bio);
854 pi_do_claimed(pf_current->pi, do_pf_read);
855 else if (pf_cmd == WRITE)
856 pi_do_claimed(pf_current->pi, do_pf_write);
859 pf_end_request(BLK_STS_IOERR);
864 static blk_status_t pf_queue_rq(struct blk_mq_hw_ctx *hctx,
865 const struct blk_mq_queue_data *bd)
867 struct pf_unit *pf = hctx->queue->queuedata;
869 spin_lock_irq(&pf_spin_lock);
870 list_add_tail(&bd->rq->queuelist, &pf->rq_list);
872 spin_unlock_irq(&pf_spin_lock);
877 static int pf_next_buf(void)
879 unsigned long saved_flags;
888 spin_lock_irqsave(&pf_spin_lock, saved_flags);
890 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
893 pf_count = blk_rq_cur_sectors(pf_req);
894 pf_buf = bio_data(pf_req->bio);
899 static inline void next_request(blk_status_t err)
901 unsigned long saved_flags;
903 spin_lock_irqsave(&pf_spin_lock, saved_flags);
907 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
910 /* detach from the calling context - in case the spinlock is held */
911 static void do_pf_read(void)
913 ps_set_intr(do_pf_read_start, NULL, 0, nice);
916 static void do_pf_read_start(void)
920 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
921 pi_disconnect(pf_current->pi);
922 if (pf_retries < PF_MAX_RETRIES) {
924 pi_do_claimed(pf_current->pi, do_pf_read_start);
927 next_request(BLK_STS_IOERR);
931 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
934 static void do_pf_read_drq(void)
937 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
938 "read block", "completion") & STAT_ERR) {
939 pi_disconnect(pf_current->pi);
940 if (pf_retries < PF_MAX_RETRIES) {
941 pf_req_sense(pf_current, 0);
943 pi_do_claimed(pf_current->pi, do_pf_read_start);
946 next_request(BLK_STS_IOERR);
949 pi_read_block(pf_current->pi, pf_buf, 512);
953 pi_disconnect(pf_current->pi);
957 static void do_pf_write(void)
959 ps_set_intr(do_pf_write_start, NULL, 0, nice);
962 static void do_pf_write_start(void)
966 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
967 pi_disconnect(pf_current->pi);
968 if (pf_retries < PF_MAX_RETRIES) {
970 pi_do_claimed(pf_current->pi, do_pf_write_start);
973 next_request(BLK_STS_IOERR);
978 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
979 "write block", "data wait") & STAT_ERR) {
980 pi_disconnect(pf_current->pi);
981 if (pf_retries < PF_MAX_RETRIES) {
983 pi_do_claimed(pf_current->pi, do_pf_write_start);
986 next_request(BLK_STS_IOERR);
989 pi_write_block(pf_current->pi, pf_buf, 512);
994 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
997 static void do_pf_write_done(void)
999 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
1000 pi_disconnect(pf_current->pi);
1001 if (pf_retries < PF_MAX_RETRIES) {
1003 pi_do_claimed(pf_current->pi, do_pf_write_start);
1006 next_request(BLK_STS_IOERR);
1009 pi_disconnect(pf_current->pi);
1013 static int __init pf_init(void)
1014 { /* preliminary initialisation */
1027 if (register_blkdev(major, name)) {
1028 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
1033 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1034 struct gendisk *disk = pf->disk;
1038 disk->private_data = pf;
1044 static void __exit pf_exit(void)
1048 unregister_blkdev(major, name);
1049 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1052 del_gendisk(pf->disk);
1053 blk_cleanup_queue(pf->disk->queue);
1054 blk_mq_free_tag_set(&pf->tag_set);
1060 MODULE_LICENSE("GPL");
1061 module_init(pf_init)
1062 module_exit(pf_exit)