Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cycx_drv.c
Go to the documentation of this file.
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 <[email protected]>
8 *
9 * Copyright: (c) 1998-2003 Arnaldo Carvalho de Melo
10 *
11 * Based on sdladrv.c by Gene Kozin <[email protected]>
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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
52 
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 */
58 #include <linux/cycx_drv.h> /* API definitions */
59 #include <linux/cycx_cfm.h> /* CYCX firmware module definitions */
60 #include <linux/delay.h> /* udelay, msleep_interruptible */
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 */
78 static int get_option_index(const long *optlist, long optval);
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 */
86 static const char fullname[] = "Cyclom 2X Support Module";
87 static const char copyright[] =
88  "(c) 1998-2003 Arnaldo Carvalho de Melo <[email protected]>";
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 const 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 const 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  pr_info("%s v%u.%u %s\n",
115  fullname, MOD_VERSION, MOD_RELEASE, 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 */
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  pr_err("IRQ %d is invalid!\n", hw->irq);
144  return -EINVAL;
145  }
146 
147  /* Setup adapter dual-port memory window and test memory */
148  if (!dpmbase) {
149  pr_err("you must specify the dpm address!\n");
150  return -EINVAL;
151  } else if (!get_option_index(cyc2x_dpmbase_options, dpmbase)) {
152  pr_err("memory address 0x%lX is invalid!\n", dpmbase);
153  return -EINVAL;
154  }
155 
156  hw->dpmbase = ioremap(dpmbase, CYCX_WINDOWSIZE);
157  hw->dpmsize = CYCX_WINDOWSIZE;
158 
159  if (!detect_cyc2x(hw->dpmbase)) {
160  pr_err("adapter Cyclom 2X not found at address 0x%lX!\n",
161  dpmbase);
162  return -EINVAL;
163  }
164 
165  pr_info("found Cyclom 2X card at address 0x%lX\n", dpmbase);
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 
177 int cycx_down(struct cycx_hw *hw)
178 {
179  iounmap(hw->dpmbase);
180  return 0;
181 }
182 
183 /* Enable interrupt generation. */
184 static void cycx_inten(struct cycx_hw *hw)
185 {
186  writeb(0, hw->dpmbase);
187 }
188 
189 /* Generate an interrupt to adapter's CPU. */
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. */
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. */
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. */
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 
257  msleep_interruptible(1 * 1000);
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);
314  msleep_interruptible(1 * 1000);
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 
323  /* boot buffer length */
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) {
340  pr_err("Error !!\n");
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 
354  /* boot buffer length */
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)))) {
371  pr_err("Error !!\n");
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 */
392  pr_info("firmware signature=\"%s\"\n", cfm->signature);
393 
394  /* Verify firmware signature */
395  if (strcmp(cfm->signature, CFM_SIGNATURE)) {
396  pr_err("load_cyc2x: not Cyclom-2X firmware!\n");
397  return -EINVAL;
398  }
399 
400  pr_info("firmware version=%u\n", cfm->version);
401 
402  /* Verify firmware module format version */
403  if (cfm->version != CFM_VERSION) {
404  pr_err("%s: firmware format %u rejected! Expecting %u.\n",
405  __func__, cfm->version, CFM_VERSION);
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) {
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);
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
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);
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 */
440  pr_info("loading firmware %s (ID=%u)...\n",
441  cfm->descr[0] ? cfm->descr : "unknown firmware",
442  cfm->info.codeid);
443 
444  for (i = 0 ; i < 5 ; i++) {
445  /* Reset Cyclom hardware */
446  if (!reset_cyc2x(hw->dpmbase)) {
447  pr_err("dpm problem or board not found\n");
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);
455  msleep_interruptible(1 * 1000);
456 
457  for (j = 0 ; j < 3 ; j++)
458  if (!readw(pt_cycld))
459  goto reset_loaded;
460  else
461  msleep_interruptible(1 * 1000);
462  }
463 
464  pr_err("reset not started\n");
465  return -EINVAL;
466 
467 reset_loaded:
468  /* Load data.bin */
469  if (cycx_data_boot(hw->dpmbase, data_image, img_hdr->data_size)) {
470  pr_err("cannot load data file\n");
471  return -EINVAL;
472  }
473 
474  /* Load code.bin */
475  if (cycx_code_boot(hw->dpmbase, code_image, img_hdr->code_size)) {
476  pr_err("cannot load code file\n");
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 */
488  msleep_interruptible(7 * 1000);
489  pr_info("firmware loaded!\n");
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 */
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. */
525 static int get_option_index(const long *optlist, long optval)
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);
540  msleep_interruptible(2 * 1000);
541  writeb(0, addr + RST_DISABLE);
542  msleep_interruptible(2 * 1000);
543 
544  return memory_exists(addr);
545 }
546 
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 */