Changeset 3735f08 in rtems


Ignore:
Timestamp:
Jul 29, 2008, 2:23:48 AM (12 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, 4.9, master
Children:
57df51f
Parents:
c4bd98c
Message:

2008-07-29 Chris Johns <chrisj@…>

  • libchip/i2c/spi-sd-card.c: Updated to the libblock changes.
  • libchip/ide/ata.c: Change to use a mutex rather than disable pre-emption. Updated to the libblock changes.
  • libchip/ide/ata_internal.h: Updated to the new chains API.
  • libchip/ide/ide_controller.c: Updated to the libblock changes. Added come debug tracing.
  • libchip/ide/ide_ctrl_cfg.h, libchip/ide/ide_ctrl_io.h: Updated to the libblock changes.
Location:
c/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • c/src/ChangeLog

    rc4bd98c r3735f08  
     12008-07-29      Chris Johns <chrisj@rtems.org>
     2
     3        * libchip/i2c/spi-sd-card.c: Updated to the libblock changes.
     4
     5        * libchip/ide/ata.c: Change to use a mutex rather than disable
     6        pre-emption. Updated to the libblock changes.
     7
     8        * libchip/ide/ata_internal.h: Updated to the new chains API.
     9
     10        * libchip/ide/ide_controller.c: Updated to the libblock
     11        changes. Added come debug tracing.
     12
     13        * libchip/ide/ide_ctrl_cfg.h, libchip/ide/ide_ctrl_io.h: Updated
     14        to the libblock changes.
     15
    1162008-07-27      Ralf Corsépius <ralf.corsepius@rtems.org>
    217
  • c/src/libchip/i2c/spi-sd-card.c

    rc4bd98c r3735f08  
    559559 */
    560560
    561 static int sd_card_disk_block_read( sd_card_driver_entry *e, blkdev_request *r)
     561static int sd_card_disk_block_read( sd_card_driver_entry *e, rtems_blkdev_request *r)
    562562{
    563563        rtems_status_code sc = RTEMS_SUCCESSFUL;
     
    649649}
    650650
    651 static int sd_card_disk_block_write( sd_card_driver_entry *e, blkdev_request *r)
     651static int sd_card_disk_block_write( sd_card_driver_entry *e, rtems_blkdev_request *r)
    652652{
    653653        rtems_status_code sc = RTEMS_SUCCESSFUL;
     
    750750{
    751751        DEBUG_PRINT( "dev = %u, req = %u, arg = 0x08%x\n", dev, req, arg);
    752         if (req == BLKIO_REQUEST) {
     752        if (req == RTEMS_BLKIO_REQUEST) {
    753753                rtems_device_minor_number minor = rtems_filesystem_dev_minor_t( dev);
    754754                sd_card_driver_entry *e = &sd_card_driver_table [minor];
    755                 blkdev_request *r = (blkdev_request *) arg;
     755                rtems_blkdev_request *r = (rtems_blkdev_request *) arg;
    756756                switch (r->req) {
    757                         case BLKDEV_REQ_READ:
     757                        case RTEMS_BLKDEV_REQ_READ:
    758758                                return sd_card_disk_block_read( e, r);
    759                         case BLKDEV_REQ_WRITE:
     759                        case RTEMS_BLKDEV_REQ_WRITE:
    760760                                return sd_card_disk_block_write( e, r);
    761761                        default:
  • c/src/libchip/ide/ata.c

    rc4bd98c r3735f08  
    2727#include "ata_internal.h"
    2828#include <libchip/ata.h>
    29 /* #define DEBUG */
     29//#define DEBUG
    3030
    3131#ifdef DEBUG
     
    5858
    5959#define SAFE
     60#define SAFE_MUTEX
     61
    6062#ifdef SAFE
     63#ifdef SAFE_MUTEX
     64static rtems_id ata_lock;
     65static void
     66rtems_ata_lock ()
     67{
     68  rtems_status_code sc = rtems_semaphore_obtain (ata_lock,
     69                                                 RTEMS_WAIT,
     70                                                 RTEMS_NO_TIMEOUT);
     71  if (sc != RTEMS_SUCCESSFUL)
     72    rtems_fatal_error_occurred (RTEMS_INTERNAL_ERROR);
     73}
     74
     75static void
     76rtems_ata_unlock ()
     77{
     78  rtems_status_code sc = rtems_semaphore_release (ata_lock);
     79  if (sc != RTEMS_SUCCESSFUL)
     80    rtems_fatal_error_occurred (RTEMS_INTERNAL_ERROR);
     81}
     82
     83#define RTEMS_ATA_LOCK_ATTRIBS \
     84  (RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE | \
     85   RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
     86
     87#define PREEMPTION_KEY(key)
     88#define DISABLE_PREEMPTION(key) rtems_ata_lock ()
     89#define ENABLE_PREEMPTION(key)  rtems_ata_unlock ()
     90
     91#else /* !SAFE_MUTEX */
    6192typedef rtems_mode preemption_key;
    6293
    63 #define DISABLE_PREEMPTION(key) \
     94#define PREEMPTION_KEY(key) preemption_key key
     95
     96#define DISABLE_PREEMPTION(key)                                        \
    6497    do {                                                               \
    6598        rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &(key)); \
     
    71104        rtems_task_mode((key), RTEMS_PREEMPT_MASK, &temp);      \
    72105    } while (0)
    73 
    74 #else
    75 
     106#endif
     107#else /* !SAFE */
    76108typedef boolean preemption_key;
     109
     110#define PREEMPTION_KEY(key) preemption_key key
    77111
    78112#define DISABLE_PREEMPTION(key) \
     
    96130/* Block device request with a single buffer provided */
    97131typedef struct blkdev_request1 {
    98     blkdev_request   req;
    99     blkdev_sg_buffer sg[1];
     132    rtems_blkdev_request   req;
     133    rtems_blkdev_sg_buffer sg[1];
    100134} blkdev_request1;
    101135
     
    153187 */
    154188static rtems_status_code
    155 ata_io_data_request(dev_t device, blkdev_request *req)
     189ata_io_data_request(dev_t device, rtems_blkdev_request *req)
    156190{
    157191    ata_req_t                 *areq; /* ATA request */
     
    195229        /* XXX: never has been tested */
    196230        areq->type = ATA_COMMAND_TYPE_DMA;
    197         if (req->req == BLKDEV_REQ_READ)
     231        if (req->req == RTEMS_BLKDEV_REQ_READ)
    198232            areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_READ_DMA;
    199233        else
     
    202236    else
    203237    {
    204         if (req->req == BLKDEV_REQ_READ)
    205         {
     238        if (req->req == RTEMS_BLKDEV_REQ_READ)
     239        {
     240#ifdef DEBUG
     241            printf("ata_io_data_request: type: READ: %d, %d\n",
     242                   req->bufs[0].block, req->count);
     243#endif           
    206244            areq->type = ATA_COMMAND_TYPE_PIO_IN;
    207245
     
    221259        else
    222260        {
     261#ifdef DEBUG
     262            printf("ata_io_data_request: type: WRITE: %d, %d\n",
     263                   req->bufs[0].block, req->count);
     264#endif           
    223265            areq->type = ATA_COMMAND_TYPE_PIO_OUT;
    224266
     
    243285    if (ATA_DEV_INFO(ctrl_minor, dev).lba_avaible)
    244286    {
    245         areq->regs.regs[IDE_REGISTER_LBA0] = (uint8_t)req->start;
    246         areq->regs.regs[IDE_REGISTER_LBA1] = (uint8_t)(req->start >> 8);
    247         areq->regs.regs[IDE_REGISTER_LBA2] = (uint8_t)(req->start >> 16);
    248         areq->regs.regs[IDE_REGISTER_LBA3] |= (uint8_t) (req->start >> 24);
     287        uint32_t start = req->bufs[0].block;
     288        areq->regs.regs[IDE_REGISTER_LBA0] = (uint8_t)start;
     289        areq->regs.regs[IDE_REGISTER_LBA1] = (uint8_t)(start >> 8);
     290        areq->regs.regs[IDE_REGISTER_LBA2] = (uint8_t)(start >> 16);
     291        areq->regs.regs[IDE_REGISTER_LBA3] |= (uint8_t) (start >> 24);
    249292        areq->regs.regs[IDE_REGISTER_LBA3] |= IDE_REGISTER_LBA3_L;
    250293    }
    251294    else
    252295    {
    253         uint32_t   count = req->start;
     296        uint32_t   count = req->bufs[0].block;
    254297
    255298        areq->regs.regs[IDE_REGISTER_SECTOR_NUMBER] =
     
    274317    /* add request to the queue of awaiting requests to the controller */
    275318    ata_add_to_controller_queue(ctrl_minor, areq);
    276 
     319   
    277320    return RTEMS_SUCCESSFUL;
    278321}
     
    425468                               */
    426469    ISR_Level        level;
    427 
     470   
    428471    /* if no requests to controller then do nothing */
    429472    if (rtems_chain_is_empty(&ata_ide_ctrls[ctrl_minor].reqs))
     
    460503    }
    461504
     505#ifdef DEBUG
     506    printf("ata_process_request: type: %d\n", areq->type);
     507#endif
     508   
    462509    /* continue to execute ATA protocols depending on type of request */
    463510    if (areq->type == ATA_COMMAND_TYPE_PIO_OUT)
     
    522569                 rtems_status_code status, int error)
    523570{
    524     preemption_key key;
    525 
    526571    assert(areq);
    527572
    528     DISABLE_PREEMPTION(key);
     573#ifdef DEBUG
     574    printf("ata_request_done: entry\n");
     575#endif
     576   
    529577    ATA_EXEC_CALLBACK(areq, status, error);
    530578    rtems_chain_extract(&areq->link);
    531 
     579   
    532580    if (!rtems_chain_is_empty(&ata_ide_ctrls[ctrl_minor].reqs))
    533581    {
    534         ENABLE_PREEMPTION(key);
    535         free(areq);
     582        free(areq);
    536583        ata_process_request(ctrl_minor);
    537584        return;
    538585    }
    539     ENABLE_PREEMPTION(key);
     586   
    540587    free(areq);
     588   
     589#ifdef DEBUG
     590    printf("ata_request_done: exit\n");
     591#endif
    541592}
    542593
     
    578629                            ata_req_t                 *areq)
    579630{
     631    PREEMPTION_KEY(key);
     632   
     633    DISABLE_PREEMPTION(key);
     634   
    580635    rtems_chain_append(&ata_ide_ctrls[ctrl_minor].reqs, &areq->link);
    581636    if (rtems_chain_has_only_one_node(&ata_ide_ctrls[ctrl_minor].reqs))
     
    598653        ATA_SEND_EVT(msg, ATA_MSG_PROCESS_NEXT_EVT, ctrl_minor, 0);
    599654    }
     655
     656    ENABLE_PREEMPTION(key);
    600657}
    601658
     
    637694}
    638695#else
    639 
    640696void ata_interrupt_handler(rtems_irq_hdl_param handle)
    641697{
     
    774830    ata_queue_msg_t msg;
    775831
     832#ifdef DEBUG
     833    printf("ata_pio_out_protocol:\n");
     834#endif
     835   
    776836    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
    777837           IDE_REGISTER_DEVICE_HEAD_DEV;
     
    827887    rtems_status_code          rc;
    828888    ISR_Level                  level;
    829 
     889   
     890    PREEMPTION_KEY(key);
     891
     892    DISABLE_PREEMPTION(key);
     893   
    830894    while (1)
    831895    {
     896        ENABLE_PREEMPTION(key);
     897       
    832898        /* get event which has happend */
    833899        rc = rtems_message_queue_receive(ata_queue_id, &msg, &size, RTEMS_WAIT,
     
    839905        ctrl_minor = msg.ctrl_minor;
    840906
     907        DISABLE_PREEMPTION(key);
     908       
    841909        /* get current request to the controller */
    842910        _ISR_Disable(level);
    843911        areq = (ata_req_t *)(ata_ide_ctrls[ctrl_minor].reqs.first);
    844912        _ISR_Enable(level);
    845 
     913       
    846914        switch(msg.type)
    847915        {
     
    926994
    927995            default:
     996#ifdef DEBUG
     997                printf("ata_queue_task: internal error\n");
     998                rtems_task_delete (RTEMS_SELF);
     999#endif
    9281000                rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR);
    9291001                break;
     
    9641036    switch (cmd)
    9651037    {
    966         case BLKIO_REQUEST:
    967             status = ata_io_data_request(device, (blkdev_request *)argp);
     1038        case RTEMS_BLKIO_REQUEST:
     1039            status = ata_io_data_request(device, (rtems_blkdev_request *)argp);
    9681040            break;
    9691041
    9701042        case ATAIO_SET_MULTIPLE_MODE:
    9711043            status = ata_non_data_request(device, cmd, argp);
     1044            break;
     1045
     1046        case RTEMS_BLKDEV_CAPABILITIES:
     1047            *((uint32_t*) argp)  = RTEMS_BLKDEV_CAP_MULTISECTOR_CONT;
     1048            status = RTEMS_SUCCESSFUL;
    9721049            break;
    9731050
     
    10001077 */
    10011078rtems_device_driver
    1002 ata_initialize(rtems_device_major_number major,
    1003                rtems_device_minor_number minor_arg,
    1004                void *args)
     1079rtems_ata_initialize(rtems_device_major_number major,
     1080                     rtems_device_minor_number minor_arg,
     1081                     void *args)
    10051082{
    10061083    uint32_t           ctrl_minor;
     
    10291106        return status;
    10301107
     1108#ifdef SAFE
     1109#ifdef SAFE_MUTEX
     1110    status = rtems_semaphore_create (rtems_build_name ('A', 'T', 'A', 'L'),
     1111                                     1, RTEMS_ATA_LOCK_ATTRIBS, 0,
     1112                                     &ata_lock);
     1113    if (status != RTEMS_SUCCESSFUL)
     1114        return status;
     1115#endif
     1116#endif
     1117   
    10311118    /* create queue for asynchronous requests handling */
    10321119    status = rtems_message_queue_create(
     
    10481135    status = rtems_task_create(
    10491136                 rtems_build_name ('A', 'T', 'A', 'T'),
    1050                  ((ata_driver_task_priority > 0)
    1051                   ? ata_driver_task_priority
     1137                 ((rtems_ata_driver_task_priority > 0)
     1138                  ? rtems_ata_driver_task_priority
    10521139                  : ATA_DRIVER_TASK_DEFAULT_PRIORITY),
    10531140                 ATA_DRIVER_TASK_STACK_SIZE,
    1054                  RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_ASR |
     1141                 RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR |
    10551142                 RTEMS_INTERRUPT_LEVEL(0),
    10561143                 RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
     
    12161303        areq.regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_ERROR);
    12171304
    1218         areq.breq = (blkdev_request *)&breq;
     1305        areq.breq = (rtems_blkdev_request *)&breq;
    12191306
    12201307        /*
     
    12771364                                              ATA_COMMAND_IDENTIFY_DEVICE;
    12781365            areq.regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_STATUS);
    1279             areq.breq = (blkdev_request *)&breq;
     1366            areq.breq = (rtems_blkdev_request *)&breq;
    12801367
    12811368            areq.cnt = breq.req.count;
     
    13641451                 ATA_DEV_INFO(ctrl_minor, dev).cylinders *
    13651452                 ATA_DEV_INFO(ctrl_minor, dev).sectors),
    1366                 (block_device_ioctl) ata_ioctl, name);
     1453                (rtems_block_device_ioctl) ata_ioctl, name);
    13671454            if (status != RTEMS_SUCCESSFUL)
    13681455            {
  • c/src/libchip/ide/ata.h

    rc4bd98c r3735f08  
    2626#include <rtems/blkdev.h>
    2727
    28 rtems_device_driver ata_initialize(
     28rtems_device_driver rtems_ata_initialize(
    2929        rtems_device_major_number major,
    3030        rtems_device_minor_number minor,
     
    3232
    3333#define ATA_DRIVER_TABLE_ENTRY \
    34     {ata_initialize, GENERIC_BLOCK_DEVICE_DRIVER_ENTRIES}
     34    {rtems_ata_initialize, RTEMS_GENERIC_BLOCK_DEVICE_DRIVER_ENTRIES}
    3535
    3636/* ATA IOCTL request codes */
     
    4444#define ATA_DRIVER_TASK_STACK_SIZE       16*1024
    4545#define ATA_DRIVER_TASK_DEFAULT_PRIORITY 140
    46   extern rtems_task_priority ata_driver_task_priority;
     46  extern rtems_task_priority rtems_ata_driver_task_priority;
    4747#ifdef __cplusplus
    4848}
  • c/src/libchip/ide/ata_internal.h

    rc4bd98c r3735f08  
    198198/* ATA request */
    199199typedef struct ata_req_s {
    200     Chain_Node        link;   /* link in requests chain */
     200    rtems_chain_node  link;   /* link in requests chain */
    201201    char              type;   /* request type */
    202202    ata_registers_t   regs;   /* ATA command */
     
    204204    uint32_t    cbuf;   /* number of current buffer from breq in use */
    205205    uint32_t    pos;    /* current position in 'cbuf' */
    206     blkdev_request  *breq;   /* blkdev_request which corresponds to the
     206    rtems_blkdev_request *breq;   /* blkdev_request which corresponds to the
    207207                               * ata request
    208208                               */
     
    259259 */
    260260typedef struct ata_int_st_s {
    261     Chain_Node                link;
     261    rtems_chain_node          link;
    262262    rtems_device_minor_number ctrl_minor;
    263263} ata_int_st_t;
     
    276276 */
    277277typedef struct ata_dev_s {
    278     int8_t       present;     /* 1 -- present, 0 -- not present, */
     278    int8_t      present;     /* 1 -- present, 0 -- not present, */
    279279                             /* -1 -- non-initialized */
    280280    uint16_t    cylinders;
     
    301301    rtems_boolean present;   /* controller state */
    302302    ata_dev_t     device[2]; /* ata diveces description */
    303     Chain_Control reqs;      /* requests chain */
     303    rtems_chain_control reqs; /* requests chain */
    304304} ata_ide_ctrl_t;
    305305
  • c/src/libchip/ide/ide_controller.c

    rc4bd98c r3735f08  
    1515 *
    1616 */
     17
     18#define IDE_CONTROLLER_TRACE 0
     19
    1720#include <rtems/chain.h>
    1821#include <assert.h>
     
    2124#include <libchip/ide_ctrl_cfg.h>
    2225#include <libchip/ide_ctrl_io.h>
     26
     27#if IDE_CONTROLLER_TRACE
     28int ide_controller_trace;
     29#endif
    2330
    2431/*
     
    8794ide_controller_read_data_block(rtems_device_minor_number  minor,
    8895                               uint16_t                   block_size,
    89                                blkdev_sg_buffer          *bufs,
    90                                uint32_t            *cbuf,
    91                                uint32_t            *pos)
    92 {
     96                               rtems_blkdev_sg_buffer    *bufs,
     97                               uint32_t                  *cbuf,
     98                               uint32_t                  *pos)
     99{
     100#if IDE_CONTROLLER_TRACE
     101    if (ide_controller_trace)
     102        printk ("IDE data block read: %d:%d\n", *cbuf, bufs[*cbuf].block);
     103#endif
    93104    IDE_Controller_Table[minor].fns->ctrl_read_block(minor, block_size, bufs,
    94105                                                     cbuf, pos);
     
    112123ide_controller_write_data_block(rtems_device_minor_number  minor,
    113124                                uint16_t                   block_size,
    114                                 blkdev_sg_buffer          *bufs,
    115                                 uint32_t            *cbuf,
    116                                 uint32_t            *pos)
    117 
    118 {
     125                                rtems_blkdev_sg_buffer    *bufs,
     126                                uint32_t                  *cbuf,
     127                                uint32_t                  *pos)
     128
     129{
     130#if IDE_CONTROLLER_TRACE
     131    if (ide_controller_trace)
     132        printk ("IDE data block write: %d:%d\n", *cbuf, bufs[*cbuf].block);
     133#endif
    119134    IDE_Controller_Table[minor].fns->ctrl_write_block(minor, block_size, bufs,
    120135                                                      cbuf, pos);
     
    139154{
    140155    IDE_Controller_Table[minor].fns->ctrl_reg_read(minor, reg, value);
     156#if IDE_CONTROLLER_TRACE
     157    if (ide_controller_trace)
     158        printk ("IDE read reg: %d => %04x\n", reg, *value);
     159#endif
    141160}
    142161
     
    157176                              uint16_t   value)
    158177{
     178#if IDE_CONTROLLER_TRACE
     179    if (ide_controller_trace)
     180        printk ("IDE write reg: %d => %04x\n", reg, value);
     181#endif
    159182    IDE_Controller_Table[minor].fns->ctrl_reg_write(minor, reg, value);
    160183}
  • c/src/libchip/ide/ide_ctrl_cfg.h

    rc4bd98c r3735f08  
    7575     */
    7676    void  (*ctrl_read_block)(int minor, uint16_t   block_size,
    77                              blkdev_sg_buffer *bufs, uint32_t   *cbuf,
     77                             rtems_blkdev_sg_buffer *bufs, uint32_t   *cbuf,
    7878                             uint32_t   *pos);
    7979    void  (*ctrl_write_block)(int minor, uint16_t   block_size,
    80                               blkdev_sg_buffer *bufs, uint32_t   *cbuf,
     80                              rtems_blkdev_sg_buffer *bufs, uint32_t   *cbuf,
    8181                              uint32_t   *pos);
    8282
  • c/src/libchip/ide/ide_ctrl_io.h

    rc4bd98c r3735f08  
    105105ide_controller_read_data_block(rtems_device_minor_number  minor,
    106106                               uint16_t                   block_size,
    107                                blkdev_sg_buffer          *bufs,
    108                                uint32_t            *cbuf,
    109                                uint32_t            *pos);
     107                               rtems_blkdev_sg_buffer    *bufs,
     108                               uint32_t                  *cbuf,
     109                               uint32_t                  *pos);
    110110
    111111/*
     
    126126ide_controller_write_data_block(rtems_device_minor_number  minor,
    127127                                uint16_t                   block_size,
    128                                 blkdev_sg_buffer          *bufs,
    129                                uint32_t             *cbuf,
    130                                uint32_t             *pos);
     128                                rtems_blkdev_sg_buffer    *bufs,
     129                                uint32_t                  *cbuf,
     130                                uint32_t                  *pos);
    131131
    132132/*
Note: See TracChangeset for help on using the changeset viewer.