1 /* 2 * Driver for SWIM (Sander Woz Integrated Machine) floppy controller 3 * 4 * Copyright (C) 2004,2008 Laurent Vivier <Laurent@lvivier.info> 5 * 6 * based on Alastair Bridgewater SWIM analysis, 2001 7 * based on SWIM3 driver (c) Paul Mackerras, 1996 8 * based on netBSD IWM driver (c) 1997, 1998 Hauke Fath. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * as published by the Free Software Foundation; either version 13 * 2 of the License, or (at your option) any later version. 14 * 15 * 2004-08-21 (lv) - Initial implementation 16 * 2008-10-30 (lv) - Port to 2.6 17 */ 18 19 #include <linux/module.h> 20 #include <linux/fd.h> 21 #include <linux/slab.h> 22 #include <linux/blk-mq.h> 23 #include <linux/mutex.h> 24 #include <linux/hdreg.h> 25 #include <linux/kernel.h> 26 #include <linux/delay.h> 27 #include <linux/platform_device.h> 28 29 #include <asm/mac_via.h> 30 31 #define CARDNAME "swim" 32 33 struct sector_header { 34 unsigned char side; 35 unsigned char track; 36 unsigned char sector; 37 unsigned char size; 38 unsigned char crc0; 39 unsigned char crc1; 40 } __attribute__((packed)); 41 42 #define DRIVER_VERSION "Version 0.2 (2008-10-30)" 43 44 #define REG(x) unsigned char x, x ## _pad[0x200 - 1]; 45 46 struct swim { 47 REG(write_data) 48 REG(write_mark) 49 REG(write_CRC) 50 REG(write_parameter) 51 REG(write_phase) 52 REG(write_setup) 53 REG(write_mode0) 54 REG(write_mode1) 55 56 REG(read_data) 57 REG(read_mark) 58 REG(read_error) 59 REG(read_parameter) 60 REG(read_phase) 61 REG(read_setup) 62 REG(read_status) 63 REG(read_handshake) 64 } __attribute__((packed)); 65 66 #define swim_write(base, reg, v) out_8(&(base)->write_##reg, (v)) 67 #define swim_read(base, reg) in_8(&(base)->read_##reg) 68 69 /* IWM registers */ 70 71 struct iwm { 72 REG(ph0L) 73 REG(ph0H) 74 REG(ph1L) 75 REG(ph1H) 76 REG(ph2L) 77 REG(ph2H) 78 REG(ph3L) 79 REG(ph3H) 80 REG(mtrOff) 81 REG(mtrOn) 82 REG(intDrive) 83 REG(extDrive) 84 REG(q6L) 85 REG(q6H) 86 REG(q7L) 87 REG(q7H) 88 } __attribute__((packed)); 89 90 #define iwm_write(base, reg, v) out_8(&(base)->reg, (v)) 91 #define iwm_read(base, reg) in_8(&(base)->reg) 92 93 /* bits in phase register */ 94 95 #define SEEK_POSITIVE 0x070 96 #define SEEK_NEGATIVE 0x074 97 #define STEP 0x071 98 #define MOTOR_ON 0x072 99 #define MOTOR_OFF 0x076 100 #define INDEX 0x073 101 #define EJECT 0x077 102 #define SETMFM 0x171 103 #define SETGCR 0x175 104 105 #define RELAX 0x033 106 #define LSTRB 0x008 107 108 #define CA_MASK 0x077 109 110 /* Select values for swim_select and swim_readbit */ 111 112 #define READ_DATA_0 0x074 113 #define ONEMEG_DRIVE 0x075 114 #define SINGLE_SIDED 0x076 115 #define DRIVE_PRESENT 0x077 116 #define DISK_IN 0x170 117 #define WRITE_PROT 0x171 118 #define TRACK_ZERO 0x172 119 #define TACHO 0x173 120 #define READ_DATA_1 0x174 121 #define GCR_MODE 0x175 122 #define SEEK_COMPLETE 0x176 123 #define TWOMEG_MEDIA 0x177 124 125 /* Bits in handshake register */ 126 127 #define MARK_BYTE 0x01 128 #define CRC_ZERO 0x02 129 #define RDDATA 0x04 130 #define SENSE 0x08 131 #define MOTEN 0x10 132 #define ERROR 0x20 133 #define DAT2BYTE 0x40 134 #define DAT1BYTE 0x80 135 136 /* bits in setup register */ 137 138 #define S_INV_WDATA 0x01 139 #define S_3_5_SELECT 0x02 140 #define S_GCR 0x04 141 #define S_FCLK_DIV2 0x08 142 #define S_ERROR_CORR 0x10 143 #define S_IBM_DRIVE 0x20 144 #define S_GCR_WRITE 0x40 145 #define S_TIMEOUT 0x80 146 147 /* bits in mode register */ 148 149 #define CLFIFO 0x01 150 #define ENBL1 0x02 151 #define ENBL2 0x04 152 #define ACTION 0x08 153 #define WRITE_MODE 0x10 154 #define HEDSEL 0x20 155 #define MOTON 0x80 156 157 /*----------------------------------------------------------------------------*/ 158 159 enum drive_location { 160 INTERNAL_DRIVE = 0x02, 161 EXTERNAL_DRIVE = 0x04, 162 }; 163 164 enum media_type { 165 DD_MEDIA, 166 HD_MEDIA, 167 }; 168 169 struct floppy_state { 170 171 /* physical properties */ 172 173 enum drive_location location; /* internal or external drive */ 174 int head_number; /* single- or double-sided drive */ 175 176 /* media */ 177 178 int disk_in; 179 int ejected; 180 enum media_type type; 181 int write_protected; 182 183 int total_secs; 184 int secpercyl; 185 int secpertrack; 186 187 /* in-use information */ 188 189 int track; 190 int ref_count; 191 192 struct gendisk *disk; 193 struct blk_mq_tag_set tag_set; 194 195 /* parent controller */ 196 197 struct swim_priv *swd; 198 }; 199 200 enum motor_action { 201 OFF, 202 ON, 203 }; 204 205 enum head { 206 LOWER_HEAD = 0, 207 UPPER_HEAD = 1, 208 }; 209 210 #define FD_MAX_UNIT 2 211 212 struct swim_priv { 213 struct swim __iomem *base; 214 spinlock_t lock; 215 int floppy_count; 216 struct floppy_state unit[FD_MAX_UNIT]; 217 }; 218 219 extern int swim_read_sector_header(struct swim __iomem *base, 220 struct sector_header *header); 221 extern int swim_read_sector_data(struct swim __iomem *base, 222 unsigned char *data); 223 224 static DEFINE_MUTEX(swim_mutex); 225 static inline void set_swim_mode(struct swim __iomem *base, int enable) 226 { 227 struct iwm __iomem *iwm_base; 228 unsigned long flags; 229 230 if (!enable) { 231 swim_write(base, mode0, 0xf8); 232 return; 233 } 234 235 iwm_base = (struct iwm __iomem *)base; 236 local_irq_save(flags); 237 238 iwm_read(iwm_base, q7L); 239 iwm_read(iwm_base, mtrOff); 240 iwm_read(iwm_base, q6H); 241 242 iwm_write(iwm_base, q7H, 0x57); 243 iwm_write(iwm_base, q7H, 0x17); 244 iwm_write(iwm_base, q7H, 0x57); 245 iwm_write(iwm_base, q7H, 0x57); 246 247 local_irq_restore(flags); 248 } 249 250 static inline int get_swim_mode(struct swim __iomem *base) 251 { 252 unsigned long flags; 253 254 local_irq_save(flags); 255 256 swim_write(base, phase, 0xf5); 257 if (swim_read(base, phase) != 0xf5) 258 goto is_iwm; 259 swim_write(base, phase, 0xf6); 260 if (swim_read(base, phase) != 0xf6) 261 goto is_iwm; 262 swim_write(base, phase, 0xf7); 263 if (swim_read(base, phase) != 0xf7) 264 goto is_iwm; 265 local_irq_restore(flags); 266 return 1; 267 is_iwm: 268 local_irq_restore(flags); 269 return 0; 270 } 271 272 static inline void swim_select(struct swim __iomem *base, int sel) 273 { 274 swim_write(base, phase, RELAX); 275 276 via1_set_head(sel & 0x100); 277 278 swim_write(base, phase, sel & CA_MASK); 279 } 280 281 static inline void swim_action(struct swim __iomem *base, int action) 282 { 283 unsigned long flags; 284 285 local_irq_save(flags); 286 287 swim_select(base, action); 288 udelay(1); 289 swim_write(base, phase, (LSTRB<<4) | LSTRB); 290 udelay(1); 291 swim_write(base, phase, (LSTRB<<4) | ((~LSTRB) & 0x0F)); 292 udelay(1); 293 294 local_irq_restore(flags); 295 } 296 297 static inline int swim_readbit(struct swim __iomem *base, int bit) 298 { 299 int stat; 300 301 swim_select(base, bit); 302 303 udelay(10); 304 305 stat = swim_read(base, handshake); 306 307 return (stat & SENSE) == 0; 308 } 309 310 static inline void swim_drive(struct swim __iomem *base, 311 enum drive_location location) 312 { 313 if (location == INTERNAL_DRIVE) { 314 swim_write(base, mode0, EXTERNAL_DRIVE); /* clear drive 1 bit */ 315 swim_write(base, mode1, INTERNAL_DRIVE); /* set drive 0 bit */ 316 } else if (location == EXTERNAL_DRIVE) { 317 swim_write(base, mode0, INTERNAL_DRIVE); /* clear drive 0 bit */ 318 swim_write(base, mode1, EXTERNAL_DRIVE); /* set drive 1 bit */ 319 } 320 } 321 322 static inline void swim_motor(struct swim __iomem *base, 323 enum motor_action action) 324 { 325 if (action == ON) { 326 int i; 327 328 swim_action(base, MOTOR_ON); 329 330 for (i = 0; i < 2*HZ; i++) { 331 swim_select(base, RELAX); 332 if (swim_readbit(base, MOTOR_ON)) 333 break; 334 current->state = TASK_INTERRUPTIBLE; 335 schedule_timeout(1); 336 } 337 } else if (action == OFF) { 338 swim_action(base, MOTOR_OFF); 339 swim_select(base, RELAX); 340 } 341 } 342 343 static inline void swim_eject(struct swim __iomem *base) 344 { 345 int i; 346 347 swim_action(base, EJECT); 348 349 for (i = 0; i < 2*HZ; i++) { 350 swim_select(base, RELAX); 351 if (!swim_readbit(base, DISK_IN)) 352 break; 353 current->state = TASK_INTERRUPTIBLE; 354 schedule_timeout(1); 355 } 356 swim_select(base, RELAX); 357 } 358 359 static inline void swim_head(struct swim __iomem *base, enum head head) 360 { 361 /* wait drive is ready */ 362 363 if (head == UPPER_HEAD) 364 swim_select(base, READ_DATA_1); 365 else if (head == LOWER_HEAD) 366 swim_select(base, READ_DATA_0); 367 } 368 369 static inline int swim_step(struct swim __iomem *base) 370 { 371 int wait; 372 373 swim_action(base, STEP); 374 375 for (wait = 0; wait < HZ; wait++) { 376 377 current->state = TASK_INTERRUPTIBLE; 378 schedule_timeout(1); 379 380 swim_select(base, RELAX); 381 if (!swim_readbit(base, STEP)) 382 return 0; 383 } 384 return -1; 385 } 386 387 static inline int swim_track00(struct swim __iomem *base) 388 { 389 int try; 390 391 swim_action(base, SEEK_NEGATIVE); 392 393 for (try = 0; try < 100; try++) { 394 395 swim_select(base, RELAX); 396 if (swim_readbit(base, TRACK_ZERO)) 397 break; 398 399 if (swim_step(base)) 400 return -1; 401 } 402 403 if (swim_readbit(base, TRACK_ZERO)) 404 return 0; 405 406 return -1; 407 } 408 409 static inline int swim_seek(struct swim __iomem *base, int step) 410 { 411 if (step == 0) 412 return 0; 413 414 if (step < 0) { 415 swim_action(base, SEEK_NEGATIVE); 416 step = -step; 417 } else 418 swim_action(base, SEEK_POSITIVE); 419 420 for ( ; step > 0; step--) { 421 if (swim_step(base)) 422 return -1; 423 } 424 425 return 0; 426 } 427 428 static inline int swim_track(struct floppy_state *fs, int track) 429 { 430 struct swim __iomem *base = fs->swd->base; 431 int ret; 432 433 ret = swim_seek(base, track - fs->track); 434 435 if (ret == 0) 436 fs->track = track; 437 else { 438 swim_track00(base); 439 fs->track = 0; 440 } 441 442 return ret; 443 } 444 445 static int floppy_eject(struct floppy_state *fs) 446 { 447 struct swim __iomem *base = fs->swd->base; 448 449 swim_drive(base, fs->location); 450 swim_motor(base, OFF); 451 swim_eject(base); 452 453 fs->disk_in = 0; 454 fs->ejected = 1; 455 456 return 0; 457 } 458 459 static inline int swim_read_sector(struct floppy_state *fs, 460 int side, int track, 461 int sector, unsigned char *buffer) 462 { 463 struct swim __iomem *base = fs->swd->base; 464 unsigned long flags; 465 struct sector_header header; 466 int ret = -1; 467 short i; 468 469 swim_track(fs, track); 470 471 swim_write(base, mode1, MOTON); 472 swim_head(base, side); 473 swim_write(base, mode0, side); 474 475 local_irq_save(flags); 476 for (i = 0; i < 36; i++) { 477 ret = swim_read_sector_header(base, &header); 478 if (!ret && (header.sector == sector)) { 479 /* found */ 480 481 ret = swim_read_sector_data(base, buffer); 482 break; 483 } 484 } 485 local_irq_restore(flags); 486 487 swim_write(base, mode0, MOTON); 488 489 if ((header.side != side) || (header.track != track) || 490 (header.sector != sector)) 491 return 0; 492 493 return ret; 494 } 495 496 static blk_status_t floppy_read_sectors(struct floppy_state *fs, 497 int req_sector, int sectors_nb, 498 unsigned char *buffer) 499 { 500 struct swim __iomem *base = fs->swd->base; 501 int ret; 502 int side, track, sector; 503 int i, try; 504 505 506 swim_drive(base, fs->location); 507 for (i = req_sector; i < req_sector + sectors_nb; i++) { 508 int x; 509 track = i / fs->secpercyl; 510 x = i % fs->secpercyl; 511 side = x / fs->secpertrack; 512 sector = x % fs->secpertrack + 1; 513 514 try = 5; 515 do { 516 ret = swim_read_sector(fs, side, track, sector, 517 buffer); 518 if (try-- == 0) 519 return BLK_STS_IOERR; 520 } while (ret != 512); 521 522 buffer += ret; 523 } 524 525 return 0; 526 } 527 528 static blk_status_t swim_queue_rq(struct blk_mq_hw_ctx *hctx, 529 const struct blk_mq_queue_data *bd) 530 { 531 struct floppy_state *fs = hctx->queue->queuedata; 532 struct swim_priv *swd = fs->swd; 533 struct request *req = bd->rq; 534 blk_status_t err; 535 536 if (!spin_trylock_irq(&swd->lock)) 537 return BLK_STS_DEV_RESOURCE; 538 539 blk_mq_start_request(req); 540 541 if (!fs->disk_in || rq_data_dir(req) == WRITE) { 542 err = BLK_STS_IOERR; 543 goto out; 544 } 545 546 do { 547 err = floppy_read_sectors(fs, blk_rq_pos(req), 548 blk_rq_cur_sectors(req), 549 bio_data(req->bio)); 550 } while (blk_update_request(req, err, blk_rq_cur_bytes(req))); 551 __blk_mq_end_request(req, err); 552 553 err = BLK_STS_OK; 554 out: 555 spin_unlock_irq(&swd->lock); 556 return err; 557 558 } 559 560 static struct floppy_struct floppy_type[4] = { 561 { 0, 0, 0, 0, 0, 0x00, 0x00, 0x00, 0x00, NULL }, /* no testing */ 562 { 720, 9, 1, 80, 0, 0x2A, 0x02, 0xDF, 0x50, NULL }, /* 360KB SS 3.5"*/ 563 { 1440, 9, 2, 80, 0, 0x2A, 0x02, 0xDF, 0x50, NULL }, /* 720KB 3.5" */ 564 { 2880, 18, 2, 80, 0, 0x1B, 0x00, 0xCF, 0x6C, NULL }, /* 1.44MB 3.5" */ 565 }; 566 567 static int get_floppy_geometry(struct floppy_state *fs, int type, 568 struct floppy_struct **g) 569 { 570 if (type >= ARRAY_SIZE(floppy_type)) 571 return -EINVAL; 572 573 if (type) 574 *g = &floppy_type[type]; 575 else if (fs->type == HD_MEDIA) /* High-Density media */ 576 *g = &floppy_type[3]; 577 else if (fs->head_number == 2) /* double-sided */ 578 *g = &floppy_type[2]; 579 else 580 *g = &floppy_type[1]; 581 582 return 0; 583 } 584 585 static void setup_medium(struct floppy_state *fs) 586 { 587 struct swim __iomem *base = fs->swd->base; 588 589 if (swim_readbit(base, DISK_IN)) { 590 struct floppy_struct *g; 591 fs->disk_in = 1; 592 fs->write_protected = swim_readbit(base, WRITE_PROT); 593 594 if (swim_track00(base)) 595 printk(KERN_ERR 596 "SWIM: cannot move floppy head to track 0\n"); 597 598 swim_track00(base); 599 600 fs->type = swim_readbit(base, TWOMEG_MEDIA) ? 601 HD_MEDIA : DD_MEDIA; 602 fs->head_number = swim_readbit(base, SINGLE_SIDED) ? 1 : 2; 603 get_floppy_geometry(fs, 0, &g); 604 fs->total_secs = g->size; 605 fs->secpercyl = g->head * g->sect; 606 fs->secpertrack = g->sect; 607 fs->track = 0; 608 } else { 609 fs->disk_in = 0; 610 } 611 } 612 613 static int floppy_open(struct block_device *bdev, fmode_t mode) 614 { 615 struct floppy_state *fs = bdev->bd_disk->private_data; 616 struct swim __iomem *base = fs->swd->base; 617 int err; 618 619 if (fs->ref_count == -1 || (fs->ref_count && mode & FMODE_EXCL)) 620 return -EBUSY; 621 622 if (mode & FMODE_EXCL) 623 fs->ref_count = -1; 624 else 625 fs->ref_count++; 626 627 swim_write(base, setup, S_IBM_DRIVE | S_FCLK_DIV2); 628 udelay(10); 629 swim_drive(base, fs->location); 630 swim_motor(base, ON); 631 swim_action(base, SETMFM); 632 if (fs->ejected) 633 setup_medium(fs); 634 if (!fs->disk_in) { 635 err = -ENXIO; 636 goto out; 637 } 638 639 set_capacity(fs->disk, fs->total_secs); 640 641 if (mode & FMODE_NDELAY) 642 return 0; 643 644 if (mode & (FMODE_READ|FMODE_WRITE)) { 645 check_disk_change(bdev); 646 if ((mode & FMODE_WRITE) && fs->write_protected) { 647 err = -EROFS; 648 goto out; 649 } 650 } 651 return 0; 652 out: 653 if (fs->ref_count < 0) 654 fs->ref_count = 0; 655 else if (fs->ref_count > 0) 656 --fs->ref_count; 657 658 if (fs->ref_count == 0) 659 swim_motor(base, OFF); 660 return err; 661 } 662 663 static int floppy_unlocked_open(struct block_device *bdev, fmode_t mode) 664 { 665 int ret; 666 667 mutex_lock(&swim_mutex); 668 ret = floppy_open(bdev, mode); 669 mutex_unlock(&swim_mutex); 670 671 return ret; 672 } 673 674 static void floppy_release(struct gendisk *disk, fmode_t mode) 675 { 676 struct floppy_state *fs = disk->private_data; 677 struct swim __iomem *base = fs->swd->base; 678 679 mutex_lock(&swim_mutex); 680 if (fs->ref_count < 0) 681 fs->ref_count = 0; 682 else if (fs->ref_count > 0) 683 --fs->ref_count; 684 685 if (fs->ref_count == 0) 686 swim_motor(base, OFF); 687 mutex_unlock(&swim_mutex); 688 } 689 690 static int floppy_ioctl(struct block_device *bdev, fmode_t mode, 691 unsigned int cmd, unsigned long param) 692 { 693 struct floppy_state *fs = bdev->bd_disk->private_data; 694 int err; 695 696 if ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)) 697 return -EPERM; 698 699 switch (cmd) { 700 case FDEJECT: 701 if (fs->ref_count != 1) 702 return -EBUSY; 703 mutex_lock(&swim_mutex); 704 err = floppy_eject(fs); 705 mutex_unlock(&swim_mutex); 706 return err; 707 708 case FDGETPRM: 709 if (copy_to_user((void __user *) param, (void *) &floppy_type, 710 sizeof(struct floppy_struct))) 711 return -EFAULT; 712 return 0; 713 } 714 return -ENOTTY; 715 } 716 717 static int floppy_getgeo(struct block_device *bdev, struct hd_geometry *geo) 718 { 719 struct floppy_state *fs = bdev->bd_disk->private_data; 720 struct floppy_struct *g; 721 int ret; 722 723 ret = get_floppy_geometry(fs, 0, &g); 724 if (ret) 725 return ret; 726 727 geo->heads = g->head; 728 geo->sectors = g->sect; 729 geo->cylinders = g->track; 730 731 return 0; 732 } 733 734 static unsigned int floppy_check_events(struct gendisk *disk, 735 unsigned int clearing) 736 { 737 struct floppy_state *fs = disk->private_data; 738 739 return fs->ejected ? DISK_EVENT_MEDIA_CHANGE : 0; 740 } 741 742 static int floppy_revalidate(struct gendisk *disk) 743 { 744 struct floppy_state *fs = disk->private_data; 745 struct swim __iomem *base = fs->swd->base; 746 747 swim_drive(base, fs->location); 748 749 if (fs->ejected) 750 setup_medium(fs); 751 752 if (!fs->disk_in) 753 swim_motor(base, OFF); 754 else 755 fs->ejected = 0; 756 757 return !fs->disk_in; 758 } 759 760 static const struct block_device_operations floppy_fops = { 761 .owner = THIS_MODULE, 762 .open = floppy_unlocked_open, 763 .release = floppy_release, 764 .ioctl = floppy_ioctl, 765 .getgeo = floppy_getgeo, 766 .check_events = floppy_check_events, 767 .revalidate_disk = floppy_revalidate, 768 }; 769 770 static struct kobject *floppy_find(dev_t dev, int *part, void *data) 771 { 772 struct swim_priv *swd = data; 773 int drive = (*part & 3); 774 775 if (drive >= swd->floppy_count) 776 return NULL; 777 778 *part = 0; 779 return get_disk_and_module(swd->unit[drive].disk); 780 } 781 782 static int swim_add_floppy(struct swim_priv *swd, enum drive_location location) 783 { 784 struct floppy_state *fs = &swd->unit[swd->floppy_count]; 785 struct swim __iomem *base = swd->base; 786 787 fs->location = location; 788 789 swim_drive(base, location); 790 791 swim_motor(base, OFF); 792 793 fs->type = HD_MEDIA; 794 fs->head_number = 2; 795 796 fs->ref_count = 0; 797 fs->ejected = 1; 798 799 swd->floppy_count++; 800 801 return 0; 802 } 803 804 static const struct blk_mq_ops swim_mq_ops = { 805 .queue_rq = swim_queue_rq, 806 }; 807 808 static int swim_floppy_init(struct swim_priv *swd) 809 { 810 int err; 811 int drive; 812 struct swim __iomem *base = swd->base; 813 814 /* scan floppy drives */ 815 816 swim_drive(base, INTERNAL_DRIVE); 817 if (swim_readbit(base, DRIVE_PRESENT) && 818 !swim_readbit(base, ONEMEG_DRIVE)) 819 swim_add_floppy(swd, INTERNAL_DRIVE); 820 swim_drive(base, EXTERNAL_DRIVE); 821 if (swim_readbit(base, DRIVE_PRESENT) && 822 !swim_readbit(base, ONEMEG_DRIVE)) 823 swim_add_floppy(swd, EXTERNAL_DRIVE); 824 825 /* register floppy drives */ 826 827 err = register_blkdev(FLOPPY_MAJOR, "fd"); 828 if (err) { 829 printk(KERN_ERR "Unable to get major %d for SWIM floppy\n", 830 FLOPPY_MAJOR); 831 return -EBUSY; 832 } 833 834 spin_lock_init(&swd->lock); 835 836 for (drive = 0; drive < swd->floppy_count; drive++) { 837 struct request_queue *q; 838 839 swd->unit[drive].disk = alloc_disk(1); 840 if (swd->unit[drive].disk == NULL) { 841 err = -ENOMEM; 842 goto exit_put_disks; 843 } 844 845 q = blk_mq_init_sq_queue(&swd->unit[drive].tag_set, &swim_mq_ops, 846 2, BLK_MQ_F_SHOULD_MERGE); 847 if (IS_ERR(q)) { 848 err = PTR_ERR(q); 849 goto exit_put_disks; 850 } 851 852 swd->unit[drive].disk->queue = q; 853 blk_queue_bounce_limit(swd->unit[drive].disk->queue, 854 BLK_BOUNCE_HIGH); 855 swd->unit[drive].disk->queue->queuedata = &swd->unit[drive]; 856 swd->unit[drive].swd = swd; 857 } 858 859 for (drive = 0; drive < swd->floppy_count; drive++) { 860 swd->unit[drive].disk->flags = GENHD_FL_REMOVABLE; 861 swd->unit[drive].disk->major = FLOPPY_MAJOR; 862 swd->unit[drive].disk->first_minor = drive; 863 sprintf(swd->unit[drive].disk->disk_name, "fd%d", drive); 864 swd->unit[drive].disk->fops = &floppy_fops; 865 swd->unit[drive].disk->private_data = &swd->unit[drive]; 866 set_capacity(swd->unit[drive].disk, 2880); 867 add_disk(swd->unit[drive].disk); 868 } 869 870 blk_register_region(MKDEV(FLOPPY_MAJOR, 0), 256, THIS_MODULE, 871 floppy_find, NULL, swd); 872 873 return 0; 874 875 exit_put_disks: 876 unregister_blkdev(FLOPPY_MAJOR, "fd"); 877 do { 878 struct gendisk *disk = swd->unit[drive].disk; 879 880 if (disk) { 881 if (disk->queue) { 882 blk_cleanup_queue(disk->queue); 883 disk->queue = NULL; 884 } 885 blk_mq_free_tag_set(&swd->unit[drive].tag_set); 886 put_disk(disk); 887 } 888 } while (drive--); 889 return err; 890 } 891 892 static int swim_probe(struct platform_device *dev) 893 { 894 struct resource *res; 895 struct swim __iomem *swim_base; 896 struct swim_priv *swd; 897 int ret; 898 899 res = platform_get_resource(dev, IORESOURCE_MEM, 0); 900 if (!res) { 901 ret = -ENODEV; 902 goto out; 903 } 904 905 if (!request_mem_region(res->start, resource_size(res), CARDNAME)) { 906 ret = -EBUSY; 907 goto out; 908 } 909 910 swim_base = (struct swim __iomem *)res->start; 911 if (!swim_base) { 912 ret = -ENOMEM; 913 goto out_release_io; 914 } 915 916 /* probe device */ 917 918 set_swim_mode(swim_base, 1); 919 if (!get_swim_mode(swim_base)) { 920 printk(KERN_INFO "SWIM device not found !\n"); 921 ret = -ENODEV; 922 goto out_release_io; 923 } 924 925 /* set platform driver data */ 926 927 swd = kzalloc(sizeof(struct swim_priv), GFP_KERNEL); 928 if (!swd) { 929 ret = -ENOMEM; 930 goto out_release_io; 931 } 932 platform_set_drvdata(dev, swd); 933 934 swd->base = swim_base; 935 936 ret = swim_floppy_init(swd); 937 if (ret) 938 goto out_kfree; 939 940 return 0; 941 942 out_kfree: 943 kfree(swd); 944 out_release_io: 945 release_mem_region(res->start, resource_size(res)); 946 out: 947 return ret; 948 } 949 950 static int swim_remove(struct platform_device *dev) 951 { 952 struct swim_priv *swd = platform_get_drvdata(dev); 953 int drive; 954 struct resource *res; 955 956 blk_unregister_region(MKDEV(FLOPPY_MAJOR, 0), 256); 957 958 for (drive = 0; drive < swd->floppy_count; drive++) { 959 del_gendisk(swd->unit[drive].disk); 960 blk_cleanup_queue(swd->unit[drive].disk->queue); 961 blk_mq_free_tag_set(&swd->unit[drive].tag_set); 962 put_disk(swd->unit[drive].disk); 963 } 964 965 unregister_blkdev(FLOPPY_MAJOR, "fd"); 966 967 /* eject floppies */ 968 969 for (drive = 0; drive < swd->floppy_count; drive++) 970 floppy_eject(&swd->unit[drive]); 971 972 res = platform_get_resource(dev, IORESOURCE_MEM, 0); 973 if (res) 974 release_mem_region(res->start, resource_size(res)); 975 976 kfree(swd); 977 978 return 0; 979 } 980 981 static struct platform_driver swim_driver = { 982 .probe = swim_probe, 983 .remove = swim_remove, 984 .driver = { 985 .name = CARDNAME, 986 }, 987 }; 988 989 static int __init swim_init(void) 990 { 991 printk(KERN_INFO "SWIM floppy driver %s\n", DRIVER_VERSION); 992 993 return platform_driver_register(&swim_driver); 994 } 995 module_init(swim_init); 996 997 static void __exit swim_exit(void) 998 { 999 platform_driver_unregister(&swim_driver); 1000 } 1001 module_exit(swim_exit); 1002 1003 MODULE_DESCRIPTION("Driver for SWIM floppy controller"); 1004 MODULE_LICENSE("GPL"); 1005 MODULE_AUTHOR("Laurent Vivier <laurent@lvivier.info>"); 1006 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR); 1007