baycom_epp.c

powerpc内核mpc8241linux系统下net驱动程序

	bc = (struct baycom_state *)dev->priv;
	pp = bc->pdev->port;
	bc->bh_running = 0;
	dev->start = 0;
	dev->tbusy = 1;
	run_task_queue(&tq_timer);  /* dequeue bottom half */
	bc->stat = EPP_DCDBIT;
	parport_epp_write_addr(pp, 0);
	parport_write_control(pp, 0); /* reset the adapter */
        parport_release(bc->pdev);
        parport_unregister_device(bc->pdev);
        /* Free any buffers left in the hardware transmit queue */
        while ((skb = skb_dequeue(&bc->send_queue)))
			dev_kfree_skb(skb);
	printk(KERN_INFO "%s: close epp at iobase 0x%lx irq %u\n",
	       bc_drvname, dev->base_addr, dev->irq);
	MOD_DEC_USE_COUNT;
	return 0;
}

/* --------------------------------------------------------------------- */

static int baycom_setmode(struct baycom_state *bc, const char *modestr)
{
	const char *cp;

	if (strstr(modestr,"intclk"))
		bc->cfg.intclk = 1;
	if (strstr(modestr,"extclk"))
		bc->cfg.intclk = 0;
	if (strstr(modestr,"intmodem"))
		bc->cfg.extmodem = 0;
	if (strstr(modestr,"extmodem"))
		bc->cfg.extmodem = 1;
	if (strstr(modestr,"noloopback"))
		bc->cfg.loopback = 0;
	if (strstr(modestr,"loopback"))
		bc->cfg.loopback = 1;
	if ((cp = strstr(modestr,"divider="))) {
		bc->cfg.divider = simple_strtoul(cp+8, NULL, 0);
		if (bc->cfg.divider < 1)
			bc->cfg.divider = 1;
		if (bc->cfg.divider > 1023)
			bc->cfg.divider = 1023;
	}
	return 0;
}

/* --------------------------------------------------------------------- */

static int baycom_ioctl(struct device *dev, struct ifreq *ifr, int cmd)
{
	struct baycom_state *bc;
	struct baycom_ioctl bi;
	struct hdlcdrv_ioctl hi;
	struct sm_ioctl si;

	baycom_paranoia_check(dev, "baycom_ioctl", -EINVAL);
	bc = (struct baycom_state *)dev->priv;
	if (cmd != SIOCDEVPRIVATE)
		return -ENOIOCTLCMD;
	if (get_user(cmd, (int *)ifr->ifr_data))
		return -EFAULT;
#ifdef BAYCOM_DEBUG
	if (cmd == BAYCOMCTL_GETDEBUG) {
		bi.data.dbg.debug1 = bc->ptt_keyed;
		bi.data.dbg.debug2 = bc->debug_vals.last_intcnt;
		bi.data.dbg.debug3 = bc->debug_vals.last_pllcorr;
		bc->debug_vals.last_intcnt = 0;
		if (copy_to_user(ifr->ifr_data, &bi, sizeof(bi)))
			return -EFAULT;
		return 0;
	}
	if (cmd == SMCTL_GETDEBUG) {
                si.data.dbg.int_rate = bc->debug_vals.last_intcnt;
                si.data.dbg.mod_cycles = bc->debug_vals.mod_cycles;
                si.data.dbg.demod_cycles = bc->debug_vals.demod_cycles;
                si.data.dbg.dma_residue = 0;
                bc->debug_vals.mod_cycles = bc->debug_vals.demod_cycles = 0;
		bc->debug_vals.last_intcnt = 0;
                if (copy_to_user(ifr->ifr_data, &si, sizeof(si)))
                        return -EFAULT;
                return 0;
	}
#endif /* BAYCOM_DEBUG */

	if (copy_from_user(&hi, ifr->ifr_data, sizeof(hi)))
		return -EFAULT;
	switch (hi.cmd) {
	default:
		return -ENOIOCTLCMD;

	case HDLCDRVCTL_GETCHANNELPAR:
		hi.data.cp.tx_delay = bc->ch_params.tx_delay;
		hi.data.cp.tx_tail = bc->ch_params.tx_tail;
		hi.data.cp.slottime = bc->ch_params.slottime;
		hi.data.cp.ppersist = bc->ch_params.ppersist;
		hi.data.cp.fulldup = bc->ch_params.fulldup;
		break;

	case HDLCDRVCTL_SETCHANNELPAR:
		if (!suser())
			return -EACCES;
		bc->ch_params.tx_delay = hi.data.cp.tx_delay;
		bc->ch_params.tx_tail = hi.data.cp.tx_tail;
		bc->ch_params.slottime = hi.data.cp.slottime;
		bc->ch_params.ppersist = hi.data.cp.ppersist;
		bc->ch_params.fulldup = hi.data.cp.fulldup;
		bc->hdlctx.slotcnt = 1;
		return 0;
		
	case HDLCDRVCTL_GETMODEMPAR:
		hi.data.mp.iobase = dev->base_addr;
		hi.data.mp.irq = dev->irq;
		hi.data.mp.dma = dev->dma;
		hi.data.mp.dma2 = 0;
		hi.data.mp.seriobase = 0;
		hi.data.mp.pariobase = 0;
		hi.data.mp.midiiobase = 0;
		break;

	case HDLCDRVCTL_SETMODEMPAR:
		if ((!suser()) || dev->start)
			return -EACCES;
		dev->base_addr = hi.data.mp.iobase;
		dev->irq = /*hi.data.mp.irq*/0;
		dev->dma = /*hi.data.mp.dma*/0;
		return 0;	
		
	case HDLCDRVCTL_GETSTAT:
		hi.data.cs.ptt = !!(bc->stat & EPP_PTTBIT);
		hi.data.cs.dcd = !(bc->stat & EPP_DCDBIT);
		hi.data.cs.ptt_keyed = bc->ptt_keyed;
		hi.data.cs.tx_packets = bc->stats.tx_packets;
		hi.data.cs.tx_errors = bc->stats.tx_errors;
		hi.data.cs.rx_packets = bc->stats.rx_packets;
		hi.data.cs.rx_errors = bc->stats.rx_errors;
		break;		

	case HDLCDRVCTL_OLDGETSTAT:
		hi.data.ocs.ptt = !!(bc->stat & EPP_PTTBIT);
		hi.data.ocs.dcd = !(bc->stat & EPP_DCDBIT);
		hi.data.ocs.ptt_keyed = bc->ptt_keyed;
		break;		

	case HDLCDRVCTL_CALIBRATE:
		bc->hdlctx.calibrate = hi.data.calibrate * bc->bitrate / 8;
		return 0;

	case HDLCDRVCTL_DRIVERNAME:
		strncpy(hi.data.drivername, "baycom_epp", sizeof(hi.data.drivername));
		break;
		
	case HDLCDRVCTL_GETMODE:
		sprintf(hi.data.modename, "%sclk,%smodem,divider=%d%s", 
			bc->cfg.intclk ? "int" : "ext",
			bc->cfg.extmodem ? "ext" : "int", bc->cfg.divider,
			bc->cfg.loopback ? ",loopback" : "");
		break;

	case HDLCDRVCTL_SETMODE:
		if (!suser() || dev->start)
			return -EACCES;
		hi.data.modename[sizeof(hi.data.modename)-1] = '\0';
		return baycom_setmode(bc, hi.data.modename);

	case HDLCDRVCTL_MODELIST:
		strncpy(hi.data.modename, "intclk,extclk,intmodem,extmodem,divider=x",
			sizeof(hi.data.modename));
		break;

	case HDLCDRVCTL_MODEMPARMASK:
		return HDLCDRV_PARMASK_IOBASE;

	}
	if (copy_to_user(ifr->ifr_data, &hi, sizeof(hi)))
		return -EFAULT;
	return 0;
}

/* --------------------------------------------------------------------- */

/*
 * Check for a network adaptor of this type, and return '0' if one exists.
 * If dev->base_addr == 0, probe all likely locations.
 * If dev->base_addr == 1, always return failure.
 * If dev->base_addr == 2, allocate space for the device and return success
 * (detachable devices only).
 */
static int baycom_probe(struct device *dev)
{
	static char ax25_bcast[AX25_ADDR_LEN] = {
		'Q' << 1, 'S' << 1, 'T' << 1, ' ' << 1, ' ' << 1, ' ' << 1, '0' << 1
	};
	static char ax25_nocall[AX25_ADDR_LEN] = {
		'L' << 1, 'I' << 1, 'N' << 1, 'U' << 1, 'X' << 1, ' ' << 1, '1' << 1
	};
	const struct hdlcdrv_channel_params dflt_ch_params = { 
		20, 2, 10, 40, 0 
	};
	struct baycom_state *bc;

	if (!dev)
		return -ENXIO;
	baycom_paranoia_check(dev, "baycom_probe", -ENXIO);
	/*
	 * not a real probe! only initialize data structures
	 */
	bc = (struct baycom_state *)dev->priv;
	/*
	 * initialize the baycom_state struct
	 */
	bc->ch_params = dflt_ch_params;
	bc->ptt_keyed = 0;

	/*
	 * initialize the device struct
	 */
	dev->open = epp_open;
	dev->stop = epp_close;
	dev->do_ioctl = baycom_ioctl;
	dev->hard_start_xmit = baycom_send_packet;
	dev->get_stats = baycom_get_stats;

	/* Fill in the fields of the device structure */
	dev_init_buffers(dev);

	skb_queue_head_init(&bc->send_queue);
	
#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
	dev->hard_header = ax25_encapsulate;
	dev->rebuild_header = ax25_rebuild_header;
#else /* CONFIG_AX25 || CONFIG_AX25_MODULE */
	dev->hard_header = NULL;
	dev->rebuild_header = NULL;
#endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
	dev->set_mac_address = baycom_set_mac_address;
	
	dev->type = ARPHRD_AX25;           /* AF_AX25 device */
	dev->hard_header_len = AX25_MAX_HEADER_LEN + AX25_BPQ_HEADER_LEN;
	dev->mtu = AX25_DEF_PACLEN;        /* eth_mtu is the default */
	dev->addr_len = AX25_ADDR_LEN;     /* sizeof an ax.25 address */
	memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
	memcpy(dev->dev_addr, ax25_nocall, AX25_ADDR_LEN);

	/* New style flags */
	dev->flags = 0;

	return 0;
}

/* --------------------------------------------------------------------- */

__initfunc(int baycom_epp_init(void))
{
	struct device *dev;
	int i, found = 0;
	char set_hw = 1;
	struct baycom_state *bc;

	printk(bc_drvinfo);
	/*
	 * register net devices
	 */
	for (i = 0; i < NR_PORTS; i++) {
		dev = baycom_device+i;
		if (!baycom_ports[i].mode)
			set_hw = 0;
		if (!set_hw)
			baycom_ports[i].iobase = 0;
		memset(dev, 0, sizeof(struct device));
		if (!(bc = dev->priv = kmalloc(sizeof(struct baycom_state), GFP_KERNEL)))
			return -ENOMEM;
		/*
		 * initialize part of the baycom_state struct
		 */
		memset(bc, 0, sizeof(struct baycom_state));
		bc->magic = BAYCOM_MAGIC;
		sprintf(bc->ifname, "bce%d", i);
		/*
		 * initialize part of the device struct
		 */
		dev->name = bc->ifname;
		dev->if_port = 0;
		dev->init = baycom_probe;
		dev->start = 0;
		dev->tbusy = 1;
		dev->base_addr = baycom_ports[i].iobase;
		dev->irq = 0;
		dev->dma = 0;
		if (register_netdev(dev)) {
			printk(KERN_WARNING "%s: cannot register net device %s\n", bc_drvname, bc->ifname);
			kfree(dev->priv);
			return -ENXIO;
		}
		if (set_hw && baycom_setmode(bc, baycom_ports[i].mode))
			set_hw = 0;
		found++;
	}
	if (!found)
		return -ENXIO;
	return 0;
}

/* --------------------------------------------------------------------- */

#ifdef MODULE

/*
 * command line settable parameters
 */
static const char *mode[NR_PORTS] = { "epp", };
static int iobase[NR_PORTS] = { 0x378, };

#if LINUX_VERSION_CODE >= 0x20115

MODULE_PARM(mode, "s");
MODULE_PARM_DESC(mode, "baycom operating mode; epp");
MODULE_PARM(iobase, "i");
MODULE_PARM_DESC(iobase, "baycom io base address");

MODULE_AUTHOR("Thomas M. Sailer, [e-mail], [e-mail]");
MODULE_DESCRIPTION("Baycom epp amateur radio modem driver");

#endif

__initfunc(int init_module(void))
{
        int i;

        for (i = 0; (i < NR_PORTS) && (mode[i]); i++) {
                baycom_ports[i].mode = mode[i];
                baycom_ports[i].iobase = iobase[i];
        }
        if (i < NR_PORTS-1)
                baycom_ports[i+1].mode = NULL;
        return baycom_epp_init();
}

/* --------------------------------------------------------------------- */

void cleanup_module(void)
{
	struct device *dev;
	struct baycom_state *bc;
	int i;

	for(i = 0; i < NR_PORTS; i++) {
		dev = baycom_device+i;
		bc = (struct baycom_state *)dev->priv;
		if (bc) {
			if (bc->magic == BAYCOM_MAGIC) {
				unregister_netdev(dev);
				kfree(dev->priv);
			} else
				printk(paranoia_str, "cleanup_module");
		}
	}
}

#else /* MODULE */
/* --------------------------------------------------------------------- */
/*
 * format: baycom=io,mode
 * mode: epp
 */

__initfunc(void baycom_epp_setup(char *str, int *ints))
{
	int i;

	for (i = 0; (i < NR_PORTS) && (baycom_ports[i].mode); i++);
	if ((i >= NR_PORTS) || (ints[0] < 1)) {
		printk(KERN_INFO "%s: too many or invalid interface "
		       "specifications\n", bc_drvname);
		return;
	}
	baycom_ports[i].mode = str;
	baycom_ports[i].iobase = ints[1];
	if (i < NR_PORTS-1)
		baycom_ports[i+1].mode = NULL;
}

#endif /* MODULE */
/* --------------------------------------------------------------------- */