Changeset a3d3d9a in rtems for c/src/libchip/ide/ata.c


Ignore:
Timestamp:
Apr 20, 2004, 10:43:39 AM (16 years ago)
Author:
Ralf Corsepius <ralf.corsepius@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
cdaff4d
Parents:
c8e8f119
Message:

Remove stray white spaces.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • c/src/libchip/ide/ata.c

    rc8e8f119 ra3d3d9a  
    22 * ata.c
    33 *
    4  * ATA RTEMS driver. ATA driver is hardware independant implementation of 
    5  * ATA-2 standart, working draft X3T10/0948D, revision 4c. ATA driver bases 
     4 * ATA RTEMS driver. ATA driver is hardware independant implementation of
     5 * ATA-2 standart, working draft X3T10/0948D, revision 4c. ATA driver bases
    66 * on RTEMS IDE controller driver.
    77 *
     
    1212 * found in the file LICENSE in this distribution or at
    1313 * http://www.rtems.com/license/LICENSE.
    14  * 
     14 *
    1515 * $Id$
    16  * 
     16 *
    1717 */
    1818#include <errno.h>
     
    5050
    5151#else
    52  
     52
    5353typedef boolean preemption_key;
    5454
     
    5858        _Thread_Executing->is_preemptible = 0;       \
    5959    } while (0)
    60    
     60
    6161#define ENABLE_PREEMPTION(key) \
    6262    do {                                             \
     
    8282
    8383/*
    84  * Mapping from ATA-minor numbers to 
     84 * Mapping from ATA-minor numbers to
    8585 * controller-minor and device on this controller.
    8686 */
     
    9797
    9898/* Mapping of interrupt vectors to devices */
    99 static Chain_Control ata_int_vec[ATA_MAX_RTEMS_INT_VEC_NUMBER + 1]; 
     99static Chain_Control ata_int_vec[ATA_MAX_RTEMS_INT_VEC_NUMBER + 1];
    100100
    101101static void
     
    106106                                  ata_req_t                 *areq);
    107107
    108 static void 
    109 ata_add_to_controller_queue(rtems_device_minor_number  ctrl_minor, 
     108static void
     109ata_add_to_controller_queue(rtems_device_minor_number  ctrl_minor,
    110110                            ata_req_t                 *areq);
    111111
    112112/*
    113  * read/write, open/close and ioctl are provided by general block device 
     113 * read/write, open/close and ioctl are provided by general block device
    114114 * driver. Only initialization and ata-specific ioctl are here.
    115115 */
    116116
    117 /* ata_io_data_request -- 
    118  *     Form read/write request for an ATA device and enqueue it to 
    119  *     IDE controller. 
    120  * 
     117/* ata_io_data_request --
     118 *     Form read/write request for an ATA device and enqueue it to
     119 *     IDE controller.
     120 *
    121121 * PARAMETERS:
    122122 *     device - device identifier
     
    125125 * RETURNS:
    126126 *     RTEMS_SUCCESSFUL on success, or error code if
    127  *     error occured 
     127 *     error occured
    128128 */
    129129static rtems_status_code
     
    131131{
    132132    ata_req_t                 *areq; /* ATA request */
    133     rtems_device_minor_number  rel_minor; /* relative minor which indexes 
     133    rtems_device_minor_number  rel_minor; /* relative minor which indexes
    134134                                           * ata_devs array
    135135                                           */
    136136    rtems_device_minor_number  ctrl_minor;
    137137    uint8_t                    dev;
    138    
    139     rel_minor = (rtems_filesystem_dev_minor_t(device)) / 
     138
     139    rel_minor = (rtems_filesystem_dev_minor_t(device)) /
    140140                ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;
    141    
     141
    142142    /* get controller which serves the ATA device */
    143143    ctrl_minor = ata_devs[rel_minor].ctrl_minor;
     
    151151        return RTEMS_NO_MEMORY;
    152152    }
    153                                                            
     153
    154154    areq->breq = req;
    155155    areq->cnt = req->count;
    156156    areq->cbuf = 0;
    157157    areq->pos = 0;
    158    
    159     /* set up registers masks */   
     158
     159    /* set up registers masks */
    160160    areq->regs.to_write = ATA_REGISTERS_POSITION;
    161161    areq->regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_STATUS);
    162    
     162
    163163    /* choose device on the controller for which the command will be issued */
    164     areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] = 
     164    areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] =
    165165                                    (dev << IDE_REGISTER_DEVICE_HEAD_DEV_POS);
    166166
     
    172172        if (req->req == BLKDEV_REQ_READ)
    173173            areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_READ_DMA;
    174         else 
     174        else
    175175            areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_WRITE_DMA;
    176176    }
    177     else 
     177    else
    178178    {
    179179        if (req->req == BLKDEV_REQ_READ)
    180180        {
    181181            areq->type = ATA_COMMAND_TYPE_PIO_IN;
    182              
    183             /* 
    184              * choose command to issue: if the number of blocks to be 
     182
     183            /*
     184             * choose command to issue: if the number of blocks to be
    185185             * exchanged is greater then 1 and for ATA command READ MULTIPLE
    186186             * data block consists of more then 1 sector choose READ MULTIPLE
    187187             * otherwise READ SECTORS
    188188             */
    189             areq->regs.regs[IDE_REGISTER_COMMAND] = 
    190                 ((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) && 
    191                  (req->count > 1) && 
    192                  (ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ? 
    193                  ATA_COMMAND_READ_MULTIPLE : 
     189            areq->regs.regs[IDE_REGISTER_COMMAND] =
     190                ((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) &&
     191                 (req->count > 1) &&
     192                 (ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ?
     193                 ATA_COMMAND_READ_MULTIPLE :
    194194                 ATA_COMMAND_READ_SECTORS;
    195195        }
     
    198198            areq->type = ATA_COMMAND_TYPE_PIO_OUT;
    199199
    200             /* 
    201              * choose command to issue: if the number of blocks to be 
     200            /*
     201             * choose command to issue: if the number of blocks to be
    202202             * exchanged is greater then 1 and for ATA command WRITE MULTIPLE
    203203             * data block consists of more then 1 sector choose WRITE MULTIPLE
    204204             * otherwise WRITE SECTORS
    205205             */
    206             areq->regs.regs[IDE_REGISTER_COMMAND] = 
     206            areq->regs.regs[IDE_REGISTER_COMMAND] =
    207207              ((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) &&
    208208               (req->count > 1) &&
    209                (ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ? 
    210                ATA_COMMAND_WRITE_MULTIPLE : 
     209               (ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ?
     210               ATA_COMMAND_WRITE_MULTIPLE :
    211211               ATA_COMMAND_WRITE_SECTORS;
    212212        }
     
    233233        /* now count = number of tracks: */
    234234        count /= ATA_DEV_INFO(ctrl_minor, dev).sectors;
    235         areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] |= 
     235        areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] |=
    236236                          (count / ATA_DEV_INFO(ctrl_minor, dev).cylinders);
    237237
     
    240240        areq->regs.regs[IDE_REGISTER_CYLINDER_LOW] = (uint8_t)count;
    241241        areq->regs.regs[IDE_REGISTER_CYLINDER_HIGH] = (uint8_t)(count >> 8);
    242         areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &= 
     242        areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &=
    243243                                                ~IDE_REGISTER_DEVICE_HEAD_L;
    244244    }
     
    246246    /* fill sector count register */
    247247    areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] = areq->breq->count;
    248    
     248
    249249    /* add request to the queue of awaiting requests to the controller */
    250250    ata_add_to_controller_queue(ctrl_minor, areq);
    251  
     251
    252252    return RTEMS_SUCCESSFUL;
    253253}
    254254
    255 /* ata_non_data_request -- 
    256  *     Form and serve request of NON DATA type for an ATA device. 
     255/* ata_non_data_request --
     256 *     Form and serve request of NON DATA type for an ATA device.
    257257 *     Processing of NON DATA request is SYNChronous operation.
    258  * 
     258 *
    259259 * PARAMETERS:
    260260 *     device - device identifier
     
    264264 * RETURNS:
    265265 *     RTEMS_SUCCESSFUL on success, or error code if
    266  *     error occured 
     266 *     error occured
    267267 */
    268268static rtems_status_code
     
    276276    rtems_device_minor_number  ctrl_minor;
    277277    uint8_t                    dev;
    278     ata_queue_msg_t            msg;   
    279    
     278    ata_queue_msg_t            msg;
     279
    280280    rel_minor = (rtems_filesystem_dev_minor_t(device)) /
    281                 ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE; 
     281                ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;
    282282
    283283    /* get controller which serves the ATA device */
     
    293293        return RTEMS_NO_MEMORY;
    294294    }
    295     memset(areq, 0, sizeof(ata_req_t));   
     295    memset(areq, 0, sizeof(ata_req_t));
    296296
    297297    areq->type = ATA_COMMAND_TYPE_NON_DATA;
    298298    areq->regs.to_write = ATA_REGISTERS_VALUE(IDE_REGISTER_COMMAND);
    299     areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] |= 
     299    areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] |=
    300300                                    (dev << IDE_REGISTER_DEVICE_HEAD_DEV_POS);
    301301    areq->breq = NULL;
    302302    areq->regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_ERROR);
    303    
    304     /* 
    305      * depending on command fill command register and additional registers 
     303
     304    /*
     305     * depending on command fill command register and additional registers
    306306     * which are needed for command execution
    307307     */
    308308    switch(cmd)
    309     { 
     309    {
    310310        case ATAIO_SET_MULTIPLE_MODE:
    311             areq->regs.regs[IDE_REGISTER_COMMAND] = 
     311            areq->regs.regs[IDE_REGISTER_COMMAND] =
    312312                                                ATA_COMMAND_SET_MULTIPLE_MODE;
    313             areq->regs.to_write |= 
     313            areq->regs.to_write |=
    314314                               ATA_REGISTERS_VALUE(IDE_REGISTER_SECTOR_COUNT);
    315315            areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] = *(uint8_t*)argp;
    316316            break;
    317        
     317
    318318        default:
    319319            free(areq);
    320320            return RTEMS_INVALID_NUMBER;
    321             break;                               
    322     } 
    323 
    324     rc = rtems_semaphore_create(rtems_build_name('I', 'D', 'E', 'S'), 
    325                                 0, 
    326                                 RTEMS_FIFO | RTEMS_COUNTING_SEMAPHORE | 
     321            break;
     322    }
     323
     324    rc = rtems_semaphore_create(rtems_build_name('I', 'D', 'E', 'S'),
     325                                0,
     326                                RTEMS_FIFO | RTEMS_COUNTING_SEMAPHORE |
    327327                                RTEMS_NO_INHERIT_PRIORITY |
    328328                                RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
     
    333333        free(areq);
    334334        return rc;
    335     }                                 
    336                                        
     335    }
     336
    337337    ata_add_to_controller_queue(ctrl_minor, areq);
    338    
     338
    339339    /* wait for request processing... */
    340340    rc = rtems_semaphore_obtain(areq->sema, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
     
    343343        free(areq);
    344344        return rc;
    345     }                                 
     345    }
    346346
    347347    rtems_semaphore_delete(areq->sema);
    348    
    349     /* 
    350      * if no error occurred and if necessary, update internal ata driver data 
     348
     349    /*
     350     * if no error occurred and if necessary, update internal ata driver data
    351351     * structures to reflect changes (in device configuration, for example)
    352      */ 
     352     */
    353353    if (areq->status == RTEMS_SUCCESSFUL)
    354354    {
    355355        switch(cmd)
    356         { 
     356        {
    357357            case ATAIO_SET_MULTIPLE_MODE:
    358                 ATA_DEV_INFO(ctrl_minor, dev).current_multiple = 
     358                ATA_DEV_INFO(ctrl_minor, dev).current_multiple =
    359359                                                           *(uint8_t*)argp;
    360360                break;
    361        
     361
    362362            default:
    363363                rc = RTEMS_INVALID_NUMBER;
    364                 break;                               
    365         } 
    366     }   
    367     else   
    368     {   
    369         /* XXX: should be correct error processing: for ex, may be 
     364                break;
     365        }
     366    }
     367    else
     368    {
     369        /* XXX: should be correct error processing: for ex, may be
    370370         * ABRT and then we should return RTEMS_NOT_IMPLEMENTED
    371371         */
    372372        rc = RTEMS_IO_ERROR;
    373     }   
    374    
     373    }
     374
    375375    /* tell ata driver that controller ready to serve next request */
    376376    ATA_SEND_EVT(msg, ATA_MSG_SUCCESS_EVT, ctrl_minor, 0);
    377                                                  
     377
    378378    return rc;
    379379}
    380380
    381 /* ata_process_request -- 
    382  *     Get first request from controller's queue and process it. 
    383  * 
     381/* ata_process_request --
     382 *     Get first request from controller's queue and process it.
     383 *
    384384 * PARAMETERS:
    385385 *     ctrl_minor - controller identifier
    386386 *
    387387 * RETURNS:
    388  *     NONE 
     388 *     NONE
    389389 */
    390390static void
     
    396396    uint8_t          i, dev;
    397397    uint16_t         val;
    398     uint16_t         data_bs; /* the number of 512-bytes sectors in one 
    399                                * data block 
     398    uint16_t         data_bs; /* the number of 512-bytes sectors in one
     399                               * data block
    400400                               */
    401     ISR_Level        level;                           
    402        
     401    ISR_Level        level;
     402
    403403    /* if no requests to controller then do nothing */
    404404    if (Chain_Is_empty(&ata_ide_ctrls[ctrl_minor].reqs))
     
    409409    areq = (ata_req_t *)(ata_ide_ctrls[ctrl_minor].reqs.first);
    410410    _ISR_Enable(level);
    411    
     411
    412412    /* get ATA device identifier (0 or 1) */
    413     dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & 
     413    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
    414414           IDE_REGISTER_DEVICE_HEAD_DEV;
    415415
    416416    /* get data block size */
    417     data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ? 
    418               ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;     
    419    
     417    data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
     418              ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
     419
    420420    /* execute device select protocol */
    421     ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD, 
     421    ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD,
    422422                                  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]);
    423    
     423
    424424    do {
    425425        ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &byte);
    426     } while ((byte & IDE_REGISTER_STATUS_BSY) || 
     426    } while ((byte & IDE_REGISTER_STATUS_BSY) ||
    427427             (!(byte & IDE_REGISTER_STATUS_DRDY)));
    428428
     
    439439    {
    440440        do {
    441             ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, 
     441            ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
    442442                                         &byte);
    443443        } while (byte & IDE_REGISTER_STATUS_BSY);
     
    446446        {
    447447            ide_controller_write_data_block(
    448                 ctrl_minor, 
     448                ctrl_minor,
    449449                MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE,
    450450                areq->breq->bufs, &areq->cbuf,
    451451                &areq->pos);
    452452            areq->cnt -= MIN(data_bs, areq->cnt);
    453         }   
     453        }
    454454        else
    455         {   
     455        {
    456456            if (IDE_Controller_Table[ctrl_minor].int_driven == 0)
    457457            {
    458458                ide_controller_read_register(
    459                     ctrl_minor, 
     459                    ctrl_minor,
    460460                    IDE_REGISTER_ALTERNATE_STATUS_OFFSET,
    461461                    &val);
     
    463463                                             &val);
    464464
    465                 ATA_SEND_EVT(msg, ATA_MSG_ERROR_EVT, ctrl_minor, 
     465                ATA_SEND_EVT(msg, ATA_MSG_ERROR_EVT, ctrl_minor,
    466466                             RTEMS_IO_ERROR);
    467467            }
    468         }   
     468        }
    469469    }
    470470
     
    472472    {
    473473        do {
    474             ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, 
     474            ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
    475475                                         &byte);
    476476        } while (byte & IDE_REGISTER_STATUS_BSY);
    477        
     477
    478478        ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, ctrl_minor, 0);
    479     }   
     479    }
    480480}
    481481
    482 /* ata_request_done -- 
     482/* ata_request_done --
    483483 *     Extract request from controller queue, execute callback if necessary
    484484 *     and process next request for the controller.
    485  * 
     485 *
    486486 * PARAMETERS:
    487  *     areq       - ATA request 
     487 *     areq       - ATA request
    488488 *     ctrl_minor - controller identifier
    489489 *     status     - status with which request has been done
     
    512512        return;
    513513    }
    514     ENABLE_PREEMPTION(key); 
     514    ENABLE_PREEMPTION(key);
    515515}
    516516
    517 /* ata_non_data_request_done -- 
     517/* ata_non_data_request_done --
    518518 *     Set up request status and release request's semaphore.
    519  * 
     519 *
    520520 * PARAMETERS:
    521  *     areq       - ATA request 
     521 *     areq       - ATA request
    522522 *     ctrl_minor - controller identifier
    523523 *     status     - status with which request has been done
     
    528528 */
    529529static inline void
    530 ata_non_data_request_done(ata_req_t *areq, 
     530ata_non_data_request_done(ata_req_t *areq,
    531531                          rtems_device_minor_number ctrl_minor,
    532532                          rtems_status_code status, int error)
     
    538538
    539539
    540 /* ata_add_to_controller_queue -- 
     540/* ata_add_to_controller_queue --
    541541 *     Add request to the controller's queue.
    542  * 
     542 *
    543543 * PARAMETERS:
    544544 *     ctrl_minor - controller identifier
    545  *     areq       - ATA request 
     545 *     areq       - ATA request
    546546 *
    547547 * RETURNS:
     
    549549 */
    550550static void
    551 ata_add_to_controller_queue(rtems_device_minor_number  ctrl_minor, 
     551ata_add_to_controller_queue(rtems_device_minor_number  ctrl_minor,
    552552                            ata_req_t                 *areq)
    553553{
     
    559559
    560560#ifdef DEBUG
    561         /* 
     561        /*
    562562         * read IDE_REGISTER_ALTERNATE_STATUS instead IDE_REGISTER_STATUS
    563563         * to prevent clearing of pending interrupt
    564564         */
    565         ide_controller_read_register(ctrl_minor, 
    566                                      IDE_REGISTER_ALTERNATE_STATUS, 
     565        ide_controller_read_register(ctrl_minor,
     566                                     IDE_REGISTER_ALTERNATE_STATUS,
    567567                                     &val);
    568568        if (val & IDE_REGISTER_STATUS_BSY)
     
    570570#endif
    571571        ATA_SEND_EVT(msg, ATA_MSG_PROCESS_NEXT_EVT, ctrl_minor, 0);
    572     }   
    573 }                           
    574 
    575 
    576 /* ata_interrupt_handler -- 
     572    }
     573}
     574
     575
     576/* ata_interrupt_handler --
    577577 *     ATA driver interrrupt handler. If interrrupt happend it mapped it to
    578578 *     controller (controllerS, if a number of controllers share one int line)
    579579 *     and generates ATA event(s).
    580  * 
     580 *
    581581 * PARAMETERS:
    582  *     vec - interrupt vector 
     582 *     vec - interrupt vector
    583583 *
    584584 * RETURNS:
     
    591591    ata_queue_msg_t  msg;
    592592    uint16_t         byte; /* emphasize that only 8 low bits is meaningful */
    593    
     593
    594594    for ( ; !Chain_Is_tail(&ata_int_vec[vec], the_node) ; )
    595595    {
     
    601601        {
    602602            msg.ctrl_minor = ((ata_int_st_t *)the_node)->ctrl_minor;
    603             ide_controller_read_register(msg.ctrl_minor, IDE_REGISTER_STATUS, 
     603            ide_controller_read_register(msg.ctrl_minor, IDE_REGISTER_STATUS,
    604604                                         &byte);
    605             ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, msg.ctrl_minor, 0);                             
     605            ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, msg.ctrl_minor, 0);
    606606        }
    607607        the_node = the_node->next;
    608     }   
     608    }
    609609}
    610610
    611 /* ata_pio_in_protocol -- 
     611/* ata_pio_in_protocol --
    612612 *     ATA PIO_IN protocol implementation, see specification
    613  * 
     613 *
    614614 * PARAMETERS:
    615615 *     ctrl_minor - controller identifier
    616  *     areq       - ATA request 
     616 *     areq       - ATA request
    617617 *
    618618 * RETURNS:
     
    626626    uint32_t        min_val;
    627627    ata_queue_msg_t msg;
    628        
    629     dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & 
     628
     629    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
    630630           IDE_REGISTER_DEVICE_HEAD_DEV;
    631631
    632     bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ? 
    633          ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;     
     632    bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
     633         ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
    634634    min_val = MIN(bs, areq->cnt);
    635    
    636     ide_controller_read_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE, 
     635
     636    ide_controller_read_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE,
    637637                                   areq->breq->bufs, &areq->cbuf, &areq->pos);
    638              
     638
    639639    areq->cnt -= min_val;
    640640    if (areq->cnt == 0)
     
    647647           ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &val);
    648648        } while (val & IDE_REGISTER_STATUS_BSY);
    649        
     649
    650650        ATA_SEND_EVT(msg, ATA_MSG_GEN_EVT, ctrl_minor, 0);
    651651    }
    652652}
    653653
    654 /* ata_pio_out_protocol -- 
     654/* ata_pio_out_protocol --
    655655 *     ATA PIO_OUT protocol implementation, see specification
    656  * 
     656 *
    657657 * PARAMETERS:
    658658 *     ctrl_minor - controller identifier
    659  *     areq       - ATA request 
     659 *     areq       - ATA request
    660660 *
    661661 * RETURNS:
     
    669669    uint32_t        min_val;
    670670    ata_queue_msg_t msg;
    671    
    672     dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & 
     671
     672    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
    673673           IDE_REGISTER_DEVICE_HEAD_DEV;
    674674
    675     bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ? 
    676          ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;     
    677 
    678     min_val = MIN(bs, areq->cnt);     
     675    bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
     676         ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
     677
     678    min_val = MIN(bs, areq->cnt);
    679679
    680680    if (areq->cnt == 0)
     
    682682        ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, RTEMS_SUCCESSFUL);
    683683    }
    684     else 
     684    else
    685685    {
    686686        ide_controller_write_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE,
    687                                         areq->breq->bufs, &areq->cbuf, 
     687                                        areq->breq->bufs, &areq->cbuf,
    688688                                        &areq->pos);
    689689        areq->cnt -= min_val;
     
    691691        {
    692692            do {
    693                 ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, 
     693                ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
    694694                                             &val);
    695695            } while (val & IDE_REGISTER_STATUS_BSY);
     
    700700}
    701701
    702 /* ata_queue_task -- 
     702/* ata_queue_task --
    703703 *     Task which manages ATA driver events queue.
    704  * 
     704 *
    705705 * PARAMETERS:
    706706 *     arg - ignored
     
    710710 *
    711711 * NOTES:
    712  *     should be non-preemptive 
     712 *     should be non-preemptive
    713713 */
    714714static rtems_task
     
    727727    {
    728728        /* get event which has happend */
    729         rc = rtems_message_queue_receive(ata_queue_id, &msg, &size, RTEMS_WAIT, 
     729        rc = rtems_message_queue_receive(ata_queue_id, &msg, &size, RTEMS_WAIT,
    730730                                         RTEMS_NO_TIMEOUT);
    731731        if (rc != RTEMS_SUCCESSFUL)
    732732            rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR);
    733                                              
     733
    734734        /* get controller on which event has happend */
    735735        ctrl_minor = msg.ctrl_minor;
    736        
     736
    737737        /* get current request to the controller */
    738         _ISR_Disable(level);       
     738        _ISR_Disable(level);
    739739        areq = (ata_req_t *)(ata_ide_ctrls[ctrl_minor].reqs.first);
    740740        _ISR_Enable(level);
    741        
     741
    742742        switch(msg.type)
    743743        {
     
    748748
    749749            case ATA_MSG_SUCCESS_EVT:
    750                 /* 
    751                  * finish processing of current request with successful 
    752                  * status and start processing of the next request in the 
     750                /*
     751                 * finish processing of current request with successful
     752                 * status and start processing of the next request in the
    753753                 * controller queue
    754754                 */
    755                 ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, 
     755                ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL,
    756756                                 msg.error);
    757757                break;
    758                
     758
    759759            case ATA_MSG_ERROR_EVT:
    760                 /* 
    761                  * finish processing of current request with error 
    762                  * status and start processing of the next request in the 
     760                /*
     761                 * finish processing of current request with error
     762                 * status and start processing of the next request in the
    763763                 * controller queue
    764764                 */
    765                 ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED, 
     765                ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED,
    766766                                 msg.error);
    767767                break;
    768                
     768
    769769            case ATA_MSG_GEN_EVT:
    770                 /* 
    771                  * continue processing of the current request to the 
    772                  * controller according to current request state and 
     770                /*
     771                 * continue processing of the current request to the
     772                 * controller according to current request state and
    773773                 * ATA protocol
    774774                 */
    775                 ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, 
     775                ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS,
    776776                                           &val);
    777777                /* process error case */
    778778                if (val & IDE_REGISTER_STATUS_ERR)
    779                 { 
    780                     ide_controller_read_register(ctrl_minor, 
    781                                                  IDE_REGISTER_ERROR, 
     779                {
     780                    ide_controller_read_register(ctrl_minor,
     781                                                 IDE_REGISTER_ERROR,
    782782                                                 &val);
    783783                    if (areq->type == ATA_COMMAND_TYPE_NON_DATA)
    784                         ata_non_data_request_done(areq, ctrl_minor, 
    785                                                   RTEMS_UNSATISFIED, 
     784                        ata_non_data_request_done(areq, ctrl_minor,
     785                                                  RTEMS_UNSATISFIED,
    786786                                                  RTEMS_IO_ERROR);
    787                     else                             
    788                         ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED, 
     787                    else
     788                        ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED,
    789789                                         RTEMS_IO_ERROR);
    790                     break;                                 
     790                    break;
    791791                }
    792792
     
    796796                        ata_pio_in_protocol(ctrl_minor, areq);
    797797                        break;
    798                
     798
    799799                    case ATA_COMMAND_TYPE_PIO_OUT:
    800800                        ata_pio_out_protocol(ctrl_minor, areq);
    801801                        break;
    802                
     802
    803803                    case ATA_COMMAND_TYPE_NON_DATA:
    804                         ide_controller_read_register(ctrl_minor, 
    805                                                       IDE_REGISTER_ERROR, 
     804                        ide_controller_read_register(ctrl_minor,
     805                                                      IDE_REGISTER_ERROR,
    806806                                                     &val1);
    807807                        ata_non_data_request_done(areq, ctrl_minor,
     
    809809                                                  val1);
    810810                        break;
    811            
     811
    812812                    default:
    813813                        printf("ata_queue_task: non-supported command type\n");
     
    815815                                         RTEMS_UNSATISFIED,
    816816                                         RTEMS_NOT_IMPLEMENTED);
    817                         break;         
     817                        break;
    818818                }
    819                 break;   
     819                break;
    820820
    821821            default:
     
    826826}
    827827
    828 /* ata_ioctl -- 
     828/* ata_ioctl --
    829829 *     ATA driver ioctl interface.
    830  * 
     830 *
    831831 * PARAMETERS:
    832832 *     device - device identifier
     
    837837 *     depend on 'cmd'
    838838 */
    839 int 
     839int
    840840ata_ioctl(dev_t device, int cmd, void *argp)
    841841{
    842842    rtems_status_code         status;
    843843    rtems_device_minor_number rel_minor;
    844    
     844
    845845    rel_minor = (rtems_filesystem_dev_minor_t(device)) /
    846846                ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;
    847847
    848     /* 
     848    /*
    849849     * in most cases this means that device 'device' is not an registred ATA
    850850     * device
    851      */ 
     851     */
    852852    if (ata_devs[rel_minor].device == ATA_UNDEFINED_VALUE)
    853853    {
    854854        errno = ENODEV;
    855855        return -1;
    856     }   
    857 
    858     switch (cmd) 
     856    }
     857
     858    switch (cmd)
    859859    {
    860860        case BLKIO_REQUEST:
    861861            status = ata_io_data_request(device, (blkdev_request *)argp);
    862862            break;
    863        
     863
    864864        case ATAIO_SET_MULTIPLE_MODE:
    865865            status = ata_non_data_request(device, cmd, argp);
    866866            break;
    867      
     867
    868868        default:
    869869            errno = EBADRQC;
     
    875875    {
    876876        errno = EIO;
    877         return -1; 
     877        return -1;
    878878    }
    879879    return 0;
     
    883883 * ata_initialize --
    884884 *     Initializes all ATA devices found on initialized IDE controllers.
    885  * 
     885 *
    886886 * PARAMETERS:
    887887 *     major - device major number
     
    891891 * RETURNS:
    892892 *     RTEMS_SUCCESSFUL on success, or error code if
    893  *     error occured 
    894  */
    895 rtems_device_driver 
    896 ata_initialize(rtems_device_major_number major, 
    897                rtems_device_minor_number minor_arg, 
     893 *     error occured
     894 */
     895rtems_device_driver
     896ata_initialize(rtems_device_major_number major,
     897               rtems_device_minor_number minor_arg,
    898898               void *args)
    899899{
     
    901901    rtems_status_code  status;
    902902    ata_req_t          areq;
    903     blkdev_request1    breq;     
     903    blkdev_request1    breq;
    904904    uint8_t            i, dev = 0;
    905905    uint16_t          *buffer;
     
    912912    if (ata_initialized)
    913913        return RTEMS_SUCCESSFUL;
    914            
     914
    915915    /* initialization of disk devices library */
    916916    status = rtems_disk_io_initialize();
    917917    if (status != RTEMS_SUCCESSFUL)
    918918        return status;
    919        
     919
    920920    /* create queue for asynchronous requests handling */
    921921    status = rtems_message_queue_create(
     
    929929        rtems_disk_io_done();
    930930        return status;
    931     }   
    932 
    933     /* 
    934      * create ATA driver task, see comments for task implementation for 
    935      * details 
     931    }
     932
     933    /*
     934     * create ATA driver task, see comments for task implementation for
     935     * details
    936936     */
    937937    status = rtems_task_create(
     
    939939                 ATA_DRIVER_TASK_PRIORITY,
    940940                 ATA_DRIVER_TASK_STACK_SIZE,
    941                  RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_ASR | 
     941                 RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_ASR |
    942942                 RTEMS_INTERRUPT_LEVEL(0),
    943943                 RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
     
    948948        rtems_disk_io_done();
    949949        return status;
    950     }   
    951    
    952     /* 
    953      * start ATA driver task. Actually the task will not start immediately - 
     950    }
     951
     952    /*
     953     * start ATA driver task. Actually the task will not start immediately -
    954954     * it will start only after multitasking support will be started
    955      */ 
    956     status = rtems_task_start(ata_task_id, ata_queue_task, 0); 
     955     */
     956    status = rtems_task_start(ata_task_id, ata_queue_task, 0);
    957957    if (status != RTEMS_SUCCESSFUL)
    958958    {
     
    961961        rtems_disk_io_done();
    962962        return status;
    963     }   
    964    
     963    }
     964
    965965    buffer = (uint16_t*)malloc(ATA_SECTOR_SIZE);
    966966    if (buffer == NULL)
     
    970970        rtems_disk_io_done();
    971971        return RTEMS_NO_MEMORY;
    972     }   
    973        
     972    }
     973
    974974    ata_devs_number = 0;
    975975
     
    981981        Chain_Initialize_empty(&ata_int_vec[i]);
    982982
    983     /* 
    984      * during ATA driver initialization EXECUTE DEVICE DIAGNOSTIC and 
    985      * IDENTIFY DEVICE ATA command should be issued; for these purposes ATA 
    986      * requests should be formed; ATA requests contain block device request, 
     983    /*
     984     * during ATA driver initialization EXECUTE DEVICE DIAGNOSTIC and
     985     * IDENTIFY DEVICE ATA command should be issued; for these purposes ATA
     986     * requests should be formed; ATA requests contain block device request,
    987987     * so form block device request first
    988988     */
     
    995995    breq.req.bufs[0].buffer = buffer;
    996996
    997     /* 
     997    /*
    998998     * for each presented IDE controller execute EXECUTE DEVICE DIAGNOSTIC
    999      * ATA command; for each found device execute IDENTIFY DEVICE ATA 
    1000      * command 
     999     * ATA command; for each found device execute IDENTIFY DEVICE ATA
     1000     * command
    10011001     */
    10021002    for (ctrl_minor = 0; ctrl_minor < IDE_Controller_Count; ctrl_minor++)
     
    10041004    {
    10051005        Chain_Initialize_empty(&ata_ide_ctrls[ctrl_minor].reqs);
    1006        
     1006
    10071007        if (IDE_Controller_Table[ctrl_minor].int_driven == TRUE)
    10081008        {
     
    10151015                rtems_disk_io_done();
    10161016                return RTEMS_NO_MEMORY;
    1017             }       
     1017            }
    10181018
    10191019            int_st->ctrl_minor = ctrl_minor;
    10201020
    10211021            status = rtems_interrupt_catch(
    1022                          ata_interrupt_handler, 
    1023                          IDE_Controller_Table[ctrl_minor].int_vec, 
     1022                         ata_interrupt_handler,
     1023                         IDE_Controller_Table[ctrl_minor].int_vec,
    10241024                         &old_isr);
    10251025            if (status != RTEMS_SUCCESSFUL)
     
    10311031                rtems_disk_io_done();
    10321032                return status;
    1033             } 
     1033            }
    10341034            Chain_Append(
    10351035                &ata_int_vec[IDE_Controller_Table[ctrl_minor].int_vec],
     
    10371037
    10381038            /* disable interrupts */
    1039             ide_controller_write_register(ctrl_minor, 
    1040                                           IDE_REGISTER_DEVICE_CONTROL_OFFSET, 
     1039            ide_controller_write_register(ctrl_minor,
     1040                                          IDE_REGISTER_DEVICE_CONTROL_OFFSET,
    10411041                                          IDE_REGISTER_DEVICE_CONTROL_nIEN);
    10421042        }
     
    10491049        areq.type = ATA_COMMAND_TYPE_NON_DATA;
    10501050        areq.regs.to_write = ATA_REGISTERS_VALUE(IDE_REGISTER_COMMAND);
    1051         areq.regs.regs[IDE_REGISTER_COMMAND] = 
     1051        areq.regs.regs[IDE_REGISTER_COMMAND] =
    10521052                                  ATA_COMMAND_EXECUTE_DEVICE_DIAGNOSTIC;
    10531053        areq.regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_ERROR);
     
    10551055        areq.breq = (blkdev_request *)&breq;
    10561056
    1057         /* 
    1058          * Process the request. Special processing of requests on 
    1059          * initialization phase is needed because at this moment there 
     1057        /*
     1058         * Process the request. Special processing of requests on
     1059         * initialization phase is needed because at this moment there
    10601060         * is no multitasking enviroment
    10611061         */
     
    10671067        if (breq.req.status != RTEMS_SUCCESSFUL)
    10681068            continue;
    1069      
    1070         /* disassemble returned diagnostic codes */ 
     1069
     1070        /* disassemble returned diagnostic codes */
    10711071        if (breq.req.error == ATA_DEV0_PASSED_DEV1_PASSED_OR_NOT_PRSNT)
    10721072        {
    10731073            ATA_DEV_INFO(ctrl_minor, 0).present = 1;
    1074             ATA_DEV_INFO(ctrl_minor,1).present = 1; 
     1074            ATA_DEV_INFO(ctrl_minor,1).present = 1;
    10751075        }
    10761076        else if (breq.req.error == ATA_DEV0_PASSED_DEV1_FAILED)
     
    11051105        {
    11061106            /*
    1107              * Issue DEVICE IDENTIFY ATA command and get device 
    1108              * configuration           
     1107             * Issue DEVICE IDENTIFY ATA command and get device
     1108             * configuration
    11091109             */
    11101110            memset(&areq, 0, sizeof(ata_req_t));
    11111111            areq.type = ATA_COMMAND_TYPE_PIO_IN;
    11121112            areq.regs.to_write = ATA_REGISTERS_VALUE(IDE_REGISTER_COMMAND);
    1113             areq.regs.regs[IDE_REGISTER_COMMAND] = 
     1113            areq.regs.regs[IDE_REGISTER_COMMAND] =
    11141114                                              ATA_COMMAND_IDENTIFY_DEVICE;
    11151115            areq.regs.to_read = ATA_REGISTERS_VALUE(IDE_REGISTER_STATUS);
    11161116            areq.breq = (blkdev_request *)&breq;
    1117            
     1117
    11181118            areq.cnt = breq.req.count;
    11191119
     
    11211121                                    (dev << IDE_REGISTER_DEVICE_HEAD_DEV_POS);
    11221122
    1123             /* 
    1124              * Process the request. Special processing of requests on 
    1125              * initialization phase is needed because at this moment there 
     1123            /*
     1124             * Process the request. Special processing of requests on
     1125             * initialization phase is needed because at this moment there
    11261126             * is no multitasking enviroment
    11271127             */
     
    11331133
    11341134            /*
    1135              * Parse returned device configuration and fill in ATA internal 
     1135             * Parse returned device configuration and fill in ATA internal
    11361136             * device info structure
    11371137             */
    1138             ATA_DEV_INFO(ctrl_minor, dev).cylinders = 
     1138            ATA_DEV_INFO(ctrl_minor, dev).cylinders =
    11391139                CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_CLNDS]);
    1140             ATA_DEV_INFO(ctrl_minor, dev).heads = 
     1140            ATA_DEV_INFO(ctrl_minor, dev).heads =
    11411141                CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_HEADS]);
    1142             ATA_DEV_INFO(ctrl_minor, dev).sectors = 
     1142            ATA_DEV_INFO(ctrl_minor, dev).sectors =
    11431143                CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_SECS]);
    1144             ATA_DEV_INFO(ctrl_minor, dev).lba_sectors = 
    1145                 (CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS0]) << 16) + 
     1144            ATA_DEV_INFO(ctrl_minor, dev).lba_sectors =
     1145                (CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS0]) << 16) +
    11461146                 CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS1]);
    1147             ATA_DEV_INFO(ctrl_minor, dev).lba_avaible = 
     1147            ATA_DEV_INFO(ctrl_minor, dev).lba_avaible =
    11481148                (CF_LE_W(buffer[ATA_IDENT_WORD_CAPABILITIES]) >> 9) & 0x1;
    1149             ATA_DEV_INFO(ctrl_minor, dev).max_multiple = 
     1149            ATA_DEV_INFO(ctrl_minor, dev).max_multiple =
    11501150                (uint8_t) (CF_LE_W(buffer[ATA_IDENT_WORD_RW_MULT]));
    1151             ATA_DEV_INFO(ctrl_minor, dev).current_multiple = 
    1152                 (CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS]) & 0x100) ? 
     1151            ATA_DEV_INFO(ctrl_minor, dev).current_multiple =
     1152                (CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS]) & 0x100) ?
    11531153                (uint8_t)(CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS])) :
    11541154                 0;
    11551155
    1156             if ((CF_LE_W(buffer[ATA_IDENT_WORD_FIELD_VALIDITY]) & 
     1156            if ((CF_LE_W(buffer[ATA_IDENT_WORD_FIELD_VALIDITY]) &
    11571157                 ATA_IDENT_BIT_VALID) == 0) {
    11581158              /* no "supported modes" info -> use default */
     
    11641164                ((CF_LE_W(buffer[64]) & 0x2) ? ATA_MODES_PIO4 : 0) |
    11651165                ((CF_LE_W(buffer[63]) & 0x1) ? ATA_MODES_DMA0 : 0) |
    1166                 ((CF_LE_W(buffer[63]) & 0x2) ? 
     1166                ((CF_LE_W(buffer[63]) & 0x2) ?
    11671167                 ATA_MODES_DMA0 | ATA_MODES_DMA1 : 0) |
    1168                 ((CF_LE_W(buffer[63]) & 0x4) ? 
     1168                ((CF_LE_W(buffer[63]) & 0x4) ?
    11691169                 ATA_MODES_DMA0 | ATA_MODES_DMA1 | ATA_MODES_DMA2 : 0);
    11701170              if (ATA_DEV_INFO(ctrl_minor, dev).modes_avaible == 0)
    11711171                continue;
    1172               /* 
     1172              /*
    11731173               * choose most appropriate ATA device data I/O speed supported
    11741174               * by the controller
    11751175               */
    11761176              status = ide_controller_config_io_speed(
    1177                 ctrl_minor, 
     1177                ctrl_minor,
    11781178                ATA_DEV_INFO(ctrl_minor, dev).modes_avaible);
    11791179              if (status != RTEMS_SUCCESSFUL)
    11801180                continue;
    1181             }     
     1181            }
    11821182            /*
    11831183             * Ok, let register new ATA device in the system
     
    11911191
    11921192            device = rtems_filesystem_make_dev_t(
    1193                          major, 
    1194                          (ata_devs_number * 
     1193                         major,
     1194                         (ata_devs_number *
    11951195                          ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE));
    11961196
    1197             status = rtems_disk_create_phys(device, ATA_SECTOR_SIZE, 
    1198                 ATA_DEV_INFO(ctrl_minor, dev).lba_avaible ? 
    1199                 ATA_DEV_INFO(ctrl_minor, dev).lba_sectors : 
     1197            status = rtems_disk_create_phys(device, ATA_SECTOR_SIZE,
     1198                ATA_DEV_INFO(ctrl_minor, dev).lba_avaible ?
     1199                ATA_DEV_INFO(ctrl_minor, dev).lba_sectors :
    12001200                (ATA_DEV_INFO(ctrl_minor, dev).heads *
    12011201                 ATA_DEV_INFO(ctrl_minor, dev).cylinders *
     
    12061206                ata_devs[ata_devs_number].device = ATA_UNDEFINED_VALUE;
    12071207                continue;
    1208             }       
     1208            }
    12091209            ata_devs_number++;
    12101210        }
    12111211        if (IDE_Controller_Table[ctrl_minor].int_driven == TRUE)
    1212         {   
    1213             ide_controller_write_register(ctrl_minor, 
    1214                                           IDE_REGISTER_DEVICE_CONTROL_OFFSET, 
     1212        {
     1213            ide_controller_write_register(ctrl_minor,
     1214                                          IDE_REGISTER_DEVICE_CONTROL_OFFSET,
    12151215                                          0x00);
    12161216        }
     
    12221222}
    12231223
    1224 /* ata_process_request_on_init_phase -- 
    1225  *     Process the ATA request during system initialization. Request 
     1224/* ata_process_request_on_init_phase --
     1225 *     Process the ATA request during system initialization. Request
    12261226 *     processing is syncronous and doesn't use multiprocessing enviroment.
    1227  * 
     1227 *
    12281228 * PARAMETERS:
    12291229 *     ctrl_minor - controller identifier
     
    12311231 *
    12321232 * RETURNS:
    1233  *     NONE 
     1233 *     NONE
    12341234 */
    12351235static void
     
    12401240    uint8_t            i, dev;
    12411241    uint16_t           val, val1;
    1242     uint16_t           data_bs; /* the number of 512 bytes sectors into one 
    1243                                  * data block 
     1242    uint16_t           data_bs; /* the number of 512 bytes sectors into one
     1243                                 * data block
    12441244                                 */
    12451245    assert(areq);
    1246    
    1247     dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & 
     1246
     1247    dev =  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
    12481248           IDE_REGISTER_DEVICE_HEAD_DEV;
    12491249
    1250     data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ? 
    1251               ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;     
    1252    
    1253     ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD, 
     1250    data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
     1251              ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
     1252
     1253    ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD,
    12541254                                  areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]);
    1255    
     1255
    12561256    do {
    12571257        ide_controller_read_register(ctrl_minor, IDE_REGISTER_STATUS, &byte);
    1258     } while ((byte & IDE_REGISTER_STATUS_BSY) || 
     1258    } while ((byte & IDE_REGISTER_STATUS_BSY) ||
    12591259             (!(byte & IDE_REGISTER_STATUS_DRDY)));
    12601260
     
    12631263        uint32_t   reg = (1 << i);
    12641264        if (areq->regs.to_write & reg)
    1265             ide_controller_write_register(ctrl_minor, i, 
     1265            ide_controller_write_register(ctrl_minor, i,
    12661266                                          areq->regs.regs[i]);
    12671267    }
     
    12801280        return;
    12811281    }
    1282  
     1282
    12831283    switch(areq->type)
    12841284    {
    12851285        case ATA_COMMAND_TYPE_PIO_IN:
    12861286            ide_controller_read_data_block(
    1287                 ctrl_minor, 
     1287                ctrl_minor,
    12881288                MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE,
    12891289                areq->breq->bufs, &areq->cbuf,
    12901290                &areq->pos);
    1291              
     1291
    12921292            areq->cnt -= MIN(data_bs, areq->cnt);
    12931293            if (areq->cnt == 0)
     
    12951295                areq->breq->status = RTEMS_SUCCESSFUL;
    12961296            }
    1297             else 
     1297            else
    12981298            {
    1299                 /* 
    1300                  * this shouldn't happend on the initialization 
    1301                  * phase! 
     1299                /*
     1300                 * this shouldn't happend on the initialization
     1301                 * phase!
    13021302                 */
    1303                 rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR); 
     1303                rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR);
    13041304            }
    13051305            break;
    1306                
     1306
    13071307        case ATA_COMMAND_TYPE_NON_DATA:
    13081308            areq->breq->status = RTEMS_SUCCESSFUL;
    13091309            areq->breq->error = val1;
    13101310            break;
    1311            
     1311
    13121312        default:
    13131313            printf("ata_queue_task: non-supported command type\n");
    13141314            areq->breq->status = RTEMS_UNSATISFIED;
    13151315            areq->breq->error = RTEMS_NOT_IMPLEMENTED;
    1316             break;         
     1316            break;
    13171317    }
    13181318}
Note: See TracChangeset for help on using the changeset viewer.