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,
279 .compat_ioctl = pf_ioctl,
281 .check_events = pf_check_events,
284 static const struct blk_mq_ops pf_mq_ops = {
285 .queue_rq = pf_queue_rq,
288 static void __init pf_init_units(void)
294 for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
295 struct gendisk *disk;
297 if (blk_mq_alloc_sq_tag_set(&pf->tag_set, &pf_mq_ops, 1,
298 BLK_MQ_F_SHOULD_MERGE))
301 disk = blk_mq_alloc_disk(&pf->tag_set, pf);
303 blk_mq_free_tag_set(&pf->tag_set);
307 INIT_LIST_HEAD(&pf->rq_list);
308 blk_queue_max_segments(disk->queue, cluster);
309 blk_queue_bounce_limit(disk->queue, BLK_BOUNCE_HIGH);
312 pf->media_status = PF_NM;
313 pf->drive = (*drives[unit])[D_SLV];
314 pf->lun = (*drives[unit])[D_LUN];
315 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
317 disk->first_minor = unit;
319 strcpy(disk->disk_name, pf->name);
320 disk->fops = &pf_fops;
321 disk->events = DISK_EVENT_MEDIA_CHANGE;
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++) {
767 blk_cleanup_disk(pf->disk);
768 blk_mq_free_tag_set(&pf->tag_set);
770 pi_unregister_driver(par_drv);
774 /* The i/o request engine */
776 static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
779 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
781 for (i = 0; i < 4; i++) {
782 io_cmd[5 - i] = b & 0xff;
786 io_cmd[8] = c & 0xff;
787 io_cmd[7] = (c >> 8) & 0xff;
789 i = pf_command(pf, io_cmd, c * 512, "start i/o");
796 static int pf_ready(void)
798 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
803 static int set_next_request(void)
806 int old_pos = pf_queue;
809 pf = &units[pf_queue];
810 if (++pf_queue == PF_UNITS)
812 if (pf->present && !list_empty(&pf->rq_list)) {
813 pf_req = list_first_entry(&pf->rq_list, struct request,
815 list_del_init(&pf_req->queuelist);
816 blk_mq_start_request(pf_req);
819 } while (pf_queue != old_pos);
821 return pf_req != NULL;
824 static void pf_end_request(blk_status_t err)
828 if (!blk_update_request(pf_req, err, blk_rq_cur_bytes(pf_req))) {
829 __blk_mq_end_request(pf_req, err);
834 static void pf_request(void)
839 if (!pf_req && !set_next_request())
842 pf_current = pf_req->rq_disk->private_data;
843 pf_block = blk_rq_pos(pf_req);
844 pf_run = blk_rq_sectors(pf_req);
845 pf_count = blk_rq_cur_sectors(pf_req);
847 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
848 pf_end_request(BLK_STS_IOERR);
852 pf_cmd = rq_data_dir(pf_req);
853 pf_buf = bio_data(pf_req->bio);
858 pi_do_claimed(pf_current->pi, do_pf_read);
859 else if (pf_cmd == WRITE)
860 pi_do_claimed(pf_current->pi, do_pf_write);
863 pf_end_request(BLK_STS_IOERR);
868 static blk_status_t pf_queue_rq(struct blk_mq_hw_ctx *hctx,
869 const struct blk_mq_queue_data *bd)
871 struct pf_unit *pf = hctx->queue->queuedata;
873 spin_lock_irq(&pf_spin_lock);
874 list_add_tail(&bd->rq->queuelist, &pf->rq_list);
876 spin_unlock_irq(&pf_spin_lock);
881 static int pf_next_buf(void)
883 unsigned long saved_flags;
892 spin_lock_irqsave(&pf_spin_lock, saved_flags);
894 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
897 pf_count = blk_rq_cur_sectors(pf_req);
898 pf_buf = bio_data(pf_req->bio);
903 static inline void next_request(blk_status_t err)
905 unsigned long saved_flags;
907 spin_lock_irqsave(&pf_spin_lock, saved_flags);
911 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
914 /* detach from the calling context - in case the spinlock is held */
915 static void do_pf_read(void)
917 ps_set_intr(do_pf_read_start, NULL, 0, nice);
920 static void do_pf_read_start(void)
924 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
925 pi_disconnect(pf_current->pi);
926 if (pf_retries < PF_MAX_RETRIES) {
928 pi_do_claimed(pf_current->pi, do_pf_read_start);
931 next_request(BLK_STS_IOERR);
935 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
938 static void do_pf_read_drq(void)
941 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
942 "read block", "completion") & STAT_ERR) {
943 pi_disconnect(pf_current->pi);
944 if (pf_retries < PF_MAX_RETRIES) {
945 pf_req_sense(pf_current, 0);
947 pi_do_claimed(pf_current->pi, do_pf_read_start);
950 next_request(BLK_STS_IOERR);
953 pi_read_block(pf_current->pi, pf_buf, 512);
957 pi_disconnect(pf_current->pi);
961 static void do_pf_write(void)
963 ps_set_intr(do_pf_write_start, NULL, 0, nice);
966 static void do_pf_write_start(void)
970 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
971 pi_disconnect(pf_current->pi);
972 if (pf_retries < PF_MAX_RETRIES) {
974 pi_do_claimed(pf_current->pi, do_pf_write_start);
977 next_request(BLK_STS_IOERR);
982 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
983 "write block", "data wait") & STAT_ERR) {
984 pi_disconnect(pf_current->pi);
985 if (pf_retries < PF_MAX_RETRIES) {
987 pi_do_claimed(pf_current->pi, do_pf_write_start);
990 next_request(BLK_STS_IOERR);
993 pi_write_block(pf_current->pi, pf_buf, 512);
998 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
1001 static void do_pf_write_done(void)
1003 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
1004 pi_disconnect(pf_current->pi);
1005 if (pf_retries < PF_MAX_RETRIES) {
1007 pi_do_claimed(pf_current->pi, do_pf_write_start);
1010 next_request(BLK_STS_IOERR);
1013 pi_disconnect(pf_current->pi);
1017 static int __init pf_init(void)
1018 { /* preliminary initialisation */
1031 if (register_blkdev(major, name)) {
1032 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1035 blk_cleanup_queue(pf->disk->queue);
1036 blk_mq_free_tag_set(&pf->tag_set);
1042 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1043 struct gendisk *disk = pf->disk;
1047 disk->private_data = pf;
1053 static void __exit pf_exit(void)
1057 unregister_blkdev(major, name);
1058 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1063 del_gendisk(pf->disk);
1065 blk_cleanup_queue(pf->disk->queue);
1066 blk_mq_free_tag_set(&pf->tag_set);
1074 MODULE_LICENSE("GPL");
1075 module_init(pf_init)
1076 module_exit(pf_exit)