microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394/linux1394-2.6 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ieee1394/linux1394-2.6:
  ieee1394: sbp2: fix bogus dma mapping
  ieee1394: sbp2: pass REQUEST_SENSE through to the target
This commit is contained in:
Linus Torvalds 2006-12-30 11:40:40 -08:00
Родитель 91f6e54b6e 97d552e35d
Коммит 72836708c6
1 изменённых файлов: 40 добавлений и 43 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

83
drivers/ieee1394/sbp2.c
Просмотреть файл

@ -490,11 +490,11 @@ static int sbp2util_create_command_orb_pool(struct sbp2_lu *lu)
spin_unlock_irqrestore(&lu->cmd_orb_lock, flags); spin_unlock_irqrestore(&lu->cmd_orb_lock, flags);
return -ENOMEM; return -ENOMEM;
} }
cmd->command_orb_dma = dma_map_single(&hi->host->device, cmd->command_orb_dma = dma_map_single(hi->host->device.parent,
&cmd->command_orb, &cmd->command_orb,
sizeof(struct sbp2_command_orb), sizeof(struct sbp2_command_orb),
DMA_TO_DEVICE); DMA_TO_DEVICE);
cmd->sge_dma = dma_map_single(&hi->host->device, cmd->sge_dma = dma_map_single(hi->host->device.parent,
&cmd->scatter_gather_element, &cmd->scatter_gather_element,
sizeof(cmd->scatter_gather_element), sizeof(cmd->scatter_gather_element),
DMA_BIDIRECTIONAL); DMA_BIDIRECTIONAL);
@ -516,10 +516,11 @@ static void sbp2util_remove_command_orb_pool(struct sbp2_lu *lu)
if (!list_empty(&lu->cmd_orb_completed)) if (!list_empty(&lu->cmd_orb_completed))
list_for_each_safe(lh, next, &lu->cmd_orb_completed) { list_for_each_safe(lh, next, &lu->cmd_orb_completed) {
cmd = list_entry(lh, struct sbp2_command_info, list); cmd = list_entry(lh, struct sbp2_command_info, list);
dma_unmap_single(&host->device, cmd->command_orb_dma, dma_unmap_single(host->device.parent,
cmd->command_orb_dma,
sizeof(struct sbp2_command_orb), sizeof(struct sbp2_command_orb),
DMA_TO_DEVICE); DMA_TO_DEVICE);
dma_unmap_single(&host->device, cmd->sge_dma, dma_unmap_single(host->device.parent, cmd->sge_dma,
sizeof(cmd->scatter_gather_element), sizeof(cmd->scatter_gather_element),
DMA_BIDIRECTIONAL); DMA_BIDIRECTIONAL);
kfree(cmd); kfree(cmd);
@ -601,17 +602,17 @@ static void sbp2util_mark_command_completed(struct sbp2_lu *lu,
if (cmd->cmd_dma) { if (cmd->cmd_dma) {
if (cmd->dma_type == CMD_DMA_SINGLE) if (cmd->dma_type == CMD_DMA_SINGLE)
dma_unmap_single(&host->device, cmd->cmd_dma, dma_unmap_single(host->device.parent, cmd->cmd_dma,
cmd->dma_size, cmd->dma_dir); cmd->dma_size, cmd->dma_dir);
else if (cmd->dma_type == CMD_DMA_PAGE) else if (cmd->dma_type == CMD_DMA_PAGE)
dma_unmap_page(&host->device, cmd->cmd_dma, dma_unmap_page(host->device.parent, cmd->cmd_dma,
cmd->dma_size, cmd->dma_dir); cmd->dma_size, cmd->dma_dir);
/* XXX: Check for CMD_DMA_NONE bug */ /* XXX: Check for CMD_DMA_NONE bug */
cmd->dma_type = CMD_DMA_NONE; cmd->dma_type = CMD_DMA_NONE;
cmd->cmd_dma = 0; cmd->cmd_dma = 0;
} }
if (cmd->sge_buffer) { if (cmd->sge_buffer) {
dma_unmap_sg(&host->device, cmd->sge_buffer, dma_unmap_sg(host->device.parent, cmd->sge_buffer,
cmd->dma_size, cmd->dma_dir); cmd->dma_size, cmd->dma_dir);
cmd->sge_buffer = NULL; cmd->sge_buffer = NULL;
} }
@ -836,37 +837,37 @@ static int sbp2_start_device(struct sbp2_lu *lu)
struct sbp2_fwhost_info *hi = lu->hi; struct sbp2_fwhost_info *hi = lu->hi;
int error; int error;
lu->login_response = dma_alloc_coherent(&hi->host->device, lu->login_response = dma_alloc_coherent(hi->host->device.parent,
sizeof(struct sbp2_login_response), sizeof(struct sbp2_login_response),
&lu->login_response_dma, GFP_KERNEL); &lu->login_response_dma, GFP_KERNEL);
if (!lu->login_response) if (!lu->login_response)
goto alloc_fail; goto alloc_fail;
lu->query_logins_orb = dma_alloc_coherent(&hi->host->device, lu->query_logins_orb = dma_alloc_coherent(hi->host->device.parent,
sizeof(struct sbp2_query_logins_orb), sizeof(struct sbp2_query_logins_orb),
&lu->query_logins_orb_dma, GFP_KERNEL); &lu->query_logins_orb_dma, GFP_KERNEL);
if (!lu->query_logins_orb) if (!lu->query_logins_orb)
goto alloc_fail; goto alloc_fail;
lu->query_logins_response = dma_alloc_coherent(&hi->host->device, lu->query_logins_response = dma_alloc_coherent(hi->host->device.parent,
sizeof(struct sbp2_query_logins_response), sizeof(struct sbp2_query_logins_response),
&lu->query_logins_response_dma, GFP_KERNEL); &lu->query_logins_response_dma, GFP_KERNEL);
if (!lu->query_logins_response) if (!lu->query_logins_response)
goto alloc_fail; goto alloc_fail;
lu->reconnect_orb = dma_alloc_coherent(&hi->host->device, lu->reconnect_orb = dma_alloc_coherent(hi->host->device.parent,
sizeof(struct sbp2_reconnect_orb), sizeof(struct sbp2_reconnect_orb),
&lu->reconnect_orb_dma, GFP_KERNEL); &lu->reconnect_orb_dma, GFP_KERNEL);
if (!lu->reconnect_orb) if (!lu->reconnect_orb)
goto alloc_fail; goto alloc_fail;
lu->logout_orb = dma_alloc_coherent(&hi->host->device, lu->logout_orb = dma_alloc_coherent(hi->host->device.parent,
sizeof(struct sbp2_logout_orb), sizeof(struct sbp2_logout_orb),
&lu->logout_orb_dma, GFP_KERNEL); &lu->logout_orb_dma, GFP_KERNEL);
if (!lu->logout_orb) if (!lu->logout_orb)
goto alloc_fail; goto alloc_fail;
lu->login_orb = dma_alloc_coherent(&hi->host->device, lu->login_orb = dma_alloc_coherent(hi->host->device.parent,
sizeof(struct sbp2_login_orb), sizeof(struct sbp2_login_orb),
&lu->login_orb_dma, GFP_KERNEL); &lu->login_orb_dma, GFP_KERNEL);
if (!lu->login_orb) if (!lu->login_orb)
@ -929,32 +930,32 @@ static void sbp2_remove_device(struct sbp2_lu *lu)
list_del(&lu->lu_list); list_del(&lu->lu_list);
if (lu->login_response) if (lu->login_response)
dma_free_coherent(&hi->host->device, dma_free_coherent(hi->host->device.parent,
sizeof(struct sbp2_login_response), sizeof(struct sbp2_login_response),
lu->login_response, lu->login_response,
lu->login_response_dma); lu->login_response_dma);
if (lu->login_orb) if (lu->login_orb)
dma_free_coherent(&hi->host->device, dma_free_coherent(hi->host->device.parent,
sizeof(struct sbp2_login_orb), sizeof(struct sbp2_login_orb),
lu->login_orb, lu->login_orb,
lu->login_orb_dma); lu->login_orb_dma);
if (lu->reconnect_orb) if (lu->reconnect_orb)
dma_free_coherent(&hi->host->device, dma_free_coherent(hi->host->device.parent,
sizeof(struct sbp2_reconnect_orb), sizeof(struct sbp2_reconnect_orb),
lu->reconnect_orb, lu->reconnect_orb,
lu->reconnect_orb_dma); lu->reconnect_orb_dma);
if (lu->logout_orb) if (lu->logout_orb)
dma_free_coherent(&hi->host->device, dma_free_coherent(hi->host->device.parent,
sizeof(struct sbp2_logout_orb), sizeof(struct sbp2_logout_orb),
lu->logout_orb, lu->logout_orb,
lu->logout_orb_dma); lu->logout_orb_dma);
if (lu->query_logins_orb) if (lu->query_logins_orb)
dma_free_coherent(&hi->host->device, dma_free_coherent(hi->host->device.parent,
sizeof(struct sbp2_query_logins_orb), sizeof(struct sbp2_query_logins_orb),
lu->query_logins_orb, lu->query_logins_orb,
lu->query_logins_orb_dma); lu->query_logins_orb_dma);
if (lu->query_logins_response) if (lu->query_logins_response)
dma_free_coherent(&hi->host->device, dma_free_coherent(hi->host->device.parent,
sizeof(struct sbp2_query_logins_response), sizeof(struct sbp2_query_logins_response),
lu->query_logins_response, lu->query_logins_response,
lu->query_logins_response_dma); lu->query_logins_response_dma);
@ -1445,7 +1446,7 @@ static void sbp2_prep_command_orb_sg(struct sbp2_command_orb *orb,
cmd->dma_size = sgpnt[0].length; cmd->dma_size = sgpnt[0].length;
cmd->dma_type = CMD_DMA_PAGE; cmd->dma_type = CMD_DMA_PAGE;
cmd->cmd_dma = dma_map_page(&hi->host->device, cmd->cmd_dma = dma_map_page(hi->host->device.parent,
sgpnt[0].page, sgpnt[0].offset, sgpnt[0].page, sgpnt[0].offset,
cmd->dma_size, cmd->dma_dir); cmd->dma_size, cmd->dma_dir);
@ -1457,8 +1458,8 @@ static void sbp2_prep_command_orb_sg(struct sbp2_command_orb *orb,
&cmd->scatter_gather_element[0]; &cmd->scatter_gather_element[0];
u32 sg_count, sg_len; u32 sg_count, sg_len;
dma_addr_t sg_addr; dma_addr_t sg_addr;
int i, count = dma_map_sg(&hi->host->device, sgpnt, scsi_use_sg, int i, count = dma_map_sg(hi->host->device.parent, sgpnt,
dma_dir); scsi_use_sg, dma_dir);
cmd->dma_size = scsi_use_sg; cmd->dma_size = scsi_use_sg;
cmd->sge_buffer = sgpnt; cmd->sge_buffer = sgpnt;
@ -1508,7 +1509,8 @@ static void sbp2_prep_command_orb_no_sg(struct sbp2_command_orb *orb,
cmd->dma_dir = dma_dir; cmd->dma_dir = dma_dir;
cmd->dma_size = scsi_request_bufflen; cmd->dma_size = scsi_request_bufflen;
cmd->dma_type = CMD_DMA_SINGLE; cmd->dma_type = CMD_DMA_SINGLE;
cmd->cmd_dma = dma_map_single(&hi->host->device, scsi_request_buffer, cmd->cmd_dma = dma_map_single(hi->host->device.parent,
scsi_request_buffer,
cmd->dma_size, cmd->dma_dir); cmd->dma_size, cmd->dma_dir);
orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id); orb->data_descriptor_hi = ORB_SET_NODE_ID(hi->host->node_id);
orb->misc |= ORB_SET_DIRECTION(orb_direction); orb->misc |= ORB_SET_DIRECTION(orb_direction);
@ -1626,10 +1628,11 @@ static void sbp2_link_orb_command(struct sbp2_lu *lu,
size_t length; size_t length;
unsigned long flags; unsigned long flags;
dma_sync_single_for_device(&hi->host->device, cmd->command_orb_dma, dma_sync_single_for_device(hi->host->device.parent,
cmd->command_orb_dma,
sizeof(struct sbp2_command_orb), sizeof(struct sbp2_command_orb),
DMA_TO_DEVICE); DMA_TO_DEVICE);
dma_sync_single_for_device(&hi->host->device, cmd->sge_dma, dma_sync_single_for_device(hi->host->device.parent, cmd->sge_dma,
sizeof(cmd->scatter_gather_element), sizeof(cmd->scatter_gather_element),
DMA_BIDIRECTIONAL); DMA_BIDIRECTIONAL);
@ -1655,14 +1658,15 @@ static void sbp2_link_orb_command(struct sbp2_lu *lu,
* The target's fetch agent may or may not have read this * The target's fetch agent may or may not have read this
* previous ORB yet. * previous ORB yet.
*/ */
dma_sync_single_for_cpu(&hi->host->device, last_orb_dma, dma_sync_single_for_cpu(hi->host->device.parent, last_orb_dma,
sizeof(struct sbp2_command_orb), sizeof(struct sbp2_command_orb),
DMA_TO_DEVICE); DMA_TO_DEVICE);
last_orb->next_ORB_lo = cpu_to_be32(cmd->command_orb_dma); last_orb->next_ORB_lo = cpu_to_be32(cmd->command_orb_dma);
wmb(); wmb();
/* Tells hardware that this pointer is valid */ /* Tells hardware that this pointer is valid */
last_orb->next_ORB_hi = 0; last_orb->next_ORB_hi = 0;
dma_sync_single_for_device(&hi->host->device, last_orb_dma, dma_sync_single_for_device(hi->host->device.parent,
last_orb_dma,
sizeof(struct sbp2_command_orb), sizeof(struct sbp2_command_orb),
DMA_TO_DEVICE); DMA_TO_DEVICE);
addr += SBP2_DOORBELL_OFFSET; addr += SBP2_DOORBELL_OFFSET;
@ -1790,10 +1794,11 @@ static int sbp2_handle_status_write(struct hpsb_host *host, int nodeid,
else else
cmd = sbp2util_find_command_for_orb(lu, sb->ORB_offset_lo); cmd = sbp2util_find_command_for_orb(lu, sb->ORB_offset_lo);
if (cmd) { if (cmd) {
dma_sync_single_for_cpu(&hi->host->device, cmd->command_orb_dma, dma_sync_single_for_cpu(hi->host->device.parent,
cmd->command_orb_dma,
sizeof(struct sbp2_command_orb), sizeof(struct sbp2_command_orb),
DMA_TO_DEVICE); DMA_TO_DEVICE);
dma_sync_single_for_cpu(&hi->host->device, cmd->sge_dma, dma_sync_single_for_cpu(hi->host->device.parent, cmd->sge_dma,
sizeof(cmd->scatter_gather_element), sizeof(cmd->scatter_gather_element),
DMA_BIDIRECTIONAL); DMA_BIDIRECTIONAL);
/* Grab SCSI command pointers and check status. */ /* Grab SCSI command pointers and check status. */
@ -1882,16 +1887,6 @@ static int sbp2scsi_queuecommand(struct scsi_cmnd *SCpnt,
if (unlikely(SCpnt->device->lun)) if (unlikely(SCpnt->device->lun))
goto done; goto done;
/* handle the request sense command here (auto-request sense) */
if (SCpnt->cmnd[0] == REQUEST_SENSE) {
memcpy(SCpnt->request_buffer, SCpnt->sense_buffer,
SCpnt->request_bufflen);
memset(SCpnt->sense_buffer, 0, sizeof(SCpnt->sense_buffer));
sbp2scsi_complete_command(lu, SBP2_SCSI_STATUS_GOOD, SCpnt,
done);
return 0;
}
if (unlikely(!hpsb_node_entry_valid(lu->ne))) { if (unlikely(!hpsb_node_entry_valid(lu->ne))) {
SBP2_ERR("Bus reset in progress - rejecting command"); SBP2_ERR("Bus reset in progress - rejecting command");
result = DID_BUS_BUSY << 16; result = DID_BUS_BUSY << 16;
@ -1931,10 +1926,11 @@ static void sbp2scsi_complete_all_commands(struct sbp2_lu *lu, u32 status)
while (!list_empty(&lu->cmd_orb_inuse)) { while (!list_empty(&lu->cmd_orb_inuse)) {
lh = lu->cmd_orb_inuse.next; lh = lu->cmd_orb_inuse.next;
cmd = list_entry(lh, struct sbp2_command_info, list); cmd = list_entry(lh, struct sbp2_command_info, list);
dma_sync_single_for_cpu(&hi->host->device, cmd->command_orb_dma, dma_sync_single_for_cpu(hi->host->device.parent,
cmd->command_orb_dma,
sizeof(struct sbp2_command_orb), sizeof(struct sbp2_command_orb),
DMA_TO_DEVICE); DMA_TO_DEVICE);
dma_sync_single_for_cpu(&hi->host->device, cmd->sge_dma, dma_sync_single_for_cpu(hi->host->device.parent, cmd->sge_dma,
sizeof(cmd->scatter_gather_element), sizeof(cmd->scatter_gather_element),
DMA_BIDIRECTIONAL); DMA_BIDIRECTIONAL);
sbp2util_mark_command_completed(lu, cmd); sbp2util_mark_command_completed(lu, cmd);
@ -2059,11 +2055,12 @@ static int sbp2scsi_abort(struct scsi_cmnd *SCpnt)
spin_lock_irqsave(&lu->cmd_orb_lock, flags); spin_lock_irqsave(&lu->cmd_orb_lock, flags);
cmd = sbp2util_find_command_for_SCpnt(lu, SCpnt); cmd = sbp2util_find_command_for_SCpnt(lu, SCpnt);
if (cmd) { if (cmd) {
dma_sync_single_for_cpu(&hi->host->device, dma_sync_single_for_cpu(hi->host->device.parent,
cmd->command_orb_dma, cmd->command_orb_dma,
sizeof(struct sbp2_command_orb), sizeof(struct sbp2_command_orb),
DMA_TO_DEVICE); DMA_TO_DEVICE);
dma_sync_single_for_cpu(&hi->host->device, cmd->sge_dma, dma_sync_single_for_cpu(hi->host->device.parent,
cmd->sge_dma,
sizeof(cmd->scatter_gather_element), sizeof(cmd->scatter_gather_element),
DMA_BIDIRECTIONAL); DMA_BIDIRECTIONAL);
sbp2util_mark_command_completed(lu, cmd); sbp2util_mark_command_completed(lu, cmd);