staging: octeon-usb: switch to use kernel types

 *			status call.

 */

struct cvmx_usb_port_status {

	uint32_t reserved		: 25;

	uint32_t port_enabled		: 1;

	uint32_t port_over_current	: 1;

	uint32_t port_powered		: 1;

	u32 reserved			: 25;

	u32 port_enabled		: 1;

	u32 port_over_current		: 1;

	u32 port_powered		: 1;

	enum cvmx_usb_speed port_speed	: 2;

	uint32_t connected		: 1;

	uint32_t connect_change		: 1;

	u32 connected			: 1;

	u32 connect_change		: 1;

};

/**

struct cvmx_usb_transaction {

	struct list_head node;

	enum cvmx_usb_transfer type;

	uint64_t buffer;

	u64 buffer;

	int buffer_length;

	uint64_t control_header;

	u64 control_header;

	int iso_start_frame;

	int iso_number_packets;

	struct cvmx_usb_iso_packet *iso_packets;

struct cvmx_usb_pipe {

	struct list_head node;

	struct list_head transactions;

	uint64_t interval;

	uint64_t next_tx_frame;

	u64 interval;

	u64 next_tx_frame;

	enum cvmx_usb_pipe_flags flags;

	enum cvmx_usb_speed device_speed;

	enum cvmx_usb_transfer transfer_type;

	enum cvmx_usb_direction transfer_dir;

	int multi_count;

	uint16_t max_packet;

	uint8_t device_addr;

	uint8_t endpoint_num;

	uint8_t hub_device_addr;

	uint8_t hub_port;

	uint8_t pid_toggle;

	uint8_t channel;

	int8_t split_sc_frame;

	u16 max_packet;

	u8 device_addr;

	u8 endpoint_num;

	u8 hub_device_addr;

	u8 hub_port;

	u8 pid_toggle;

	u8 channel;

	s8 split_sc_frame;

};

struct cvmx_usb_tx_fifo {

	struct {

		int channel;

		int size;

		uint64_t address;

		u64 address;

	} entry[MAX_CHANNELS+1];

	int head;

	int tail;

	struct cvmx_usb_port_status port_status;

	struct list_head idle_pipes;

	struct list_head active_pipes[4];

	uint64_t frame_number;

	u64 frame_number;

	struct cvmx_usb_transaction *active_split;

	struct cvmx_usb_tx_fifo periodic;

	struct cvmx_usb_tx_fifo nonperiodic;

#define CVMX_WAIT_FOR_FIELD32(address, _union, cond, timeout_usec)	    \

	({int result;							    \

	do {								    \

		uint64_t done = cvmx_get_cycle() + (uint64_t)timeout_usec * \

		u64 done = cvmx_get_cycle() + (u64)timeout_usec *	    \

			   octeon_get_clock_rate() / 1000000;		    \

		union _union c;						    \

									    \

 *

 * Returns: Result of the read

 */

static inline uint32_t cvmx_usb_read_csr32(struct cvmx_usb_state *usb,

					   uint64_t address)

static inline u32 cvmx_usb_read_csr32(struct cvmx_usb_state *usb, u64 address)

{

	uint32_t result = cvmx_read64_uint32(address ^ 4);

	u32 result = cvmx_read64_uint32(address ^ 4);

	return result;

}

 * @value:   Value to write

 */

static inline void cvmx_usb_write_csr32(struct cvmx_usb_state *usb,

					uint64_t address, uint32_t value)

					u64 address, u32 value)

{

	cvmx_write64_uint32(address ^ 4, value);

	cvmx_read64_uint64(CVMX_USBNX_DMA0_INB_CHN0(usb->index));

	union cvmx_usbcx_grxstsph rx_status;

	int channel;

	int bytes;

	uint64_t address;

	uint32_t *ptr;

	u64 address;

	u32 *ptr;

	rx_status.u32 = cvmx_usb_read_csr32(usb,

					    CVMX_USBCX_GRXSTSPH(usb->index));

	 */

	while (available && (fifo->head != fifo->tail)) {

		int i = fifo->tail;

		const uint32_t *ptr = cvmx_phys_to_ptr(fifo->entry[i].address);

		uint64_t csr_address = USB_FIFO_ADDRESS(fifo->entry[i].channel,

		const u32 *ptr = cvmx_phys_to_ptr(fifo->entry[i].address);

		u64 csr_address = USB_FIFO_ADDRESS(fifo->entry[i].channel,

						   usb->index) ^ 4;

		int words = available;

	/* Setup the location the DMA engine uses. */

	{

		uint64_t reg;

		uint64_t dma_address = transaction->buffer +

		u64 reg;

		u64 dma_address = transaction->buffer +

				  transaction->actual_bytes;

		if (transaction->type == CVMX_USB_TRANSFER_ISOCHRONOUS)

static struct cvmx_usb_pipe *cvmx_usb_find_ready_pipe(

		struct cvmx_usb_state *usb,

		struct list_head *list,

		uint64_t current_frame)

		u64 current_frame)

{

	struct cvmx_usb_pipe *pipe;

				struct cvmx_usb_state *usb,

				struct cvmx_usb_pipe *pipe,

				enum cvmx_usb_transfer type,

				uint64_t buffer,

				u64 buffer,

				int buffer_length,

				uint64_t control_header,

				u64 control_header,

				int iso_start_frame,

				int iso_number_packets,

				struct cvmx_usb_iso_packet *iso_packets,

						struct urb *urb)

{

	int buffer_length = urb->transfer_buffer_length;

	uint64_t control_header = urb->setup_dma;

	u64 control_header = urb->setup_dma;

	struct usb_ctrlrequest *header = cvmx_phys_to_ptr(control_header);

	if ((header->bRequestType & USB_DIR_IN) == 0)