mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-23 12:43:55 +08:00
cd354f1ae7
After Al Viro (finally) succeeded in removing the sched.h #include in module.h recently, it makes sense again to remove other superfluous sched.h includes. There are quite a lot of files which include it but don't actually need anything defined in there. Presumably these includes were once needed for macros that used to live in sched.h, but moved to other header files in the course of cleaning it up. To ease the pain, this time I did not fiddle with any header files and only removed #includes from .c-files, which tend to cause less trouble. Compile tested against 2.6.20-rc2 and 2.6.20-rc2-mm2 (with offsets) on alpha, arm, i386, ia64, mips, powerpc, and x86_64 with allnoconfig, defconfig, allmodconfig, and allyesconfig as well as a few randconfigs on x86_64 and all configs in arch/arm/configs on arm. I also checked that no new warnings were introduced by the patch (actually, some warnings are removed that were emitted by unnecessarily included header files). Signed-off-by: Tim Schmielau <tim@physik3.uni-rostock.de> Acked-by: Russell King <rmk+kernel@arm.linux.org.uk> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
577 lines
15 KiB
C
577 lines
15 KiB
C
/*
|
|
* 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.
|
|
*/
|
|
|
|
#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(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 char modname[] = "cycx_drv";
|
|
static char fullname[] = "Cyclom 2X Support Module";
|
|
static 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 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 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)
|
|
{
|
|
printk(KERN_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)) {
|
|
printk(KERN_ERR "%s: IRQ %d is invalid!\n", modname, hw->irq);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Setup adapter dual-port memory window and test memory */
|
|
if (!dpmbase) {
|
|
printk(KERN_ERR "%s: you must specify the dpm address!\n",
|
|
modname);
|
|
return -EINVAL;
|
|
} else if (!get_option_index(cyc2x_dpmbase_options, dpmbase)) {
|
|
printk(KERN_ERR "%s: memory address 0x%lX is invalid!\n",
|
|
modname, dpmbase);
|
|
return -EINVAL;
|
|
}
|
|
|
|
hw->dpmbase = ioremap(dpmbase, CYCX_WINDOWSIZE);
|
|
hw->dpmsize = CYCX_WINDOWSIZE;
|
|
|
|
if (!detect_cyc2x(hw->dpmbase)) {
|
|
printk(KERN_ERR "%s: adapter Cyclom 2X not found at "
|
|
"address 0x%lX!\n", modname, dpmbase);
|
|
return -EINVAL;
|
|
}
|
|
|
|
printk(KERN_INFO "%s: found Cyclom 2X card at address 0x%lX.\n",
|
|
modname, 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 lenght */
|
|
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) {
|
|
printk(KERN_ERR "%s: Error !!\n", modname);
|
|
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 lenght */
|
|
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)))) {
|
|
printk(KERN_ERR "%s: Error !!\n", modname);
|
|
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 */
|
|
printk(KERN_INFO "%s: firmware signature=\"%s\"\n", modname,
|
|
cfm->signature);
|
|
|
|
/* Verify firmware signature */
|
|
if (strcmp(cfm->signature, CFM_SIGNATURE)) {
|
|
printk(KERN_ERR "%s:load_cyc2x: not Cyclom-2X firmware!\n",
|
|
modname);
|
|
return -EINVAL;
|
|
}
|
|
|
|
printk(KERN_INFO "%s: firmware version=%u\n", modname, cfm->version);
|
|
|
|
/* Verify firmware module format version */
|
|
if (cfm->version != CFM_VERSION) {
|
|
printk(KERN_ERR "%s:%s: firmware format %u rejected! "
|
|
"Expecting %u.\n",
|
|
modname, __FUNCTION__, 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) {
|
|
printk(KERN_ERR "%s:%s: firmware corrupted!\n",
|
|
modname, __FUNCTION__);
|
|
printk(KERN_ERR " cdsize = 0x%x (expected 0x%lx)\n",
|
|
len - (int)sizeof(struct cycx_firmware) - 1,
|
|
cfm->info.codesize);
|
|
printk(KERN_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
|
|
printk(KERN_INFO "%s:%s: image sizes\n", __FUNCTION__, modname);
|
|
printk(KERN_INFO " reset=%lu\n", img_hdr->reset_size);
|
|
printk(KERN_INFO " data=%lu\n", img_hdr->data_size);
|
|
printk(KERN_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 */
|
|
printk(KERN_INFO "%s: loading firmware %s (ID=%u)...\n", modname,
|
|
cfm->descr[0] ? cfm->descr : "unknown firmware",
|
|
cfm->info.codeid);
|
|
|
|
for (i = 0 ; i < 5 ; i++) {
|
|
/* Reset Cyclom hardware */
|
|
if (!reset_cyc2x(hw->dpmbase)) {
|
|
printk(KERN_ERR "%s: dpm problem or board not found\n",
|
|
modname);
|
|
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);
|
|
}
|
|
|
|
printk(KERN_ERR "%s: reset not started.\n", modname);
|
|
return -EINVAL;
|
|
|
|
reset_loaded:
|
|
/* Load data.bin */
|
|
if (cycx_data_boot(hw->dpmbase, data_image, img_hdr->data_size)) {
|
|
printk(KERN_ERR "%s: cannot load data file.\n", modname);
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Load code.bin */
|
|
if (cycx_code_boot(hw->dpmbase, code_image, img_hdr->code_size)) {
|
|
printk(KERN_ERR "%s: cannot load code file.\n", modname);
|
|
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);
|
|
printk(KERN_INFO "%s: firmware loaded!\n", modname);
|
|
|
|
/* 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(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 */
|