UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

xhci: clean up work to remove unused parameters for functions in xhci-mem.c 

Some parameters are not used by functions in xhci-mem.c, just
remove it.

Changes compared to v1:
- Rebase to the latest usb-next branch

Signed-off-by: Lin Wang <lin.x.wang@intel.com>
Signed-off-by: Mathias Nyman <mathias.nyman@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Lin Wang 2015-01-09 16:06:31 +02:00 committed by Greg Kroah-Hartman
parent 9e08a03dc1
commit 4daf9df51f
5 changed files with 33 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/usb/host/xhci-dbg.c
View File

@ -552,7 +552,7 @@ void xhci_dbg_ctx(struct xhci_hcd *xhci,
if (ctx->type == XHCI_CTX_TYPE_INPUT) { if (ctx->type == XHCI_CTX_TYPE_INPUT) {
struct xhci_input_control_ctx *ctrl_ctx = struct xhci_input_control_ctx *ctrl_ctx =
xhci_get_input_control_ctx(xhci, ctx); xhci_get_input_control_ctx(ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "Could not get input context, bad type.\n"); xhci_warn(xhci, "Could not get input context, bad type.\n");
return; return;

21
drivers/usb/host/xhci-mem.c
View File

@ -535,7 +535,7 @@ static void xhci_free_container_ctx(struct xhci_hcd *xhci,
kfree(ctx); kfree(ctx);
} }
struct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci, struct xhci_input_control_ctx *xhci_get_input_control_ctx(
struct xhci_container_ctx *ctx) struct xhci_container_ctx *ctx)
{ {
if (ctx->type != XHCI_CTX_TYPE_INPUT) if (ctx->type != XHCI_CTX_TYPE_INPUT)
@ -784,8 +784,7 @@ void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
* Reinstalls the "normal" endpoint ring (at its previous dequeue mark, * Reinstalls the "normal" endpoint ring (at its previous dequeue mark,
* not at the beginning of the ring). * not at the beginning of the ring).
*/ */
void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci, void xhci_setup_no_streams_ep_input_ctx(struct xhci_ep_ctx *ep_ctx,
struct xhci_ep_ctx *ep_ctx,
struct xhci_virt_ep *ep) struct xhci_virt_ep *ep)
{ {
dma_addr_t addr; dma_addr_t addr;
@ -1341,8 +1340,7 @@ static u32 xhci_get_endpoint_mult(struct usb_device *udev,
return ep->ss_ep_comp.bmAttributes; return ep->ss_ep_comp.bmAttributes;
} }
static u32 xhci_get_endpoint_type(struct usb_device *udev, static u32 xhci_get_endpoint_type(struct usb_host_endpoint *ep)
struct usb_host_endpoint *ep)
{ {
int in; int in;
u32 type; u32 type;
@ -1375,8 +1373,7 @@ static u32 xhci_get_endpoint_type(struct usb_device *udev,
* Basically, this is the maxpacket size, multiplied by the burst size * Basically, this is the maxpacket size, multiplied by the burst size
* and mult size. * and mult size.
*/ */
static u32 xhci_get_max_esit_payload(struct xhci_hcd *xhci, static u32 xhci_get_max_esit_payload(struct usb_device *udev,
struct usb_device *udev,
struct usb_host_endpoint *ep) struct usb_host_endpoint *ep)
{ {
int max_burst; int max_burst;
@ -1417,7 +1414,7 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
ep_index = xhci_get_endpoint_index(&ep->desc); ep_index = xhci_get_endpoint_index(&ep->desc);
ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index); ep_ctx = xhci_get_ep_ctx(xhci, virt_dev->in_ctx, ep_index);
endpoint_type = xhci_get_endpoint_type(udev, ep); endpoint_type = xhci_get_endpoint_type(ep);
if (!endpoint_type) if (!endpoint_type)
return -EINVAL; return -EINVAL;
ep_ctx->ep_info2 = cpu_to_le32(endpoint_type); ep_ctx->ep_info2 = cpu_to_le32(endpoint_type);
@ -1483,7 +1480,7 @@ int xhci_endpoint_init(struct xhci_hcd *xhci,
} }
ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet) | ep_ctx->ep_info2 |= cpu_to_le32(MAX_PACKET(max_packet) |
MAX_BURST(max_burst)); MAX_BURST(max_burst));
max_esit_payload = xhci_get_max_esit_payload(xhci, udev, ep); max_esit_payload = xhci_get_max_esit_payload(udev, ep);
ep_ctx->tx_info = cpu_to_le32(MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload)); ep_ctx->tx_info = cpu_to_le32(MAX_ESIT_PAYLOAD_FOR_EP(max_esit_payload));
/* /*
@ -1772,7 +1769,7 @@ struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
return command; return command;
} }
void xhci_urb_free_priv(struct xhci_hcd *xhci, struct urb_priv *urb_priv) void xhci_urb_free_priv(struct urb_priv *urb_priv)
{ {
if (urb_priv) { if (urb_priv) {
kfree(urb_priv->td[0]); kfree(urb_priv->td[0]);
@ -1925,7 +1922,7 @@ static int xhci_test_trb_in_td(struct xhci_hcd *xhci,
} }
/* TRB math checks for xhci_trb_in_td(), using the command and event rings. */ /* TRB math checks for xhci_trb_in_td(), using the command and event rings. */
static int xhci_check_trb_in_td_math(struct xhci_hcd *xhci, gfp_t mem_flags) static int xhci_check_trb_in_td_math(struct xhci_hcd *xhci)
{ {
struct { struct {
dma_addr_t input_dma; dma_addr_t input_dma;
@ -2451,7 +2448,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
flags); flags);
if (!xhci->event_ring) if (!xhci->event_ring)
goto fail; goto fail;
if (xhci_check_trb_in_td_math(xhci, flags) < 0) if (xhci_check_trb_in_td_math(xhci) < 0)
goto fail; goto fail;
xhci->erst.entries = dma_alloc_coherent(dev, xhci->erst.entries = dma_alloc_coherent(dev,

6
drivers/usb/host/xhci-ring.c
View File

@ -609,7 +609,7 @@ static void xhci_giveback_urb_in_irq(struct xhci_hcd *xhci,
spin_unlock(&xhci->lock); spin_unlock(&xhci->lock);
usb_hcd_giveback_urb(hcd, urb, status); usb_hcd_giveback_urb(hcd, urb, status);
xhci_urb_free_priv(xhci, urb_priv); xhci_urb_free_priv(urb_priv);
spin_lock(&xhci->lock); spin_lock(&xhci->lock);
} }
} }
@ -1110,7 +1110,7 @@ static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,
* is not waiting on the configure endpoint command. * is not waiting on the configure endpoint command.
*/ */
virt_dev = xhci->devs[slot_id]; virt_dev = xhci->devs[slot_id];
ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "Could not get input context, bad type.\n"); xhci_warn(xhci, "Could not get input context, bad type.\n");
return; return;
@ -2497,7 +2497,7 @@ cleanup:
urb = td->urb; urb = td->urb;
urb_priv = urb->hcpriv; urb_priv = urb->hcpriv;
xhci_urb_free_priv(xhci, urb_priv); xhci_urb_free_priv(urb_priv);
usb_hcd_unlink_urb_from_ep(bus_to_hcd(urb->dev->bus), urb); usb_hcd_unlink_urb_from_ep(bus_to_hcd(urb->dev->bus), urb);
if ((urb->actual_length != urb->transfer_buffer_length && if ((urb->actual_length != urb->transfer_buffer_length &&

34
drivers/usb/host/xhci.c
View File

@ -1273,7 +1273,7 @@ static int xhci_check_maxpacket(struct xhci_hcd *xhci, unsigned int slot_id,
return -ENOMEM; return -ENOMEM;
command->in_ctx = xhci->devs[slot_id]->in_ctx; command->in_ctx = xhci->devs[slot_id]->in_ctx;
ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);
@ -1371,7 +1371,7 @@ int xhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
ret = xhci_check_maxpacket(xhci, slot_id, ret = xhci_check_maxpacket(xhci, slot_id,
ep_index, urb); ep_index, urb);
if (ret < 0) { if (ret < 0) {
xhci_urb_free_priv(xhci, urb_priv); xhci_urb_free_priv(urb_priv);
urb->hcpriv = NULL; urb->hcpriv = NULL;
return ret; return ret;
} }
@ -1437,7 +1437,7 @@ dying:
urb->ep->desc.bEndpointAddress, urb); urb->ep->desc.bEndpointAddress, urb);
ret = -ESHUTDOWN; ret = -ESHUTDOWN;
free_priv: free_priv:
xhci_urb_free_priv(xhci, urb_priv); xhci_urb_free_priv(urb_priv);
urb->hcpriv = NULL; urb->hcpriv = NULL;
spin_unlock_irqrestore(&xhci->lock, flags); spin_unlock_irqrestore(&xhci->lock, flags);
return ret; return ret;
@ -1550,7 +1550,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
usb_hcd_unlink_urb_from_ep(hcd, urb); usb_hcd_unlink_urb_from_ep(hcd, urb);
spin_unlock_irqrestore(&xhci->lock, flags); spin_unlock_irqrestore(&xhci->lock, flags);
usb_hcd_giveback_urb(hcd, urb, -ESHUTDOWN); usb_hcd_giveback_urb(hcd, urb, -ESHUTDOWN);
xhci_urb_free_priv(xhci, urb_priv); xhci_urb_free_priv(urb_priv);
return ret; return ret;
} }
if ((xhci->xhc_state & XHCI_STATE_DYING) || if ((xhci->xhc_state & XHCI_STATE_DYING) ||
@ -1657,7 +1657,7 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
in_ctx = xhci->devs[udev->slot_id]->in_ctx; in_ctx = xhci->devs[udev->slot_id]->in_ctx;
out_ctx = xhci->devs[udev->slot_id]->out_ctx; out_ctx = xhci->devs[udev->slot_id]->out_ctx;
ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx); ctrl_ctx = xhci_get_input_control_ctx(in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);
@ -1742,7 +1742,7 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
virt_dev = xhci->devs[udev->slot_id]; virt_dev = xhci->devs[udev->slot_id];
in_ctx = virt_dev->in_ctx; in_ctx = virt_dev->in_ctx;
ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx); ctrl_ctx = xhci_get_input_control_ctx(in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);
@ -1810,7 +1810,7 @@ static void xhci_zero_in_ctx(struct xhci_hcd *xhci, struct xhci_virt_device *vir
struct xhci_slot_ctx *slot_ctx; struct xhci_slot_ctx *slot_ctx;
int i; int i;
ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);
@ -2536,7 +2536,7 @@ static int xhci_reserve_bandwidth(struct xhci_hcd *xhci,
if (virt_dev->tt_info) if (virt_dev->tt_info)
old_active_eps = virt_dev->tt_info->active_eps; old_active_eps = virt_dev->tt_info->active_eps;
ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx); ctrl_ctx = xhci_get_input_control_ctx(in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);
@ -2633,7 +2633,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
spin_lock_irqsave(&xhci->lock, flags); spin_lock_irqsave(&xhci->lock, flags);
virt_dev = xhci->devs[udev->slot_id]; virt_dev = xhci->devs[udev->slot_id];
ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
spin_unlock_irqrestore(&xhci->lock, flags); spin_unlock_irqrestore(&xhci->lock, flags);
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
@ -2752,7 +2752,7 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
command->in_ctx = virt_dev->in_ctx; command->in_ctx = virt_dev->in_ctx;
/* See section 4.6.6 - A0 = 1; A1 = D0 = D1 = 0 */ /* See section 4.6.6 - A0 = 1; A1 = D0 = D1 = 0 */
ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);
@ -2877,7 +2877,7 @@ static void xhci_setup_input_ctx_for_quirk(struct xhci_hcd *xhci,
dma_addr_t addr; dma_addr_t addr;
in_ctx = xhci->devs[slot_id]->in_ctx; in_ctx = xhci->devs[slot_id]->in_ctx;
ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx); ctrl_ctx = xhci_get_input_control_ctx(in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);
@ -3167,7 +3167,7 @@ int xhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
xhci_dbg(xhci, "Could not allocate xHCI command structure.\n"); xhci_dbg(xhci, "Could not allocate xHCI command structure.\n");
return -ENOMEM; return -ENOMEM;
} }
ctrl_ctx = xhci_get_input_control_ctx(xhci, config_cmd->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(config_cmd->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);
@ -3322,7 +3322,7 @@ int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
*/ */
ep_index = xhci_get_endpoint_index(&eps[0]->desc); ep_index = xhci_get_endpoint_index(&eps[0]->desc);
command = vdev->eps[ep_index].stream_info->free_streams_command; command = vdev->eps[ep_index].stream_info->free_streams_command;
ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
spin_unlock_irqrestore(&xhci->lock, flags); spin_unlock_irqrestore(&xhci->lock, flags);
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
@ -3340,7 +3340,7 @@ int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
xhci_endpoint_copy(xhci, command->in_ctx, xhci_endpoint_copy(xhci, command->in_ctx,
vdev->out_ctx, ep_index); vdev->out_ctx, ep_index);
xhci_setup_no_streams_ep_input_ctx(xhci, ep_ctx, xhci_setup_no_streams_ep_input_ctx(ep_ctx,
&vdev->eps[ep_index]); &vdev->eps[ep_index]);
} }
xhci_setup_input_ctx_for_config_ep(xhci, command->in_ctx, xhci_setup_input_ctx_for_config_ep(xhci, command->in_ctx,
@ -3805,7 +3805,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
command->completion = &xhci->addr_dev; command->completion = &xhci->addr_dev;
slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx); slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->in_ctx);
ctrl_ctx = xhci_get_input_control_ctx(xhci, virt_dev->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(virt_dev->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);
@ -3988,7 +3988,7 @@ static int __maybe_unused xhci_change_max_exit_latency(struct xhci_hcd *xhci,
/* Attempt to issue an Evaluate Context command to change the MEL. */ /* Attempt to issue an Evaluate Context command to change the MEL. */
command = xhci->lpm_command; command = xhci->lpm_command;
ctrl_ctx = xhci_get_input_control_ctx(xhci, command->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(command->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
spin_unlock_irqrestore(&xhci->lock, flags); spin_unlock_irqrestore(&xhci->lock, flags);
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
@ -4726,7 +4726,7 @@ int xhci_update_hub_device(struct usb_hcd *hcd, struct usb_device *hdev,
xhci_dbg(xhci, "Could not allocate xHCI command structure.\n"); xhci_dbg(xhci, "Could not allocate xHCI command structure.\n");
return -ENOMEM; return -ENOMEM;
} }
ctrl_ctx = xhci_get_input_control_ctx(xhci, config_cmd->in_ctx); ctrl_ctx = xhci_get_input_control_ctx(config_cmd->in_ctx);
if (!ctrl_ctx) { if (!ctrl_ctx) {
xhci_warn(xhci, "%s: Could not get input context, bad type.\n", xhci_warn(xhci, "%s: Could not get input context, bad type.\n",
__func__); __func__);

7
drivers/usb/host/xhci.h
View File

@ -1712,8 +1712,7 @@ void xhci_free_stream_info(struct xhci_hcd *xhci,
void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci, void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
struct xhci_ep_ctx *ep_ctx, struct xhci_ep_ctx *ep_ctx,
struct xhci_stream_info *stream_info); struct xhci_stream_info *stream_info);
void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci, void xhci_setup_no_streams_ep_input_ctx(struct xhci_ep_ctx *ep_ctx,
struct xhci_ep_ctx *ep_ctx,
struct xhci_virt_ep *ep); struct xhci_virt_ep *ep);
void xhci_free_device_endpoint_resources(struct xhci_hcd *xhci, void xhci_free_device_endpoint_resources(struct xhci_hcd *xhci,
struct xhci_virt_device *virt_dev, bool drop_control_ep); struct xhci_virt_device *virt_dev, bool drop_control_ep);
@ -1727,7 +1726,7 @@ struct xhci_ring *xhci_stream_id_to_ring(
struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci, struct xhci_command *xhci_alloc_command(struct xhci_hcd *xhci,
bool allocate_in_ctx, bool allocate_completion, bool allocate_in_ctx, bool allocate_completion,
gfp_t mem_flags); gfp_t mem_flags);
void xhci_urb_free_priv(struct xhci_hcd *xhci, struct urb_priv *urb_priv); void xhci_urb_free_priv(struct urb_priv *urb_priv);
void xhci_free_command(struct xhci_hcd *xhci, void xhci_free_command(struct xhci_hcd *xhci,
struct xhci_command *command); struct xhci_command *command);
@ -1863,7 +1862,7 @@ int xhci_find_slot_id_by_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
void xhci_ring_device(struct xhci_hcd *xhci, int slot_id); void xhci_ring_device(struct xhci_hcd *xhci, int slot_id);
/* xHCI contexts */ /* xHCI contexts */
struct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx); struct xhci_input_control_ctx *xhci_get_input_control_ctx(struct xhci_container_ctx *ctx);
struct xhci_slot_ctx *xhci_get_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx); struct xhci_slot_ctx *xhci_get_slot_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx);
struct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx, unsigned int ep_index); struct xhci_ep_ctx *xhci_get_ep_ctx(struct xhci_hcd *xhci, struct xhci_container_ctx *ctx, unsigned int ep_index);