kernel/fd.c

   1 /**
   2  *  thuix/kernel/fd.c
   3  *
   4  *  The floppy driver but now seems can't work correctly
   5  *
   6  *  Aleaxander (C) 2007-2008
   7  *
   8  *             Aleaxander@gmail.com
   9  *
  10  */
  11
  12 #include <fd.h>
  13 #include <timer.h>
  14 #include <thunix.h>
  15 #include <asm/io.h>
  16 #include <asm/system.h>
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <hexdump.h>
  20
  21 extern unsigned long count_down;
  22
  23 #define FALSE 0
  24 #define TRUE  1
  25
  26
  27 #define LOG //printk
  28
  29
  30 #define immoutb_p(val,port)                                             \
  31         __asm__("outb %0,%1\n\tjmp 1f\n1:\tjmp 1f\n1:"::"a" ((char) (val)),"i" (port))
  32
  33
  34 /* these are globals used by get_result() */
  35 #define MAX_REPLIES 7
  36 static unsigned char reply_buffer[MAX_REPLIES];
  37 #define ST0 (reply_buffer[0])
  38 #define ST1 (reply_buffer[1])
  39 #define ST2 (reply_buffer[2])
  40 #define ST3 (reply_buffer[3])
  41
  42
  43 static struct floppy_struct {
  44         unsigned int size, sector, head, track, stretch;
  45         unsigned char gap,rate,spec1;
  46 } floppy =  {
  47          2880,18,2,80,0,
  48          0x1b,0x00,0xCF         /* 1.44MB diskette */
  49 };
  50
  51
  52 /* Store the return vaule of get_result, we need it to do some check */
  53 //static int res;
  54
  55 static int done = FALSE;
  56 static int motoron = FALSE;
  57 static int changed = FALSE;
  58 static unsigned char sr0;
  59 static unsigned char fdc_track = 255;
  60
  61 static int track;
  62 static int sector;
  63
  64 /*
  65  *   send a byte to FD_DATA register
  66  * @param: byte is the byte that needed to send to the FD_DATA
  67  * @return: none
  68  */
  69 static void send_byte(unsigned char byte)
  70 {
  71         volatile int msr;
  72         int counter;
  73
  74         //LOG("send_byte() called ...\n");
  75
  76         for (counter = 0; counter < 1000; counter++) {
  77                 sleep(1); /* delay 10s */
  78                 msr = inb_p(FD_STATUS) & (STATUS_READY | STATUS_DIR);
  79                 if (msr == STATUS_READY) {
  80                         outb(byte,FD_DATA);
  81                         return ;
  82                 }
  83         }
  84         LOG("Unable to send byte to FDC\n");
  85 }
  86 /*
  87  * get *ONE* byte of results from FD_DATA register then return what
  88  * it get, or retrun -1 if faile.
  89  */
  90 static int get_byte()
  91 {
  92         volatile int msr;
  93         int counter;
  94
  95         //LOG("get_byte() called ...\n");
  96
  97         for (counter = 0; counter < 1000; counter ++) {
  98                 sleep(1); /* delay 10ms */
  99                 msr = inb_p(FD_STATUS) & (STATUS_DIR|STATUS_READY|STATUS_BUSY);
 100                 if (msr == (STATUS_DIR|STATUS_READY|STATUS_BUSY))
 101                         return inb_p(FD_DATA);
 102         }
 103         LOG("get_byte: get status times out!\n");
 104         return -1;
 105 }
 106
 107 /*
 108  * get *ALL* the results from the FD_DATA register then store
 109  * it in the global fileds reply_buffer. that's the only
 110  * diffrence between get_byte() and get_result().
 111  *
 112  * @param: none
 113  * @return: the number of reply chars
 114  *
 115  */
 116 static int get_result(void)
 117 {
 118         int i = 0, counter, msr;
 119
 120         //LOG("get_result() called ...\n");
 121
 122         for (counter = 0; counter < 1000; counter ++) {
 123                 sleep(1); /* delay 10ms */
 124                 msr = inb_p(FD_STATUS) & (STATUS_DIR|STATUS_READY|STATUS_BUSY);
 125                 //LOG("msr %d: %x\n", i, msr);
 126                 if (msr == STATUS_READY)
 127                         return i;
 128                 if (msr == (STATUS_DIR|STATUS_READY|STATUS_BUSY)) {
 129                         if ( i >= MAX_REPLIES)
 130                                 break;
 131                         reply_buffer[i++] = inb_p(FD_DATA);
 132                 }
 133         }
 134         LOG("get_result:get status times out!\n");
 135
 136         return -1;
 137 }
 138
 139
 140 /*
 141  * This waits for FDC command to complete
 142  *
 143  * @param: sensei
 144  * @return: if successfull then returns TRUE, or FALSE
 145  *
 146  */
 147 static int wait_fdc(int sensei)
 148 {
 149         int time_out;
 150         count_down = 1000; /* set count_down init. value to 2 second */
 151
 152
 153         /* wait for FLOPPY_INTERRUPT hander to signal command finished */
 154         while (!done && count_down)
 155                 ;
 156         time_out = count_down;
 157 #if 0
 158         do{
 159                 printk("time_out:%d\n",time_out);
 160                 printk("done:    %d\n",done);
 161         }while(0);
 162         res = get_result(); /* get the result of the command */
 163 #endif
 164
 165         /*
 166          * we use get_byte() but NOT get_result() here, because i don't
 167          * know where the error happened. or maybe get_byte() is better
 168          * than get_result(), it just come from the test
 169          *
 170         ST0 = get_byte();
 171         ST1 = get_byte();
 172         ST2 = get_byte();
 173         ST3 = get_byte();
 174          */
 175
 176         memset(reply_buffer, 0, sizeof(reply_buffer));
 177         get_result();
 178 #if 0
 179         hexdump(reply_buffer, sizeof(reply_buffer));
 180 #endif
 181
 182         if (sensei) {
 183                 /* send a "sense interrupt status" command */
 184                 send_byte(FD_SENSEI);
 185                 sr0 = get_byte();
 186                 fdc_track = get_byte();
 187         }
 188
 189         LOG("time left: %d\t done: %d\n", time_out, done);
 190         done = FALSE;
 191         if (time_out == 0)
 192                 return FALSE;
 193         else
 194                 return TRUE;
 195 }
 196
 197
 198 /**
 199  * Converts liner sector address to head/track/sector
 200  *
 201  * @param: sector is the liner sector we wanna convert.
 202  * @param: *head, save the head number to head
 203  * @param: *track, save the track number to track
 204  * @param: *sector, save the sector number to sector
 205  *
 206  * we return all the info. by the POINTER args
 207  *
 208  */
 209 static void lba_to_chs(int line_sector, int *head, int *track, int *sector)
 210 {
 211         //LOG("sector_to_hts() called ...\n");
 212         *sector = line_sector % floppy.sector;
 213         *sector += 1;
 214
 215         line_sector /= floppy.sector;
 216
 217         *head = line_sector % floppy.head;
 218         *track = line_sector / floppy.head;
 219 }
 220
 221
 222 /* test whether the motor is on or not */
 223 static inline int is_motor_on()
 224 {
 225         //LOG("is_motor_on() called ...\n");
 226         return motoron;
 227 }
 228
 229
 230
 231 /* Turns the motor on if not */
 232 static void motor_on(void)
 233 {
 234         //LOG("motor_on() called ...\n");
 235         if ( !is_motor_on()) {
 236                 outb_p(0x1c,FD_DOR);
 237                 sleep(100);  /* delay 1 second for motor on */
 238                 motoron = TRUE;
 239         }
 240 }
 241
 242
 243 /* Truns the motor off if on */
 244 static void motor_off (void)
 245 {
 246         //LOG("motor_off() called ...\n");
 247         if (is_motor_on() ) {
 248                 count_down = 200;  /* start motor kill countdown: about 2s */
 249                 while(count_down)
 250                         ;
 251                 outb_p(0x0c,FD_DOR);
 252                 motoron = FALSE;
 253         }
 254 }
 255
 256
 257 /* recalibrate the drive */
 258 static void recalibrate(void)
 259 {
 260
 261         //LOG("recalibrate() called ...\n");
 262
 263         /*turn the motor on first */
 264         motor_on();
 265
 266         /* send actual command bytes */
 267         send_byte(FD_RECALIBRATE);
 268         send_byte(0);
 269
 270         /* wait until seek finished */
 271         wait_fdc(TRUE);
 272 }
 273
 274
 275
 276 /* seek to track */
 277 static int seek(int track, int head)
 278 {
 279         //LOG("seek() called ...\n");
 280
 281         /*
 282         if (track == 0) {
 283                 LOG("RECALIBRATE...\n");
 284                 recalibrate();
 285                 return TRUE;
 286         }
 287         */
 288
 289         if (fdc_track == track)
 290                 return TRUE;   /* already there*/
 291
 292         /* send actual command bytes */
 293         send_byte(FD_SEEK);
 294         send_byte(head << 2);
 295         send_byte(track);
 296
 297         /* wait until seek finished */
 298         if ( !wait_fdc(TRUE) )
 299                 ;//return FALSE;  /* time out */
 300
 301         LOG("ST0: %x\t ST1: %x\n", sr0, fdc_track);
 302         if ( ((sr0 & 0xF8) != 0x20) || (fdc_track != track)) {
 303                 LOG("Seek track#: %d failed\n", track);
 304                 return FALSE;
 305         } else {
 306                 LOG("Seek track#: %d OK ...\n", track);
 307                 return TRUE;
 308         }
 309 }
 310
 311
 312
 313
 314 /*
 315  *    reset the floppy.
 316  *
 317  *    The first thing that the driver needs to do is reset the controller.This
 318  * will put it in a known state. To reset the primary floppy controller,(in C)
 319  *
 320  * 1.write 0x00 to the DIGITAL_OUTPUT_REG of the desired controller
 321  * 2.write 0x0C to the DIGITAL_OUTPUT_REG of the desired controller
 322  * 3.wait for an interrupt from the controller
 323  * 4.check interrupt status (this is function 0x08 of controllers)
 324  * 5.write 0x00 to the CONFIG_CONTROL_REG
 325  * 6.configure the drive desired on the controller (function 0x03 of controller)
 326  * 7.calibrate the drive (function 0x07 of controller)
 327  *
 328  */
 329 static void reset( )
 330 {
 331         //LOG("reset() called ...\n");
 332
 333         /* stop the motor and disable IRQ/DMA */
 334         outb_p(0,FD_DOR);
 335
 336         /* program data rate (500K/s) */
 337         outb_p(0,FD_DCR);
 338
 339         /* re-enable interrupts */
 340         outb_p(0x0c,FD_DOR);
 341
 342         /* resetting triggered an interrupt - handle it */
 343         done = TRUE;
 344         wait_fdc(TRUE);
 345
 346         /* specify drive timings (got these off the BIOS) */
 347         send_byte(FD_SPECIFY);
 348         send_byte(0xdf);      /* SRT = 3ms, HUT = 240ms */
 349         send_byte(0x06);      /* HLT = 16ms, ND = 0     */
 350
 351         recalibrate();
 352 }
 353
 354
 355
 356 /*
 357  * here we will setup the DMA, then we can use it to transfer data
 358  * more efficiently. For now, we just make it transfer one sector's
 359  * data once.
 360  *
 361  */
 362 static void setup_DMA(unsigned long addr, int command)
 363 {
 364         int cmd = (command == FD_READ) ? DMA_READ : DMA_WRITE;
 365         int count =  512 - 1;
 366
 367         cli();                          /* we need a safe env. */
 368
 369         immoutb_p(4|2,0x0a);            /* mask DMA 2 */
 370
 371         immoutb_p(0,0x0c);               /* clear flip flop */
 372
 373         immoutb_p(cmd,0x0b);
 374
 375         immoutb_p(addr,4);              /* 8 low bits of addr */
 376
 377         addr >>= 8;
 378         immoutb_p(addr,4);              /* bits 8-15 of addr */
 379
 380         addr >>= 8;
 381         immoutb_p(addr,0x81);           /* bits 16-19 of addr */
 382
 383         immoutb_p(count & 0xff,5);      /* low 8 bits of count-1 (1024-1=0x3ff) */
 384
 385         immoutb_p(count >> 8,5);        /* high 8 bits of count-1 */
 386
 387         immoutb_p(0|2,10);              /* activate DMA 2 */
 388         sti();
 389 }
 390
 391
 392 /*
 393  * And now, it's time to implenent the read or write function, that's
 394  * all the floppy driver mean!
 395  *
 396  * Read/Write one sector once.
 397  */
 398 static int floppy_rw(int sector, char *buf, int command)
 399 {
 400         int head;
 401         char *dma_buffer = buf;
 402         static char tmp_dma_buffer[512];
 403
 404         LOG("TMP dma buffer: %p\n", tmp_dma_buffer);
 405
 406         lba_to_chs(sector, &head, &track, &sector);
 407         LOG("head: %d \ttrack: %d \tsector: %d\n", head, track, sector);
 408
 409         /* turn it on if not */
 410         motor_on();
 411
 412         if (inb_p(FD_DIR) & 0x80) {
 413                 changed = TRUE;
 414                 seek(1, head);        /* clear "disk change" status */
 415                 recalibrate();
 416                 motor_off();
 417                 printk("floppy_rw: Disk change detected. You are going to DIE:)\n");
 418
 419                 pause();  /* just put it in DIE */
 420         }
 421
 422         /* move head to the right track */
 423         if (!seek(track, head)) {
 424                 motor_off();
 425                 printk("floppy_rw: Error seeking to track\n");
 426                 return FALSE;
 427         }
 428
 429         if ((unsigned long)buf >= 0xff000) {
 430                 dma_buffer = tmp_dma_buffer;
 431                 if (command == FD_WRITE)
 432                         memcpy(dma_buffer, buf, 512);
 433         }
 434
 435         setup_DMA((unsigned long)dma_buffer, command);
 436
 437         send_byte(command);
 438         send_byte(head<<2 | 0);
 439         send_byte(track);
 440         send_byte(head);
 441         send_byte(sector);
 442         send_byte(2);           /* sector size = 125 * 2^(2) */
 443         send_byte(floppy.sector);
 444         send_byte(0);
 445         send_byte(0xFF);        /* sector size(only two valid vaules, 0xff when n!=0*/
 446
 447         if (!wait_fdc(FALSE)) {
 448                 LOG("wait fdc failed!\n");
 449                 //return 0;
 450                 /*
 451                 printk("Time out, trying operation again after reset() \n");
 452                 reset();
 453                 return floppy_rw(sector, buf, command);
 454                 */
 455         }
 456
 457         motor_off();
 458
 459         if (/*res != 7 || */(ST0 & 0xf8) || (ST1 & 0xbf) || (ST2 & 0x73) ) {
 460                 if (ST1 & 0x02)
 461                         printk("Drive is write protected!\n");
 462                 else
 463                         printk("floppy_rw: bad interrupt!\n");
 464
 465                 return 0;
 466         } else {
 467                 LOG("floppy_rw: OK\n");
 468                 if ((unsigned long)buf >= 0xff000 && command == FD_READ)
 469                         memcpy(buf, dma_buffer, 512);
 470                 return 1;
 471         }
 472 }
 473
 474
 475 /* Read ONE sector */
 476 void floppy_read(int sector, char * buf)
 477 {
 478         floppy_rw(sector, buf, FD_READ);
 479 }
 480
 481 /* Write ONE sector */
 482 void floppy_write(int sector, char * buf)
 483 {
 484         floppy_rw(sector, buf, FD_WRITE);
 485 }
 486
 487 /*
 488  * The two following function handles multi-sectors reading
 489  * and writing.
 490  */
 491 void floppy_reads(int sector, char *buf, unsigned int sectors)
 492 {
 493         while (sectors--) {
 494                 floppy_rw(sector++, buf, FD_READ);
 495                 buf += 512;
 496         }
 497 }
 498
 499 void floppy_writes(int sector, char *buf, unsigned int sectors)
 500 {
 501         while (sectors--) {
 502                 floppy_rw(sector++, buf, FD_WRITE);
 503                 buf += 512;
 504         }
 505 }
 506
 507 static int times = 0;
 508 /*
 509  * The FLOPPY_INTERRUPT handler
 510  *
 511  * FIXME: the current do_floppy seems wouldn't be called after every
 512  * interrupt. I have no idea what's wrong with it.
 513  */
 514 void do_floppy(void)
 515 {
 516         //LOG("floppy_interrupt() called ...\n");
 517         times ++;
 518         //LOG("floppy interrupt %d times!\n",times);
 519         /* signal operation finished */
 520         done = TRUE;
 521         outb(0x20,0x20);  /* EOI */
 522 }
 523
 524 /*
 525  * OK, finally we got our last thing to do. You are right, that's it,
 526  * initialing the floppy. As you know, initialization is always easy,
 527  * just set the interrupt handler and mask off the bit of corresponding
 528  * interrupt.
 529  */
 530 void floppy_init(void)
 531 {
 532         set_trap_gate(0x26, floppy_interrupt);
 533         outb(inb_p(0x21)&~0x40,0x21);
 534 }
 535
 536 /* debug fd read */
 537 void Debug_rd(void)
 538 {
 539         char buf[512];
 540
 541         LOG("BUF addr: %p\n", buf);
 542
 543         floppy_read(70, buf);
 544         hexdump(buf, 128);
 545 }
 546
 547 /* debug fd write */
 548 void Debug(void)
 549 {
 550         char str[512 * 10] = "hello word! This is just a floppy writing test";
 551         char *buf = (char *)0x800000;
 552         memcpy(buf, str, sizeof(str));
 553
 554         LOG("STRING addr: %p\n", str);
 555
 556         floppy_write(0, str);
 557         floppy_writes(0, buf, 10);
 558         LOG("interrupts happens %d times\n", times);
 559 }