wanrouter: delete now orphaned header content, files/drivers (6fcdf4fa) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/net/wan/cycx_drv.c

deleted100644 → 0

+0 −569

Original line number	Diff line number	Diff line
		/*
		* cycx_drv.c Cyclom 2X Support Module.
		*
		* This module is a library of common hardware specific
		* functions used by the Cyclades Cyclom 2X sync card.
		*
		* Author: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
		*
		* Copyright: (c) 1998-2003 Arnaldo Carvalho de Melo
		*
		* Based on sdladrv.c by Gene Kozin <genek@compuserve.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.
		* ============================================================================
		* 1999/11/11 acme set_current_state(TASK_INTERRUPTIBLE), code
		* cleanup
		* 1999/11/08 acme init_cyc2x deleted, doing nothing
		* 1999/11/06 acme back to read[bw], write[bw] and memcpy_to and
		* fromio to use dpmbase ioremaped
		* 1999/10/26 acme use isa_read[bw], isa_write[bw] & isa_memcpy_to
		* & fromio
		* 1999/10/23 acme cleanup to only supports cyclom2x: all the other
		* boards are no longer manufactured by cyclades,
		* if someone wants to support them... be my guest!
		* 1999/05/28 acme cycx_intack & cycx_intde gone for good
		* 1999/05/18 acme lots of unlogged work, submitting to Linus...
		* 1999/01/03 acme more judicious use of data types
		* 1999/01/03 acme judicious use of data types :>
		* cycx_inten trying to reset pending interrupts
		* from cyclom 2x - I think this isn't the way to
		* go, but for now...
		* 1999/01/02 acme cycx_intack ok, I think there's nothing to do
		* to ack an int in cycx_drv.c, only handle it in
		* cyx_isr (or in the other protocols: cyp_isr,
		* cyf_isr, when they get implemented.
		* Dec 31, 1998 acme cycx_data_boot & cycx_code_boot fixed, crossing
		* fingers to see x25_configure in cycx_x25.c
		* work... :)
		* Dec 26, 1998 acme load implementation fixed, seems to work! :)
		* cycx_2x_dpmbase_options with all the possible
		* DPM addresses (20).
		* cycx_intr implemented (test this!)
		* general code cleanup
		* Dec 8, 1998 Ivan Passos Cyclom-2X firmware load implementation.
		* Aug 8, 1998 acme Initial version.
		*/

		#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

		#include <linux/init.h> /* __init */
		#include <linux/module.h>
		#include <linux/kernel.h> /* printk(), and other useful stuff */
		#include <linux/stddef.h> /* offsetof(), etc. */
		#include <linux/errno.h> /* return codes */
		#include <linux/cycx_drv.h> /* API definitions */
		#include <linux/cycx_cfm.h> /* CYCX firmware module definitions */
		#include <linux/delay.h> /* udelay, msleep_interruptible */
		#include <asm/io.h> /* read[wl], write[wl], ioremap, iounmap */

		#define MOD_VERSION 0
		#define MOD_RELEASE 6

		MODULE_AUTHOR("Arnaldo Carvalho de Melo");
		MODULE_DESCRIPTION("Cyclom 2x Sync Card Driver");
		MODULE_LICENSE("GPL");

		/* Hardware-specific functions */
		static int load_cyc2x(struct cycx_hw hw, struct cycx_firmware cfm, u32 len);
		static void cycx_bootcfg(struct cycx_hw *hw);

		static int reset_cyc2x(void __iomem *addr);
		static int detect_cyc2x(void __iomem *addr);

		/* Miscellaneous functions */
		static int get_option_index(const long *optlist, long optval);
		static u16 checksum(u8 *buf, u32 len);

		#define wait_cyc(addr) cycx_exec(addr + CMD_OFFSET)

		/* Global Data */

		/* private data */
		static const char fullname[] = "Cyclom 2X Support Module";
		static const char copyright[] =
		"(c) 1998-2003 Arnaldo Carvalho de Melo <acme@conectiva.com.br>";

		/* Hardware configuration options.
		* These are arrays of configuration options used by verification routines.
		* The first element of each array is its size (i.e. number of options).
		*/
		static const long cyc2x_dpmbase_options[] = {
		20,
		0xA0000, 0xA4000, 0xA8000, 0xAC000, 0xB0000, 0xB4000, 0xB8000,
		0xBC000, 0xC0000, 0xC4000, 0xC8000, 0xCC000, 0xD0000, 0xD4000,
		0xD8000, 0xDC000, 0xE0000, 0xE4000, 0xE8000, 0xEC000
		};

		static const long cycx_2x_irq_options[] = { 7, 3, 5, 9, 10, 11, 12, 15 };

		/* Kernel Loadable Module Entry Points */
		/* Module 'insert' entry point.
		* o print announcement
		* o initialize static data
		*
		* Return: 0 Ok
		* < 0 error.
		* Context: process */

		static int __init cycx_drv_init(void)
		{
		pr_info("%s v%u.%u %s\n",
		fullname, MOD_VERSION, MOD_RELEASE, copyright);

		return 0;
		}

		/* Module 'remove' entry point.
		* o release all remaining system resources */
		static void cycx_drv_cleanup(void)
		{
		}

		/* Kernel APIs */
		/* Set up adapter.
		* o detect adapter type
		* o verify hardware configuration options
		* o check for hardware conflicts
		* o set up adapter shared memory
		* o test adapter memory
		* o load firmware
		* Return: 0 ok.
		* < 0 error */
		EXPORT_SYMBOL(cycx_setup);
		int cycx_setup(struct cycx_hw hw, void cfm, u32 len, unsigned long dpmbase)
		{
		int err;

		/* Verify IRQ configuration options */
		if (!get_option_index(cycx_2x_irq_options, hw->irq)) {
		pr_err("IRQ %d is invalid!\n", hw->irq);
		return -EINVAL;
		}

		/* Setup adapter dual-port memory window and test memory */
		if (!dpmbase) {
		pr_err("you must specify the dpm address!\n");
		return -EINVAL;
		} else if (!get_option_index(cyc2x_dpmbase_options, dpmbase)) {
		pr_err("memory address 0x%lX is invalid!\n", dpmbase);
		return -EINVAL;
		}

		hw->dpmbase = ioremap(dpmbase, CYCX_WINDOWSIZE);
		hw->dpmsize = CYCX_WINDOWSIZE;

		if (!detect_cyc2x(hw->dpmbase)) {
		pr_err("adapter Cyclom 2X not found at address 0x%lX!\n",
		dpmbase);
		return -EINVAL;
		}

		pr_info("found Cyclom 2X card at address 0x%lX\n", dpmbase);

		/* Load firmware. If loader fails then shut down adapter */
		err = load_cyc2x(hw, cfm, len);

		if (err)
		cycx_down(hw); /* shutdown adapter */

		return err;
		}

		EXPORT_SYMBOL(cycx_down);
		int cycx_down(struct cycx_hw *hw)
		{
		iounmap(hw->dpmbase);
		return 0;
		}

		/* Enable interrupt generation. */
		static void cycx_inten(struct cycx_hw *hw)
		{
		writeb(0, hw->dpmbase);
		}

		/* Generate an interrupt to adapter's CPU. */
		EXPORT_SYMBOL(cycx_intr);
		void cycx_intr(struct cycx_hw *hw)
		{
		writew(0, hw->dpmbase + GEN_CYCX_INTR);
		}

		/* Execute Adapter Command.
		* o Set exec flag.
		* o Busy-wait until flag is reset. */
		EXPORT_SYMBOL(cycx_exec);
		int cycx_exec(void __iomem *addr)
		{
		u16 i = 0;
		/* wait till addr content is zeroed */

		while (readw(addr)) {
		udelay(1000);

		if (++i > 50)
		return -1;
		}

		return 0;
		}

		/* Read absolute adapter memory.
		* Transfer data from adapter's memory to data buffer. */
		EXPORT_SYMBOL(cycx_peek);
		int cycx_peek(struct cycx_hw hw, u32 addr, void buf, u32 len)
		{
		if (len == 1)
		(u8)buf = readb(hw->dpmbase + addr);
		else
		memcpy_fromio(buf, hw->dpmbase + addr, len);

		return 0;
		}

		/* Write Absolute Adapter Memory.
		* Transfer data from data buffer to adapter's memory. */
		EXPORT_SYMBOL(cycx_poke);
		int cycx_poke(struct cycx_hw hw, u32 addr, void buf, u32 len)
		{
		if (len == 1)
		writeb((u8)buf, hw->dpmbase + addr);
		else
		memcpy_toio(hw->dpmbase + addr, buf, len);

		return 0;
		}

		/* Hardware-Specific Functions */

		/* Load Aux Routines */
		/* Reset board hardware.
		return 1 if memory exists at addr and 0 if not. */
		static int memory_exists(void __iomem *addr)
		{
		int tries = 0;

		for (; tries < 3 ; tries++) {
		writew(TEST_PATTERN, addr + 0x10);

		if (readw(addr + 0x10) == TEST_PATTERN)
		if (readw(addr + 0x10) == TEST_PATTERN)
		return 1;

		msleep_interruptible(1 * 1000);
		}

		return 0;
		}

		/* Load reset code. */
		static void reset_load(void __iomem addr, u8 buffer, u32 cnt)
		{
		void __iomem *pt_code = addr + RESET_OFFSET;
		u16 i; /, j; /

		for (i = 0 ; i < cnt ; i++) {
		/* for (j = 0 ; j < 50 ; j++); Delay - FIXME busy waiting... */
		writeb(*buffer++, pt_code++);
		}
		}

		/* Load buffer using boot interface.
		* o copy data from buffer to Cyclom-X memory
		* o wait for reset code to copy it to right portion of memory */
		static int buffer_load(void __iomem addr, u8 buffer, u32 cnt)
		{
		memcpy_toio(addr + DATA_OFFSET, buffer, cnt);
		writew(GEN_BOOT_DAT, addr + CMD_OFFSET);

		return wait_cyc(addr);
		}

		/* Set up entry point and kick start Cyclom-X CPU. */
		static void cycx_start(void __iomem *addr)
		{
		/* put in 0x30 offset the jump instruction to the code entry point */
		writeb(0xea, addr + 0x30);
		writeb(0x00, addr + 0x31);
		writeb(0xc4, addr + 0x32);
		writeb(0x00, addr + 0x33);
		writeb(0x00, addr + 0x34);

		/* cmd to start executing code */
		writew(GEN_START, addr + CMD_OFFSET);
		}

		/* Load and boot reset code. */
		static void cycx_reset_boot(void __iomem addr, u8 code, u32 len)
		{
		void __iomem *pt_start = addr + START_OFFSET;

		writeb(0xea, pt_start++); /* jmp to f000:3f00 */
		writeb(0x00, pt_start++);
		writeb(0xfc, pt_start++);
		writeb(0x00, pt_start++);
		writeb(0xf0, pt_start);
		reset_load(addr, code, len);

		/* 80186 was in hold, go */
		writeb(0, addr + START_CPU);
		msleep_interruptible(1 * 1000);
		}

		/* Load data.bin file through boot (reset) interface. */
		static int cycx_data_boot(void __iomem addr, u8 code, u32 len)
		{
		void __iomem *pt_boot_cmd = addr + CMD_OFFSET;
		u32 i;

		/* boot buffer length */
		writew(CFM_LOAD_BUFSZ, pt_boot_cmd + sizeof(u16));
		writew(GEN_DEFPAR, pt_boot_cmd);

		if (wait_cyc(addr) < 0)
		return -1;

		writew(0, pt_boot_cmd + sizeof(u16));
		writew(0x4000, pt_boot_cmd + 2 * sizeof(u16));
		writew(GEN_SET_SEG, pt_boot_cmd);

		if (wait_cyc(addr) < 0)
		return -1;

		for (i = 0 ; i < len ; i += CFM_LOAD_BUFSZ)
		if (buffer_load(addr, code + i,
		min_t(u32, CFM_LOAD_BUFSZ, (len - i))) < 0) {
		pr_err("Error !!\n");
		return -1;
		}

		return 0;
		}


		/* Load code.bin file through boot (reset) interface. */
		static int cycx_code_boot(void __iomem addr, u8 code, u32 len)
		{
		void __iomem *pt_boot_cmd = addr + CMD_OFFSET;
		u32 i;

		/* boot buffer length */
		writew(CFM_LOAD_BUFSZ, pt_boot_cmd + sizeof(u16));
		writew(GEN_DEFPAR, pt_boot_cmd);

		if (wait_cyc(addr) < 0)
		return -1;

		writew(0x0000, pt_boot_cmd + sizeof(u16));
		writew(0xc400, pt_boot_cmd + 2 * sizeof(u16));
		writew(GEN_SET_SEG, pt_boot_cmd);

		if (wait_cyc(addr) < 0)
		return -1;

		for (i = 0 ; i < len ; i += CFM_LOAD_BUFSZ)
		if (buffer_load(addr, code + i,
		min_t(u32, CFM_LOAD_BUFSZ, (len - i)))) {
		pr_err("Error !!\n");
		return -1;
		}

		return 0;
		}

		/* Load adapter from the memory image of the CYCX firmware module.
		* o verify firmware integrity and compatibility
		* o start adapter up */
		static int load_cyc2x(struct cycx_hw hw, struct cycx_firmware cfm, u32 len)
		{
		int i, j;
		struct cycx_fw_header *img_hdr;
		u8 *reset_image,
		*data_image,
		*code_image;
		void __iomem *pt_cycld = hw->dpmbase + 0x400;
		u16 cksum;

		/* Announce */
		pr_info("firmware signature=\"%s\"\n", cfm->signature);

		/* Verify firmware signature */
		if (strcmp(cfm->signature, CFM_SIGNATURE)) {
		pr_err("load_cyc2x: not Cyclom-2X firmware!\n");
		return -EINVAL;
		}

		pr_info("firmware version=%u\n", cfm->version);

		/* Verify firmware module format version */
		if (cfm->version != CFM_VERSION) {
		pr_err("%s: firmware format %u rejected! Expecting %u.\n",
		__func__, cfm->version, CFM_VERSION);
		return -EINVAL;
		}

		/* Verify firmware module length and checksum */
		cksum = checksum((u8*)&cfm->info, sizeof(struct cycx_fw_info) +
		cfm->info.codesize);
		/*
		FIXME cfm->info.codesize is off by 2
		if (((len - sizeof(struct cycx_firmware) - 1) != cfm->info.codesize) \|\|
		*/
		if (cksum != cfm->checksum) {
		pr_err("%s: firmware corrupted!\n", __func__);
		pr_err(" cdsize = 0x%x (expected 0x%lx)\n",
		len - (int)sizeof(struct cycx_firmware) - 1,
		cfm->info.codesize);
		pr_err(" chksum = 0x%x (expected 0x%x)\n",
		cksum, cfm->checksum);
		return -EINVAL;
		}

		/* If everything is ok, set reset, data and code pointers */
		img_hdr = (struct cycx_fw_header *)&cfm->image;
		#ifdef FIRMWARE_DEBUG
		pr_info("%s: image sizes\n", __func__);
		pr_info(" reset=%lu\n", img_hdr->reset_size);
		pr_info(" data=%lu\n", img_hdr->data_size);
		pr_info(" code=%lu\n", img_hdr->code_size);
		#endif
		reset_image = ((u8 *)img_hdr) + sizeof(struct cycx_fw_header);
		data_image = reset_image + img_hdr->reset_size;
		code_image = data_image + img_hdr->data_size;

		/---- Start load ----/
		/* Announce */
		pr_info("loading firmware %s (ID=%u)...\n",
		cfm->descr[0] ? cfm->descr : "unknown firmware",
		cfm->info.codeid);

		for (i = 0 ; i < 5 ; i++) {
		/* Reset Cyclom hardware */
		if (!reset_cyc2x(hw->dpmbase)) {
		pr_err("dpm problem or board not found\n");
		return -EINVAL;
		}

		/* Load reset.bin */
		cycx_reset_boot(hw->dpmbase, reset_image, img_hdr->reset_size);
		/* reset is waiting for boot */
		writew(GEN_POWER_ON, pt_cycld);
		msleep_interruptible(1 * 1000);

		for (j = 0 ; j < 3 ; j++)
		if (!readw(pt_cycld))
		goto reset_loaded;
		else
		msleep_interruptible(1 * 1000);
		}

		pr_err("reset not started\n");
		return -EINVAL;

		reset_loaded:
		/* Load data.bin */
		if (cycx_data_boot(hw->dpmbase, data_image, img_hdr->data_size)) {
		pr_err("cannot load data file\n");
		return -EINVAL;
		}

		/* Load code.bin */
		if (cycx_code_boot(hw->dpmbase, code_image, img_hdr->code_size)) {
		pr_err("cannot load code file\n");
		return -EINVAL;
		}

		/* Prepare boot-time configuration data */
		cycx_bootcfg(hw);

		/* kick-off CPU */
		cycx_start(hw->dpmbase);

		/* Arthur Ganzert's tip: wait a while after the firmware loading...
		seg abr 26 17:17:12 EST 1999 - acme */
		msleep_interruptible(7 * 1000);
		pr_info("firmware loaded!\n");

		/* enable interrupts */
		cycx_inten(hw);

		return 0;
		}

		/* Prepare boot-time firmware configuration data.
		* o initialize configuration data area
		From async.doc - V_3.4.0 - 07/18/1994
		- As of now, only static buffers are available to the user.
		So, the bit VD_RXDIRC must be set in 'valid'. That means that user
		wants to use the static transmission and reception buffers. */
		static void cycx_bootcfg(struct cycx_hw *hw)
		{
		/* use fixed buffers */
		writeb(FIXED_BUFFERS, hw->dpmbase + CONF_OFFSET);
		}

		/* Detect Cyclom 2x adapter.
		* Following tests are used to detect Cyclom 2x adapter:
		* to be completed based on the tests done below
		* Return 1 if detected o.k. or 0 if failed.
		* Note: This test is destructive! Adapter will be left in shutdown
		* state after the test. */
		static int detect_cyc2x(void __iomem *addr)
		{
		reset_cyc2x(addr);

		return memory_exists(addr);
		}

		/* Miscellaneous */
		/* Get option's index into the options list.
		* Return option's index (1 .. N) or zero if option is invalid. */
		static int get_option_index(const long *optlist, long optval)
		{
		int i = 1;

		for (; i <= optlist[0]; ++i)
		if (optlist[i] == optval)
		return i;

		return 0;
		}

		/* Reset adapter's CPU. */
		static int reset_cyc2x(void __iomem *addr)
		{
		writeb(0, addr + RST_ENABLE);
		msleep_interruptible(2 * 1000);
		writeb(0, addr + RST_DISABLE);
		msleep_interruptible(2 * 1000);

		return memory_exists(addr);
		}

		/* Calculate 16-bit CRC using CCITT polynomial. */
		static u16 checksum(u8 *buf, u32 len)
		{
		u16 crc = 0;
		u16 mask, flag;

		for (; len; --len, ++buf)
		for (mask = 0x80; mask; mask >>= 1) {
		flag = (crc & 0x8000);
		crc <<= 1;
		crc \|= ((*buf & mask) ? 1 : 0);

		if (flag)
		crc ^= 0x1021;
		}

		return crc;
		}

		module_init(cycx_drv_init);
		module_exit(cycx_drv_cleanup);

		/* End */

drivers/net/wan/cycx_main.c

deleted100644 → 0

+0 −346

Original line number	Diff line number	Diff line
		/*
		* cycx_main.c Cyclades Cyclom 2X WAN Link Driver. Main module.
		*
		* Author: Arnaldo Carvalho de Melo <acme@conectiva.com.br>
		*
		* Copyright: (c) 1998-2003 Arnaldo Carvalho de Melo
		*
		* Based on sdlamain.c by Gene Kozin <genek@compuserve.com> &
		* Jaspreet Singh <jaspreet@sangoma.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.
		* ============================================================================
		* Please look at the bitkeeper changelog (or any other scm tool that ends up
		* importing bitkeeper changelog or that replaces bitkeeper in the future as
		* main tool for linux development).
		*
		* 2001/05/09 acme Fix MODULE_DESC for debug, .bss nitpicks,
		* some cleanups
		* 2000/07/13 acme remove useless #ifdef MODULE and crap
		* #if KERNEL_VERSION > blah
		* 2000/07/06 acme __exit at cyclomx_cleanup
		* 2000/04/02 acme dprintk and cycx_debug
		* module_init/module_exit
		* 2000/01/21 acme rename cyclomx_open to cyclomx_mod_inc_use_count
		* and cyclomx_close to cyclomx_mod_dec_use_count
		* 2000/01/08 acme cleanup
		* 1999/11/06 acme cycx_down back to life (it needs to be
		* called to iounmap the dpmbase)
		* 1999/08/09 acme removed references to enable_tx_int
		* use spinlocks instead of cli/sti in
		* cyclomx_set_state
		* 1999/05/19 acme works directly linked into the kernel
		* init_waitqueue_head for 2.3.* kernel
		* 1999/05/18 acme major cleanup (polling not needed), etc
		* 1998/08/28 acme minor cleanup (ioctls for firmware deleted)
		* queue_task activated
		* 1998/08/08 acme Initial version.
		*/

		#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

		#include <linux/stddef.h> /* offsetof(), etc. */
		#include <linux/errno.h> /* return codes */
		#include <linux/string.h> /* inline memset(), etc. */
		#include <linux/slab.h> /* kmalloc(), kfree() */
		#include <linux/kernel.h> /* printk(), and other useful stuff */
		#include <linux/module.h> /* support for loadable modules */
		#include <linux/ioport.h> /* request_region(), release_region() */
		#include <linux/wanrouter.h> /* WAN router definitions */
		#include <linux/cyclomx.h> /* cyclomx common user API definitions */
		#include <linux/init.h> /* __init (when not using as a module) */
		#include <linux/interrupt.h>

		unsigned int cycx_debug;

		MODULE_AUTHOR("Arnaldo Carvalho de Melo");
		MODULE_DESCRIPTION("Cyclom 2X Sync Card Driver.");
		MODULE_LICENSE("GPL");
		module_param(cycx_debug, int, 0);
		MODULE_PARM_DESC(cycx_debug, "cyclomx debug level");

		/* Defines & Macros */

		#define CYCX_DRV_VERSION 0 /* version number */
		#define CYCX_DRV_RELEASE 11 /* release (minor version) number */
		#define CYCX_MAX_CARDS 1 /* max number of adapters */

		#define CONFIG_CYCX_CARDS 1

		/* Function Prototypes */

		/* WAN link driver entry points */
		static int cycx_wan_setup(struct wan_device wandev, wandev_conf_t conf);
		static int cycx_wan_shutdown(struct wan_device *wandev);

		/* Miscellaneous functions */
		static irqreturn_t cycx_isr(int irq, void *dev_id);

		/* Global Data
		* Note: All data must be explicitly initialized!!!
		*/

		/* private data */
		static const char cycx_drvname[] = "cyclomx";
		static const char cycx_fullname[] = "CYCLOM 2X(tm) Sync Card Driver";
		static const char cycx_copyright[] = "(c) 1998-2003 Arnaldo Carvalho de Melo "
		"<acme@conectiva.com.br>";
		static int cycx_ncards = CONFIG_CYCX_CARDS;
		static struct cycx_device cycx_card_array; / adapter data space */

		/* Kernel Loadable Module Entry Points */

		/*
		* Module 'insert' entry point.
		* o print announcement
		* o allocate adapter data space
		* o initialize static data
		* o register all cards with WAN router
		* o calibrate Cyclom 2X shared memory access delay.
		*
		* Return: 0 Ok
		* < 0 error.
		* Context: process
		*/
		static int __init cycx_init(void)
		{
		int cnt, err = -ENOMEM;

		pr_info("%s v%u.%u %s\n",
		cycx_fullname, CYCX_DRV_VERSION, CYCX_DRV_RELEASE,
		cycx_copyright);

		/* Verify number of cards and allocate adapter data space */
		cycx_ncards = min_t(int, cycx_ncards, CYCX_MAX_CARDS);
		cycx_ncards = max_t(int, cycx_ncards, 1);
		cycx_card_array = kcalloc(cycx_ncards, sizeof(struct cycx_device), GFP_KERNEL);
		if (!cycx_card_array)
		goto out;


		/* Register adapters with WAN router */
		for (cnt = 0; cnt < cycx_ncards; ++cnt) {
		struct cycx_device *card = &cycx_card_array[cnt];
		struct wan_device *wandev = &card->wandev;

		sprintf(card->devname, "%s%d", cycx_drvname, cnt + 1);
		wandev->magic = ROUTER_MAGIC;
		wandev->name = card->devname;
		wandev->private = card;
		wandev->setup = cycx_wan_setup;
		wandev->shutdown = cycx_wan_shutdown;
		err = register_wan_device(wandev);

		if (err) {
		pr_err("%s registration failed with error %d!\n",
		card->devname, err);
		break;
		}
		}

		err = -ENODEV;
		if (!cnt) {
		kfree(cycx_card_array);
		goto out;
		}
		err = 0;
		cycx_ncards = cnt; /* adjust actual number of cards */
		out: return err;
		}

		/*
		* Module 'remove' entry point.
		* o unregister all adapters from the WAN router
		* o release all remaining system resources
		*/
		static void __exit cycx_exit(void)
		{
		int i = 0;

		for (; i < cycx_ncards; ++i) {
		struct cycx_device *card = &cycx_card_array[i];
		unregister_wan_device(card->devname);
		}

		kfree(cycx_card_array);
		}

		/* WAN Device Driver Entry Points */
		/*
		* Setup/configure WAN link driver.
		* o check adapter state
		* o make sure firmware is present in configuration
		* o allocate interrupt vector
		* o setup Cyclom 2X hardware
		* o call appropriate routine to perform protocol-specific initialization
		*
		* This function is called when router handles ROUTER_SETUP IOCTL. The
		* configuration structure is in kernel memory (including extended data, if
		* any).
		*/
		static int cycx_wan_setup(struct wan_device wandev, wandev_conf_t conf)
		{
		int rc = -EFAULT;
		struct cycx_device *card;
		int irq;

		/* Sanity checks */

		if (!wandev \|\| !wandev->private \|\| !conf)
		goto out;

		card = wandev->private;
		rc = -EBUSY;
		if (wandev->state != WAN_UNCONFIGURED)
		goto out;

		rc = -EINVAL;
		if (!conf->data_size \|\| !conf->data) {
		pr_err("%s: firmware not found in configuration data!\n",
		wandev->name);
		goto out;
		}

		if (conf->irq <= 0) {
		pr_err("%s: can't configure without IRQ!\n", wandev->name);
		goto out;
		}

		/* Allocate IRQ */
		irq = conf->irq == 2 ? 9 : conf->irq; /* IRQ2 -> IRQ9 */

		if (request_irq(irq, cycx_isr, 0, wandev->name, card)) {
		pr_err("%s: can't reserve IRQ %d!\n", wandev->name, irq);
		goto out;
		}

		/* Configure hardware, load firmware, etc. */
		memset(&card->hw, 0, sizeof(card->hw));
		card->hw.irq = irq;
		card->hw.dpmsize = CYCX_WINDOWSIZE;
		card->hw.fwid = CFID_X25_2X;
		spin_lock_init(&card->lock);
		init_waitqueue_head(&card->wait_stats);

		rc = cycx_setup(&card->hw, conf->data, conf->data_size, conf->maddr);
		if (rc)
		goto out_irq;

		/* Initialize WAN device data space */
		wandev->irq = irq;
		wandev->dma = wandev->ioport = 0;
		wandev->maddr = (unsigned long)card->hw.dpmbase;
		wandev->msize = card->hw.dpmsize;
		wandev->hw_opt[2] = 0;
		wandev->hw_opt[3] = card->hw.fwid;

		/* Protocol-specific initialization */
		switch (card->hw.fwid) {
		#ifdef CONFIG_CYCLOMX_X25
		case CFID_X25_2X:
		rc = cycx_x25_wan_init(card, conf);
		break;
		#endif
		default:
		pr_err("%s: this firmware is not supported!\n", wandev->name);
		rc = -EINVAL;
		}

		if (rc) {
		cycx_down(&card->hw);
		goto out_irq;
		}

		rc = 0;
		out:
		return rc;
		out_irq:
		free_irq(irq, card);
		goto out;
		}

		/*
		* Shut down WAN link driver.
		* o shut down adapter hardware
		* o release system resources.
		*
		* This function is called by the router when device is being unregistered or
		* when it handles ROUTER_DOWN IOCTL.
		*/
		static int cycx_wan_shutdown(struct wan_device *wandev)
		{
		int ret = -EFAULT;
		struct cycx_device *card;

		/* sanity checks */
		if (!wandev \|\| !wandev->private)
		goto out;

		ret = 0;
		if (wandev->state == WAN_UNCONFIGURED)
		goto out;

		card = wandev->private;
		wandev->state = WAN_UNCONFIGURED;
		cycx_down(&card->hw);
		pr_info("%s: irq %d being freed!\n", wandev->name, wandev->irq);
		free_irq(wandev->irq, card);
		out: return ret;
		}

		/* Miscellaneous */
		/*
		* Cyclom 2X Interrupt Service Routine.
		* o acknowledge Cyclom 2X hardware interrupt.
		* o call protocol-specific interrupt service routine, if any.
		*/
		static irqreturn_t cycx_isr(int irq, void *dev_id)
		{
		struct cycx_device *card = dev_id;

		if (card->wandev.state == WAN_UNCONFIGURED)
		goto out;

		if (card->in_isr) {
		pr_warn("%s: interrupt re-entrancy on IRQ %d!\n",
		card->devname, card->wandev.irq);
		goto out;
		}

		if (card->isr)
		card->isr(card);
		return IRQ_HANDLED;
		out:
		return IRQ_NONE;
		}

		/* Set WAN device state. */
		void cycx_set_state(struct cycx_device *card, int state)
		{
		unsigned long flags;
		char *string_state = NULL;

		spin_lock_irqsave(&card->lock, flags);

		if (card->wandev.state != state) {
		switch (state) {
		case WAN_CONNECTED:
		string_state = "connected!";
		break;
		case WAN_DISCONNECTED:
		string_state = "disconnected!";
		break;
		}
		pr_info("%s: link %s\n", card->devname, string_state);
		card->wandev.state = state;
		}

		card->state_tick = jiffies;
		spin_unlock_irqrestore(&card->lock, flags);
		}

		module_init(cycx_init);
		module_exit(cycx_exit);

drivers/net/wan/cycx_x25.c

deleted100644 → 0

+0 −1602

File deleted.

Preview size limit exceeded, changes collapsed.

include/linux/cyclomx.h

deleted100644 → 0

+0 −77

File deleted.

Preview size limit exceeded, changes collapsed.

include/linux/cycx_drv.h

deleted100644 → 0

+0 −64

File deleted.

Preview size limit exceeded, changes collapsed.