Lines Matching refs:fs
209 #define swim3_err(fmt, arg...) dev_err(&fs->mdev->ofdev.dev, "[fd%d] " fmt, fs->index, arg)
210 #define swim3_warn(fmt, arg...) dev_warn(&fs->mdev->ofdev.dev, "[fd%d] " fmt, fs->index, arg)
211 #define swim3_info(fmt, arg...) dev_info(&fs->mdev->ofdev.dev, "[fd%d] " fmt, fs->index, arg)
214 #define swim3_dbg(fmt, arg...) dev_dbg(&fs->mdev->ofdev.dev, "[fd%d] " fmt, fs->index, arg)
237 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);
256 static bool swim3_end_request(struct floppy_state *fs, blk_status_t err, unsigned int nr_bytes)
258 struct request *req = fs->cur_req;
268 fs->cur_req = NULL;
272 static void swim3_select(struct floppy_state *fs, int sel)
274 struct swim3 __iomem *sw = fs->swim3;
284 static void swim3_action(struct floppy_state *fs, int action)
286 struct swim3 __iomem *sw = fs->swim3;
288 swim3_select(fs, action);
296 static int swim3_readbit(struct floppy_state *fs, int bit)
298 struct swim3 __iomem *sw = fs->swim3;
301 swim3_select(fs, bit);
310 struct floppy_state *fs = hctx->queue->queuedata;
315 if (fs->cur_req || fs->state != idle) {
320 fs->cur_req = req;
321 if (fs->mdev->media_bay &&
322 check_media_bay(fs->mdev->media_bay) != MB_FD) {
324 swim3_end_request(fs, BLK_STS_IOERR, 0);
327 if (fs->ejected) {
329 swim3_end_request(fs, BLK_STS_IOERR, 0);
333 if (fs->write_prot < 0)
334 fs->write_prot = swim3_readbit(fs, WRITE_PROT);
335 if (fs->write_prot) {
337 swim3_end_request(fs, BLK_STS_IOERR, 0);
347 fs->req_cyl = ((long)blk_rq_pos(req)) / fs->secpercyl;
348 x = ((long)blk_rq_pos(req)) % fs->secpercyl;
349 fs->head = x / fs->secpertrack;
350 fs->req_sector = x % fs->secpertrack + 1;
351 fs->state = do_transfer;
352 fs->retries = 0;
354 act(fs);
361 static void set_timeout(struct floppy_state *fs, int nticks,
364 if (fs->timeout_pending)
365 del_timer(&fs->timeout);
366 fs->timeout.expires = jiffies + nticks;
367 fs->timeout.function = proc;
368 add_timer(&fs->timeout);
369 fs->timeout_pending = 1;
372 static inline void scan_track(struct floppy_state *fs)
374 struct swim3 __iomem *sw = fs->swim3;
376 swim3_select(fs, READ_DATA_0);
382 set_timeout(fs, HZ, scan_timeout); /* enable timeout */
385 static inline void seek_track(struct floppy_state *fs, int n)
387 struct swim3 __iomem *sw = fs->swim3;
390 swim3_action(fs, SEEK_POSITIVE);
393 swim3_action(fs, SEEK_NEGATIVE);
396 fs->expect_cyl = (fs->cur_cyl >= 0)? fs->cur_cyl + n: -1;
397 swim3_select(fs, STEP);
402 set_timeout(fs, 3*HZ, seek_timeout); /* enable timeout */
403 fs->settle_time = 0;
431 static inline void setup_transfer(struct floppy_state *fs)
434 struct swim3 __iomem *sw = fs->swim3;
435 struct dbdma_cmd *cp = fs->dma_cmd;
436 struct dbdma_regs __iomem *dr = fs->dma;
437 struct request *req = fs->cur_req;
446 n = fs->secpertrack - fs->req_sector + 1;
452 fs->req_sector, fs->secpertrack, fs->head, n);
454 fs->scount = n;
455 swim3_select(fs, fs->head? READ_DATA_1: READ_DATA_0);
456 out_8(&sw->sector, fs->req_sector);
484 set_timeout(fs, 2*HZ, xfer_timeout); /* enable timeout */
487 static void act(struct floppy_state *fs)
491 fs->state, fs->req_cyl, fs->cur_cyl);
493 switch (fs->state) {
498 if (swim3_readbit(fs, TRACK_ZERO)) {
500 fs->cur_cyl = 0;
501 if (fs->req_cyl == 0)
502 fs->state = do_transfer;
504 fs->state = seeking;
507 scan_track(fs);
511 if (fs->cur_cyl < 0) {
512 fs->expect_cyl = -1;
513 fs->state = locating;
516 if (fs->req_cyl == fs->cur_cyl) {
518 fs->state = do_transfer;
521 seek_track(fs, fs->req_cyl - fs->cur_cyl);
526 fs->settle_time = (HZ + 32) / 33;
527 set_timeout(fs, fs->settle_time, settle_timeout);
531 if (fs->cur_cyl != fs->req_cyl) {
532 if (fs->retries > 5) {
534 fs->req_cyl, fs->cur_cyl);
535 swim3_end_request(fs, BLK_STS_IOERR, 0);
536 fs->state = idle;
539 fs->state = seeking;
542 setup_transfer(fs);
546 seek_track(fs, -5);
550 swim3_err("Unknown state %d\n", fs->state);
558 struct floppy_state *fs = from_timer(fs, t, timeout);
559 struct swim3 __iomem *sw = fs->swim3;
562 swim3_dbg("* scan timeout, state=%d\n", fs->state);
565 fs->timeout_pending = 0;
569 fs->cur_cyl = -1;
570 if (fs->retries > 5) {
571 swim3_end_request(fs, BLK_STS_IOERR, 0);
572 fs->state = idle;
574 fs->state = jogging;
575 act(fs);
582 struct floppy_state *fs = from_timer(fs, t, timeout);
583 struct swim3 __iomem *sw = fs->swim3;
586 swim3_dbg("* seek timeout, state=%d\n", fs->state);
589 fs->timeout_pending = 0;
594 swim3_end_request(fs, BLK_STS_IOERR, 0);
595 fs->state = idle;
601 struct floppy_state *fs = from_timer(fs, t, timeout);
602 struct swim3 __iomem *sw = fs->swim3;
605 swim3_dbg("* settle timeout, state=%d\n", fs->state);
608 fs->timeout_pending = 0;
609 if (swim3_readbit(fs, SEEK_COMPLETE)) {
611 fs->state = locating;
612 act(fs);
616 if (fs->settle_time < 2*HZ) {
617 ++fs->settle_time;
618 set_timeout(fs, 1, settle_timeout);
622 swim3_end_request(fs, BLK_STS_IOERR, 0);
623 fs->state = idle;
630 struct floppy_state *fs = from_timer(fs, t, timeout);
631 struct swim3 __iomem *sw = fs->swim3;
632 struct dbdma_regs __iomem *dr = fs->dma;
636 swim3_dbg("* xfer timeout, state=%d\n", fs->state);
639 fs->timeout_pending = 0;
648 (rq_data_dir(fs->cur_req)==WRITE? "writ": "read"),
649 (long)blk_rq_pos(fs->cur_req));
650 swim3_end_request(fs, BLK_STS_IOERR, 0);
651 fs->state = idle;
657 struct floppy_state *fs = (struct floppy_state *) dev_id;
658 struct swim3 __iomem *sw = fs->swim3;
664 struct request *req = fs->cur_req;
666 swim3_dbg("* interrupt, state=%d\n", fs->state);
671 if ((intr & ERROR_INTR) && fs->state != do_transfer)
673 fs->state, rq_data_dir(req), intr, err);
674 switch (fs->state) {
680 del_timer(&fs->timeout);
681 fs->timeout_pending = 0;
684 fs->cur_cyl = -1;
685 if (fs->retries > 5) {
686 swim3_end_request(fs, BLK_STS_IOERR, 0);
687 fs->state = idle;
689 fs->state = jogging;
690 act(fs);
694 fs->cur_cyl = sw->ctrack;
695 fs->cur_sector = sw->csect;
696 if (fs->expect_cyl != -1 && fs->expect_cyl != fs->cur_cyl)
698 fs->expect_cyl, fs->cur_cyl);
699 fs->state = do_transfer;
700 act(fs);
709 del_timer(&fs->timeout);
710 fs->timeout_pending = 0;
711 if (fs->state == seeking)
712 ++fs->retries;
713 fs->state = settling;
714 act(fs);
719 del_timer(&fs->timeout);
720 fs->timeout_pending = 0;
721 act(fs);
729 del_timer(&fs->timeout);
730 fs->timeout_pending = 0;
731 dr = fs->dma;
732 cp = fs->dma_cmd;
756 n = fs->scount - 1 - resid / 512;
759 fs->req_sector += n;
761 if (fs->retries < 5) {
762 ++fs->retries;
763 act(fs);
768 swim3_end_request(fs, BLK_STS_IOERR, 0);
769 fs->state = idle;
776 fs->state, rq_data_dir(req), intr, err);
777 swim3_end_request(fs, BLK_STS_IOERR, 0);
778 fs->state = idle;
781 fs->retries = 0;
782 if (swim3_end_request(fs, 0, fs->scount << 9)) {
783 fs->req_sector += fs->scount;
784 if (fs->req_sector > fs->secpertrack) {
785 fs->req_sector -= fs->secpertrack;
786 if (++fs->head > 1) {
787 fs->head = 0;
788 ++fs->req_cyl;
791 act(fs);
793 fs->state = idle;
797 swim3_err("Don't know what to do in state %d\n", fs->state);
810 static int grab_drive(struct floppy_state *fs, enum swim_state state,
818 if (fs->state != idle && fs->state != available) {
819 ++fs->wanted;
822 wait_event_lock_irq(fs->wait,
823 fs->state == available,
825 else if (wait_event_interruptible_lock_irq(fs->wait,
826 fs->state == available,
828 --fs->wanted;
832 --fs->wanted;
834 fs->state = state;
840 static void release_drive(struct floppy_state *fs)
842 struct request_queue *q = disks[fs->index]->queue;
848 fs->state = idle;
857 static int fd_eject(struct floppy_state *fs)
861 err = grab_drive(fs, ejecting, 1);
864 swim3_action(fs, EJECT);
870 swim3_select(fs, RELAX);
872 if (swim3_readbit(fs, DISK_IN) == 0)
875 swim3_select(fs, RELAX);
877 fs->ejected = 1;
878 release_drive(fs);
888 struct floppy_state *fs = bdev->bd_disk->private_data;
894 if (fs->mdev->media_bay &&
895 check_media_bay(fs->mdev->media_bay) != MB_FD)
900 if (fs->ref_count != 1)
902 err = fd_eject(fs);
927 struct floppy_state *fs = disk->private_data;
928 struct swim3 __iomem *sw = fs->swim3;
931 if (fs->ref_count == 0) {
932 if (fs->mdev->media_bay &&
933 check_media_bay(fs->mdev->media_bay) != MB_FD)
941 swim3_action(fs, MOTOR_ON);
942 fs->write_prot = -1;
943 fs->cur_cyl = -1;
945 if (n >= HZ/30 && swim3_readbit(fs, SEEK_COMPLETE))
951 swim3_select(fs, RELAX);
954 if (err == 0 && (swim3_readbit(fs, SEEK_COMPLETE) == 0
955 || swim3_readbit(fs, DISK_IN) == 0))
957 swim3_action(fs, SETMFM);
958 swim3_select(fs, RELAX);
960 } else if (fs->ref_count == -1 || mode & BLK_OPEN_EXCL)
967 if (fs->ejected)
972 if (fs->write_prot < 0)
973 fs->write_prot = swim3_readbit(fs, WRITE_PROT);
974 if (fs->write_prot)
979 if (fs->ref_count == 0) {
980 swim3_action(fs, MOTOR_OFF);
982 swim3_select(fs, RELAX);
988 fs->ref_count = -1;
990 ++fs->ref_count;
1008 struct floppy_state *fs = disk->private_data;
1009 struct swim3 __iomem *sw = fs->swim3;
1012 if (fs->ref_count > 0)
1013 --fs->ref_count;
1014 else if (fs->ref_count == -1)
1015 fs->ref_count = 0;
1016 if (fs->ref_count == 0) {
1017 swim3_action(fs, MOTOR_OFF);
1019 swim3_select(fs, RELAX);
1027 struct floppy_state *fs = disk->private_data;
1028 return fs->ejected ? DISK_EVENT_MEDIA_CHANGE : 0;
1033 struct floppy_state *fs = disk->private_data;
1037 if (fs->mdev->media_bay &&
1038 check_media_bay(fs->mdev->media_bay) != MB_FD)
1041 sw = fs->swim3;
1042 grab_drive(fs, revalidating, 0);
1045 swim3_action(fs, MOTOR_ON); /* necessary? */
1046 fs->write_prot = -1;
1047 fs->cur_cyl = -1;
1050 if (swim3_readbit(fs, SEEK_COMPLETE))
1054 swim3_select(fs, RELAX);
1057 ret = swim3_readbit(fs, SEEK_COMPLETE) == 0
1058 || swim3_readbit(fs, DISK_IN) == 0;
1060 swim3_action(fs, MOTOR_OFF);
1062 fs->ejected = 0;
1063 swim3_action(fs, SETMFM);
1065 swim3_select(fs, RELAX);
1067 release_drive(fs);
1084 struct floppy_state *fs = macio_get_drvdata(mdev);
1087 if (!fs)
1090 sw = fs->swim3;
1104 struct floppy_state *fs = &floppy_states[index];
1107 fs->mdev = mdev;
1108 fs->index = index;
1128 dev_set_drvdata(&mdev->ofdev.dev, fs);
1133 fs->state = idle;
1134 fs->swim3 = (struct swim3 __iomem *)
1136 if (fs->swim3 == NULL) {
1141 fs->dma = (struct dbdma_regs __iomem *)
1143 if (fs->dma == NULL) {
1145 iounmap(fs->swim3);
1149 fs->swim3_intr = macio_irq(mdev, 0);
1150 fs->dma_intr = macio_irq(mdev, 1);
1151 fs->cur_cyl = -1;
1152 fs->cur_sector = -1;
1153 fs->secpercyl = 36;
1154 fs->secpertrack = 18;
1155 fs->total_secs = 2880;
1156 init_waitqueue_head(&fs->wait);
1158 fs->dma_cmd = (struct dbdma_cmd *) DBDMA_ALIGN(fs->dbdma_cmd_space);
1159 memset(fs->dma_cmd, 0, 2 * sizeof(struct dbdma_cmd));
1160 fs->dma_cmd[1].command = cpu_to_le16(DBDMA_STOP);
1165 if (request_irq(fs->swim3_intr, swim3_interrupt, 0, "SWIM3", fs)) {
1171 timer_setup(&fs->timeout, NULL, 0);
1179 iounmap(fs->dma);
1180 iounmap(fs->swim3);
1192 struct floppy_state *fs;
1205 fs = &floppy_states[floppy_count];
1206 memset(fs, 0, sizeof(*fs));
1208 rc = blk_mq_alloc_sq_tag_set(&fs->tag_set, &swim3_mq_ops, 2,
1213 disk = blk_mq_alloc_disk(&fs->tag_set, NULL, fs);
1227 disk->private_data = fs;
1242 blk_mq_free_tag_set(&fs->tag_set);