Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * cycx_drv.c Cyclom 2X Support Module. |
| 3 | * |
| 4 | * This module is a library of common hardware specific |
| 5 | * functions used by the Cyclades Cyclom 2X sync card. |
| 6 | * |
| 7 | * Author: Arnaldo Carvalho de Melo <acme@conectiva.com.br> |
| 8 | * |
| 9 | * Copyright: (c) 1998-2003 Arnaldo Carvalho de Melo |
| 10 | * |
| 11 | * Based on sdladrv.c by Gene Kozin <genek@compuserve.com> |
| 12 | * |
| 13 | * This program is free software; you can redistribute it and/or |
| 14 | * modify it under the terms of the GNU General Public License |
| 15 | * as published by the Free Software Foundation; either version |
| 16 | * 2 of the License, or (at your option) any later version. |
| 17 | * ============================================================================ |
| 18 | * 1999/11/11 acme set_current_state(TASK_INTERRUPTIBLE), code |
| 19 | * cleanup |
| 20 | * 1999/11/08 acme init_cyc2x deleted, doing nothing |
| 21 | * 1999/11/06 acme back to read[bw], write[bw] and memcpy_to and |
| 22 | * fromio to use dpmbase ioremaped |
| 23 | * 1999/10/26 acme use isa_read[bw], isa_write[bw] & isa_memcpy_to |
| 24 | * & fromio |
| 25 | * 1999/10/23 acme cleanup to only supports cyclom2x: all the other |
| 26 | * boards are no longer manufactured by cyclades, |
| 27 | * if someone wants to support them... be my guest! |
| 28 | * 1999/05/28 acme cycx_intack & cycx_intde gone for good |
| 29 | * 1999/05/18 acme lots of unlogged work, submitting to Linus... |
| 30 | * 1999/01/03 acme more judicious use of data types |
| 31 | * 1999/01/03 acme judicious use of data types :> |
| 32 | * cycx_inten trying to reset pending interrupts |
| 33 | * from cyclom 2x - I think this isn't the way to |
| 34 | * go, but for now... |
| 35 | * 1999/01/02 acme cycx_intack ok, I think there's nothing to do |
| 36 | * to ack an int in cycx_drv.c, only handle it in |
| 37 | * cyx_isr (or in the other protocols: cyp_isr, |
| 38 | * cyf_isr, when they get implemented. |
| 39 | * Dec 31, 1998 acme cycx_data_boot & cycx_code_boot fixed, crossing |
| 40 | * fingers to see x25_configure in cycx_x25.c |
| 41 | * work... :) |
| 42 | * Dec 26, 1998 acme load implementation fixed, seems to work! :) |
| 43 | * cycx_2x_dpmbase_options with all the possible |
| 44 | * DPM addresses (20). |
| 45 | * cycx_intr implemented (test this!) |
| 46 | * general code cleanup |
| 47 | * Dec 8, 1998 Ivan Passos Cyclom-2X firmware load implementation. |
| 48 | * Aug 8, 1998 acme Initial version. |
| 49 | */ |
| 50 | |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 51 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
| 52 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | #include <linux/init.h> /* __init */ |
| 54 | #include <linux/module.h> |
| 55 | #include <linux/kernel.h> /* printk(), and other useful stuff */ |
| 56 | #include <linux/stddef.h> /* offsetof(), etc. */ |
| 57 | #include <linux/errno.h> /* return codes */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | #include <linux/cycx_drv.h> /* API definitions */ |
| 59 | #include <linux/cycx_cfm.h> /* CYCX firmware module definitions */ |
Nishanth Aravamudan | a51d744 | 2005-06-27 09:20:04 -0700 | [diff] [blame] | 60 | #include <linux/delay.h> /* udelay, msleep_interruptible */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | #include <asm/io.h> /* read[wl], write[wl], ioremap, iounmap */ |
| 62 | |
| 63 | #define MOD_VERSION 0 |
| 64 | #define MOD_RELEASE 6 |
| 65 | |
| 66 | MODULE_AUTHOR("Arnaldo Carvalho de Melo"); |
| 67 | MODULE_DESCRIPTION("Cyclom 2x Sync Card Driver"); |
| 68 | MODULE_LICENSE("GPL"); |
| 69 | |
| 70 | /* Hardware-specific functions */ |
| 71 | static int load_cyc2x(struct cycx_hw *hw, struct cycx_firmware *cfm, u32 len); |
| 72 | static void cycx_bootcfg(struct cycx_hw *hw); |
| 73 | |
| 74 | static int reset_cyc2x(void __iomem *addr); |
| 75 | static int detect_cyc2x(void __iomem *addr); |
| 76 | |
| 77 | /* Miscellaneous functions */ |
stephen hemminger | dcfc5d7 | 2010-09-02 14:29:35 +0000 | [diff] [blame] | 78 | static int get_option_index(const long *optlist, long optval); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | static u16 checksum(u8 *buf, u32 len); |
| 80 | |
| 81 | #define wait_cyc(addr) cycx_exec(addr + CMD_OFFSET) |
| 82 | |
| 83 | /* Global Data */ |
| 84 | |
| 85 | /* private data */ |
stephen hemminger | dcfc5d7 | 2010-09-02 14:29:35 +0000 | [diff] [blame] | 86 | static const char fullname[] = "Cyclom 2X Support Module"; |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 87 | static const char copyright[] = |
| 88 | "(c) 1998-2003 Arnaldo Carvalho de Melo <acme@conectiva.com.br>"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 89 | |
| 90 | /* Hardware configuration options. |
| 91 | * These are arrays of configuration options used by verification routines. |
| 92 | * The first element of each array is its size (i.e. number of options). |
| 93 | */ |
stephen hemminger | dcfc5d7 | 2010-09-02 14:29:35 +0000 | [diff] [blame] | 94 | static const long cyc2x_dpmbase_options[] = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | 20, |
| 96 | 0xA0000, 0xA4000, 0xA8000, 0xAC000, 0xB0000, 0xB4000, 0xB8000, |
| 97 | 0xBC000, 0xC0000, 0xC4000, 0xC8000, 0xCC000, 0xD0000, 0xD4000, |
| 98 | 0xD8000, 0xDC000, 0xE0000, 0xE4000, 0xE8000, 0xEC000 |
| 99 | }; |
| 100 | |
stephen hemminger | dcfc5d7 | 2010-09-02 14:29:35 +0000 | [diff] [blame] | 101 | static const long cycx_2x_irq_options[] = { 7, 3, 5, 9, 10, 11, 12, 15 }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | |
| 103 | /* Kernel Loadable Module Entry Points */ |
| 104 | /* Module 'insert' entry point. |
| 105 | * o print announcement |
| 106 | * o initialize static data |
| 107 | * |
| 108 | * Return: 0 Ok |
| 109 | * < 0 error. |
| 110 | * Context: process */ |
| 111 | |
Adrian Bunk | 7665a08 | 2005-09-09 23:17:28 -0700 | [diff] [blame] | 112 | static int __init cycx_drv_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 114 | pr_info("%s v%u.%u %s\n", |
| 115 | fullname, MOD_VERSION, MOD_RELEASE, copyright); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | |
| 117 | return 0; |
| 118 | } |
| 119 | |
| 120 | /* Module 'remove' entry point. |
| 121 | * o release all remaining system resources */ |
Adrian Bunk | 7665a08 | 2005-09-09 23:17:28 -0700 | [diff] [blame] | 122 | static void cycx_drv_cleanup(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 123 | { |
| 124 | } |
| 125 | |
| 126 | /* Kernel APIs */ |
| 127 | /* Set up adapter. |
| 128 | * o detect adapter type |
| 129 | * o verify hardware configuration options |
| 130 | * o check for hardware conflicts |
| 131 | * o set up adapter shared memory |
| 132 | * o test adapter memory |
| 133 | * o load firmware |
| 134 | * Return: 0 ok. |
| 135 | * < 0 error */ |
| 136 | EXPORT_SYMBOL(cycx_setup); |
| 137 | int cycx_setup(struct cycx_hw *hw, void *cfm, u32 len, unsigned long dpmbase) |
| 138 | { |
| 139 | int err; |
| 140 | |
| 141 | /* Verify IRQ configuration options */ |
| 142 | if (!get_option_index(cycx_2x_irq_options, hw->irq)) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 143 | pr_err("IRQ %d is invalid!\n", hw->irq); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | return -EINVAL; |
| 145 | } |
| 146 | |
| 147 | /* Setup adapter dual-port memory window and test memory */ |
| 148 | if (!dpmbase) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 149 | pr_err("you must specify the dpm address!\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | return -EINVAL; |
| 151 | } else if (!get_option_index(cyc2x_dpmbase_options, dpmbase)) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 152 | pr_err("memory address 0x%lX is invalid!\n", dpmbase); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 153 | return -EINVAL; |
| 154 | } |
| 155 | |
| 156 | hw->dpmbase = ioremap(dpmbase, CYCX_WINDOWSIZE); |
| 157 | hw->dpmsize = CYCX_WINDOWSIZE; |
| 158 | |
| 159 | if (!detect_cyc2x(hw->dpmbase)) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 160 | pr_err("adapter Cyclom 2X not found at address 0x%lX!\n", |
| 161 | dpmbase); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 162 | return -EINVAL; |
| 163 | } |
| 164 | |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 165 | pr_info("found Cyclom 2X card at address 0x%lX\n", dpmbase); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | |
| 167 | /* Load firmware. If loader fails then shut down adapter */ |
| 168 | err = load_cyc2x(hw, cfm, len); |
| 169 | |
| 170 | if (err) |
| 171 | cycx_down(hw); /* shutdown adapter */ |
| 172 | |
| 173 | return err; |
| 174 | } |
| 175 | |
| 176 | EXPORT_SYMBOL(cycx_down); |
| 177 | int cycx_down(struct cycx_hw *hw) |
| 178 | { |
| 179 | iounmap(hw->dpmbase); |
| 180 | return 0; |
| 181 | } |
| 182 | |
| 183 | /* Enable interrupt generation. */ |
Adrian Bunk | 7665a08 | 2005-09-09 23:17:28 -0700 | [diff] [blame] | 184 | static void cycx_inten(struct cycx_hw *hw) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | { |
| 186 | writeb(0, hw->dpmbase); |
| 187 | } |
| 188 | |
| 189 | /* Generate an interrupt to adapter's CPU. */ |
| 190 | EXPORT_SYMBOL(cycx_intr); |
| 191 | void cycx_intr(struct cycx_hw *hw) |
| 192 | { |
| 193 | writew(0, hw->dpmbase + GEN_CYCX_INTR); |
| 194 | } |
| 195 | |
| 196 | /* Execute Adapter Command. |
| 197 | * o Set exec flag. |
| 198 | * o Busy-wait until flag is reset. */ |
| 199 | EXPORT_SYMBOL(cycx_exec); |
| 200 | int cycx_exec(void __iomem *addr) |
| 201 | { |
| 202 | u16 i = 0; |
| 203 | /* wait till addr content is zeroed */ |
| 204 | |
| 205 | while (readw(addr)) { |
| 206 | udelay(1000); |
| 207 | |
| 208 | if (++i > 50) |
| 209 | return -1; |
| 210 | } |
| 211 | |
| 212 | return 0; |
| 213 | } |
| 214 | |
| 215 | /* Read absolute adapter memory. |
| 216 | * Transfer data from adapter's memory to data buffer. */ |
| 217 | EXPORT_SYMBOL(cycx_peek); |
| 218 | int cycx_peek(struct cycx_hw *hw, u32 addr, void *buf, u32 len) |
| 219 | { |
| 220 | if (len == 1) |
| 221 | *(u8*)buf = readb(hw->dpmbase + addr); |
| 222 | else |
| 223 | memcpy_fromio(buf, hw->dpmbase + addr, len); |
| 224 | |
| 225 | return 0; |
| 226 | } |
| 227 | |
| 228 | /* Write Absolute Adapter Memory. |
| 229 | * Transfer data from data buffer to adapter's memory. */ |
| 230 | EXPORT_SYMBOL(cycx_poke); |
| 231 | int cycx_poke(struct cycx_hw *hw, u32 addr, void *buf, u32 len) |
| 232 | { |
| 233 | if (len == 1) |
| 234 | writeb(*(u8*)buf, hw->dpmbase + addr); |
| 235 | else |
| 236 | memcpy_toio(hw->dpmbase + addr, buf, len); |
| 237 | |
| 238 | return 0; |
| 239 | } |
| 240 | |
| 241 | /* Hardware-Specific Functions */ |
| 242 | |
| 243 | /* Load Aux Routines */ |
| 244 | /* Reset board hardware. |
| 245 | return 1 if memory exists at addr and 0 if not. */ |
| 246 | static int memory_exists(void __iomem *addr) |
| 247 | { |
| 248 | int tries = 0; |
| 249 | |
| 250 | for (; tries < 3 ; tries++) { |
| 251 | writew(TEST_PATTERN, addr + 0x10); |
| 252 | |
| 253 | if (readw(addr + 0x10) == TEST_PATTERN) |
| 254 | if (readw(addr + 0x10) == TEST_PATTERN) |
| 255 | return 1; |
| 256 | |
Nishanth Aravamudan | a51d744 | 2005-06-27 09:20:04 -0700 | [diff] [blame] | 257 | msleep_interruptible(1 * 1000); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | } |
| 259 | |
| 260 | return 0; |
| 261 | } |
| 262 | |
| 263 | /* Load reset code. */ |
| 264 | static void reset_load(void __iomem *addr, u8 *buffer, u32 cnt) |
| 265 | { |
| 266 | void __iomem *pt_code = addr + RESET_OFFSET; |
| 267 | u16 i; /*, j; */ |
| 268 | |
| 269 | for (i = 0 ; i < cnt ; i++) { |
| 270 | /* for (j = 0 ; j < 50 ; j++); Delay - FIXME busy waiting... */ |
| 271 | writeb(*buffer++, pt_code++); |
| 272 | } |
| 273 | } |
| 274 | |
| 275 | /* Load buffer using boot interface. |
| 276 | * o copy data from buffer to Cyclom-X memory |
| 277 | * o wait for reset code to copy it to right portion of memory */ |
| 278 | static int buffer_load(void __iomem *addr, u8 *buffer, u32 cnt) |
| 279 | { |
| 280 | memcpy_toio(addr + DATA_OFFSET, buffer, cnt); |
| 281 | writew(GEN_BOOT_DAT, addr + CMD_OFFSET); |
| 282 | |
| 283 | return wait_cyc(addr); |
| 284 | } |
| 285 | |
| 286 | /* Set up entry point and kick start Cyclom-X CPU. */ |
| 287 | static void cycx_start(void __iomem *addr) |
| 288 | { |
| 289 | /* put in 0x30 offset the jump instruction to the code entry point */ |
| 290 | writeb(0xea, addr + 0x30); |
| 291 | writeb(0x00, addr + 0x31); |
| 292 | writeb(0xc4, addr + 0x32); |
| 293 | writeb(0x00, addr + 0x33); |
| 294 | writeb(0x00, addr + 0x34); |
| 295 | |
| 296 | /* cmd to start executing code */ |
| 297 | writew(GEN_START, addr + CMD_OFFSET); |
| 298 | } |
| 299 | |
| 300 | /* Load and boot reset code. */ |
| 301 | static void cycx_reset_boot(void __iomem *addr, u8 *code, u32 len) |
| 302 | { |
| 303 | void __iomem *pt_start = addr + START_OFFSET; |
| 304 | |
| 305 | writeb(0xea, pt_start++); /* jmp to f000:3f00 */ |
| 306 | writeb(0x00, pt_start++); |
| 307 | writeb(0xfc, pt_start++); |
| 308 | writeb(0x00, pt_start++); |
| 309 | writeb(0xf0, pt_start); |
| 310 | reset_load(addr, code, len); |
| 311 | |
| 312 | /* 80186 was in hold, go */ |
| 313 | writeb(0, addr + START_CPU); |
Nishanth Aravamudan | a51d744 | 2005-06-27 09:20:04 -0700 | [diff] [blame] | 314 | msleep_interruptible(1 * 1000); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 315 | } |
| 316 | |
| 317 | /* Load data.bin file through boot (reset) interface. */ |
| 318 | static int cycx_data_boot(void __iomem *addr, u8 *code, u32 len) |
| 319 | { |
| 320 | void __iomem *pt_boot_cmd = addr + CMD_OFFSET; |
| 321 | u32 i; |
| 322 | |
Paulius Zaleckas | efad798b | 2008-02-03 15:42:53 +0200 | [diff] [blame] | 323 | /* boot buffer length */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 324 | writew(CFM_LOAD_BUFSZ, pt_boot_cmd + sizeof(u16)); |
| 325 | writew(GEN_DEFPAR, pt_boot_cmd); |
| 326 | |
| 327 | if (wait_cyc(addr) < 0) |
| 328 | return -1; |
| 329 | |
| 330 | writew(0, pt_boot_cmd + sizeof(u16)); |
| 331 | writew(0x4000, pt_boot_cmd + 2 * sizeof(u16)); |
| 332 | writew(GEN_SET_SEG, pt_boot_cmd); |
| 333 | |
| 334 | if (wait_cyc(addr) < 0) |
| 335 | return -1; |
| 336 | |
| 337 | for (i = 0 ; i < len ; i += CFM_LOAD_BUFSZ) |
| 338 | if (buffer_load(addr, code + i, |
| 339 | min_t(u32, CFM_LOAD_BUFSZ, (len - i))) < 0) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 340 | pr_err("Error !!\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 341 | return -1; |
| 342 | } |
| 343 | |
| 344 | return 0; |
| 345 | } |
| 346 | |
| 347 | |
| 348 | /* Load code.bin file through boot (reset) interface. */ |
| 349 | static int cycx_code_boot(void __iomem *addr, u8 *code, u32 len) |
| 350 | { |
| 351 | void __iomem *pt_boot_cmd = addr + CMD_OFFSET; |
| 352 | u32 i; |
| 353 | |
Paulius Zaleckas | efad798b | 2008-02-03 15:42:53 +0200 | [diff] [blame] | 354 | /* boot buffer length */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 355 | writew(CFM_LOAD_BUFSZ, pt_boot_cmd + sizeof(u16)); |
| 356 | writew(GEN_DEFPAR, pt_boot_cmd); |
| 357 | |
| 358 | if (wait_cyc(addr) < 0) |
| 359 | return -1; |
| 360 | |
| 361 | writew(0x0000, pt_boot_cmd + sizeof(u16)); |
| 362 | writew(0xc400, pt_boot_cmd + 2 * sizeof(u16)); |
| 363 | writew(GEN_SET_SEG, pt_boot_cmd); |
| 364 | |
| 365 | if (wait_cyc(addr) < 0) |
| 366 | return -1; |
| 367 | |
| 368 | for (i = 0 ; i < len ; i += CFM_LOAD_BUFSZ) |
| 369 | if (buffer_load(addr, code + i, |
| 370 | min_t(u32, CFM_LOAD_BUFSZ, (len - i)))) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 371 | pr_err("Error !!\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 372 | return -1; |
| 373 | } |
| 374 | |
| 375 | return 0; |
| 376 | } |
| 377 | |
| 378 | /* Load adapter from the memory image of the CYCX firmware module. |
| 379 | * o verify firmware integrity and compatibility |
| 380 | * o start adapter up */ |
| 381 | static int load_cyc2x(struct cycx_hw *hw, struct cycx_firmware *cfm, u32 len) |
| 382 | { |
| 383 | int i, j; |
| 384 | struct cycx_fw_header *img_hdr; |
| 385 | u8 *reset_image, |
| 386 | *data_image, |
| 387 | *code_image; |
| 388 | void __iomem *pt_cycld = hw->dpmbase + 0x400; |
| 389 | u16 cksum; |
| 390 | |
| 391 | /* Announce */ |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 392 | pr_info("firmware signature=\"%s\"\n", cfm->signature); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 393 | |
| 394 | /* Verify firmware signature */ |
| 395 | if (strcmp(cfm->signature, CFM_SIGNATURE)) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 396 | pr_err("load_cyc2x: not Cyclom-2X firmware!\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 397 | return -EINVAL; |
| 398 | } |
| 399 | |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 400 | pr_info("firmware version=%u\n", cfm->version); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 401 | |
| 402 | /* Verify firmware module format version */ |
| 403 | if (cfm->version != CFM_VERSION) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 404 | pr_err("%s: firmware format %u rejected! Expecting %u.\n", |
| 405 | __func__, cfm->version, CFM_VERSION); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 406 | return -EINVAL; |
| 407 | } |
| 408 | |
| 409 | /* Verify firmware module length and checksum */ |
| 410 | cksum = checksum((u8*)&cfm->info, sizeof(struct cycx_fw_info) + |
| 411 | cfm->info.codesize); |
| 412 | /* |
| 413 | FIXME cfm->info.codesize is off by 2 |
| 414 | if (((len - sizeof(struct cycx_firmware) - 1) != cfm->info.codesize) || |
| 415 | */ |
| 416 | if (cksum != cfm->checksum) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 417 | pr_err("%s: firmware corrupted!\n", __func__); |
| 418 | pr_err(" cdsize = 0x%x (expected 0x%lx)\n", |
| 419 | len - (int)sizeof(struct cycx_firmware) - 1, |
| 420 | cfm->info.codesize); |
| 421 | pr_err(" chksum = 0x%x (expected 0x%x)\n", |
| 422 | cksum, cfm->checksum); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 423 | return -EINVAL; |
| 424 | } |
| 425 | |
| 426 | /* If everything is ok, set reset, data and code pointers */ |
| 427 | img_hdr = (struct cycx_fw_header *)&cfm->image; |
| 428 | #ifdef FIRMWARE_DEBUG |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 429 | pr_info("%s: image sizes\n", __func__); |
| 430 | pr_info(" reset=%lu\n", img_hdr->reset_size); |
| 431 | pr_info(" data=%lu\n", img_hdr->data_size); |
| 432 | pr_info(" code=%lu\n", img_hdr->code_size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | #endif |
| 434 | reset_image = ((u8 *)img_hdr) + sizeof(struct cycx_fw_header); |
| 435 | data_image = reset_image + img_hdr->reset_size; |
| 436 | code_image = data_image + img_hdr->data_size; |
| 437 | |
| 438 | /*---- Start load ----*/ |
| 439 | /* Announce */ |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 440 | pr_info("loading firmware %s (ID=%u)...\n", |
| 441 | cfm->descr[0] ? cfm->descr : "unknown firmware", |
| 442 | cfm->info.codeid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 443 | |
| 444 | for (i = 0 ; i < 5 ; i++) { |
| 445 | /* Reset Cyclom hardware */ |
| 446 | if (!reset_cyc2x(hw->dpmbase)) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 447 | pr_err("dpm problem or board not found\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 448 | return -EINVAL; |
| 449 | } |
| 450 | |
| 451 | /* Load reset.bin */ |
| 452 | cycx_reset_boot(hw->dpmbase, reset_image, img_hdr->reset_size); |
| 453 | /* reset is waiting for boot */ |
| 454 | writew(GEN_POWER_ON, pt_cycld); |
Nishanth Aravamudan | a51d744 | 2005-06-27 09:20:04 -0700 | [diff] [blame] | 455 | msleep_interruptible(1 * 1000); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 456 | |
| 457 | for (j = 0 ; j < 3 ; j++) |
| 458 | if (!readw(pt_cycld)) |
| 459 | goto reset_loaded; |
| 460 | else |
Nishanth Aravamudan | a51d744 | 2005-06-27 09:20:04 -0700 | [diff] [blame] | 461 | msleep_interruptible(1 * 1000); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 462 | } |
| 463 | |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 464 | pr_err("reset not started\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 465 | return -EINVAL; |
| 466 | |
| 467 | reset_loaded: |
| 468 | /* Load data.bin */ |
| 469 | if (cycx_data_boot(hw->dpmbase, data_image, img_hdr->data_size)) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 470 | pr_err("cannot load data file\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 471 | return -EINVAL; |
| 472 | } |
| 473 | |
| 474 | /* Load code.bin */ |
| 475 | if (cycx_code_boot(hw->dpmbase, code_image, img_hdr->code_size)) { |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 476 | pr_err("cannot load code file\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 477 | return -EINVAL; |
| 478 | } |
| 479 | |
| 480 | /* Prepare boot-time configuration data */ |
| 481 | cycx_bootcfg(hw); |
| 482 | |
| 483 | /* kick-off CPU */ |
| 484 | cycx_start(hw->dpmbase); |
| 485 | |
| 486 | /* Arthur Ganzert's tip: wait a while after the firmware loading... |
| 487 | seg abr 26 17:17:12 EST 1999 - acme */ |
Nishanth Aravamudan | a51d744 | 2005-06-27 09:20:04 -0700 | [diff] [blame] | 488 | msleep_interruptible(7 * 1000); |
Joe Perches | d6810e1 | 2011-06-26 19:01:30 +0000 | [diff] [blame] | 489 | pr_info("firmware loaded!\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 490 | |
| 491 | /* enable interrupts */ |
| 492 | cycx_inten(hw); |
| 493 | |
| 494 | return 0; |
| 495 | } |
| 496 | |
| 497 | /* Prepare boot-time firmware configuration data. |
| 498 | * o initialize configuration data area |
| 499 | From async.doc - V_3.4.0 - 07/18/1994 |
| 500 | - As of now, only static buffers are available to the user. |
| 501 | So, the bit VD_RXDIRC must be set in 'valid'. That means that user |
| 502 | wants to use the static transmission and reception buffers. */ |
| 503 | static void cycx_bootcfg(struct cycx_hw *hw) |
| 504 | { |
| 505 | /* use fixed buffers */ |
| 506 | writeb(FIXED_BUFFERS, hw->dpmbase + CONF_OFFSET); |
| 507 | } |
| 508 | |
| 509 | /* Detect Cyclom 2x adapter. |
| 510 | * Following tests are used to detect Cyclom 2x adapter: |
| 511 | * to be completed based on the tests done below |
| 512 | * Return 1 if detected o.k. or 0 if failed. |
| 513 | * Note: This test is destructive! Adapter will be left in shutdown |
| 514 | * state after the test. */ |
| 515 | static int detect_cyc2x(void __iomem *addr) |
| 516 | { |
| 517 | reset_cyc2x(addr); |
| 518 | |
| 519 | return memory_exists(addr); |
| 520 | } |
| 521 | |
| 522 | /* Miscellaneous */ |
| 523 | /* Get option's index into the options list. |
| 524 | * Return option's index (1 .. N) or zero if option is invalid. */ |
stephen hemminger | dcfc5d7 | 2010-09-02 14:29:35 +0000 | [diff] [blame] | 525 | static int get_option_index(const long *optlist, long optval) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 526 | { |
| 527 | int i = 1; |
| 528 | |
| 529 | for (; i <= optlist[0]; ++i) |
| 530 | if (optlist[i] == optval) |
| 531 | return i; |
| 532 | |
| 533 | return 0; |
| 534 | } |
| 535 | |
| 536 | /* Reset adapter's CPU. */ |
| 537 | static int reset_cyc2x(void __iomem *addr) |
| 538 | { |
| 539 | writeb(0, addr + RST_ENABLE); |
Nishanth Aravamudan | a51d744 | 2005-06-27 09:20:04 -0700 | [diff] [blame] | 540 | msleep_interruptible(2 * 1000); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | writeb(0, addr + RST_DISABLE); |
Nishanth Aravamudan | a51d744 | 2005-06-27 09:20:04 -0700 | [diff] [blame] | 542 | msleep_interruptible(2 * 1000); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 543 | |
| 544 | return memory_exists(addr); |
| 545 | } |
| 546 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 547 | /* Calculate 16-bit CRC using CCITT polynomial. */ |
| 548 | static u16 checksum(u8 *buf, u32 len) |
| 549 | { |
| 550 | u16 crc = 0; |
| 551 | u16 mask, flag; |
| 552 | |
| 553 | for (; len; --len, ++buf) |
| 554 | for (mask = 0x80; mask; mask >>= 1) { |
| 555 | flag = (crc & 0x8000); |
| 556 | crc <<= 1; |
| 557 | crc |= ((*buf & mask) ? 1 : 0); |
| 558 | |
| 559 | if (flag) |
| 560 | crc ^= 0x1021; |
| 561 | } |
| 562 | |
| 563 | return crc; |
| 564 | } |
| 565 | |
| 566 | module_init(cycx_drv_init); |
| 567 | module_exit(cycx_drv_cleanup); |
| 568 | |
| 569 | /* End */ |