Lines Matching refs:fs
208 #define swim3_err(fmt, arg...) dev_err(&fs->mdev->ofdev.dev, "[fd%d] " fmt, fs->index, arg)
209 #define swim3_warn(fmt, arg...) dev_warn(&fs->mdev->ofdev.dev, "[fd%d] " fmt, fs->index, arg)
210 #define swim3_info(fmt, arg...) dev_info(&fs->mdev->ofdev.dev, "[fd%d] " fmt, fs->index, arg)
213 #define swim3_dbg(fmt, arg...) dev_dbg(&fs->mdev->ofdev.dev, "[fd%d] " fmt, fs->index, arg)
236 static void seek_track(struct floppy_state *fs, int n);
238 static void act(struct floppy_state *fs);
245 static int grab_drive(struct floppy_state *fs, enum swim_state state,
247 static void release_drive(struct floppy_state *fs);
248 static int fd_eject(struct floppy_state *fs);
257 static bool swim3_end_request(struct floppy_state *fs, blk_status_t err, unsigned int nr_bytes)
259 struct request *req = fs->cur_req;
269 fs->cur_req = NULL;
273 static void swim3_select(struct floppy_state *fs, int sel)
275 struct swim3 __iomem *sw = fs->swim3;
285 static void swim3_action(struct floppy_state *fs, int action)
287 struct swim3 __iomem *sw = fs->swim3;
289 swim3_select(fs, action);
297 static int swim3_readbit(struct floppy_state *fs, int bit)
299 struct swim3 __iomem *sw = fs->swim3;
302 swim3_select(fs, bit);
311 struct floppy_state *fs = hctx->queue->queuedata;
316 if (fs->cur_req || fs->state != idle) {
321 fs->cur_req = req;
322 if (fs->mdev->media_bay &&
323 check_media_bay(fs->mdev->media_bay) != MB_FD) {
325 swim3_end_request(fs, BLK_STS_IOERR, 0);
328 if (fs->ejected) {
330 swim3_end_request(fs, BLK_STS_IOERR, 0);
334 if (fs->write_prot < 0)
335 fs->write_prot = swim3_readbit(fs, WRITE_PROT);
336 if (fs->write_prot) {
338 swim3_end_request(fs, BLK_STS_IOERR, 0);
348 fs->req_cyl = ((long)blk_rq_pos(req)) / fs->secpercyl;
349 x = ((long)blk_rq_pos(req)) % fs->secpercyl;
350 fs->head = x / fs->secpertrack;
351 fs->req_sector = x % fs->secpertrack + 1;
352 fs->state = do_transfer;
353 fs->retries = 0;
355 act(fs);
362 static void set_timeout(struct floppy_state *fs, int nticks,
365 if (fs->timeout_pending)
366 del_timer(&fs->timeout);
367 fs->timeout.expires = jiffies + nticks;
368 fs->timeout.function = proc;
369 add_timer(&fs->timeout);
370 fs->timeout_pending = 1;
373 static inline void scan_track(struct floppy_state *fs)
375 struct swim3 __iomem *sw = fs->swim3;
377 swim3_select(fs, READ_DATA_0);
383 set_timeout(fs, HZ, scan_timeout); /* enable timeout */
386 static inline void seek_track(struct floppy_state *fs, int n)
388 struct swim3 __iomem *sw = fs->swim3;
391 swim3_action(fs, SEEK_POSITIVE);
394 swim3_action(fs, SEEK_NEGATIVE);
397 fs->expect_cyl = (fs->cur_cyl >= 0)? fs->cur_cyl + n: -1;
398 swim3_select(fs, STEP);
403 set_timeout(fs, 3*HZ, seek_timeout); /* enable timeout */
404 fs->settle_time = 0;
416 static inline void setup_transfer(struct floppy_state *fs)
419 struct swim3 __iomem *sw = fs->swim3;
420 struct dbdma_cmd *cp = fs->dma_cmd;
421 struct dbdma_regs __iomem *dr = fs->dma;
422 struct request *req = fs->cur_req;
431 n = fs->secpertrack - fs->req_sector + 1;
437 fs->req_sector, fs->secpertrack, fs->head, n);
439 fs->scount = n;
440 swim3_select(fs, fs->head? READ_DATA_1: READ_DATA_0);
441 out_8(&sw->sector, fs->req_sector);
467 set_timeout(fs, 2*HZ, xfer_timeout); /* enable timeout */
470 static void act(struct floppy_state *fs)
474 fs->state, fs->req_cyl, fs->cur_cyl);
476 switch (fs->state) {
481 if (swim3_readbit(fs, TRACK_ZERO)) {
483 fs->cur_cyl = 0;
484 if (fs->req_cyl == 0)
485 fs->state = do_transfer;
487 fs->state = seeking;
490 scan_track(fs);
494 if (fs->cur_cyl < 0) {
495 fs->expect_cyl = -1;
496 fs->state = locating;
499 if (fs->req_cyl == fs->cur_cyl) {
501 fs->state = do_transfer;
504 seek_track(fs, fs->req_cyl - fs->cur_cyl);
509 fs->settle_time = (HZ + 32) / 33;
510 set_timeout(fs, fs->settle_time, settle_timeout);
514 if (fs->cur_cyl != fs->req_cyl) {
515 if (fs->retries > 5) {
517 fs->req_cyl, fs->cur_cyl);
518 swim3_end_request(fs, BLK_STS_IOERR, 0);
519 fs->state = idle;
522 fs->state = seeking;
525 setup_transfer(fs);
529 seek_track(fs, -5);
533 swim3_err("Unknown state %d\n", fs->state);
541 struct floppy_state *fs = from_timer(fs, t, timeout);
542 struct swim3 __iomem *sw = fs->swim3;
545 swim3_dbg("* scan timeout, state=%d\n", fs->state);
548 fs->timeout_pending = 0;
552 fs->cur_cyl = -1;
553 if (fs->retries > 5) {
554 swim3_end_request(fs, BLK_STS_IOERR, 0);
555 fs->state = idle;
557 fs->state = jogging;
558 act(fs);
565 struct floppy_state *fs = from_timer(fs, t, timeout);
566 struct swim3 __iomem *sw = fs->swim3;
569 swim3_dbg("* seek timeout, state=%d\n", fs->state);
572 fs->timeout_pending = 0;
577 swim3_end_request(fs, BLK_STS_IOERR, 0);
578 fs->state = idle;
584 struct floppy_state *fs = from_timer(fs, t, timeout);
585 struct swim3 __iomem *sw = fs->swim3;
588 swim3_dbg("* settle timeout, state=%d\n", fs->state);
591 fs->timeout_pending = 0;
592 if (swim3_readbit(fs, SEEK_COMPLETE)) {
594 fs->state = locating;
595 act(fs);
599 if (fs->settle_time < 2*HZ) {
600 ++fs->settle_time;
601 set_timeout(fs, 1, settle_timeout);
605 swim3_end_request(fs, BLK_STS_IOERR, 0);
606 fs->state = idle;
613 struct floppy_state *fs = from_timer(fs, t, timeout);
614 struct swim3 __iomem *sw = fs->swim3;
615 struct dbdma_regs __iomem *dr = fs->dma;
619 swim3_dbg("* xfer timeout, state=%d\n", fs->state);
622 fs->timeout_pending = 0;
631 (rq_data_dir(fs->cur_req)==WRITE? "writ": "read"),
632 (long)blk_rq_pos(fs->cur_req));
633 swim3_end_request(fs, BLK_STS_IOERR, 0);
634 fs->state = idle;
640 struct floppy_state *fs = (struct floppy_state *) dev_id;
641 struct swim3 __iomem *sw = fs->swim3;
647 struct request *req = fs->cur_req;
649 swim3_dbg("* interrupt, state=%d\n", fs->state);
654 if ((intr & ERROR_INTR) && fs->state != do_transfer)
656 fs->state, rq_data_dir(req), intr, err);
657 switch (fs->state) {
663 del_timer(&fs->timeout);
664 fs->timeout_pending = 0;
667 fs->cur_cyl = -1;
668 if (fs->retries > 5) {
669 swim3_end_request(fs, BLK_STS_IOERR, 0);
670 fs->state = idle;
672 fs->state = jogging;
673 act(fs);
677 fs->cur_cyl = sw->ctrack;
678 fs->cur_sector = sw->csect;
679 if (fs->expect_cyl != -1 && fs->expect_cyl != fs->cur_cyl)
681 fs->expect_cyl, fs->cur_cyl);
682 fs->state = do_transfer;
683 act(fs);
692 del_timer(&fs->timeout);
693 fs->timeout_pending = 0;
694 if (fs->state == seeking)
695 ++fs->retries;
696 fs->state = settling;
697 act(fs);
702 del_timer(&fs->timeout);
703 fs->timeout_pending = 0;
704 act(fs);
712 del_timer(&fs->timeout);
713 fs->timeout_pending = 0;
714 dr = fs->dma;
715 cp = fs->dma_cmd;
739 n = fs->scount - 1 - resid / 512;
742 fs->req_sector += n;
744 if (fs->retries < 5) {
745 ++fs->retries;
746 act(fs);
751 swim3_end_request(fs, BLK_STS_IOERR, 0);
752 fs->state = idle;
759 fs->state, rq_data_dir(req), intr, err);
760 swim3_end_request(fs, BLK_STS_IOERR, 0);
761 fs->state = idle;
764 fs->retries = 0;
765 if (swim3_end_request(fs, 0, fs->scount << 9)) {
766 fs->req_sector += fs->scount;
767 if (fs->req_sector > fs->secpertrack) {
768 fs->req_sector -= fs->secpertrack;
769 if (++fs->head > 1) {
770 fs->head = 0;
771 ++fs->req_cyl;
774 act(fs);
776 fs->state = idle;
780 swim3_err("Don't know what to do in state %d\n", fs->state);
793 static int grab_drive(struct floppy_state *fs, enum swim_state state,
801 if (fs->state != idle && fs->state != available) {
802 ++fs->wanted;
805 wait_event_lock_irq(fs->wait,
806 fs->state == available,
808 else if (wait_event_interruptible_lock_irq(fs->wait,
809 fs->state == available,
811 --fs->wanted;
815 --fs->wanted;
817 fs->state = state;
823 static void release_drive(struct floppy_state *fs)
825 struct request_queue *q = disks[fs->index]->queue;
831 fs->state = idle;
840 static int fd_eject(struct floppy_state *fs)
844 err = grab_drive(fs, ejecting, 1);
847 swim3_action(fs, EJECT);
853 swim3_select(fs, RELAX);
855 if (swim3_readbit(fs, DISK_IN) == 0)
858 swim3_select(fs, RELAX);
860 fs->ejected = 1;
861 release_drive(fs);
871 struct floppy_state *fs = bdev->bd_disk->private_data;
877 if (fs->mdev->media_bay &&
878 check_media_bay(fs->mdev->media_bay) != MB_FD)
883 if (fs->ref_count != 1)
885 err = fd_eject(fs);
910 struct floppy_state *fs = bdev->bd_disk->private_data;
911 struct swim3 __iomem *sw = fs->swim3;
914 if (fs->ref_count == 0) {
915 if (fs->mdev->media_bay &&
916 check_media_bay(fs->mdev->media_bay) != MB_FD)
924 swim3_action(fs, MOTOR_ON);
925 fs->write_prot = -1;
926 fs->cur_cyl = -1;
928 if (n >= HZ/30 && swim3_readbit(fs, SEEK_COMPLETE))
934 swim3_select(fs, RELAX);
937 if (err == 0 && (swim3_readbit(fs, SEEK_COMPLETE) == 0
938 || swim3_readbit(fs, DISK_IN) == 0))
940 swim3_action(fs, SETMFM);
941 swim3_select(fs, RELAX);
943 } else if (fs->ref_count == -1 || mode & FMODE_EXCL)
950 if (fs->ejected)
955 if (fs->write_prot < 0)
956 fs->write_prot = swim3_readbit(fs, WRITE_PROT);
957 if (fs->write_prot)
962 if (fs->ref_count == 0) {
963 swim3_action(fs, MOTOR_OFF);
965 swim3_select(fs, RELAX);
971 fs->ref_count = -1;
973 ++fs->ref_count;
991 struct floppy_state *fs = disk->private_data;
992 struct swim3 __iomem *sw = fs->swim3;
995 if (fs->ref_count > 0)
996 --fs->ref_count;
997 else if (fs->ref_count == -1)
998 fs->ref_count = 0;
999 if (fs->ref_count == 0) {
1000 swim3_action(fs, MOTOR_OFF);
1002 swim3_select(fs, RELAX);
1010 struct floppy_state *fs = disk->private_data;
1011 return fs->ejected ? DISK_EVENT_MEDIA_CHANGE : 0;
1016 struct floppy_state *fs = disk->private_data;
1020 if (fs->mdev->media_bay &&
1021 check_media_bay(fs->mdev->media_bay) != MB_FD)
1024 sw = fs->swim3;
1025 grab_drive(fs, revalidating, 0);
1028 swim3_action(fs, MOTOR_ON); /* necessary? */
1029 fs->write_prot = -1;
1030 fs->cur_cyl = -1;
1033 if (swim3_readbit(fs, SEEK_COMPLETE))
1037 swim3_select(fs, RELAX);
1040 ret = swim3_readbit(fs, SEEK_COMPLETE) == 0
1041 || swim3_readbit(fs, DISK_IN) == 0;
1043 swim3_action(fs, MOTOR_OFF);
1045 fs->ejected = 0;
1046 swim3_action(fs, SETMFM);
1048 swim3_select(fs, RELAX);
1050 release_drive(fs);
1067 struct floppy_state *fs = macio_get_drvdata(mdev);
1070 if (!fs)
1073 sw = fs->swim3;
1087 struct floppy_state *fs = &floppy_states[index];
1090 fs->mdev = mdev;
1091 fs->index = index;
1111 dev_set_drvdata(&mdev->ofdev.dev, fs);
1116 fs->state = idle;
1117 fs->swim3 = (struct swim3 __iomem *)
1119 if (fs->swim3 == NULL) {
1124 fs->dma = (struct dbdma_regs __iomem *)
1126 if (fs->dma == NULL) {
1128 iounmap(fs->swim3);
1132 fs->swim3_intr = macio_irq(mdev, 0);
1133 fs->dma_intr = macio_irq(mdev, 1);
1134 fs->cur_cyl = -1;
1135 fs->cur_sector = -1;
1136 fs->secpercyl = 36;
1137 fs->secpertrack = 18;
1138 fs->total_secs = 2880;
1139 init_waitqueue_head(&fs->wait);
1141 fs->dma_cmd = (struct dbdma_cmd *) DBDMA_ALIGN(fs->dbdma_cmd_space);
1142 memset(fs->dma_cmd, 0, 2 * sizeof(struct dbdma_cmd));
1143 fs->dma_cmd[1].command = cpu_to_le16(DBDMA_STOP);
1148 if (request_irq(fs->swim3_intr, swim3_interrupt, 0, "SWIM3", fs)) {
1154 timer_setup(&fs->timeout, NULL, 0);
1162 iounmap(fs->dma);
1163 iounmap(fs->swim3);
1175 struct floppy_state *fs;
1194 fs = &floppy_states[floppy_count];
1195 memset(fs, 0, sizeof(*fs));
1197 disk->queue = blk_mq_init_sq_queue(&fs->tag_set, &swim3_mq_ops, 2,
1205 disk->queue->queuedata = fs;
1214 disk->private_data = fs;
1227 blk_mq_free_tag_set(&fs->tag_set);