path: root/carl9170fw/carlfw/usb/main.c

/*
 * carl9170 firmware - used by the ar9170 wireless device
 *
 * Copyright (c) 2000-2005 ZyDAS Technology Corporation
 * Copyright (c) 2007-2009 Atheros Communications, Inc.
 * Copyright	2009	Johannes Berg <johannes@sipsolutions.net>
 * Copyright 2009-2011	Christian Lamparter <chunkeey@googlemail.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "carl9170.h"

#include "shared/phy.h"
#include "hostif.h"
#include "printf.h"
#include "timer.h"
#include "rom.h"
#include "wl.h"
#include "wol.h"

#ifdef CONFIG_CARL9170FW_DEBUG_USB
void usb_putc(const char c)
{
	fw.usb.put_buffer[fw.usb.put_index++] = (uint8_t) c;

	if (fw.usb.put_index == CARL9170_MAX_CMD_PAYLOAD_LEN || c == '\0') {
		fw.usb.put_buffer[fw.usb.put_index] = 0;

		send_cmd_to_host(__roundup(fw.usb.put_index, 4),
				 CARL9170_RSP_TEXT, fw.usb.put_index,
				 fw.usb.put_buffer);
		fw.usb.put_index = 0;
	}
}

void usb_print_hex_dump(const void *buf, int len)
{
	unsigned int offset = 0, block = 0;
	while (len > 0) {
		block = min(__roundup(len, 4), CARL9170_MAX_CMD_PAYLOAD_LEN);

		send_cmd_to_host(block, CARL9170_RSP_HEXDUMP, len,
				 (const uint8_t *) buf + offset);

		offset += block;
		len -= block;
	}
}
#endif /* CONFIG_CARL9170FW_DEBUG_USB */

/* grab a buffer from the interrupt in queue ring-buffer */
static struct carl9170_rsp *get_int_buf(void)
{
	struct carl9170_rsp *tmp;

	/* fetch the _oldest_ buffer from the ring */
	tmp = &fw.usb.int_buf[fw.usb.int_tail_index];

	/* assign a unique sequence for every response/trap */
	tmp->hdr.seq = fw.usb.int_tail_index;

	fw.usb.int_tail_index++;

	fw.usb.int_tail_index %= CARL9170_INT_RQ_CACHES;
	if (fw.usb.int_pending != CARL9170_INT_RQ_CACHES)
		fw.usb.int_pending++;

	return tmp;
}

/* Pop up data from Interrupt IN Queue to USB Response buffer */
static struct carl9170_rsp *dequeue_int_buf(unsigned int space)
{
	struct carl9170_rsp *tmp = NULL;

	if (fw.usb.int_pending > 0) {
		tmp = &fw.usb.int_buf[fw.usb.int_head_index];

		if ((unsigned int)(tmp->hdr.len + 8) > space)
			return NULL;

		fw.usb.int_head_index++;
		fw.usb.int_head_index %= CARL9170_INT_RQ_CACHES;
		fw.usb.int_pending--;
	}

	return tmp;
}

static void usb_data_in(void)
{
}

static void usb_reg_out(void)
{
	uint32_t *regaddr = (uint32_t *) &dma_mem.reserved.cmd;
	uint16_t usbfifolen, i;

	usb_reset_out();

	usbfifolen = getb(AR9170_USB_REG_EP4_BYTE_COUNT_LOW) |
		     getb(AR9170_USB_REG_EP4_BYTE_COUNT_HIGH) << 8;

	if (usbfifolen & 0x3)
		usbfifolen = (usbfifolen >> 2) + 1;
	else
		usbfifolen = usbfifolen >> 2;

	for (i = 0; i < usbfifolen; i++)
		*regaddr++ = get(AR9170_USB_REG_EP4_DATA);

	handle_cmd(get_int_buf());

	usb_trigger_in();
}

static void usb_status_in(void)
{
	struct carl9170_rsp *rsp;
	unsigned int rem, tlen, elen;

	if (!fw.usb.int_desc_available)
		return ;

	fw.usb.int_desc_available = 0;

	rem = AR9170_BLOCK_SIZE - AR9170_INT_MAGIC_HEADER_SIZE;
	tlen = AR9170_INT_MAGIC_HEADER_SIZE;

	usb_reset_in();

	while (fw.usb.int_pending) {
		rsp = dequeue_int_buf(rem);
		if (!rsp)
			break;

		elen = rsp->hdr.len + 4;

		memcpy(DESC_PAYLOAD_OFF(fw.usb.int_desc, tlen), rsp, elen);

		rem -= elen;
		tlen += elen;
	}

	if (tlen == AR9170_INT_MAGIC_HEADER_SIZE) {
		DBG("attempted to send an empty int response!\n");
		goto reclaim;
	}

	fw.usb.int_desc->ctrl = AR9170_CTRL_FS_BIT | AR9170_CTRL_LS_BIT;
	fw.usb.int_desc->totalLen = tlen;
	fw.usb.int_desc->dataSize = tlen;

	/* Put to UpQ */
	dma_put(&fw.pta.up_queue, fw.usb.int_desc);

	/* Trigger PTA UP DMA */
	set(AR9170_PTA_REG_UP_DMA_TRIGGER, 1);
	usb_trigger_out();

	return ;

reclaim:
	/* TODO: not sure what to do here */
	fw.usb.int_desc_available = 1;
}

void send_cmd_to_host(const uint8_t len, const uint8_t type,
		      const uint8_t ext, const uint8_t *body)
{
	struct carl9170_cmd *resp;

#ifdef CONFIG_CARL9170FW_DEBUG
	if (unlikely(len > sizeof(resp->data))) {
		DBG("CMD too long:%x %d\n", type, len);
		return ;
	}

	/* Element length must be a multiple of 4. */
	if (unlikely(len & 0x3)) {
		DBG("CMD length not mult. of 4:%x %d\n", type, len);
		return ;
	}
#endif /* CONFIG_CARL9170FW_DEBUG */

	resp = (struct carl9170_cmd *) get_int_buf();
	if (unlikely(resp == NULL)) {
		/* not very helpful for NON UART users */
		DBG("out of msg buffers\n");
		return ;
	}

	resp->hdr.len = len;
	resp->hdr.cmd = type;
	resp->hdr.ext = ext;

	memcpy(resp->data, body, len);
	usb_trigger_in();
}

/* Turn off ADDA/RF power, PLL */
static void turn_power_off(void)
{
	set(AR9170_PHY_REG_ACTIVE, AR9170_PHY_ACTIVE_DIS);
	set(AR9170_PHY_REG_ADC_CTL, 0xa0000000 |
	    AR9170_PHY_ADC_CTL_OFF_PWDADC | AR9170_PHY_ADC_CTL_OFF_PWDDAC);

	/* This will also turn-off the LEDs */
	set(AR9170_GPIO_REG_PORT_DATA, 0);
	set(AR9170_GPIO_REG_PORT_TYPE, 0xf);

	set(AR9170_PWR_REG_BASE, 0x40021);

	set(AR9170_MAC_REG_DMA_TRIGGER, 0);

	andl(AR9170_USB_REG_DMA_CTL, ~(AR9170_USB_DMA_CTL_ENABLE_TO_DEVICE |
				       AR9170_USB_DMA_CTL_ENABLE_FROM_DEVICE |
				       AR9170_USB_DMA_CTL_UP_PACKET_MODE |
				       AR9170_USB_DMA_CTL_DOWN_STREAM));

	/* Do a software reset to PTA component */
	orl(AR9170_PTA_REG_DMA_MODE_CTRL, AR9170_PTA_DMA_MODE_CTRL_RESET);
	andl(AR9170_PTA_REG_DMA_MODE_CTRL, ~AR9170_PTA_DMA_MODE_CTRL_RESET);

	orl(AR9170_PTA_REG_DMA_MODE_CTRL, AR9170_PTA_DMA_MODE_CTRL_DISABLE_USB);

	set(AR9170_MAC_REG_POWER_STATE_CTRL,
	    AR9170_MAC_POWER_STATE_CTRL_RESET);

	/* Reset USB FIFO */
	set(AR9170_PWR_REG_RESET, AR9170_PWR_RESET_COMMIT_RESET_MASK |
				  AR9170_PWR_RESET_DMA_MASK |
				  AR9170_PWR_RESET_WLAN_MASK);
	set(AR9170_PWR_REG_RESET, 0x0);

	clock_set(AHB_20_22MHZ, false);

	set(AR9170_PWR_REG_PLL_ADDAC, 0x5163);	/* 0x502b; */
	set(AR9170_PHY_REG_ADC_SERIAL_CTL, AR9170_PHY_ADC_SCTL_SEL_EXTERNAL_RADIO);
	set(0x1c589c, 0);	/* 7-0 */
	set(0x1c589c, 0);	/* 15-8 */
	set(0x1c589c, 0);	/* 23-16 */
	set(0x1c589c, 0);	/* 31- */
	set(0x1c589c, 0);	/* 39- */
	set(0x1c589c, 0);	/* 47- */
	set(0x1c589c, 0);	/* 55- */
	set(0x1c589c, 0xf8);	/* 63- */
	set(0x1c589c, 0x27);	/* 0x24;	71-	modified */
	set(0x1c589c, 0xf9);	/* 79- */
	set(0x1c589c, 0x90);	/* 87- */
	set(0x1c589c, 0x04);	/* 95- */
	set(0x1c589c, 0x48);	/* 103- */
	set(0x1c589c, 0x19);	/* 0;		111-	modified */
	set(0x1c589c, 0);	/* 119- */
	set(0x1c589c, 0);	/* 127- */
	set(0x1c589c, 0);	/* 135- */
	set(0x1c589c, 0);	/* 143- */
	set(0x1c589c, 0);	/* 151- */
	set(0x1c589c, 0x70);	/* 159- */
	set(0x1c589c, 0x0c);	/* 167- */
	set(0x1c589c, 0);	/* 175- */
	set(0x1c589c, 0);	/* 183-176 */
	set(0x1c589c, 0);	/* 191-184 */
	set(0x1c589c, 0);	/* 199- */
	set(0x1c589c, 0);	/* 207- */
	set(0x1c589c, 0);	/* 215- */
	set(0x1c589c, 0);	/* 223- */
	set(0x1c589c, 0);	/* 231- */
	set(0x1c58c4, 0);	/* 233- 232 */
	set(AR9170_PHY_REG_ADC_SERIAL_CTL, AR9170_PHY_ADC_SCTL_SEL_INTERNAL_ADDAC);
}

static void disable_watchdog(void)
{
	if (!fw.watchdog_enable)
		return;

	/* write watchdog magic pattern for suspend  */
	andl(AR9170_PWR_REG_WATCH_DOG_MAGIC, 0xffff);
	orl(AR9170_PWR_REG_WATCH_DOG_MAGIC, 0x98760000);

	/* Disable watchdog */
	set(AR9170_TIMER_REG_WATCH_DOG, 0xffff);
}

void __noreturn reboot(void)
{
	disable_watchdog();

	/* Turn off power */
	turn_power_off();

	/* clean bootloader workspace */
	memset(&dma_mem, 0, sizeof(dma_mem));

	/* add by ygwei for work around USB PHY chirp sequence problem */
	set(0x10f100, 0x12345678);

	/* Jump to boot code */
	jump_to_bootcode();
}

/* service USB events and re-enable USB interrupt */
static void usb_handler(uint8_t usb_interrupt_level1)
{
	uint8_t usb_interrupt_level2;

	if (usb_interrupt_level1 & BIT(5))
		usb_data_in();

	if (usb_interrupt_level1 & BIT(4))
		usb_reg_out();

	if (usb_interrupt_level1 & BIT(6))
		usb_status_in();

	if (usb_interrupt_level1 & BIT(0)) {
		usb_interrupt_level2 = getb(AR9170_USB_REG_INTR_SOURCE_0);

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC0_SETUP)
			usb_ep0setup();

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC0_IN)
			usb_ep0tx();

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC0_OUT)
			usb_ep0rx();

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC0_ABORT) {
			/* Clear the command abort interrupt */
			andb(AR9170_USB_REG_INTR_SOURCE_0, (uint8_t)
			     ~AR9170_USB_INTR_SRC0_ABORT);
		}

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC0_FAIL ||
		    fw.usb.ep0_action & CARL9170_EP0_STALL) {
			/*
			 * transmission failure.
			 * stall ep 0
			 */
			setb(AR9170_USB_REG_CX_CONFIG_STATUS, BIT(2));
			fw.usb.ep0_action &= ~CARL9170_EP0_STALL;
		}

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC0_END ||
		    fw.usb.ep0_action & CARL9170_EP0_TRIGGER) {
			/*
			 * transmission done.
			 * set DONE bit.
			 */
			setb(AR9170_USB_REG_CX_CONFIG_STATUS, BIT(0));
			fw.usb.ep0_action &= ~CARL9170_EP0_TRIGGER;
		}
	}

	if (usb_interrupt_level1 & BIT(7)) {
		usb_interrupt_level2 = getb(AR9170_USB_REG_INTR_SOURCE_7);

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC7_RX0BYTE)
			usb_data_out0Byte();

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC7_TX0BYTE)
			usb_data_in0Byte();

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC7_USB_RESET) {
			usb_reset_ack();
			reboot();
		}

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC7_USB_SUSPEND) {
			usb_suspend_ack();

			fw.suspend_mode = CARL9170_HOST_SUSPENDED;

#ifdef CONFIG_CARL9170FW_WOL
			if (!(fw.usb.device_feature & USB_DEVICE_REMOTE_WAKEUP) ||
			    !fw.wol.cmd.flags) {
				disable_watchdog();

				/* GO_TO_SUSPEND stops the CPU clock too. */
				orb(AR9170_USB_REG_MAIN_CTRL, AR9170_USB_MAIN_CTRL_GO_TO_SUSPEND);
			} else {
				wol_prepare();
			}
#else /* CONFIG_CARL9170FW_WOL */
			disable_watchdog();

			/* GO_TO_SUSPEND stops the CPU clock too. */
			orb(AR9170_USB_REG_MAIN_CTRL, AR9170_USB_MAIN_CTRL_GO_TO_SUSPEND);
#endif /* CONFIG_CARL9170FW_WOL */
		}

		if (usb_interrupt_level2 & AR9170_USB_INTR_SRC7_USB_RESUME) {
			usb_resume_ack();

			fw.suspend_mode = CARL9170_HOST_AWAKE;
			set(AR9170_USB_REG_WAKE_UP, 0);

			reboot();
		}
	}
}

void handle_usb(void)
{
	uint8_t usb_interrupt_level1;

	usb_interrupt_level1 = getb(AR9170_USB_REG_INTR_GROUP);

	if (usb_interrupt_level1)
		usb_handler(usb_interrupt_level1);

	if (fw.usb.int_pending > 0)
		usb_trigger_in();
}

void usb_timer(void)
{
}