kernel/drivers/block/drive.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2007  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   5  *  Copyright (C) 2009  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   6  *
   7  *  This program is free software: you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation, either version 3 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19  */
  20
  21
  22 #include <config.h>
  23 #include <build.h>
  24
  25 #ifdef ARCH_i386
  26
  27 #include <system.h>
  28 #include <mytypes.h>
  29 #include <partition.h>
  30 #include <dev.h>
  31 #include <vfs.h>
  32 #include <fs.h>
  33 #include <arch/io.h>
  34 #include <drive.h>
  35
  36 extern unsigned long timer_ticks;
  37
  38 static int drive_type (int port)
  39 {
  40         outb (0x70, port);
  41         unsigned char c = inb (0x71);
  42
  43         if (c == 255)
  44                 return DRIVE_TYPE_CDROM;
  45
  46         return DRIVE_TYPE_HDD;
  47 }
  48
  49 int lba28_drive_detect (int id)
  50 {
  51         int tmpword;
  52
  53         switch (id) {
  54                 case 0:
  55                         outb (0x1F6, 0xA0); // use 0xB0 instead of 0xA0 to test the second drive on the controller
  56
  57                         delay (200); // wait 1/250th of a second
  58
  59                         tmpword = inb (0x1F7); // read the status port
  60                         if (tmpword & 0x40) // see if the busy bit is set
  61                                 return 1;
  62
  63                         return 0;
  64                 case 1:
  65                         outb (0x1F6, 0xB0); // use 0xB0 instead of 0xA0 to test the second drive on the controller
  66
  67                         delay (200); // wait 1/250th of a second
  68
  69                         tmpword = inb (0x1F7); // read the status port
  70                         if (tmpword & 0x40) // see if the busy bit is set
  71                                 return 1;
  72
  73                         return 0;
  74                 case 2:
  75                         outb (0x176, 0xA0); // use 0xB0 instead of 0xA0 to test the second drive on the controller
  76
  77                         delay (200); // wait 1/250th of a second
  78
  79                         tmpword = inb (0x177); // read the status port
  80                         if (tmpword & 0x40) // see if the busy bit is set
  81                                 return 1;
  82
  83                         return 0;
  84                 case 3:
  85                         outb (0x176, 0xB0); // use 0xB0 instead of 0xA0 to test the second drive on the controller
  86
  87                         delay (200); // wait 1/250th of a second
  88
  89                         tmpword = inb (0x177); // read the status port
  90                         if (tmpword & 0x40) // see if the busy bit is set
  91                                 return 1;
  92
  93                         return 0;
  94         }
  95 }
  96
  97 /* check status of currently selected device */
  98 int ata_status (partition_t *p, int flag)
  99 {
 100         int status = inb (p->base_io + ATA_STATUS);
 101
 102         switch (flag) {
 103                 case LBA_FLAG_ERROR:
 104                         if(status & ATA_STATUS_ERR)
 105                                 return 1;
 106                         break;
 107                 case LBA_FLAG_BUSY:
 108                         if(status & ATA_STATUS_BUSY)
 109                                 return 1;
 110                         break;
 111                 case LBA_FLAG_DATA:
 112                         if(status & ATA_STATUS_DRQ)
 113                                 return 1;
 114                         break;
 115                 default:
 116                         break;
 117         }
 118
 119         return 0;
 120 }
 121
 122 int ata_wait (partition_t *p)
 123 {
 124         unsigned long stime = timer_ticks;
 125
 126         /* timeout for 5000ms */
 127         while ((stime+5000) > timer_ticks) {
 128                 if (!ata_status (p, LBA_FLAG_BUSY))
 129                         return 0;
 130
 131                 schedule ();
 132         }
 133
 134         return 1;
 135 }
 136
 137 int lba28_drive_read (partition_t *p, unsigned addr, unsigned char *buffer)
 138 {
 139         if (!p->base_io)
 140                 return 0;
 141
 142         outb (p->base_io + 1, 0x00);
 143         outb (p->base_io + 2, (unsigned char) 0x01);
 144         outb (p->base_io + 3, (unsigned) addr);
 145         outb (p->base_io + 4, (unsigned) (addr >> 8));
 146         outb (p->base_io + 5, (unsigned) (addr >> 16));
 147         outb (p->base_io + 6, 0xE0 | (p->id << 4) | ((addr >> 24) & 0x0F));
 148         outb (p->base_io + 7, 0x20);
 149
 150         if (ata_wait (p)) {
 151                 DPRINT (DBG_DRIVER | DBG_BLOCK, "lba28_drive_read: device is busy");
 152                 return 0;
 153         }
 154
 155         /*if (ata_status (p, LBA_FLAG_ERROR)) {
 156                 DPRINT (DBG_DRIVER | DBG_BLOCK, "lba28_drive_read: read error - device");
 157                 return 0;
 158         }*/
 159
 160         if (!ata_status (p, LBA_FLAG_DATA)) {
 161                 DPRINT (DBG_DRIVER | DBG_BLOCK, "lba28_drive_read: no data are available");
 162                 return 0;
 163         }
 164
 165         unsigned short tmpword;
 166         // for read:
 167         int idx;
 168         for (idx = 0; idx < 256; idx ++) {
 169                 tmpword = inw (p->base_io);
 170                 buffer[idx * 2] = (unsigned char)tmpword;
 171                 buffer[idx * 2 + 1] = (unsigned char) (tmpword >> 8);
 172         }
 173
 174         return 1;
 175 }
 176
 177 /* NOTE: this code is buggy, because you need everytime go from 0 to 256 indexes (512 bytes) */
 178 int lba28_drive_read_len (partition_t *p, unsigned addr, unsigned char *buffer, unsigned len)
 179 {
 180         outb (0x1F1, 0x00);
 181         outb (0x1F2, (unsigned char) 0x01);
 182         outb (0x1F3, (unsigned) addr);
 183         outb (0x1F4, (unsigned) (addr >> 8));
 184         outb (0x1F5, (unsigned) (addr >> 16));
 185         outb (0x1F6, 0xE0 | (p->id << 4) | ((addr >> 24) & 0x0F));
 186         outb (0x1F7, 0x20);
 187
 188         //usleep (1000);
 189
 190         while (!(inb (0x1F7) & 0x08))   // 0x08
 191                 schedule ();
 192
 193         unsigned short tmpword;
 194         // for read:
 195         int idx;
 196         int i;
 197         for (idx = 0; idx < len; idx ++) {
 198                 tmpword = inw (0x1F0);
 199                 i = (idx * 2);
 200
 201                 if (i < len)
 202                         buffer[i] = (unsigned char) tmpword;
 203                 if (i+1 < len)
 204                         buffer[i + 1] = (unsigned char) (tmpword >> 8);
 205         }
 206
 207         return 1;
 208 }
 209
 210 int lba28_drive_write (partition_t *p, unsigned addr, unsigned char *buffer)
 211 {
 212         if (!p->base_io)
 213                 return 0;
 214
 215         /* p->id = 0 for master device */
 216         outb (p->base_io + 1, 0x00);
 217         outb (p->base_io + 2, (unsigned char) 0x01);
 218         outb (p->base_io + 3, (unsigned) addr);
 219         outb (p->base_io + 4, (unsigned) (addr >> 8));
 220         outb (p->base_io + 5, (unsigned) (addr >> 16));
 221         outb (p->base_io + 6, 0xE0 | (p->id << 4) | ((addr >> 24) & 0x0F));
 222         outb (p->base_io + 7, 0x30);
 223
 224         unsigned long stime = timer_ticks;
 225
 226         if (ata_wait (p)) {
 227                 DPRINT (DBG_DRIVER | DBG_BLOCK, "lba28_drive_write: device is busy");
 228                 return 0;
 229         }
 230
 231         /*if (ata_status (p, LBA_FLAG_ERROR)) {
 232                 DPRINT (DBG_DRIVER | DBG_BLOCK, "lba28_drive_write: write error - device");
 233                 return 0;
 234         }*/
 235
 236         /*if (!ata_status (p, LBA_FLAG_DATA)) {
 237                 DPRINT (DBG_DRIVER | DBG_BLOCK, "lba28_drive_write: no data are available");
 238                 return 0;
 239         }*/
 240
 241         unsigned short tmpword;
 242         // for write:
 243         int idx;
 244         for (idx = 0; idx < 256; idx ++) {
 245                 tmpword = buffer[idx * 2] | (buffer[idx * 2 + 1] << 8);
 246                 outw (p->base_io, tmpword);
 247         }
 248
 249         return 1;
 250 }
 251
 252 /* NOTE: this code is buggy, because you need everytime go from 0 to 256 indexes (512 bytes) */
 253 int lba28_drive_write_len (partition_t *p, unsigned addr, unsigned char *buffer, unsigned len)
 254 {
 255         outb (0x1F1, 0x00);
 256         outb (0x1F2, (unsigned char) 0x01);
 257         outb (0x1F3, (unsigned) addr);
 258         outb (0x1F4, (unsigned char) (addr >> 8));
 259         outb (0x1F5, (unsigned char) (addr >> 16));
 260         outb (0x1F6, 0xE0 | (p->id << 4) | ((addr >> 24) & 0x0F));
 261         outb (0x1F7, 0x30);
 262
 263         while (!(inb (0x1F7) & 0x08))
 264                 schedule ();
 265
 266         unsigned short tmpword;
 267         unsigned short l = 0;
 268         unsigned short h = 0;
 269         // for write:
 270
 271         int idx;
 272         for (idx = 0; idx < 256; idx ++) {
 273                 l = 0;
 274                 h = 0;
 275
 276                 if ((idx*2) < len)
 277                         l = buffer[idx * 2];
 278
 279                 if ((idx*2+1) < len)
 280                         h = (buffer[idx * 2 + 1] << 8);
 281
 282                 tmpword = l | h;
 283                 outw (0x1F0, tmpword);
 284         }
 285
 286         return 1;
 287 }
 288
 289 int lba28_drive_write_spec (partition_t *p, unsigned addr, unsigned char *buffer, unsigned len, unsigned offset)
 290 {
 291         outb (0x1F1, 0x00);
 292         outb (0x1F2, (unsigned char) 0x01);
 293         outb (0x1F3, (unsigned) addr);
 294         outb (0x1F4, (unsigned char) (addr >> 8));
 295         outb (0x1F5, (unsigned char) (addr >> 16));
 296         outb (0x1F6, 0xE0 | (p->id << 4) | ((addr >> 24) & 0x0F));
 297         outb (0x1F7, 0x30);
 298
 299         while (!(inb (0x1F7) & 0x08))
 300                 schedule ();
 301
 302         unsigned short tmpword;
 303         unsigned short l = 0;
 304         unsigned short h = 0;
 305         // for write:
 306
 307         int idx;
 308         int i = 0;
 309         for (idx = 0; idx < 256; idx ++) {
 310                 l = 0;
 311                 h = 0 << 8;
 312                 i = (idx*2);
 313
 314                 if (i >= offset)
 315                         if (i < len+offset)
 316                                 l = buffer[i-offset];
 317
 318                 if ((i+1) >= offset)
 319                         if ((i+1) < len+offset)
 320                                 h = buffer[i-offset+1] << 8;
 321
 322
 323                 tmpword = l | h;
 324                 outw (0x1F0, tmpword);
 325         }
 326
 327         return 1;
 328 }
 329
 330 int lba48_drive_write (partition_t *p, unsigned long long addr, unsigned char *buffer)
 331 {
 332         outb (0x1F1, 0x00);
 333         outb (0x1F1, 0x00);
 334
 335         outb (0x1F2, 0x00);
 336         outb (0x1F2, 0x01);
 337
 338         outb (0x1F3, (unsigned char) (addr >> 24));
 339         outb (0x1F3, (unsigned char) addr);
 340         outb (0x1F4, (unsigned char) (addr >> 32));
 341         outb (0x1F4, (unsigned char) (addr >> 8));
 342         outb (0x1F5, (unsigned char) (addr >> 40));
 343         outb (0x1F5, (unsigned char) (addr >> 16));
 344
 345         outb (0x1F6, 0x40 | (p->id << 4));
 346
 347         outb (0x1F7, 0x34);
 348
 349         while (!(inb (0x1F7) & 0x08))   // 0x08
 350                 schedule ();
 351
 352         unsigned short tmpword;
 353         // for write:
 354         int idx;
 355         for (idx = 0; idx < 256; idx ++) {
 356                 tmpword = buffer[idx * 2] | (buffer[idx * 2 + 1] << 8);
 357                 outw (0x1F0, tmpword);
 358         }
 359
 360         return 1;
 361 }
 362
 363 bool ide_acthandler (unsigned act, partition_t *p, char *block, char *more, int n)
 364 {
 365         switch (act) {
 366                 case DEV_ACT_INIT:
 367                 {
 368                         return 1;
 369                 }
 370                 break;
 371                 case DEV_ACT_READ:
 372                 {
 373                         return (bool) lba28_drive_read (p, n, block);
 374                 }
 375                 break;
 376                 case DEV_ACT_WRITE:
 377                 {
 378                         return (bool) lba28_drive_write (p, n, block);
 379                 }
 380                 break;
 381                 case DEV_ACT_MOUNT:
 382                 {
 383                         //fs_t *fs = fs_detect (p);
 384                         int f = 0, t = 0;
 385
 386                         curr_part = p;
 387
 388                         unsigned l = strlen (more);
 389
 390                         if (!l)
 391                                 if (!p->fs->handler (FS_ACT_CHDIR, more, -1, 0))
 392                                         return 0;
 393                         /*
 394                         unsigned x = 0;
 395                         while (dir[x].name[0] != '\0') {
 396                                 printf ("slozka: '%s'\n", dir[x].name);
 397                                 x ++;
 398                         }*/
 399
 400                         if (l) {
 401                                 if (!strcmp (more, "."))
 402                                         return p->fs->handler (FS_ACT_CHDIR, more, 0, l);
 403
 404                                 if (!strcmp (more, ".."))
 405                                         return p->fs->handler (FS_ACT_CHDIR, more, 1, l);
 406
 407                                 while (strlen (dir[f].name)) {
 408                                         //printf ("drive__: '%s' : %d | '%s'\n", dir[f].name, f, more);
 409                                         if (!strncmp (dir[f].name, more, l)) {
 410                                                 if (!p->fs->handler (FS_ACT_CHDIR, more, f, l))
 411                                                         return 0;
 412
 413                                                 t = 1;
 414                                                 break;
 415                                         }
 416
 417                                         f ++;
 418                                 }
 419
 420                                 if (!t)
 421                                         return 0;
 422                         }
 423
 424                         f = 0;
 425                         unsigned fl = strlen (dir[f].name);
 426
 427                          while (fl) {
 428                                 unsigned attrib = VFS_FILEATTR_MOUNTED;
 429
 430                                 /*unsigned x = fl;
 431                                 while (x) {
 432                                         if (dir[f].name[x] != ' ')
 433
 434                                         x --;
 435                                 }*/
 436 /*
 437                                 #define VFS_FILEATTR_FILE       0x1
 438                                 #define VFS_FILEATTR_DIR        0x2
 439                                 #define VFS_FILEATTR_HIDDEN     0x4
 440                                 #define VFS_FILEATTR_SYSTEM     0x8
 441                                 #define VFS_FILEATTR_BIN        0x10
 442                                 #define VFS_FILEATTR_READ       0x20
 443                                 #define VFS_FILEATTR_WRITE      0x40
 444
 445                                 case 0: dir[y].read=1; break;
 446                                 case 1: dir[y].hidden=1; break;
 447                                 case 2: dir[y].system=1; break;
 448                                 case 3: dir[y].volume=1; break;
 449                                 case 4: dir[y].dir=1; break;
 450                                 case 5: dir[y].bin=1; break;
 451 */
 452
 453                                 if (dir[f].read) {
 454                                         attrib |= VFS_FILEATTR_READ;
 455                                         attrib |= VFS_FILEATTR_WRITE;
 456                                 }
 457                                 if (dir[f].hidden)
 458                                         attrib |= VFS_FILEATTR_HIDDEN;
 459                                 if (dir[f].system)
 460                                         attrib |= VFS_FILEATTR_SYSTEM;
 461                                 if (dir[f].dir)
 462                                         attrib |= VFS_FILEATTR_DIR;
 463                                 else
 464                                         attrib |= VFS_FILEATTR_FILE;
 465                                 if (dir[f].bin)
 466                                         attrib |= VFS_FILEATTR_BIN;
 467
 468                                         int i = 10;
 469                                         while (i) {
 470                                                 if (dir[f].name[i] == ' ')
 471                                                         dir[f].name[i] = '\0';
 472                                                 else
 473                                                         break;
 474
 475                                                 i --;
 476                                         }
 477
 478                                 vfs_list_add (dir[f].name, attrib, block);
 479 /*
 480         dir[y].read=0;
 481         dir[y].hidden=0;
 482         dir[y].system=0;
 483         dir[y].volume=0;
 484         dir[y].dir=0;
 485         dir[y].bin=0;
 486 */
 487
 488                                 //printf ("add: %s to %s | %d%d%d%d%d\n", dir[f].name, block, dir[f].read, dir[f].hidden, dir[f].system, dir[f].volume, dir[f].dir, dir[f].bin);
 489
 490                                 f ++;
 491                                 fl = strlen (dir[f].name);
 492                         }
 493
 494                         return 1;
 495                 }
 496                 break;
 497                 case DEV_ACT_UMOUNT:
 498                 {
 499                         if (!p->fs->handler (FS_ACT_EXIT, more, -1, 0))
 500                                 return 0;
 501
 502                         return 1;
 503                 }
 504         }
 505
 506         return 0;
 507 }
 508
 509 bool ata_acthandler (unsigned act, char drive, char *block)
 510 {
 511         switch (act) {
 512                 case DEV_ACT_INIT:
 513                 {
 514                         if (kernel_attr & KERNEL_NOATA)
 515                                 return 0;
 516
 517                         int res = 0;
 518
 519                         if (lba28_drive_detect (0)) {
 520                                 /* when it's hdd, check partition table, else pre-set isofs on cdrom drive */
 521                                 int type = drive_type (0x1b);
 522
 523                                 dev_t *dev = (dev_t *) dev_register (type == DRIVE_TYPE_CDROM ? "cda" : "hda",
 524                                                                      "Drive controller", DEV_ATTR_BLOCK, (dev_handler_t *) &ide_acthandler);
 525
 526                                 if (type == DRIVE_TYPE_HDD)
 527                                         partition_table (dev);
 528                                 else if (type == DRIVE_TYPE_CDROM)
 529                                         partition_add (dev, fs_supported ("isofs"), 0);
 530
 531                                 res ++;
 532                         }
 533
 534                         if (lba28_drive_detect (1)) {
 535                                 /* when it's hdd, check partition table, else pre-set isofs on cdrom drive */
 536                                 int type = drive_type (0x24+9);
 537
 538                                 dev_t *dev = (dev_t *) dev_register (type == DRIVE_TYPE_CDROM ? "cdb" : "hdb",
 539                                                                      "Drive controller", DEV_ATTR_BLOCK, (dev_handler_t *) &ide_acthandler);
 540
 541                                 if (type == DRIVE_TYPE_HDD)
 542                                         partition_table (dev);
 543                                 else if (type == DRIVE_TYPE_CDROM)
 544                                         partition_add (dev, fs_supported ("isofs"), 0);
 545
 546                                 res ++;
 547                         }
 548
 549                         if (lba28_drive_detect (2)) {
 550                                 /* when it's hdd, check partition table, else pre-set isofs on cdrom drive */
 551                                 int type = drive_type (0x24);
 552
 553                                 dev_t *dev = (dev_t *) dev_register (type == DRIVE_TYPE_CDROM ? "cdc" : "hdc",
 554                                                                      "Drive controller", DEV_ATTR_BLOCK, (dev_handler_t *) &ide_acthandler);
 555
 556                                 if (type == DRIVE_TYPE_HDD)
 557                                         partition_table (dev);
 558                                 else if (type == DRIVE_TYPE_CDROM)
 559                                         partition_add (dev, fs_supported ("isofs"), 0);
 560
 561                                 res ++;
 562                         }
 563
 564                         if (lba28_drive_detect (3)) {
 565                                 /* when it's hdd, check partition table, else pre-set isofs on cdrom drive */
 566                                 int type = drive_type (0x24+18);
 567
 568                                 dev_t *dev = (dev_t *) dev_register (type == DRIVE_TYPE_CDROM ? "cdd" : "hdd",
 569                                                                      "Drive controller", DEV_ATTR_BLOCK, (dev_handler_t *) &ide_acthandler);
 570
 571                                 if (type == DRIVE_TYPE_HDD)
 572                                         partition_table (dev);
 573                                 else if (type == DRIVE_TYPE_CDROM)
 574                                         partition_add (dev, fs_supported ("isofs"), 0);
 575
 576                                 res ++;
 577                         }
 578
 579                         return res;
 580                 }
 581                 break;
 582                 /*case DEV_ACT_READ:
 583                 {
 584                         lba28_drive_read (drive, 0x01, n, block);
 585                         return 1;
 586                 }
 587                 break;
 588                 case DEV_ACT_WRITE:
 589                 {
 590                         lba28_drive_write (drive, 0x01, n, block);
 591                         return 1;
 592                 }*/
 593         }
 594
 595         return 0;
 596 }
 597 #endif