pxa_ir.c

linux嵌入式课程实践中的一个关于声卡驱动程序 。

	   DCSR(si->txdma_ch) = DCSR_RUN | DCSR_NODESC ;

	   DBG("FICP status %x\n",ICSR0);

	   return 0;
	}
	
}

static int
pxa250_irda_ioctl(struct net_device *dev, struct ifreq *ifreq, int cmd)
{
	struct if_irda_req *rq = (struct if_irda_req *)ifreq;
	struct pxa250_irda *si = dev->priv;
	int ret = -EOPNOTSUPP;

	__ECHO_IN;
	
	switch (cmd) {
	case SIOCSBANDWIDTH:
		if (capable(CAP_NET_ADMIN)) {
			/*
			 * We are unable to set the speed if the
			 * device is not running.
			 */
			if (si->open) {
				ret = pxa250_irda_set_speed(dev,
						rq->ifr_baudrate);
			} else {
				printk("pxa250_irda_ioctl: 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 = IS_FIR(si) ? 0
					: si->rx_buff.state != OUTSIDE_FRAME;
		break;

	default:
		break;
	}

	__ECHO_OUT;

	return ret;
}

static struct net_device_stats *pxa250_irda_stats(struct net_device *dev)
{
	struct pxa250_irda *si = dev->priv;
	return &si->stats;
}

static int pxa250_irda_start(struct net_device *dev)
{
	struct pxa250_irda *si = dev->priv;
	int err;
	unsigned int flags;
	

	MOD_INC_USE_COUNT;

	__ECHO_IN;
	si->speed = 9600;

	local_irq_save(flags);
	
	err = request_irq(si->fir_irq, pxa250_irda_fir_irq, 0,  dev->name, dev);
	if (err)
		goto err_fir_irq;

	err = request_irq(dev->irq, pxa250_irda_irq, 0, dev->name, dev);
	if (err)
		goto err_irq;

	/*
	 * The interrupt must remain disabled for now.
	 */
	
	disable_irq(dev->irq);
  	disable_irq(si->fir_irq);

	local_irq_restore(flags);


	/* Allocate DMA channel for receiver (not used) */
	err = pxa_request_dma("IrDA receive", DMA_PRIO_LOW, pxa250_irda_rxdma_irq, dev);
	if (err < 0 )
	   goto err_rx_dma;
	si->rxdma_ch=err;

	DRCMRRXICDR = DRCMR_MAPVLD | si->rxdma_ch;
	

	/* Allocate DMA channel for transmit */
	err = pxa_request_dma("IrDA transmit", DMA_PRIO_LOW, pxa250_irda_txdma_irq , dev);
	if (err < 0 )
	   goto err_tx_dma;

	si->txdma_ch=err;

	/*
	 * Make sure that ICP will be able 
	 * to assert the transmit dma request bit
	 * through the peripherals request bus (PREQ)
	 */
	
	DRCMRTXICDR = DRCMR_MAPVLD | si->txdma_ch;

	DBG("rx(not used) channel=%d tx channel=%d\n",si->rxdma_ch,si->txdma_ch);
	
	/* allocate consistent buffers for dma access
	 * buffers have to be aligned and situated in dma capable memory region;
	 */
	si->rxbuf_dma_virt = consistent_alloc(GFP_KERNEL | GFP_DMA ,HPSIR_MAX_RXLEN , &si->rxbuf_dma);
	if (! si->rxbuf_dma_virt )
		goto err_rxbuf_dma;

	si->txbuf_dma_virt = consistent_alloc(GFP_KERNEL | GFP_DMA, HPSIR_MAX_TXLEN,  &si->txbuf_dma); 
	if (! si->txbuf_dma_virt )
		goto err_txbuf_dma;

	/* Alocate skb for receiver */
	err=pxa250_irda_rx_alloc(si);
	if (err)
	   goto err_rx_alloc;
	
	/*
	 * Setup the serial port for the specified config.
	 */
	err = pxa250_irda_startup(dev);
	if (err)
		goto err_startup;

	pxa250_irda_set_speed(dev,si->speed = 9600);


	/*
	 * Open a new IrLAP layer instance.
	 */
	si->irlap = irlap_open(dev, &si->qos, "pxa250");
	err = -ENOMEM;
	if (!si->irlap)
		goto err_irlap;

	/*
	 * Now enable the interrupt and start the queue
	 */
	si->open = 1;
	enable_irq(dev->irq);
	netif_start_queue(dev);
	return 0;

err_irlap:
	si->open = 0;
	pxa250_sir_irda_shutdown(si);
err_startup:
	dev_kfree_skb(si->rxskb);
err_rx_alloc:	
	consistent_free (si->txbuf_dma_virt,HPSIR_MAX_TXLEN,si->txbuf_dma);
err_txbuf_dma:
	consistent_free (si->rxbuf_dma_virt,HPSIR_MAX_RXLEN,si->rxbuf_dma);
err_rxbuf_dma:
	pxa_free_dma(si->txdma_ch);
err_tx_dma:
	pxa_free_dma(si->rxdma_ch);
err_rx_dma:
	free_irq(dev->irq, dev);
err_irq:
	free_irq(si->fir_irq, dev);
err_fir_irq:	
	MOD_DEC_USE_COUNT;
	return err;
}

static int pxa250_irda_stop(struct net_device *dev)
{
	struct pxa250_irda *si = dev->priv;
	
	printk(KERN_ERR "Irda stop... RX = %d TX = %d\n",rx_count,tx_count);

	disable_irq(dev->irq);
  	disable_irq(si->fir_irq); 
/*  	pxa250_irda_shutdown(si); */

	/*
	 * If we have been doing DMA receive, make sure we
	 * tidy that up cleanly.
	 */
	if (si->rxskb) {
	        dev_kfree_skb(si->rxskb);
		si->rxskb = NULL;
	}

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

	consistent_free (si->txbuf_dma_virt,HPSIR_MAX_TXLEN,si->txbuf_dma);
	consistent_free (si->rxbuf_dma_virt,HPSIR_MAX_RXLEN,si->rxbuf_dma);
	pxa_free_dma(si->txdma_ch);
	pxa_free_dma(si->rxdma_ch);

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

	/*
	 * Free resources
	 */
	free_irq(dev->irq, dev);
	free_irq(si->fir_irq, dev);


	MOD_DEC_USE_COUNT;

	return 0;
}

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




static int pxa250_stop_fir(struct net_device *dev)
{
   struct pxa250_irda *si = dev->priv;
   unsigned int flag;

   save_flags(flag);
   cli();
   
   pxa250_dma_stop(si->txdma_ch);
   pxa250_dma_stop(si->rxdma_ch);

   if (si->txskb)
      dev_kfree_skb_irq(si->txskb);

   ICCR0 &= ~(ICCR0_RXE | ICCR0_TXE );
   disable_irq(si->fir_irq);
   CKEN &= ~CKEN13_FICP;

#ifdef CONFIG_ARCH_H3900
H3900_ASIC3_GPIO_B_DIR |=  GPIO3_IR_ON_N;
H3900_ASIC3_GPIO_B_OUT |=  GPIO3_IR_ON_N;
H3900_ASIC3_GPIO_B_DIR |=  GPIO3_CIR_CTL_PWR_ON;
H3900_ASIC3_GPIO_B_OUT &=  ~GPIO3_CIR_CTL_PWR_ON;
#endif

   restore_flags(flag);

   return 0;
}



static int pxa250_irda_set_speed(struct net_device *dev, int speed)
{
   struct pxa250_irda *si = dev->priv;
   int brd, ret = -EINVAL;
   static int last_fir_speed=0;

   __ECHO_IN;
   


   switch (speed) {
      case 9600:	case 19200:	case 38400:
      case 57600:	case 115200:
	   
	 /* Baud rate fixed - Clo */

	 /*
	  * FIXME
	  */
	 if (last_fir_speed) 
	 {

	    pxa250_stop_fir(dev);
	    DBG("GPIO sir\n");
	    set_GPIO_mode (GPIO46_STRXD_MD);
	    set_GPIO_mode (GPIO47_STTXD_MD);
   
	    enable_irq(dev->irq);
	    netif_wake_queue(dev);
	    last_fir_speed=0;
	 }
	 

//	 LUB_MISC_WR &= ~(1 << 4);

	 brd = 14745600 / (16 * speed); 

	 STLCR |= LCR_DLAB;

	 STDLH = brd >> 8; /* Clo: set Divisor Latch High */
	 STDLL = brd & 0xFF; /* Clo: set Devisor Latch Low */

	 DBG("STDLH %x, STDLL %x\n", STDLH, STDLL);
		
	 STLCR &= ~LCR_DLAB; /* Clo: clear DLAB bit */ 

//	 STMCR = MCR_OUT2 | (sir_loop?MCR_LOOP:0);
	 STMCR = MCR_OUT2;

	 CKEN |= CKEN5_STUART;

	 ICMR |= ( 1 << 20 );
		
	 STLCR = LCR_WLS1 | LCR_WLS0;

	 SET_SIR_MODE;
		
	 STFCR = FCR_TRFIFOE |  FCR_RESETTF | FCR_RESETRF;

	 STIER = IER_UUE | IER_RAVIE | IER_RTIOE;

	 si->speed = speed;

	 ret = 0;
	 break;

      case 4000000:

	 if (last_fir_speed)
	    goto speed_out;
	 
	 disable_irq(dev->irq);

	 pxa250_sir_irda_shutdown(si);
	 pxa250_fir_irda_startup(si);
	 pxa250_irda_rx_alloc(si);
	 ICCR0=0;
	 pxa250_start_rx_dma(dev);
	 pxa250_ficp_rx_start();
	 
	 enable_irq(si->fir_irq);
	 DBG("enable FIR \n");
	 si->speed = speed;

	 netif_wake_queue(dev);
	 last_fir_speed=1;
speed_out:
	 
	 ret=0;
	 
	 break;

      default:
	 break;
   }
   __ECHO_OUT;

   return ret;
}


static int pxa250_irda_net_init(struct net_device *dev)
{
	struct pxa250_irda *si = dev->priv;
	unsigned int baudrate_mask;
	int err = -ENOMEM;

	si = kmalloc(sizeof(struct pxa250_irda), GFP_KERNEL);
	if (!si)
		goto out;

	memset(si, 0, sizeof(*si));

	/*
	 * Initialise the HP-SIR buffers
	 */

	err = pxa250_irda_init_iobuf(&si->rx_buff, 14384);
	if (err)
		goto out;
	err = pxa250_irda_init_iobuf(&si->tx_buff, 4000);
	if (err)
		goto out_free_rx;

	si->fir_irq		= IRQ_ICP;
	dev->priv = si;
	dev->hard_start_xmit	= pxa250_irda_hard_xmit;
	dev->open		= pxa250_irda_start;
	dev->stop		= pxa250_irda_stop;
	dev->do_ioctl		= pxa250_irda_ioctl;
	dev->get_stats		= pxa250_irda_stats;

	irda_device_setup(dev);
	irda_init_max_qos_capabilies(&si->qos);

	/*
	 * We support original IRDA up to 115k2. (we don't currently
	 * support 4Mbps).  Min Turn Time set to 1ms or greater.
	 */
	baudrate_mask = IR_9600|IR_19200|IR_38400|IR_57600|IR_115200;
  	baudrate_mask |= IR_4000000 << 8; 
	si->qos.baud_rate.bits &= baudrate_mask;
	si->qos.min_turn_time.bits = 7;

	irda_qos_bits_to_value(&si->qos);

#ifdef CONFIG_PM
	/*
	 * Power-Management is optional.
	 */
	si->pmdev = pm_register(PM_SYS_DEV, PM_SYS_IRDA, pxa250_irda_pmproc);
	if (si->pmdev)
		si->pmdev->data = dev;
#endif

	return 0;

	kfree(si->tx_buff.head);
out_free_rx:
	kfree(si->rx_buff.head);
out:
	kfree(si);

	return err;
}

/*
 * Remove all traces of this driver module from the kernel, so we can't be
 * called.  Note that the device has already been stopped, so we don't have
 * to worry about interrupts or dma.
 */
static void pxa250_irda_net_uninit(struct net_device *dev)
{
	struct pxa250_irda *si = dev->priv;

	dev->hard_start_xmit	= NULL;
	dev->open		= NULL;
	dev->stop		= NULL;
	dev->do_ioctl		= NULL;
	dev->get_stats		= NULL;
	dev->priv		= NULL;

	pm_unregister(si->pmdev);

	kfree(si->tx_buff.head);
	kfree(si->rx_buff.head);
	kfree(si);
}

static int __init pxa250_irda_init(void)
{
	struct net_device *dev;
	int err;

	/* STUART */
	err = request_mem_region(__PREG(STRBR), 0x24, "IrDA") ? 0 : -EBUSY;
	if (err)
		goto err_mem_1;

	/* FIR */
	err = request_mem_region(__PREG(ICCR0), 0x1c, "IrDA") ? 0 : -EBUSY;
	if (err)
		goto err_mem_2;


	rtnl_lock();
	dev = dev_alloc("irda%d", &err);
	if (dev) {
		dev->irq    = IRQ_STUART;
		dev->init   = pxa250_irda_net_init;
		dev->uninit = pxa250_irda_net_uninit;

		err = register_netdevice(dev);

		if (err)
			kfree(dev);
		else
			netdev = dev;
	}
	rtnl_unlock();

	if (err) {
		release_mem_region(__PREG(ICCR0), 0x1c);
err_mem_2:
		release_mem_region(__PREG(STRBR), 0x24);
	}
err_mem_1:
	return err;
}

static void __exit pxa250_irda_exit(void)
{
	struct net_device *dev = netdev;

	netdev = NULL;
	if (dev) {
		rtnl_lock();
		unregister_netdevice(dev);
		rtnl_unlock();
	}

        release_mem_region(__PREG(ICCR0), 0x1c);

	release_mem_region(__PREG(STRBR), 0x24);

	/*
	 * We now know that the netdevice is no longer in use, and all
	 * references to our driver have been removed.  The only structure
	 * which may still be present is the netdevice, which will get
	 * cleaned up by net/core/dev.c
	 */
}

module_init(pxa250_irda_init);
module_exit(pxa250_irda_exit);

MODULE_AUTHOR("Alexey Lugovskoy Frasenyak Dmitrij, changes for h3900 Chrsitian P <[e-mail]>");
MODULE_DESCRIPTION("PXA250 SIR/FIR");
MODULE_LICENSE("GPL");
EXPORT_NO_SYMBOLS;