1 /* 2 * Driver for the SWIM3 (Super Woz Integrated Machine 3) 3 * floppy controller found on Power Macintoshes. 4 * 5 * Copyright (C) 1996 Paul Mackerras. 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 10 * 2 of the License, or (at your option) any later version. 11 */ 12 13 /* 14 * TODO: 15 * handle 2 drives 16 * handle GCR disks 17 */ 18 19 #include <linux/config.h> 20 #include <linux/stddef.h> 21 #include <linux/kernel.h> 22 #include <linux/sched.h> 23 #include <linux/timer.h> 24 #include <linux/delay.h> 25 #include <linux/fd.h> 26 #include <linux/ioctl.h> 27 #include <linux/blkdev.h> 28 #include <linux/devfs_fs_kernel.h> 29 #include <linux/interrupt.h> 30 #include <linux/module.h> 31 #include <asm/io.h> 32 #include <asm/dbdma.h> 33 #include <asm/prom.h> 34 #include <asm/uaccess.h> 35 #include <asm/mediabay.h> 36 #include <asm/machdep.h> 37 #include <asm/pmac_feature.h> 38 39 static struct request_queue *swim3_queue; 40 static struct gendisk *disks[2]; 41 static struct request *fd_req; 42 43 #define MAX_FLOPPIES 2 44 45 enum swim_state { 46 idle, 47 locating, 48 seeking, 49 settling, 50 do_transfer, 51 jogging, 52 available, 53 revalidating, 54 ejecting 55 }; 56 57 #define REG(x) unsigned char x; char x ## _pad[15]; 58 59 /* 60 * The names for these registers mostly represent speculation on my part. 61 * It will be interesting to see how close they are to the names Apple uses. 62 */ 63 struct swim3 { 64 REG(data); 65 REG(timer); /* counts down at 1MHz */ 66 REG(error); 67 REG(mode); 68 REG(select); /* controls CA0, CA1, CA2 and LSTRB signals */ 69 REG(setup); 70 REG(control); /* writing bits clears them */ 71 REG(status); /* writing bits sets them in control */ 72 REG(intr); 73 REG(nseek); /* # tracks to seek */ 74 REG(ctrack); /* current track number */ 75 REG(csect); /* current sector number */ 76 REG(gap3); /* size of gap 3 in track format */ 77 REG(sector); /* sector # to read or write */ 78 REG(nsect); /* # sectors to read or write */ 79 REG(intr_enable); 80 }; 81 82 #define control_bic control 83 #define control_bis status 84 85 /* Bits in select register */ 86 #define CA_MASK 7 87 #define LSTRB 8 88 89 /* Bits in control register */ 90 #define DO_SEEK 0x80 91 #define FORMAT 0x40 92 #define SELECT 0x20 93 #define WRITE_SECTORS 0x10 94 #define DO_ACTION 0x08 95 #define DRIVE2_ENABLE 0x04 96 #define DRIVE_ENABLE 0x02 97 #define INTR_ENABLE 0x01 98 99 /* Bits in status register */ 100 #define FIFO_1BYTE 0x80 101 #define FIFO_2BYTE 0x40 102 #define ERROR 0x20 103 #define DATA 0x08 104 #define RDDATA 0x04 105 #define INTR_PENDING 0x02 106 #define MARK_BYTE 0x01 107 108 /* Bits in intr and intr_enable registers */ 109 #define ERROR_INTR 0x20 110 #define DATA_CHANGED 0x10 111 #define TRANSFER_DONE 0x08 112 #define SEEN_SECTOR 0x04 113 #define SEEK_DONE 0x02 114 #define TIMER_DONE 0x01 115 116 /* Bits in error register */ 117 #define ERR_DATA_CRC 0x80 118 #define ERR_ADDR_CRC 0x40 119 #define ERR_OVERRUN 0x04 120 #define ERR_UNDERRUN 0x01 121 122 /* Bits in setup register */ 123 #define S_SW_RESET 0x80 124 #define S_GCR_WRITE 0x40 125 #define S_IBM_DRIVE 0x20 126 #define S_TEST_MODE 0x10 127 #define S_FCLK_DIV2 0x08 128 #define S_GCR 0x04 129 #define S_COPY_PROT 0x02 130 #define S_INV_WDATA 0x01 131 132 /* Select values for swim3_action */ 133 #define SEEK_POSITIVE 0 134 #define SEEK_NEGATIVE 4 135 #define STEP 1 136 #define MOTOR_ON 2 137 #define MOTOR_OFF 6 138 #define INDEX 3 139 #define EJECT 7 140 #define SETMFM 9 141 #define SETGCR 13 142 143 /* Select values for swim3_select and swim3_readbit */ 144 #define STEP_DIR 0 145 #define STEPPING 1 146 #define MOTOR_ON 2 147 #define RELAX 3 /* also eject in progress */ 148 #define READ_DATA_0 4 149 #define TWOMEG_DRIVE 5 150 #define SINGLE_SIDED 6 /* drive or diskette is 4MB type? */ 151 #define DRIVE_PRESENT 7 152 #define DISK_IN 8 153 #define WRITE_PROT 9 154 #define TRACK_ZERO 10 155 #define TACHO 11 156 #define READ_DATA_1 12 157 #define MFM_MODE 13 158 #define SEEK_COMPLETE 14 159 #define ONEMEG_MEDIA 15 160 161 /* Definitions of values used in writing and formatting */ 162 #define DATA_ESCAPE 0x99 163 #define GCR_SYNC_EXC 0x3f 164 #define GCR_SYNC_CONV 0x80 165 #define GCR_FIRST_MARK 0xd5 166 #define GCR_SECOND_MARK 0xaa 167 #define GCR_ADDR_MARK "\xd5\xaa\x00" 168 #define GCR_DATA_MARK "\xd5\xaa\x0b" 169 #define GCR_SLIP_BYTE "\x27\xaa" 170 #define GCR_SELF_SYNC "\x3f\xbf\x1e\x34\x3c\x3f" 171 172 #define DATA_99 "\x99\x99" 173 #define MFM_ADDR_MARK "\x99\xa1\x99\xa1\x99\xa1\x99\xfe" 174 #define MFM_INDEX_MARK "\x99\xc2\x99\xc2\x99\xc2\x99\xfc" 175 #define MFM_GAP_LEN 12 176 177 struct floppy_state { 178 enum swim_state state; 179 struct swim3 __iomem *swim3; /* hardware registers */ 180 struct dbdma_regs __iomem *dma; /* DMA controller registers */ 181 int swim3_intr; /* interrupt number for SWIM3 */ 182 int dma_intr; /* interrupt number for DMA channel */ 183 int cur_cyl; /* cylinder head is on, or -1 */ 184 int cur_sector; /* last sector we saw go past */ 185 int req_cyl; /* the cylinder for the current r/w request */ 186 int head; /* head number ditto */ 187 int req_sector; /* sector number ditto */ 188 int scount; /* # sectors we're transferring at present */ 189 int retries; 190 int settle_time; 191 int secpercyl; /* disk geometry information */ 192 int secpertrack; 193 int total_secs; 194 int write_prot; /* 1 if write-protected, 0 if not, -1 dunno */ 195 struct dbdma_cmd *dma_cmd; 196 int ref_count; 197 int expect_cyl; 198 struct timer_list timeout; 199 int timeout_pending; 200 int ejected; 201 wait_queue_head_t wait; 202 int wanted; 203 struct device_node* media_bay; /* NULL when not in bay */ 204 char dbdma_cmd_space[5 * sizeof(struct dbdma_cmd)]; 205 }; 206 207 static struct floppy_state floppy_states[MAX_FLOPPIES]; 208 static int floppy_count = 0; 209 static DEFINE_SPINLOCK(swim3_lock); 210 211 static unsigned short write_preamble[] = { 212 0x4e4e, 0x4e4e, 0x4e4e, 0x4e4e, 0x4e4e, /* gap field */ 213 0, 0, 0, 0, 0, 0, /* sync field */ 214 0x99a1, 0x99a1, 0x99a1, 0x99fb, /* data address mark */ 215 0x990f /* no escape for 512 bytes */ 216 }; 217 218 static unsigned short write_postamble[] = { 219 0x9904, /* insert CRC */ 220 0x4e4e, 0x4e4e, 221 0x9908, /* stop writing */ 222 0, 0, 0, 0, 0, 0 223 }; 224 225 static void swim3_select(struct floppy_state *fs, int sel); 226 static void swim3_action(struct floppy_state *fs, int action); 227 static int swim3_readbit(struct floppy_state *fs, int bit); 228 static void do_fd_request(request_queue_t * q); 229 static void start_request(struct floppy_state *fs); 230 static void set_timeout(struct floppy_state *fs, int nticks, 231 void (*proc)(unsigned long)); 232 static void scan_track(struct floppy_state *fs); 233 static void seek_track(struct floppy_state *fs, int n); 234 static void init_dma(struct dbdma_cmd *cp, int cmd, void *buf, int count); 235 static void setup_transfer(struct floppy_state *fs); 236 static void act(struct floppy_state *fs); 237 static void scan_timeout(unsigned long data); 238 static void seek_timeout(unsigned long data); 239 static void settle_timeout(unsigned long data); 240 static void xfer_timeout(unsigned long data); 241 static irqreturn_t swim3_interrupt(int irq, void *dev_id, struct pt_regs *regs); 242 /*static void fd_dma_interrupt(int irq, void *dev_id, struct pt_regs *regs);*/ 243 static int grab_drive(struct floppy_state *fs, enum swim_state state, 244 int interruptible); 245 static void release_drive(struct floppy_state *fs); 246 static int fd_eject(struct floppy_state *fs); 247 static int floppy_ioctl(struct inode *inode, struct file *filp, 248 unsigned int cmd, unsigned long param); 249 static int floppy_open(struct inode *inode, struct file *filp); 250 static int floppy_release(struct inode *inode, struct file *filp); 251 static int floppy_check_change(struct gendisk *disk); 252 static int floppy_revalidate(struct gendisk *disk); 253 static int swim3_add_device(struct device_node *swims); 254 int swim3_init(void); 255 256 #ifndef CONFIG_PMAC_MEDIABAY 257 #define check_media_bay(which, what) 1 258 #endif 259 260 static void swim3_select(struct floppy_state *fs, int sel) 261 { 262 struct swim3 __iomem *sw = fs->swim3; 263 264 out_8(&sw->select, RELAX); 265 if (sel & 8) 266 out_8(&sw->control_bis, SELECT); 267 else 268 out_8(&sw->control_bic, SELECT); 269 out_8(&sw->select, sel & CA_MASK); 270 } 271 272 static void swim3_action(struct floppy_state *fs, int action) 273 { 274 struct swim3 __iomem *sw = fs->swim3; 275 276 swim3_select(fs, action); 277 udelay(1); 278 out_8(&sw->select, sw->select | LSTRB); 279 udelay(2); 280 out_8(&sw->select, sw->select & ~LSTRB); 281 udelay(1); 282 } 283 284 static int swim3_readbit(struct floppy_state *fs, int bit) 285 { 286 struct swim3 __iomem *sw = fs->swim3; 287 int stat; 288 289 swim3_select(fs, bit); 290 udelay(1); 291 stat = in_8(&sw->status); 292 return (stat & DATA) == 0; 293 } 294 295 static void do_fd_request(request_queue_t * q) 296 { 297 int i; 298 for(i=0;i<floppy_count;i++) 299 { 300 #ifdef CONFIG_PMAC_MEDIABAY 301 if (floppy_states[i].media_bay && 302 check_media_bay(floppy_states[i].media_bay, MB_FD)) 303 continue; 304 #endif /* CONFIG_PMAC_MEDIABAY */ 305 start_request(&floppy_states[i]); 306 } 307 sti(); 308 } 309 310 static void start_request(struct floppy_state *fs) 311 { 312 struct request *req; 313 unsigned long x; 314 315 if (fs->state == idle && fs->wanted) { 316 fs->state = available; 317 wake_up(&fs->wait); 318 return; 319 } 320 while (fs->state == idle && (req = elv_next_request(swim3_queue))) { 321 #if 0 322 printk("do_fd_req: dev=%s cmd=%d sec=%ld nr_sec=%ld buf=%p\n", 323 req->rq_disk->disk_name, req->cmd, 324 (long)req->sector, req->nr_sectors, req->buffer); 325 printk(" rq_status=%d errors=%d current_nr_sectors=%ld\n", 326 req->rq_status, req->errors, req->current_nr_sectors); 327 #endif 328 329 if (req->sector < 0 || req->sector >= fs->total_secs) { 330 end_request(req, 0); 331 continue; 332 } 333 if (req->current_nr_sectors == 0) { 334 end_request(req, 1); 335 continue; 336 } 337 if (fs->ejected) { 338 end_request(req, 0); 339 continue; 340 } 341 342 if (rq_data_dir(req) == WRITE) { 343 if (fs->write_prot < 0) 344 fs->write_prot = swim3_readbit(fs, WRITE_PROT); 345 if (fs->write_prot) { 346 end_request(req, 0); 347 continue; 348 } 349 } 350 351 /* Do not remove the cast. req->sector is now a sector_t and 352 * can be 64 bits, but it will never go past 32 bits for this 353 * driver anyway, so we can safely cast it down and not have 354 * to do a 64/32 division 355 */ 356 fs->req_cyl = ((long)req->sector) / fs->secpercyl; 357 x = ((long)req->sector) % fs->secpercyl; 358 fs->head = x / fs->secpertrack; 359 fs->req_sector = x % fs->secpertrack + 1; 360 fd_req = req; 361 fs->state = do_transfer; 362 fs->retries = 0; 363 364 act(fs); 365 } 366 } 367 368 static void set_timeout(struct floppy_state *fs, int nticks, 369 void (*proc)(unsigned long)) 370 { 371 unsigned long flags; 372 373 save_flags(flags); cli(); 374 if (fs->timeout_pending) 375 del_timer(&fs->timeout); 376 fs->timeout.expires = jiffies + nticks; 377 fs->timeout.function = proc; 378 fs->timeout.data = (unsigned long) fs; 379 add_timer(&fs->timeout); 380 fs->timeout_pending = 1; 381 restore_flags(flags); 382 } 383 384 static inline void scan_track(struct floppy_state *fs) 385 { 386 struct swim3 __iomem *sw = fs->swim3; 387 388 swim3_select(fs, READ_DATA_0); 389 in_8(&sw->intr); /* clear SEEN_SECTOR bit */ 390 in_8(&sw->error); 391 out_8(&sw->intr_enable, SEEN_SECTOR); 392 out_8(&sw->control_bis, DO_ACTION); 393 /* enable intr when track found */ 394 set_timeout(fs, HZ, scan_timeout); /* enable timeout */ 395 } 396 397 static inline void seek_track(struct floppy_state *fs, int n) 398 { 399 struct swim3 __iomem *sw = fs->swim3; 400 401 if (n >= 0) { 402 swim3_action(fs, SEEK_POSITIVE); 403 sw->nseek = n; 404 } else { 405 swim3_action(fs, SEEK_NEGATIVE); 406 sw->nseek = -n; 407 } 408 fs->expect_cyl = (fs->cur_cyl >= 0)? fs->cur_cyl + n: -1; 409 swim3_select(fs, STEP); 410 in_8(&sw->error); 411 /* enable intr when seek finished */ 412 out_8(&sw->intr_enable, SEEK_DONE); 413 out_8(&sw->control_bis, DO_SEEK); 414 set_timeout(fs, 3*HZ, seek_timeout); /* enable timeout */ 415 fs->settle_time = 0; 416 } 417 418 static inline void init_dma(struct dbdma_cmd *cp, int cmd, 419 void *buf, int count) 420 { 421 st_le16(&cp->req_count, count); 422 st_le16(&cp->command, cmd); 423 st_le32(&cp->phy_addr, virt_to_bus(buf)); 424 cp->xfer_status = 0; 425 } 426 427 static inline void setup_transfer(struct floppy_state *fs) 428 { 429 int n; 430 struct swim3 __iomem *sw = fs->swim3; 431 struct dbdma_cmd *cp = fs->dma_cmd; 432 struct dbdma_regs __iomem *dr = fs->dma; 433 434 if (fd_req->current_nr_sectors <= 0) { 435 printk(KERN_ERR "swim3: transfer 0 sectors?\n"); 436 return; 437 } 438 if (rq_data_dir(fd_req) == WRITE) 439 n = 1; 440 else { 441 n = fs->secpertrack - fs->req_sector + 1; 442 if (n > fd_req->current_nr_sectors) 443 n = fd_req->current_nr_sectors; 444 } 445 fs->scount = n; 446 swim3_select(fs, fs->head? READ_DATA_1: READ_DATA_0); 447 out_8(&sw->sector, fs->req_sector); 448 out_8(&sw->nsect, n); 449 out_8(&sw->gap3, 0); 450 out_le32(&dr->cmdptr, virt_to_bus(cp)); 451 if (rq_data_dir(fd_req) == WRITE) { 452 /* Set up 3 dma commands: write preamble, data, postamble */ 453 init_dma(cp, OUTPUT_MORE, write_preamble, sizeof(write_preamble)); 454 ++cp; 455 init_dma(cp, OUTPUT_MORE, fd_req->buffer, 512); 456 ++cp; 457 init_dma(cp, OUTPUT_LAST, write_postamble, sizeof(write_postamble)); 458 } else { 459 init_dma(cp, INPUT_LAST, fd_req->buffer, n * 512); 460 } 461 ++cp; 462 out_le16(&cp->command, DBDMA_STOP); 463 out_8(&sw->control_bic, DO_ACTION | WRITE_SECTORS); 464 in_8(&sw->error); 465 out_8(&sw->control_bic, DO_ACTION | WRITE_SECTORS); 466 if (rq_data_dir(fd_req) == WRITE) 467 out_8(&sw->control_bis, WRITE_SECTORS); 468 in_8(&sw->intr); 469 out_le32(&dr->control, (RUN << 16) | RUN); 470 /* enable intr when transfer complete */ 471 out_8(&sw->intr_enable, TRANSFER_DONE); 472 out_8(&sw->control_bis, DO_ACTION); 473 set_timeout(fs, 2*HZ, xfer_timeout); /* enable timeout */ 474 } 475 476 static void act(struct floppy_state *fs) 477 { 478 for (;;) { 479 switch (fs->state) { 480 case idle: 481 return; /* XXX shouldn't get here */ 482 483 case locating: 484 if (swim3_readbit(fs, TRACK_ZERO)) { 485 fs->cur_cyl = 0; 486 if (fs->req_cyl == 0) 487 fs->state = do_transfer; 488 else 489 fs->state = seeking; 490 break; 491 } 492 scan_track(fs); 493 return; 494 495 case seeking: 496 if (fs->cur_cyl < 0) { 497 fs->expect_cyl = -1; 498 fs->state = locating; 499 break; 500 } 501 if (fs->req_cyl == fs->cur_cyl) { 502 printk("whoops, seeking 0\n"); 503 fs->state = do_transfer; 504 break; 505 } 506 seek_track(fs, fs->req_cyl - fs->cur_cyl); 507 return; 508 509 case settling: 510 /* check for SEEK_COMPLETE after 30ms */ 511 fs->settle_time = (HZ + 32) / 33; 512 set_timeout(fs, fs->settle_time, settle_timeout); 513 return; 514 515 case do_transfer: 516 if (fs->cur_cyl != fs->req_cyl) { 517 if (fs->retries > 5) { 518 end_request(fd_req, 0); 519 fs->state = idle; 520 return; 521 } 522 fs->state = seeking; 523 break; 524 } 525 setup_transfer(fs); 526 return; 527 528 case jogging: 529 seek_track(fs, -5); 530 return; 531 532 default: 533 printk(KERN_ERR"swim3: unknown state %d\n", fs->state); 534 return; 535 } 536 } 537 } 538 539 static void scan_timeout(unsigned long data) 540 { 541 struct floppy_state *fs = (struct floppy_state *) data; 542 struct swim3 __iomem *sw = fs->swim3; 543 544 fs->timeout_pending = 0; 545 out_8(&sw->control_bic, DO_ACTION | WRITE_SECTORS); 546 out_8(&sw->select, RELAX); 547 out_8(&sw->intr_enable, 0); 548 fs->cur_cyl = -1; 549 if (fs->retries > 5) { 550 end_request(fd_req, 0); 551 fs->state = idle; 552 start_request(fs); 553 } else { 554 fs->state = jogging; 555 act(fs); 556 } 557 } 558 559 static void seek_timeout(unsigned long data) 560 { 561 struct floppy_state *fs = (struct floppy_state *) data; 562 struct swim3 __iomem *sw = fs->swim3; 563 564 fs->timeout_pending = 0; 565 out_8(&sw->control_bic, DO_SEEK); 566 out_8(&sw->select, RELAX); 567 out_8(&sw->intr_enable, 0); 568 printk(KERN_ERR "swim3: seek timeout\n"); 569 end_request(fd_req, 0); 570 fs->state = idle; 571 start_request(fs); 572 } 573 574 static void settle_timeout(unsigned long data) 575 { 576 struct floppy_state *fs = (struct floppy_state *) data; 577 struct swim3 __iomem *sw = fs->swim3; 578 579 fs->timeout_pending = 0; 580 if (swim3_readbit(fs, SEEK_COMPLETE)) { 581 out_8(&sw->select, RELAX); 582 fs->state = locating; 583 act(fs); 584 return; 585 } 586 out_8(&sw->select, RELAX); 587 if (fs->settle_time < 2*HZ) { 588 ++fs->settle_time; 589 set_timeout(fs, 1, settle_timeout); 590 return; 591 } 592 printk(KERN_ERR "swim3: seek settle timeout\n"); 593 end_request(fd_req, 0); 594 fs->state = idle; 595 start_request(fs); 596 } 597 598 static void xfer_timeout(unsigned long data) 599 { 600 struct floppy_state *fs = (struct floppy_state *) data; 601 struct swim3 __iomem *sw = fs->swim3; 602 struct dbdma_regs __iomem *dr = fs->dma; 603 struct dbdma_cmd *cp = fs->dma_cmd; 604 unsigned long s; 605 int n; 606 607 fs->timeout_pending = 0; 608 out_le32(&dr->control, RUN << 16); 609 /* We must wait a bit for dbdma to stop */ 610 for (n = 0; (in_le32(&dr->status) & ACTIVE) && n < 1000; n++) 611 udelay(1); 612 out_8(&sw->intr_enable, 0); 613 out_8(&sw->control_bic, WRITE_SECTORS | DO_ACTION); 614 out_8(&sw->select, RELAX); 615 if (rq_data_dir(fd_req) == WRITE) 616 ++cp; 617 if (ld_le16(&cp->xfer_status) != 0) 618 s = fs->scount - ((ld_le16(&cp->res_count) + 511) >> 9); 619 else 620 s = 0; 621 fd_req->sector += s; 622 fd_req->current_nr_sectors -= s; 623 printk(KERN_ERR "swim3: timeout %sing sector %ld\n", 624 (rq_data_dir(fd_req)==WRITE? "writ": "read"), (long)fd_req->sector); 625 end_request(fd_req, 0); 626 fs->state = idle; 627 start_request(fs); 628 } 629 630 static irqreturn_t swim3_interrupt(int irq, void *dev_id, struct pt_regs *regs) 631 { 632 struct floppy_state *fs = (struct floppy_state *) dev_id; 633 struct swim3 __iomem *sw = fs->swim3; 634 int intr, err, n; 635 int stat, resid; 636 struct dbdma_regs __iomem *dr; 637 struct dbdma_cmd *cp; 638 639 intr = in_8(&sw->intr); 640 err = (intr & ERROR_INTR)? in_8(&sw->error): 0; 641 if ((intr & ERROR_INTR) && fs->state != do_transfer) 642 printk(KERN_ERR "swim3_interrupt, state=%d, dir=%lx, intr=%x, err=%x\n", 643 fs->state, rq_data_dir(fd_req), intr, err); 644 switch (fs->state) { 645 case locating: 646 if (intr & SEEN_SECTOR) { 647 out_8(&sw->control_bic, DO_ACTION | WRITE_SECTORS); 648 out_8(&sw->select, RELAX); 649 out_8(&sw->intr_enable, 0); 650 del_timer(&fs->timeout); 651 fs->timeout_pending = 0; 652 if (sw->ctrack == 0xff) { 653 printk(KERN_ERR "swim3: seen sector but cyl=ff?\n"); 654 fs->cur_cyl = -1; 655 if (fs->retries > 5) { 656 end_request(fd_req, 0); 657 fs->state = idle; 658 start_request(fs); 659 } else { 660 fs->state = jogging; 661 act(fs); 662 } 663 break; 664 } 665 fs->cur_cyl = sw->ctrack; 666 fs->cur_sector = sw->csect; 667 if (fs->expect_cyl != -1 && fs->expect_cyl != fs->cur_cyl) 668 printk(KERN_ERR "swim3: expected cyl %d, got %d\n", 669 fs->expect_cyl, fs->cur_cyl); 670 fs->state = do_transfer; 671 act(fs); 672 } 673 break; 674 case seeking: 675 case jogging: 676 if (sw->nseek == 0) { 677 out_8(&sw->control_bic, DO_SEEK); 678 out_8(&sw->select, RELAX); 679 out_8(&sw->intr_enable, 0); 680 del_timer(&fs->timeout); 681 fs->timeout_pending = 0; 682 if (fs->state == seeking) 683 ++fs->retries; 684 fs->state = settling; 685 act(fs); 686 } 687 break; 688 case settling: 689 out_8(&sw->intr_enable, 0); 690 del_timer(&fs->timeout); 691 fs->timeout_pending = 0; 692 act(fs); 693 break; 694 case do_transfer: 695 if ((intr & (ERROR_INTR | TRANSFER_DONE)) == 0) 696 break; 697 out_8(&sw->intr_enable, 0); 698 out_8(&sw->control_bic, WRITE_SECTORS | DO_ACTION); 699 out_8(&sw->select, RELAX); 700 del_timer(&fs->timeout); 701 fs->timeout_pending = 0; 702 dr = fs->dma; 703 cp = fs->dma_cmd; 704 if (rq_data_dir(fd_req) == WRITE) 705 ++cp; 706 /* 707 * Check that the main data transfer has finished. 708 * On writing, the swim3 sometimes doesn't use 709 * up all the bytes of the postamble, so we can still 710 * see DMA active here. That doesn't matter as long 711 * as all the sector data has been transferred. 712 */ 713 if ((intr & ERROR_INTR) == 0 && cp->xfer_status == 0) { 714 /* wait a little while for DMA to complete */ 715 for (n = 0; n < 100; ++n) { 716 if (cp->xfer_status != 0) 717 break; 718 udelay(1); 719 barrier(); 720 } 721 } 722 /* turn off DMA */ 723 out_le32(&dr->control, (RUN | PAUSE) << 16); 724 stat = ld_le16(&cp->xfer_status); 725 resid = ld_le16(&cp->res_count); 726 if (intr & ERROR_INTR) { 727 n = fs->scount - 1 - resid / 512; 728 if (n > 0) { 729 fd_req->sector += n; 730 fd_req->current_nr_sectors -= n; 731 fd_req->buffer += n * 512; 732 fs->req_sector += n; 733 } 734 if (fs->retries < 5) { 735 ++fs->retries; 736 act(fs); 737 } else { 738 printk("swim3: error %sing block %ld (err=%x)\n", 739 rq_data_dir(fd_req) == WRITE? "writ": "read", 740 (long)fd_req->sector, err); 741 end_request(fd_req, 0); 742 fs->state = idle; 743 } 744 } else { 745 if ((stat & ACTIVE) == 0 || resid != 0) { 746 /* musta been an error */ 747 printk(KERN_ERR "swim3: fd dma: stat=%x resid=%d\n", stat, resid); 748 printk(KERN_ERR " state=%d, dir=%lx, intr=%x, err=%x\n", 749 fs->state, rq_data_dir(fd_req), intr, err); 750 end_request(fd_req, 0); 751 fs->state = idle; 752 start_request(fs); 753 break; 754 } 755 fd_req->sector += fs->scount; 756 fd_req->current_nr_sectors -= fs->scount; 757 fd_req->buffer += fs->scount * 512; 758 if (fd_req->current_nr_sectors <= 0) { 759 end_request(fd_req, 1); 760 fs->state = idle; 761 } else { 762 fs->req_sector += fs->scount; 763 if (fs->req_sector > fs->secpertrack) { 764 fs->req_sector -= fs->secpertrack; 765 if (++fs->head > 1) { 766 fs->head = 0; 767 ++fs->req_cyl; 768 } 769 } 770 act(fs); 771 } 772 } 773 if (fs->state == idle) 774 start_request(fs); 775 break; 776 default: 777 printk(KERN_ERR "swim3: don't know what to do in state %d\n", fs->state); 778 } 779 return IRQ_HANDLED; 780 } 781 782 /* 783 static void fd_dma_interrupt(int irq, void *dev_id, struct pt_regs *regs) 784 { 785 } 786 */ 787 788 static int grab_drive(struct floppy_state *fs, enum swim_state state, 789 int interruptible) 790 { 791 unsigned long flags; 792 793 save_flags(flags); 794 cli(); 795 if (fs->state != idle) { 796 ++fs->wanted; 797 while (fs->state != available) { 798 if (interruptible && signal_pending(current)) { 799 --fs->wanted; 800 restore_flags(flags); 801 return -EINTR; 802 } 803 interruptible_sleep_on(&fs->wait); 804 } 805 --fs->wanted; 806 } 807 fs->state = state; 808 restore_flags(flags); 809 return 0; 810 } 811 812 static void release_drive(struct floppy_state *fs) 813 { 814 unsigned long flags; 815 816 save_flags(flags); 817 cli(); 818 fs->state = idle; 819 start_request(fs); 820 restore_flags(flags); 821 } 822 823 static int fd_eject(struct floppy_state *fs) 824 { 825 int err, n; 826 827 err = grab_drive(fs, ejecting, 1); 828 if (err) 829 return err; 830 swim3_action(fs, EJECT); 831 for (n = 20; n > 0; --n) { 832 if (signal_pending(current)) { 833 err = -EINTR; 834 break; 835 } 836 swim3_select(fs, RELAX); 837 schedule_timeout_interruptible(1); 838 if (swim3_readbit(fs, DISK_IN) == 0) 839 break; 840 } 841 swim3_select(fs, RELAX); 842 udelay(150); 843 fs->ejected = 1; 844 release_drive(fs); 845 return err; 846 } 847 848 static struct floppy_struct floppy_type = 849 { 2880,18,2,80,0,0x1B,0x00,0xCF,0x6C,NULL }; /* 7 1.44MB 3.5" */ 850 851 static int floppy_ioctl(struct inode *inode, struct file *filp, 852 unsigned int cmd, unsigned long param) 853 { 854 struct floppy_state *fs = inode->i_bdev->bd_disk->private_data; 855 int err; 856 857 if ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)) 858 return -EPERM; 859 860 #ifdef CONFIG_PMAC_MEDIABAY 861 if (fs->media_bay && check_media_bay(fs->media_bay, MB_FD)) 862 return -ENXIO; 863 #endif 864 865 switch (cmd) { 866 case FDEJECT: 867 if (fs->ref_count != 1) 868 return -EBUSY; 869 err = fd_eject(fs); 870 return err; 871 case FDGETPRM: 872 if (copy_to_user((void __user *) param, &floppy_type, 873 sizeof(struct floppy_struct))) 874 return -EFAULT; 875 return 0; 876 } 877 return -ENOTTY; 878 } 879 880 static int floppy_open(struct inode *inode, struct file *filp) 881 { 882 struct floppy_state *fs = inode->i_bdev->bd_disk->private_data; 883 struct swim3 __iomem *sw = fs->swim3; 884 int n, err = 0; 885 886 if (fs->ref_count == 0) { 887 #ifdef CONFIG_PMAC_MEDIABAY 888 if (fs->media_bay && check_media_bay(fs->media_bay, MB_FD)) 889 return -ENXIO; 890 #endif 891 out_8(&sw->setup, S_IBM_DRIVE | S_FCLK_DIV2); 892 out_8(&sw->control_bic, 0xff); 893 out_8(&sw->mode, 0x95); 894 udelay(10); 895 out_8(&sw->intr_enable, 0); 896 out_8(&sw->control_bis, DRIVE_ENABLE | INTR_ENABLE); 897 swim3_action(fs, MOTOR_ON); 898 fs->write_prot = -1; 899 fs->cur_cyl = -1; 900 for (n = 0; n < 2 * HZ; ++n) { 901 if (n >= HZ/30 && swim3_readbit(fs, SEEK_COMPLETE)) 902 break; 903 if (signal_pending(current)) { 904 err = -EINTR; 905 break; 906 } 907 swim3_select(fs, RELAX); 908 schedule_timeout_interruptible(1); 909 } 910 if (err == 0 && (swim3_readbit(fs, SEEK_COMPLETE) == 0 911 || swim3_readbit(fs, DISK_IN) == 0)) 912 err = -ENXIO; 913 swim3_action(fs, SETMFM); 914 swim3_select(fs, RELAX); 915 916 } else if (fs->ref_count == -1 || filp->f_flags & O_EXCL) 917 return -EBUSY; 918 919 if (err == 0 && (filp->f_flags & O_NDELAY) == 0 920 && (filp->f_mode & 3)) { 921 check_disk_change(inode->i_bdev); 922 if (fs->ejected) 923 err = -ENXIO; 924 } 925 926 if (err == 0 && (filp->f_mode & 2)) { 927 if (fs->write_prot < 0) 928 fs->write_prot = swim3_readbit(fs, WRITE_PROT); 929 if (fs->write_prot) 930 err = -EROFS; 931 } 932 933 if (err) { 934 if (fs->ref_count == 0) { 935 swim3_action(fs, MOTOR_OFF); 936 out_8(&sw->control_bic, DRIVE_ENABLE | INTR_ENABLE); 937 swim3_select(fs, RELAX); 938 } 939 return err; 940 } 941 942 if (filp->f_flags & O_EXCL) 943 fs->ref_count = -1; 944 else 945 ++fs->ref_count; 946 947 return 0; 948 } 949 950 static int floppy_release(struct inode *inode, struct file *filp) 951 { 952 struct floppy_state *fs = inode->i_bdev->bd_disk->private_data; 953 struct swim3 __iomem *sw = fs->swim3; 954 if (fs->ref_count > 0 && --fs->ref_count == 0) { 955 swim3_action(fs, MOTOR_OFF); 956 out_8(&sw->control_bic, 0xff); 957 swim3_select(fs, RELAX); 958 } 959 return 0; 960 } 961 962 static int floppy_check_change(struct gendisk *disk) 963 { 964 struct floppy_state *fs = disk->private_data; 965 return fs->ejected; 966 } 967 968 static int floppy_revalidate(struct gendisk *disk) 969 { 970 struct floppy_state *fs = disk->private_data; 971 struct swim3 __iomem *sw; 972 int ret, n; 973 974 #ifdef CONFIG_PMAC_MEDIABAY 975 if (fs->media_bay && check_media_bay(fs->media_bay, MB_FD)) 976 return -ENXIO; 977 #endif 978 979 sw = fs->swim3; 980 grab_drive(fs, revalidating, 0); 981 out_8(&sw->intr_enable, 0); 982 out_8(&sw->control_bis, DRIVE_ENABLE); 983 swim3_action(fs, MOTOR_ON); /* necessary? */ 984 fs->write_prot = -1; 985 fs->cur_cyl = -1; 986 mdelay(1); 987 for (n = HZ; n > 0; --n) { 988 if (swim3_readbit(fs, SEEK_COMPLETE)) 989 break; 990 if (signal_pending(current)) 991 break; 992 swim3_select(fs, RELAX); 993 schedule_timeout_interruptible(1); 994 } 995 ret = swim3_readbit(fs, SEEK_COMPLETE) == 0 996 || swim3_readbit(fs, DISK_IN) == 0; 997 if (ret) 998 swim3_action(fs, MOTOR_OFF); 999 else { 1000 fs->ejected = 0; 1001 swim3_action(fs, SETMFM); 1002 } 1003 swim3_select(fs, RELAX); 1004 1005 release_drive(fs); 1006 return ret; 1007 } 1008 1009 static struct block_device_operations floppy_fops = { 1010 .open = floppy_open, 1011 .release = floppy_release, 1012 .ioctl = floppy_ioctl, 1013 .media_changed = floppy_check_change, 1014 .revalidate_disk= floppy_revalidate, 1015 }; 1016 1017 int swim3_init(void) 1018 { 1019 struct device_node *swim; 1020 int err = -ENOMEM; 1021 int i; 1022 1023 devfs_mk_dir("floppy"); 1024 1025 swim = find_devices("floppy"); 1026 while (swim && (floppy_count < MAX_FLOPPIES)) 1027 { 1028 swim3_add_device(swim); 1029 swim = swim->next; 1030 } 1031 1032 swim = find_devices("swim3"); 1033 while (swim && (floppy_count < MAX_FLOPPIES)) 1034 { 1035 swim3_add_device(swim); 1036 swim = swim->next; 1037 } 1038 1039 if (!floppy_count) 1040 return -ENODEV; 1041 1042 for (i = 0; i < floppy_count; i++) { 1043 disks[i] = alloc_disk(1); 1044 if (!disks[i]) 1045 goto out; 1046 } 1047 1048 if (register_blkdev(FLOPPY_MAJOR, "fd")) { 1049 err = -EBUSY; 1050 goto out; 1051 } 1052 1053 swim3_queue = blk_init_queue(do_fd_request, &swim3_lock); 1054 if (!swim3_queue) { 1055 err = -ENOMEM; 1056 goto out_queue; 1057 } 1058 1059 for (i = 0; i < floppy_count; i++) { 1060 struct gendisk *disk = disks[i]; 1061 disk->major = FLOPPY_MAJOR; 1062 disk->first_minor = i; 1063 disk->fops = &floppy_fops; 1064 disk->private_data = &floppy_states[i]; 1065 disk->queue = swim3_queue; 1066 disk->flags |= GENHD_FL_REMOVABLE; 1067 sprintf(disk->disk_name, "fd%d", i); 1068 sprintf(disk->devfs_name, "floppy/%d", i); 1069 set_capacity(disk, 2880); 1070 add_disk(disk); 1071 } 1072 return 0; 1073 1074 out_queue: 1075 unregister_blkdev(FLOPPY_MAJOR, "fd"); 1076 out: 1077 while (i--) 1078 put_disk(disks[i]); 1079 /* shouldn't we do something with results of swim_add_device()? */ 1080 return err; 1081 } 1082 1083 static int swim3_add_device(struct device_node *swim) 1084 { 1085 struct device_node *mediabay; 1086 struct floppy_state *fs = &floppy_states[floppy_count]; 1087 1088 if (swim->n_addrs < 2) 1089 { 1090 printk(KERN_INFO "swim3: expecting 2 addrs (n_addrs:%d, n_intrs:%d)\n", 1091 swim->n_addrs, swim->n_intrs); 1092 return -EINVAL; 1093 } 1094 1095 if (swim->n_intrs < 2) 1096 { 1097 printk(KERN_INFO "swim3: expecting 2 intrs (n_addrs:%d, n_intrs:%d)\n", 1098 swim->n_addrs, swim->n_intrs); 1099 return -EINVAL; 1100 } 1101 1102 if (!request_OF_resource(swim, 0, NULL)) { 1103 printk(KERN_INFO "swim3: can't request IO resource !\n"); 1104 return -EINVAL; 1105 } 1106 1107 mediabay = (strcasecmp(swim->parent->type, "media-bay") == 0) ? swim->parent : NULL; 1108 if (mediabay == NULL) 1109 pmac_call_feature(PMAC_FTR_SWIM3_ENABLE, swim, 0, 1); 1110 1111 memset(fs, 0, sizeof(*fs)); 1112 fs->state = idle; 1113 fs->swim3 = (struct swim3 __iomem *) 1114 ioremap(swim->addrs[0].address, 0x200); 1115 fs->dma = (struct dbdma_regs __iomem *) 1116 ioremap(swim->addrs[1].address, 0x200); 1117 fs->swim3_intr = swim->intrs[0].line; 1118 fs->dma_intr = swim->intrs[1].line; 1119 fs->cur_cyl = -1; 1120 fs->cur_sector = -1; 1121 fs->secpercyl = 36; 1122 fs->secpertrack = 18; 1123 fs->total_secs = 2880; 1124 fs->media_bay = mediabay; 1125 init_waitqueue_head(&fs->wait); 1126 1127 fs->dma_cmd = (struct dbdma_cmd *) DBDMA_ALIGN(fs->dbdma_cmd_space); 1128 memset(fs->dma_cmd, 0, 2 * sizeof(struct dbdma_cmd)); 1129 st_le16(&fs->dma_cmd[1].command, DBDMA_STOP); 1130 1131 if (request_irq(fs->swim3_intr, swim3_interrupt, 0, "SWIM3", fs)) { 1132 printk(KERN_ERR "Couldn't get irq %d for SWIM3\n", fs->swim3_intr); 1133 pmac_call_feature(PMAC_FTR_SWIM3_ENABLE, swim, 0, 0); 1134 return -EBUSY; 1135 } 1136 /* 1137 if (request_irq(fs->dma_intr, fd_dma_interrupt, 0, "SWIM3-dma", fs)) { 1138 printk(KERN_ERR "Couldn't get irq %d for SWIM3 DMA", 1139 fs->dma_intr); 1140 pmac_call_feature(PMAC_FTR_SWIM3_ENABLE, swim, 0, 0); 1141 return -EBUSY; 1142 } 1143 */ 1144 1145 init_timer(&fs->timeout); 1146 1147 printk(KERN_INFO "fd%d: SWIM3 floppy controller %s\n", floppy_count, 1148 mediabay ? "in media bay" : ""); 1149 1150 floppy_count++; 1151 1152 return 0; 1153 } 1154 1155 module_init(swim3_init) 1156 1157 MODULE_LICENSE("GPL"); 1158 MODULE_AUTHOR("Paul Mackerras"); 1159 MODULE_ALIAS_BLOCKDEV_MAJOR(FLOPPY_MAJOR); 1160