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;
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 void 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 WARN_ON(1);
371 return;
372 }
373
374 pf->access--;
375
376 if (!pf->access && pf->removable)
377 pf_lock(pf, 0);
378
379 mutex_unlock(&pf_mutex);
380}
381
382static unsigned int pf_check_events(struct gendisk *disk, unsigned int clearing)
383{
384 return DISK_EVENT_MEDIA_CHANGE;
385}
386
387static inline int status_reg(struct pf_unit *pf)
388{
389 return pi_read_regr(pf->pi, 1, 6);
390}
391
392static inline int read_reg(struct pf_unit *pf, int reg)
393{
394 return pi_read_regr(pf->pi, 0, reg);
395}
396
397static inline void write_reg(struct pf_unit *pf, int reg, int val)
398{
399 pi_write_regr(pf->pi, 0, reg, val);
400}
401
402static int pf_wait(struct pf_unit *pf, int go, int stop, char *fun, char *msg)
403{
404 int j, r, e, s, p;
405
406 j = 0;
407 while ((((r = status_reg(pf)) & go) || (stop && (!(r & stop))))
408 && (j++ < PF_SPIN))
409 udelay(PF_SPIN_DEL);
410
411 if ((r & (STAT_ERR & stop)) || (j > PF_SPIN)) {
412 s = read_reg(pf, 7);
413 e = read_reg(pf, 1);
414 p = read_reg(pf, 2);
415 if (j > PF_SPIN)
416 e |= 0x100;
417 if (fun)
418 printk("%s: %s %s: alt=0x%x stat=0x%x err=0x%x"
419 " loop=%d phase=%d\n",
420 pf->name, fun, msg, r, s, e, j, p);
421 return (e << 8) + s;
422 }
423 return 0;
424}
425
426static int pf_command(struct pf_unit *pf, char *cmd, int dlen, char *fun)
427{
428 pi_connect(pf->pi);
429
430 write_reg(pf, 6, 0xa0+0x10*pf->drive);
431
432 if (pf_wait(pf, STAT_BUSY | STAT_DRQ, 0, fun, "before command")) {
433 pi_disconnect(pf->pi);
434 return -1;
435 }
436
437 write_reg(pf, 4, dlen % 256);
438 write_reg(pf, 5, dlen / 256);
439 write_reg(pf, 7, 0xa0);
440
441 if (pf_wait(pf, STAT_BUSY, STAT_DRQ, fun, "command DRQ")) {
442 pi_disconnect(pf->pi);
443 return -1;
444 }
445
446 if (read_reg(pf, 2) != 1) {
447 printk("%s: %s: command phase error\n", pf->name, fun);
448 pi_disconnect(pf->pi);
449 return -1;
450 }
451
452 pi_write_block(pf->pi, cmd, 12);
453
454 return 0;
455}
456
457static int pf_completion(struct pf_unit *pf, char *buf, char *fun)
458{
459 int r, s, n;
460
461 r = pf_wait(pf, STAT_BUSY, STAT_DRQ | STAT_READY | STAT_ERR,
462 fun, "completion");
463
464 if ((read_reg(pf, 2) & 2) && (read_reg(pf, 7) & STAT_DRQ)) {
465 n = (((read_reg(pf, 4) + 256 * read_reg(pf, 5)) +
466 3) & 0xfffc);
467 pi_read_block(pf->pi, buf, n);
468 }
469
470 s = pf_wait(pf, STAT_BUSY, STAT_READY | STAT_ERR, fun, "data done");
471
472 pi_disconnect(pf->pi);
473
474 return (r ? r : s);
475}
476
477static void pf_req_sense(struct pf_unit *pf, int quiet)
478{
479 char rs_cmd[12] =
480 { ATAPI_REQ_SENSE, pf->lun << 5, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
481 char buf[16];
482 int r;
483
484 r = pf_command(pf, rs_cmd, 16, "Request sense");
485 mdelay(1);
486 if (!r)
487 pf_completion(pf, buf, "Request sense");
488
489 if ((!r) && (!quiet))
490 printk("%s: Sense key: %x, ASC: %x, ASQ: %x\n",
491 pf->name, buf[2] & 0xf, buf[12], buf[13]);
492}
493
494static int pf_atapi(struct pf_unit *pf, char *cmd, int dlen, char *buf, char *fun)
495{
496 int r;
497
498 r = pf_command(pf, cmd, dlen, fun);
499 mdelay(1);
500 if (!r)
501 r = pf_completion(pf, buf, fun);
502 if (r)
503 pf_req_sense(pf, !fun);
504
505 return r;
506}
507
508static void pf_lock(struct pf_unit *pf, int func)
509{
510 char lo_cmd[12] = { ATAPI_LOCK, pf->lun << 5, 0, 0, func, 0, 0, 0, 0, 0, 0, 0 };
511
512 pf_atapi(pf, lo_cmd, 0, pf_scratch, func ? "lock" : "unlock");
513}
514
515static void pf_eject(struct pf_unit *pf)
516{
517 char ej_cmd[12] = { ATAPI_DOOR, pf->lun << 5, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
518
519 pf_lock(pf, 0);
520 pf_atapi(pf, ej_cmd, 0, pf_scratch, "eject");
521}
522
523#define PF_RESET_TMO 30
524
525static void pf_sleep(int cs)
526{
527 schedule_timeout_interruptible(cs);
528}
529
530
531
532
533
534
535static int pf_reset(struct pf_unit *pf)
536{
537 int i, k, flg;
538 int expect[5] = { 1, 1, 1, 0x14, 0xeb };
539
540 pi_connect(pf->pi);
541 write_reg(pf, 6, 0xa0+0x10*pf->drive);
542 write_reg(pf, 7, 8);
543
544 pf_sleep(20 * HZ / 1000);
545
546 k = 0;
547 while ((k++ < PF_RESET_TMO) && (status_reg(pf) & STAT_BUSY))
548 pf_sleep(HZ / 10);
549
550 flg = 1;
551 for (i = 0; i < 5; i++)
552 flg &= (read_reg(pf, i + 1) == expect[i]);
553
554 if (verbose) {
555 printk("%s: Reset (%d) signature = ", pf->name, k);
556 for (i = 0; i < 5; i++)
557 printk("%3x", read_reg(pf, i + 1));
558 if (!flg)
559 printk(" (incorrect)");
560 printk("\n");
561 }
562
563 pi_disconnect(pf->pi);
564 return flg - 1;
565}
566
567static void pf_mode_sense(struct pf_unit *pf)
568{
569 char ms_cmd[12] =
570 { ATAPI_MODE_SENSE, pf->lun << 5, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0 };
571 char buf[8];
572
573 pf_atapi(pf, ms_cmd, 8, buf, "mode sense");
574 pf->media_status = PF_RW;
575 if (buf[3] & 0x80)
576 pf->media_status = PF_RO;
577}
578
579static void xs(char *buf, char *targ, int offs, int len)
580{
581 int j, k, l;
582
583 j = 0;
584 l = 0;
585 for (k = 0; k < len; k++)
586 if ((buf[k + offs] != 0x20) || (buf[k + offs] != l))
587 l = targ[j++] = buf[k + offs];
588 if (l == 0x20)
589 j--;
590 targ[j] = 0;
591}
592
593static int xl(char *buf, int offs)
594{
595 int v, k;
596
597 v = 0;
598 for (k = 0; k < 4; k++)
599 v = v * 256 + (buf[k + offs] & 0xff);
600 return v;
601}
602
603static void pf_get_capacity(struct pf_unit *pf)
604{
605 char rc_cmd[12] = { ATAPI_CAPACITY, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
606 char buf[8];
607 int bs;
608
609 if (pf_atapi(pf, rc_cmd, 8, buf, "get capacity")) {
610 pf->media_status = PF_NM;
611 return;
612 }
613 set_capacity(pf->disk, xl(buf, 0) + 1);
614 bs = xl(buf, 4);
615 if (bs != 512) {
616 set_capacity(pf->disk, 0);
617 if (verbose)
618 printk("%s: Drive %d, LUN %d,"
619 " unsupported block size %d\n",
620 pf->name, pf->drive, pf->lun, bs);
621 }
622}
623
624static int pf_identify(struct pf_unit *pf)
625{
626 int dt, s;
627 char *ms[2] = { "master", "slave" };
628 char mf[10], id[18];
629 char id_cmd[12] =
630 { ATAPI_IDENTIFY, pf->lun << 5, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0 };
631 char buf[36];
632
633 s = pf_atapi(pf, id_cmd, 36, buf, "identify");
634 if (s)
635 return -1;
636
637 dt = buf[0] & 0x1f;
638 if ((dt != 0) && (dt != 7)) {
639 if (verbose)
640 printk("%s: Drive %d, LUN %d, unsupported type %d\n",
641 pf->name, pf->drive, pf->lun, dt);
642 return -1;
643 }
644
645 xs(buf, mf, 8, 8);
646 xs(buf, id, 16, 16);
647
648 pf->removable = (buf[1] & 0x80);
649
650 pf_mode_sense(pf);
651 pf_mode_sense(pf);
652 pf_mode_sense(pf);
653
654 pf_get_capacity(pf);
655
656 printk("%s: %s %s, %s LUN %d, type %d",
657 pf->name, mf, id, ms[pf->drive], pf->lun, dt);
658 if (pf->removable)
659 printk(", removable");
660 if (pf->media_status == PF_NM)
661 printk(", no media\n");
662 else {
663 if (pf->media_status == PF_RO)
664 printk(", RO");
665 printk(", %llu blocks\n",
666 (unsigned long long)get_capacity(pf->disk));
667 }
668 return 0;
669}
670
671
672
673
674static int pf_probe(struct pf_unit *pf)
675{
676 if (pf->drive == -1) {
677 for (pf->drive = 0; pf->drive <= 1; pf->drive++)
678 if (!pf_reset(pf)) {
679 if (pf->lun != -1)
680 return pf_identify(pf);
681 else
682 for (pf->lun = 0; pf->lun < 8; pf->lun++)
683 if (!pf_identify(pf))
684 return 0;
685 }
686 } else {
687 if (pf_reset(pf))
688 return -1;
689 if (pf->lun != -1)
690 return pf_identify(pf);
691 for (pf->lun = 0; pf->lun < 8; pf->lun++)
692 if (!pf_identify(pf))
693 return 0;
694 }
695 return -1;
696}
697
698static int pf_detect(void)
699{
700 struct pf_unit *pf = units;
701 int k, unit;
702
703 printk("%s: %s version %s, major %d, cluster %d, nice %d\n",
704 name, name, PF_VERSION, major, cluster, nice);
705
706 k = 0;
707 if (pf_drive_count == 0) {
708 if (pi_init(pf->pi, 1, -1, -1, -1, -1, -1, pf_scratch, PI_PF,
709 verbose, pf->name)) {
710 if (!pf_probe(pf) && pf->disk) {
711 pf->present = 1;
712 k++;
713 } else
714 pi_release(pf->pi);
715 }
716
717 } else
718 for (unit = 0; unit < PF_UNITS; unit++, pf++) {
719 int *conf = *drives[unit];
720 if (!conf[D_PRT])
721 continue;
722 if (pi_init(pf->pi, 0, conf[D_PRT], conf[D_MOD],
723 conf[D_UNI], conf[D_PRO], conf[D_DLY],
724 pf_scratch, PI_PF, verbose, pf->name)) {
725 if (pf->disk && !pf_probe(pf)) {
726 pf->present = 1;
727 k++;
728 } else
729 pi_release(pf->pi);
730 }
731 }
732 if (k)
733 return 0;
734
735 printk("%s: No ATAPI disk detected\n", name);
736 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
737 put_disk(pf->disk);
738 return -1;
739}
740
741
742
743static int pf_start(struct pf_unit *pf, int cmd, int b, int c)
744{
745 int i;
746 char io_cmd[12] = { cmd, pf->lun << 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
747
748 for (i = 0; i < 4; i++) {
749 io_cmd[5 - i] = b & 0xff;
750 b = b >> 8;
751 }
752
753 io_cmd[8] = c & 0xff;
754 io_cmd[7] = (c >> 8) & 0xff;
755
756 i = pf_command(pf, io_cmd, c * 512, "start i/o");
757
758 mdelay(1);
759
760 return i;
761}
762
763static int pf_ready(void)
764{
765 return (((status_reg(pf_current) & (STAT_BUSY | pf_mask)) == pf_mask));
766}
767
768static struct request_queue *pf_queue;
769
770static void pf_end_request(int err)
771{
772 if (pf_req && !__blk_end_request_cur(pf_req, err))
773 pf_req = NULL;
774}
775
776static void do_pf_request(struct request_queue * q)
777{
778 if (pf_busy)
779 return;
780repeat:
781 if (!pf_req) {
782 pf_req = blk_fetch_request(q);
783 if (!pf_req)
784 return;
785 }
786
787 pf_current = pf_req->rq_disk->private_data;
788 pf_block = blk_rq_pos(pf_req);
789 pf_run = blk_rq_sectors(pf_req);
790 pf_count = blk_rq_cur_sectors(pf_req);
791
792 if (pf_block + pf_count > get_capacity(pf_req->rq_disk)) {
793 pf_end_request(-EIO);
794 goto repeat;
795 }
796
797 pf_cmd = rq_data_dir(pf_req);
798 pf_buf = pf_req->buffer;
799 pf_retries = 0;
800
801 pf_busy = 1;
802 if (pf_cmd == READ)
803 pi_do_claimed(pf_current->pi, do_pf_read);
804 else if (pf_cmd == WRITE)
805 pi_do_claimed(pf_current->pi, do_pf_write);
806 else {
807 pf_busy = 0;
808 pf_end_request(-EIO);
809 goto repeat;
810 }
811}
812
813static int pf_next_buf(void)
814{
815 unsigned long saved_flags;
816
817 pf_count--;
818 pf_run--;
819 pf_buf += 512;
820 pf_block++;
821 if (!pf_run)
822 return 1;
823 if (!pf_count) {
824 spin_lock_irqsave(&pf_spin_lock, saved_flags);
825 pf_end_request(0);
826 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
827 if (!pf_req)
828 return 1;
829 pf_count = blk_rq_cur_sectors(pf_req);
830 pf_buf = pf_req->buffer;
831 }
832 return 0;
833}
834
835static inline void next_request(int err)
836{
837 unsigned long saved_flags;
838
839 spin_lock_irqsave(&pf_spin_lock, saved_flags);
840 pf_end_request(err);
841 pf_busy = 0;
842 do_pf_request(pf_queue);
843 spin_unlock_irqrestore(&pf_spin_lock, saved_flags);
844}
845
846
847static void do_pf_read(void)
848{
849 ps_set_intr(do_pf_read_start, NULL, 0, nice);
850}
851
852static void do_pf_read_start(void)
853{
854 pf_busy = 1;
855
856 if (pf_start(pf_current, ATAPI_READ_10, pf_block, pf_run)) {
857 pi_disconnect(pf_current->pi);
858 if (pf_retries < PF_MAX_RETRIES) {
859 pf_retries++;
860 pi_do_claimed(pf_current->pi, do_pf_read_start);
861 return;
862 }
863 next_request(-EIO);
864 return;
865 }
866 pf_mask = STAT_DRQ;
867 ps_set_intr(do_pf_read_drq, pf_ready, PF_TMO, nice);
868}
869
870static void do_pf_read_drq(void)
871{
872 while (1) {
873 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
874 "read block", "completion") & STAT_ERR) {
875 pi_disconnect(pf_current->pi);
876 if (pf_retries < PF_MAX_RETRIES) {
877 pf_req_sense(pf_current, 0);
878 pf_retries++;
879 pi_do_claimed(pf_current->pi, do_pf_read_start);
880 return;
881 }
882 next_request(-EIO);
883 return;
884 }
885 pi_read_block(pf_current->pi, pf_buf, 512);
886 if (pf_next_buf())
887 break;
888 }
889 pi_disconnect(pf_current->pi);
890 next_request(0);
891}
892
893static void do_pf_write(void)
894{
895 ps_set_intr(do_pf_write_start, NULL, 0, nice);
896}
897
898static void do_pf_write_start(void)
899{
900 pf_busy = 1;
901
902 if (pf_start(pf_current, ATAPI_WRITE_10, pf_block, pf_run)) {
903 pi_disconnect(pf_current->pi);
904 if (pf_retries < PF_MAX_RETRIES) {
905 pf_retries++;
906 pi_do_claimed(pf_current->pi, do_pf_write_start);
907 return;
908 }
909 next_request(-EIO);
910 return;
911 }
912
913 while (1) {
914 if (pf_wait(pf_current, STAT_BUSY, STAT_DRQ | STAT_ERR,
915 "write block", "data wait") & STAT_ERR) {
916 pi_disconnect(pf_current->pi);
917 if (pf_retries < PF_MAX_RETRIES) {
918 pf_retries++;
919 pi_do_claimed(pf_current->pi, do_pf_write_start);
920 return;
921 }
922 next_request(-EIO);
923 return;
924 }
925 pi_write_block(pf_current->pi, pf_buf, 512);
926 if (pf_next_buf())
927 break;
928 }
929 pf_mask = 0;
930 ps_set_intr(do_pf_write_done, pf_ready, PF_TMO, nice);
931}
932
933static void do_pf_write_done(void)
934{
935 if (pf_wait(pf_current, STAT_BUSY, 0, "write block", "done") & STAT_ERR) {
936 pi_disconnect(pf_current->pi);
937 if (pf_retries < PF_MAX_RETRIES) {
938 pf_retries++;
939 pi_do_claimed(pf_current->pi, do_pf_write_start);
940 return;
941 }
942 next_request(-EIO);
943 return;
944 }
945 pi_disconnect(pf_current->pi);
946 next_request(0);
947}
948
949static int __init pf_init(void)
950{
951 struct pf_unit *pf;
952 int unit;
953
954 if (disable)
955 return -EINVAL;
956
957 pf_init_units();
958
959 if (pf_detect())
960 return -ENODEV;
961 pf_busy = 0;
962
963 if (register_blkdev(major, name)) {
964 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
965 put_disk(pf->disk);
966 return -EBUSY;
967 }
968 pf_queue = blk_init_queue(do_pf_request, &pf_spin_lock);
969 if (!pf_queue) {
970 unregister_blkdev(major, name);
971 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++)
972 put_disk(pf->disk);
973 return -ENOMEM;
974 }
975
976 blk_queue_max_segments(pf_queue, cluster);
977
978 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
979 struct gendisk *disk = pf->disk;
980
981 if (!pf->present)
982 continue;
983 disk->private_data = pf;
984 disk->queue = pf_queue;
985 add_disk(disk);
986 }
987 return 0;
988}
989
990static void __exit pf_exit(void)
991{
992 struct pf_unit *pf;
993 int unit;
994 unregister_blkdev(major, name);
995 for (pf = units, unit = 0; unit < PF_UNITS; pf++, unit++) {
996 if (!pf->present)
997 continue;
998 del_gendisk(pf->disk);
999 put_disk(pf->disk);
1000 pi_release(pf->pi);
1001 }
1002 blk_cleanup_queue(pf_queue);
1003}
1004
1005MODULE_LICENSE("GPL");
1006module_init(pf_init)
1007module_exit(pf_exit)
1008