Subversion Repositories test_project

/*

* 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 */