Changeset 7357f566 in rtems


Ignore:
Timestamp:
Oct 8, 2009, 7:25:15 AM (10 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, master
Children:
578e6fe
Parents:
c1fc5d4
Message:

2009-10-08 Chris Johns <chrisj@…>

  • libchip/ide/ata.c, c/src/libchip/ide/ata_internal.h: Remove the multiblock support from the ATA driver. Multiblock at the disk level should not be a global policy as a disk may have more than one partition with different block sizes. An IDE driver could decide to use the feature with DMA but this a driver specific design choice. Fixed bugs relating to variable block sizes and large block transfer.
  • c/src/libchip/ide/ide_controller.c, c/src/libchip/ide/ide_ctrl_cfg.h, c/src/libchip/ide/ide_ctrl_io.h: Changed the block size to 32bits so blocks of 64K or bigger can be transfered in a single driver call.
Location:
c/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • c/src/ChangeLog

    rc1fc5d4 r7357f566  
     12009-10-08      Chris Johns <chrisj@rtems.org>
     2
     3        * libchip/ide/ata.c, c/src/libchip/ide/ata_internal.h: Remove the
     4        multiblock support from the ATA driver. Multiblock at the disk
     5        level should not be a global policy as a disk may have more than
     6        one partition with different block sizes. An IDE driver could
     7        decide to use the feature with DMA but this a driver specific
     8        design choice. Fixed bugs relating to variable block sizes and
     9        large block transfer.
     10        * c/src/libchip/ide/ide_controller.c,
     11        c/src/libchip/ide/ide_ctrl_cfg.h, c/src/libchip/ide/ide_ctrl_io.h:
     12        Changed the block size to 32bits so blocks of 64K or bigger can be
     13        transfered in a single driver call.
     14
    1152009-10-05      Joel Sherrill <joel.sherrill@oarcorp.com>
    216
  • c/src/libchip/ide/ata.c

    rc1fc5d4 r7357f566  
    2727#include "ata_internal.h"
    2828#include <libchip/ata.h>
    29 /* #define DEBUG */
    30 
    31 #ifdef DEBUG
     29
     30#define ATA_DEBUG 0
     31
     32#if ATA_DEBUG
    3233#include <stdio.h>
     34bool ata_trace;
     35#define ata_printf if (ata_trace) printf
    3336#endif
    3437
     
    238241        if (req->req == RTEMS_BLKDEV_REQ_READ)
    239242        {
    240 #ifdef DEBUG
    241             printf("ata_io_data_request: type: READ: %d, %d\n",
    242                    req->bufs[0].block, req->bufnum);
     243            areq->type = ATA_COMMAND_TYPE_PIO_IN;
     244            areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_READ_SECTORS;
     245#if ATA_DEBUG
     246            ata_printf("ata_io_data_request: type: READ: %lu, %lu cmd:%02x\n",
     247                       req->bufs[0].block, req->bufnum,
     248                       areq->regs.regs[IDE_REGISTER_COMMAND]);
    243249#endif           
    244             areq->type = ATA_COMMAND_TYPE_PIO_IN;
    245 
    246             /*
    247              * choose command to issue: if the number of blocks to be
    248              * exchanged is greater then 1 and for ATA command READ MULTIPLE
    249              * data block consists of more then 1 sector choose READ MULTIPLE
    250              * otherwise READ SECTORS
    251              */
    252             areq->regs.regs[IDE_REGISTER_COMMAND] =
    253                 ((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) &&
    254                  (req->bufnum > 1) &&
    255                  (ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ?
    256                  ATA_COMMAND_READ_MULTIPLE :
    257                  ATA_COMMAND_READ_SECTORS;
    258250        }
    259251        else
    260252        {
    261 #ifdef DEBUG
    262             printf("ata_io_data_request: type: WRITE: %d, %d\n",
    263                    req->bufs[0].block, req->bufnum);
     253            areq->type = ATA_COMMAND_TYPE_PIO_OUT;
     254            areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_WRITE_SECTORS;
     255#if ATA_DEBUG
     256            ata_printf("ata_io_data_request: type: WRITE: %lu, %lu cmd:%02x\n",
     257                       req->bufs[0].block, req->bufnum,
     258                       areq->regs.regs[IDE_REGISTER_COMMAND]);
    264259#endif           
    265             areq->type = ATA_COMMAND_TYPE_PIO_OUT;
    266 
    267             /*
    268              * choose command to issue: if the number of blocks to be
    269              * exchanged is greater then 1 and for ATA command WRITE MULTIPLE
    270              * data block consists of more then 1 sector choose WRITE MULTIPLE
    271              * otherwise WRITE SECTORS
    272              */
    273             areq->regs.regs[IDE_REGISTER_COMMAND] =
    274               ((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) &&
    275                (req->bufnum > 1) &&
    276                (ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ?
    277                ATA_COMMAND_WRITE_MULTIPLE :
    278                ATA_COMMAND_WRITE_SECTORS;
    279260        }
    280261    }
     
    289270        areq->regs.regs[IDE_REGISTER_LBA1] = (uint8_t)(start >> 8);
    290271        areq->regs.regs[IDE_REGISTER_LBA2] = (uint8_t)(start >> 16);
     272        /* Set as the head register write above */
    291273        areq->regs.regs[IDE_REGISTER_LBA3] |= (uint8_t) (start >> 24);
    292274        areq->regs.regs[IDE_REGISTER_LBA3] |= IDE_REGISTER_LBA3_L;
     
    312294    }
    313295
    314     /* fill sector count register */
    315     areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] = areq->breq->bufnum;
     296    /*
     297     * Fill sector count register. We have a number of buffers (bufnum) which
     298     * can be of a specific length (bufs[0].length / ATA_SECTOR_SIZE).
     299     */
     300    areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] =
     301      areq->breq->bufnum * (areq->breq->bufs[0].length / ATA_SECTOR_SIZE);
    316302
    317303    /* add request to the queue of awaiting requests to the controller */
     
    424410        {
    425411            case ATAIO_SET_MULTIPLE_MODE:
    426                 ATA_DEV_INFO(ctrl_minor, dev).current_multiple =
    427                                                            *(uint8_t*)argp;
    428                 break;
    429 
     412              /* invalid operation now */
    430413            default:
    431414                rc = RTEMS_INVALID_NUMBER;
     
    464447    uint8_t          i, dev;
    465448    uint16_t         val;
    466     uint16_t         data_bs; /* the number of 512-bytes sectors in one
    467                                * data block
    468                                */
    469449    ISR_Level        level;
    470450   
     
    482462           IDE_REGISTER_DEVICE_HEAD_DEV;
    483463
    484     /* get data block size */
    485     data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
    486               ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
    487 
    488464    /* execute device select protocol */
    489465    ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD,
     
    503479    }
    504480
    505 #ifdef DEBUG
    506     printf("ata_process_request: type: %d\n", areq->type);
     481#if ATA_DEBUG
     482    ata_printf("ata_process_request: type: %d\n", areq->type);
    507483#endif
    508484   
     
    517493        if (byte & IDE_REGISTER_STATUS_DRQ)
    518494        {
    519             ide_controller_write_data_block(
    520                 ctrl_minor,
    521                 MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE,
    522                 areq->breq->bufs, &areq->cbuf,
    523                 &areq->pos);
    524             areq->cnt -= MIN(data_bs, areq->cnt);
     495            if (areq->cnt)
     496            {
     497              int ccbuf = areq->cbuf;
     498              ide_controller_write_data_block(ctrl_minor,
     499                                              areq->breq->bufs[0].length * areq->cnt,
     500                                              areq->breq->bufs, &areq->cbuf,
     501                                              &areq->pos);
     502              ccbuf = areq->cbuf - ccbuf;
     503              areq->cnt -= ccbuf;
     504            }
    525505        }
    526506        else
     
    571551    assert(areq);
    572552
    573 #ifdef DEBUG
    574     printf("ata_request_done: entry\n");
     553#if ATA_DEBUG
     554    ata_printf("ata_request_done: entry\n");
    575555#endif
    576556   
     
    587567    free(areq);
    588568   
    589 #ifdef DEBUG
    590     printf("ata_request_done: exit\n");
     569#if ATA_DEBUG
     570    ata_printf("ata_request_done: exit\n");
    591571#endif
    592572}
     
    609589                          rtems_status_code status, int error)
    610590{
    611 #ifdef DEBUG
    612     printf("ata_non_data_request_done: entry\n");
     591#if ATA_DEBUG
     592    ata_printf("ata_non_data_request_done: entry\n");
    613593#endif
    614594   
     
    643623        ata_queue_msg_t msg;
    644624
    645 #ifdef DEBUG_DOES_NOT_WORK_WITH_QEMU
     625#if ATA_DEBUG_DOES_NOT_WORK_WITH_QEMU
    646626        uint16_t      val;
    647627        /*
     
    786766ata_pio_in_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq)
    787767{
    788     uint16_t        bs, val;
     768    uint16_t        val;
    789769    uint8_t         dev;
    790     uint32_t        min_val;
    791770    ata_queue_msg_t msg;
    792771
     
    794773           IDE_REGISTER_DEVICE_HEAD_DEV;
    795774
    796     bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
    797          ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
    798     min_val = MIN(bs, areq->cnt);
    799 
    800     ide_controller_read_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE,
    801                                    areq->breq->bufs, &areq->cbuf, &areq->pos);
    802 
    803     areq->cnt -= min_val;
     775    if (areq->cnt)
     776    {
     777      int ccbuf = areq->cbuf;
     778      ide_controller_read_data_block(ctrl_minor,
     779                                     areq->breq->bufs[0].length * areq->cnt,
     780                                     areq->breq->bufs, &areq->cbuf, &areq->pos);
     781      ccbuf = areq->cbuf - ccbuf;
     782      areq->cnt -= ccbuf;
     783    }
     784   
    804785    if (areq->cnt == 0)
    805786    {
     
    829810ata_pio_out_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq)
    830811{
    831     uint16_t        bs, val;
     812    uint16_t        val;
    832813    uint8_t         dev;
    833     uint32_t        min_val;
    834814    ata_queue_msg_t msg;
    835815
    836 #ifdef DEBUG
    837     printf("ata_pio_out_protocol:\n");
     816#if ATA_DEBUG
     817    ata_printf("ata_pio_out_protocol:\n");
    838818#endif
    839819   
     
    841821           IDE_REGISTER_DEVICE_HEAD_DEV;
    842822
    843     bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
    844          ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
    845 
    846     min_val = MIN(bs, areq->cnt);
    847 
    848823    if (areq->cnt == 0)
    849824    {
     
    852827    else
    853828    {
    854         ide_controller_write_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE,
    855                                         areq->breq->bufs, &areq->cbuf,
    856                                         &areq->pos);
    857         areq->cnt -= min_val;
     829        if (areq->cnt)
     830        {
     831          int ccbuf = areq->cbuf;
     832          ide_controller_write_data_block(ctrl_minor,
     833                                          areq->breq->bufs[0].length * areq->cnt,
     834                                          areq->breq->bufs, &areq->cbuf,
     835                                          &areq->pos);
     836          ccbuf = areq->cbuf - ccbuf;
     837          areq->cnt -= ccbuf;
     838        }
    858839        if (IDE_Controller_Table[ctrl_minor].int_driven == false)
    859840        {
     
    957938                                                 IDE_REGISTER_ERROR,
    958939                                                 &val);
    959                     if (areq->type == ATA_COMMAND_TYPE_NON_DATA)
    960                         ata_non_data_request_done(areq, ctrl_minor,
    961                                                   RTEMS_UNSATISFIED,
    962                                                   RTEMS_IO_ERROR);
    963                     else
    964                         ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED,
    965                                          RTEMS_IO_ERROR);
    966                     break;
     940                    if (val & (IDE_REGISTER_ERROR_UNC |
     941                               IDE_REGISTER_ERROR_ICRC |
     942                               IDE_REGISTER_ERROR_IDNF |
     943                               IDE_REGISTER_ERROR_NM |
     944                               IDE_REGISTER_ERROR_MED))
     945                    {
     946                        if (areq->type == ATA_COMMAND_TYPE_NON_DATA)
     947                            ata_non_data_request_done(areq, ctrl_minor,
     948                                                      RTEMS_UNSATISFIED,
     949                                                      RTEMS_IO_ERROR);
     950                        else
     951                            ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED,
     952                                             RTEMS_IO_ERROR);
     953                        break;
     954                    }
    967955                }
    968956
     
    987975
    988976                    default:
    989 #ifdef DEBUG
    990                         printf("ata_queue_task: non-supported command type\n");
     977#if ATA_DEBUG
     978                        ata_printf("ata_queue_task: non-supported command type\n");
    991979#endif
    992980                        ata_request_done(areq, ctrl_minor,
     
    998986
    999987            default:
    1000 #ifdef DEBUG
    1001                 printf("ata_queue_task: internal error\n");
     988#if ATA_DEBUG
     989                ata_printf("ata_queue_task: internal error\n");
    1002990                rtems_task_delete (RTEMS_SELF);
    1003991#endif
     
    10241012    rtems_status_code         status;
    10251013    rtems_device_minor_number rel_minor;
    1026 
     1014    uint8_t                   block_count;
     1015   
    10271016    rel_minor = (rtems_filesystem_dev_minor_t(device)) /
    10281017                ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;
     
    10521041            status = RTEMS_SUCCESSFUL;
    10531042            break;
    1054 
     1043           
    10551044        default:
    1056             errno = EINVAL;
    1057             return -1;
     1045            return rtems_blkdev_ioctl (device, cmd, argp);
    10581046            break;
    10591047    }
     
    14191407                CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_SECS]);
    14201408            ATA_DEV_INFO(ctrl_minor, dev).lba_sectors =
    1421                 (CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS0]) << 16) +
    1422                  CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS1]);
     1409                (CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS1]) << 16) +
     1410                 CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS0]);
    14231411            ATA_DEV_INFO(ctrl_minor, dev).lba_avaible =
    14241412                (CF_LE_W(buffer[ATA_IDENT_WORD_CAPABILITIES]) >> 9) & 0x1;
    1425             ATA_DEV_INFO(ctrl_minor, dev).max_multiple =
    1426                 (uint8_t) (CF_LE_W(buffer[ATA_IDENT_WORD_RW_MULT]));
    1427             ATA_DEV_INFO(ctrl_minor, dev).current_multiple =
    1428                 (CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS]) & 0x100) ?
    1429                 (uint8_t)(CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS])) :
    1430                  0;
    14311413
    14321414            if ((CF_LE_W(buffer[ATA_IDENT_WORD_FIELD_VALIDITY]) &
     
    14701452                         (ata_devs_number *
    14711453                          ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE));
    1472 
    14731454            status = rtems_disk_create_phys(device, ATA_SECTOR_SIZE,
    14741455                ATA_DEV_INFO(ctrl_minor, dev).lba_avaible ?
     
    15161497    uint8_t            i, dev;
    15171498    uint16_t           val, val1;
    1518     uint16_t           data_bs; /* the number of 512 bytes sectors into one
    1519                                  * data block
    1520                                  */
    15211499    volatile unsigned  retries;
     1500   
    15221501    assert(areq);
    15231502
    15241503    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
    15251504           IDE_REGISTER_DEVICE_HEAD_DEV;
    1526 
    1527     data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
    1528               ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
    15291505
    15301506    ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD,
     
    15771553    {
    15781554        case ATA_COMMAND_TYPE_PIO_IN:
    1579             ide_controller_read_data_block(
    1580                 ctrl_minor,
    1581                 MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE,
    1582                 areq->breq->bufs, &areq->cbuf,
    1583                 &areq->pos);
    1584 
    1585             areq->cnt -= MIN(data_bs, areq->cnt);
     1555            if (areq->cnt)
     1556            {
     1557              int ccbuf = areq->cbuf;
     1558              ide_controller_read_data_block(ctrl_minor,
     1559                                             areq->breq->bufs[0].length * areq->cnt,
     1560                                             areq->breq->bufs, &areq->cbuf,
     1561                                             &areq->pos);
     1562              ccbuf = areq->cbuf - ccbuf;
     1563              areq->cnt -= ccbuf;
     1564            }
    15861565            if (areq->cnt == 0)
    15871566            {
     
    16041583
    16051584        default:
    1606 #ifdef DEBUG
    1607             printf("ata_queue_task: non-supported command type\n");
     1585#if ATA_DEBUG
     1586            ata_printf("ata_queue_task: non-supported command type\n");
    16081587#endif
    16091588            areq->breq->status = RTEMS_UNSATISFIED;
  • c/src/libchip/ide/ata_internal.h

    rc1fc5d4 r7357f566  
    286286    uint8_t     lba_avaible;  /* 0 - CHS mode, 1 - LBA mode */
    287287
    288     uint8_t     max_multiple; /* 0 if READ/WRITE MULTIPLE is unsupported */
    289     uint8_t     current_multiple;
    290 
    291288    uint16_t  modes_available; /* OR of values for this modes */
    292289    uint16_t  mode_active;
  • c/src/libchip/ide/ide_controller.c

    rc1fc5d4 r7357f566  
    9393void
    9494ide_controller_read_data_block(rtems_device_minor_number  minor,
    95                                uint16_t                   block_size,
     95                               uint32_t                   block_size,
    9696                               rtems_blkdev_sg_buffer    *bufs,
    9797                               uint32_t                  *cbuf,
     
    122122void
    123123ide_controller_write_data_block(rtems_device_minor_number  minor,
    124                                 uint16_t                   block_size,
     124                                uint32_t                   block_size,
    125125                                rtems_blkdev_sg_buffer    *bufs,
    126126                                uint32_t                  *cbuf,
  • c/src/libchip/ide/ide_ctrl_cfg.h

    rc1fc5d4 r7357f566  
    7474     * functions calls
    7575     */
    76     void  (*ctrl_read_block)(int minor, uint16_t   block_size,
     76    void  (*ctrl_read_block)(int minor, uint32_t   block_size,
    7777                             rtems_blkdev_sg_buffer *bufs, uint32_t   *cbuf,
    7878                             uint32_t   *pos);
    79     void  (*ctrl_write_block)(int minor, uint16_t   block_size,
     79    void  (*ctrl_write_block)(int minor, uint32_t   block_size,
    8080                              rtems_blkdev_sg_buffer *bufs, uint32_t   *cbuf,
    8181                              uint32_t   *pos);
  • c/src/libchip/ide/ide_ctrl_io.h

    rc1fc5d4 r7357f566  
    7575#define IDE_REGISTER_LBA3_LBA            0x0f
    7676
    77 #define IDE_REGISTER_ERROR_ICRC          0x80  /* Interface CRC error on */
    78                                                /* UDMA data transfer */
    79 #define IDE_REGISTER_ERROR_UNC           0x40  /* Uncorrectable data error */
    80 #define IDE_REGISTER_ERROR_WP            0x40  /* Write protect */
    81 #define IDE_REGISTER_ERROR_MC            0x20  /* Media changed */
    82 #define IDE_REGISTER_ERROR_IDNF          0x10  /* Sector ID not found */
    83 #define IDE_REGISTER_ERROR_MCR           0x08  /* Media change requested */
    84 #define IDE_REGISTER_ERROR_ABRT          0x04  /* Aborted command */
    85 #define IDE_REGISTER_ERROR_NM            0x02  /* No media */
    86 #define IDE_REGISTER_ERROR_AMNF          0x01  /* Address mark not found */
    87                                                /* --obsolette in ATA-4 */
    88 #define IDE_REGISTER_ERROR_MED           0x01  /* Media error is detected */
     77#define IDE_REGISTER_ERROR_ICRC          (1 << 7) /* Interface CRC error on */
     78                                                  /* UDMA data transfer */
     79#define IDE_REGISTER_ERROR_UNC           (1 << 6) /* Uncorrectable data error */
     80#if CCJ_COULD_NOT_FIND_THIS_ERROR
     81#define IDE_REGISTER_ERROR_WP            (1 << 6) /* Write protect */
     82#endif
     83#define IDE_REGISTER_ERROR_MC            (1 << 5) /* Media changed */
     84#define IDE_REGISTER_ERROR_IDNF          (1 << 4) /* Sector ID not found */
     85#define IDE_REGISTER_ERROR_MCR           (1 << 3) /* Media change requested */
     86                                                  /* obsolette */
     87#define IDE_REGISTER_ERROR_ABRT          (1 << 2) /* Aborted command */
     88#define IDE_REGISTER_ERROR_NM            (1 << 1) /* No media, End of Media. */
     89#define IDE_REGISTER_ERROR_AMNF          (1 << 0) /* Address mark not found */
     90                                                  /* --obsolette in ATA-4 */
     91#define IDE_REGISTER_ERROR_MED           (1 << 0) /* Media error is detected */
    8992
    9093/*
     
    104107void
    105108ide_controller_read_data_block(rtems_device_minor_number  minor,
    106                                uint16_t                   block_size,
     109                               uint32_t                   block_size,
    107110                               rtems_blkdev_sg_buffer    *bufs,
    108111                               uint32_t                  *cbuf,
     
    125128void
    126129ide_controller_write_data_block(rtems_device_minor_number  minor,
    127                                 uint16_t                   block_size,
     130                                uint32_t                   block_size,
    128131                                rtems_blkdev_sg_buffer    *bufs,
    129132                                uint32_t                  *cbuf,
Note: See TracChangeset for help on using the changeset viewer.