Commit f5960b69 authored by Matt Evans's avatar Matt Evans Committed by Sarah Sharp
Browse files

xhci: Remove some unnecessary casts and tidy some endian swap code 



Some of the recently-added cpu_to_leXX and leXX_to_cpu made things somewhat
messy; this patch neatens some of these areas, removing unnecessary casts
in those parts also.  In some places (where Y & Z are constants) a
comparison of (leXX_to_cpu(X) & Y) == Z has been replaced with
(X & cpu_to_leXX(Y)) == cpu_to_leXX(Z).  The endian reversal of the
constants should wash out at compile time.

Signed-off-by: default avatarMatt Evans <matt@ozlabs.org>
Signed-off-by: default avatarSarah Sharp <sarah.a.sharp@linux.intel.com>
parent 55922c9d

drivers/usb/host/xhci-dbg.c

+11 −11
Original line number Diff line number Diff line
@@ -266,11 +266,11 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb) 
		xhci_dbg(xhci, "Interrupter target = 0x%x\n",

			 GET_INTR_TARGET(le32_to_cpu(trb->link.intr_target)));

		xhci_dbg(xhci, "Cycle bit = %u\n",

			 (unsigned int) (le32_to_cpu(trb->link.control) & TRB_CYCLE));

			 le32_to_cpu(trb->link.control) & TRB_CYCLE);

		xhci_dbg(xhci, "Toggle cycle bit = %u\n",

			 (unsigned int) (le32_to_cpu(trb->link.control) & LINK_TOGGLE));

			 le32_to_cpu(trb->link.control) & LINK_TOGGLE);

		xhci_dbg(xhci, "No Snoop bit = %u\n",

			 (unsigned int) (le32_to_cpu(trb->link.control) & TRB_NO_SNOOP));

			 le32_to_cpu(trb->link.control) & TRB_NO_SNOOP);

		break;

	case TRB_TYPE(TRB_TRANSFER):

		address = le64_to_cpu(trb->trans_event.buffer);
@@ -284,9 +284,9 @@ void xhci_debug_trb(struct xhci_hcd *xhci, union xhci_trb *trb) 
		address = le64_to_cpu(trb->event_cmd.cmd_trb);

		xhci_dbg(xhci, "Command TRB pointer = %llu\n", address);

		xhci_dbg(xhci, "Completion status = %u\n",

			 (unsigned int) GET_COMP_CODE(le32_to_cpu(trb->event_cmd.status)));

			 GET_COMP_CODE(le32_to_cpu(trb->event_cmd.status)));

		xhci_dbg(xhci, "Flags = 0x%x\n",

			 (unsigned int) le32_to_cpu(trb->event_cmd.flags));

			 le32_to_cpu(trb->event_cmd.flags));

		break;

	default:

		xhci_dbg(xhci, "Unknown TRB with TRB type ID %u\n",
@@ -318,10 +318,10 @@ void xhci_debug_segment(struct xhci_hcd *xhci, struct xhci_segment *seg) 
	for (i = 0; i < TRBS_PER_SEGMENT; ++i) {

		trb = &seg->trbs[i];

		xhci_dbg(xhci, "@%016llx %08x %08x %08x %08x\n", addr,

			 (u32)lower_32_bits(le64_to_cpu(trb->link.segment_ptr)),

			 (u32)upper_32_bits(le64_to_cpu(trb->link.segment_ptr)),

			 (unsigned int) le32_to_cpu(trb->link.intr_target),

			 (unsigned int) le32_to_cpu(trb->link.control));

			 lower_32_bits(le64_to_cpu(trb->link.segment_ptr)),

			 upper_32_bits(le64_to_cpu(trb->link.segment_ptr)),

			 le32_to_cpu(trb->link.intr_target),

			 le32_to_cpu(trb->link.control));

		addr += sizeof(*trb);

	}

}
@@ -402,8 +402,8 @@ void xhci_dbg_erst(struct xhci_hcd *xhci, struct xhci_erst *erst) 
			 addr,

			 lower_32_bits(le64_to_cpu(entry->seg_addr)),

			 upper_32_bits(le64_to_cpu(entry->seg_addr)),

			 (unsigned int) le32_to_cpu(entry->seg_size),

			 (unsigned int) le32_to_cpu(entry->rsvd));

			 le32_to_cpu(entry->seg_size),

			 le32_to_cpu(entry->rsvd));

		addr += sizeof(*entry);

	}

}

drivers/usb/host/xhci-mem.c

+13 −13
Original line number Diff line number Diff line
@@ -89,8 +89,8 @@ static void xhci_link_segments(struct xhci_hcd *xhci, struct xhci_segment *prev, 
		return;

	prev->next = next;

	if (link_trbs) {

		prev->trbs[TRBS_PER_SEGMENT-1].link.

			segment_ptr = cpu_to_le64(next->dma);

		prev->trbs[TRBS_PER_SEGMENT-1].link.segment_ptr =

			cpu_to_le64(next->dma);



		/* Set the last TRB in the segment to have a TRB type ID of Link TRB */

		val = le32_to_cpu(prev->trbs[TRBS_PER_SEGMENT-1].link.control);
@@ -187,8 +187,8 @@ static struct xhci_ring *xhci_ring_alloc(struct xhci_hcd *xhci, 


	if (link_trbs) {

		/* See section 4.9.2.1 and 6.4.4.1 */

		prev->trbs[TRBS_PER_SEGMENT-1].link.

			control |= cpu_to_le32(LINK_TOGGLE);

		prev->trbs[TRBS_PER_SEGMENT-1].link.control |=

			cpu_to_le32(LINK_TOGGLE);

		xhci_dbg(xhci, "Wrote link toggle flag to"

				" segment %p (virtual), 0x%llx (DMA)\n",

				prev, (unsigned long long)prev->dma);
@@ -549,8 +549,8 @@ struct xhci_stream_info *xhci_alloc_stream_info(struct xhci_hcd *xhci, 
		addr = cur_ring->first_seg->dma |

			SCT_FOR_CTX(SCT_PRI_TR) |

			cur_ring->cycle_state;

		stream_info->stream_ctx_array[cur_stream].

			stream_ring = cpu_to_le64(addr);

		stream_info->stream_ctx_array[cur_stream].stream_ring =

			cpu_to_le64(addr);

		xhci_dbg(xhci, "Setting stream %d ring ptr to 0x%08llx\n",

				cur_stream, (unsigned long long) addr);
@@ -786,7 +786,7 @@ int xhci_alloc_virt_device(struct xhci_hcd *xhci, int slot_id, 
	xhci_dbg(xhci, "Set slot id %d dcbaa entry %p to 0x%llx\n",

		 slot_id,

		 &xhci->dcbaa->dev_context_ptrs[slot_id],

		 (unsigned long long) le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id]));

		 le64_to_cpu(xhci->dcbaa->dev_context_ptrs[slot_id]));



	return 1;

fail:
@@ -890,19 +890,19 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud 
	ctrl_ctx->add_flags = cpu_to_le32(SLOT_FLAG | EP0_FLAG);



	/* 3) Only the control endpoint is valid - one endpoint context */

	slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | (u32) udev->route);

	slot_ctx->dev_info |= cpu_to_le32(LAST_CTX(1) | udev->route);

	switch (udev->speed) {

	case USB_SPEED_SUPER:

		slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_SS);

		slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_SS);

		break;

	case USB_SPEED_HIGH:

		slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_HS);

		slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_HS);

		break;

	case USB_SPEED_FULL:

		slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_FS);

		slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_FS);

		break;

	case USB_SPEED_LOW:

		slot_ctx->dev_info |= cpu_to_le32((u32) SLOT_SPEED_LS);

		slot_ctx->dev_info |= cpu_to_le32(SLOT_SPEED_LS);

		break;

	case USB_SPEED_WIRELESS:

		xhci_dbg(xhci, "FIXME xHCI doesn't support wireless speeds\n");
@@ -916,7 +916,7 @@ int xhci_setup_addressable_virt_dev(struct xhci_hcd *xhci, struct usb_device *ud 
	port_num = xhci_find_real_port_number(xhci, udev);

	if (!port_num)

		return -EINVAL;

	slot_ctx->dev_info2 |= cpu_to_le32((u32) ROOT_HUB_PORT(port_num));

	slot_ctx->dev_info2 |= cpu_to_le32(ROOT_HUB_PORT(port_num));

	/* Set the port number in the virtual_device to the faked port number */

	for (top_dev = udev; top_dev->parent && top_dev->parent->parent;

			top_dev = top_dev->parent)

drivers/usb/host/xhci-ring.c

+17 −25
Original line number Diff line number Diff line
@@ -113,15 +113,13 @@ static int last_trb(struct xhci_hcd *xhci, struct xhci_ring *ring, 
	if (ring == xhci->event_ring)

		return trb == &seg->trbs[TRBS_PER_SEGMENT];

	else

		return (le32_to_cpu(trb->link.control) & TRB_TYPE_BITMASK)

			== TRB_TYPE(TRB_LINK);

		return TRB_TYPE_LINK_LE32(trb->link.control);

}



static int enqueue_is_link_trb(struct xhci_ring *ring)

{

	struct xhci_link_trb *link = &ring->enqueue->link;

	return ((le32_to_cpu(link->control) & TRB_TYPE_BITMASK) ==

		TRB_TYPE(TRB_LINK));

	return TRB_TYPE_LINK_LE32(link->control);

}



/* Updates trb to point to the next TRB in the ring, and updates seg if the next
@@ -372,7 +370,7 @@ static struct xhci_segment *find_trb_seg( 
	while (cur_seg->trbs > trb ||

			&cur_seg->trbs[TRBS_PER_SEGMENT - 1] < trb) {

		generic_trb = &cur_seg->trbs[TRBS_PER_SEGMENT - 1].generic;

		if (le32_to_cpu(generic_trb->field[3]) & LINK_TOGGLE)

		if (generic_trb->field[3] & cpu_to_le32(LINK_TOGGLE))

			*cycle_state ^= 0x1;

		cur_seg = cur_seg->next;

		if (cur_seg == start_seg)
@@ -489,8 +487,8 @@ void xhci_find_new_dequeue_state(struct xhci_hcd *xhci, 
	}



	trb = &state->new_deq_ptr->generic;

	if ((le32_to_cpu(trb->field[3]) & TRB_TYPE_BITMASK) ==

	    TRB_TYPE(TRB_LINK) && (le32_to_cpu(trb->field[3]) & LINK_TOGGLE))

	if (TRB_TYPE_LINK_LE32(trb->field[3]) &&

	    (trb->field[3] & cpu_to_le32(LINK_TOGGLE)))

		state->new_cycle_state ^= 0x1;

	next_trb(xhci, ep_ring, &state->new_deq_seg, &state->new_deq_ptr);
@@ -525,8 +523,7 @@ static void td_to_noop(struct xhci_hcd *xhci, struct xhci_ring *ep_ring, 
	for (cur_seg = cur_td->start_seg, cur_trb = cur_td->first_trb;

			true;

			next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {

		if ((le32_to_cpu(cur_trb->generic.field[3]) & TRB_TYPE_BITMASK)

		    == TRB_TYPE(TRB_LINK)) {

		if (TRB_TYPE_LINK_LE32(cur_trb->generic.field[3])) {

			/* Unchain any chained Link TRBs, but

			 * leave the pointers intact.

			 */
@@ -1000,7 +997,7 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci, 
	 * but we don't care.

	 */

	xhci_dbg(xhci, "Ignoring reset ep completion code of %u\n",

		 (unsigned int) GET_COMP_CODE(le32_to_cpu(event->status)));

		 GET_COMP_CODE(le32_to_cpu(event->status)));



	/* HW with the reset endpoint quirk needs to have a configure endpoint

	 * command complete before the endpoint can be used.  Queue that here
@@ -1458,7 +1455,8 @@ static int xhci_requires_manual_halt_cleanup(struct xhci_hcd *xhci, 
		 * endpoint anyway.  Check if a babble halted the

		 * endpoint.

		 */

		if ((le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) == EP_STATE_HALTED)

		if ((ep_ctx->ep_info & cpu_to_le32(EP_STATE_MASK)) ==

		    cpu_to_le32(EP_STATE_HALTED))

			return 1;



	return 0;
@@ -1752,10 +1750,8 @@ static int process_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td, 
		for (cur_trb = ep_ring->dequeue,

		     cur_seg = ep_ring->deq_seg; cur_trb != event_trb;

		     next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {

			if ((le32_to_cpu(cur_trb->generic.field[3]) &

			 TRB_TYPE_BITMASK) != TRB_TYPE(TRB_TR_NOOP) &&

			    (le32_to_cpu(cur_trb->generic.field[3]) &

			 TRB_TYPE_BITMASK) != TRB_TYPE(TRB_LINK))

			if (!TRB_TYPE_NOOP_LE32(cur_trb->generic.field[3]) &&

			    !TRB_TYPE_LINK_LE32(cur_trb->generic.field[3]))

				len += TRB_LEN(le32_to_cpu(cur_trb->generic.field[2]));

		}

		len += TRB_LEN(le32_to_cpu(cur_trb->generic.field[2])) -
@@ -1888,10 +1884,8 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td, 
		for (cur_trb = ep_ring->dequeue, cur_seg = ep_ring->deq_seg;

				cur_trb != event_trb;

				next_trb(xhci, ep_ring, &cur_seg, &cur_trb)) {

			if ((le32_to_cpu(cur_trb->generic.field[3]) &

			 TRB_TYPE_BITMASK) != TRB_TYPE(TRB_TR_NOOP) &&

			    (le32_to_cpu(cur_trb->generic.field[3]) &

			 TRB_TYPE_BITMASK) != TRB_TYPE(TRB_LINK))

			if (!TRB_TYPE_NOOP_LE32(cur_trb->generic.field[3]) &&

			    !TRB_TYPE_LINK_LE32(cur_trb->generic.field[3]))

				td->urb->actual_length +=

					TRB_LEN(le32_to_cpu(cur_trb->generic.field[2]));

		}
@@ -2046,8 +2040,8 @@ static int handle_tx_event(struct xhci_hcd *xhci, 
				  TRB_TO_SLOT_ID(le32_to_cpu(event->flags)),

				  ep_index);

			xhci_dbg(xhci, "Event TRB with TRB type ID %u\n",

				 (unsigned int) (le32_to_cpu(event->flags)

						 & TRB_TYPE_BITMASK)>>10);

				 (le32_to_cpu(event->flags) &

				  TRB_TYPE_BITMASK)>>10);

			xhci_print_trb_offsets(xhci, (union xhci_trb *) event);

			if (ep->skip) {

				ep->skip = false;
@@ -2104,9 +2098,7 @@ static int handle_tx_event(struct xhci_hcd *xhci, 
		 * corresponding TD has been cancelled. Just ignore

		 * the TD.

		 */

		if ((le32_to_cpu(event_trb->generic.field[3])

			     & TRB_TYPE_BITMASK)

				 == TRB_TYPE(TRB_TR_NOOP)) {

		if (TRB_TYPE_NOOP_LE32(event_trb->generic.field[3])) {

			xhci_dbg(xhci,

				 "event_trb is a no-op TRB. Skip it\n");

			goto cleanup;
@@ -2432,7 +2424,7 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring, 
				next->link.control |= cpu_to_le32(TRB_CHAIN);



			wmb();

			next->link.control ^= cpu_to_le32((u32) TRB_CYCLE);

			next->link.control ^= cpu_to_le32(TRB_CYCLE);



			/* Toggle the cycle bit after the last ring segment. */

			if (last_trb_on_last_seg(xhci, ring, ring->enq_seg, next)) {

drivers/usb/host/xhci.c

+4 −6
Original line number Diff line number Diff line
@@ -1333,8 +1333,8 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev, 
	/* If the HC already knows the endpoint is disabled,

	 * or the HCD has noted it is disabled, ignore this request

	 */

	if ((le32_to_cpu(ep_ctx->ep_info) & EP_STATE_MASK) ==

	    EP_STATE_DISABLED ||

	if (((ep_ctx->ep_info & cpu_to_le32(EP_STATE_MASK)) ==

	     cpu_to_le32(EP_STATE_DISABLED)) ||

	    le32_to_cpu(ctrl_ctx->drop_flags) &

	    xhci_get_endpoint_flag(&ep->desc)) {

		xhci_warn(xhci, "xHCI %s called with disabled ep %p\n",
@@ -1725,8 +1725,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci, 
		/* Enqueue pointer can be left pointing to the link TRB,

		 * we must handle that

		 */

		if ((le32_to_cpu(command->command_trb->link.control)

		     & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))

		if (TRB_TYPE_LINK_LE32(command->command_trb->link.control))

			command->command_trb =

				xhci->cmd_ring->enq_seg->next->trbs;
@@ -2519,8 +2518,7 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev) 
	/* Enqueue pointer can be left pointing to the link TRB,

	 * we must handle that

	 */

	if ((le32_to_cpu(reset_device_cmd->command_trb->link.control)

	     & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))

	if (TRB_TYPE_LINK_LE32(reset_device_cmd->command_trb->link.control))

		reset_device_cmd->command_trb =

			xhci->cmd_ring->enq_seg->next->trbs;

drivers/usb/host/xhci.h

+7 −0
Original line number Diff line number Diff line
@@ -1065,6 +1065,13 @@ union xhci_trb { 
/* Get NEC firmware revision. */

#define	TRB_NEC_GET_FW		49



#define TRB_TYPE_LINK(x)	(((x) & TRB_TYPE_BITMASK) == TRB_TYPE(TRB_LINK))

/* Above, but for __le32 types -- can avoid work by swapping constants: */

#define TRB_TYPE_LINK_LE32(x)	(((x) & cpu_to_le32(TRB_TYPE_BITMASK)) == \

				 cpu_to_le32(TRB_TYPE(TRB_LINK)))

#define TRB_TYPE_NOOP_LE32(x)	(((x) & cpu_to_le32(TRB_TYPE_BITMASK)) == \

				 cpu_to_le32(TRB_TYPE(TRB_TR_NOOP)))



#define NEC_FW_MINOR(p)		(((p) >> 0) & 0xff)

#define NEC_FW_MAJOR(p)		(((p) >> 8) & 0xff)

CRA Git | Maintained and supported by SUSTech CRA and CCSE