server/ide/ide.cpp

   1 /*
   2 lightOS server
   3 Copyright (C) 2006-2009 Jörg Pfähler
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18 */
  19 #include <libarch/ioport.hpp>
  20 #include <lightOS/lightOS.hpp>
  21 #include <iostream>
  22 #include "ide.hpp"
  23 using namespace lightOS;
  24 using namespace server;
  25 using namespace ide;
  26 using namespace std;
  27
  28 using libkernel::message;
  29
  30 #define DEVICE_ERROR(x) cerr << "ide[" << miController << ":" << (master_dev ? "0" : "1") << "]: " << x << endl;
  31
  32 #define CMD_NO_SECTOR_NUMBER 0
  33 #define CMD_SECTOR_NUMBER    1
  34 #define CMD_NO_SECTOR_COUNT  0
  35 #define CMD_SECTOR_COUNT     2
  36
  37 bool controller::is_present(uint16_t command_block_port,
  38                             uint16_t control_block_port)
  39 {
  40   // Select the master device
  41   libarch::out8(command_block_port + port_device_lba3, 0xA0);
  42
  43   // TODO: Delay
  44
  45   // Floating Bus
  46   if (libarch::in8(command_block_port + port_status) != 0xFF)
  47     return true;
  48
  49   // Select the master device
  50   libarch::out8(command_block_port + port_device_lba3, 0xA0 | (1 << 4));
  51
  52   // TODO: Delay
  53
  54   // Floating Bus
  55   if (libarch::in8(command_block_port + port_status) != 0xFF)
  56     return true;
  57   return false;
  58 }
  59
  60 bool controller::has_device(uint16_t command_block_port,
  61                             uint16_t control_block_port)
  62 {
  63   return check_device_presence(command_block_port, control_block_port, true) ||
  64          check_device_presence(command_block_port, control_block_port, false);
  65 }
  66
  67 controller::controller(size_t iController,
  68                        uint16_t command_block_port,
  69                        uint16_t control_block_port,
  70                        uint8_t irq)
  71   : miController(iController), mCommandBase(command_block_port), mControlBase(control_block_port), mIrq(irq)
  72 {
  73   // Request the IRQ line
  74   mIntVector = mPort.register_isa_irq(mIrq, 0);
  75
  76   // Enable interrupts
  77   libarch::out8(mControlBase + port_control, 0x00);
  78
  79   // Probe for a master device
  80   if (check_device_presence(mCommandBase,
  81                             mControlBase,
  82                             true) == true)
  83     mDevice[0] = unknown;
  84   else
  85     mDevice[0] = none;
  86
  87   // Probe for a slave device
  88   if (check_device_presence(mCommandBase,
  89                             mControlBase,
  90                             false) == true)
  91     mDevice[1] = unknown;
  92   else
  93     mDevice[1] = none;
  94 }
  95
  96 bool controller::init_devices()
  97 {
  98   // TODO Soft reset the devices
  99   /*if (software_reset(true) == false)
 100   {
 101     cerr << "ide[" << miController << ":0]: failed to reset the device" << endl;
 102     mDevice[0] = none;
 103   }*/
 104   /*if (software_reset(false) == false)
 105   {
 106     cerr << "ide[" << miController << ":1]: failed to reset the device" << endl;
 107     mDevice[1] = none;
 108   }*/
 109
 110   // Execute a NOP-Command
 111   // TODO: Remove
 112
 113   device_identification did;
 114   if (mDevice[0] == unknown)
 115     if (identify_device(true, did) == false)
 116       mDevice[0] = none;
 117   if (mDevice[1] == unknown)
 118     if (identify_device(false, did) == false)
 119       mDevice[1] = none;
 120   return true;
 121 }
 122
 123 void controller::loop()
 124 {
 125 }
 126
 127 bool controller::check_device_presence(uint16_t command_block_port,
 128                                        uint16_t control_block_port,
 129                                        bool master_dev)
 130 {
 131   // Select the device
 132   libarch::out8(command_block_port + port_device_lba3, 0xA0 | ((master_dev) ? 0 : (1 << 4)));
 133
 134   // TODO: Delay
 135
 136   // Put some values in the sector-count & the LBA0 register
 137   libarch::out8(command_block_port + port_sector_count, 0x55);
 138   libarch::out8(command_block_port + port_lba0, 0xAA);
 139
 140   // Read the values back
 141   uint8_t sectorCount = libarch::in8(command_block_port + port_sector_count);
 142   uint8_t sector = libarch::in8(command_block_port + port_lba0);
 143
 144   // Check for inconsistencies
 145   if (sectorCount != 0x55 || sector != 0xAA)
 146     return false;
 147   return true;
 148 }
 149
 150 // TODO: currently unused
 151
 152 void controller::select(bool master_dev)
 153 {
 154   // Set/Reset the DEV bit in the Device I/O register
 155   libarch::out8(mCommandBase + port_device_lba3, 0xA0 | (master_dev ? 0x00 : 0x10));
 156 }
 157
 158 bool controller::wait_status(uint8_t mask, uint8_t state)
 159 {
 160   while ((libarch::in8(mCommandBase + port_status) & mask) != state)
 161     ;
 162   return true;
 163 }
 164
 165 bool controller::wait_irq()
 166 {
 167   // TODO: multiple wait messages not yet supported by the kernel
 168   // Register timer
 169   mPort.register_event(libkernel::event::timer, 500);
 170   message irq(libkernel::message_port::kernel, libkernel::message::event, libkernel::event::irq, mIntVector);
 171   message msg(libkernel::message_port::kernel, libkernel::message::event, libkernel::event::timer);
 172
 173   // Wait for timer or irq
 174   mPort.wait(msg, irq);
 175   cout << msg.port() << ", " << msg.param1() << ", " << msg.param2() << ", " << msg.param3() << endl;
 176
 177   // timer elapsed first
 178   if (msg.param1() == libkernel::event::timer)
 179     return false;
 180
 181   // irq
 182   mPort.unregister_event(libkernel::event::timer);
 183   mPort.acknoledge_irq(mIntVector);
 184   return true;
 185 }
 186
 187 uint8_t controller::read_errors()
 188 {
 189   if ((libarch::in8(mCommandBase + port_status) & ERR_CHK) == 0)return 0;
 190   return libarch::in8(mCommandBase + port_error);
 191 }
 192
 193 // TODO: Does not work on other controllers than ide0
 194 bool controller::software_reset(bool master_dev)
 195 {
 196   select(master_dev);
 197
 198   // Set the SRST bit in the device control register
 199   libarch::out8(mControlBase + port_control, SRST);
 200
 201   // Wait for at least 5µs
 202   // NOTE: We wait for 1ms
 203   wait(1);
 204
 205   // Clear SRST bit in the device control register
 206   libarch::out8(mControlBase + port_control, 0x00);
 207
 208   // Wait for 2ms
 209   wait(2);
 210
 211   // Wait for BSY = 0
 212   if (wait_status(BSY, 0) == false)
 213     return false;
 214
 215   // Check the error register
 216   if ((libarch::in8(mControlBase + port_status) & ERR_CHK) == ERR_CHK)
 217   {
 218     DEVICE_ERROR("error register = 0x" << hex << static_cast<size_t>(libarch::in8(mControlBase + port_error)));
 219     return false;
 220   }
 221
 222   return true;
 223 }
 224
 225 bool controller::identify_device(bool master_dev,
 226                                  device_identification &id)
 227 {
 228   return command_pio_in(master_dev,
 229                         0xEC,
 230                         0,
 231                         0,
 232                         CMD_NO_SECTOR_COUNT | CMD_NO_SECTOR_NUMBER,
 233                         reinterpret_cast<void*>(&id));
 234 }
 235
 236 bool controller::identify_packet_device(bool master_dev,
 237                                         device_identification &id)
 238 {
 239   return command_pio_in(master_dev,
 240                         0xA1,
 241                         0,
 242                         0,
 243                         CMD_NO_SECTOR_COUNT | CMD_NO_SECTOR_NUMBER,
 244                         reinterpret_cast<void*>(&id));
 245 }
 246
 247
 248 bool controller::write_command(bool master_dev,
 249                                uint8_t command,
 250                                uint8_t sector_count,
 251                                uint64_t sector_number,
 252                                uint8_t flags)
 253 {
 254   // Wait for BSY = 0
 255   if (wait_status(BSY, 0) == false)
 256   {
 257     DEVICE_ERROR("device busy");
 258     return false;
 259   }
 260
 261   // Select the device
 262   select(master_dev);
 263
 264   // Wait 400ns
 265   // NOTE: We wait for 1ms
 266   wait(1);
 267
 268   // Write sector count/number & device/head register
 269   if ((flags & CMD_SECTOR_NUMBER) == CMD_SECTOR_NUMBER)
 270   {
 271     libarch::out8(mCommandBase + port_lba0, sector_number & 0xFF);
 272     libarch::out8(mCommandBase + port_lba1, (sector_number >> 8) & 0xFF);
 273     libarch::out8(mCommandBase + port_lba2, (sector_number >> 16) & 0xFF);
 274   }
 275   if ((flags & CMD_SECTOR_COUNT) == CMD_SECTOR_COUNT)
 276     libarch::out8(mCommandBase + port_sector_count, sector_count);
 277   if ((flags & CMD_SECTOR_NUMBER) == CMD_SECTOR_NUMBER)
 278     libarch::out8(mCommandBase + port_device_lba3, 0xE0 | (master_dev ? 0x00 : 0x10) | ((sector_number >> 24) & 0x0F));
 279
 280   // Write the command code
 281   libarch::out8(mCommandBase + port_command, command);
 282   return true;
 283 }
 284
 285 // TODO Does not, at least not with NOP on qemu
 286 bool controller::command_no_data(bool master_dev,
 287                                  uint8_t command,
 288                                  uint8_t sector_count,
 289                                  uint64_t sector_number,
 290                                  uint8_t flags)
 291 {
 292   if (write_command(master_dev,
 293                     command,
 294                     sector_count,
 295                     sector_number,
 296                     flags) == false)
 297     return false;
 298
 299   // Wait for interrupt
 300   if (wait_irq() == false)
 301   {
 302     DEVICE_ERROR("no interrupt");
 303     return false;
 304   }
 305
 306   // BSY = 0?
 307   if (wait_status(BSY, 0) == false)
 308   {
 309     DEVICE_ERROR("device still busy");
 310     return false;
 311   }
 312
 313   // Any errors?
 314   uint8_t errCode = read_errors();
 315   if (errCode != 0)
 316   {
 317     DEVICE_ERROR("error register = 0x" << static_cast<size_t>(errCode));
 318     return false;
 319   }
 320
 321   return true;
 322 }
 323
 324 bool controller::command_pio_in(bool master_dev,
 325                                 uint8_t command,
 326                                 uint8_t sector_count,
 327                                 uint64_t sector_number,
 328                                 uint8_t flags,
 329                                 void *data)
 330 {
 331   if (write_command(master_dev,
 332                     command,
 333                     sector_count,
 334                     sector_number,
 335                     flags) == false)
 336     return false;
 337
 338   cout << "HERE" << endl;
 339   // Wait for interrupt
 340   if (wait_irq() == false)
 341   {
 342     DEVICE_ERROR("no interrupt");
 343     return false;
 344   }
 345   cout << "THERE" << endl;
 346
 347   // BSY = 0?
 348   if (wait_status(BSY, 0) == false)
 349   {
 350     DEVICE_ERROR("device still busy");
 351     return false;
 352   }
 353
 354   // Any errors?
 355   uint8_t errCode = read_errors();
 356   if (errCode != 0)
 357   {
 358     DEVICE_ERROR("error register = 0x" << static_cast<size_t>(errCode));
 359     return false;
 360   }
 361
 362   return true;
 363 }
 364
 365 // TODO: command_PIO_in() chapter 11.5
 366 // TODO: command_PIO_out() chapter 11.6
 367 // TODO: command_packet() chapter 11.8
 368 // TODO: identify_device() chapter 6.17
 369 // TODO: identify_packet_decice() chapter 6.18
 370 // TODO: ata_read_sector() chapter 6.36
 371   // TODO: add LBA48 extension
 372 // TODO: ata_write_sector() sector 6.68
 373   // TODO: add LBA48 extension
 374
 375 /*ide::ide( unsigned short commandBase0,
 376       unsigned short commandBase1,
 377       unsigned short controlBase0,
 378       unsigned short controlBase1,
 379       unsigned char irq0,
 380       unsigned char irq1)
 381 {
 382   for (size_t i = 0;i < 4;i++)
 383   {
 384     if (mDevice[i] == unknown)
 385     {
 386       size_t ctrl = i / 2;
 387       unsigned short port = mCommandBase[ctrl];
 388       unsigned short port2 = mControlBase[ctrl];
 389
 390       // Software reset
 391       // TODO: some select_device function
 392       if ((i % 2) == 0)out8(port + reg_device_lba3, 0);
 393       else out8(port + reg_device_lba3, 1 << 4);
 394       out8(port2 + reg_control, 0x0E);
 395       //TODO: wait 400ns
 396       out8(port2 + reg_control, 0x08);
 397       //TODO: wait 400ns
 398
 399       if (waitBusy(i, false) == false)continue;
 400
 401       // No device present (master)?
 402       // TODO: select_device again
 403       if ((i % 2) == 0)out8(port + reg_device_lba3, 0);
 404       else out8(port + reg_device_lba3, 1 << 4);
 405       uint8_t sectorCount = in8(port + reg_sector_count);
 406       uint8_t sector = in8(port + reg_lba0);
 407       if (sectorCount == 0x01 && sector == 0x01)
 408       {
 409         unsigned char lba1 = in8(port + reg_lba1);
 410         unsigned char lba2 = in8(port + reg_lba2);
 411         unsigned char stat = in8(port + reg_status);
 412
 413         if (lba1 == 0x14 && lba2 == 0xEB)
 414         {
 415           cout << "ide[" << i << "]: atapi" << endl;
 416           mDevice[i] = atapi;
 417           executePIO(i, packet_identify, 0, 0, 512, reinterpret_cast<void*>(&mDeviceId[i]), true);
 418           cout << "ide[" << i << "]: 0x" << hex << mDeviceId[i].atapi.config << endl;
 419
 420           uint8_t Packet[12];
 421           uint8_t buffer[96];
 422           Packet[0] = 0x12;
 423           Packet[1] = 0;
 424           Packet[2] = 0;
 425           Packet[3] = 0;
 426           Packet[4] = 0;
 427           Packet[5] = 0;
 428
 429           executePACKET(i, 12, Packet, 96, buffer, true);
 430         }
 431         else if (lba1 == 0 && lba2 == 0 && stat != 0)
 432         {
 433           cout << "ide[" << i << "]: ata" << endl;
 434           mDevice[i] = ata;
 435           executePIO(i, identify, 0, 0, 512, reinterpret_cast<void*>(&mDeviceId[i]), true);
 436         }
 437       }
 438     }
 439   }
 440 }
 441 bool ide::getData(size_t device, unsigned short &buffer)
 442 {
 443   for (size_t i=0;i < timeout_data_ready;i++)
 444   {
 445     if ((in8(mControlBase[device / 2] + reg_alternative_status) & status_data_ready) == status_data_ready)
 446     {
 447       buffer = in16(mCommandBase[device / 2] + reg_data);
 448       return true;
 449     }
 450   }
 451   return false;
 452 }
 453 bool ide::sendData( size_t device,
 454           unsigned short buffer)
 455 {
 456   for (size_t i=0;i < timeout_data_ready;i++)
 457   {
 458     if ((in8(mControlBase[device / 2] + reg_alternative_status) & status_data_ready) == status_data_ready)
 459     {
 460       out16(mCommandBase[device / 2] + reg_data, buffer);
 461       return true;
 462     }
 463   }
 464   return false;
 465 }
 466 bool ide::executePIO( size_t device,
 467             command cmd,
 468             size_t count,
 469             size_t lba,
 470             size_t size,
 471             void *buffer,
 472             bool in)
 473 {
 474   //TODO: PIO out
 475   size_t ctrl = device / 2;
 476   unsigned short port = mCommandBase[ctrl];
 477   //unsigned short port2 = mControlBase[ctrl];
 478
 479   // BSY = 0?
 480   if (waitBusy(device, false) == false)
 481   {
 482     cout << "ide[" << device << "]: device busy" << endl;
 483     return false;
 484   }
 485
 486   // Write device/head register (DEV bit only)
 487   out8(port + reg_device_lba3, (device % 2) << 4);
 488
 489   //TODO: wait 400ns
 490
 491   // BSY = 0 && DRY = 1?
 492   if ((waitBusy(device, false) || waitReady(device, true)) == false)
 493   {
 494     cout << "ide[" << device << "]: device not ready" << endl;
 495     return false;
 496   }
 497
 498   // Write sector count/number & device/head register
 499   out8(port + reg_lba0, lba & 0xFF);
 500   out8(port + reg_lba1, (lba >> 8) & 0xFF);
 501   out8(port + reg_lba2, (lba >> 16) & 0xFF);
 502   out8(port + reg_sector_count, count);
 503   out8(port + reg_device_lba3, 0xE0 | ((device % 2) << 4) | ((lba >> 24) & 0x0F));
 504
 505   // Write the command code
 506   out8(port + reg_command, cmd);
 507
 508   // Wait for interrupt
 509   message irq(port::kernel, message::event, event::irq, mIrq[ctrl]);
 510   mPort[ctrl].wait(irq);
 511
 512   // Read status register (Negate INTRQ)
 513   if ((in8(port + reg_status) & status_error) == status_error)
 514   {
 515     cout << "ide[" << device << "]: error 0x" << hex << (unsigned int)in8(port + reg_error) << endl;
 516     // TODO: Inspect the errorcode
 517     return false;
 518   }
 519
 520   // Read the data (only if PIO in)
 521   if (in)
 522   {
 523     size_t i  = 0;
 524     for (;i < (size / 2);i++)
 525     {
 526       unsigned short data;
 527       if (getData(device, data) == false)
 528       {
 529         cout << "ide[" << device << "]: could not get the data (" << i << ")" << endl;
 530         return false;
 531       }
 532       reinterpret_cast<unsigned short*>(buffer)[i] = data;
 533     }
 534   }
 535   return true;
 536 }
 537 bool ide::executePACKET(size_t device,
 538             size_t packetsize,
 539             void *packet,
 540             size_t size,
 541             void *buffer,
 542             bool in)
 543 {
 544   //TODO: PIO out
 545   size_t ctrl = device / 2;
 546   unsigned short port = mCommandBase[ctrl];
 547
 548   // BSY = 0?
 549   if (waitBusy(device, false) == false)return false;
 550
 551   // Write device/head register (DEV bit only)
 552   out8(port + reg_device_lba3, (device % 2) << 4);
 553
 554   //TODO: wait 400ns
 555
 556   // BSY = 0 && DRY = 1?
 557   if ((waitBusy(device, false) || waitReady(device, true)) == false)return false;
 558
 559   // Write sector count/number & device/head register
 560   out8(port + reg_atapi_feature, 0); // Disable DMA & OVERLAP
 561   out8(port + reg_atapi_bytecount0, size & 0xFF);
 562   out8(port + reg_atapi_bytecount1, (size >> 8) & 0xFF);
 563   out8(port + reg_device_lba3, ((device % 2) << 4));
 564
 565   // Write the command code
 566   out8(port + reg_command, ide::packet);
 567
 568   // Wait for irq
 569   cout << "waiting" << endl;
 570   message irq(port::kernel, message::event, event::irq, mIrq[ctrl]);
 571   mPort[ctrl].wait(irq);
 572
 573   cout << "first irq fired" << endl;
 574
 575   // Negate INTRQ
 576   in8(port + reg_status);
 577
 578   // Send Packet
 579   for (size_t i=0;i < (packetsize / 2);i++)
 580   {
 581     unsigned short data;
 582     data = reinterpret_cast<unsigned short*>(packet)[i];
 583     if (sendData(device, data) == false)return false;
 584   }
 585
 586   //TODO: wait 400ns
 587
 588   if (size != 0)
 589   {
 590     // Wait for irq
 591     mPort[ctrl].wait(irq);
 592     cout << "second irq fired" << endl;
 593
 594     // Negate INTRQ
 595     in8(port + reg_status);
 596
 597     if (in)
 598     {
 599       //TODO: Read the number of bytes from the ATAPI register?
 600       for (size_t i=0;i < (size / 2);i++)
 601       {
 602         unsigned short data;
 603         if (getData(device, data) == false)return false;
 604         reinterpret_cast<unsigned short*>(buffer)[i] = data;
 605       }
 606     }
 607     else
 608     {
 609       //TODO: write data
 610     }
 611   }
 612
 613   // Wait for irq
 614   mPort[ctrl].wait(irq);
 615   cout << "third irq fired" << endl;
 616
 617   // Read status register (Negate INTRQ)
 618   if ((in8(port + reg_status) & status_error) == status_error)
 619   {
 620     //cout << "ide[" << device << "]: error 0x" << hex << (unsigned int)in8(mControlBase[ctrl] + reg_error) << endl;
 621     // TODO: Inspect the errorcode
 622     return false;
 623   }
 624
 625   return true;
 626 }
 627 bool ide::read( size_t device,
 628         size_t blocknumber,
 629         size_t blockcount,
 630         void *buffer)
 631 {
 632   if (mDevice[device] == ata)
 633   {
 634     return executePIO(device, read_sector, blockcount, blocknumber, blockcount * 512, buffer, true);
 635   }
 636   cerr << "ide: read not supported for this device type" << endl;
 637   return false;
 638 }
 639 ide::~ide()
 640 {
 641 }*/