Merge "ARCH: msm: micrel: ks8851: Changes to enable high tput perf"

#include "ks8851.h"

#include <linux/dma-mapping.h>

#define KSZ8851_TX_SPACE (6144 * 3)

#define TX_DMA_BUFFER_SIZE (8192 * 3)

#define RX_DMA_BUFFER_SIZE (2048 * 2)

/**

 * struct ks8851_rxctrl - KS8851 driver rx control

 * @mchash: Multicast hash-table data.

	struct ks8851_rxctrl	rxctrl;

	struct work_struct	tx_work;

	struct work_struct	rx_work;

	struct work_struct	rxctrl_work;

	struct sk_buff_head	txq;

	return rxb[0];

}

/**

 * ks8851_rdreg16 - read 16 bit register from device

 * @ks: The chip information

 * @reg: The register address

 *

 * Read a 16bit register from the chip, returning the result

*/

static unsigned ks8851_rdreg16(struct ks8851_net *ks, unsigned reg)

static unsigned ks8851_32bitrdreg16(struct ks8851_net *ks, unsigned reg)

{

	__le16 rx = 0;

	ks8851_rdreg(ks, MK_OP(reg & 2 ? 0xC : 0x3, reg), (u8 *)&rx, 2);

	return le16_to_cpu(rx);

}

/**

 * ks8851_rdreg32 - read 32 bit register from device

 * @ks: The chip information

 * @reg: The register address

 *

 * Read a 32bit register from the chip.

 *

 * Note, this read requires the address be aligned to 4 bytes.

*/

static unsigned ks8851_rdreg32(struct ks8851_net *ks, unsigned reg)

{

	__le32 rx = 0;

	WARN_ON(reg & 3);

	int ret;

	struct spi_transfer *xfer = &ks->spi_xfer1;

	struct spi_message *msg = &ks->spi_msg1;

	u32 *txd;

	u32 *rxd;

	unsigned op;

	txd = (u32 *)ks->txd;

	rxd = (u32 *)ks->rxd;

	op = MK_OP(reg & 2 ? 0xC : 0x3, reg);

	txd[0] = htonl(0x0000ffff & (op | KS_SPIOP_RD));

	xfer->bits_per_word = 32;

	xfer->tx_buf = txd;

	xfer->rx_buf = rxd;

	xfer->len = 4;

	ret = spi_sync(ks->spidev, msg);

	xfer->bits_per_word = 8;

	if (ret < 0)

		netdev_err(ks->netdev, "read: spi_sync() failed\n");

	ks8851_rdreg(ks, MK_OP(0xf, reg), (u8 *)&rx, 4);

	return le32_to_cpu(rx);

	return htons((u16)rxd[0]);

}

/**

	netif_dbg(ks, hw, ks->netdev, "setting power mode %d\n", pwrmode);

	pmecr = ks8851_rdreg16(ks, KS_PMECR);

	pmecr = ks8851_32bitrdreg16(ks, KS_PMECR);

	pmecr &= ~PMECR_PM_MASK;

	pmecr |= pwrmode;

*/

static int ks8851_write_mac_addr(struct net_device *dev)

{

	struct ks8851_net *ks = netdev_priv(dev);

	struct ks8851_net *ks;

	int i;

	ks = netdev_priv(dev);

	mutex_lock(&ks->lock);

	/*

*/

static void ks8851_read_mac_addr(struct net_device *dev)

{

	struct ks8851_net *ks = netdev_priv(dev);

	struct ks8851_net *ks;

	int i;

	ks = netdev_priv(dev);

	mutex_lock(&ks->lock);

	for (i = 0; i < ETH_ALEN; i++)

 */

static void ks8851_init_mac(struct ks8851_net *ks)

{

	struct net_device *dev = ks->netdev;

	struct net_device *dev;

	dev = ks->netdev;

	/* first, try reading what we've got already */

	if (ks->rc_ccr & CCR_EEPROM) {

		ks8851_read_mac_addr(dev);

 */

static void ks8851_rdfifo(struct ks8851_net *ks, u8 *buff, unsigned len)

{

	struct spi_transfer *xfer = ks->spi_xfer2;

	struct spi_message *msg = &ks->spi_msg2;

	struct spi_transfer *xfer;

	struct spi_message *msg;

	u8 txb[1];

	int ret;

	xfer = ks->spi_xfer2;

	msg = &ks->spi_msg2;

	netif_dbg(ks, rx_status, ks->netdev,

		  "%s: %d@%p\n", __func__, len, buff);

	xfer->len = 1;

	xfer++;

	xfer->bits_per_word = 32;

	xfer->rx_buf = buff;

	xfer->tx_buf = NULL;

	xfer->len = len;

	ret = spi_sync(ks->spidev, msg);

	xfer->bits_per_word = 8;

	if (ret < 0)

		netdev_err(ks->netdev, "%s: spi_sync() failed\n", __func__);

}

static int ks8851_rdfifolen(struct ks8851_net *ks, u16 fc)

{

	int ret;

	u16 count;

	u16 rxfifosize = 0;

	struct spi_transfer *xfer;

	struct spi_message *msg;

	u32 *txd;

	u32 *rxd = kmalloc(4 * fc, GFP_DMA);

	unsigned op;

	if (rxd == NULL)

		return -ENOMEM;

	txd = (u32 *)ks->txd;

	op = MK_OP(KS_RXFHBCR & 2 ? 0xC : 0x3, KS_RXFHBCR);

	txd[0] = htonl(0x0000ffff & (op | KS_SPIOP_RD));

	/*Create new with all the transfers*/

	msg = spi_message_alloc(fc, GFP_DMA);

	if (msg == NULL) {

		kfree(rxd);

		return -ENOMEM;

	}

	/* fill in each transfer */

	count = 0;

	list_for_each_entry(xfer, &msg->transfers, transfer_list) {

		xfer->bits_per_word = 32;

		xfer->tx_buf = txd;

		xfer->rx_buf = &rxd[count];

		xfer->delay_usecs = 0;

		xfer->len = 4;

		xfer->cs_change = ++count == fc ? 0 : 1;

	}

	ret = spi_sync(ks->spidev, msg);

	for (count = 0, rxfifosize = 0; count < fc; count++)

		rxfifosize += ALIGN((htons((u16)rxd[count]) & 0xfff), 4)+4;

	rxfifosize += 4;

	if (ret < 0)

		netdev_err(ks->netdev, "read: spi_sync() failed\n");

	spi_message_free(msg);

	kfree(rxd);

	return rxfifosize;

}

/**

 * ks8851_dbg_dumpkkt - dump initial packet contents to debug

 * @ks: The device state

}

/**

 * ks8851_rx_pkts - receive packets from the host

 * ks8851_rx_pkts3 - receive packets from the host

 * @ks: The device information.

 *

 * This is called from the IRQ work queue when the system detects that there

 * are packets in the receive queue. Find out how many packets there are and

 * read them from the FIFO.

 */

static void ks8851_rx_pkts(struct ks8851_net *ks)

static void ks8851_rx_pkts3(struct ks8851_net *ks)

{

	struct sk_buff *skb;

	unsigned rxfc;

	unsigned rxlen;

	unsigned rxstat;

	u32 rxh;

	u8 *rxpkt;

	struct sk_buff *skb = 0;

	unsigned rxfc = 0, rxfct = 0;

	int rxfifosize = 0;

	unsigned rxlen = 0;

	unsigned rxalign = 0;

	u8 *rxpkt = 0;

	u8 *buf = 0;

	u32 *buf32 = 0;

	u16 rxlen32 = 0;

	u16 index32 = 0;

	/* read in fame count from ks8851 reg*/

	rxfc = ks8851_rdreg8(ks, KS_RXFC);

	rxfct = rxfc;

	netif_dbg(ks, rx_status, ks->netdev,

		  "%s: %d packets\n", __func__, rxfc);

	if (rxfc == 0) {

		pr_debug("ks8851: Frame count is 0 NOP further\n");

		return;

	}

	/* Currently we're issuing a read per packet, but we could possibly

	 * improve the code by issuing a single read, getting the receive

	 * header, allocating the packet and then reading the packet data

	 * out in one go.

	 *

	 * This form of operation would require us to hold the SPI bus'

	 * chipselect low during the entie transaction to avoid any

	 * reset to the data stream coming from the chip.

	 */

	/* tabulate all frame sizes so we can do one read for all frames */

	rxfifosize = ks8851_rdfifolen(ks, rxfc);

	for (; rxfc != 0; rxfc--) {

		rxh = ks8851_rdreg32(ks, KS_RXFHSR);

		rxstat = rxh & 0xffff;

		rxlen = (rxh >> 16) & 0xfff;

	if (rxfifosize < 0) {

		pr_debug("ks8851:Memory not available");

		return;

	}

		netif_dbg(ks, rx_status, ks->netdev,

			  "rx: stat 0x%04x, len 0x%04x\n", rxstat, rxlen);

	/* allocate memory for one fifo read */

	buf = kmalloc(rxfifosize, GFP_DMA);

	if (buf == NULL)

		return;

		/* the length of the packet includes the 32bit CRC */

	buf32 = (u32 *)buf;

	/* set dma read address */

	ks8851_wrreg16(ks, KS_RXFDPR, RXFDPR_RXFPAI | 0x00);

	/* start the packet dma process, and set auto-dequeue rx */

		ks8851_wrreg16(ks, KS_RXQCR,

			       ks->rc_rxqcr | RXQCR_SDA | RXQCR_ADRFE);

	ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr

				   | RXQCR_SDA | RXQCR_ADRFE);

		if (rxlen > 4) {

			unsigned int rxalign;

			rxlen -= 4;

			rxalign = ALIGN(rxlen, 4);

			skb = netdev_alloc_skb_ip_align(ks->netdev, rxalign);

			if (skb) {

	/* read all frames from rx fifo */

	ks8851_rdfifo(ks, buf, rxfifosize);

				/* 4 bytes of status header + 4 bytes of

				 * garbage: we put them before ethernet

				 * header, so that they are copied,

				 * but ignored.

				 */

				rxpkt = skb_put(skb, rxlen) - 8;

	ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);

				ks8851_rdfifo(ks, rxpkt, rxalign + 8);

	/* parse frames */

	for (index32 = 1; rxfc > 0; rxfc--) {

		/* Get packet data length and pointer to packet data */

		rxlen = (htonl(buf32[index32]) >> 16) & 0xfff;

		index32++;

		rxalign = ALIGN(rxlen-4, 4);

		rxlen32 = ALIGN(rxlen, 4)/4;

		rxpkt = (u8 *)&buf32[index32];

		/* swap bytes to make the correct order */

		for (; rxlen32 > 0; rxlen32--, index32++)

			buf32[index32] = htonl(buf32[index32]);

		/* send packet on its way */

		skb = netdev_alloc_skb_ip_align(ks->netdev, rxalign);

		skb_add_data(skb, rxpkt, rxalign);

		if (netif_msg_pktdata(ks))

			ks8851_dbg_dumpkkt(ks, rxpkt);

		skb->protocol = eth_type_trans(skb, ks->netdev);

		netif_rx_ni(skb);

		/* record packet stats */

		ks->netdev->stats.rx_packets++;

		ks->netdev->stats.rx_bytes += rxlen;

	}

		}

		ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);

	}

	kfree(buf);

}

/**

	mutex_lock(&ks->lock);

	status = ks8851_rdreg16(ks, KS_ISR);

	status = ks8851_32bitrdreg16(ks, KS_ISR);

	netif_dbg(ks, intr, ks->netdev,

		  "%s: status 0x%04x\n", __func__, status);

		handled |= IRQ_LCI;

	if (status & IRQ_LDI) {

		u16 pmecr = ks8851_rdreg16(ks, KS_PMECR);

		u16 pmecr = ks8851_32bitrdreg16(ks, KS_PMECR);

		pmecr &= ~PMECR_WKEVT_MASK;

		ks8851_wrreg16(ks, KS_PMECR, pmecr | PMECR_WKEVT_LINK);

		/* update our idea of how much tx space is available to the

		 * system */

		ks->tx_space = ks8851_rdreg16(ks, KS_TXMIR);

		ks->tx_space = KSZ8851_TX_SPACE;

		netif_dbg(ks, intr, ks->netdev,

			  "%s: txspace %d\n", __func__, ks->tx_space);

		/* TX FIFO is empty */

		netif_wake_queue(ks->netdev);

	}

	if (status & IRQ_RXI)

	if (status & IRQ_RXI) {

		handled |= IRQ_RXI;

	}

	if (status & IRQ_SPIBEI) {

		dev_err(&ks->spidev->dev, "%s: spi bus error\n", __func__);

		 * packet read-out, however we're masking the interrupt

		 * from the device so do not bother masking just the RX

		 * from the device. */

		ks8851_rx_pkts(ks);

		schedule_work(&ks->rx_work);

	}

	/* if something stopped the rx process, probably due to wanting

	if (status & IRQ_LCI)

		mii_check_link(&ks->mii);

	if (status & IRQ_TXI)

		netif_wake_queue(ks->netdev);

	return IRQ_HANDLED;

}

 */

static inline unsigned calc_txlen(unsigned len)

{

	return ALIGN(len + 4, 4);

	return 4+ALIGN(len, 4);

}

/**

 * ks8851_wrpkt - write packet to TX FIFO

 * @ks: The device state.

 * @txp: The sk_buff to transmit.

 * @irq: IRQ on completion of the packet.

 * ks8851_wrpkts3 - write packets to TX FIFO

 *

 * Send the @txp to the chip. This means creating the relevant packet header

 * specifying the length of the packet and the other information the chip

 * needs, such as IRQ on completion. Send the header and the packet data to

 * the device.

 */

static void ks8851_wrpkt(struct ks8851_net *ks, struct sk_buff *txp, bool irq)

static void ks8851_wrpkts3(struct ks8851_net *ks)

{

	struct spi_transfer *xfer = ks->spi_xfer2;

	struct spi_message *msg = &ks->spi_msg2;

	unsigned fid = 0;

	int ret;

	netif_dbg(ks, tx_queued, ks->netdev, "%s: skb %p, %d@%p, irq %d\n",

		  __func__, txp, txp->len, txp->data, irq);

	fid = ks->fid++;

	fid &= TXFR_TXFID_MASK;

	if (irq)

		fid |= TXFR_TXIC;	/* irq on completion */

	/* start header at txb[1] to align txw entries */

	ks->txh.txb[1] = KS_SPIOP_TXFIFO;

	ks->txh.txw[1] = cpu_to_le16(fid);

	ks->txh.txw[2] = cpu_to_le16(txp->len);

	struct net_device *dev = ks->netdev;

	struct sk_buff *txb;

	u8 *buf = NULL;

	u16 len = 0;

	u8 count = 0;

	u8 opc[1];

	u16 cpy;

	u16 index = 0;

	u16 len32;

	u32 *buf32;

	bool last;

	xfer->tx_buf = &ks->txh.txb[1];

	last = skb_queue_empty(&ks->txq);

	opc[0] = KS_SPIOP_TXFIFO;

	xfer->tx_buf = opc;

	xfer->len = 1;

	xfer->rx_buf = NULL;

	xfer->len = 5;

	xfer->bits_per_word = 8;

	xfer->cs_change = 0;

	xfer++;

	xfer->tx_buf = txp->data;

	xfer->rx_buf = NULL;

	xfer->len = ALIGN(txp->len, 4);

	xfer->bits_per_word = 32;

	xfer->cs_change = 0;

	xfer->tx_buf = kmalloc(TX_DMA_BUFFER_SIZE, GFP_DMA);

	buf = (u8 *)xfer->tx_buf;

	buf32 = (u32 *)xfer->tx_buf;

	if (buf == NULL) {

		pr_debug("ks8851:memory alloc fail for tx buffer");

		return;

	}

	len = 0;

	len32 = 0;

	for (count = 0; !last && len < 6144; count++) {

		txb = skb_dequeue(&ks->txq);

		last = skb_queue_empty(&ks->txq);

		if (txb != NULL) {

			fid = ks->fid++;

			fid &= TXFR_TXFID_MASK;

			if (last || len >= 6144)

				fid |= TXFR_TXIC;

			buf32[len32] = htonl(cpu_to_le16(txb->len) << 16

						   | cpu_to_le16(fid));

			len32++;

			for (cpy = ALIGN(txb->len, 4)/4, index = 0;

					index < cpy; index++, len32++)

				buf32[len32] = htonl(((u32 *)txb->data)[index]);

			len += 4+ALIGN(txb->len, 4);

			dev->stats.tx_bytes += txb->len;

			dev->stats.tx_packets++;

			dev_kfree_skb(txb);

		}

	}

	xfer->len = len;

	if (len > 0)

		ret = spi_sync(ks->spidev, msg);

	xfer->bits_per_word = 8;

	if (ret < 0)

		netdev_err(ks->netdev, "%s: spi_sync() failed\n", __func__);

	kfree(xfer->tx_buf);

	xfer->tx_buf = NULL;

}

/**

 * ks8851_done_tx - update and then free skbuff after transmitting

 * @ks: The device state

 * @txb: The buffer transmitted

 */

static void ks8851_done_tx(struct ks8851_net *ks, struct sk_buff *txb)

static void ks8851_rx_work(struct work_struct *work)

{

	struct net_device *dev = ks->netdev;

	struct ks8851_net *ks = container_of(work, struct ks8851_net, rx_work);

	dev->stats.tx_bytes += txb->len;

	dev->stats.tx_packets++;

	dev_kfree_skb(txb);

	mutex_lock(&ks->lock);

	ks8851_rx_pkts3(ks);

	mutex_unlock(&ks->lock);

}

/**

 * ks8851_tx_work - process tx packet(s)

 * @work: The work strucutre what was scheduled.

static void ks8851_tx_work(struct work_struct *work)

{

	struct ks8851_net *ks = container_of(work, struct ks8851_net, tx_work);

	struct sk_buff *txb;

	bool last = skb_queue_empty(&ks->txq);

	bool last;

	mutex_lock(&ks->lock);

	while (!last) {

		txb = skb_dequeue(&ks->txq);

	last = skb_queue_empty(&ks->txq);

		if (txb != NULL) {

	if (!last) {

		ks8851_wrreg16(ks, KS_TXQCR, TXQCR_AETFE);

		ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr | RXQCR_SDA);

			ks8851_wrpkt(ks, txb, last);

			ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);

			ks8851_wrreg16(ks, KS_TXQCR, TXQCR_METFE);

			ks8851_done_tx(ks, txb);

		/* write packets to the queue once, and raise interrupt */

		while (!last) {

			ks8851_wrpkts3(ks);

			last = skb_queue_empty(&ks->txq);

		}

		ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);

	}

	mutex_unlock(&ks->lock);

}

	ks8851_wrreg16(ks, KS_RXQCR, ks->rc_rxqcr);

	/* Set watermarks for proper flow control. */

	ks8851_wrreg16(ks, KS_FCLWR, 0x800);

	ks8851_wrreg16(ks, KS_FCHWR, 0x400);

	/* clear then enable interrupts */

#define STD_IRQ (IRQ_LCI |	/* Link Change */	\

static netdev_tx_t ks8851_start_xmit(struct sk_buff *skb,

				     struct net_device *dev)

{

	struct ks8851_net *ks = netdev_priv(dev);

	unsigned needed = calc_txlen(skb->len);

	struct ks8851_net *ks;

	unsigned needed;

	netdev_tx_t ret = NETDEV_TX_OK;

	ks = netdev_priv(dev);

	needed = calc_txlen(skb->len);

	netif_dbg(ks, tx_queued, ks->netdev,

		  "%s: skb %p, %d@%p\n", __func__, skb, skb->len, skb->data);

	spin_lock(&ks->statelock);

	if (needed > ks->tx_space) {

		netif_stop_queue(dev);

		ret = NETDEV_TX_BUSY;

		netif_stop_queue(dev);

	} else {

		ks->tx_space -= needed;

		skb_queue_tail(&ks->txq, skb);

	}

	spin_unlock(&ks->statelock);

	schedule_work(&ks->tx_work);