1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116#define PF_VERSION "1.04"
117#define PF_MAJOR 47
118#define PF_NAME "pf"
119#define PF_UNITS 4
120
121#include <linux/types.h>
122
123
124
125
126
127
128
129static bool verbose = 0;
130static int major = PF_MAJOR;
131static char *name = PF_NAME;
132static int cluster = 64;
133static int nice = 0;
134static int disable = 0;
135
136static int drive0[7] = { 0, 0, 0, -1, -1, -1, -1 };
137static int drive1[7] = { 0, 0, 0, -1, -1, -1, -1 };
138static int drive2[7] = { 0, 0, 0, -1, -1, -1, -1 };
139static int drive3[7] = { 0, 0, 0, -1, -1, -1, -1 };
140
141static int (*drives[4])[7] = {&drive0, &drive1, &drive2, &drive3};
142static int pf_drive_count;
143
144enum {D_PRT, D_PRO, D_UNI, D_MOD, D_SLV, D_LUN, D_DLY};
145
146
147
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 <asm/uaccess.h>
159
160static DEFINE_MUTEX(pf_mutex);
161static DEFINE_SPINLOCK(pf_spin_lock);
162
163module_param(verbose, bool, 0644);
164module_param(major, int, 0);
165module_param(name, charp, 0);
166module_param(cluster, int, 0);
167module_param(nice, int, 0);
168module_param_array(drive0, int, NULL, 0);
169module_param_array(drive1, int, NULL, 0);
170module_param_array(drive2, int, NULL, 0);
171module_param_array(drive3, int, NULL, 0);
172
173#include "paride.h"
174#include "pseudo.h"
175
176
177
178#define PF_FD_MAX 8192
179#define PF_FD_HDS 2
180#define PF_FD_SPT 18
181#define PF_HD_HDS 64
182#define PF_HD_SPT 32
183
184#define PF_MAX_RETRIES 5
185#define PF_TMO 800
186#define PF_SPIN_DEL 50
187
188#define PF_SPIN (1000000*PF_TMO)/(HZ*PF_SPIN_DEL)
189
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
198
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
207
208static int pf_open(struct block_device *bdev, fmode_t mode);
209static void do_pf_request(struct request_queue * q);
210static int pf_ioctl(struct block_device *bdev, fmode_t mode,
211 unsigned int cmd, unsigned long arg);
212static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo);
213
214static void pf_release(struct gendisk *disk, fmode_t mode);
215
216static int pf_detect(void);
217static void do_pf_read(void);
218static void do_pf_read_start(void);
219static void do_pf_write(void);
220static void do_pf_write_start(void);
221static void do_pf_read_drq(void);
222static void do_pf_write_done(void);
223
224#define PF_NM 0
225#define PF_RO 1
226#define PF_RW 2
227
228#define PF_NAMELEN 8
229
230struct pf_unit {
231 struct pi_adapter pia;
232 struct pi_adapter *pi;
233 int removable;
234 int media_status;
235 int drive;
236 int lun;
237 int access;
238 int present;
239 char name[PF_NAMELEN];
240 struct gendisk *disk;
241};
242
243static struct pf_unit units[PF_UNITS];
244
245static int pf_identify(struct pf_unit *pf);
246static void pf_lock(struct pf_unit *pf, int func);
247static void pf_eject(struct pf_unit *pf);
248static unsigned int pf_check_events(struct gendisk *disk,
249 unsigned int clearing);
250
251static char pf_scratch[512];
252
253
254
255
256
257static int pf_retries = 0;
258static int pf_busy = 0;
259static struct request *pf_req;
260static int pf_block;
261static int pf_count;
262static int pf_run;
263static int pf_cmd;
264static struct pf_unit *pf_current;
265static int pf_mask;
266static char *pf_buf;
267static void *par_drv;
268
269
270
271static const struct block_device_operations pf_fops = {
272 .owner = THIS_MODULE,
273 .open = pf_open,
274 .release = pf_release,
275 .ioctl = pf_ioctl,
276 .getgeo = pf_getgeo,
277 .check_events = pf_check_events,
278};
279
280static void __init pf_init_units(void)
281{
282 struct pf_unit *pf;
283 int unit;
284
285 pf_drive_count = 0;
286 for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
287 struct gendisk *disk = alloc_disk(1);
288 if (!disk)
289 continue;
290 pf->disk = disk;
291 pf->pi = &pf->pia;
292 pf->media_status = PF_NM;
293 pf->drive = (*drives[unit])[D_SLV];
294 pf->lun = (*drives[unit])[D_LUN];
295 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
296 disk->major = major;
297 disk->first_minor = unit;
298 strcpy(disk->disk_name, pf->name);
299 disk->fops = &pf_fops;
300 if (!(*drives[unit])[D_PRT])
301 pf_drive_count++;
302 }
303}
304
305static int pf_open(struct block_device *bdev, fmode_t mode)
306{
307 struct pf_unit *pf = bdev->bd_disk->private_data;
308 int ret;
309
310 mutex_lock(&pf_mutex);
311 pf_identify(pf);
312
313 ret = -ENODEV;
314 if (pf->media_status == PF_NM)
315 goto out;
316
317 ret = -EROFS;
318 if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
319 goto out;
320
321 ret = 0;
322 pf->access++;
323 if (pf->removable)
324 pf_lock(pf, 1);
325out:
326 mutex_unlock(&pf_mutex);
327 return ret;
328}
329
330static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
331{
332 struct pf_unit *pf = bdev->bd_disk->private_data;
333 sector_t capacity = get_capacity(pf->disk);
334
335 if (capacity < PF_FD_MAX) {
336 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
337 geo->heads = PF_FD_HDS;
338 geo->sectors = PF_FD_SPT;
339 } else {
340 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
341 geo->heads = PF_HD_HDS;
342 geo->sectors = PF_HD_SPT;
343 }
344
345 return 0;
346}
347
348static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
349{
350 struct pf_unit *pf = bdev->bd_disk->private_data;
351
352 if (cmd != CDROMEJECT)
353 return -EINVAL;
354
355 if (pf->access != 1)
356 return -EBUSY;
357 mutex_lock(&pf_mutex);
358 pf_eject(pf);
359 mutex_unlock(&pf_mutex);
360
361 return 0;
362}
363
364static void pf_release(struct gendisk *disk, fmode_t mode)
365{
366 struct pf_unit *pf = disk->private_data;
367
368 mutex_lock(&pf_mutex);
369 if (pf->access <= 0) {
370 mutex_unlock(&pf_mutex);
371 WARN_ON(1);
372 return;
373 }
374
375 pf->access--;
376
377 if (!pf->access && pf->removable)
378 pf_lock(pf, 0);
379
380 mutex_unlock(&pf_mutex);
381}
382
383static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
384{
385 return DISK_EVENT_MEDIA_CHANGE;
386}
387
388static inline int status_reg(struct pf_unit *pf)
389{
390 return pi_read_regr(pf->pi, 1, 6);
391}
392
393static inline int read_reg(struct pf_unit *pf, int reg)
394{
395 return pi_read_regr(pf->pi, 0, reg);
396}
397
398static inline void write_reg(struct pf_unit *pf, int reg, int val)
399{
400 pi_write_regr(pf->pi, 0, reg, val);
401}
402
403static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
404{
405 int j, r, e, s, p;
406
407 j = 0;
408 while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
409 && (j++ < PF_SPIN))
410 udelay(PF_SPIN_DEL);
411
412 if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
413 s = read_reg(pf, 7);
414 e = read_reg(pf, 1);
415 p = read_reg(pf, 2);
416 if (j > PF_SPIN)
417 e |= 0x100;
418 if (fun)
419 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
420 " loop=%d phase=%d\n",
421 pf->name, fun, msg, r, s, e, j, p);
422 return (e << 8) + s;
423 }
424 return 0;
425}
426
427static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
428{
429 pi_connect(pf->pi);
430
431 write_reg(pf, 6, 0xa0+0x10*pf->drive);
432
433 if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
434 pi_disconnect(pf->pi);
435 return -1;
436 }
437
438 write_reg(pf, 4, dlen % 256);
439 write_reg(pf, 5, dlen / 256);
440 write_reg(pf, 7, 0xa0);
441
442 if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
443 pi_disconnect(pf->pi);
444 return -1;
445 }
446
447 if (read_reg(pf, 2) != 1) {
448 printk("%s: %s: command phase error\n", pf->name, fun);
449 pi_disconnect(pf->pi);
450 return -1;
451 }
452
453 pi_write_block(pf->pi, cmd, 12);
454
455 return 0;
456}
457
458static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
459{
460 int r, s, n;
461
462 r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
463 fun, "completion");
464
465 if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
466 n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
467 3) & 0xfffc);
468 pi_read_block(pf->pi, buf, n);
469 }
470
471 s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
472
473 pi_disconnect(pf->pi);
474
475 return (r ? r : s);
476}
477
478static void pf_req_sense(struct pf_unit *pf, int quiet)
479{
480 char rs_cmd[12] =
481 { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
482 char buf[16];
483 int r;
484
485 r = pf_command(pf, rs_cmd, 16, "Request sense");
486 mdelay(1);
487 if (!r)
488 pf_completion(pf, buf, "Request sense");
489
490 if ((!r) && (!quiet))
491 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
492 pf->name, buf[2] & 0xf, buf[12], buf[13]);
493}
494
495static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
496{
497 int r;
498
499 r = pf_command(pf, cmd, dlen, fun);
500 mdelay(1);
501 if (!r)
502 r = pf_completion(pf, buf, fun);
503 if (r)
504 pf_req_sense(pf, !fun);
505
506 return r;
507}
508
509static void pf_lock(struct pf_unit *pf, int func)
510{
511 char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
512
513 pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
514}
515
516static void pf_eject(struct pf_unit *pf)
517{
518 char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
519
520 pf_lock(pf, 0);
521 pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
522}
523
524#define PF_RESET_TMO 30
525
526static void pf_sleep(int cs)
527{
528 schedule_timeout_interruptible(cs);
529}
530
531
532
533
534
535
536static int pf_reset(struct pf_unit *pf)
537{
538 int i, k, flg;
539 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
540
541 pi_connect(pf->pi);
542 write_reg(pf, 6, 0xa0+0x10*pf->drive);
543 write_reg(pf, 7, 8);
544
545 pf_sleep(20 * HZ / 1000);
546
547 k = 0;
548 while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
549 pf_sleep(HZ / 10);
550
551 flg = 1;
552 for (i = 0; i < 5; i++)
553 flg &= (read_reg(pf, i + 1) == expect[i]);
554
555 if (verbose) {
556 printk("%s: Reset (%d) signature = ", pf->name, k);
557 for (i = 0; i < 5; i++)
558 printk("%3x", read_reg(pf, i + 1));
559 if (!flg)
560 printk(" (incorrect)");
561 printk("\n");
562 }
563
564 pi_disconnect(pf->pi);
565 return flg - 1;
566}
567
568static void pf_mode_sense(struct pf_unit *pf)
569{
570 char ms_cmd[12] =
571 { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
572 char buf[8];
573
574 pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
575 pf->media_status = PF_RW;
576 if (buf[3] & 0x80)
577 pf->media_status = PF_RO;
578}
579
580static void xs(char *buf, char *targ, int offs, int len)
581{
582 int j, k, l;
583
584 j = 0;
585 l = 0;
586 for (k = 0; k < len; k++)
587 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
588 l = targ[j++] = buf[k + offs];
589 if (l == 0x20)
590 j--;
591 targ[j] = 0;
592}
593
594static int xl(char *buf, int offs)
595{
596 int v, k;
597
598 v = 0;
599 for (k = 0; k < 4; k++)
600 v = v * 256 + (buf[k + offs] & 0xff);
601 return v;
602}
603
604static void pf_get_capacity(struct pf_unit *pf)
605{
606 char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
607 char buf[8];
608 int bs;
609
610 if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
611 pf->media_status = PF_NM;
612 return;
613 }
614 set_capacity(pf->disk, xl(buf, 0) + 1);
615 bs = xl(buf, 4);
616 if (bs != 512) {
617 set_capacity(pf->disk, 0);
618 if (verbose)
619 printk("%s: Drive %d, LUN %d,"
620 " unsupported block size %d\n",
621 pf->name, pf->drive, pf->lun, bs);
622 }
623}
624
625static int pf_identify(struct pf_unit *pf)
626{
627 int dt, s;
628 char *ms[2] = { "master", "slave" };
629 char mf[10], id[18];
630 char id_cmd[12] =
631 { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
632 char buf[36];
633
634 s = pf_atapi(pf, id_cmd, 36, buf, "identify");
635 if (s)
636 return -1;
637
638 dt = buf[0] & 0x1f;
639 if ((dt != 0) && (dt != 7)) {
640 if (verbose)
641 printk("%s: Drive %d, LUN %d, unsupported type %d\n",
642 pf->name, pf->drive, pf->lun, dt);
643 return -1;
644 }
645
646 xs(buf, mf, 8, 8);
647 xs(buf, id, 16, 16);
648
649 pf->removable = (buf[1] & 0x80);
650
651 pf_mode_sense(pf);
652 pf_mode_sense(pf);
653 pf_mode_sense(pf);
654
655 pf_get_capacity(pf);
656
657 printk("%s: %s %s, %s LUN %d, type %d",
658 pf->name, mf, id, ms[pf->drive], pf->lun, dt);
659 if (pf->removable)
660 printk(", removable");
661 if (pf->media_status == PF_NM)
662 printk(", no media\n");
663 else {
664 if (pf->media_status == PF_RO)
665 printk(", RO");
666 printk(", %llu blocks\n",
667 (unsigned long long)get_capacity(pf->disk));
668 }
669 return 0;
670}
671
672
673
674
675static int pf_probe(struct pf_unit *pf)
676{
677 if (pf->drive == -1) {
678 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
679 if (!pf_reset(pf)) {
680 if (pf->lun != -1)
681 return pf_identify(pf);
682 else
683 for (pf->lun = 0; pf->lun < 8; pf->lun++)
684 if (!pf_identify(pf))
685 return 0;
686 }
687 } else {
688 if (pf_reset(pf))
689 return -1;
690 if (pf->lun != -1)
691 return pf_identify(pf);
692 for (pf->lun = 0; pf->lun < 8; pf->lun++)
693 if (!pf_identify(pf))
694 return 0;
695 }
696 return -1;
697}
698
699static int pf_detect(void)
700{
701 struct pf_unit *pf = units;
702 int k, unit;
703
704 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
705 name, name, PF_VERSION, major, cluster, nice);
706
707 par_drv = pi_register_driver(name);
708 if (!par_drv) {
709 pr_err("failed to register %s driver\n", name);
710 return -1;
711 }
712 k = 0;
713 if (pf_drive_count == 0) {
714 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
715 verbose, pf->name)) {
716 if (!pf_probe(pf) && pf->disk) {
717 pf->present = 1;
718 k++;
719 } else
720 pi_release(pf->pi);
721 }
722
723 } else
724 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
725 int *conf = *drives[unit];
726 if (!conf[D_PRT])
727 continue;
728 if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
729 conf[D_UNI], conf[D_PRO], conf[D_DLY],
730 pf_scratch, PI_PF, verbose, pf->name)) {
731 if (pf->disk && !pf_probe(pf)) {
732 pf->present = 1;
733 k++;
734 } else
735 pi_release(pf->pi);
736 }
737 }
738 if (k)
739 return 0;
740
741 printk("%s: No ATAPI disk detected\n", name);
742 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
743 put_disk(pf->disk);
744 pi_unregister_driver(par_drv);
745 return -1;
746}
747
748
749
750static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
751{
752 int i;
753 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
754
755 for (i = 0; i < 4; i++) {
756 io_cmd[5 - i] = b & 0xff;
757 b = b >> 8;
758 }
759
760 io_cmd[8] = c & 0xff;
761 io_cmd[7] = (c >> 8) & 0xff;
762
763 i = pf_command(pf, io_cmd, c * 512, "start i/o");
764
765 mdelay(1);
766
767 return i;
768}
769
770static int pf_ready(void)
771{
772 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
773}
774
775static struct request_queue *pf_queue;
776
777static void pf_end_request(int err)
778{
779 if (pf_req && !__blk_end_request_cur(pf_req, err))
780 pf_req = NULL;
781}
782
783static void do_pf_request(struct request_queue * q)
784{
785 if (pf_busy)
786 return;
787repeat:
788 if (!pf_req) {
789 pf_req = blk_fetch_request(q);
790 if (!pf_req)
791 return;
792 }
793
794 pf_current = pf_req->rq_disk->private_data;
795 pf_block = blk_rq_pos(pf_req);
796 pf_run = blk_rq_sectors(pf_req);
797 pf_count = blk_rq_cur_sectors(pf_req);
798
799 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
800 pf_end_request(-EIO);
801 goto repeat;
802 }
803
804 pf_cmd = rq_data_dir(pf_req);
805 pf_buf = bio_data(pf_req->bio);
806 pf_retries = 0;
807
808 pf_busy = 1;
809 if (pf_cmd == READ)
810 pi_do_claimed(pf_current->pi, do_pf_read);
811 else if (pf_cmd == WRITE)
812 pi_do_claimed(pf_current->pi, do_pf_write);
813 else {
814 pf_busy = 0;
815 pf_end_request(-EIO);
816 goto repeat;
817 }
818}
819
820static int pf_next_buf(void)
821{
822 unsigned long saved_flags;
823
824 pf_count--;
825 pf_run--;
826 pf_buf += 512;
827 pf_block++;
828 if (!pf_run)
829 return 1;
830 if (!pf_count) {
831 spin_lock_irqsave(&pf_spin_lock, saved_flags);
832 pf_end_request(0);
833 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
834 if (!pf_req)
835 return 1;
836 pf_count = blk_rq_cur_sectors(pf_req);
837 pf_buf = bio_data(pf_req->bio);
838 }
839 return 0;
840}
841
842static inline void next_request(int err)
843{
844 unsigned long saved_flags;
845
846 spin_lock_irqsave(&pf_spin_lock, saved_flags);
847 pf_end_request(err);
848 pf_busy = 0;
849 do_pf_request(pf_queue);
850 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
851}
852
853
854static void do_pf_read(void)
855{
856 ps_set_intr(do_pf_read_start, NULL, 0, nice);
857}
858
859static void do_pf_read_start(void)
860{
861 pf_busy = 1;
862
863 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
864 pi_disconnect(pf_current->pi);
865 if (pf_retries < PF_MAX_RETRIES) {
866 pf_retries++;
867 pi_do_claimed(pf_current->pi, do_pf_read_start);
868 return;
869 }
870 next_request(-EIO);
871 return;
872 }
873 pf_mask = STAT_DRQ;
874 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
875}
876
877static void do_pf_read_drq(void)
878{
879 while (1) {
880 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
881 "read block", "completion") & STAT_ERR) {
882 pi_disconnect(pf_current->pi);
883 if (pf_retries < PF_MAX_RETRIES) {
884 pf_req_sense(pf_current, 0);
885 pf_retries++;
886 pi_do_claimed(pf_current->pi, do_pf_read_start);
887 return;
888 }
889 next_request(-EIO);
890 return;
891 }
892 pi_read_block(pf_current->pi, pf_buf, 512);
893 if (pf_next_buf())
894 break;
895 }
896 pi_disconnect(pf_current->pi);
897 next_request(0);
898}
899
900static void do_pf_write(void)
901{
902 ps_set_intr(do_pf_write_start, NULL, 0, nice);
903}
904
905static void do_pf_write_start(void)
906{
907 pf_busy = 1;
908
909 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
910 pi_disconnect(pf_current->pi);
911 if (pf_retries < PF_MAX_RETRIES) {
912 pf_retries++;
913 pi_do_claimed(pf_current->pi, do_pf_write_start);
914 return;
915 }
916 next_request(-EIO);
917 return;
918 }
919
920 while (1) {
921 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
922 "write block", "data wait") & STAT_ERR) {
923 pi_disconnect(pf_current->pi);
924 if (pf_retries < PF_MAX_RETRIES) {
925 pf_retries++;
926 pi_do_claimed(pf_current->pi, do_pf_write_start);
927 return;
928 }
929 next_request(-EIO);
930 return;
931 }
932 pi_write_block(pf_current->pi, pf_buf, 512);
933 if (pf_next_buf())
934 break;
935 }
936 pf_mask = 0;
937 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
938}
939
940static void do_pf_write_done(void)
941{
942 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
943 pi_disconnect(pf_current->pi);
944 if (pf_retries < PF_MAX_RETRIES) {
945 pf_retries++;
946 pi_do_claimed(pf_current->pi, do_pf_write_start);
947 return;
948 }
949 next_request(-EIO);
950 return;
951 }
952 pi_disconnect(pf_current->pi);
953 next_request(0);
954}
955
956static int __init pf_init(void)
957{
958 struct pf_unit *pf;
959 int unit;
960
961 if (disable)
962 return -EINVAL;
963
964 pf_init_units();
965
966 if (pf_detect())
967 return -ENODEV;
968 pf_busy = 0;
969
970 if (register_blkdev(major, name)) {
971 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
972 put_disk(pf->disk);
973 return -EBUSY;
974 }
975 pf_queue = blk_init_queue(do_pf_request, &pf_spin_lock);
976 if (!pf_queue) {
977 unregister_blkdev(major, name);
978 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
979 put_disk(pf->disk);
980 return -ENOMEM;
981 }
982
983 blk_queue_max_segments(pf_queue, cluster);
984
985 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
986 struct gendisk *disk = pf->disk;
987
988 if (!pf->present)
989 continue;
990 disk->private_data = pf;
991 disk->queue = pf_queue;
992 add_disk(disk);
993 }
994 return 0;
995}
996
997static void __exit pf_exit(void)
998{
999 struct pf_unit *pf;
1000 int unit;
1001 unregister_blkdev(major, name);
1002 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
1003 if (!pf->present)
1004 continue;
1005 del_gendisk(pf->disk);
1006 put_disk(pf->disk);
1007 pi_release(pf->pi);
1008 }
1009 blk_cleanup_queue(pf_queue);
1010}
1011
1012MODULE_LICENSE("GPL");
1013module_init(pf_init)
1014module_exit(pf_exit)
1015