RTOS/rtems
1
0
Fork 0
forked from Imagelibrary/rtems
Code Pull Requests Activity

2009-10-08 Chris Johns <chrisj@rtems.org>

Browse Source 
* 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.
This commit is contained in:
Chris Johns
2009-10-08 07:25:15 +00:00
parent c1fc5d4709
commit 7357f5665b
6 changed files with 141 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
c/src/ChangeLog
View File

@@ -1,3 +1,17 @@
2009-10-08 Chris Johns <chrisj@rtems.org>
* 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.
2009-10-05 Joel Sherrill <joel.sherrill@oarcorp.com> 2009-10-05 Joel Sherrill <joel.sherrill@oarcorp.com>
* libchip/ide/ata.c: Revert previous change. Not all ARM BSPs use a * libchip/ide/ata.c: Revert previous change. Not all ARM BSPs use a

233
c/src/libchip/ide/ata.c
View File

@@ -26,10 +26,13 @@
#include <libchip/ide_ctrl_cfg.h> #include <libchip/ide_ctrl_cfg.h>
#include "ata_internal.h" #include "ata_internal.h"
#include <libchip/ata.h> #include <libchip/ata.h>
/* #define DEBUG */
#ifdef DEBUG #define ATA_DEBUG 0
#if ATA_DEBUG
#include <stdio.h> #include <stdio.h>
bool ata_trace;
#define ata_printf if (ata_trace) printf
#endif #endif
/* /*
@@ -237,45 +240,23 @@ ata_io_data_request(dev_t device, rtems_blkdev_request *req)
{ {
if (req->req == RTEMS_BLKDEV_REQ_READ) if (req->req == RTEMS_BLKDEV_REQ_READ)
{ {
#ifdef DEBUG
printf("ata_io_data_request: type: READ: %d, %d\n",
req->bufs[0].block, req->bufnum);
#endif
areq->type = ATA_COMMAND_TYPE_PIO_IN; areq->type = ATA_COMMAND_TYPE_PIO_IN;
areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_READ_SECTORS;
/* #if ATA_DEBUG
* choose command to issue: if the number of blocks to be ata_printf("ata_io_data_request: type: READ: %lu, %lu cmd:%02x\n",
* exchanged is greater then 1 and for ATA command READ MULTIPLE req->bufs[0].block, req->bufnum,
* data block consists of more then 1 sector choose READ MULTIPLE areq->regs.regs[IDE_REGISTER_COMMAND]);
* otherwise READ SECTORS #endif
*/
areq->regs.regs[IDE_REGISTER_COMMAND] =
((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) &&
(req->bufnum > 1) &&
(ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ?
ATA_COMMAND_READ_MULTIPLE :
ATA_COMMAND_READ_SECTORS;
} }
else else
{ {
#ifdef DEBUG
printf("ata_io_data_request: type: WRITE: %d, %d\n",
req->bufs[0].block, req->bufnum);
#endif
areq->type = ATA_COMMAND_TYPE_PIO_OUT; areq->type = ATA_COMMAND_TYPE_PIO_OUT;
areq->regs.regs[IDE_REGISTER_COMMAND] = ATA_COMMAND_WRITE_SECTORS;
/* #if ATA_DEBUG
* choose command to issue: if the number of blocks to be ata_printf("ata_io_data_request: type: WRITE: %lu, %lu cmd:%02x\n",
* exchanged is greater then 1 and for ATA command WRITE MULTIPLE req->bufs[0].block, req->bufnum,
* data block consists of more then 1 sector choose WRITE MULTIPLE areq->regs.regs[IDE_REGISTER_COMMAND]);
* otherwise WRITE SECTORS #endif
*/
areq->regs.regs[IDE_REGISTER_COMMAND] =
((ATA_DEV_INFO(ctrl_minor, dev).max_multiple) &&
(req->bufnum > 1) &&
(ATA_DEV_INFO(ctrl_minor, dev).current_multiple > 1)) ?
ATA_COMMAND_WRITE_MULTIPLE :
ATA_COMMAND_WRITE_SECTORS;
} }
} }
@@ -288,6 +269,7 @@ ata_io_data_request(dev_t device, rtems_blkdev_request *req)
areq->regs.regs[IDE_REGISTER_LBA0] = (uint8_t)start; areq->regs.regs[IDE_REGISTER_LBA0] = (uint8_t)start;
areq->regs.regs[IDE_REGISTER_LBA1] = (uint8_t)(start >> 8); areq->regs.regs[IDE_REGISTER_LBA1] = (uint8_t)(start >> 8);
areq->regs.regs[IDE_REGISTER_LBA2] = (uint8_t)(start >> 16); areq->regs.regs[IDE_REGISTER_LBA2] = (uint8_t)(start >> 16);
/* Set as the head register write above */
areq->regs.regs[IDE_REGISTER_LBA3] |= (uint8_t) (start >> 24); areq->regs.regs[IDE_REGISTER_LBA3] |= (uint8_t) (start >> 24);
areq->regs.regs[IDE_REGISTER_LBA3] |= IDE_REGISTER_LBA3_L; areq->regs.regs[IDE_REGISTER_LBA3] |= IDE_REGISTER_LBA3_L;
} }
@@ -311,8 +293,12 @@ ata_io_data_request(dev_t device, rtems_blkdev_request *req)
~IDE_REGISTER_DEVICE_HEAD_L; ~IDE_REGISTER_DEVICE_HEAD_L;
} }
/* fill sector count register */ /*
areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] = areq->breq->bufnum; * Fill sector count register. We have a number of buffers (bufnum) which
* can be of a specific length (bufs[0].length / ATA_SECTOR_SIZE).
*/
areq->regs.regs[IDE_REGISTER_SECTOR_COUNT] =
areq->breq->bufnum * (areq->breq->bufs[0].length / ATA_SECTOR_SIZE);
/* add request to the queue of awaiting requests to the controller */ /* add request to the queue of awaiting requests to the controller */
ata_add_to_controller_queue(ctrl_minor, areq); ata_add_to_controller_queue(ctrl_minor, areq);
@@ -423,10 +409,7 @@ ata_non_data_request(dev_t device, int cmd, void *argp)
switch(cmd) switch(cmd)
{ {
case ATAIO_SET_MULTIPLE_MODE: case ATAIO_SET_MULTIPLE_MODE:
ATA_DEV_INFO(ctrl_minor, dev).current_multiple = /* invalid operation now */
*(uint8_t*)argp;
break;
default: default:
rc = RTEMS_INVALID_NUMBER; rc = RTEMS_INVALID_NUMBER;
break; break;
@@ -463,9 +446,6 @@ ata_process_request(rtems_device_minor_number ctrl_minor)
ata_queue_msg_t msg; ata_queue_msg_t msg;
uint8_t i, dev; uint8_t i, dev;
uint16_t val; uint16_t val;
uint16_t data_bs; /* the number of 512-bytes sectors in one
* data block
*/
ISR_Level level; ISR_Level level;
/* if no requests to controller then do nothing */ /* if no requests to controller then do nothing */
@@ -481,10 +461,6 @@ ata_process_request(rtems_device_minor_number ctrl_minor)
dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
IDE_REGISTER_DEVICE_HEAD_DEV; IDE_REGISTER_DEVICE_HEAD_DEV;
/* get data block size */
data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
/* execute device select protocol */ /* execute device select protocol */
ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD, ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD,
areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]); areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]);
@@ -502,8 +478,8 @@ ata_process_request(rtems_device_minor_number ctrl_minor)
ide_controller_write_register(ctrl_minor, i, areq->regs.regs[i]); ide_controller_write_register(ctrl_minor, i, areq->regs.regs[i]);
} }
#ifdef DEBUG #if ATA_DEBUG
printf("ata_process_request: type: %d\n", areq->type); ata_printf("ata_process_request: type: %d\n", areq->type);
#endif #endif
/* continue to execute ATA protocols depending on type of request */ /* continue to execute ATA protocols depending on type of request */
@@ -516,12 +492,16 @@ ata_process_request(rtems_device_minor_number ctrl_minor)
if (byte & IDE_REGISTER_STATUS_DRQ) if (byte & IDE_REGISTER_STATUS_DRQ)
{ {
ide_controller_write_data_block( if (areq->cnt)
ctrl_minor, {
MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE, int ccbuf = areq->cbuf;
areq->breq->bufs, &areq->cbuf, ide_controller_write_data_block(ctrl_minor,
&areq->pos); areq->breq->bufs[0].length * areq->cnt,
areq->cnt -= MIN(data_bs, areq->cnt); areq->breq->bufs, &areq->cbuf,
&areq->pos);
ccbuf = areq->cbuf - ccbuf;
areq->cnt -= ccbuf;
}
} }
else else
{ {
@@ -570,8 +550,8 @@ ata_request_done(ata_req_t *areq, rtems_device_minor_number ctrl_minor,
{ {
assert(areq); assert(areq);
#ifdef DEBUG #if ATA_DEBUG
printf("ata_request_done: entry\n"); ata_printf("ata_request_done: entry\n");
#endif #endif
ATA_EXEC_CALLBACK(areq, status, error); ATA_EXEC_CALLBACK(areq, status, error);
@@ -586,8 +566,8 @@ ata_request_done(ata_req_t *areq, rtems_device_minor_number ctrl_minor,
free(areq); free(areq);
#ifdef DEBUG #if ATA_DEBUG
printf("ata_request_done: exit\n"); ata_printf("ata_request_done: exit\n");
#endif #endif
} }
@@ -608,8 +588,8 @@ ata_non_data_request_done(ata_req_t *areq,
rtems_device_minor_number ctrl_minor, rtems_device_minor_number ctrl_minor,
rtems_status_code status, int error) rtems_status_code status, int error)
{ {
#ifdef DEBUG #if ATA_DEBUG
printf("ata_non_data_request_done: entry\n"); ata_printf("ata_non_data_request_done: entry\n");
#endif #endif
areq->status = status; areq->status = status;
@@ -642,7 +622,7 @@ ata_add_to_controller_queue(rtems_device_minor_number ctrl_minor,
ata_queue_msg_t msg; ata_queue_msg_t msg;
#ifdef DEBUG_DOES_NOT_WORK_WITH_QEMU #if ATA_DEBUG_DOES_NOT_WORK_WITH_QEMU
uint16_t val; uint16_t val;
/* /*
* read IDE_REGISTER_ALTERNATE_STATUS instead IDE_REGISTER_STATUS * read IDE_REGISTER_ALTERNATE_STATUS instead IDE_REGISTER_STATUS
@@ -785,22 +765,23 @@ static rtems_irq_connect_data ata_irq_data =
static inline void static inline void
ata_pio_in_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq) ata_pio_in_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq)
{ {
uint16_t bs, val; uint16_t val;
uint8_t dev; uint8_t dev;
uint32_t min_val;
ata_queue_msg_t msg; ata_queue_msg_t msg;
dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
IDE_REGISTER_DEVICE_HEAD_DEV; IDE_REGISTER_DEVICE_HEAD_DEV;
bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ? if (areq->cnt)
ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1; {
min_val = MIN(bs, areq->cnt); int ccbuf = areq->cbuf;
ide_controller_read_data_block(ctrl_minor,
ide_controller_read_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE, areq->breq->bufs[0].length * areq->cnt,
areq->breq->bufs, &areq->cbuf, &areq->pos); areq->breq->bufs, &areq->cbuf, &areq->pos);
ccbuf = areq->cbuf - ccbuf;
areq->cnt -= min_val; areq->cnt -= ccbuf;
}
if (areq->cnt == 0) if (areq->cnt == 0)
{ {
ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, RTEMS_SUCCESSFUL); ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, RTEMS_SUCCESSFUL);
@@ -828,33 +809,33 @@ ata_pio_in_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq)
static inline void static inline void
ata_pio_out_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq) ata_pio_out_protocol(rtems_device_minor_number ctrl_minor, ata_req_t *areq)
{ {
uint16_t bs, val; uint16_t val;
uint8_t dev; uint8_t dev;
uint32_t min_val;
ata_queue_msg_t msg; ata_queue_msg_t msg;
#ifdef DEBUG #if ATA_DEBUG
printf("ata_pio_out_protocol:\n"); ata_printf("ata_pio_out_protocol:\n");
#endif #endif
dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
IDE_REGISTER_DEVICE_HEAD_DEV; IDE_REGISTER_DEVICE_HEAD_DEV;
bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
min_val = MIN(bs, areq->cnt);
if (areq->cnt == 0) if (areq->cnt == 0)
{ {
ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, RTEMS_SUCCESSFUL); ata_request_done(areq, ctrl_minor, RTEMS_SUCCESSFUL, RTEMS_SUCCESSFUL);
} }
else else
{ {
ide_controller_write_data_block(ctrl_minor, min_val * ATA_SECTOR_SIZE, if (areq->cnt)
areq->breq->bufs, &areq->cbuf, {
&areq->pos); int ccbuf = areq->cbuf;
areq->cnt -= min_val; ide_controller_write_data_block(ctrl_minor,
areq->breq->bufs[0].length * areq->cnt,
areq->breq->bufs, &areq->cbuf,
&areq->pos);
ccbuf = areq->cbuf - ccbuf;
areq->cnt -= ccbuf;
}
if (IDE_Controller_Table[ctrl_minor].int_driven == false) if (IDE_Controller_Table[ctrl_minor].int_driven == false)
{ {
do { do {
@@ -956,14 +937,21 @@ ata_queue_task(rtems_task_argument arg)
ide_controller_read_register(ctrl_minor, ide_controller_read_register(ctrl_minor,
IDE_REGISTER_ERROR, IDE_REGISTER_ERROR,
&val); &val);
if (areq->type == ATA_COMMAND_TYPE_NON_DATA) if (val & (IDE_REGISTER_ERROR_UNC |
ata_non_data_request_done(areq, ctrl_minor, IDE_REGISTER_ERROR_ICRC |
RTEMS_UNSATISFIED, IDE_REGISTER_ERROR_IDNF |
RTEMS_IO_ERROR); IDE_REGISTER_ERROR_NM |
else IDE_REGISTER_ERROR_MED))
ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED, {
RTEMS_IO_ERROR); if (areq->type == ATA_COMMAND_TYPE_NON_DATA)
break; ata_non_data_request_done(areq, ctrl_minor,
RTEMS_UNSATISFIED,
RTEMS_IO_ERROR);
else
ata_request_done(areq, ctrl_minor, RTEMS_UNSATISFIED,
RTEMS_IO_ERROR);
break;
}
} }
switch(areq->type) switch(areq->type)
@@ -986,8 +974,8 @@ ata_queue_task(rtems_task_argument arg)
break; break;
default: default:
#ifdef DEBUG #if ATA_DEBUG
printf("ata_queue_task: non-supported command type\n"); ata_printf("ata_queue_task: non-supported command type\n");
#endif #endif
ata_request_done(areq, ctrl_minor, ata_request_done(areq, ctrl_minor,
RTEMS_UNSATISFIED, RTEMS_UNSATISFIED,
@@ -997,8 +985,8 @@ ata_queue_task(rtems_task_argument arg)
break; break;
default: default:
#ifdef DEBUG #if ATA_DEBUG
printf("ata_queue_task: internal error\n"); ata_printf("ata_queue_task: internal error\n");
rtems_task_delete (RTEMS_SELF); rtems_task_delete (RTEMS_SELF);
#endif #endif
rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR); rtems_fatal_error_occurred(RTEMS_INTERNAL_ERROR);
@@ -1023,7 +1011,8 @@ ata_ioctl(dev_t device, int cmd, void *argp)
{ {
rtems_status_code status; rtems_status_code status;
rtems_device_minor_number rel_minor; rtems_device_minor_number rel_minor;
uint8_t block_count;
rel_minor = (rtems_filesystem_dev_minor_t(device)) / rel_minor = (rtems_filesystem_dev_minor_t(device)) /
ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE; ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE;
@@ -1051,10 +1040,9 @@ ata_ioctl(dev_t device, int cmd, void *argp)
*((uint32_t*) argp) = RTEMS_BLKDEV_CAP_MULTISECTOR_CONT; *((uint32_t*) argp) = RTEMS_BLKDEV_CAP_MULTISECTOR_CONT;
status = RTEMS_SUCCESSFUL; status = RTEMS_SUCCESSFUL;
break; break;
default: default:
errno = EINVAL; return rtems_blkdev_ioctl (device, cmd, argp);
return -1;
break; break;
} }
@@ -1418,16 +1406,10 @@ rtems_ata_initialize(rtems_device_major_number major,
ATA_DEV_INFO(ctrl_minor, dev).sectors = ATA_DEV_INFO(ctrl_minor, dev).sectors =
CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_SECS]); CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_CURR_LOG_SECS]);
ATA_DEV_INFO(ctrl_minor, dev).lba_sectors = ATA_DEV_INFO(ctrl_minor, dev).lba_sectors =
(CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS0]) << 16) + (CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS1]) << 16) +
CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS1]); CF_LE_W(buffer[ATA_IDENT_WORD_NUM_OF_USR_SECS0]);
ATA_DEV_INFO(ctrl_minor, dev).lba_avaible = ATA_DEV_INFO(ctrl_minor, dev).lba_avaible =
(CF_LE_W(buffer[ATA_IDENT_WORD_CAPABILITIES]) >> 9) & 0x1; (CF_LE_W(buffer[ATA_IDENT_WORD_CAPABILITIES]) >> 9) & 0x1;
ATA_DEV_INFO(ctrl_minor, dev).max_multiple =
(uint8_t) (CF_LE_W(buffer[ATA_IDENT_WORD_RW_MULT]));
ATA_DEV_INFO(ctrl_minor, dev).current_multiple =
(CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS]) & 0x100) ?
(uint8_t)(CF_LE_W(buffer[ATA_IDENT_WORD_MULT_SECS])) :
0;
if ((CF_LE_W(buffer[ATA_IDENT_WORD_FIELD_VALIDITY]) & if ((CF_LE_W(buffer[ATA_IDENT_WORD_FIELD_VALIDITY]) &
ATA_IDENT_BIT_VALID) == 0) { ATA_IDENT_BIT_VALID) == 0) {
@@ -1469,7 +1451,6 @@ rtems_ata_initialize(rtems_device_major_number major,
major, major,
(ata_devs_number * (ata_devs_number *
ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE)); ATA_MINOR_NUM_RESERVED_PER_ATA_DEVICE));
status = rtems_disk_create_phys(device, ATA_SECTOR_SIZE, status = rtems_disk_create_phys(device, ATA_SECTOR_SIZE,
ATA_DEV_INFO(ctrl_minor, dev).lba_avaible ? ATA_DEV_INFO(ctrl_minor, dev).lba_avaible ?
ATA_DEV_INFO(ctrl_minor, dev).lba_sectors : ATA_DEV_INFO(ctrl_minor, dev).lba_sectors :
@@ -1515,18 +1496,13 @@ ata_process_request_on_init_phase(rtems_device_minor_number ctrl_minor,
uint16_t byte;/* emphasize that only 8 low bits is meaningful */ uint16_t byte;/* emphasize that only 8 low bits is meaningful */
uint8_t i, dev; uint8_t i, dev;
uint16_t val, val1; uint16_t val, val1;
uint16_t data_bs; /* the number of 512 bytes sectors into one
* data block
*/
volatile unsigned retries; volatile unsigned retries;
assert(areq); assert(areq);
dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] & dev = areq->regs.regs[IDE_REGISTER_DEVICE_HEAD] &
IDE_REGISTER_DEVICE_HEAD_DEV; IDE_REGISTER_DEVICE_HEAD_DEV;
data_bs = ATA_DEV_INFO(ctrl_minor, dev).current_multiple ?
ATA_DEV_INFO(ctrl_minor, dev).current_multiple : 1;
ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD, ide_controller_write_register(ctrl_minor, IDE_REGISTER_DEVICE_HEAD,
areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]); areq->regs.regs[IDE_REGISTER_DEVICE_HEAD]);
@@ -1576,13 +1552,16 @@ ata_process_request_on_init_phase(rtems_device_minor_number ctrl_minor,
switch(areq->type) switch(areq->type)
{ {
case ATA_COMMAND_TYPE_PIO_IN: case ATA_COMMAND_TYPE_PIO_IN:
ide_controller_read_data_block( if (areq->cnt)
ctrl_minor, {
MIN(data_bs, areq->cnt) * ATA_SECTOR_SIZE, int ccbuf = areq->cbuf;
areq->breq->bufs, &areq->cbuf, ide_controller_read_data_block(ctrl_minor,
&areq->pos); areq->breq->bufs[0].length * areq->cnt,
areq->breq->bufs, &areq->cbuf,
areq->cnt -= MIN(data_bs, areq->cnt); &areq->pos);
ccbuf = areq->cbuf - ccbuf;
areq->cnt -= ccbuf;
}
if (areq->cnt == 0) if (areq->cnt == 0)
{ {
areq->breq->status = RTEMS_SUCCESSFUL; areq->breq->status = RTEMS_SUCCESSFUL;
@@ -1603,8 +1582,8 @@ ata_process_request_on_init_phase(rtems_device_minor_number ctrl_minor,
break; break;
default: default:
#ifdef DEBUG #if ATA_DEBUG
printf("ata_queue_task: non-supported command type\n"); ata_printf("ata_queue_task: non-supported command type\n");
#endif #endif
areq->breq->status = RTEMS_UNSATISFIED; areq->breq->status = RTEMS_UNSATISFIED;
areq->breq->error = RTEMS_NOT_IMPLEMENTED; areq->breq->error = RTEMS_NOT_IMPLEMENTED;

3
c/src/libchip/ide/ata_internal.h
View File

@@ -285,9 +285,6 @@ typedef struct ata_dev_s {
uint8_t lba_avaible; /* 0 - CHS mode, 1 - LBA mode */ uint8_t lba_avaible; /* 0 - CHS mode, 1 - LBA mode */
uint8_t max_multiple; /* 0 if READ/WRITE MULTIPLE is unsupported */
uint8_t current_multiple;
uint16_t modes_available; /* OR of values for this modes */ uint16_t modes_available; /* OR of values for this modes */
uint16_t mode_active; uint16_t mode_active;
} ata_dev_t; } ata_dev_t;

4
c/src/libchip/ide/ide_controller.c
View File

@@ -92,7 +92,7 @@ ide_controller_initialize(rtems_device_major_number major,
*/ */
void void
ide_controller_read_data_block(rtems_device_minor_number minor, ide_controller_read_data_block(rtems_device_minor_number minor,
uint16_t block_size, uint32_t block_size,
rtems_blkdev_sg_buffer *bufs, rtems_blkdev_sg_buffer *bufs,
uint32_t *cbuf, uint32_t *cbuf,
uint32_t *pos) uint32_t *pos)
@@ -121,7 +121,7 @@ ide_controller_read_data_block(rtems_device_minor_number minor,
*/ */
void void
ide_controller_write_data_block(rtems_device_minor_number minor, ide_controller_write_data_block(rtems_device_minor_number minor,
uint16_t block_size, uint32_t block_size,
rtems_blkdev_sg_buffer *bufs, rtems_blkdev_sg_buffer *bufs,
uint32_t *cbuf, uint32_t *cbuf,
uint32_t *pos) uint32_t *pos)

4
c/src/libchip/ide/ide_ctrl_cfg.h
View File

@@ -73,10 +73,10 @@ typedef struct ide_ctrl_fns_s {
* The function allows to escape overhead for read/write register * The function allows to escape overhead for read/write register
* functions calls * functions calls
*/ */
void (*ctrl_read_block)(int minor, uint16_t block_size, void (*ctrl_read_block)(int minor, uint32_t block_size,
rtems_blkdev_sg_buffer *bufs, uint32_t *cbuf, rtems_blkdev_sg_buffer *bufs, uint32_t *cbuf,
uint32_t *pos); uint32_t *pos);
void (*ctrl_write_block)(int minor, uint16_t block_size, void (*ctrl_write_block)(int minor, uint32_t block_size,
rtems_blkdev_sg_buffer *bufs, uint32_t *cbuf, rtems_blkdev_sg_buffer *bufs, uint32_t *cbuf,
uint32_t *pos); uint32_t *pos);

31
c/src/libchip/ide/ide_ctrl_io.h
View File

@@ -74,18 +74,21 @@ extern "C" {
#define IDE_REGISTER_LBA3_DEV 0x10 #define IDE_REGISTER_LBA3_DEV 0x10
#define IDE_REGISTER_LBA3_LBA 0x0f #define IDE_REGISTER_LBA3_LBA 0x0f
#define IDE_REGISTER_ERROR_ICRC 0x80 /* Interface CRC error on */ #define IDE_REGISTER_ERROR_ICRC (1 << 7) /* Interface CRC error on */
/* UDMA data transfer */ /* UDMA data transfer */
#define IDE_REGISTER_ERROR_UNC 0x40 /* Uncorrectable data error */ #define IDE_REGISTER_ERROR_UNC (1 << 6) /* Uncorrectable data error */
#define IDE_REGISTER_ERROR_WP 0x40 /* Write protect */ #if CCJ_COULD_NOT_FIND_THIS_ERROR
#define IDE_REGISTER_ERROR_MC 0x20 /* Media changed */ #define IDE_REGISTER_ERROR_WP (1 << 6) /* Write protect */
#define IDE_REGISTER_ERROR_IDNF 0x10 /* Sector ID not found */ #endif
#define IDE_REGISTER_ERROR_MCR 0x08 /* Media change requested */ #define IDE_REGISTER_ERROR_MC (1 << 5) /* Media changed */
#define IDE_REGISTER_ERROR_ABRT 0x04 /* Aborted command */ #define IDE_REGISTER_ERROR_IDNF (1 << 4) /* Sector ID not found */
#define IDE_REGISTER_ERROR_NM 0x02 /* No media */ #define IDE_REGISTER_ERROR_MCR (1 << 3) /* Media change requested */
#define IDE_REGISTER_ERROR_AMNF 0x01 /* Address mark not found */ /* obsolette */
/* --obsolette in ATA-4 */ #define IDE_REGISTER_ERROR_ABRT (1 << 2) /* Aborted command */
#define IDE_REGISTER_ERROR_MED 0x01 /* Media error is detected */ #define IDE_REGISTER_ERROR_NM (1 << 1) /* No media, End of Media. */
#define IDE_REGISTER_ERROR_AMNF (1 << 0) /* Address mark not found */
/* --obsolette in ATA-4 */
#define IDE_REGISTER_ERROR_MED (1 << 0) /* Media error is detected */
/* /*
* ide_controller_read_data_block -- * ide_controller_read_data_block --
@@ -103,7 +106,7 @@ extern "C" {
*/ */
void void
ide_controller_read_data_block(rtems_device_minor_number minor, ide_controller_read_data_block(rtems_device_minor_number minor,
uint16_t block_size, uint32_t block_size,
rtems_blkdev_sg_buffer *bufs, rtems_blkdev_sg_buffer *bufs,
uint32_t *cbuf, uint32_t *cbuf,
uint32_t *pos); uint32_t *pos);
@@ -124,7 +127,7 @@ ide_controller_read_data_block(rtems_device_minor_number minor,
*/ */
void void
ide_controller_write_data_block(rtems_device_minor_number minor, ide_controller_write_data_block(rtems_device_minor_number minor,
uint16_t block_size, uint32_t block_size,
rtems_blkdev_sg_buffer *bufs, rtems_blkdev_sg_buffer *bufs,
uint32_t *cbuf, uint32_t *cbuf,
uint32_t *pos); uint32_t *pos);