path: root/c/src/libchip/ide/ata.c

/*
 * ata.c
 *
 * ATA RTEMS driver. ATA driver is hardware independant implementation of 
 * ATA-2 standart, working draft X3T10/0948D, revision 4c. ATA driver bases 
 * on RTEMS IDE controller driver.
 *
 * Copyright (C) 2001 OKTET Ltd., St.-Petersburg, Russia
 * Authors: Eugeny S. Mints <Eugeny.Mints@oktet.ru>
 *
 * The license and distribution terms for this file may be
 * found in the file LICENSE in this distribution or at
 * http://www.rtems.com/license/LICENSE.
 * 
 * $Id$
 * 
 */
#include <errno.h>
#include <rtems/chain.h>
#include <assert.h>
#include <string.h> /* for "memset" declaration */

#include <rtems/diskdevs.h>
#include <rtems/blkdev.h>
#include <libchip/ide_ctrl_io.h>
#include <libchip/ide_ctrl_cfg.h>
#include "ata_internal.h"
#include <libchip/ata.h>

#define DEBUG

#ifdef DEBUG
#include <stdio.h>
#endif

#define SAFE
#ifdef SAFE
typedef rtems_mode preemption_key;

#define DISABLE_PREEMPTION(key) \
    do {                                                               \
        rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &(key)); \
    } while (0)

#define ENABLE_PREEMPTION(key) \
    do {                                                        \
        rtems_mode temp;                                        \
        rtems_task_mode((key), RTEMS_PREEMPT_MASK, &temp);      \
    } while (0)

#else
 
typedef boolean preemption_key;

#define DISABLE_PREEMPTION(key) \
    do {                                             \
        (key) = _Thread_Executing->is_preemptible;   \
        _Thread_Executing->is_preemptible = 0;       \
    } while (0)
    
#define ENABLE_PREEMPTION(key) \
    do {                                             \
        _Thread_Executing->is_preemptible = (key);   \
        if (_Thread_Evaluate_mode())                 \
            _Thread_Dispatch();                      \
    } while (0)

#endif

/* FIXME: case if ATA device is FLASH device need more attention */
#undef ATA_DEV_IS_FLASH_DISK

/* Block device request with a single buffer provided */
typedef struct blkdev_request1 {
    blkdev_request   req;
    blkdev_sg_buffer sg[1];
} blkdev_request1;


/* Array indexed by controllers minor number */
static ata_ide_ctrl_t ata_ide_ctrls[IDE_CTRL_MAX_MINOR_NUMBER];

/*
 * Mapping from ATA-minor numbers to 
 * controller-minor and device on this controller.
 */
static ata_ide_dev_t ata_devs[2 * IDE_CTRL_MAX_MINOR_NUMBER];
static int ata_devs_number;

/* Flag meaning that ATA driver has already been initialized */
static rtems_boolean ata_initialized = FALSE;


/* task and queue used for asynchronous I/O operations */
static rtems_id ata_task_id;
static rtems_id ata_queue_id;

/* Mapping of interrupt vectors to devices */
static Chain_Control ata_int_vec[ATA_MAX_RTEMS_INT_VEC_NUMBER + 1];  

static void
ata_process_request(rtems_device_minor_number ctrl_minor);

static void
ata_process_request_on_init_phase(rtems_device_minor_number  ctrl_minor,
                                  ata_req_t                 *areq);

static void 
ata_add_to_controller_queue(rtems_device_minor_number  ctrl_minor, 
                            ata_req_t                 *areq);

/*
 * read/write, open/close and ioctl are provided by general block device 
 * driver. Only initialization and ata-specific ioctl are here.
 */

/* ata_io_data_request -- 
 *     Form read/write request for an ATA device and enqueue it to 
 *     IDE controller. 
 * 
 * PARAMETERS:
 *     device - device identifier
 *     req    - read/write request from block device driver
 *
 * RETURNS:
 *     RTEMS_SUCCESSFUL on success, or error code if
 *     error occured 
 */
static rtems_status_code
ata_io_data_request(dev_t device, blkdev_request *req)
{
    ata_req_t                 *areq; /* ATA request */
    rtems_device_minor_number  rel_minor; /* relative minor which indexes 
                                           * ata_devs array
                                           */
    rtems_device_minor_number  ctrl_minor;
    uint8_t                    dev;
    
    rel_minor = (rtems_filesystem_dev_minor_t(device)) / 
                ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;
    
    /* get controller which serves the ATA device */
    ctrl_minor = ata_devs[rel_minor].ctrl_minor;

    /* get ATA device identifier (0 or 1) */
    dev = ata_devs[rel_minor].device;

    areq = malloc(sizeof(ata_req_t));
    if (areq == NULL)
    {
        return RTEMS_NO_MEMORY;
    }
                                                            
    areq->breq = req;
    areq->cnt = req->count;
    areq->cbuf = 0;
    areq->pos = 0;
    
    /* set up registers masks */   
    areq->regs.to_write = ATA_REGISTERS_POSITION;
    areq->regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_STATUS);
    
    /* choose device on the controller for which the command will be issued */
    areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] = 
                                    (dev << IDE_REGISTER_DEVICE_HEAD_DEV_POS);

    /* Find ATA command and its type */
    if (ATA_DEV_INFO(ctrl_minor, dev).mode_active & ATA_MODES_DMA)
    {
        /* XXX: never has been tested */
        areq->type = ATA_COMMAND_TYPE_DMA;
        if (req->req == BLKDEV_REQ_READ)
            areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_READ_DMA;
        else 
            areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_WRITE_DMA;
    }
    else 
    {
        if (req->req == BLKDEV_REQ_READ)
        {
            areq->type = ATA_COMMAND_TYPE_PIO_IN;
              
            /* 
             * choose command to issue: if the number of blocks to be 
             * exchanged is greater then 1 and for ATA command READ MULTIPLE
             * data block consists of more then 1 sector choose READ MULTIPLE
             * otherwise READ SECTORS
             */
            areq->regs.regs[IDE_REGISTER_COMMAND] = 
                ((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) && 
                 (req->count > 1) && 
                 (ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ? 
                 ATA_COMMAND_READ_MULTIPLE : 
                 ATA_COMMAND_READ_SECTORS;
        }
        else
        {
            areq->type = ATA_COMMAND_TYPE_PIO_OUT;

            /* 
             * choose command to issue: if the number of blocks to be 
             * exchanged is greater then 1 and for ATA command WRITE MULTIPLE
             * data block consists of more then 1 sector choose WRITE MULTIPLE
             * otherwise WRITE SECTORS
             */
            areq->regs.regs[IDE_REGISTER_COMMAND] = 
              ((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) &&
               (req->count > 1) &&
               (ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ? 
               ATA_COMMAND_WRITE_MULTIPLE : 
               ATA_COMMAND_WRITE_SECTORS;
        }
    }

    /*
     * Fill position registers
     */
    if (ATA_DEV_INFO(ctrl_minor, dev).lba_avaible)
    {
        areq->regs.regs[IDE_REGISTER_LBA0] = (uint8_t)req->start;
        areq->regs.regs[IDE_REGISTER_LBA1] = (uint8_t)(req->start >> 8);
        areq->regs.regs[IDE_REGISTER_LBA2] = (uint8_t)(req->start >> 16);
        areq->regs.regs[IDE_REGISTER_LBA3] |= (uint8_t) (req->start >> 24);
        areq->regs.regs[IDE_REGISTER_LBA3] |= IDE_REGISTER_LBA3_L;
    }
    else
    {
        uint32_t   count = req->start;

        areq->regs.regs[IDE_REGISTER_SECTOR_NUMBER] =
                        (count % ATA_DEV_INFO(ctrl_minor, dev).sectors) + 1;

        /* now count = number of tracks: */
        count /= ATA_DEV_INFO(ctrl_minor, dev).sectors;
        areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] |= 
                          (count / ATA_DEV_INFO(ctrl_minor, dev).cylinders);

        /* now count = number of cylinders */
        count %= ATA_DEV_INFO(ctrl_minor, dev).cylinders;
        areq->regs.regs[IDE_REGISTER_CYLINDER_LOW] = (uint8_t)count;
        areq->regs.regs[IDE_REGISTER_CYLINDER_HIGH] = (uint8_t)(count >> 8);
        areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &= 
                                                ~IDE_REGISTER_DEVICE_HEAD_L;
    }

    /* fill sector count register */
    areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] = areq->breq->count;
    
    /* add request to the queue of awaiting requests to the controller */
    ata_add_to_controller_queue(ctrl_minor, areq);
 
    return RTEMS_SUCCESSFUL;
}

/* ata_non_data_request -- 
 *     Form and serve request of NON DATA type for an ATA device. 
 *     Processing of NON DATA request is SYNChronous operation.
 * 
 * PARAMETERS:
 *     device - device identifier
 *     cmd    - command
 *     argp   - arguments for command
 *
 * RETURNS:
 *     RTEMS_SUCCESSFUL on success, or error code if
 *     error occured 
 */
static rtems_status_code
ata_non_data_request(dev_t device, int cmd, void *argp)
{
    rtems_status_code          rc;
    ata_req_t                 *areq;       /* ATA request */
    rtems_device_minor_number  rel_minor; /* relative minor which indexes
                                           * ata_devs array
                                           */
    rtems_device_minor_number  ctrl_minor;
    uint8_t                    dev;
    ata_queue_msg_t            msg;    
    
    rel_minor = (rtems_filesystem_dev_minor_t(device)) /
                ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE; 

    /* get controller which serves the ATA device */
    ctrl_minor = ata_devs[rel_minor].ctrl_minor;

    /* get ATA device identifier (0 or 1) */
    dev = ata_devs[rel_minor].device;

    /* form the request */
    areq = malloc(sizeof(ata_req_t));
    if (areq == NULL)
    {
        return RTEMS_NO_MEMORY;
    }
    memset(areq, 0, sizeof(ata_req_t));    

    areq->type = ATA_COMMAND_TYPE_NON_DATA;
    areq->regs.to_write = ATA_REGISTERS_VALUE(IDE_REGISTER_COMMAND);
    areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] |= 
                                    (dev << IDE_REGISTER_DEVICE_HEAD_DEV_POS);
    areq->breq = NULL;
    areq->regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_ERROR);
    
    /* 
     * depending on command fill command register and additional registers 
     * which are needed for command execution
     */
    switch(cmd)
    { 
        case ATAIO_SET_MULTIPLE_MODE:
            areq->regs.regs[IDE_REGISTER_COMMAND] = 
                                                ATA_COMMAND_SET_MULTIPLE_MODE;
            areq->regs.to_write |= 
                               ATA_REGISTERS_VALUE(IDE_REGISTER_SECTOR_COUNT);
            areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] = *(uint8_t*)argp;
            break;
        
        default:
            free(areq);
            return RTEMS_INVALID_NUMBER;
            break;                                
    }  

    rc = rtems_semaphore_create(rtems_build_name('I', 'D', 'E', 'S'), 
                                0, 
                                RTEMS_FIFO | RTEMS_COUNTING_SEMAPHORE | 
                                RTEMS_NO_INHERIT_PRIORITY |
                                RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
                                0,
                                &(areq->sema));
    if (rc != RTEMS_SUCCESSFUL)
    {
        free(areq);
        return rc;
    }                                 
                                        
    ata_add_to_controller_queue(ctrl_minor, areq);
    
    /* wait for request processing... */
    rc = rtems_semaphore_obtain(areq->sema, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
    if (rc != RTEMS_SUCCESSFUL)
    {
        free(areq);
        return rc;
    }                                 

    rtems_semaphore_delete(areq->sema);
    
    /* 
     * if no error occurred and if necessary, update internal ata driver data 
     * structures to reflect changes (in device configuration, for example)
     */ 
    if (areq->status == RTEMS_SUCCESSFUL)
    {
        switch(cmd)
        { 
            case ATAIO_SET_MULTIPLE_MODE:
                ATA_DEV_INFO(ctrl_minor, dev).current_multiple = 
                                                           *(uint8_t*)argp;
                break;
        
            default:
                rc = RTEMS_INVALID_NUMBER;
                break;                                
        }  
    }    
    else    
    {    
        /* XXX: should be correct error processing: for ex, may be 
         * ABRT and then we should return RTEMS_NOT_IMPLEMENTED
         */
        rc = RTEMS_IO_ERROR;
    }    
    
    /* tell ata driver that controller ready to serve next request */
    ATA_SEND_EVT(msg, ATA_MSG_SUCCESS_EVT, ctrl_minor, 0);
                                                 
    return rc;
}

/* ata_process_request -- 
 *     Get first request from controller's queue and process it. 
 * 
 * PARAMETERS:
 *     ctrl_minor - controller identifier
 *
 * RETURNS:
 *     NONE 
 */
static void
ata_process_request(rtems_device_minor_number ctrl_minor)
{
    ata_req_t       *areq;
    uint16_t         byte; /* emphasize that only 8 low bits is meaningful */
    ata_queue_msg_t  msg;
    uint8_t          i, dev;
    uint16_t         val;
    uint16_t         data_bs; /* the number of 512-bytes sectors in one 
                               * data block 
                               */
    ISR_Level        level;                           
        
    /* if no requests to controller then do nothing */
    if (Chain_Is_empty(&ata_ide_ctrls[ctrl_minor].reqs))
        return;

    /* get first request in the controller's queue */
    _ISR_Disable(level);
    areq = (ata_req_t *)(ata_ide_ctrls[ctrl_minor].reqs.first);
    _ISR_Enable(level);
    
    /* get ATA device identifier (0 or 1) */
    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & 
           IDE_REGISTER_DEVICE_HEAD_DEV;

    /* get data block size */
    data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?  
              ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;      
    
    /* execute device select protocol */
    ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD, 
                                  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]);
    
    do {
        ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &byte);
    } while ((byte & IDE_REGISTER_STATUS_BSY) || 
             (!(byte & IDE_REGISTER_STATUS_DRDY)));

    /* fill in all  necessary registers on the controller */
    for (i=0; i< ATA_MAX_CMD_REG_OFFSET; i++)
    {
        uint32_t   reg = (1 << i);
        if (areq->regs.to_write & reg)
            ide_controller_write_register(ctrl_minor, i, areq->regs.regs[i]);
    }

    /* continue to execute ATA protocols depending on type of request */
    if (areq->type == ATA_COMMAND_TYPE_PIO_OUT)
    {
        do {
            ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, 
                                         &byte);
        } while (byte & IDE_REGISTER_STATUS_BSY);

        if (byte & IDE_REGISTER_STATUS_DRQ)
        {
            ide_controller_write_data_block(
                ctrl_minor, 
                MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE,
                areq->breq->bufs, &areq->cbuf,
                &areq->pos);
            areq->cnt -= MIN(data_bs, areq->cnt);
        }    
        else
        {    
            if (IDE_Controller_Table[ctrl_minor].int_driven == 0)
            {
                ide_controller_read_register(
                    ctrl_minor, 
                    IDE_REGISTER_ALTERNATE_STATUS_OFFSET,
                    &val);
                ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
                                             &val);

                ATA_SEND_EVT(msg, ATA_MSG_ERROR_EVT, ctrl_minor, 
                             RTEMS_IO_ERROR);
            }
        }    
    }

    if (IDE_Controller_Table[ctrl_minor].int_driven == 0)
    {
        do {
            ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, 
                                         &byte);
        } while (byte & IDE_REGISTER_STATUS_BSY);
        
        ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, ctrl_minor, 0);
    }    
}

/* ata_request_done -- 
 *     Extract request from controller queue, execute callback if necessary
 *     and process next request for the controller.
 * 
 * PARAMETERS:
 *     areq       - ATA request 
 *     ctrl_minor - controller identifier
 *     status     - status with which request has been done
 *     error      - error, if status != RTEMS_SUCCESSFUL
 *
 * RETURNS:
 *     NONE
 */
static inline void
ata_request_done(ata_req_t *areq, rtems_device_minor_number ctrl_minor,
                 rtems_status_code status, int error)
{
    preemption_key key;

    assert(areq);

    DISABLE_PREEMPTION(key);
    ATA_EXEC_CALLBACK(areq, status, error);
    Chain_Extract(&areq->link);
    free(areq);

    if (!Chain_Is_empty(&ata_ide_ctrls[ctrl_minor].reqs))
    {
        ENABLE_PREEMPTION(key);
        ata_process_request(ctrl_minor);
        return;
    }
    ENABLE_PREEMPTION(key); 
}

/* ata_non_data_request_done -- 
 *     Set up request status and release request's semaphore.
 * 
 * PARAMETERS:
 *     areq       - ATA request 
 *     ctrl_minor - controller identifier
 *     status     - status with which request has been done
 *     error      - error, if status != RTEMS_SUCCESSFUL
 *
 * RETURNS:
 *     NONE
 */
static inline void
ata_non_data_request_done(ata_req_t *areq, 
                          rtems_device_minor_number ctrl_minor,
                          rtems_status_code status, int error)
{
    areq->status = status;
    areq->error = error;
    rtems_semaphore_release(areq->sema);
}


/* ata_add_to_controller_queue -- 
 *     Add request to the controller's queue.
 * 
 * PARAMETERS:
 *     ctrl_minor - controller identifier
 *     areq       - ATA request 
 *
 * RETURNS:
 *     NONE
 */
static void
ata_add_to_controller_queue(rtems_device_minor_number  ctrl_minor, 
                            ata_req_t                 *areq)
{
    Chain_Append(&ata_ide_ctrls[ctrl_minor].reqs, &areq->link);
    if (Chain_Has_only_one_node(&ata_ide_ctrls[ctrl_minor].reqs))
    {
        uint16_t        val;
        ata_queue_msg_t msg;

#ifdef DEBUG
        /* 
         * read IDE_REGISTER_ALTERNATE_STATUS instead IDE_REGISTER_STATUS
         * to prevent clearing of pending interrupt
         */
        ide_controller_read_register(ctrl_minor, 
                                     IDE_REGISTER_ALTERNATE_STATUS, 
                                     &val);
        if (val & IDE_REGISTER_STATUS_BSY)
            return;
#endif
        ATA_SEND_EVT(msg, ATA_MSG_PROCESS_NEXT_EVT, ctrl_minor, 0);
    }    
}                            


/* ata_interrupt_handler -- 
 *     ATA driver interrrupt handler. If interrrupt happend it mapped it to
 *     controller (controllerS, if a number of controllers share one int line)
 *     and generates ATA event(s).
 * 
 * PARAMETERS:
 *     vec - interrupt vector  
 *
 * RETURNS:
 *     NONE
 */
rtems_isr
ata_interrupt_handler(rtems_vector_number vec)
{
    Chain_Node      *the_node = ((Chain_Control *)(&ata_int_vec[vec]))->first;
    ata_queue_msg_t  msg;
    uint16_t         byte; /* emphasize that only 8 low bits is meaningful */
    
    for ( ; !Chain_Is_tail(&ata_int_vec[vec], the_node) ; )
    {
        /* if (1) - is temporary hack - currently I don't know how to identify
         * controller which asserted interrupt if few controllers share one
         * interrupt line
         */
        if (1)
        {
            msg.ctrl_minor = ((ata_int_st_t *)the_node)->ctrl_minor;
            ide_controller_read_register(msg.ctrl_minor, IDE_REGISTER_STATUS, 
                                         &byte);
            ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, msg.ctrl_minor, 0);                             
        }
        the_node = the_node->next;
    }   
}

/* ata_pio_in_protocol -- 
 *     ATA PIO_IN protocol implementation, see specification
 * 
 * PARAMETERS:
 *     ctrl_minor - controller identifier
 *     areq       - ATA request 
 *
 * RETURNS:
 *     NONE
 */
static inline void
ata_pio_in_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq)
{
    uint16_t        bs, val;
    uint8_t         dev;
    uint32_t        min_val;
    ata_queue_msg_t msg;
        
    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & 
           IDE_REGISTER_DEVICE_HEAD_DEV;

    bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?  
         ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;      
    min_val = MIN(bs, areq->cnt);
    
    ide_controller_read_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE, 
                                   areq->breq->bufs, &areq->cbuf, &areq->pos);
              
    areq->cnt -= min_val;
    if (areq->cnt == 0)
    {
        ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, RTEMS_SUCCESSFUL);
    }
    else if (IDE_Controller_Table[ctrl_minor].int_driven == 0)
    {
        do {
           ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &val);
        } while (val & IDE_REGISTER_STATUS_BSY);
        
        ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, ctrl_minor, 0);
    }
}

/* ata_pio_out_protocol -- 
 *     ATA PIO_OUT protocol implementation, see specification
 * 
 * PARAMETERS:
 *     ctrl_minor - controller identifier
 *     areq       - ATA request 
 *
 * RETURNS:
 *     NONE
 */
static inline void
ata_pio_out_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq)
{
    uint16_t        bs, val;
    uint8_t         dev;
    uint32_t        min_val;
    ata_queue_msg_t msg;
    
    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & 
           IDE_REGISTER_DEVICE_HEAD_DEV;

    bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?  
         ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;      

    min_val = MIN(bs, areq->cnt);     

    if (areq->cnt == 0)
    {
        ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, RTEMS_SUCCESSFUL);
    }
    else 
    {
        ide_controller_write_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE,
                                        areq->breq->bufs, &areq->cbuf, 
                                        &areq->pos);
        areq->cnt -= min_val;
        if (IDE_Controller_Table[ctrl_minor].int_driven == 0)
        {
            do {
                ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, 
                                             &val);
            } while (val & IDE_REGISTER_STATUS_BSY);

            ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, ctrl_minor, 0);
        }
  }
}

/* ata_queue_task -- 
 *     Task which manages ATA driver events queue.
 * 
 * PARAMETERS:
 *     arg - ignored
 *
 * RETURNS:
 *     NONE
 *
 * NOTES:
 *     should be non-preemptive 
 */
static rtems_task
ata_queue_task(rtems_task_argument arg)
{
    ata_queue_msg_t            msg;
    uint32_t             size;
    ata_req_t                 *areq;
    rtems_device_minor_number  ctrl_minor;
    uint16_t                   val;
    uint16_t                   val1;
    rtems_status_code          rc;
    ISR_Level                  level;

    while (1)
    {
        /* get event which has happend */
        rc = rtems_message_queue_receive(ata_queue_id, &msg, &size, RTEMS_WAIT, 
                                         RTEMS_NO_TIMEOUT);
        if (rc != RTEMS_SUCCESSFUL)
            rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR);
                                             
        /* get controller on which event has happend */
        ctrl_minor = msg.ctrl_minor;
        
        /* get current request to the controller */
        _ISR_Disable(level);        
        areq = (ata_req_t *)(ata_ide_ctrls[ctrl_minor].reqs.first);
        _ISR_Enable(level);
        
        switch(msg.type)
        {
            case ATA_MSG_PROCESS_NEXT_EVT:
                /* process next request in the controller queue */
                ata_process_request(ctrl_minor);
                break;

            case ATA_MSG_SUCCESS_EVT:
                /* 
                 * finish processing of current request with successful 
                 * status and start processing of the next request in the 
                 * controller queue
                 */
                ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, 
                                 msg.error);
                break;
                
            case ATA_MSG_ERROR_EVT:
                /* 
                 * finish processing of current request with error 
                 * status and start processing of the next request in the 
                 * controller queue
                 */
                ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED, 
                                 msg.error);
                break;
                
            case ATA_MSG_GEN_EVT:
                /* 
                 * continue processing of the current request to the 
                 * controller according to current request state and 
                 * ATA protocol
                 */
                ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, 
                                           &val);
                /* process error case */
                if (val & IDE_REGISTER_STATUS_ERR)
                { 
                    ide_controller_read_register(ctrl_minor, 
                                                 IDE_REGISTER_ERROR, 
                                                 &val);
                    if (areq->type == ATA_COMMAND_TYPE_NON_DATA)
                        ata_non_data_request_done(areq, ctrl_minor, 
                                                  RTEMS_UNSATISFIED, 
                                                  RTEMS_IO_ERROR);
                    else                             
                        ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED, 
                                         RTEMS_IO_ERROR);
                    break;                                  
                }

                switch(areq->type)
                {
                    case ATA_COMMAND_TYPE_PIO_IN:
                        ata_pio_in_protocol(ctrl_minor, areq);
                        break;
                
                    case ATA_COMMAND_TYPE_PIO_OUT:
                        ata_pio_out_protocol(ctrl_minor, areq);
                        break;
                
                    case ATA_COMMAND_TYPE_NON_DATA:
                        ide_controller_read_register(ctrl_minor, 
                                                      IDE_REGISTER_ERROR, 
                                                     &val1);
                        ata_non_data_request_done(areq, ctrl_minor,
                                                  RTEMS_SUCCESSFUL,
                                                  val1);
                        break;
            
                    default:
                        printf("ata_queue_task: non-supported command type\n");
                        ata_request_done(areq, ctrl_minor,
                                         RTEMS_UNSATISFIED,
                                         RTEMS_NOT_IMPLEMENTED);
                        break;          
                }
                break;    

            default:
                rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR);
                break;
        }
    }
}

/* ata_ioctl -- 
 *     ATA driver ioctl interface.
 * 
 * PARAMETERS:
 *     device - device identifier
 *     cmd    - command
 *     argp   - arguments
 *
 * RETURNS:
 *     depend on 'cmd'
 */
int 
ata_ioctl(dev_t device, int cmd, void *argp)
{
    rtems_status_code         status;
    rtems_device_minor_number rel_minor;
    
    rel_minor = (rtems_filesystem_dev_minor_t(device)) /
                ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;

    /* 
     * in most cases this means that device 'device' is not an registred ATA
     * device
     */ 
    if (ata_devs[rel_minor].device == ATA_UNDEFINED_VALUE)
    {
        errno = ENODEV;
        return -1;
    }    

    switch (cmd) 
    {
        case BLKIO_REQUEST:
            status = ata_io_data_request(device, (blkdev_request *)argp);
            break;
        
        case ATAIO_SET_MULTIPLE_MODE:
            status = ata_non_data_request(device, cmd, argp);
            break;
      
        default:
            errno = EBADRQC;
            return -1;
            break;
    }

    if (status != RTEMS_SUCCESSFUL)
    {
        errno = EIO;
        return -1; 
    }
    return 0;
}

/*
 * ata_initialize --
 *     Initializes all ATA devices found on initialized IDE controllers.
 * 
 * PARAMETERS:
 *     major - device major number
 *     minor - device minor number
 *     args   - arguments
 *
 * RETURNS:
 *     RTEMS_SUCCESSFUL on success, or error code if
 *     error occured 
 */
rtems_device_driver 
ata_initialize(rtems_device_major_number major, 
               rtems_device_minor_number minor_arg, 
               void *args)
{
    uint32_t           ctrl_minor;
    rtems_status_code  status;
    ata_req_t          areq;
    blkdev_request1    breq;     
    uint8_t            i, dev = 0;
    uint16_t          *buffer;
    uint16_t           ec;
    char               name[ATA_MAX_NAME_LENGTH];
    dev_t              device;
    ata_int_st_t      *int_st;
    rtems_isr_entry    old_isr;

    if (ata_initialized)
        return RTEMS_SUCCESSFUL;
            
    /* initialization of disk devices library */
    status = rtems_disk_io_initialize();
    if (status != RTEMS_SUCCESSFUL)
        return status;
        
    /* create queue for asynchronous requests handling */
    status = rtems_message_queue_create(
                 rtems_build_name('A', 'T', 'A', 'Q'),
                 ATA_DRIVER_MESSAGE_QUEUE_SIZE,
                 sizeof(ata_queue_msg_t),
                 RTEMS_FIFO | RTEMS_LOCAL,
                 &ata_queue_id);
    if (status != RTEMS_SUCCESSFUL)
    {
        rtems_disk_io_done();
        return status;
    }    

    /* 
     * create ATA driver task, see comments for task implementation for 
     * details 
     */
    status = rtems_task_create(
                 rtems_build_name ('A', 'T', 'A', 'T'),
                 ATA_DRIVER_TASK_PRIORITY,
                 ATA_DRIVER_TASK_STACK_SIZE,
                 RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_ASR | 
                 RTEMS_INTERRUPT_LEVEL(0),
                 RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
                 &ata_task_id);
    if (status != RTEMS_SUCCESSFUL)
    {
        rtems_message_queue_delete(ata_queue_id);
        rtems_disk_io_done();
        return status;
    }    
    
    /* 
     * start ATA driver task. Actually the task will not start immediately - 
     * it will start only after multitasking support will be started
     */ 
    status = rtems_task_start(ata_task_id, ata_queue_task, 0); 
    if (status != RTEMS_SUCCESSFUL)
    {
        rtems_task_delete(ata_task_id);
        rtems_message_queue_delete(ata_queue_id);
        rtems_disk_io_done();
        return status;
    }    
    
    buffer = (uint16_t*)malloc(ATA_SECTOR_SIZE);
    if (buffer == NULL)
    {
        rtems_task_delete(ata_task_id);
        rtems_message_queue_delete(ata_queue_id);
        rtems_disk_io_done();
        return RTEMS_NO_MEMORY;
    }    
        
    ata_devs_number = 0;

    for (i = 0; i < (2 * IDE_CTRL_MAX_MINOR_NUMBER); i++)
        ata_devs[i].device = ATA_UNDEFINED_VALUE;

    /* prepare ATA driver for handling  interrupt driven devices */
    for (i = 0; i < ATA_MAX_RTEMS_INT_VEC_NUMBER; i++)
        Chain_Initialize_empty(&ata_int_vec[i]);

    /* 
     * during ATA driver initialization EXECUTE DEVICE DIAGNOSTIC and 
     * IDENTIFY DEVICE ATA command should be issued; for these purposes ATA 
     * requests should be formed; ATA requests contain block device request, 
     * so form block device request first
     */
    memset(&breq, 0, sizeof(blkdev_request1));
    breq.req.req_done = NULL;
    breq.req.done_arg = &breq;
    breq.req.bufnum = 1;
    breq.req.count = 1;
    breq.req.bufs[0].length = ATA_SECTOR_SIZE;
    breq.req.bufs[0].buffer = buffer;

    /* 
     * for each presented IDE controller execute EXECUTE DEVICE DIAGNOSTIC
     * ATA command; for each found device execute IDENTIFY DEVICE ATA 
     * command 
     */
    for (ctrl_minor = 0; ctrl_minor < IDE_Controller_Count; ctrl_minor++)
    if (IDE_Controller_Table[ctrl_minor].status == IDE_CTRL_INITIALIZED)
    {
        Chain_Initialize_empty(&ata_ide_ctrls[ctrl_minor].reqs);
        
        if (IDE_Controller_Table[ctrl_minor].int_driven == TRUE)
        {
            int_st = malloc(sizeof(ata_int_st_t));
            if (int_st == NULL)
            {
                free(buffer);
                rtems_task_delete(ata_task_id);
                rtems_message_queue_delete(ata_queue_id);
                rtems_disk_io_done();
                return RTEMS_NO_MEMORY;
            }       

            int_st->ctrl_minor = ctrl_minor;

            status = rtems_interrupt_catch(
                         ata_interrupt_handler, 
                         IDE_Controller_Table[ctrl_minor].int_vec, 
                         &old_isr);
            if (status != RTEMS_SUCCESSFUL)
            {
                free(int_st);
                free(buffer);
                rtems_task_delete(ata_task_id);
                rtems_message_queue_delete(ata_queue_id);
                rtems_disk_io_done();
                return status;
            } 
            Chain_Append(
                &ata_int_vec[IDE_Controller_Table[ctrl_minor].int_vec],
                &int_st->link);

            /* disable interrupts */
            ide_controller_write_register(ctrl_minor, 
                                          IDE_REGISTER_DEVICE_CONTROL_OFFSET, 
                                          IDE_REGISTER_DEVICE_CONTROL_nIEN);
        }

        /*
         * Issue EXECUTE DEVICE DIAGNOSTIC ATA command for explore is
         * there any ATA device on the controller.
         */
        memset(&areq, 0, sizeof(ata_req_t));
        areq.type = ATA_COMMAND_TYPE_NON_DATA;
        areq.regs.to_write = ATA_REGISTERS_VALUE(IDE_REGISTER_COMMAND);
        areq.regs.regs[IDE_REGISTER_COMMAND] = 
                                  ATA_COMMAND_EXECUTE_DEVICE_DIAGNOSTIC;
        areq.regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_ERROR);

        areq.breq = (blkdev_request *)&breq;

        /* 
         * Process the request. Special processing of requests on 
         * initialization phase is needed because at this moment there 
         * is no multitasking enviroment
         */
        ata_process_request_on_init_phase(ctrl_minor, &areq);

        /*
         * check status of I/O operation
         */
        if (breq.req.status != RTEMS_SUCCESSFUL)
            continue;
      
        /* disassemble returned diagnostic codes */ 
        if (breq.req.error == ATA_DEV0_PASSED_DEV1_PASSED_OR_NOT_PRSNT)
        {
            ATA_DEV_INFO(ctrl_minor, 0).present = 1;
            ATA_DEV_INFO(ctrl_minor,1).present = 1; 
        }
        else if (breq.req.error == ATA_DEV0_PASSED_DEV1_FAILED)
        {
            ATA_DEV_INFO(ctrl_minor,0).present = 1;
            ATA_DEV_INFO(ctrl_minor,1).present = 0;
        }
        else if (breq.req.error < ATA_DEV1_PASSED_DEV0_FAILED)
        {
            ATA_DEV_INFO(ctrl_minor,0).present = 0;
            ATA_DEV_INFO(ctrl_minor,1).present = 1;
        }
        else
        {
            ATA_DEV_INFO(ctrl_minor, 0).present = 0;
            ATA_DEV_INFO(ctrl_minor, 1).present = 0;
        }

        /* refine the returned codes */
        if (ATA_DEV_INFO(ctrl_minor, 1).present != 0)
        {
            ide_controller_read_register(ctrl_minor, IDE_REGISTER_ERROR, &ec);
            if (ec & ATA_DEV1_PASSED_DEV0_FAILED)
                ATA_DEV_INFO(ctrl_minor, 1).present = 1;
            else
                ATA_DEV_INFO(ctrl_minor, 1).present = 0;
        }

        /* for each found ATA device obtain it configuration */
        for (dev = 0; dev < 2; dev++)
        if (ATA_DEV_INFO(ctrl_minor, dev).present)
        {
            /*
             * Issue DEVICE IDENTIFY ATA command and get device 
             * configuration           
             */
            memset(&areq, 0, sizeof(ata_req_t));
            areq.type = ATA_COMMAND_TYPE_PIO_IN;
            areq.regs.to_write = ATA_REGISTERS_VALUE(IDE_REGISTER_COMMAND);
            areq.regs.regs[IDE_REGISTER_COMMAND] = 
                                              ATA_COMMAND_IDENTIFY_DEVICE;
            areq.regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_STATUS);
            areq.breq = (blkdev_request *)&breq;
            
            areq.cnt = breq.req.count;

            areq.regs.regs[IDE_REGISTER_DEVICE_HEAD] |=
                                    (dev << IDE_REGISTER_DEVICE_HEAD_DEV_POS);

            /* 
             * Process the request. Special processing of requests on 
             * initialization phase is needed because at this moment there 
             * is no multitasking enviroment
             */
            ata_process_request_on_init_phase(ctrl_minor, &areq);

            /* check status of I/O operation */
            if (breq.req.status != RTEMS_SUCCESSFUL)
                continue;

            /*
             * Parse returned device configuration and fill in ATA internal 
             * device info structure
             */
            ATA_DEV_INFO(ctrl_minor, dev).cylinders = 
                CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_CLNDS]);
            ATA_DEV_INFO(ctrl_minor, dev).heads = 
                CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_HEADS]);
            ATA_DEV_INFO(ctrl_minor, dev).sectors = 
                CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_SECS]);
            ATA_DEV_INFO(ctrl_minor, dev).lba_sectors = 
                (CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS0]) << 16) + 
                 CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS1]);
            ATA_DEV_INFO(ctrl_minor, dev).lba_avaible = 
                (CF_LE_W(buffer[ATA_IDENT_WORD_CAPABILITIES]) >> 9) & 0x1;
            ATA_DEV_INFO(ctrl_minor, dev).max_multiple = 
                (uint8_t) (CF_LE_W(buffer[ATA_IDENT_WORD_RW_MULT]));
            ATA_DEV_INFO(ctrl_minor, dev).current_multiple = 
                (CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS]) & 0x100) ? 
                (uint8_t)(CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS])) :
                 0;

            if ((CF_LE_W(buffer[ATA_IDENT_WORD_FIELD_VALIDITY]) & 
                 ATA_IDENT_BIT_VALID) == 0) {
	      /* no "supported modes" info -> use default */
	      ATA_DEV_INFO(ctrl_minor, dev).mode_active = ATA_MODES_PIO3;
	    }
	    else {
	      ATA_DEV_INFO(ctrl_minor, dev).modes_avaible =
		((CF_LE_W(buffer[64]) & 0x1) ? ATA_MODES_PIO3 : 0) |
		((CF_LE_W(buffer[64]) & 0x2) ? ATA_MODES_PIO4 : 0) |
		((CF_LE_W(buffer[63]) & 0x1) ? ATA_MODES_DMA0 : 0) |
		((CF_LE_W(buffer[63]) & 0x2) ? 
		 ATA_MODES_DMA0 | ATA_MODES_DMA1 : 0) |
		((CF_LE_W(buffer[63]) & 0x4) ? 
		 ATA_MODES_DMA0 | ATA_MODES_DMA1 | ATA_MODES_DMA2 : 0);
	      if (ATA_DEV_INFO(ctrl_minor, dev).modes_avaible == 0)
                continue;
	      /* 
	       * choose most appropriate ATA device data I/O speed supported
	       * by the controller
	       */
	      status = ide_controller_config_io_speed(
                ctrl_minor, 
                ATA_DEV_INFO(ctrl_minor, dev).modes_avaible);
	      if (status != RTEMS_SUCCESSFUL)
                continue;
	    }      
            /*
             * Ok, let register new ATA device in the system
             */
            ata_devs[ata_devs_number].ctrl_minor = ctrl_minor;
            ata_devs[ata_devs_number].device = dev;

            /* The space leaves a hole for the character. */
            strcpy(name, "/dev/hd ");
            name[7] = 'a' + 2 * ctrl_minor + dev;

            device = rtems_filesystem_make_dev_t(
                         major, 
                         (ata_devs_number * 
                          ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE));

            status = rtems_disk_create_phys(device, ATA_SECTOR_SIZE, 
                ATA_DEV_INFO(ctrl_minor, dev).lba_avaible ? 
                ATA_DEV_INFO(ctrl_minor, dev).lba_sectors : 
                (ATA_DEV_INFO(ctrl_minor, dev).heads *
                 ATA_DEV_INFO(ctrl_minor, dev).cylinders *
                 ATA_DEV_INFO(ctrl_minor, dev).sectors),
                (block_device_ioctl) ata_ioctl, name);
            if (status != RTEMS_SUCCESSFUL)
            {
                ata_devs[ata_devs_number].device = ATA_UNDEFINED_VALUE;
                continue;
            }       
            ata_devs_number++;
        }
        if (IDE_Controller_Table[ctrl_minor].int_driven == TRUE)
        {    
            ide_controller_write_register(ctrl_minor, 
                                          IDE_REGISTER_DEVICE_CONTROL_OFFSET, 
                                          0x00);
        }
    }

    free(buffer);
    ata_initialized = TRUE;
    return RTEMS_SUCCESSFUL;
}

/* ata_process_request_on_init_phase -- 
 *     Process the ATA request during system initialization. Request 
 *     processing is syncronous and doesn't use multiprocessing enviroment.
 * 
 * PARAMETERS:
 *     ctrl_minor - controller identifier
 *     areq       - ATA request
 *
 * RETURNS:
 *     NONE 
 */
static void
ata_process_request_on_init_phase(rtems_device_minor_number  ctrl_minor,
                                  ata_req_t                 *areq)
{
    uint16_t           byte;/* emphasize that only 8 low bits is meaningful */
    uint8_t            i, dev;
    uint16_t           val, val1;
    uint16_t           data_bs; /* the number of 512 bytes sectors into one 
                                 * data block 
                                 */
    assert(areq);
    
    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & 
           IDE_REGISTER_DEVICE_HEAD_DEV;

    data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?  
              ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;      
    
    ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD, 
                                  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]);
    
    do {
        ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &byte);
    } while ((byte & IDE_REGISTER_STATUS_BSY) || 
             (!(byte & IDE_REGISTER_STATUS_DRDY)));

    for (i=0; i< ATA_MAX_CMD_REG_OFFSET; i++)
    {
        uint32_t   reg = (1 << i);
        if (areq->regs.to_write & reg)
            ide_controller_write_register(ctrl_minor, i, 
                                          areq->regs.regs[i]);
    }

    do {
        ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &byte);
    } while (byte & IDE_REGISTER_STATUS_BSY);

    ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &val);
    ide_controller_read_register(ctrl_minor, IDE_REGISTER_ERROR, &val1);

    if (val & IDE_REGISTER_STATUS_ERR)
    {
        areq->breq->status = RTEMS_UNSATISFIED;
        areq->breq->error = RTEMS_IO_ERROR;
        return;
    }
 
    switch(areq->type)
    {
        case ATA_COMMAND_TYPE_PIO_IN:
            ide_controller_read_data_block(
                ctrl_minor, 
                MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE,
                areq->breq->bufs, &areq->cbuf,
                &areq->pos);
              
            areq->cnt -= MIN(data_bs, areq->cnt);
            if (areq->cnt == 0)
            {
                areq->breq->status = RTEMS_SUCCESSFUL;
            }
            else 
            {
                /* 
                 * this shouldn't happend on the initialization 
                 * phase! 
                 */
                rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR); 
            }
            break;
                
        case ATA_COMMAND_TYPE_NON_DATA:
            areq->breq->status = RTEMS_SUCCESSFUL;
            areq->breq->error = val1;
            break;
            
        default:
            printf("ata_queue_task: non-supported command type\n");
            areq->breq->status = RTEMS_UNSATISFIED;
            areq->breq->error = RTEMS_NOT_IMPLEMENTED;
            break;          
    }
}