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 int 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;
267
268
269
270static const struct block_device_operations pf_fops = {
271 .owner = THIS_MODULE,
272 .open = pf_open,
273 .release = pf_release,
274 .ioctl = pf_ioctl,
275 .getgeo = pf_getgeo,
276 .check_events = pf_check_events,
277};
278
279static void __init pf_init_units(void)
280{
281 struct pf_unit *pf;
282 int unit;
283
284 pf_drive_count = 0;
285 for (unit = 0, pf = units; unit < PF_UNITS; unit++, pf++) {
286 struct gendisk *disk = alloc_disk(1);
287 if (!disk)
288 continue;
289 pf->disk = disk;
290 pf->pi = &pf->pia;
291 pf->media_status = PF_NM;
292 pf->drive = (*drives[unit])[D_SLV];
293 pf->lun = (*drives[unit])[D_LUN];
294 snprintf(pf->name, PF_NAMELEN, "%s%d", name, unit);
295 disk->major = major;
296 disk->first_minor = unit;
297 strcpy(disk->disk_name, pf->name);
298 disk->fops = &pf_fops;
299 if (!(*drives[unit])[D_PRT])
300 pf_drive_count++;
301 }
302}
303
304static int pf_open(struct block_device *bdev, fmode_t mode)
305{
306 struct pf_unit *pf = bdev->bd_disk->private_data;
307 int ret;
308
309 mutex_lock(&pf_mutex);
310 pf_identify(pf);
311
312 ret = -ENODEV;
313 if (pf->media_status == PF_NM)
314 goto out;
315
316 ret = -EROFS;
317 if ((pf->media_status == PF_RO) && (mode & FMODE_WRITE))
318 goto out;
319
320 ret = 0;
321 pf->access++;
322 if (pf->removable)
323 pf_lock(pf, 1);
324out:
325 mutex_unlock(&pf_mutex);
326 return ret;
327}
328
329static int pf_getgeo(struct block_device *bdev, struct hd_geometry *geo)
330{
331 struct pf_unit *pf = bdev->bd_disk->private_data;
332 sector_t capacity = get_capacity(pf->disk);
333
334 if (capacity < PF_FD_MAX) {
335 geo->cylinders = sector_div(capacity, PF_FD_HDS * PF_FD_SPT);
336 geo->heads = PF_FD_HDS;
337 geo->sectors = PF_FD_SPT;
338 } else {
339 geo->cylinders = sector_div(capacity, PF_HD_HDS * PF_HD_SPT);
340 geo->heads = PF_HD_HDS;
341 geo->sectors = PF_HD_SPT;
342 }
343
344 return 0;
345}
346
347static int pf_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
348{
349 struct pf_unit *pf = bdev->bd_disk->private_data;
350
351 if (cmd != CDROMEJECT)
352 return -EINVAL;
353
354 if (pf->access != 1)
355 return -EBUSY;
356 mutex_lock(&pf_mutex);
357 pf_eject(pf);
358 mutex_unlock(&pf_mutex);
359
360 return 0;
361}
362
363static int pf_release(struct gendisk *disk, fmode_t mode)
364{
365 struct pf_unit *pf = disk->private_data;
366
367 mutex_lock(&pf_mutex);
368 if (pf->access <= 0) {
369 mutex_unlock(&pf_mutex);
370 return -EINVAL;
371 }
372
373 pf->access--;
374
375 if (!pf->access && pf->removable)
376 pf_lock(pf, 0);
377
378 mutex_unlock(&pf_mutex);
379 return 0;
380
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 k = 0;
708 if (pf_drive_count == 0) {
709 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
710 verbose, pf->name)) {
711 if (!pf_probe(pf) && pf->disk) {
712 pf->present = 1;
713 k++;
714 } else
715 pi_release(pf->pi);
716 }
717
718 } else
719 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
720 int *conf = *drives[unit];
721 if (!conf[D_PRT])
722 continue;
723 if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
724 conf[D_UNI], conf[D_PRO], conf[D_DLY],
725 pf_scratch, PI_PF, verbose, pf->name)) {
726 if (pf->disk && !pf_probe(pf)) {
727 pf->present = 1;
728 k++;
729 } else
730 pi_release(pf->pi);
731 }
732 }
733 if (k)
734 return 0;
735
736 printk("%s: No ATAPI disk detected\n", name);
737 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
738 put_disk(pf->disk);
739 return -1;
740}
741
742
743
744static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
745{
746 int i;
747 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
748
749 for (i = 0; i < 4; i++) {
750 io_cmd[5 - i] = b & 0xff;
751 b = b >> 8;
752 }
753
754 io_cmd[8] = c & 0xff;
755 io_cmd[7] = (c >> 8) & 0xff;
756
757 i = pf_command(pf, io_cmd, c * 512, "start i/o");
758
759 mdelay(1);
760
761 return i;
762}
763
764static int pf_ready(void)
765{
766 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
767}
768
769static struct request_queue *pf_queue;
770
771static void pf_end_request(int err)
772{
773 if (pf_req && !__blk_end_request_cur(pf_req, err))
774 pf_req = NULL;
775}
776
777static void do_pf_request(struct request_queue * q)
778{
779 if (pf_busy)
780 return;
781repeat:
782 if (!pf_req) {
783 pf_req = blk_fetch_request(q);
784 if (!pf_req)
785 return;
786 }
787
788 pf_current = pf_req->rq_disk->private_data;
789 pf_block = blk_rq_pos(pf_req);
790 pf_run = blk_rq_sectors(pf_req);
791 pf_count = blk_rq_cur_sectors(pf_req);
792
793 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
794 pf_end_request(-EIO);
795 goto repeat;
796 }
797
798 pf_cmd = rq_data_dir(pf_req);
799 pf_buf = pf_req->buffer;
800 pf_retries = 0;
801
802 pf_busy = 1;
803 if (pf_cmd == READ)
804 pi_do_claimed(pf_current->pi, do_pf_read);
805 else if (pf_cmd == WRITE)
806 pi_do_claimed(pf_current->pi, do_pf_write);
807 else {
808 pf_busy = 0;
809 pf_end_request(-EIO);
810 goto repeat;
811 }
812}
813
814static int pf_next_buf(void)
815{
816 unsigned long saved_flags;
817
818 pf_count--;
819 pf_run--;
820 pf_buf += 512;
821 pf_block++;
822 if (!pf_run)
823 return 1;
824 if (!pf_count) {
825 spin_lock_irqsave(&pf_spin_lock, saved_flags);
826 pf_end_request(0);
827 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
828 if (!pf_req)
829 return 1;
830 pf_count = blk_rq_cur_sectors(pf_req);
831 pf_buf = pf_req->buffer;
832 }
833 return 0;
834}
835
836static inline void next_request(int err)
837{
838 unsigned long saved_flags;
839
840 spin_lock_irqsave(&pf_spin_lock, saved_flags);
841 pf_end_request(err);
842 pf_busy = 0;
843 do_pf_request(pf_queue);
844 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
845}
846
847
848static void do_pf_read(void)
849{
850 ps_set_intr(do_pf_read_start, NULL, 0, nice);
851}
852
853static void do_pf_read_start(void)
854{
855 pf_busy = 1;
856
857 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
858 pi_disconnect(pf_current->pi);
859 if (pf_retries < PF_MAX_RETRIES) {
860 pf_retries++;
861 pi_do_claimed(pf_current->pi, do_pf_read_start);
862 return;
863 }
864 next_request(-EIO);
865 return;
866 }
867 pf_mask = STAT_DRQ;
868 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
869}
870
871static void do_pf_read_drq(void)
872{
873 while (1) {
874 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
875 "read block", "completion") & STAT_ERR) {
876 pi_disconnect(pf_current->pi);
877 if (pf_retries < PF_MAX_RETRIES) {
878 pf_req_sense(pf_current, 0);
879 pf_retries++;
880 pi_do_claimed(pf_current->pi, do_pf_read_start);
881 return;
882 }
883 next_request(-EIO);
884 return;
885 }
886 pi_read_block(pf_current->pi, pf_buf, 512);
887 if (pf_next_buf())
888 break;
889 }
890 pi_disconnect(pf_current->pi);
891 next_request(0);
892}
893
894static void do_pf_write(void)
895{
896 ps_set_intr(do_pf_write_start, NULL, 0, nice);
897}
898
899static void do_pf_write_start(void)
900{
901 pf_busy = 1;
902
903 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
904 pi_disconnect(pf_current->pi);
905 if (pf_retries < PF_MAX_RETRIES) {
906 pf_retries++;
907 pi_do_claimed(pf_current->pi, do_pf_write_start);
908 return;
909 }
910 next_request(-EIO);
911 return;
912 }
913
914 while (1) {
915 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
916 "write block", "data wait") & STAT_ERR) {
917 pi_disconnect(pf_current->pi);
918 if (pf_retries < PF_MAX_RETRIES) {
919 pf_retries++;
920 pi_do_claimed(pf_current->pi, do_pf_write_start);
921 return;
922 }
923 next_request(-EIO);
924 return;
925 }
926 pi_write_block(pf_current->pi, pf_buf, 512);
927 if (pf_next_buf())
928 break;
929 }
930 pf_mask = 0;
931 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
932}
933
934static void do_pf_write_done(void)
935{
936 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
937 pi_disconnect(pf_current->pi);
938 if (pf_retries < PF_MAX_RETRIES) {
939 pf_retries++;
940 pi_do_claimed(pf_current->pi, do_pf_write_start);
941 return;
942 }
943 next_request(-EIO);
944 return;
945 }
946 pi_disconnect(pf_current->pi);
947 next_request(0);
948}
949
950static int __init pf_init(void)
951{
952 struct pf_unit *pf;
953 int unit;
954
955 if (disable)
956 return -EINVAL;
957
958 pf_init_units();
959
960 if (pf_detect())
961 return -ENODEV;
962 pf_busy = 0;
963
964 if (register_blkdev(major, name)) {
965 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
966 put_disk(pf->disk);
967 return -EBUSY;
968 }
969 pf_queue = blk_init_queue(do_pf_request, &pf_spin_lock);
970 if (!pf_queue) {
971 unregister_blkdev(major, name);
972 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
973 put_disk(pf->disk);
974 return -ENOMEM;
975 }
976
977 blk_queue_max_segments(pf_queue, cluster);
978
979 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
980 struct gendisk *disk = pf->disk;
981
982 if (!pf->present)
983 continue;
984 disk->private_data = pf;
985 disk->queue = pf_queue;
986 add_disk(disk);
987 }
988 return 0;
989}
990
991static void __exit pf_exit(void)
992{
993 struct pf_unit *pf;
994 int unit;
995 unregister_blkdev(major, name);
996 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
997 if (!pf->present)
998 continue;
999 del_gendisk(pf->disk);
1000 put_disk(pf->disk);
1001 pi_release(pf->pi);
1002 }
1003 blk_cleanup_queue(pf_queue);
1004}
1005
1006MODULE_LICENSE("GPL");
1007module_init(pf_init)
1008module_exit(pf_exit)
1009