OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

uas: s/ui/iu/

Browse Source 
The various uas data structures are called IU-s, which is short for
Information Unit, rather then UI-s.

Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
This commit is contained in:
Hans de Goede 2013-11-19 14:37:04 +01:00 committed by Gerd Hoffmann
parent 49cfa2fdc9
commit 5007c940a9
1 changed files with 38 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
hw/usb/dev-uas.c
View File

@ -55,7 +55,7 @@ typedef struct {
uint8_t id;
uint8_t reserved;
uint16_t tag;
} QEMU_PACKED uas_ui_header;
} QEMU_PACKED uas_iu_header;
typedef struct {
uint8_t prio_taskattr; /* 6:3 priority, 2:0 task attribute */
@ -65,7 +65,7 @@ typedef struct {
uint64_t lun;
uint8_t cdb[16];
uint8_t add_cdb[];
} QEMU_PACKED uas_ui_command;
} QEMU_PACKED uas_iu_command;
typedef struct {
uint16_t status_qualifier;
@ -73,29 +73,29 @@ typedef struct {
uint8_t reserved[7];
uint16_t sense_length;
uint8_t sense_data[18];
} QEMU_PACKED uas_ui_sense;
} QEMU_PACKED uas_iu_sense;
typedef struct {
uint8_t add_response_info[3];
uint8_t response_code;
} QEMU_PACKED uas_ui_response;
} QEMU_PACKED uas_iu_response;
typedef struct {
uint8_t function;
uint8_t reserved;
uint16_t task_tag;
uint64_t lun;
} QEMU_PACKED uas_ui_task_mgmt;
} QEMU_PACKED uas_iu_task_mgmt;
typedef struct {
uas_ui_header hdr;
uas_iu_header hdr;
union {
uas_ui_command command;
uas_ui_sense sense;
uas_ui_task_mgmt task;
uas_ui_response response;
uas_iu_command command;
uas_iu_sense sense;
uas_iu_task_mgmt task;
uas_iu_response response;
};
} QEMU_PACKED uas_ui;
} QEMU_PACKED uas_iu;
/* --------------------------------------------------------------------- */
@ -145,7 +145,7 @@ struct UASRequest {
struct UASStatus {
uint32_t stream;
uas_ui status;
uas_iu status;
uint32_t length;
QTAILQ_ENTRY(UASStatus) next;
};
@ -338,7 +338,7 @@ static UASStatus *usb_uas_alloc_status(UASDevice *uas, uint8_t id, uint16_t tag)
st->status.hdr.id = id;
st->status.hdr.tag = cpu_to_be16(tag);
st->length = sizeof(uas_ui_header);
st->length = sizeof(uas_iu_header);
if (uas_using_streams(uas)) {
st->stream = tag;
}
@ -398,7 +398,7 @@ static void usb_uas_queue_response(UASDevice *uas, uint16_t tag, uint8_t code)
trace_usb_uas_response(uas->dev.addr, tag, code);
st->status.response.response_code = code;
usb_uas_queue_status(uas, st, sizeof(uas_ui_response));
usb_uas_queue_status(uas, st, sizeof(uas_iu_response));
}
static void usb_uas_queue_sense(UASRequest *req, uint8_t status)
@ -414,7 +414,7 @@ static void usb_uas_queue_sense(UASRequest *req, uint8_t status)
sizeof(st->status.sense.sense_data));
st->status.sense.sense_length = cpu_to_be16(slen);
}
len = sizeof(uas_ui_sense) - sizeof(st->status.sense.sense_data) + slen;
len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
usb_uas_queue_status(req->uas, st, len);
}
@ -432,7 +432,7 @@ static void usb_uas_queue_fake_sense(UASDevice *uas, uint16_t tag,
st->status.sense.sense_data[12] = sense.asc;
st->status.sense.sense_data[13] = sense.ascq;
slen = 18;
len = sizeof(uas_ui_sense) - sizeof(st->status.sense.sense_data) + slen;
len = sizeof(uas_iu_sense) - sizeof(st->status.sense.sense_data) + slen;
usb_uas_queue_status(uas, st, len);
}
@ -534,14 +534,14 @@ static void usb_uas_start_next_transfer(UASDevice *uas)
}
}
static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_ui *ui)
static UASRequest *usb_uas_alloc_request(UASDevice *uas, uas_iu *iu)
{
UASRequest *req;
req = g_new0(UASRequest, 1);
req->uas = uas;
req->tag = be16_to_cpu(ui->hdr.tag);
req->lun = be64_to_cpu(ui->command.lun);
req->tag = be16_to_cpu(iu->hdr.tag);
req->lun = be64_to_cpu(iu->command.lun);
req->dev = usb_uas_get_dev(req->uas, req->lun);
return req;
}
@ -684,11 +684,11 @@ static void usb_uas_cancel_io(USBDevice *dev, USBPacket *p)
assert(!"canceled usb packet not found");
}
static void usb_uas_command(UASDevice *uas, uas_ui *ui)
static void usb_uas_command(UASDevice *uas, uas_iu *iu)
{
UASRequest *req;
uint32_t len;
uint16_t tag = be16_to_cpu(ui->hdr.tag);
uint16_t tag = be16_to_cpu(iu->hdr.tag);
if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
goto invalid_tag;
@ -697,7 +697,7 @@ static void usb_uas_command(UASDevice *uas, uas_ui *ui)
if (req) {
goto overlapped_tag;
}
req = usb_uas_alloc_request(uas, ui);
req = usb_uas_alloc_request(uas, iu);
if (req->dev == NULL) {
goto bad_target;
}
@ -714,7 +714,7 @@ static void usb_uas_command(UASDevice *uas, uas_ui *ui)
req->req = scsi_req_new(req->dev, req->tag,
usb_uas_get_lun(req->lun),
ui->command.cdb, req);
iu->command.cdb, req);
if (uas->requestlog) {
scsi_req_print(req->req);
}
@ -738,10 +738,10 @@ bad_target:
g_free(req);
}
static void usb_uas_task(UASDevice *uas, uas_ui *ui)
static void usb_uas_task(UASDevice *uas, uas_iu *iu)
{
uint16_t tag = be16_to_cpu(ui->hdr.tag);
uint64_t lun64 = be64_to_cpu(ui->task.lun);
uint16_t tag = be16_to_cpu(iu->hdr.tag);
uint64_t lun64 = be64_to_cpu(iu->task.lun);
SCSIDevice *dev = usb_uas_get_dev(uas, lun64);
int lun = usb_uas_get_lun(lun64);
UASRequest *req;
@ -750,7 +750,7 @@ static void usb_uas_task(UASDevice *uas, uas_ui *ui)
if (uas_using_streams(uas) && tag > UAS_MAX_STREAMS) {
goto invalid_tag;
}
req = usb_uas_find_request(uas, be16_to_cpu(ui->hdr.tag));
req = usb_uas_find_request(uas, be16_to_cpu(iu->hdr.tag));
if (req) {
goto overlapped_tag;
}
@ -758,9 +758,9 @@ static void usb_uas_task(UASDevice *uas, uas_ui *ui)
goto incorrect_lun;
}
switch (ui->task.function) {
switch (iu->task.function) {
case UAS_TMF_ABORT_TASK:
task_tag = be16_to_cpu(ui->task.task_tag);
task_tag = be16_to_cpu(iu->task.task_tag);
trace_usb_uas_tmf_abort_task(uas->dev.addr, tag, task_tag);
req = usb_uas_find_request(uas, task_tag);
if (req && req->dev == dev) {
@ -776,7 +776,7 @@ static void usb_uas_task(UASDevice *uas, uas_ui *ui)
break;
default:
trace_usb_uas_tmf_unsupported(uas->dev.addr, tag, ui->task.function);
trace_usb_uas_tmf_unsupported(uas->dev.addr, tag, iu->task.function);
usb_uas_queue_response(uas, tag, UAS_RC_TMF_NOT_SUPPORTED);
break;
}
@ -797,25 +797,25 @@ incorrect_lun:
static void usb_uas_handle_data(USBDevice *dev, USBPacket *p)
{
UASDevice *uas = DO_UPCAST(UASDevice, dev, dev);
uas_ui ui;
uas_iu iu;
UASStatus *st;
UASRequest *req;
int length;
switch (p->ep->nr) {
case UAS_PIPE_ID_COMMAND:
length = MIN(sizeof(ui), p->iov.size);
usb_packet_copy(p, &ui, length);
switch (ui.hdr.id) {
length = MIN(sizeof(iu), p->iov.size);
usb_packet_copy(p, &iu, length);
switch (iu.hdr.id) {
case UAS_UI_COMMAND:
usb_uas_command(uas, &ui);
usb_uas_command(uas, &iu);
break;
case UAS_UI_TASK_MGMT:
usb_uas_task(uas, &ui);
usb_uas_task(uas, &iu);
break;
default:
fprintf(stderr, "%s: unknown command ui: id 0x%x\n",
__func__, ui.hdr.id);
fprintf(stderr, "%s: unknown command iu: id 0x%x\n",
__func__, iu.hdr.id);
p->status = USB_RET_STALL;
break;
}