Merge branch 'upstream-fixes'
[linux-2.6] / drivers / net / wan / cycx_drv.c
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 */
59 #include <linux/delay.h>        /* udelay, msleep_interruptible */
60 #include <asm/io.h>             /* read[wl], write[wl], ioremap, iounmap */
61
62 #define MOD_VERSION     0
63 #define MOD_RELEASE     6
64
65 MODULE_AUTHOR("Arnaldo Carvalho de Melo");
66 MODULE_DESCRIPTION("Cyclom 2x Sync Card Driver");
67 MODULE_LICENSE("GPL");
68
69 /* Hardware-specific functions */
70 static int load_cyc2x(struct cycx_hw *hw, struct cycx_firmware *cfm, u32 len);
71 static void cycx_bootcfg(struct cycx_hw *hw);
72
73 static int reset_cyc2x(void __iomem *addr);
74 static int detect_cyc2x(void __iomem *addr);
75
76 /* Miscellaneous functions */
77 static int get_option_index(long *optlist, long optval);
78 static 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 */
85 static char modname[] = "cycx_drv";
86 static char fullname[] = "Cyclom 2X Support Module";
87 static 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  */
94 static 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
101 static 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
112 static int __init cycx_drv_init(void)
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 */
122 static void cycx_drv_cleanup(void)
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)) {
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
179 EXPORT_SYMBOL(cycx_down);
180 int cycx_down(struct cycx_hw *hw)
181 {
182         iounmap(hw->dpmbase);
183         return 0;
184 }
185
186 /* Enable interrupt generation.  */
187 static void cycx_inten(struct cycx_hw *hw)
188 {
189         writeb(0, hw->dpmbase);
190 }
191
192 /* Generate an interrupt to adapter's CPU. */
193 EXPORT_SYMBOL(cycx_intr);
194 void 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. */
202 EXPORT_SYMBOL(cycx_exec);
203 int 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. */
220 EXPORT_SYMBOL(cycx_peek);
221 int 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. */
233 EXPORT_SYMBOL(cycx_poke);
234 int 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. */
249 static 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
260                 msleep_interruptible(1 * 1000);
261         }
262
263         return 0;
264 }
265
266 /* Load reset code. */
267 static 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 */
281 static 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. */
290 static 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. */
304 static 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);
317         msleep_interruptible(1 * 1000);
318 }
319
320 /* Load data.bin file through boot (reset) interface. */
321 static 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. */
352 static 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 */
384 static 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);
463                 msleep_interruptible(1 * 1000);
464
465                 for (j = 0 ; j < 3 ; j++)
466                         if (!readw(pt_cycld))
467                                 goto reset_loaded;
468                         else
469                                 msleep_interruptible(1 * 1000);
470         }
471
472         printk(KERN_ERR "%s: reset not started.\n", modname);
473         return -EINVAL;
474
475 reset_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 */
496         msleep_interruptible(7 * 1000);
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. */
511 static 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. */
523 static 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. */
533 static 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. */
545 static int reset_cyc2x(void __iomem *addr)
546 {
547         writeb(0, addr + RST_ENABLE);
548         msleep_interruptible(2 * 1000);
549         writeb(0, addr + RST_DISABLE);
550         msleep_interruptible(2 * 1000);
551
552         return memory_exists(addr);
553 }
554
555 /* Calculate 16-bit CRC using CCITT polynomial. */
556 static 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
574 module_init(cycx_drv_init);
575 module_exit(cycx_drv_cleanup);
576
577 /* End */