projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge ../bleed-2.6
[deliverable/linux.git] / drivers / net / wan / cycx_drv.c
CommitLineData
1da177e4
LT		 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
51#include <linux/init.h> /* __init */
52#include <linux/module.h>
53#include <linux/kernel.h> /* printk(), and other useful stuff */
54#include <linux/stddef.h> /* offsetof(), etc. */
55#include <linux/errno.h> /* return codes */
56#include <linux/sched.h> /* for jiffies, HZ, etc. */
57#include <linux/cycx_drv.h> /* API definitions */
58#include <linux/cycx_cfm.h> /* CYCX firmware module definitions */
a51d7440 59#include <linux/delay.h> /* udelay, msleep_interruptible */
1da177e4
LT		 60#include <asm/io.h> /* read[wl], write[wl], ioremap, iounmap */
61
62#define MOD_VERSION 0
63#define MOD_RELEASE 6
64
65MODULE_AUTHOR("Arnaldo Carvalho de Melo");
66MODULE_DESCRIPTION("Cyclom 2x Sync Card Driver");
67MODULE_LICENSE("GPL");
68
69/* Hardware-specific functions */
70static int load_cyc2x(struct cycx_hw *hw, struct cycx_firmware *cfm, u32 len);
71static void cycx_bootcfg(struct cycx_hw *hw);
72
73static int reset_cyc2x(void __iomem *addr);
74static int detect_cyc2x(void __iomem *addr);
75
76/* Miscellaneous functions */
1da177e4
LT		 77static int get_option_index(long *optlist, long optval);
78static u16 checksum(u8 *buf, u32 len);
79
80#define wait_cyc(addr) cycx_exec(addr + CMD_OFFSET)
81
82/* Global Data */
83
84/* private data */
85static char modname[] = "cycx_drv";
86static char fullname[] = "Cyclom 2X Support Module";
87static char copyright[] = "(c) 1998-2003 Arnaldo Carvalho de Melo "
88 "<acme@conectiva.com.br>";
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 */
94static long cyc2x_dpmbase_options[] = {
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
101static long cycx_2x_irq_options[] = { 7, 3, 5, 9, 10, 11, 12, 15 };
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
7665a089 112static int __init cycx_drv_init(void)
1da177e4
LT		 113{
114 printk(KERN_INFO "%s v%u.%u %s\n", fullname, MOD_VERSION, MOD_RELEASE,
115 copyright);
116
117 return 0;
118}
119
120/* Module 'remove' entry point.
121 * o release all remaining system resources */
7665a089 122static void cycx_drv_cleanup(void)
1da177e4
LT		 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 */
136EXPORT_SYMBOL(cycx_setup);
137int 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)) {
143 printk(KERN_ERR "%s: IRQ %d is invalid!\n", modname, hw->irq);
144 return -EINVAL;
145 }
146
147 /* Setup adapter dual-port memory window and test memory */
148 if (!dpmbase) {
149 printk(KERN_ERR "%s: you must specify the dpm address!\n",
150 modname);
151 return -EINVAL;
152 } else if (!get_option_index(cyc2x_dpmbase_options, dpmbase)) {
153 printk(KERN_ERR "%s: memory address 0x%lX is invalid!\n",
154 modname, dpmbase);
155 return -EINVAL;
156 }
157
158 hw->dpmbase = ioremap(dpmbase, CYCX_WINDOWSIZE);
159 hw->dpmsize = CYCX_WINDOWSIZE;
160
161 if (!detect_cyc2x(hw->dpmbase)) {
162 printk(KERN_ERR "%s: adapter Cyclom 2X not found at "
163 "address 0x%lX!\n", modname, dpmbase);
164 return -EINVAL;
165 }
166
167 printk(KERN_INFO "%s: found Cyclom 2X card at address 0x%lX.\n",
168 modname, dpmbase);
169
170 /* Load firmware. If loader fails then shut down adapter */
171 err = load_cyc2x(hw, cfm, len);
172
173 if (err)
174 cycx_down(hw); /* shutdown adapter */
175
176 return err;
177}
178
179EXPORT_SYMBOL(cycx_down);
180int cycx_down(struct cycx_hw *hw)
181{
182 iounmap(hw->dpmbase);
183 return 0;
184}
185
186/* Enable interrupt generation. */
7665a089 187static void cycx_inten(struct cycx_hw *hw)
1da177e4
LT		 188{
189 writeb(0, hw->dpmbase);
190}
191
192/* Generate an interrupt to adapter's CPU. */
193EXPORT_SYMBOL(cycx_intr);
194void cycx_intr(struct cycx_hw *hw)
195{
196 writew(0, hw->dpmbase + GEN_CYCX_INTR);
197}
198
199/* Execute Adapter Command.
200 * o Set exec flag.
201 * o Busy-wait until flag is reset. */
202EXPORT_SYMBOL(cycx_exec);
203int cycx_exec(void __iomem *addr)
204{
205 u16 i = 0;
206 /* wait till addr content is zeroed */
207
208 while (readw(addr)) {
209 udelay(1000);
210
211 if (++i > 50)
212 return -1;
213 }
214
215 return 0;
216}
217
218/* Read absolute adapter memory.
219 * Transfer data from adapter's memory to data buffer. */
220EXPORT_SYMBOL(cycx_peek);
221int cycx_peek(struct cycx_hw *hw, u32 addr, void *buf, u32 len)
222{
223 if (len == 1)
224 *(u8*)buf = readb(hw->dpmbase + addr);
225 else
226 memcpy_fromio(buf, hw->dpmbase + addr, len);
227
228 return 0;
229}
230
231/* Write Absolute Adapter Memory.
232 * Transfer data from data buffer to adapter's memory. */
233EXPORT_SYMBOL(cycx_poke);
234int cycx_poke(struct cycx_hw *hw, u32 addr, void *buf, u32 len)
235{
236 if (len == 1)
237 writeb(*(u8*)buf, hw->dpmbase + addr);
238 else
239 memcpy_toio(hw->dpmbase + addr, buf, len);
240
241 return 0;
242}
243
244/* Hardware-Specific Functions */
245
246/* Load Aux Routines */
247/* Reset board hardware.
248 return 1 if memory exists at addr and 0 if not. */
249static int memory_exists(void __iomem *addr)
250{
251 int tries = 0;
252
253 for (; tries < 3 ; tries++) {
254 writew(TEST_PATTERN, addr + 0x10);
255
256 if (readw(addr + 0x10) == TEST_PATTERN)
257 if (readw(addr + 0x10) == TEST_PATTERN)
258 return 1;
259
a51d7440 260 msleep_interruptible(1 * 1000);
1da177e4
LT		 261 }
262
263 return 0;
264}
265
266/* Load reset code. */
267static void reset_load(void __iomem *addr, u8 *buffer, u32 cnt)
268{
269 void __iomem *pt_code = addr + RESET_OFFSET;
270 u16 i; /*, j; */
271
272 for (i = 0 ; i < cnt ; i++) {
273/* for (j = 0 ; j < 50 ; j++); Delay - FIXME busy waiting... */
274 writeb(*buffer++, pt_code++);
275 }
276}
277
278/* Load buffer using boot interface.
279 * o copy data from buffer to Cyclom-X memory
280 * o wait for reset code to copy it to right portion of memory */
281static int buffer_load(void __iomem *addr, u8 *buffer, u32 cnt)
282{
283 memcpy_toio(addr + DATA_OFFSET, buffer, cnt);
284 writew(GEN_BOOT_DAT, addr + CMD_OFFSET);
285
286 return wait_cyc(addr);
287}
288
289/* Set up entry point and kick start Cyclom-X CPU. */
290static void cycx_start(void __iomem *addr)
291{
292 /* put in 0x30 offset the jump instruction to the code entry point */
293 writeb(0xea, addr + 0x30);
294 writeb(0x00, addr + 0x31);
295 writeb(0xc4, addr + 0x32);
296 writeb(0x00, addr + 0x33);
297 writeb(0x00, addr + 0x34);
298
299 /* cmd to start executing code */
300 writew(GEN_START, addr + CMD_OFFSET);
301}
302
303/* Load and boot reset code. */
304static void cycx_reset_boot(void __iomem *addr, u8 *code, u32 len)
305{
306 void __iomem *pt_start = addr + START_OFFSET;
307
308 writeb(0xea, pt_start++); /* jmp to f000:3f00 */
309 writeb(0x00, pt_start++);
310 writeb(0xfc, pt_start++);
311 writeb(0x00, pt_start++);
312 writeb(0xf0, pt_start);
313 reset_load(addr, code, len);
314
315 /* 80186 was in hold, go */
316 writeb(0, addr + START_CPU);
a51d7440 317 msleep_interruptible(1 * 1000);
1da177e4
LT		 318}
319
320/* Load data.bin file through boot (reset) interface. */
321static int cycx_data_boot(void __iomem *addr, u8 *code, u32 len)
322{
323 void __iomem *pt_boot_cmd = addr + CMD_OFFSET;
324 u32 i;
325
326 /* boot buffer lenght */
327 writew(CFM_LOAD_BUFSZ, pt_boot_cmd + sizeof(u16));
328 writew(GEN_DEFPAR, pt_boot_cmd);
329
330 if (wait_cyc(addr) < 0)
331 return -1;
332
333 writew(0, pt_boot_cmd + sizeof(u16));
334 writew(0x4000, pt_boot_cmd + 2 * sizeof(u16));
335 writew(GEN_SET_SEG, pt_boot_cmd);
336
337 if (wait_cyc(addr) < 0)
338 return -1;
339
340 for (i = 0 ; i < len ; i += CFM_LOAD_BUFSZ)
341 if (buffer_load(addr, code + i,
342 min_t(u32, CFM_LOAD_BUFSZ, (len - i))) < 0) {
343 printk(KERN_ERR "%s: Error !!\n", modname);
344 return -1;
345 }
346
347 return 0;
348}
349
350
351/* Load code.bin file through boot (reset) interface. */
352static int cycx_code_boot(void __iomem *addr, u8 *code, u32 len)
353{
354 void __iomem *pt_boot_cmd = addr + CMD_OFFSET;
355 u32 i;
356
357 /* boot buffer lenght */
358 writew(CFM_LOAD_BUFSZ, pt_boot_cmd + sizeof(u16));
359 writew(GEN_DEFPAR, pt_boot_cmd);
360
361 if (wait_cyc(addr) < 0)
362 return -1;
363
364 writew(0x0000, pt_boot_cmd + sizeof(u16));
365 writew(0xc400, pt_boot_cmd + 2 * sizeof(u16));
366 writew(GEN_SET_SEG, pt_boot_cmd);
367
368 if (wait_cyc(addr) < 0)
369 return -1;
370
371 for (i = 0 ; i < len ; i += CFM_LOAD_BUFSZ)
372 if (buffer_load(addr, code + i,
373 min_t(u32, CFM_LOAD_BUFSZ, (len - i)))) {
374 printk(KERN_ERR "%s: Error !!\n", modname);
375 return -1;
376 }
377
378 return 0;
379}
380
381/* Load adapter from the memory image of the CYCX firmware module.
382 * o verify firmware integrity and compatibility
383 * o start adapter up */
384static int load_cyc2x(struct cycx_hw *hw, struct cycx_firmware *cfm, u32 len)
385{
386 int i, j;
387 struct cycx_fw_header *img_hdr;
388 u8 *reset_image,
389 *data_image,
390 *code_image;
391 void __iomem *pt_cycld = hw->dpmbase + 0x400;
392 u16 cksum;
393
394 /* Announce */
395 printk(KERN_INFO "%s: firmware signature=\"%s\"\n", modname,
396 cfm->signature);
397
398 /* Verify firmware signature */
399 if (strcmp(cfm->signature, CFM_SIGNATURE)) {
400 printk(KERN_ERR "%s:load_cyc2x: not Cyclom-2X firmware!\n",
401 modname);
402 return -EINVAL;
403 }
404
405 printk(KERN_INFO "%s: firmware version=%u\n", modname, cfm->version);
406
407 /* Verify firmware module format version */
408 if (cfm->version != CFM_VERSION) {
409 printk(KERN_ERR "%s:%s: firmware format %u rejected! "
410 "Expecting %u.\n",
411 modname, __FUNCTION__, cfm->version, CFM_VERSION);
412 return -EINVAL;
413 }
414
415 /* Verify firmware module length and checksum */
416 cksum = checksum((u8*)&cfm->info, sizeof(struct cycx_fw_info) +
417 cfm->info.codesize);
418/*
419 FIXME cfm->info.codesize is off by 2
420 if (((len - sizeof(struct cycx_firmware) - 1) != cfm->info.codesize) ||
421*/
422 if (cksum != cfm->checksum) {
423 printk(KERN_ERR "%s:%s: firmware corrupted!\n",
424 modname, __FUNCTION__);
425 printk(KERN_ERR " cdsize = 0x%x (expected 0x%lx)\n",
426 len - (int)sizeof(struct cycx_firmware) - 1,
427 cfm->info.codesize);
428 printk(KERN_ERR " chksum = 0x%x (expected 0x%x)\n",
429 cksum, cfm->checksum);
430 return -EINVAL;
431 }
432
433 /* If everything is ok, set reset, data and code pointers */
434 img_hdr = (struct cycx_fw_header *)&cfm->image;
435#ifdef FIRMWARE_DEBUG
436 printk(KERN_INFO "%s:%s: image sizes\n", __FUNCTION__, modname);
437 printk(KERN_INFO " reset=%lu\n", img_hdr->reset_size);
438 printk(KERN_INFO " data=%lu\n", img_hdr->data_size);
439 printk(KERN_INFO " code=%lu\n", img_hdr->code_size);
440#endif
441 reset_image = ((u8 *)img_hdr) + sizeof(struct cycx_fw_header);
442 data_image = reset_image + img_hdr->reset_size;
443 code_image = data_image + img_hdr->data_size;
444
445 /*---- Start load ----*/
446 /* Announce */
447 printk(KERN_INFO "%s: loading firmware %s (ID=%u)...\n", modname,
448 cfm->descr[0] ? cfm->descr : "unknown firmware",
449 cfm->info.codeid);
450
451 for (i = 0 ; i < 5 ; i++) {
452 /* Reset Cyclom hardware */
453 if (!reset_cyc2x(hw->dpmbase)) {
454 printk(KERN_ERR "%s: dpm problem or board not found\n",
455 modname);
456 return -EINVAL;
457 }
458
459 /* Load reset.bin */
460 cycx_reset_boot(hw->dpmbase, reset_image, img_hdr->reset_size);
461 /* reset is waiting for boot */
462 writew(GEN_POWER_ON, pt_cycld);
a51d7440 463 msleep_interruptible(1 * 1000);
1da177e4
LT		 464
465 for (j = 0 ; j < 3 ; j++)
466 if (!readw(pt_cycld))
467 goto reset_loaded;
468 else
a51d7440 469 msleep_interruptible(1 * 1000);
1da177e4
LT		 470 }
471
472 printk(KERN_ERR "%s: reset not started.\n", modname);
473 return -EINVAL;
474
475reset_loaded:
476 /* Load data.bin */
477 if (cycx_data_boot(hw->dpmbase, data_image, img_hdr->data_size)) {
478 printk(KERN_ERR "%s: cannot load data file.\n", modname);
479 return -EINVAL;
480 }
481
482 /* Load code.bin */
483 if (cycx_code_boot(hw->dpmbase, code_image, img_hdr->code_size)) {
484 printk(KERN_ERR "%s: cannot load code file.\n", modname);
485 return -EINVAL;
486 }
487
488 /* Prepare boot-time configuration data */
489 cycx_bootcfg(hw);
490
491 /* kick-off CPU */
492 cycx_start(hw->dpmbase);
493
494 /* Arthur Ganzert's tip: wait a while after the firmware loading...
495 seg abr 26 17:17:12 EST 1999 - acme */
a51d7440 496 msleep_interruptible(7 * 1000);
1da177e4
LT		 497 printk(KERN_INFO "%s: firmware loaded!\n", modname);
498
499 /* enable interrupts */
500 cycx_inten(hw);
501
502 return 0;
503}
504
505/* Prepare boot-time firmware configuration data.
506 * o initialize configuration data area
507 From async.doc - V_3.4.0 - 07/18/1994
508 - As of now, only static buffers are available to the user.
509 So, the bit VD_RXDIRC must be set in 'valid'. That means that user
510 wants to use the static transmission and reception buffers. */
511static void cycx_bootcfg(struct cycx_hw *hw)
512{
513 /* use fixed buffers */
514 writeb(FIXED_BUFFERS, hw->dpmbase + CONF_OFFSET);
515}
516
517/* Detect Cyclom 2x adapter.
518 * Following tests are used to detect Cyclom 2x adapter:
519 * to be completed based on the tests done below
520 * Return 1 if detected o.k. or 0 if failed.
521 * Note: This test is destructive! Adapter will be left in shutdown
522 * state after the test. */
523static int detect_cyc2x(void __iomem *addr)
524{
525 reset_cyc2x(addr);
526
527 return memory_exists(addr);
528}
529
530/* Miscellaneous */
531/* Get option's index into the options list.
532 * Return option's index (1 .. N) or zero if option is invalid. */
533static int get_option_index(long *optlist, long optval)
534{
535 int i = 1;
536
537 for (; i <= optlist[0]; ++i)
538 if (optlist[i] == optval)
539 return i;
540
541 return 0;
542}
543
544/* Reset adapter's CPU. */
545static int reset_cyc2x(void __iomem *addr)
546{
547 writeb(0, addr + RST_ENABLE);
a51d7440 548 msleep_interruptible(2 * 1000);
1da177e4 549 writeb(0, addr + RST_DISABLE);
a51d7440 550 msleep_interruptible(2 * 1000);
1da177e4
LT		 551
552 return memory_exists(addr);
553}
554
1da177e4
LT		 555/* Calculate 16-bit CRC using CCITT polynomial. */
556static u16 checksum(u8 *buf, u32 len)
557{
558 u16 crc = 0;
559 u16 mask, flag;
560
561 for (; len; --len, ++buf)
562 for (mask = 0x80; mask; mask >>= 1) {
563 flag = (crc & 0x8000);
564 crc <<= 1;
565 crc |= ((*buf & mask) ? 1 : 0);
566
567 if (flag)
568 crc ^= 0x1021;
569 }
570
571 return crc;
572}
573
574module_init(cycx_drv_init);
575module_exit(cycx_drv_cleanup);
576
577/* End */
Linux kernel - Deliverables
This page took 0.08671 seconds and 5 git commands to generate.