Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/bd/ata_bd/ata_bd.c

    r029b13c raa893e0  
    5151#include <libarch/ddi.h>
    5252#include <ddi.h>
     53#include <ipc/ipc.h>
    5354#include <ipc/bd.h>
    5455#include <async.h>
     
    281282        sysarg_t method;
    282283        devmap_handle_t dh;
    283         unsigned int flags;
     284        int flags;
    284285        int retval;
    285286        uint64_t ba;
     
    297298
    298299        if (disk_id < 0 || disk[disk_id].present == false) {
    299                 async_answer_0(iid, EINVAL);
     300                ipc_answer_0(iid, EINVAL);
    300301                return;
    301302        }
    302303
    303304        /* Answer the IPC_M_CONNECT_ME_TO call. */
    304         async_answer_0(iid, EOK);
     305        ipc_answer_0(iid, EOK);
    305306
    306307        if (!async_share_out_receive(&callid, &comm_size, &flags)) {
    307                 async_answer_0(callid, EHANGUP);
     308                ipc_answer_0(callid, EHANGUP);
    308309                return;
    309310        }
     
    311312        fs_va = as_get_mappable_page(comm_size);
    312313        if (fs_va == NULL) {
    313                 async_answer_0(callid, EHANGUP);
     314                ipc_answer_0(callid, EHANGUP);
    314315                return;
    315316        }
     
    323324                case IPC_M_PHONE_HUNGUP:
    324325                        /* The other side has hung up. */
    325                         async_answer_0(callid, EOK);
     326                        ipc_answer_0(callid, EOK);
    326327                        return;
    327328                case BD_READ_BLOCKS:
     
    346347                        break;
    347348                case BD_GET_BLOCK_SIZE:
    348                         async_answer_1(callid, EOK, disk[disk_id].block_size);
     349                        ipc_answer_1(callid, EOK, disk[disk_id].block_size);
    349350                        continue;
    350351                case BD_GET_NUM_BLOCKS:
    351                         async_answer_2(callid, EOK, LOWER32(disk[disk_id].blocks),
     352                        ipc_answer_2(callid, EOK, LOWER32(disk[disk_id].blocks),
    352353                            UPPER32(disk[disk_id].blocks));
    353354                        continue;
     
    356357                        break;
    357358                }
    358                 async_answer_0(callid, retval);
     359                ipc_answer_0(callid, retval);
    359360        }
    360361}
     
    372373        uint16_t w;
    373374        uint8_t c;
    374         uint16_t bc;
    375375        size_t pos, len;
    376376        int rc;
     
    388388        } else if (rc == EIO) {
    389389                /*
    390                  * There is something, but not a register device. Check to see
    391                  * whether the IDENTIFY command left the packet signature in
    392                  * the registers in case this is a packet device.
    393                  *
    394                  * According to the ATA specification, the LBA low and
    395                  * interrupt reason registers should be set to 0x01. However,
    396                  * there are many devices that do not follow this and only set
    397                  * the byte count registers. So, only check these.
     390                 * There is something, but not a register device.
     391                 * It could be a packet device.
    398392                 */
    399                 bc = ((uint16_t)pio_read_8(&cmd->cylinder_high) << 8) |
    400                     pio_read_8(&cmd->cylinder_low);
    401 
    402                 if (bc == PDEV_SIGNATURE_BC) {
    403                         rc = identify_pkt_dev(disk_id, &idata);
    404                         if (rc == EOK) {
    405                                 /* We have a packet device. */
    406                                 d->dev_type = ata_pkt_dev;
    407                         } else {
    408                                 return EIO;
    409                         }
     393                rc = identify_pkt_dev(disk_id, &idata);
     394                if (rc == EOK) {
     395                        /* We have a packet device. */
     396                        d->dev_type = ata_pkt_dev;
    410397                } else {
    411398                        /* Nope. Something's there, but not recognized. */
     
    417404        }
    418405
     406        printf("device caps: 0x%04x\n", idata.caps);
    419407        if (d->dev_type == ata_pkt_dev) {
    420408                /* Packet device */
     
    579567
    580568        /*
    581          * Do not wait for DRDY to be set in case this is a packet device.
    582          * We determine whether the device is present by waiting for DRQ to be
    583          * set after issuing the command.
     569         * This is where we would most likely expect a non-existing device to
     570         * show up by not setting SR_DRDY.
    584571         */
    585         if (wait_status(0, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
     572        if (wait_status(SR_DRDY, ~SR_BSY, NULL, TIMEOUT_PROBE) != EOK)
    586573                return ETIMEOUT;
    587574
     
    591578                return ETIMEOUT;
    592579
    593         /*
    594          * If ERR is set, this may be a packet device, so return EIO to cause
    595          * the caller to check for one.
    596          */
     580        /* Read data from the disk buffer. */
     581
     582        if ((status & SR_DRQ) != 0) {
     583                for (i = 0; i < identify_data_size / 2; i++) {
     584                        data = pio_read_16(&cmd->data_port);
     585                        ((uint16_t *) buf)[i] = data;
     586                }
     587        }
     588
    597589        if ((status & SR_ERR) != 0) {
    598590                return EIO;
    599         }
    600 
    601         if (wait_status(SR_DRQ, ~SR_BSY, &status, TIMEOUT_PROBE) != EOK)
    602                 return ETIMEOUT;
    603 
    604         /* Read data from the disk buffer. */
    605 
    606         for (i = 0; i < identify_data_size / 2; i++) {
    607                 data = pio_read_16(&cmd->data_port);
    608                 ((uint16_t *) buf)[i] = data;
    609591        }
    610592
Note: See TracChangeset for help on using the changeset viewer.