[mirror_ubuntu-bionic-kernel.git] / drivers / net / irda / bfin_sir.c

/*
 * Blackfin Infra-red Driver
 *
 * Copyright 2006-2009 Analog Devices Inc.
 *
 * Enter bugs at http://blackfin.uclinux.org/
 *
 * Licensed under the GPL-2 or later.
 *
 */
#include "bfin_sir.h"

#ifdef CONFIG_SIR_BFIN_DMA
#define DMA_SIR_RX_XCNT        10
#define DMA_SIR_RX_YCNT        (PAGE_SIZE / DMA_SIR_RX_XCNT)
#define DMA_SIR_RX_FLUSH_JIFS  (HZ * 4 / 250)
#endif

#if ANOMALY_05000447
static int max_rate = 57600;
#else
static int max_rate = 115200;
#endif

static void turnaround_delay(unsigned long last_jif, int mtt)
{
	long ticks;

	mtt = mtt < 10000 ? 10000 : mtt;
	ticks = 1 + mtt / (USEC_PER_SEC / HZ);
	schedule_timeout_uninterruptible(ticks);
}

static void __devinit bfin_sir_init_ports(struct bfin_sir_port *sp, struct platform_device *pdev)
{
	int i;
	struct resource *res;

	for (i = 0; i < pdev->num_resources; i++) {
		res = &pdev->resource[i];
		switch (res->flags) {
		case IORESOURCE_MEM:
			sp->membase   = (void __iomem *)res->start;
			break;
		case IORESOURCE_IRQ:
			sp->irq = res->start;
			break;
		case IORESOURCE_DMA:
			sp->rx_dma_channel = res->start;
			sp->tx_dma_channel = res->end;
			break;
		default:
			break;
		}
	}

	sp->clk = get_sclk();
#ifdef CONFIG_SIR_BFIN_DMA
	sp->tx_done        = 1;
	init_timer(&(sp->rx_dma_timer));
#endif
}

static void bfin_sir_stop_tx(struct bfin_sir_port *port)
{
#ifdef CONFIG_SIR_BFIN_DMA
	disable_dma(port->tx_dma_channel);
#endif

	while (!(SIR_UART_GET_LSR(port) & THRE)) {
		cpu_relax();
		continue;
	}

	SIR_UART_STOP_TX(port);
}

static void bfin_sir_enable_tx(struct bfin_sir_port *port)
{
	SIR_UART_ENABLE_TX(port);
}

static void bfin_sir_stop_rx(struct bfin_sir_port *port)
{
	SIR_UART_STOP_RX(port);
}

static void bfin_sir_enable_rx(struct bfin_sir_port *port)
{
	SIR_UART_ENABLE_RX(port);
}

static int bfin_sir_set_speed(struct bfin_sir_port *port, int speed)
{
	int ret = -EINVAL;
	unsigned int quot;
	unsigned short val, lsr, lcr;
	static int utime;
	int count = 10;

	lcr = WLS(8);

	switch (speed) {
	case 9600:
	case 19200:
	case 38400:
	case 57600:
	case 115200:

		quot = (port->clk + (8 * speed)) / (16 * speed)\
						- ANOMALY_05000230;

		do {
			udelay(utime);
			lsr = SIR_UART_GET_LSR(port);
		} while (!(lsr & TEMT) && count--);

		/* The useconds for 1 bits to transmit */
		utime = 1000000 / speed + 1;

		/* Clear UCEN bit to reset the UART state machine
		 * and control registers
		 */
		val = SIR_UART_GET_GCTL(port);
		val &= ~UCEN;
		SIR_UART_PUT_GCTL(port, val);

		/* Set DLAB in LCR to Access THR RBR IER */
		SIR_UART_SET_DLAB(port);
		SSYNC();

		SIR_UART_PUT_DLL(port, quot & 0xFF);
		SIR_UART_PUT_DLH(port, (quot >> 8) & 0xFF);
		SSYNC();

		/* Clear DLAB in LCR */
		SIR_UART_CLEAR_DLAB(port);
		SSYNC();

		SIR_UART_PUT_LCR(port, lcr);

		val = SIR_UART_GET_GCTL(port);
		val |= UCEN;
		SIR_UART_PUT_GCTL(port, val);

		ret = 0;
		break;
	default:
		printk(KERN_WARNING "bfin_sir: Invalid speed %d\n", speed);
		break;
	}

	val = SIR_UART_GET_GCTL(port);
	/* If not add the 'RPOLC', we can't catch the receive interrupt.
	 * It's related with the HW layout and the IR transiver.
	 */
	val |= IREN | RPOLC;
	SIR_UART_PUT_GCTL(port, val);
	return ret;
}

static int bfin_sir_is_receiving(struct net_device *dev)
{
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;

	if (!(SIR_UART_GET_IER(port) & ERBFI))
		return 0;
	return self->rx_buff.state != OUTSIDE_FRAME;
}

#ifdef CONFIG_SIR_BFIN_PIO
static void bfin_sir_tx_chars(struct net_device *dev)
{
	unsigned int chr;
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;

	if (self->tx_buff.len != 0) {
		chr = *(self->tx_buff.data);
		SIR_UART_PUT_CHAR(port, chr);
		self->tx_buff.data++;
		self->tx_buff.len--;
	} else {
		self->stats.tx_packets++;
		self->stats.tx_bytes += self->tx_buff.data - self->tx_buff.head;
		if (self->newspeed) {
			bfin_sir_set_speed(port, self->newspeed);
			self->speed = self->newspeed;
			self->newspeed = 0;
		}
		bfin_sir_stop_tx(port);
		bfin_sir_enable_rx(port);
		/* I'm hungry! */
		netif_wake_queue(dev);
	}
}

static void bfin_sir_rx_chars(struct net_device *dev)
{
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;
	unsigned char ch;

	SIR_UART_CLEAR_LSR(port);
	ch = SIR_UART_GET_CHAR(port);
	async_unwrap_char(dev, &self->stats, &self->rx_buff, ch);
	dev->last_rx = jiffies;
}

static irqreturn_t bfin_sir_rx_int(int irq, void *dev_id)
{
	struct net_device *dev = dev_id;
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;

	spin_lock(&self->lock);
	while ((SIR_UART_GET_LSR(port) & DR))
		bfin_sir_rx_chars(dev);
	spin_unlock(&self->lock);

	return IRQ_HANDLED;
}

static irqreturn_t bfin_sir_tx_int(int irq, void *dev_id)
{
	struct net_device *dev = dev_id;
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;

	spin_lock(&self->lock);
	if (SIR_UART_GET_LSR(port) & THRE)
		bfin_sir_tx_chars(dev);
	spin_unlock(&self->lock);

	return IRQ_HANDLED;
}
#endif /* CONFIG_SIR_BFIN_PIO */

#ifdef CONFIG_SIR_BFIN_DMA
static void bfin_sir_dma_tx_chars(struct net_device *dev)
{
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;

	if (!port->tx_done)
		return;
	port->tx_done = 0;

	if (self->tx_buff.len == 0) {
		self->stats.tx_packets++;
		if (self->newspeed) {
			bfin_sir_set_speed(port, self->newspeed);
			self->speed = self->newspeed;
			self->newspeed = 0;
		}
		bfin_sir_enable_rx(port);
		port->tx_done = 1;
		netif_wake_queue(dev);
		return;
	}

	blackfin_dcache_flush_range((unsigned long)(self->tx_buff.data),
		(unsigned long)(self->tx_buff.data+self->tx_buff.len));
	set_dma_config(port->tx_dma_channel,
		set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP,
			INTR_ON_BUF, DIMENSION_LINEAR, DATA_SIZE_8,
			DMA_SYNC_RESTART));
	set_dma_start_addr(port->tx_dma_channel,
		(unsigned long)(self->tx_buff.data));
	set_dma_x_count(port->tx_dma_channel, self->tx_buff.len);
	set_dma_x_modify(port->tx_dma_channel, 1);
	enable_dma(port->tx_dma_channel);
}

static irqreturn_t bfin_sir_dma_tx_int(int irq, void *dev_id)
{
	struct net_device *dev = dev_id;
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;

	spin_lock(&self->lock);
	if (!(get_dma_curr_irqstat(port->tx_dma_channel) & DMA_RUN)) {
		clear_dma_irqstat(port->tx_dma_channel);
		bfin_sir_stop_tx(port);

		self->stats.tx_packets++;
		self->stats.tx_bytes += self->tx_buff.len;
		self->tx_buff.len = 0;
		if (self->newspeed) {
			bfin_sir_set_speed(port, self->newspeed);
			self->speed = self->newspeed;
			self->newspeed = 0;
		}
		bfin_sir_enable_rx(port);
		/* I'm hungry! */
		netif_wake_queue(dev);
		port->tx_done = 1;
	}
	spin_unlock(&self->lock);

	return IRQ_HANDLED;
}

static void bfin_sir_dma_rx_chars(struct net_device *dev)
{
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;
	int i;

	SIR_UART_CLEAR_LSR(port);

	for (i = port->rx_dma_buf.head; i < port->rx_dma_buf.tail; i++)
		async_unwrap_char(dev, &self->stats, &self->rx_buff, port->rx_dma_buf.buf[i]);
}

void bfin_sir_rx_dma_timeout(struct net_device *dev)
{
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;
	int x_pos, pos;
	unsigned long flags;

	spin_lock_irqsave(&self->lock, flags);
	x_pos = DMA_SIR_RX_XCNT - get_dma_curr_xcount(port->rx_dma_channel);
	if (x_pos == DMA_SIR_RX_XCNT)
		x_pos = 0;

	pos = port->rx_dma_nrows * DMA_SIR_RX_XCNT + x_pos;

	if (pos > port->rx_dma_buf.tail) {
		port->rx_dma_buf.tail = pos;
		bfin_sir_dma_rx_chars(dev);
		port->rx_dma_buf.head = port->rx_dma_buf.tail;
	}
	spin_unlock_irqrestore(&self->lock, flags);
}

static irqreturn_t bfin_sir_dma_rx_int(int irq, void *dev_id)
{
	struct net_device *dev = dev_id;
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;
	unsigned short irqstat;

	spin_lock(&self->lock);

	port->rx_dma_nrows++;
	port->rx_dma_buf.tail = DMA_SIR_RX_XCNT * port->rx_dma_nrows;
	bfin_sir_dma_rx_chars(dev);
	if (port->rx_dma_nrows >= DMA_SIR_RX_YCNT) {
		port->rx_dma_nrows = 0;
		port->rx_dma_buf.tail = 0;
	}
	port->rx_dma_buf.head = port->rx_dma_buf.tail;

	irqstat = get_dma_curr_irqstat(port->rx_dma_channel);
	clear_dma_irqstat(port->rx_dma_channel);
	spin_unlock(&self->lock);

	mod_timer(&port->rx_dma_timer, jiffies + DMA_SIR_RX_FLUSH_JIFS);
	return IRQ_HANDLED;
}
#endif /* CONFIG_SIR_BFIN_DMA */

static int bfin_sir_startup(struct bfin_sir_port *port, struct net_device *dev)
{
#ifdef CONFIG_SIR_BFIN_DMA
	dma_addr_t dma_handle;
#endif /* CONFIG_SIR_BFIN_DMA */

	if (request_dma(port->rx_dma_channel, "BFIN_UART_RX") < 0) {
		dev_warn(&dev->dev, "Unable to attach SIR RX DMA channel\n");
		return -EBUSY;
	}

	if (request_dma(port->tx_dma_channel, "BFIN_UART_TX") < 0) {
		dev_warn(&dev->dev, "Unable to attach SIR TX DMA channel\n");
		free_dma(port->rx_dma_channel);
		return -EBUSY;
	}

#ifdef CONFIG_SIR_BFIN_DMA

	set_dma_callback(port->rx_dma_channel, bfin_sir_dma_rx_int, dev);
	set_dma_callback(port->tx_dma_channel, bfin_sir_dma_tx_int, dev);

	port->rx_dma_buf.buf = (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE, &dma_handle, GFP_DMA);
	port->rx_dma_buf.head = 0;
	port->rx_dma_buf.tail = 0;
	port->rx_dma_nrows = 0;

	set_dma_config(port->rx_dma_channel,
				set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO,
									INTR_ON_ROW, DIMENSION_2D,
									DATA_SIZE_8, DMA_SYNC_RESTART));
	set_dma_x_count(port->rx_dma_channel, DMA_SIR_RX_XCNT);
	set_dma_x_modify(port->rx_dma_channel, 1);
	set_dma_y_count(port->rx_dma_channel, DMA_SIR_RX_YCNT);
	set_dma_y_modify(port->rx_dma_channel, 1);
	set_dma_start_addr(port->rx_dma_channel, (unsigned long)port->rx_dma_buf.buf);
	enable_dma(port->rx_dma_channel);

	port->rx_dma_timer.data = (unsigned long)(dev);
	port->rx_dma_timer.function = (void *)bfin_sir_rx_dma_timeout;

#else

	if (request_irq(port->irq, bfin_sir_rx_int, IRQF_DISABLED, "BFIN_SIR_RX", dev)) {
		dev_warn(&dev->dev, "Unable to attach SIR RX interrupt\n");
		return -EBUSY;
	}

	if (request_irq(port->irq+1, bfin_sir_tx_int, IRQF_DISABLED, "BFIN_SIR_TX", dev)) {
		dev_warn(&dev->dev, "Unable to attach SIR TX interrupt\n");
		free_irq(port->irq, dev);
		return -EBUSY;
	}
#endif

	return 0;
}

static void bfin_sir_shutdown(struct bfin_sir_port *port, struct net_device *dev)
{
	unsigned short val;

	bfin_sir_stop_rx(port);
	SIR_UART_DISABLE_INTS(port);

	val = SIR_UART_GET_GCTL(port);
	val &= ~(UCEN | IREN | RPOLC);
	SIR_UART_PUT_GCTL(port, val);

#ifdef CONFIG_SIR_BFIN_DMA
	disable_dma(port->tx_dma_channel);
	disable_dma(port->rx_dma_channel);
	del_timer(&(port->rx_dma_timer));
	dma_free_coherent(NULL, PAGE_SIZE, port->rx_dma_buf.buf, 0);
#else
	free_irq(port->irq+1, dev);
	free_irq(port->irq, dev);
#endif
	free_dma(port->tx_dma_channel);
	free_dma(port->rx_dma_channel);
}

#ifdef CONFIG_PM
static int bfin_sir_suspend(struct platform_device *pdev, pm_message_t state)
{
	struct bfin_sir_port *sir_port;
	struct net_device *dev;
	struct bfin_sir_self *self;

	sir_port = platform_get_drvdata(pdev);
	if (!sir_port)
		return 0;

	dev = sir_port->dev;
	self = netdev_priv(dev);
	if (self->open) {
		flush_work(&self->work);
		bfin_sir_shutdown(self->sir_port, dev);
		netif_device_detach(dev);
	}

	return 0;
}
static int bfin_sir_resume(struct platform_device *pdev)
{
	struct bfin_sir_port *sir_port;
	struct net_device *dev;
	struct bfin_sir_self *self;
	struct bfin_sir_port *port;

	sir_port = platform_get_drvdata(pdev);
	if (!sir_port)
		return 0;

	dev = sir_port->dev;
	self = netdev_priv(dev);
	port = self->sir_port;
	if (self->open) {
		if (self->newspeed) {
			self->speed = self->newspeed;
			self->newspeed = 0;
		}
		bfin_sir_startup(port, dev);
		bfin_sir_set_speed(port, 9600);
		bfin_sir_enable_rx(port);
		netif_device_attach(dev);
	}
	return 0;
}
#else
#define bfin_sir_suspend   NULL
#define bfin_sir_resume    NULL
#endif

static void bfin_sir_send_work(struct work_struct *work)
{
	struct bfin_sir_self  *self = container_of(work, struct bfin_sir_self, work);
	struct net_device *dev = self->sir_port->dev;
	struct bfin_sir_port *port = self->sir_port;
	unsigned short val;
	int tx_cnt = 10;

	while (bfin_sir_is_receiving(dev) && --tx_cnt)
		turnaround_delay(dev->last_rx, self->mtt);

	bfin_sir_stop_rx(port);

	/* To avoid losting RX interrupt, we reset IR function before
	 * sending data. We also can set the speed, which will
	 * reset all the UART.
	 */
	val = SIR_UART_GET_GCTL(port);
	val &= ~(IREN | RPOLC);
	SIR_UART_PUT_GCTL(port, val);
	SSYNC();
	val |= IREN | RPOLC;
	SIR_UART_PUT_GCTL(port, val);
	SSYNC();
	/* bfin_sir_set_speed(port, self->speed); */

#ifdef CONFIG_SIR_BFIN_DMA
	bfin_sir_dma_tx_chars(dev);
#endif
	bfin_sir_enable_tx(port);
	dev->trans_start = jiffies;
}

static int bfin_sir_hard_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct bfin_sir_self *self = netdev_priv(dev);
	int speed = irda_get_next_speed(skb);

	netif_stop_queue(dev);

	self->mtt = irda_get_mtt(skb);

	if (speed != self->speed && speed != -1)
		self->newspeed = speed;

	self->tx_buff.data = self->tx_buff.head;
	if (skb->len == 0)
		self->tx_buff.len = 0;
	else
		self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, self->tx_buff.truesize);

	schedule_work(&self->work);
	dev_kfree_skb(skb);

	return 0;
}

static int bfin_sir_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)
{
	struct if_irda_req *rq = (struct if_irda_req *)ifreq;
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;
	int ret = 0;

	switch (cmd) {
	case SIOCSBANDWIDTH:
		if (capable(CAP_NET_ADMIN)) {
			if (self->open) {
				ret = bfin_sir_set_speed(port, rq->ifr_baudrate);
				bfin_sir_enable_rx(port);
			} else {
				dev_warn(&dev->dev, "SIOCSBANDWIDTH: !netif_running\n");
				ret = 0;
			}
		}
		break;

	case SIOCSMEDIABUSY:
		ret = -EPERM;
		if (capable(CAP_NET_ADMIN)) {
			irda_device_set_media_busy(dev, TRUE);
			ret = 0;
		}
		break;

	case SIOCGRECEIVING:
		rq->ifr_receiving = bfin_sir_is_receiving(dev);
		break;

	default:
		ret = -EOPNOTSUPP;
		break;
	}

	return ret;
}

static struct net_device_stats *bfin_sir_stats(struct net_device *dev)
{
	struct bfin_sir_self *self = netdev_priv(dev);

	return &self->stats;
}

static int bfin_sir_open(struct net_device *dev)
{
	struct bfin_sir_self *self = netdev_priv(dev);
	struct bfin_sir_port *port = self->sir_port;
	int err = -ENOMEM;

	self->newspeed = 0;
	self->speed = 9600;

	spin_lock_init(&self->lock);

	err = bfin_sir_startup(port, dev);
	if (err)
		goto err_startup;

	bfin_sir_set_speed(port, 9600);

	self->irlap = irlap_open(dev, &self->qos, DRIVER_NAME);
	if (!self->irlap)
		goto err_irlap;

	INIT_WORK(&self->work, bfin_sir_send_work);

	/*
	 * Now enable the interrupt then start the queue
	 */
	self->open = 1;
	bfin_sir_enable_rx(port);

	netif_start_queue(dev);

	return 0;

err_irlap:
	self->open = 0;
	bfin_sir_shutdown(port, dev);
err_startup:
	return err;
}

static int bfin_sir_stop(struct net_device *dev)
{
	struct bfin_sir_self *self = netdev_priv(dev);

	flush_work(&self->work);
	bfin_sir_shutdown(self->sir_port, dev);

	if (self->rxskb) {
		dev_kfree_skb(self->rxskb);
		self->rxskb = NULL;
	}

	/* Stop IrLAP */
	if (self->irlap) {
		irlap_close(self->irlap);
		self->irlap = NULL;
	}

	netif_stop_queue(dev);
	self->open = 0;

	return 0;
}

static int bfin_sir_init_iobuf(iobuff_t *io, int size)
{
	io->head = kmalloc(size, GFP_KERNEL);
	if (!io->head)
		return -ENOMEM;
	io->truesize = size;
	io->in_frame = FALSE;
	io->state    = OUTSIDE_FRAME;
	io->data     = io->head;
	return 0;
}

static const struct net_device_ops bfin_sir_ndo = {
	.ndo_open		= bfin_sir_open,
	.ndo_stop		= bfin_sir_stop,
	.ndo_start_xmit		= bfin_sir_hard_xmit,
	.ndo_do_ioctl		= bfin_sir_ioctl,
	.ndo_get_stats		= bfin_sir_stats,
};

static int __devinit bfin_sir_probe(struct platform_device *pdev)
{
	struct net_device *dev;
	struct bfin_sir_self *self;
	unsigned int baudrate_mask;
	struct bfin_sir_port *sir_port;
	int err;

	if (pdev->id >= 0 && pdev->id < ARRAY_SIZE(per) && \
				per[pdev->id][3] == pdev->id) {
		err = peripheral_request_list(per[pdev->id], DRIVER_NAME);
		if (err)
			return err;
	} else {
		dev_err(&pdev->dev, "Invalid pdev id, please check board file\n");
		return -ENODEV;
	}

	err = -ENOMEM;
	sir_port = kmalloc(sizeof(*sir_port), GFP_KERNEL);
	if (!sir_port)
		goto err_mem_0;

	bfin_sir_init_ports(sir_port, pdev);

	dev = alloc_irdadev(sizeof(*self));
	if (!dev)
		goto err_mem_1;

	self = netdev_priv(dev);
	self->dev = &pdev->dev;
	self->sir_port = sir_port;
	sir_port->dev = dev;

	err = bfin_sir_init_iobuf(&self->rx_buff, IRDA_SKB_MAX_MTU);
	if (err)
		goto err_mem_2;
	err = bfin_sir_init_iobuf(&self->tx_buff, IRDA_SIR_MAX_FRAME);
	if (err)
		goto err_mem_3;

	dev->netdev_ops = &bfin_sir_ndo;
	dev->irq = sir_port->irq;

	irda_init_max_qos_capabilies(&self->qos);

	baudrate_mask = IR_9600;

	switch (max_rate) {
	case 115200:
		baudrate_mask |= IR_115200;
	case 57600:
		baudrate_mask |= IR_57600;
	case 38400:
		baudrate_mask |= IR_38400;
	case 19200:
		baudrate_mask |= IR_19200;
	case 9600:
		break;
	default:
		dev_warn(&pdev->dev, "Invalid maximum baud rate, using 9600\n");
	}

	self->qos.baud_rate.bits &= baudrate_mask;

	self->qos.min_turn_time.bits = 1; /* 10 ms or more */

	irda_qos_bits_to_value(&self->qos);

	err = register_netdev(dev);

	if (err) {
		kfree(self->tx_buff.head);
err_mem_3:
		kfree(self->rx_buff.head);
err_mem_2:
		free_netdev(dev);
err_mem_1:
		kfree(sir_port);
err_mem_0:
		peripheral_free_list(per[pdev->id]);
	} else
		platform_set_drvdata(pdev, sir_port);

	return err;
}

static int __devexit bfin_sir_remove(struct platform_device *pdev)
{
	struct bfin_sir_port *sir_port;
	struct net_device *dev = NULL;
	struct bfin_sir_self *self;

	sir_port = platform_get_drvdata(pdev);
	if (!sir_port)
		return 0;
	dev = sir_port->dev;
	self = netdev_priv(dev);
	unregister_netdev(dev);
	kfree(self->tx_buff.head);
	kfree(self->rx_buff.head);
	free_netdev(dev);
	kfree(sir_port);
	platform_set_drvdata(pdev, NULL);

	return 0;
}

static struct platform_driver bfin_ir_driver = {
	.probe   = bfin_sir_probe,
	.remove  = __devexit_p(bfin_sir_remove),
	.suspend = bfin_sir_suspend,
	.resume  = bfin_sir_resume,
	.driver  = {
		.name = DRIVER_NAME,
	},
};

static int __init bfin_sir_init(void)
{
	return platform_driver_register(&bfin_ir_driver);
}

static void __exit bfin_sir_exit(void)
{
	platform_driver_unregister(&bfin_ir_driver);
}

module_init(bfin_sir_init);
module_exit(bfin_sir_exit);

module_param(max_rate, int, 0);
MODULE_PARM_DESC(max_rate, "Maximum baud rate (115200, 57600, 38400, 19200, 9600)");

MODULE_AUTHOR("Graf Yang <graf.yang@analog.com>");
MODULE_DESCRIPTION("Blackfin IrDA driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
d510fe70 GY	1	/*
	2	* Blackfin Infra-red Driver
	3	*
	4	* Copyright 2006-2009 Analog Devices Inc.
	5	*
	6	* Enter bugs at http://blackfin.uclinux.org/
	7	*
	8	* Licensed under the GPL-2 or later.
	9	*
	10	*/
	11	#include "bfin_sir.h"
	12
	13	#ifdef CONFIG_SIR_BFIN_DMA
	14	#define DMA_SIR_RX_XCNT 10
	15	#define DMA_SIR_RX_YCNT (PAGE_SIZE / DMA_SIR_RX_XCNT)
	16	#define DMA_SIR_RX_FLUSH_JIFS (HZ * 4 / 250)
	17	#endif
	18
	19	#if ANOMALY_05000447
	20	static int max_rate = 57600;
	21	#else
	22	static int max_rate = 115200;
	23	#endif
	24
	25	static void turnaround_delay(unsigned long last_jif, int mtt)
	26	{
	27	long ticks;
	28
	29	mtt = mtt < 10000 ? 10000 : mtt;
	30	ticks = 1 + mtt / (USEC_PER_SEC / HZ);
	31	schedule_timeout_uninterruptible(ticks);
	32	}
	33
	34	static void __devinit bfin_sir_init_ports(struct bfin_sir_port sp, struct platform_device pdev)
	35	{
	36	int i;
	37	struct resource *res;
	38
	39	for (i = 0; i < pdev->num_resources; i++) {
	40	res = &pdev->resource[i];
	41	switch (res->flags) {
	42	case IORESOURCE_MEM:
	43	sp->membase = (void __iomem *)res->start;
	44	break;
	45	case IORESOURCE_IRQ:
	46	sp->irq = res->start;
	47	break;
	48	case IORESOURCE_DMA:
	49	sp->rx_dma_channel = res->start;
	50	sp->tx_dma_channel = res->end;
	51	break;
	52	default:
	53	break;
	54	}
	55	}
	56
	57	sp->clk = get_sclk();
	58	#ifdef CONFIG_SIR_BFIN_DMA
	59	sp->tx_done = 1;
	60	init_timer(&(sp->rx_dma_timer));
	61	#endif
	62	}
	63
	64	static void bfin_sir_stop_tx(struct bfin_sir_port *port)
65	{
66	#ifdef CONFIG_SIR_BFIN_DMA
67	disable_dma(port->tx_dma_channel);
68	#endif
69
70	while (!(SIR_UART_GET_LSR(port) & THRE)) {
71	cpu_relax();
72	continue;
73	}
74
75	SIR_UART_STOP_TX(port);
76	}
77
78	static void bfin_sir_enable_tx(struct bfin_sir_port *port)
79	{
80	SIR_UART_ENABLE_TX(port);
81	}
82
83	static void bfin_sir_stop_rx(struct bfin_sir_port *port)
84	{
85	SIR_UART_STOP_RX(port);
86	}
87
88	static void bfin_sir_enable_rx(struct bfin_sir_port *port)
89	{
90	SIR_UART_ENABLE_RX(port);
91	}
92
93	static int bfin_sir_set_speed(struct bfin_sir_port *port, int speed)
94	{
95	int ret = -EINVAL;
96	unsigned int quot;
97	unsigned short val, lsr, lcr;
98	static int utime;
99	int count = 10;
100
101	lcr = WLS(8);
102
103	switch (speed) {
104	case 9600:
105	case 19200:
106	case 38400:
107	case 57600:
108	case 115200:
109
110	quot = (port->clk + (8 * speed)) / (16 * speed)\
111	- ANOMALY_05000230;
112
113	do {
114	udelay(utime);
115	lsr = SIR_UART_GET_LSR(port);
116	} while (!(lsr & TEMT) && count--);
117
118	/* The useconds for 1 bits to transmit */
119	utime = 1000000 / speed + 1;
120
121	/* Clear UCEN bit to reset the UART state machine
122	* and control registers
123	*/
124	val = SIR_UART_GET_GCTL(port);
125	val &= ~UCEN;
126	SIR_UART_PUT_GCTL(port, val);
127
128	/* Set DLAB in LCR to Access THR RBR IER */
129	SIR_UART_SET_DLAB(port);
130	SSYNC();
131
132	SIR_UART_PUT_DLL(port, quot & 0xFF);
133	SIR_UART_PUT_DLH(port, (quot >> 8) & 0xFF);
134	SSYNC();
135
136	/* Clear DLAB in LCR */
137	SIR_UART_CLEAR_DLAB(port);
138	SSYNC();
139
140	SIR_UART_PUT_LCR(port, lcr);
141
142	val = SIR_UART_GET_GCTL(port);
143	val \|= UCEN;
144	SIR_UART_PUT_GCTL(port, val);
145
146	ret = 0;
147	break;
148	default:
149	printk(KERN_WARNING "bfin_sir: Invalid speed %d\n", speed);
150	break;
151	}
152
153	val = SIR_UART_GET_GCTL(port);
154	/* If not add the 'RPOLC', we can't catch the receive interrupt.
155	* It's related with the HW layout and the IR transiver.
156	*/
157	val \|= IREN \| RPOLC;
158	SIR_UART_PUT_GCTL(port, val);
159	return ret;
160	}
161
162	static int bfin_sir_is_receiving(struct net_device *dev)
163	{
164	struct bfin_sir_self *self = netdev_priv(dev);
165	struct bfin_sir_port *port = self->sir_port;
166
167	if (!(SIR_UART_GET_IER(port) & ERBFI))
168	return 0;
169	return self->rx_buff.state != OUTSIDE_FRAME;
170	}
171
172	#ifdef CONFIG_SIR_BFIN_PIO
173	static void bfin_sir_tx_chars(struct net_device *dev)
174	{
175	unsigned int chr;
176	struct bfin_sir_self *self = netdev_priv(dev);
177	struct bfin_sir_port *port = self->sir_port;
178
179	if (self->tx_buff.len != 0) {
180	chr = *(self->tx_buff.data);
181	SIR_UART_PUT_CHAR(port, chr);
182	self->tx_buff.data++;
183	self->tx_buff.len--;
184	} else {
185	self->stats.tx_packets++;
186	self->stats.tx_bytes += self->tx_buff.data - self->tx_buff.head;
187	if (self->newspeed) {
188	bfin_sir_set_speed(port, self->newspeed);
189	self->speed = self->newspeed;
190	self->newspeed = 0;
191	}
192	bfin_sir_stop_tx(port);
193	bfin_sir_enable_rx(port);
194	/* I'm hungry! */
195	netif_wake_queue(dev);
196	}
197	}
198
199	static void bfin_sir_rx_chars(struct net_device *dev)
200	{
201	struct bfin_sir_self *self = netdev_priv(dev);
202	struct bfin_sir_port *port = self->sir_port;
203	unsigned char ch;
204
205	SIR_UART_CLEAR_LSR(port);
206	ch = SIR_UART_GET_CHAR(port);
207	async_unwrap_char(dev, &self->stats, &self->rx_buff, ch);
208	dev->last_rx = jiffies;
209	}
210
211	static irqreturn_t bfin_sir_rx_int(int irq, void *dev_id)
212	{
213	struct net_device *dev = dev_id;
214	struct bfin_sir_self *self = netdev_priv(dev);
215	struct bfin_sir_port *port = self->sir_port;
216
217	spin_lock(&self->lock);
218	while ((SIR_UART_GET_LSR(port) & DR))
219	bfin_sir_rx_chars(dev);
220	spin_unlock(&self->lock);
221
222	return IRQ_HANDLED;
223	}
224
225	static irqreturn_t bfin_sir_tx_int(int irq, void *dev_id)
226	{
227	struct net_device *dev = dev_id;
228	struct bfin_sir_self *self = netdev_priv(dev);
229	struct bfin_sir_port *port = self->sir_port;
230
231	spin_lock(&self->lock);
232	if (SIR_UART_GET_LSR(port) & THRE)
233	bfin_sir_tx_chars(dev);
234	spin_unlock(&self->lock);
235
236	return IRQ_HANDLED;
237	}
238	#endif /* CONFIG_SIR_BFIN_PIO */
239
240	#ifdef CONFIG_SIR_BFIN_DMA
241	static void bfin_sir_dma_tx_chars(struct net_device *dev)
242	{
243	struct bfin_sir_self *self = netdev_priv(dev);
244	struct bfin_sir_port *port = self->sir_port;
245
246	if (!port->tx_done)
247	return;
248	port->tx_done = 0;
249
250	if (self->tx_buff.len == 0) {
251	self->stats.tx_packets++;
252	if (self->newspeed) {
253	bfin_sir_set_speed(port, self->newspeed);
254	self->speed = self->newspeed;
255	self->newspeed = 0;
256	}
257	bfin_sir_enable_rx(port);
258	port->tx_done = 1;
259	netif_wake_queue(dev);
260	return;
261	}
262
263	blackfin_dcache_flush_range((unsigned long)(self->tx_buff.data),
264	(unsigned long)(self->tx_buff.data+self->tx_buff.len));
265	set_dma_config(port->tx_dma_channel,
266	set_bfin_dma_config(DIR_READ, DMA_FLOW_STOP,
267	INTR_ON_BUF, DIMENSION_LINEAR, DATA_SIZE_8,
268	DMA_SYNC_RESTART));
269	set_dma_start_addr(port->tx_dma_channel,
270	(unsigned long)(self->tx_buff.data));
271	set_dma_x_count(port->tx_dma_channel, self->tx_buff.len);
272	set_dma_x_modify(port->tx_dma_channel, 1);
273	enable_dma(port->tx_dma_channel);
274	}
275
276	static irqreturn_t bfin_sir_dma_tx_int(int irq, void *dev_id)
277	{
278	struct net_device *dev = dev_id;
279	struct bfin_sir_self *self = netdev_priv(dev);
280	struct bfin_sir_port *port = self->sir_port;
281
282	spin_lock(&self->lock);
283	if (!(get_dma_curr_irqstat(port->tx_dma_channel) & DMA_RUN)) {
284	clear_dma_irqstat(port->tx_dma_channel);
285	bfin_sir_stop_tx(port);
286
287	self->stats.tx_packets++;
288	self->stats.tx_bytes += self->tx_buff.len;
289	self->tx_buff.len = 0;
290	if (self->newspeed) {
291	bfin_sir_set_speed(port, self->newspeed);
292	self->speed = self->newspeed;
293	self->newspeed = 0;
294	}
295	bfin_sir_enable_rx(port);
296	/* I'm hungry! */
297	netif_wake_queue(dev);
298	port->tx_done = 1;
299	}
300	spin_unlock(&self->lock);
301
302	return IRQ_HANDLED;
303	}
304
305	static void bfin_sir_dma_rx_chars(struct net_device *dev)
306	{
307	struct bfin_sir_self *self = netdev_priv(dev);
308	struct bfin_sir_port *port = self->sir_port;
309	int i;
310
311	SIR_UART_CLEAR_LSR(port);
312
313	for (i = port->rx_dma_buf.head; i < port->rx_dma_buf.tail; i++)
314	async_unwrap_char(dev, &self->stats, &self->rx_buff, port->rx_dma_buf.buf[i]);
315	}
316
317	void bfin_sir_rx_dma_timeout(struct net_device *dev)
318	{
319	struct bfin_sir_self *self = netdev_priv(dev);
320	struct bfin_sir_port *port = self->sir_port;
321	int x_pos, pos;
322	unsigned long flags;
323
324	spin_lock_irqsave(&self->lock, flags);
325	x_pos = DMA_SIR_RX_XCNT - get_dma_curr_xcount(port->rx_dma_channel);
326	if (x_pos == DMA_SIR_RX_XCNT)
327	x_pos = 0;
328
329	pos = port->rx_dma_nrows * DMA_SIR_RX_XCNT + x_pos;
330
331	if (pos > port->rx_dma_buf.tail) {
332	port->rx_dma_buf.tail = pos;
333	bfin_sir_dma_rx_chars(dev);
334	port->rx_dma_buf.head = port->rx_dma_buf.tail;
335	}
336	spin_unlock_irqrestore(&self->lock, flags);
337	}
338
339	static irqreturn_t bfin_sir_dma_rx_int(int irq, void *dev_id)
340	{
341	struct net_device *dev = dev_id;
342	struct bfin_sir_self *self = netdev_priv(dev);
343	struct bfin_sir_port *port = self->sir_port;
344	unsigned short irqstat;
345
346	spin_lock(&self->lock);
347
348	port->rx_dma_nrows++;
349	port->rx_dma_buf.tail = DMA_SIR_RX_XCNT * port->rx_dma_nrows;
350	bfin_sir_dma_rx_chars(dev);
351	if (port->rx_dma_nrows >= DMA_SIR_RX_YCNT) {
352	port->rx_dma_nrows = 0;
353	port->rx_dma_buf.tail = 0;
354	}
355	port->rx_dma_buf.head = port->rx_dma_buf.tail;
356
357	irqstat = get_dma_curr_irqstat(port->rx_dma_channel);
358	clear_dma_irqstat(port->rx_dma_channel);
359	spin_unlock(&self->lock);
360
361	mod_timer(&port->rx_dma_timer, jiffies + DMA_SIR_RX_FLUSH_JIFS);
362	return IRQ_HANDLED;
363	}
364	#endif /* CONFIG_SIR_BFIN_DMA */
365
366	static int bfin_sir_startup(struct bfin_sir_port port, struct net_device dev)
367	{
368	#ifdef CONFIG_SIR_BFIN_DMA
369	dma_addr_t dma_handle;
370	#endif /* CONFIG_SIR_BFIN_DMA */
371
372	if (request_dma(port->rx_dma_channel, "BFIN_UART_RX") < 0) {
373	dev_warn(&dev->dev, "Unable to attach SIR RX DMA channel\n");
374	return -EBUSY;
375	}
376
377	if (request_dma(port->tx_dma_channel, "BFIN_UART_TX") < 0) {
378	dev_warn(&dev->dev, "Unable to attach SIR TX DMA channel\n");
379	free_dma(port->rx_dma_channel);
380	return -EBUSY;
381	}
382
383	#ifdef CONFIG_SIR_BFIN_DMA
384
385	set_dma_callback(port->rx_dma_channel, bfin_sir_dma_rx_int, dev);
386	set_dma_callback(port->tx_dma_channel, bfin_sir_dma_tx_int, dev);
387
388	port->rx_dma_buf.buf = (unsigned char *)dma_alloc_coherent(NULL, PAGE_SIZE, &dma_handle, GFP_DMA);
389	port->rx_dma_buf.head = 0;
390	port->rx_dma_buf.tail = 0;
391	port->rx_dma_nrows = 0;
392
393	set_dma_config(port->rx_dma_channel,
394	set_bfin_dma_config(DIR_WRITE, DMA_FLOW_AUTO,
395	INTR_ON_ROW, DIMENSION_2D,
396	DATA_SIZE_8, DMA_SYNC_RESTART));
397	set_dma_x_count(port->rx_dma_channel, DMA_SIR_RX_XCNT);
398	set_dma_x_modify(port->rx_dma_channel, 1);
399	set_dma_y_count(port->rx_dma_channel, DMA_SIR_RX_YCNT);
400	set_dma_y_modify(port->rx_dma_channel, 1);
401	set_dma_start_addr(port->rx_dma_channel, (unsigned long)port->rx_dma_buf.buf);
402	enable_dma(port->rx_dma_channel);
403
404	port->rx_dma_timer.data = (unsigned long)(dev);
405	port->rx_dma_timer.function = (void *)bfin_sir_rx_dma_timeout;
406
407	#else
408
409	if (request_irq(port->irq, bfin_sir_rx_int, IRQF_DISABLED, "BFIN_SIR_RX", dev)) {
410	dev_warn(&dev->dev, "Unable to attach SIR RX interrupt\n");
411	return -EBUSY;
412	}
413
414	if (request_irq(port->irq+1, bfin_sir_tx_int, IRQF_DISABLED, "BFIN_SIR_TX", dev)) {
415	dev_warn(&dev->dev, "Unable to attach SIR TX interrupt\n");
416	free_irq(port->irq, dev);
417	return -EBUSY;
418	}
419	#endif
420
421	return 0;
422	}
423
424	static void bfin_sir_shutdown(struct bfin_sir_port port, struct net_device dev)
425	{
426	unsigned short val;
427
428	bfin_sir_stop_rx(port);
429	SIR_UART_DISABLE_INTS(port);
430
431	val = SIR_UART_GET_GCTL(port);
432	val &= ~(UCEN \| IREN \| RPOLC);
433	SIR_UART_PUT_GCTL(port, val);
434
435	#ifdef CONFIG_SIR_BFIN_DMA
436	disable_dma(port->tx_dma_channel);
437	disable_dma(port->rx_dma_channel);
438	del_timer(&(port->rx_dma_timer));
439	dma_free_coherent(NULL, PAGE_SIZE, port->rx_dma_buf.buf, 0);
440	#else
441	free_irq(port->irq+1, dev);
442	free_irq(port->irq, dev);
443	#endif
444	free_dma(port->tx_dma_channel);
445	free_dma(port->rx_dma_channel);
446	}
447
448	#ifdef CONFIG_PM
449	static int bfin_sir_suspend(struct platform_device *pdev, pm_message_t state)
450	{
451	struct bfin_sir_port *sir_port;
452	struct net_device *dev;
453	struct bfin_sir_self *self;
454
455	sir_port = platform_get_drvdata(pdev);
456	if (!sir_port)
457	return 0;
458
459	dev = sir_port->dev;
460	self = netdev_priv(dev);
461	if (self->open) {
462	flush_work(&self->work);
463	bfin_sir_shutdown(self->sir_port, dev);
464	netif_device_detach(dev);
465	}
466
467	return 0;
468	}
469	static int bfin_sir_resume(struct platform_device *pdev)
470	{
471	struct bfin_sir_port *sir_port;
472	struct net_device *dev;
473	struct bfin_sir_self *self;
474	struct bfin_sir_port *port;
475
476	sir_port = platform_get_drvdata(pdev);
477	if (!sir_port)
478	return 0;
479
480	dev = sir_port->dev;
481	self = netdev_priv(dev);
482	port = self->sir_port;
483	if (self->open) {
484	if (self->newspeed) {
485	self->speed = self->newspeed;
486	self->newspeed = 0;
487	}
488	bfin_sir_startup(port, dev);
489	bfin_sir_set_speed(port, 9600);
490	bfin_sir_enable_rx(port);
491	netif_device_attach(dev);
492	}
493	return 0;
494	}
495	#else
496	#define bfin_sir_suspend NULL
497	#define bfin_sir_resume NULL
498	#endif
499
500	static void bfin_sir_send_work(struct work_struct *work)
501	{
502	struct bfin_sir_self *self = container_of(work, struct bfin_sir_self, work);
503	struct net_device *dev = self->sir_port->dev;
504	struct bfin_sir_port *port = self->sir_port;
505	unsigned short val;
506	int tx_cnt = 10;
507
508	while (bfin_sir_is_receiving(dev) && --tx_cnt)
509	turnaround_delay(dev->last_rx, self->mtt);
510
511	bfin_sir_stop_rx(port);
512
513	/* To avoid losting RX interrupt, we reset IR function before
514	* sending data. We also can set the speed, which will
515	* reset all the UART.
516	*/
517	val = SIR_UART_GET_GCTL(port);
518	val &= ~(IREN \| RPOLC);
519	SIR_UART_PUT_GCTL(port, val);
520	SSYNC();
521	val \|= IREN \| RPOLC;
522	SIR_UART_PUT_GCTL(port, val);
523	SSYNC();
524	/* bfin_sir_set_speed(port, self->speed); */
525
526	#ifdef CONFIG_SIR_BFIN_DMA
527	bfin_sir_dma_tx_chars(dev);
528	#endif
529	bfin_sir_enable_tx(port);
530	dev->trans_start = jiffies;
531	}
532
533	static int bfin_sir_hard_xmit(struct sk_buff skb, struct net_device dev)
534	{
535	struct bfin_sir_self *self = netdev_priv(dev);
536	int speed = irda_get_next_speed(skb);
537
538	netif_stop_queue(dev);
539
540	self->mtt = irda_get_mtt(skb);
541
542	if (speed != self->speed && speed != -1)
543	self->newspeed = speed;
544
545	self->tx_buff.data = self->tx_buff.head;
546	if (skb->len == 0)
547	self->tx_buff.len = 0;
548	else
549	self->tx_buff.len = async_wrap_skb(skb, self->tx_buff.data, self->tx_buff.truesize);
550
551	schedule_work(&self->work);
552	dev_kfree_skb(skb);
553
554	return 0;
555	}
556
557	static int bfin_sir_ioctl(struct net_device dev, struct ifreq ifreq, int cmd)
558	{
559	struct if_irda_req rq = (struct if_irda_req )ifreq;
560	struct bfin_sir_self *self = netdev_priv(dev);
561	struct bfin_sir_port *port = self->sir_port;
562	int ret = 0;
563
564	switch (cmd) {
565	case SIOCSBANDWIDTH:
566	if (capable(CAP_NET_ADMIN)) {
567	if (self->open) {
568	ret = bfin_sir_set_speed(port, rq->ifr_baudrate);
569	bfin_sir_enable_rx(port);
570	} else {
571	dev_warn(&dev->dev, "SIOCSBANDWIDTH: !netif_running\n");
572	ret = 0;
573	}
574	}
575	break;
576
577	case SIOCSMEDIABUSY:
578	ret = -EPERM;
579	if (capable(CAP_NET_ADMIN)) {
580	irda_device_set_media_busy(dev, TRUE);
581	ret = 0;
582	}
583	break;
584
585	case SIOCGRECEIVING:
586	rq->ifr_receiving = bfin_sir_is_receiving(dev);
587	break;
588
589	default:
590	ret = -EOPNOTSUPP;
591	break;
592	}
593
594	return ret;
595	}
596
597	static struct net_device_stats bfin_sir_stats(struct net_device dev)
598	{
599	struct bfin_sir_self *self = netdev_priv(dev);
600
601	return &self->stats;
602	}
603
604	static int bfin_sir_open(struct net_device *dev)
605	{
606	struct bfin_sir_self *self = netdev_priv(dev);
607	struct bfin_sir_port *port = self->sir_port;
608	int err = -ENOMEM;
609
610	self->newspeed = 0;
611	self->speed = 9600;
612
613	spin_lock_init(&self->lock);
614
615	err = bfin_sir_startup(port, dev);
616	if (err)
617	goto err_startup;
618
619	bfin_sir_set_speed(port, 9600);
620
621	self->irlap = irlap_open(dev, &self->qos, DRIVER_NAME);
622	if (!self->irlap)
623	goto err_irlap;
624
625	INIT_WORK(&self->work, bfin_sir_send_work);
626
627	/*
628	* Now enable the interrupt then start the queue
629	*/
630	self->open = 1;
631	bfin_sir_enable_rx(port);
632
633	netif_start_queue(dev);
634
635	return 0;
636
637	err_irlap:
638	self->open = 0;
639	bfin_sir_shutdown(port, dev);
640	err_startup:
641	return err;
642	}
643
644	static int bfin_sir_stop(struct net_device *dev)
645	{
646	struct bfin_sir_self *self = netdev_priv(dev);
647
648	flush_work(&self->work);
649	bfin_sir_shutdown(self->sir_port, dev);
650
651	if (self->rxskb) {
652	dev_kfree_skb(self->rxskb);
653	self->rxskb = NULL;
654	}
655
656	/* Stop IrLAP */
657	if (self->irlap) {
658	irlap_close(self->irlap);
659	self->irlap = NULL;
660	}
661
662	netif_stop_queue(dev);
663	self->open = 0;
664
665	return 0;
666	}
667
668	static int bfin_sir_init_iobuf(iobuff_t *io, int size)
669	{
670	io->head = kmalloc(size, GFP_KERNEL);
671	if (!io->head)
672	return -ENOMEM;
673	io->truesize = size;
674	io->in_frame = FALSE;
675	io->state = OUTSIDE_FRAME;
676	io->data = io->head;
677	return 0;
678	}
679
d51e9b0d GY	680	static const struct net_device_ops bfin_sir_ndo = {
	681	.ndo_open = bfin_sir_open,
	682	.ndo_stop = bfin_sir_stop,
	683	.ndo_start_xmit = bfin_sir_hard_xmit,
	684	.ndo_do_ioctl = bfin_sir_ioctl,
	685	.ndo_get_stats = bfin_sir_stats,
	686	};
	687
d510fe70 GY	688	static int __devinit bfin_sir_probe(struct platform_device *pdev)
	689	{
	690	struct net_device *dev;
	691	struct bfin_sir_self *self;
	692	unsigned int baudrate_mask;
	693	struct bfin_sir_port *sir_port;
	694	int err;
	695
	696	if (pdev->id >= 0 && pdev->id < ARRAY_SIZE(per) && \
	697	per[pdev->id][3] == pdev->id) {
	698	err = peripheral_request_list(per[pdev->id], DRIVER_NAME);
	699	if (err)
	700	return err;
	701	} else {
	702	dev_err(&pdev->dev, "Invalid pdev id, please check board file\n");
	703	return -ENODEV;
	704	}
	705
	706	err = -ENOMEM;
	707	sir_port = kmalloc(sizeof(*sir_port), GFP_KERNEL);
	708	if (!sir_port)
	709	goto err_mem_0;
	710
	711	bfin_sir_init_ports(sir_port, pdev);
	712
	713	dev = alloc_irdadev(sizeof(*self));
	714	if (!dev)
	715	goto err_mem_1;
	716
	717	self = netdev_priv(dev);
	718	self->dev = &pdev->dev;
	719	self->sir_port = sir_port;
	720	sir_port->dev = dev;
	721
	722	err = bfin_sir_init_iobuf(&self->rx_buff, IRDA_SKB_MAX_MTU);
	723	if (err)
	724	goto err_mem_2;
	725	err = bfin_sir_init_iobuf(&self->tx_buff, IRDA_SIR_MAX_FRAME);
	726	if (err)
	727	goto err_mem_3;
	728
d51e9b0d GY	729	dev->netdev_ops = &bfin_sir_ndo;
d51e9b0d GY	730	dev->irq = sir_port->irq;
d510fe70 GY	731
	732	irda_init_max_qos_capabilies(&self->qos);
	733
	734	baudrate_mask = IR_9600;
	735
	736	switch (max_rate) {
	737	case 115200:
	738	baudrate_mask \|= IR_115200;
	739	case 57600:
	740	baudrate_mask \|= IR_57600;
	741	case 38400:
	742	baudrate_mask \|= IR_38400;
	743	case 19200:
	744	baudrate_mask \|= IR_19200;
	745	case 9600:
	746	break;
	747	default:
	748	dev_warn(&pdev->dev, "Invalid maximum baud rate, using 9600\n");
	749	}
	750
	751	self->qos.baud_rate.bits &= baudrate_mask;
	752
	753	self->qos.min_turn_time.bits = 1; /* 10 ms or more */
	754
	755	irda_qos_bits_to_value(&self->qos);
	756
	757	err = register_netdev(dev);
	758
	759	if (err) {
	760	kfree(self->tx_buff.head);
	761	err_mem_3:
	762	kfree(self->rx_buff.head);
	763	err_mem_2:
	764	free_netdev(dev);
	765	err_mem_1:
	766	kfree(sir_port);
	767	err_mem_0:
	768	peripheral_free_list(per[pdev->id]);
	769	} else
	770	platform_set_drvdata(pdev, sir_port);
	771
	772	return err;
	773	}
	774
	775	static int __devexit bfin_sir_remove(struct platform_device *pdev)
	776	{
	777	struct bfin_sir_port *sir_port;
	778	struct net_device *dev = NULL;
	779	struct bfin_sir_self *self;
	780
	781	sir_port = platform_get_drvdata(pdev);
	782	if (!sir_port)
	783	return 0;
	784	dev = sir_port->dev;
	785	self = netdev_priv(dev);
	786	unregister_netdev(dev);
	787	kfree(self->tx_buff.head);
	788	kfree(self->rx_buff.head);
	789	free_netdev(dev);
	790	kfree(sir_port);
	791	platform_set_drvdata(pdev, NULL);
	792
	793	return 0;
	794	}
795
796	static struct platform_driver bfin_ir_driver = {
797	.probe = bfin_sir_probe,
798	.remove = __devexit_p(bfin_sir_remove),
799	.suspend = bfin_sir_suspend,
800	.resume = bfin_sir_resume,
801	.driver = {
802	.name = DRIVER_NAME,
803	},
804	};
805
806	static int __init bfin_sir_init(void)
807	{
808	return platform_driver_register(&bfin_ir_driver);
809	}
810
811	static void __exit bfin_sir_exit(void)
812	{
813	platform_driver_unregister(&bfin_ir_driver);
814	}
815
816	module_init(bfin_sir_init);
817	module_exit(bfin_sir_exit);
818
819	module_param(max_rate, int, 0);
820	MODULE_PARM_DESC(max_rate, "Maximum baud rate (115200, 57600, 38400, 19200, 9600)");
821
822	MODULE_AUTHOR("Graf Yang <graf.yang@analog.com>");
823	MODULE_DESCRIPTION("Blackfin IrDA driver");
824	MODULE_LICENSE("GPL");