ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

uas: s/ui/iu/ 

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