projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
add fixes for dsl code, clean up old hacks
[openwrt.git] / openwrt / target / linux / linux-2.4 / patches / ar7 / 005-vlynq.patch
1 diff -urN linux.old/drivers/char/avalanche_vlynq/Makefile linux.dev/drivers/char/avalanche_vlynq/Makefile
2 --- linux.old/drivers/char/avalanche_vlynq/Makefile 1970-01-01 01:00:00.000000000 +0100
3 +++ linux.dev/drivers/char/avalanche_vlynq/Makefile 2005-07-22 06:32:53.345189608 +0200
4 @@ -0,0 +1,14 @@
5 +#
6 +# Makefile for the linux kernel.
7 +#
8 +# Note! Dependencies are done automagically by 'make dep', which also
9 +# removes any old dependencies. DON'T put your own dependencies here
10 +# unless it's something special (ie not a .c file).
11 +#
12 +# Note 2! The CFLAGS definitions are now in the main makefile...
13 +
14 +O_TARGET := avalanche_vlynq.o
15 +
16 +obj-y += vlynq_drv.o vlynq_hal.o vlynq_board.o
17 +
18 +include $(TOPDIR)/Rules.make
19 diff -urN linux.old/drivers/char/avalanche_vlynq/vlynq_board.c linux.dev/drivers/char/avalanche_vlynq/vlynq_board.c
20 --- linux.old/drivers/char/avalanche_vlynq/vlynq_board.c 1970-01-01 01:00:00.000000000 +0100
21 +++ linux.dev/drivers/char/avalanche_vlynq/vlynq_board.c 2005-07-22 06:34:39.448059520 +0200
22 @@ -0,0 +1,182 @@
23 +/*
24 + * Jeff Harrell, jharrell@ti.com
25 + * Copyright (C) 2001 Texas Instruments, Inc. All rights reserved.
26 + *
27 + * This program is free software; you can distribute it and/or modify it
28 + * under the terms of the GNU General Public License (Version 2) as
29 + * published by the Free Software Foundation.
30 + *
31 + * This program is distributed in the hope it will be useful, but WITHOUT
32 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
33 + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
34 + * for more details.
35 + *
36 + * You should have received a copy of the GNU General Public License along
37 + * with this program; if not, write to the Free Software Foundation, Inc.,
38 + * 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
39 + *
40 + * Texas Instruments Sangam specific setup.
41 + */
42 +#include <linux/config.h>
43 +#include <asm/ar7/sangam.h>
44 +#include <asm/ar7/avalanche_misc.h>
45 +#include <asm/ar7/vlynq.h>
46 +
47 +#define SYS_VLYNQ_LOCAL_INTERRUPT_VECTOR 30 /* MSB - 1 bit */
48 +#define SYS_VLYNQ_REMOTE_INTERRUPT_VECTOR 31 /* MSB bit */
49 +#define SYS_VLYNQ_OPTIONS 0x7F; /* all options*/
50 +
51 +/* These defines are board specific */
52 +
53 +
54 +#define VLYNQ0_REMOTE_WINDOW1_OFFSET (0x0C000000)
55 +#define VLYNQ0_REMOTE_WINDOW1_SIZE (0x500)
56 +
57 +
58 +#define VLYNQ1_REMOTE_WINDOW1_OFFSET (0x0C000000)
59 +#define VLYNQ1_REMOTE_WINDOW1_SIZE (0x500)
60 +
61 +
62 +extern VLYNQ_DEV vlynqDevice0, vlynqDevice1;
63 +int vlynq_init_status[2] = {0, 0};
64 +static int reset_hack = 1;
65 +
66 +void vlynq_ar7wrd_dev_init()
67 +{
68 + *(unsigned long*) AVALANCHE_GPIO_ENBL |= (1<<18);
69 + vlynq_delay(20000);
70 + *(unsigned long*) AVALANCHE_GPIO_DIR &= ~(1<<18);
71 + vlynq_delay(20000);
72 + *(unsigned long*) AVALANCHE_GPIO_DATA_OUT&= ~(1<<18);
73 + vlynq_delay(50000);
74 + *(unsigned long*) AVALANCHE_GPIO_DATA_OUT|= (1<<18);
75 + vlynq_delay(50000);
76 +
77 + /* Initialize the MIPS host vlynq driver for a given vlynq interface */
78 + vlynqDevice0.dev_idx = 0; /* first vlynq module - this parameter is for reference only */
79 + vlynqDevice0.module_base = AVALANCHE_LOW_VLYNQ_CONTROL_BASE; /* vlynq0 module base address */
80 +
81 +#if defined(CONFIG_VLYNQ_CLK_LOCAL)
82 + vlynqDevice0.clk_source = VLYNQ_CLK_SOURCE_LOCAL;
83 +#else
84 + vlynqDevice0.clk_source = VLYNQ_CLK_SOURCE_REMOTE;
85 +#endif
86 + vlynqDevice0.clk_div = 0x01; /* board/hardware specific */
87 + vlynqDevice0.state = VLYNQ_DRV_STATE_UNINIT; /* uninitialized module */
88 +
89 + /* Populate vlynqDevice0.local_mem & Vlynq0.remote_mem based on system configuration */
90 + /*Local memory configuration */
91 +
92 + /* Demiurg : not good !*/
93 +#if 0
94 + vlynqDevice0.local_mem.Txmap= AVALANCHE_LOW_VLYNQ_MEM_MAP_BASE & ~(0xc0000000) ; /* physical address */
95 + vlynqDevice0.remote_mem.RxOffset[0]= VLYNQ0_REMOTE_WINDOW1_OFFSET; /* This is specific to the board on the other end */
96 + vlynqDevice0.remote_mem.RxSize[0]=VLYNQ0_REMOTE_WINDOW1_SIZE;
97 +#endif
98 +
99 + /* Demiurg : This is how it should be ! */
100 + vlynqDevice0.local_mem.Txmap = PHYSADDR(AVALANCHE_LOW_VLYNQ_MEM_MAP_BASE);
101 +#define VLYNQ_ACX111_MEM_OFFSET 0xC0000000 /* Physical address of ACX111 memory */
102 +#define VLYNQ_ACX111_MEM_SIZE 0x00040000 /* Total size of the ACX111 memory */
103 +#define VLYNQ_ACX111_REG_OFFSET 0xF0000000 /* PHYS_ADDR of ACX111 control registers */
104 +#define VLYNQ_ACX111_REG_SIZE 0x00022000 /* Size of ACX111 registers area, MAC+PHY */
105 +#define ACX111_VL1_REMOTE_SIZE 0x1000000
106 + vlynqDevice0.remote_mem.RxOffset[0] = VLYNQ_ACX111_MEM_OFFSET;
107 + vlynqDevice0.remote_mem.RxSize[0] = VLYNQ_ACX111_MEM_SIZE ;
108 + vlynqDevice0.remote_mem.RxOffset[1] = VLYNQ_ACX111_REG_OFFSET;
109 + vlynqDevice0.remote_mem.RxSize[1] = VLYNQ_ACX111_REG_SIZE ;
110 + vlynqDevice0.remote_mem.Txmap = 0;
111 + vlynqDevice0.local_mem.RxOffset[0] = AVALANCHE_SDRAM_BASE;
112 + vlynqDevice0.local_mem.RxSize[0] = ACX111_VL1_REMOTE_SIZE;
113 +
114 +
115 + /* Local interrupt configuration */
116 + vlynqDevice0.local_irq.intLocal = VLYNQ_INT_LOCAL; /* Host handles vlynq interrupts*/
117 + vlynqDevice0.local_irq.intRemote = VLYNQ_INT_ROOT_ISR; /* vlynq root isr used */
118 + vlynqDevice0.local_irq.map_vector = SYS_VLYNQ_LOCAL_INTERRUPT_VECTOR;
119 + vlynqDevice0.local_irq.intr_ptr = 0; /* Since remote interrupts part of vlynq root isr this is unused */
120 +
121 + /* Remote interrupt configuration */
122 + vlynqDevice0.remote_irq.intLocal = VLYNQ_INT_REMOTE; /* MIPS handles interrupts */
123 + vlynqDevice0.remote_irq.intRemote = VLYNQ_INT_ROOT_ISR; /* Not significant since MIPS handles interrupts */
124 + vlynqDevice0.remote_irq.map_vector = SYS_VLYNQ_REMOTE_INTERRUPT_VECTOR;
125 + vlynqDevice0. remote_irq.intr_ptr = AVALANCHE_INTC_BASE; /* Not significant since MIPS handles interrupts */
126 +
127 + if(reset_hack != 1)
128 + printk("About to re-init the VLYNQ.\n");
129 +
130 + if(vlynq_init(&vlynqDevice0,VLYNQ_INIT_PERFORM_ALL)== 0)
131 + {
132 + /* Suraj added the following to keep the 1130 going. */
133 + vlynq_interrupt_vector_set(&vlynqDevice0, 0 /* intr vector line running into 1130 vlynq */,
134 + 0 /* intr mapped onto the interrupt register on remote vlynq and this vlynq */,
135 + VLYNQ_REMOTE_DVC, 0 /* polarity active high */, 0 /* interrupt Level triggered */);
136 +
137 + /* System wide interrupt is 80 for 1130, please note. */
138 + vlynq_init_status[0] = 1;
139 + reset_hack = 2;
140 + }
141 + else
142 + {
143 + if(reset_hack == 1)
144 + printk("VLYNQ INIT FAILED: Please try cold reboot. \n");
145 + else
146 + printk("Failed to initialize the VLYNQ interface at insmod.\n");
147 +
148 + }
149 +}
150 +
151 +void vlynq_dev_init(void)
152 +{
153 + volatile unsigned int *reset_base = (unsigned int *) AVALANCHE_RESET_CONTROL_BASE;
154 +
155 + *reset_base &= ~((1 << AVALANCHE_LOW_VLYNQ_RESET_BIT)); /* | (1 << AVALANCHE_HIGH_VLYNQ_RESET_BIT)); */
156 +
157 + vlynq_delay(20000);
158 +
159 + /* Bring vlynq out of reset if not already done */
160 + *reset_base |= (1 << AVALANCHE_LOW_VLYNQ_RESET_BIT); /* | (1 << AVALANCHE_HIGH_VLYNQ_RESET_BIT); */
161 + vlynq_delay(20000); /* Allowing sufficient time to VLYNQ to settle down.*/
162 +
163 + vlynq_ar7wrd_dev_init( );
164 +
165 +}
166 +
167 +/* This function is board specific and should be ported for each board. */
168 +void remote_vlynq_dev_reset_ctrl(unsigned int module_reset_bit,
169 + AVALANCHE_RESET_CTRL_T reset_ctrl)
170 +{
171 + if(module_reset_bit >= 32)
172 + return;
173 +
174 + switch(module_reset_bit)
175 + {
176 + case 0:
177 + if(OUT_OF_RESET == reset_ctrl)
178 + {
179 + if(reset_hack) return;
180 +
181 + vlynq_delay(20000);
182 + printk("Un-resetting the remote device.\n");
183 + vlynq_dev_init();
184 + printk("Re-initialized the VLYNQ.\n");
185 + reset_hack = 2;
186 + }
187 + else if(IN_RESET == reset_ctrl)
188 + {
189 + *(unsigned long*) AVALANCHE_GPIO_DATA_OUT &= ~(1<<18);
190 +
191 + vlynq_delay(20000);
192 + printk("Resetting the remote device.\n");
193 + reset_hack = 0;
194 + }
195 + else
196 + ;
197 + break;
198 +
199 + default:
200 + break;
201 +
202 + }
203 +}
204 +
205 diff -urN linux.old/drivers/char/avalanche_vlynq/vlynq_drv.c linux.dev/drivers/char/avalanche_vlynq/vlynq_drv.c
206 --- linux.old/drivers/char/avalanche_vlynq/vlynq_drv.c 1970-01-01 01:00:00.000000000 +0100
207 +++ linux.dev/drivers/char/avalanche_vlynq/vlynq_drv.c 2005-07-22 06:32:53.345189608 +0200
208 @@ -0,0 +1,242 @@
209 +/******************************************************************************
210 + * FILE PURPOSE: Vlynq Linux Device Driver Source
211 + ******************************************************************************
212 + * FILE NAME: vlynq_drv.c
213 + *
214 + * DESCRIPTION: Vlynq Linux Device Driver Source
215 + *
216 + * REVISION HISTORY:
217 + *
218 + * Date Description Author
219 + *-----------------------------------------------------------------------------
220 + * 17 July 2003 Initial Creation Anant Gole
221 + * 17 Dec 2003 Updates Sharath Kumar
222 + *
223 + * (C) Copyright 2003, Texas Instruments, Inc
224 + *******************************************************************************/
225 +
226 +#include <linux/config.h>
227 +#include <linux/init.h>
228 +#include <linux/module.h>
229 +#include <linux/sched.h>
230 +#include <linux/miscdevice.h>
231 +#include <linux/smp_lock.h>
232 +#include <linux/delay.h>
233 +#include <linux/proc_fs.h>
234 +#include <linux/capability.h>
235 +#include <asm/ar7/avalanche_intc.h>
236 +#include <asm/ar7/sangam.h>
237 +#include <asm/ar7/vlynq.h>
238 +
239 +
240 +#define TI_VLYNQ_VERSION "0.2"
241 +
242 +/* debug on ? */
243 +#define VLYNQ_DEBUG
244 +
245 +/* Macro for debug and error printf's */
246 +#ifdef VLYNQ_DEBUG
247 +#define DBGPRINT printk
248 +#else
249 +#define DBGPRINT(x)
250 +#endif
251 +
252 +#define ERRPRINT printk
253 +
254 +/* Define the max vlynq ports this driver will support.
255 + Device name strings are statically added here */
256 +#define MAX_VLYNQ_PORTS 2
257 +
258 +
259 +/* Type define for VLYNQ private structure */
260 +typedef struct vlynqPriv{
261 + int irq;
262 + VLYNQ_DEV *vlynqDevice;
263 +}VLYNQ_PRIV;
264 +
265 +extern int vlynq_init_status[2];
266 +
267 +/* Extern Global variable for vlynq devices used in initialization of the vlynq device
268 + * These variables need to be populated/initialized by the system as part of initialization
269 + * process. The vlynq enumerator can run at initialization and populate these globals
270 + */
271 +
272 +VLYNQ_DEV vlynqDevice0;
273 +VLYNQ_DEV vlynqDevice1;
274 +
275 +/* Defining dummy macro AVALANCHE_HIGH_VLYNQ_INT to take
276 + * care of compilation in case of single vlynq device
277 + */
278 +
279 +#ifndef AVALANCHE_HIGH_VLYNQ_INT
280 +#define AVALANCHE_HIGH_VLYNQ_INT 0
281 +#endif
282 +
283 +
284 +
285 +/* vlynq private object */
286 +VLYNQ_PRIV vlynq_priv[CONFIG_AR7_VLYNQ_PORTS] = {
287 + { LNXINTNUM(AVALANCHE_LOW_VLYNQ_INT),&vlynqDevice0},
288 + { LNXINTNUM(AVALANCHE_HIGH_VLYNQ_INT),&vlynqDevice1},
289 +};
290 +
291 +extern void vlynq_dev_init(void);
292 +
293 +
294 +/* =================================== all the operations */
295 +
296 +static int
297 +vlynq_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
298 +{
299 + return 0;
300 +}
301 +
302 +static struct file_operations vlynq_fops = {
303 + owner: THIS_MODULE,
304 + ioctl: vlynq_ioctl,
305 +};
306 +
307 +/* Vlynq device object */
308 +static struct miscdevice vlynq_dev [MAX_VLYNQ_PORTS] = {
309 + { MISC_DYNAMIC_MINOR , "vlynq0", &vlynq_fops },
310 + { MISC_DYNAMIC_MINOR , "vlynq1", &vlynq_fops },
311 +};
312 +
313 +
314 +/* Proc read function */
315 +static int
316 +vlynq_read_link_proc(char *buf, char **start, off_t offset, int count, int *eof, void *unused)
317 +{
318 + int instance;
319 + int len = 0;
320 +
321 + len += sprintf(buf +len,"VLYNQ Devices : %d\n",CONFIG_AR7_VLYNQ_PORTS);
322 +
323 + for(instance =0;instance < CONFIG_AR7_VLYNQ_PORTS;instance++)
324 + {
325 + int link_state;
326 + char *link_msg[] = {" DOWN "," UP "};
327 +
328 + if(vlynq_init_status[instance] == 0)
329 + link_state = 0;
330 +
331 + else if (vlynq_link_check(vlynq_priv[instance].vlynqDevice))
332 + link_state = 1;
333 +
334 + else
335 + link_state = 0;
336 +
337 + len += sprintf(buf + len, "VLYNQ %d: Link state: %s\n",instance,link_msg[link_state]);
338 +
339 + }
340 + /* Print info about vlynq device 1 */
341 +
342 + return len;
343 +}
344 +
345 +
346 +/* Proc function to display driver version */
347 +static int
348 +vlynq_read_ver_proc(char *buf, char **start, off_t offset, int count, int *eof, void *data)
349 +{
350 + int instance;
351 + int len=0;
352 +
353 + len += sprintf(buf +len,"\nTI Linux VLYNQ Driver Version %s\n",TI_VLYNQ_VERSION);
354 + return len;
355 +}
356 +
357 +
358 +
359 +
360 +/* Wrapper for vlynq ISR */
361 +static void lnx_vlynq_root_isr(int irq, void * arg, struct pt_regs *regs)
362 +{
363 + vlynq_root_isr(arg);
364 +}
365 +
366 +/* =================================== init and cleanup */
367 +
368 +int vlynq_init_module(void)
369 +{
370 + int ret;
371 + int unit = 0;
372 + int instance_count = CONFIG_AR7_VLYNQ_PORTS;
373 + volatile int *ptr;
374 +
375 + vlynq_dev_init();
376 +
377 + DBGPRINT("Vlynq CONFIG_AR7_VLYNQ_PORTS=%d\n", CONFIG_AR7_VLYNQ_PORTS);
378 + /* If num of configured vlynq ports > supported by driver return error */
379 + if (instance_count > MAX_VLYNQ_PORTS)
380 + {
381 + ERRPRINT("ERROR: vlynq_init_module(): Max %d supported\n", MAX_VLYNQ_PORTS);
382 + return (-1);
383 + }
384 +
385 + /* register the misc device */
386 + for (unit = 0; unit < CONFIG_AR7_VLYNQ_PORTS; unit++)
387 + {
388 + ret = misc_register(&vlynq_dev[unit]);
389 +
390 + if(ret < 0)
391 + {
392 + ERRPRINT("ERROR:Could not register vlynq device:%d\n",unit);
393 + continue;
394 + }
395 + else
396 + DBGPRINT("Vlynq Device %s registered with minor no %d as misc device. Result=%d\n",
397 + vlynq_dev[unit].name, vlynq_dev[unit].minor, ret);
398 +#if 0
399 +
400 + DBGPRINT("Calling vlynq init\n");
401 +
402 + /* Read the global variable for VLYNQ device structure and initialize vlynq driver */
403 + ret = vlynq_init(vlynq_priv[unit].vlynqDevice,VLYNQ_INIT_PERFORM_ALL );
404 +#endif
405 +
406 + if(vlynq_init_status[unit] == 0)
407 + {
408 + printk("VLYNQ %d : init failed\n",unit);
409 + continue;
410 + }
411 +
412 + /* Check link before proceeding */
413 + if (!vlynq_link_check(vlynq_priv[unit].vlynqDevice))
414 + {
415 + DBGPRINT("\nError: Vlynq link not available.trying once before Exiting");
416 + }
417 + else
418 + {
419 + DBGPRINT("Vlynq instance:%d Link UP\n",unit);
420 +
421 + /* Install the vlynq local root ISR */
422 + request_irq(vlynq_priv[unit].irq,lnx_vlynq_root_isr,0,vlynq_dev[unit].name,vlynq_priv[unit].vlynqDevice);
423 + }
424 + }
425 +
426 + /* Creating proc entry for the devices */
427 + create_proc_read_entry("avalanche/vlynq_link", 0, NULL, vlynq_read_link_proc, NULL);
428 + create_proc_read_entry("avalanche/vlynq_ver", 0, NULL, vlynq_read_ver_proc, NULL);
429 +
430 + return 0;
431 +}
432 +
433 +void vlynq_cleanup_module(void)
434 +{
435 + int unit = 0;
436 +
437 + for (unit = 0; unit < CONFIG_AR7_VLYNQ_PORTS; unit++)
438 + {
439 + DBGPRINT("vlynq_cleanup_module(): Unregistring misc device %s\n",vlynq_dev[unit].name);
440 + misc_deregister(&vlynq_dev[unit]);
441 + }
442 +
443 + remove_proc_entry("avalanche/vlynq_link", NULL);
444 + remove_proc_entry("avalanche/vlynq_ver", NULL);
445 +}
446 +
447 +
448 +module_init(vlynq_init_module);
449 +module_exit(vlynq_cleanup_module);
450 +
451 diff -urN linux.old/drivers/char/avalanche_vlynq/vlynq_hal.c linux.dev/drivers/char/avalanche_vlynq/vlynq_hal.c
452 --- linux.old/drivers/char/avalanche_vlynq/vlynq_hal.c 1970-01-01 01:00:00.000000000 +0100
453 +++ linux.dev/drivers/char/avalanche_vlynq/vlynq_hal.c 2005-07-22 06:32:53.359187480 +0200
454 @@ -0,0 +1,1214 @@
455 +/***************************************************************************
456 +**+----------------------------------------------------------------------+**
457 +**| **** |**
458 +**| **** |**
459 +**| ******o*** |**
460 +**| ********_///_**** |**
461 +**| ***** /_//_/ **** |**
462 +**| ** ** (__/ **** |**
463 +**| ********* |**
464 +**| **** |**
465 +**| *** |**
466 +**| |**
467 +**| Copyright (c) 2003 Texas Instruments Incorporated |**
468 +**| ALL RIGHTS RESERVED |**
469 +**| |**
470 +**| Permission is hereby granted to licensees of Texas Instruments |**
471 +**| Incorporated (TI) products to use this computer program for the sole |**
472 +**| purpose of implementing a licensee product based on TI products. |**
473 +**| No other rights to reproduce, use, or disseminate this computer |**
474 +**| program, whether in part or in whole, are granted. |**
475 +**| |**
476 +**| TI makes no representation or warranties with respect to the |**
477 +**| performance of this computer program, and specifically disclaims |**
478 +**| any responsibility for any damages, special or consequential, |**
479 +**| connected with the use of this program. |**
480 +**| |**
481 +**+----------------------------------------------------------------------+**
482 +***************************************************************************/
483 +
484 +/***************************************************************************
485 + * ------------------------------------------------------------------------------
486 + * Module : vlynq_hal.c
487 + * Description : This file implements VLYNQ HAL API.
488 + * ------------------------------------------------------------------------------
489 + ***************************************************************************/
490 +
491 +#include <linux/stddef.h>
492 +#include <linux/types.h>
493 +#include <asm/ar7/vlynq.h>
494 +
495 +/**** Local Function prototypes *******/
496 +static int vlynqInterruptInit(VLYNQ_DEV *pdev);
497 +static void vlynq_configClock(VLYNQ_DEV *pdev);
498 +
499 +/*** Second argument must be explicitly type casted to
500 + * (VLYNQ_DEV*) inside the following functions */
501 +static void vlynq_local_module_isr(void *arg1, void *arg2, void *arg3);
502 +static void vlynq_remote_module_isr(void *arg1, void *arg2, void *arg3);
503 +
504 +
505 +volatile int vlynq_delay_value = 0;
506 +
507 +/* Code adopted from original vlynq driver */
508 +void vlynq_delay(unsigned int clktime)
509 +{
510 + int i = 0;
511 + volatile int *ptr = &vlynq_delay_value;
512 + *ptr = 0;
513 +
514 + /* We are assuming that the each cycle takes about
515 + * 23 assembly instructions. */
516 + for(i = 0; i < (clktime + 23)/23; i++)
517 + {
518 + *ptr = *ptr + 1;
519 + }
520 +}
521 +
522 +
523 +/* ----------------------------------------------------------------------------
524 + * Function : vlynq_configClock()
525 + * Description: Configures clock settings based on input parameters
526 + * Adapted from original vlyna driver from Cable
527 + */
528 +static void vlynq_configClock(VLYNQ_DEV * pdev)
529 +{
530 + unsigned int tmp;
531 +
532 + switch( pdev->clk_source)
533 + {
534 + case VLYNQ_CLK_SOURCE_LOCAL: /* we output the clock, clk_div in range [1..8]. */
535 + tmp = ((pdev->clk_div - 1) << 16) | VLYNQ_CTL_CLKDIR_MASK ;
536 + VLYNQ_CTRL_REG = tmp;
537 + VLYNQ_R_CTRL_REG = 0ul;
538 + break;
539 + case VLYNQ_CLK_SOURCE_REMOTE: /* we need to set the clock pin as input */
540 + VLYNQ_CTRL_REG = 0ul;
541 + tmp = ((pdev->clk_div - 1) << 16) | VLYNQ_CTL_CLKDIR_MASK ;
542 + VLYNQ_R_CTRL_REG = tmp;
543 + break;
544 + default: /* do nothing about the clock, but clear other bits. */
545 + tmp = ~(VLYNQ_CTL_CLKDIR_MASK | VLYNQ_CTL_CLKDIV_MASK);
546 + VLYNQ_CTRL_REG &= tmp;
547 + break;
548 + }
549 +}
550 +
551 + /* ----------------------------------------------------------------------------
552 + * Function : vlynq_link_check()
553 + * Description: This function checks the current VLYNQ for a link.
554 + * An arbitrary amount of time is allowed for the link to come up .
555 + * Returns 0 for "no link / failure " and 1 for "link available".
556 + * -----------------------------------------------------------------------------
557 + */
558 +unsigned int vlynq_link_check( VLYNQ_DEV * pdev)
559 +{
560 + /*sleep for 64 cycles, allow link to come up*/
561 + vlynq_delay(64);
562 +
563 + /* check status register return OK if link is found. */
564 + if (VLYNQ_STATUS_REG & VLYNQ_STS_LINK_MASK)
565 + {
566 + return 1; /* Link Available */
567 + }
568 + else
569 + {
570 + return 0; /* Link Failure */
571 + }
572 +}
573 +
574 +/* ----------------------------------------------------------------------------
575 + * Function : vlynq_init()
576 + * Description: Initialization function accepting paramaters for VLYNQ module
577 + * initialization. The Options bitmap decides what operations are performed
578 + * as a part of initialization. The Input parameters are obtained through the
579 + * sub fields of VLYNQ_DEV structure.
580 + */
581 +
582 +int vlynq_init(VLYNQ_DEV *pdev, VLYNQ_INIT_OPTIONS options)
583 +{
584 + unsigned int map;
585 + unsigned int val=0,cnt,tmp;
586 + unsigned int counter=0;
587 + VLYNQ_INTERRUPT_CNTRL *intSetting=NULL;
588 +
589 + /* validate arguments */
590 + if( VLYNQ_OUTRANGE(pdev->clk_source, VLYNQ_CLK_SOURCE_REMOTE, VLYNQ_CLK_SOURCE_NONE) ||
591 + VLYNQ_OUTRANGE(pdev->clk_div, 8, 1) )
592 + {
593 + return VLYNQ_INVALID_ARG;
594 + }
595 +
596 + /** perform all sanity checks first **/
597 + if(pdev->state != VLYNQ_DRV_STATE_UNINIT)
598 + return VLYNQ_INVALID_DRV_STATE;
599 +
600 + /** Initialize local and remote register set addresses- additional
601 + * provision to access the registers directly if need be */
602 + pdev->local = (VLYNQ_REG_SET*)pdev->module_base;
603 + pdev->remote = (VLYNQ_REG_SET*) (pdev->module_base + VLYNQ_REMOTE_REGS_OFFSET);
604 +
605 + /* Detect faulty int configuration that might induce int pkt looping */
606 + if ( (options & VLYNQ_INIT_LOCAL_INTERRUPTS) && (options & VLYNQ_INIT_REMOTE_INTERRUPTS) )
607 + {
608 + /* case when both local and remote are configured */
609 + if((pdev->local_irq.intLocal== VLYNQ_INT_REMOTE ) /* interrupts transfered to remote from local */
610 + && (pdev->remote_irq.intLocal== VLYNQ_INT_REMOTE) /* interrupts transfered from remote to local */
611 + && ((pdev->local_irq.intRemote == VLYNQ_INT_ROOT_ISR) || (pdev->remote_irq.intRemote == VLYNQ_INT_ROOT_ISR)) )
612 + {
613 + return (VLYNQ_INT_CONFIG_ERR);
614 + }
615 + }
616 +
617 + pdev->state = VLYNQ_DRV_STATE_ININIT;
618 + pdev->intCount = 0;
619 + pdev->isrCount = 0;
620 +
621 + /*** Its assumed that the vlynq module has been brought out of reset
622 + * before invocation of vlynq_init. Since, this operation is board specific
623 + * it must be handled outside this generic driver */
624 +
625 + /* Assert reset the remote device, call reset_cb,
626 + * reset CB holds Reset according to the device needs. */
627 + VLYNQ_RESETCB(VLYNQ_RESET_ASSERT);
628 +
629 + /* Handle VLYNQ clock, HW default (Sense On Reset) is
630 + * usually input for all the devices. */
631 + if (options & VLYNQ_INIT_CONFIG_CLOCK)
632 + {
633 + vlynq_configClock(pdev);
634 + }
635 +
636 + /* Call reset_cb again. It will release the remote device
637 + * from reset, and wait for a while. */
638 + VLYNQ_RESETCB(VLYNQ_RESET_DEASSERT);
639 +
640 + if(options & VLYNQ_INIT_CHECK_LINK )
641 + {
642 + /* Check for link up during initialization*/
643 + while( counter < 25 )
644 + {
645 + /* loop around giving a chance for link status to settle down */
646 + counter++;
647 + if(vlynq_link_check(pdev))
648 + {
649 + /* Link is up exit loop*/
650 + break;
651 + }
652 +
653 + vlynq_delay(4000);
654 + }/*end of while counter loop */
655 +
656 + if(!vlynq_link_check(pdev))
657 + {
658 + /* Handle this case as abort */
659 + pdev->state = VLYNQ_DRV_STATE_ERROR;
660 + VLYNQ_RESETCB( VLYNQ_RESET_INITFAIL);
661 + return VLYNQ_LINK_DOWN;
662 + }/* end of if not vlynq_link_check conditional block */
663 +
664 + }/*end of if options & VLYNQ_INIT_CHECK_LINK conditional block */
665 +
666 +
667 + if (options & VLYNQ_INIT_LOCAL_MEM_REGIONS)
668 + {
669 + /* Initialise local memory regions . This initialization lets
670 + * the local host access remote device memory regions*/
671 + int i;
672 +
673 + /* configure the VLYNQ portal window to a PHYSICAL
674 + * address of the local CPU */
675 + VLYNQ_ALIGN4(pdev->local_mem.Txmap);
676 + VLYNQ_TXMAP_REG = (pdev->local_mem.Txmap);
677 +
678 + /*This code assumes input parameter is itself a physical address */
679 + for(i=0; i < VLYNQ_MAX_MEMORY_REGIONS ; i++)
680 + {
681 + /* Physical address on the remote */
682 + map = i+1;
683 + VLYNQ_R_RXMAP_SIZE_REG(map) = 0;
684 + if( pdev->remote_mem.RxSize[i])
685 + {
686 + VLYNQ_ALIGN4(pdev->remote_mem.RxOffset[i]);
687 + VLYNQ_ALIGN4(pdev->remote_mem.RxSize[i]);
688 + VLYNQ_R_RXMAP_OFFSET_REG(map) = pdev->remote_mem.RxOffset[i];
689 + VLYNQ_R_RXMAP_SIZE_REG(map) = pdev->remote_mem.RxSize[i];
690 + }
691 + }
692 + }
693 +
694 + if(options & VLYNQ_INIT_REMOTE_MEM_REGIONS )
695 + {
696 + int i;
697 +
698 + /* Initialise remote memory regions. This initialization lets remote
699 + * device access local host memory regions. It configures the VLYNQ portal
700 + * window to a PHYSICAL address of the remote */
701 + VLYNQ_ALIGN4(pdev->remote_mem.Txmap);
702 + VLYNQ_R_TXMAP_REG = pdev->remote_mem.Txmap;
703 +
704 + for( i=0; i<VLYNQ_MAX_MEMORY_REGIONS; i++)
705 + {
706 + /* Physical address on the local */
707 + map = i+1;
708 + VLYNQ_RXMAP_SIZE_REG(map) = 0;
709 + if( pdev->local_mem.RxSize[i])
710 + {
711 + VLYNQ_ALIGN4(pdev->local_mem.RxOffset[i]);
712 + VLYNQ_ALIGN4(pdev->local_mem.RxSize[i]);
713 + VLYNQ_RXMAP_OFFSET_REG(map) = (pdev->local_mem.RxOffset[i]);
714 + VLYNQ_RXMAP_SIZE_REG(map) = (pdev->local_mem.RxSize[i]);
715 + }
716 + }
717 + }
718 +
719 + /* Adapted from original vlynq driver from cable - Calculate VLYNQ bus width */
720 + pdev->width = 3 + VLYNQ_STATUS_FLD_WIDTH(VLYNQ_STATUS_REG)
721 + + VLYNQ_STATUS_FLD_WIDTH(VLYNQ_R_STATUS_REG);
722 +
723 + /* chance to initialize the device, e.g. to boost VLYNQ
724 + * clock by modifying pdev->clk_div or and verify the width. */
725 + VLYNQ_RESETCB(VLYNQ_RESET_LINKESTABLISH);
726 +
727 + /* Handle VLYNQ clock, HW default (Sense On Reset) is
728 + * usually input for all the devices. */
729 + if(options & VLYNQ_INIT_CONFIG_CLOCK )
730 + {
731 + vlynq_configClock(pdev);
732 + }
733 +
734 + /* last check for link*/
735 + if(options & VLYNQ_INIT_CHECK_LINK )
736 + {
737 + /* Final Check for link during initialization*/
738 + while( counter < 25 )
739 + {
740 + /* loop around giving a chance for link status to settle down */
741 + counter++;
742 + if(vlynq_link_check(pdev))
743 + {
744 + /* Link is up exit loop*/
745 + break;
746 + }
747 +
748 + vlynq_delay(4000);
749 + }/*end of while counter loop */
750 +
751 + if(!vlynq_link_check(pdev))
752 + {
753 + /* Handle this case as abort */
754 + pdev->state = VLYNQ_DRV_STATE_ERROR;
755 + VLYNQ_RESETCB( VLYNQ_RESET_INITFAIL);
756 + return VLYNQ_LINK_DOWN;
757 + }/* end of if not vlynq_link_check conditional block */
758 +
759 + } /* end of if options & VLYNQ_INIT_CHECK_LINK */
760 +
761 + if(options & VLYNQ_INIT_LOCAL_INTERRUPTS )
762 + {
763 + /* Configure local interrupt settings */
764 + intSetting = &(pdev->local_irq);
765 +
766 + /* Map local module status interrupts to interrupt vector*/
767 + val = intSetting->map_vector << VLYNQ_CTL_INTVEC_SHIFT ;
768 +
769 + /* enable local module status interrupts */
770 + val |= 0x01 << VLYNQ_CTL_INTEN_SHIFT;
771 +
772 + if ( intSetting->intLocal == VLYNQ_INT_LOCAL )
773 + {
774 + /*set the intLocal bit*/
775 + val |= 0x01 << VLYNQ_CTL_INTLOCAL_SHIFT;
776 + }
777 +
778 + /* Irrespective of whether interrupts are handled locally, program
779 + * int2Cfg. Error checking for accidental loop(when intLocal=0 and int2Cfg=1
780 + * i.e remote packets are set intPending register->which will result in
781 + * same packet being sent out) has been done already
782 + */
783 +
784 + if (intSetting->intRemote == VLYNQ_INT_ROOT_ISR)
785 + {
786 + /* Set the int2Cfg register, so that remote interrupt
787 + * packets are written to intPending register */
788 + val |= 0x01 << VLYNQ_CTL_INT2CFG_SHIFT;
789 +
790 + /* Set intPtr register to point to intPending register */
791 + VLYNQ_INT_PTR_REG = VLYNQ_INT_PENDING_REG_PTR ;
792 + }
793 + else
794 + {
795 + /*set the interrupt pointer register*/
796 + VLYNQ_INT_PTR_REG = intSetting->intr_ptr;
797 + /* Dont bother to modify int2Cfg as it would be zero */
798 + }
799 +
800 + /** Clear bits related to INT settings in control register **/
801 + VLYNQ_CTRL_REG = VLYNQ_CTRL_REG & (~VLYNQ_CTL_INTFIELDS_CLEAR_MASK);
802 +
803 + /** Or the bits to be set with Control register **/
804 + VLYNQ_CTRL_REG = VLYNQ_CTRL_REG | val;
805 +
806 + /* initialise local ICB */
807 + if(vlynqInterruptInit(pdev)==VLYNQ_MEMALLOC_FAIL)
808 + return VLYNQ_MEMALLOC_FAIL;
809 +
810 + /* Install handler for local module status interrupts. By default when
811 + * local interrupt setting is initialised, the local module status are
812 + * enabled and handler hooked up */
813 + if(vlynq_install_isr(pdev, intSetting->map_vector, vlynq_local_module_isr,
814 + pdev, NULL, NULL) == VLYNQ_INVALID_ARG)
815 + return VLYNQ_INVALID_ARG;
816 + } /* end of init local interrupts */
817 +
818 + if(options & VLYNQ_INIT_REMOTE_INTERRUPTS )
819 + {
820 + /* Configure remote interrupt settings from configuration */
821 + intSetting = &(pdev->remote_irq);
822 +
823 + /* Map remote module status interrupts to remote interrupt vector*/
824 + val = intSetting->map_vector << VLYNQ_CTL_INTVEC_SHIFT ;
825 + /* enable remote module status interrupts */
826 + val |= 0x01 << VLYNQ_CTL_INTEN_SHIFT;
827 +
828 + if ( intSetting->intLocal == VLYNQ_INT_LOCAL )
829 + {
830 + /*set the intLocal bit*/
831 + val |= 0x01 << VLYNQ_CTL_INTLOCAL_SHIFT;
832 + }
833 +
834 + /* Irrespective of whether interrupts are handled locally, program
835 + * int2Cfg. Error checking for accidental loop(when intLocal=0 and int2Cfg=1
836 + * i.e remote packets are set intPending register->which will result in
837 + * same packet being sent out) has been done already
838 + */
839 +
840 + if (intSetting->intRemote == VLYNQ_INT_ROOT_ISR)
841 + {
842 + /* Set the int2Cfg register, so that remote interrupt
843 + * packets are written to intPending register */
844 + val |= 0x01 << VLYNQ_CTL_INT2CFG_SHIFT;
845 + /* Set intPtr register to point to intPending register */
846 + VLYNQ_R_INT_PTR_REG = VLYNQ_R_INT_PENDING_REG_PTR ;
847 + }
848 + else
849 + {
850 + /*set the interrupt pointer register*/
851 + VLYNQ_R_INT_PTR_REG = intSetting->intr_ptr;
852 + /* Dont bother to modify int2Cfg as it would be zero */
853 + }
854 +
855 + if( (intSetting->intLocal == VLYNQ_INT_REMOTE) &&
856 + (options & VLYNQ_INIT_LOCAL_INTERRUPTS) &&
857 + (pdev->local_irq.intRemote == VLYNQ_INT_ROOT_ISR) )
858 + {
859 + /* Install handler for remote module status interrupts. By default when
860 + * remote interrupts are forwarded to local root_isr then remote_module_isr is
861 + * enabled and handler hooked up */
862 + if(vlynq_install_isr(pdev,intSetting->map_vector,vlynq_remote_module_isr,
863 + pdev, NULL, NULL) == VLYNQ_INVALID_ARG)
864 + return VLYNQ_INVALID_ARG;
865 + }
866 +
867 +
868 + /** Clear bits related to INT settings in control register **/
869 + VLYNQ_R_CTRL_REG = VLYNQ_R_CTRL_REG & (~VLYNQ_CTL_INTFIELDS_CLEAR_MASK);
870 +
871 + /** Or the bits to be set with the remote Control register **/
872 + VLYNQ_R_CTRL_REG = VLYNQ_R_CTRL_REG | val;
873 +
874 + } /* init remote interrupt settings*/
875 +
876 + if(options & VLYNQ_INIT_CLEAR_ERRORS )
877 + {
878 + /* Clear errors during initialization */
879 + tmp = VLYNQ_STATUS_REG & (VLYNQ_STS_RERROR_MASK | VLYNQ_STS_LERROR_MASK);
880 + VLYNQ_STATUS_REG = tmp;
881 + tmp = VLYNQ_R_STATUS_REG & (VLYNQ_STS_RERROR_MASK | VLYNQ_STS_LERROR_MASK);
882 + VLYNQ_R_STATUS_REG = tmp;
883 + }
884 +
885 + /* clear int status */
886 + val = VLYNQ_INT_STAT_REG;
887 + VLYNQ_INT_STAT_REG = val;
888 +
889 + /* finish initialization */
890 + pdev->state = VLYNQ_DRV_STATE_RUN;
891 + VLYNQ_RESETCB( VLYNQ_RESET_INITOK);
892 + return VLYNQ_SUCCESS;
893 +
894 +}
895 +
896 +
897 +/* ----------------------------------------------------------------------------
898 + * Function : vlynqInterruptInit()
899 + * Description: This local function is used to set up the ICB table for the
900 + * VLYNQ_STATUS_REG vlynq module. The input parameter "pdev" points the vlynq
901 + * device instance whose ICB is allocated.
902 + * Return : returns VLYNQ_SUCCESS or vlynq error for failure
903 + * -----------------------------------------------------------------------------
904 + */
905 +static int vlynqInterruptInit(VLYNQ_DEV *pdev)
906 +{
907 + int i, numslots;
908 +
909 + /* Memory allocated statically.
910 + * Initialise ICB,free list.Indicate primary slot empty.
911 + * Intialise intVector <==> map_vector translation table*/
912 + for(i=0; i < VLYNQ_NUM_INT_BITS; i++)
913 + {
914 + pdev->pIntrCB[i].isr = NULL;
915 + pdev->pIntrCB[i].next = NULL; /*nothing chained */
916 + pdev->vector_map[i] = -1; /* indicates unmapped */
917 + }
918 +
919 + /* In the ICB slots, [VLYNQ_NUM_INT_BITS i.e 32 to ICB array size) are expansion slots
920 + * required only when interrupt chaining/sharing is supported. In case
921 + * of chained interrupts the list starts from primary slot and the
922 + * additional slots are obtained from the common free area */
923 +
924 + /* Initialise freelist */
925 +
926 + numslots = VLYNQ_NUM_INT_BITS + VLYNQ_IVR_CHAIN_SLOTS;
927 +
928 + if (numslots > VLYNQ_NUM_INT_BITS)
929 + {
930 + pdev->freelist = &(pdev->pIntrCB[VLYNQ_NUM_INT_BITS]);
931 +
932 + for(i = VLYNQ_NUM_INT_BITS; i < (numslots-1) ; i++)
933 + {
934 + pdev->pIntrCB[i].next = &(pdev->pIntrCB[i+1]);
935 + pdev->pIntrCB[i].isr = NULL;
936 + }
937 + pdev->pIntrCB[i].next=NULL; /* Indicate end of freelist*/
938 + pdev->pIntrCB[i].isr=NULL;
939 + }
940 + else
941 + {
942 + pdev->freelist = NULL;
943 + }
944 +
945 + /** Reset mapping for IV 0-7 **/
946 + VLYNQ_IVR_03TO00_REG = 0;
947 + VLYNQ_IVR_07TO04_REG = 0;
948 +
949 + return VLYNQ_SUCCESS;
950 +}
951 +
952 +/** remember that hooking up of root ISR handler with the interrupt controller
953 + * is not done as a part of this driver. Typically, it must be done after
954 + * invoking vlynq_init*/
955 +
956 +
957 + /* ----------------------------------------------------------------------------
958 + * ISR with the SOC interrupt controller. This ISR typically scans
959 + * the Int PENDING/SET register in the VLYNQ module and calls the
960 + * appropriate ISR associated with the correponding vector number.
961 + * -----------------------------------------------------------------------------
962 + */
963 +void vlynq_root_isr(void *arg)
964 +{
965 + int source; /* Bit position of pending interrupt, start from 0 */
966 + unsigned int interrupts, clrInterrupts;
967 + VLYNQ_DEV * pdev;
968 + VLYNQ_INTR_CNTRL_ICB *entry;
969 +
970 + pdev=(VLYNQ_DEV*)(arg); /*obtain the vlynq device pointer*/
971 +
972 + interrupts = VLYNQ_INT_STAT_REG; /* Get the list of pending interrupts */
973 + VLYNQ_INT_STAT_REG = interrupts; /* clear the int CR register */
974 + clrInterrupts = interrupts; /* save them for further analysis */
975 +
976 + debugPrint("vlynq_root_isr: dev %u. INTCR = 0x%08lx\n", pdev->dev_idx, clrInterrupts,0,0,0,0);
977 +
978 + /* Scan interrupt bits */
979 + source =0;
980 + while( clrInterrupts != 0)
981 + {
982 + /* test if bit is set? */
983 + if( 0x1ul & clrInterrupts)
984 + {
985 + entry = &(pdev->pIntrCB[source]); /* Get the ISR entry */
986 + pdev->intCount++; /* update interrupt count */
987 + if(entry->isr != NULL)
988 + {
989 + do
990 + {
991 + pdev->isrCount++; /* update isr invocation count */
992 + /* Call the user ISR and update the count for ISR */
993 + entry->isrCount++;
994 + entry->isr(entry->arg1, entry->arg2, entry->arg3);
995 + if (entry->next == NULL) break;
996 + entry = entry->next;
997 +
998 + } while (entry->isr != NULL);
999 + }
1000 + else
1001 + {
1002 + debugPrint(" ISR not installed for vlynq vector:%d\n",source,0,0,0,0,0);
1003 + }
1004 + }
1005 + clrInterrupts >>= 1; /* Next source bit */
1006 + ++source;
1007 + } /* endWhile clrInterrupts != 0 */
1008 +}
1009 +
1010 +
1011 + /* ----------------------------------------------------------------------------
1012 + * Function : vlynq_local__module_isr()
1013 + * Description: This ISR is attached to the local VLYNQ interrupt vector
1014 + * by the Vlynq Driver when local interrupts are being handled. i.e.
1015 + * intLocal=1. This ISR handles local Vlynq module status interrupts only
1016 + * AS a part of this ISR, user callback in VLYNQ_DEV structure
1017 + * is invoked.
1018 + * VLYNQ_DEV is passed as arg1. arg2 and arg3 are unused.
1019 + * -----------------------------------------------------------------------------
1020 + */
1021 +static void vlynq_local_module_isr(void *arg1,void *arg2, void *arg3)
1022 +{
1023 + VLYNQ_REPORT_CB func;
1024 + unsigned int dwStatRegVal;
1025 + VLYNQ_DEV * pdev;
1026 +
1027 + pdev = (VLYNQ_DEV*) arg1;
1028 + /* Callback function is read from the device pointer that is passed as an argument */
1029 + func = pdev->report_cb;
1030 +
1031 + /* read local status register */
1032 + dwStatRegVal = VLYNQ_STATUS_REG;
1033 +
1034 + /* clear pending events */
1035 + VLYNQ_STATUS_REG = dwStatRegVal;
1036 +
1037 + /* invoke user callback */
1038 + if( func != NULL)
1039 + func( pdev, VLYNQ_LOCAL_DVC, dwStatRegVal);
1040 +
1041 +}
1042 +
1043 + /* ----------------------------------------------------------------------------
1044 + * Function : vlynq_remote_module_isr()
1045 + * Description: This ISR is attached to the remote VLYNQ interrupt vector
1046 + * by the Vlynq Driver when remote interrupts are being handled locally. i.e.
1047 + * intLocal=1. This ISR handles local Vlynq module status interrupts only
1048 + * AS a part of this ISR, user callback in VLYNQ_DEV structure
1049 + * is invoked.
1050 + * The parameters irq,regs ar unused.
1051 + * -----------------------------------------------------------------------------
1052 + */
1053 +static void vlynq_remote_module_isr(void *arg1,void *arg2, void *arg3)
1054 +{
1055 + VLYNQ_REPORT_CB func;
1056 + unsigned int dwStatRegVal;
1057 + VLYNQ_DEV * pdev;
1058 +
1059 +
1060 + pdev = (VLYNQ_DEV*) arg1;
1061 +
1062 + /* Callback function is read from the device pointer that is passed as an argument */
1063 + func = pdev->report_cb;
1064 +
1065 + /* read local status register */
1066 + dwStatRegVal = VLYNQ_R_STATUS_REG;
1067 +
1068 + /* clear pending events */
1069 + VLYNQ_R_STATUS_REG = dwStatRegVal;
1070 +
1071 + /* invoke user callback */
1072 + if( func != NULL)
1073 + func( pdev, VLYNQ_REMOTE_DVC, dwStatRegVal);
1074 +
1075 +}
1076 +
1077 +/* ----------------------------------------------------------------------------
1078 + * Function : vlynq_interrupt_get_count()
1079 + * Description: This function returns the number of times a particular intr
1080 + * has been invoked.
1081 + *
1082 + * It returns 0, if erroneous map_vector is specified or if the corres isr
1083 + * has not been registered with VLYNQ.
1084 + */
1085 +unsigned int vlynq_interrupt_get_count(VLYNQ_DEV *pdev,
1086 + unsigned int map_vector)
1087 +{
1088 + VLYNQ_INTR_CNTRL_ICB *entry;
1089 + unsigned int count = 0;
1090 +
1091 + if (map_vector > (VLYNQ_NUM_INT_BITS-1))
1092 + return count;
1093 +
1094 + entry = &(pdev->pIntrCB[map_vector]);
1095 +
1096 + if (entry)
1097 + count = entry->isrCount;
1098 +
1099 + return (count);
1100 +}
1101 +
1102 +
1103 +/* ----------------------------------------------------------------------------
1104 + * Function : vlynq_install_isr()
1105 + * Description: This function installs ISR for Vlynq interrupt vector
1106 + * bits(in IntPending register). This function should be used only when
1107 + * Vlynq interrupts are being handled locally(remote may be programmed to send
1108 + * interrupt packets).Also, the int2cfg should be 1 and the least significant
1109 + * 8 bits of the Interrupt Pointer Register must point to Interrupt
1110 + * Pending/Set Register).
1111 + * If host int2cfg=0 and the Interrupt Pointer register contains
1112 + * the address of the interrupt set register in the interrupt controller
1113 + * module of the local device , then the ISR for the remote interrupt must be
1114 + * directly registered with the Interrupt controller and must not use this API
1115 + * Note: this function simply installs the ISR in ICB It doesnt modify
1116 + * any register settings
1117 + */
1118 +int
1119 +vlynq_install_isr(VLYNQ_DEV *pdev,
1120 + unsigned int map_vector,
1121 + VLYNQ_INTR_CNTRL_ISR isr,
1122 + void *arg1, void *arg2, void *arg3)
1123 +{
1124 + VLYNQ_INTR_CNTRL_ICB *entry;
1125 +
1126 + if ( (map_vector > (VLYNQ_NUM_INT_BITS-1)) || (isr == NULL) )
1127 + return VLYNQ_INVALID_ARG;
1128 +
1129 + entry = &(pdev->pIntrCB[map_vector]);
1130 +
1131 + if(entry->isr == NULL)
1132 + {
1133 + entry->isr = isr;
1134 + entry->arg1 = arg1;
1135 + entry->arg2 = arg2;
1136 + entry->arg3 = arg3;
1137 + entry->next = NULL;
1138 + }
1139 + else
1140 + {
1141 + /** No more empty slots,return error */
1142 + if(pdev->freelist == NULL)
1143 + return VLYNQ_MEMALLOC_FAIL;
1144 +
1145 + while(entry->next != NULL)
1146 + {
1147 + entry = entry->next;
1148 + }
1149 +
1150 + /* Append new node to the chain */
1151 + entry->next = pdev->freelist;
1152 + /* Remove the appended node from freelist */
1153 + pdev->freelist = pdev->freelist->next;
1154 + entry= entry->next;
1155 +
1156 + /*** Set the ICB fields ***/
1157 + entry->isr = isr;
1158 + entry->arg1 = arg1;
1159 + entry->arg2 = arg2;
1160 + entry->arg3 = arg3;
1161 + entry->next = NULL;
1162 + }
1163 +
1164 + return VLYNQ_SUCCESS;
1165 +}
1166 +
1167 +
1168 +
1169 +/* ----------------------------------------------------------------------------
1170 + * Function : vlynq_uninstall_isr
1171 + * Description: This function is used to uninstall a previously
1172 + * registered ISR. In case of shared/chained interrupts, the
1173 + * void * arg parameter must uniquely identify the ISR to be
1174 + * uninstalled.
1175 + * Note: this function simply uninstalls the ISR in ICB
1176 + * It doesnt modify any register settings
1177 + */
1178 +int
1179 +vlynq_uninstall_isr(VLYNQ_DEV *pdev,
1180 + unsigned int map_vector,
1181 + void *arg1, void *arg2, void *arg3)
1182 +{
1183 + VLYNQ_INTR_CNTRL_ICB *entry,*temp;
1184 +
1185 + if (map_vector > (VLYNQ_NUM_INT_BITS-1))
1186 + return VLYNQ_INVALID_ARG;
1187 +
1188 + entry = &(pdev->pIntrCB[map_vector]);
1189 +
1190 + if(entry->isr == NULL )
1191 + return VLYNQ_ISR_NON_EXISTENT;
1192 +
1193 + if ( (entry->arg1 == arg1) && (entry->arg2 == arg2) && (entry->arg3 == arg3) )
1194 + {
1195 + if(entry->next == NULL)
1196 + {
1197 + entry->isr=NULL;
1198 + return VLYNQ_SUCCESS;
1199 + }
1200 + else
1201 + {
1202 + temp = entry->next;
1203 + /* Copy next node in the chain to prim.slot */
1204 + entry->isr = temp->isr;
1205 + entry->arg1 = temp->arg1;
1206 + entry->arg2 = temp->arg2;
1207 + entry->arg3 = temp->arg3;
1208 + entry->next = temp->next;
1209 + /* Free the just copied node */
1210 + temp->isr = NULL;
1211 + temp->arg1 = NULL;
1212 + temp->arg2 = NULL;
1213 + temp->arg3 = NULL;
1214 + temp->next = pdev->freelist;
1215 + pdev->freelist = temp;
1216 + return VLYNQ_SUCCESS;
1217 + }
1218 + }
1219 + else
1220 + {
1221 + temp = entry;
1222 + while ( (entry = temp->next) != NULL)
1223 + {
1224 + if ( (entry->arg1 == arg1) && (entry->arg2 == arg2) && (entry->arg3 == arg3) )
1225 + {
1226 + /* remove node from chain */
1227 + temp->next = entry->next;
1228 + /* Add the removed node to freelist */
1229 + entry->isr = NULL;
1230 + entry->arg1 = NULL;
1231 + entry->arg2 = NULL;
1232 + entry->arg3 = NULL;
1233 + entry->next = pdev->freelist;
1234 + entry->isrCount = 0;
1235 + pdev->freelist = entry;
1236 + return VLYNQ_SUCCESS;
1237 + }
1238 + temp = entry;
1239 + }
1240 +
1241 + return VLYNQ_ISR_NON_EXISTENT;
1242 + }
1243 +}
1244 +
1245 +
1246 +
1247 +
1248 +/* ----------------------------------------------------------------------------
1249 + * function : vlynq_interrupt_vector_set()
1250 + * description:configures interrupt vector mapping,interrupt type
1251 + * polarity -all in one go.
1252 + */
1253 +int
1254 +vlynq_interrupt_vector_set(VLYNQ_DEV *pdev, /* vlynq device */
1255 + unsigned int int_vector, /* int vector on vlynq device */
1256 + unsigned int map_vector, /* bit for this interrupt */
1257 + VLYNQ_DEV_TYPE dev_type, /* local or remote device */
1258 + VLYNQ_INTR_POLARITY pol, /* polarity of interrupt */
1259 + VLYNQ_INTR_TYPE type) /* pulsed/level interrupt */
1260 +{
1261 + volatile unsigned int * vecreg;
1262 + unsigned int val=0;
1263 + unsigned int bytemask=0XFF;
1264 +
1265 + /* use the lower 8 bits of val to set the value , shift it to
1266 + * appropriate byte position in the ivr and write it to the
1267 + * corresponding register */
1268 +
1269 + /* validate the number of interrupts supported */
1270 + if (int_vector >= VLYNQ_IVR_MAXIVR)
1271 + return VLYNQ_INVALID_ARG;
1272 +
1273 + if(map_vector > (VLYNQ_NUM_INT_BITS - 1) )
1274 + return VLYNQ_INVALID_ARG;
1275 +
1276 + if (dev_type == VLYNQ_LOCAL_DVC)
1277 + {
1278 + vecreg = (volatile unsigned int *) (VLYNQ_IVR_OFFSET(int_vector));
1279 + }
1280 + else
1281 + {
1282 + vecreg = (volatile unsigned int *) (VLYNQ_R_IVR_OFFSET(int_vector));
1283 + }
1284 +
1285 + /* Update the intVector<==> bit position translation table */
1286 + pdev->vector_map[map_vector] = int_vector;
1287 +
1288 + /* val has been initialised to zero. we only have to turn on appropriate bits*/
1289 + if(type == VLYNQ_INTR_PULSED)
1290 + val |= VLYNQ_IVR_INTTYPE_MASK;
1291 +
1292 + if(pol == VLYNQ_INTR_ACTIVE_LOW)
1293 + val |= VLYNQ_IVR_INTPOL_MASK;
1294 +
1295 + val |= map_vector;
1296 +
1297 + /** clear the correct byte position and then or val **/
1298 + *vecreg = (*vecreg) & ( ~(bytemask << ( (int_vector %4)*8) ) );
1299 +
1300 + /** write to correct byte position in vecreg*/
1301 + *vecreg = (*vecreg) | (val << ( (int_vector % 4)*8) ) ;
1302 +
1303 + /* Setting a interrupt vector, leaves the interrupt disabled
1304 + * which must be enabled subsequently */
1305 +
1306 + return VLYNQ_SUCCESS;
1307 +}
1308 +
1309 +
1310 +/* ----------------------------------------------------------------------------
1311 + * Function : vlynq_interrupt_vector_cntl()
1312 + * Description:enables/disable interrupt
1313 + */
1314 +int vlynq_interrupt_vector_cntl( VLYNQ_DEV *pdev,
1315 + unsigned int int_vector,
1316 + VLYNQ_DEV_TYPE dev_type,
1317 + unsigned int enable)
1318 +{
1319 + volatile unsigned int *vecReg;
1320 + unsigned int val=0;
1321 + unsigned int intenMask=0x80;
1322 +
1323 + /* validate the number of interrupts supported */
1324 + if (int_vector >= VLYNQ_IVR_MAXIVR)
1325 + return VLYNQ_INVALID_ARG;
1326 +
1327 + if (dev_type == VLYNQ_LOCAL_DVC)
1328 + {
1329 + vecReg = (volatile unsigned int *) (VLYNQ_IVR_OFFSET(int_vector));
1330 + }
1331 + else
1332 + {
1333 + vecReg = (volatile unsigned int *) (VLYNQ_R_IVR_OFFSET(int_vector));
1334 + }
1335 +
1336 + /** Clear the correct byte position and then or val **/
1337 + *vecReg = (*vecReg) & ( ~(intenMask << ( (int_vector %4)*8) ) );
1338 +
1339 + if(enable)
1340 + {
1341 + val |= VLYNQ_IVR_INTEN_MASK;
1342 + /** Write to correct byte position in vecReg*/
1343 + *vecReg = (*vecReg) | (val << ( (int_vector % 4)*8) ) ;
1344 + }
1345 +
1346 + return VLYNQ_SUCCESS;
1347 +
1348 +}/* end of function vlynq_interrupt_vector_cntl */
1349 +
1350 +
1351 +
1352 +/* ----------------------------------------------------------------------------
1353 + * Function : vlynq_interrupt_vector_map()
1354 + * Description:Configures interrupt vector mapping alone
1355 + */
1356 +int
1357 +vlynq_interrupt_vector_map( VLYNQ_DEV *pdev,
1358 + VLYNQ_DEV_TYPE dev_type,
1359 + unsigned int int_vector,
1360 + unsigned int map_vector)
1361 +{
1362 + volatile unsigned int * vecreg;
1363 + unsigned int val=0;
1364 + unsigned int bytemask=0x1f; /* mask to turn off bits corresponding to int vector */
1365 +
1366 + /* use the lower 8 bits of val to set the value , shift it to
1367 + * appropriate byte position in the ivr and write it to the
1368 + * corresponding register */
1369 +
1370 + /* validate the number of interrupts supported */
1371 + if (int_vector >= VLYNQ_IVR_MAXIVR)
1372 + return VLYNQ_INVALID_ARG;
1373 +
1374 + if(map_vector > (VLYNQ_NUM_INT_BITS - 1) )
1375 + return VLYNQ_INVALID_ARG;
1376 +
1377 + if (dev_type == VLYNQ_LOCAL_DVC)
1378 + {
1379 + vecreg = (volatile unsigned int *) (VLYNQ_IVR_OFFSET(int_vector));
1380 + }
1381 + else
1382 + {
1383 + vecreg = (volatile unsigned int *) (VLYNQ_R_IVR_OFFSET(int_vector));
1384 + }
1385 +
1386 + /* Update the intVector<==> bit position translation table */
1387 + pdev->vector_map[map_vector] = int_vector;
1388 +
1389 + /** val has been initialised to zero. we only have to turn on
1390 + * appropriate bits*/
1391 + val |= map_vector;
1392 +
1393 + /** clear the correct byte position and then or val **/
1394 + *vecreg = (*vecreg) & ( ~(bytemask << ( (int_vector %4)*8) ) );
1395 +
1396 + /** write to correct byte position in vecreg*/
1397 + *vecreg = (*vecreg) | (val << ( (int_vector % 4)*8) ) ;
1398 +
1399 + return VLYNQ_SUCCESS;
1400 +}
1401 +
1402 +
1403 +/* ----------------------------------------------------------------------------
1404 + * function : vlynq_interrupt_set_polarity()
1405 + * description:configures interrupt polarity .
1406 + */
1407 +int
1408 +vlynq_interrupt_set_polarity( VLYNQ_DEV *pdev ,
1409 + VLYNQ_DEV_TYPE dev_type,
1410 + unsigned int map_vector,
1411 + VLYNQ_INTR_POLARITY pol)
1412 +{
1413 + volatile unsigned int * vecreg;
1414 + int int_vector;
1415 + unsigned int val=0;
1416 + unsigned int bytemask=0x20; /** mask to turn off bits corresponding to int polarity */
1417 +
1418 + /* get the int_vector from map_vector */
1419 + int_vector = pdev->vector_map[map_vector];
1420 +
1421 + if(int_vector == -1)
1422 + return VLYNQ_INTVEC_MAP_NOT_FOUND;
1423 +
1424 + /* use the lower 8 bits of val to set the value , shift it to
1425 + * appropriate byte position in the ivr and write it to the
1426 + * corresponding register */
1427 +
1428 + if (dev_type == VLYNQ_LOCAL_DVC)
1429 + {
1430 + vecreg = (volatile unsigned int *) (VLYNQ_IVR_OFFSET(int_vector));
1431 + }
1432 + else
1433 + {
1434 + vecreg = (volatile unsigned int *) (VLYNQ_R_IVR_OFFSET(int_vector));
1435 + }
1436 +
1437 + /* val has been initialised to zero. we only have to turn on
1438 + * appropriate bits, if need be*/
1439 +
1440 + /** clear the correct byte position and then or val **/
1441 + *vecreg = (*vecreg) & ( ~(bytemask << ( (int_vector %4)*8) ) );
1442 +
1443 + if( pol == VLYNQ_INTR_ACTIVE_LOW)
1444 + {
1445 + val |= VLYNQ_IVR_INTPOL_MASK;
1446 + /** write to correct byte position in vecreg*/
1447 + *vecreg = (*vecreg) | (val << ( (int_vector % 4)*8) ) ;
1448 + }
1449 +
1450 + return VLYNQ_SUCCESS;
1451 +}
1452 +
1453 +int vlynq_interrupt_get_polarity( VLYNQ_DEV *pdev ,
1454 + VLYNQ_DEV_TYPE dev_type,
1455 + unsigned int map_vector)
1456 +{
1457 + volatile unsigned int * vecreg;
1458 + int int_vector;
1459 + unsigned int val=0;
1460 +
1461 + /* get the int_vector from map_vector */
1462 + int_vector = pdev->vector_map[map_vector];
1463 +
1464 + if (map_vector > (VLYNQ_NUM_INT_BITS-1))
1465 + return(-1);
1466 +
1467 + if(int_vector == -1)
1468 + return VLYNQ_INTVEC_MAP_NOT_FOUND;
1469 +
1470 + /* use the lower 8 bits of val to set the value , shift it to
1471 + * appropriate byte position in the ivr and write it to the
1472 + * corresponding register */
1473 +
1474 + if (dev_type == VLYNQ_LOCAL_DVC)
1475 + {
1476 + vecreg = (volatile unsigned int *) (VLYNQ_IVR_OFFSET(int_vector));
1477 + }
1478 + else
1479 + {
1480 + vecreg = (volatile unsigned int *) (VLYNQ_R_IVR_OFFSET(int_vector));
1481 + }
1482 +
1483 + /** read the information into val **/
1484 + val = (*vecreg) & ((VLYNQ_IVR_INTPOL_MASK << ( (int_vector %4)*8) ) );
1485 +
1486 + return (val ? (VLYNQ_INTR_ACTIVE_LOW) : (VLYNQ_INTR_ACTIVE_HIGH));
1487 +}
1488 +
1489 +
1490 +/* ----------------------------------------------------------------------------
1491 + * function : vlynq_interrupt_set_type()
1492 + * description:configures interrupt type .
1493 + */
1494 +int vlynq_interrupt_set_type( VLYNQ_DEV *pdev,
1495 + VLYNQ_DEV_TYPE dev_type,
1496 + unsigned int map_vector,
1497 + VLYNQ_INTR_TYPE type)
1498 +{
1499 + volatile unsigned int * vecreg;
1500 + unsigned int val=0;
1501 + int int_vector;
1502 +
1503 + /** mask to turn off bits corresponding to interrupt type */
1504 + unsigned int bytemask=0x40;
1505 +
1506 + /* get the int_vector from map_vector */
1507 + int_vector = pdev->vector_map[map_vector];
1508 + if(int_vector == -1)
1509 + return VLYNQ_INTVEC_MAP_NOT_FOUND;
1510 +
1511 + /* use the lower 8 bits of val to set the value , shift it to
1512 + * appropriate byte position in the ivr and write it to the
1513 + * corresponding register */
1514 + if (dev_type == VLYNQ_LOCAL_DVC)
1515 + {
1516 + vecreg = (volatile unsigned int *) (VLYNQ_IVR_OFFSET(int_vector));
1517 + }
1518 + else
1519 + {
1520 + vecreg = (volatile unsigned int *) (VLYNQ_R_IVR_OFFSET(int_vector));
1521 + }
1522 +
1523 + /** val has been initialised to zero. we only have to turn on
1524 + * appropriate bits if need be*/
1525 +
1526 + /** clear the correct byte position and then or val **/
1527 + *vecreg = (*vecreg) & ( ~(bytemask << ( (int_vector %4)*8) ) );
1528 +
1529 + if( type == VLYNQ_INTR_PULSED)
1530 + {
1531 + val |= VLYNQ_IVR_INTTYPE_MASK;
1532 + /** write to correct byte position in vecreg*/
1533 + *vecreg = (*vecreg) | (val << ( (int_vector % 4)*8) ) ;
1534 + }
1535 +
1536 + return VLYNQ_SUCCESS;
1537 +}
1538 +
1539 +/* ----------------------------------------------------------------------------
1540 + * function : vlynq_interrupt_get_type()
1541 + * description:returns interrupt type .
1542 + */
1543 +int vlynq_interrupt_get_type( VLYNQ_DEV *pdev, VLYNQ_DEV_TYPE dev_type,
1544 + unsigned int map_vector)
1545 +{
1546 + volatile unsigned int * vecreg;
1547 + unsigned int val=0;
1548 + int int_vector;
1549 +
1550 + if (map_vector > (VLYNQ_NUM_INT_BITS-1))
1551 + return(-1);
1552 +
1553 + /* get the int_vector from map_vector */
1554 + int_vector = pdev->vector_map[map_vector];
1555 + if(int_vector == -1)
1556 + return VLYNQ_INTVEC_MAP_NOT_FOUND;
1557 +
1558 + /* use the lower 8 bits of val to set the value , shift it to
1559 + * appropriate byte position in the ivr and write it to the
1560 + * corresponding register */
1561 + if (dev_type == VLYNQ_LOCAL_DVC)
1562 + {
1563 + vecreg = (volatile unsigned int *) (VLYNQ_IVR_OFFSET(int_vector));
1564 + }
1565 + else
1566 + {
1567 + vecreg = (volatile unsigned int *) (VLYNQ_R_IVR_OFFSET(int_vector));
1568 + }
1569 +
1570 + /** Read the correct bit position into val **/
1571 + val = (*vecreg) & ((VLYNQ_IVR_INTTYPE_MASK << ( (int_vector %4)*8) ) );
1572 +
1573 + return (val ? (VLYNQ_INTR_PULSED) : (VLYNQ_INTR_LEVEL));
1574 +}
1575 +
1576 +/* ----------------------------------------------------------------------------
1577 + * function : vlynq_interrupt_enable()
1578 + * description:Enable interrupt by writing to IVR register.
1579 + */
1580 +int vlynq_interrupt_enable( VLYNQ_DEV *pdev,
1581 + VLYNQ_DEV_TYPE dev_type,
1582 + unsigned int map_vector)
1583 +{
1584 + volatile unsigned int * vecreg;
1585 + unsigned int val=0;
1586 + int int_vector;
1587 +
1588 + /** mask to turn off bits corresponding to interrupt enable */
1589 + unsigned int bytemask=0x80;
1590 +
1591 + /* get the int_vector from map_vector */
1592 + int_vector = pdev->vector_map[map_vector];
1593 + if(int_vector == -1)
1594 + return VLYNQ_INTVEC_MAP_NOT_FOUND;
1595 +
1596 + /* use the lower 8 bits of val to set the value , shift it to
1597 + * appropriate byte position in the ivr and write it to the
1598 + * corresponding register */
1599 +
1600 + if (dev_type == VLYNQ_LOCAL_DVC)
1601 + {
1602 + vecreg = (volatile unsigned int *) (VLYNQ_IVR_OFFSET(int_vector));
1603 + }
1604 + else
1605 + {
1606 + vecreg = (volatile unsigned int *) (VLYNQ_R_IVR_OFFSET(int_vector));
1607 + }
1608 +
1609 + /** val has been initialised to zero. we only have to turn on
1610 + * bit corresponding to interrupt enable*/
1611 + val |= VLYNQ_IVR_INTEN_MASK;
1612 +
1613 + /** clear the correct byte position and then or val **/
1614 + *vecreg = (*vecreg) & ( ~(bytemask << ( (int_vector %4)*8) ) );
1615 +
1616 + /** write to correct byte position in vecreg*/
1617 + *vecreg = (*vecreg) | (val << ( (int_vector % 4)*8) ) ;
1618 +
1619 + return VLYNQ_SUCCESS;
1620 +}
1621 +
1622 +
1623 +/* ----------------------------------------------------------------------------
1624 + * function : vlynq_interrupt_disable()
1625 + * description:Disable interrupt by writing to IVR register.
1626 + */
1627 +int
1628 +vlynq_interrupt_disable( VLYNQ_DEV *pdev,
1629 + VLYNQ_DEV_TYPE dev_type,
1630 + unsigned int map_vector)
1631 +{
1632 + volatile unsigned int * vecreg;
1633 + int int_vector;
1634 +
1635 + /** mask to turn off bits corresponding to interrupt enable */
1636 + unsigned int bytemask=0x80;
1637 +
1638 + /* get the int_vector from map_vector */
1639 + int_vector = pdev->vector_map[map_vector];
1640 + if(int_vector == -1)
1641 + return VLYNQ_INTVEC_MAP_NOT_FOUND;
1642 +
1643 + /* use the lower 8 bits of val to set the value , shift it to
1644 + * appropriate byte position in the ivr and write it to the
1645 + * corresponding register */
1646 + if (dev_type == VLYNQ_LOCAL_DVC)
1647 + {
1648 + vecreg = (volatile unsigned int *) (VLYNQ_IVR_OFFSET(int_vector));
1649 + }
1650 + else
1651 + {
1652 + vecreg = (volatile unsigned int *) (VLYNQ_R_IVR_OFFSET(int_vector));
1653 + }
1654 +
1655 + /* We disable the interrupt by simply turning off the bit
1656 + * corresponding to Interrupt enable.
1657 + * Clear the interrupt enable bit in the correct byte position **/
1658 + *vecreg = (*vecreg) & ( ~(bytemask << ( (int_vector %4)*8) ) );
1659 +
1660 + /* Dont have to set any bit positions */
1661 +
1662 + return VLYNQ_SUCCESS;
1663 +
1664 +}
1665 +
1666 +
1667 +
1668 +
1669 diff -urN linux.old/drivers/char/Config.in linux.dev/drivers/char/Config.in
1670 --- linux.old/drivers/char/Config.in 2005-07-22 06:47:42.777975272 +0200
1671 +++ linux.dev/drivers/char/Config.in 2005-07-22 06:48:54.359093288 +0200
1672 @@ -192,6 +192,13 @@
1673 tristate 'Total Impact briQ front panel driver' CONFIG_BRIQ_PANEL
1674 fi
1675
1676 +if [ "$CONFIG_AR7" = "y" ]; then
1677 + bool 'VLYNQ support for the TI SOC' CONFIG_AR7_VLYNQ
1678 + dep_bool 'VLYNQ clock source Internal' CONFIG_VLYNQ_CLK_LOCAL $CONFIG_AR7_VLYNQ
1679 +
1680 + define_int CONFIG_AR7_VLYNQ_PORTS 2
1681 +fi
1682 +
1683 source drivers/i2c/Config.in
1684
1685 mainmenu_option next_comment
1686 diff -urN linux.old/drivers/char/Makefile linux.dev/drivers/char/Makefile
1687 --- linux.old/drivers/char/Makefile 2005-07-22 06:47:35.151134728 +0200
1688 +++ linux.dev/drivers/char/Makefile 2005-07-22 06:32:53.360187328 +0200
1689 @@ -191,6 +191,13 @@
1690 endif
1691
1692 #
1693 +# Texas Intruments VLYNQ driver
1694 +#
1695 +
1696 +subdir-$(CONFIG_AR7_VLYNQ) += avalanche_vlynq
1697 +obj-$(CONFIG_AR7_VLYNQ) += avalanche_vlynq/avalanche_vlynq.o
1698 +
1699 +#
1700 # Texas Intruments LED driver
1701 #
1702 obj-$(CONFIG_AR7_LED) += avalanche_led/avalanche_led.o
1703 diff -urN linux.old/include/asm-mips/ar7/vlynq.h linux.dev/include/asm-mips/ar7/vlynq.h
1704 --- linux.old/include/asm-mips/ar7/vlynq.h 1970-01-01 01:00:00.000000000 +0100
1705 +++ linux.dev/include/asm-mips/ar7/vlynq.h 2005-07-22 06:32:53.361187176 +0200
1706 @@ -0,0 +1,610 @@
1707 +/***************************************************************************
1708 +**+----------------------------------------------------------------------+**
1709 +**| **** |**
1710 +**| **** |**
1711 +**| ******o*** |**
1712 +**| ********_///_**** |**
1713 +**| ***** /_//_/ **** |**
1714 +**| ** ** (__/ **** |**
1715 +**| ********* |**
1716 +**| **** |**
1717 +**| *** |**
1718 +**| |**
1719 +**| Copyright (c) 2003 Texas Instruments Incorporated |**
1720 +**| ALL RIGHTS RESERVED |**
1721 +**| |**
1722 +**| Permission is hereby granted to licensees of Texas Instruments |**
1723 +**| Incorporated (TI) products to use this computer program for the sole |**
1724 +**| purpose of implementing a licensee product based on TI products. |**
1725 +**| No other rights to reproduce, use, or disseminate this computer |**
1726 +**| program, whether in part or in whole, are granted. |**
1727 +**| |**
1728 +**| TI makes no representation or warranties with respect to the |**
1729 +**| performance of this computer program, and specifically disclaims |**
1730 +**| any responsibility for any damages, special or consequential, |**
1731 +**| connected with the use of this program. |**
1732 +**| |**
1733 +**+----------------------------------------------------------------------+**
1734 +***************************************************************************/
1735 +
1736 +/*********************************************************************************
1737 + * ------------------------------------------------------------------------------
1738 + * Module : vlynq_hal.h
1739 + * Description :
1740 + * This header file provides the set of functions exported by the
1741 + * VLYNQ HAL. This file is included from the SOC specific VLYNQ driver wrapper.
1742 + * ------------------------------------------------------------------------------
1743 + *********************************************************************************/
1744 +
1745 +#ifndef _VLYNQ_HAL_H_
1746 +#define _VLYNQ_HAL_H_
1747 +
1748 +/* Enable/Disable debug feature */
1749 +#undef VLYNQ_DEBUG
1750 +
1751 +#ifdef VLYNQ_DEBUG /* This needs to be OS abstracted - for testing use vxworks/linux calls */
1752 +#define debugPrint(format,args...)
1753 +#else
1754 +#define debugPrint(format,args...)
1755 +#endif
1756 +
1757 + /* number of VLYNQ memory regions supported */
1758 +#define VLYNQ_MAX_MEMORY_REGIONS 0x04
1759 +
1760 + /* Max.number of external interrupt inputs supported by VLYNQ module */
1761 +#define VLYNQ_IVR_MAXIVR 0x08
1762 +
1763 +#define VLYNQ_CLK_DIV_MAX 0x08
1764 +#define VLYNQ_CLK_DIV_MIN 0x01
1765 +
1766 +
1767 +/*** the total number of entries allocated for ICB would be
1768 + * 32(for 32 bits in IntPending register) + VLYNQ_IVR_CHAIN_SLOTS*/
1769 +#define VLYNQ_IVR_CHAIN_SLOTS 10
1770 +
1771 +
1772 +/* Error defines */
1773 +#define VLYNQ_SUCCESS 0
1774 +
1775 +#define VLYNQ_ERRCODE_BASE 0 /* Chosen by system */
1776 +#define VLYNQ_INVALID_ARG -(VLYNQ_ERRCODE_BASE+1)
1777 +#define VLYNQ_INVALID_DRV_STATE -(VLYNQ_ERRCODE_BASE+2)
1778 +#define VLYNQ_INT_CONFIG_ERR -(VLYNQ_ERRCODE_BASE+3)
1779 +#define VLYNQ_LINK_DOWN -(VLYNQ_ERRCODE_BASE+4)
1780 +#define VLYNQ_MEMALLOC_FAIL -(VLYNQ_ERRCODE_BASE+5)
1781 +#define VLYNQ_ISR_NON_EXISTENT -(VLYNQ_ERRCODE_BASE+6)
1782 +#define VLYNQ_INTVEC_MAP_NOT_FOUND -(VLYNQ_ERRCODE_BASE+7)
1783 +
1784 +/* Vlynq Defines and Macros */
1785 +
1786 +#define VLYNQ_NUM_INT_BITS 32 /* 32 bit interrupt staus register */
1787 +
1788 +/* Base address of module */
1789 +#define VLYNQ_BASE (pdev->module_base)
1790 +
1791 +#define VLYNQ_REMOTE_REGS_OFFSET 0x0080
1792 +
1793 +#define VLYNQ_REV_OFFSET 0x0000
1794 +#define VLYNQ_CTRL_OFFSET 0x0004
1795 +#define VLYNQ_STATUS_OFFSET 0x0008
1796 +#define VLYNQ_INT_STAT_OFFSET 0x0010
1797 +#define VLYNQ_INT_PEND_OFFSET 0x0014
1798 +#define VLYNQ_INT_PTR_OFFSET 0x0018
1799 +#define VLYNQ_TXMAP_OFFSET 0x001c
1800 +
1801 +#define VLYNQ_RX0MAP_SIZE_REG_OFFSET 0x0020
1802 +#define VLYNQ_RX0MAP_OFFSET_REG_OFFSET 0x0024
1803 +
1804 +#define VLYNQ_CHIP_VER_OFFSET 0x0040
1805 +#define VLYNQ_IVR_REGS_OFFSET 0x0060
1806 +
1807 +#define VLYNQ_INT_PENDING_REG_PTR 0x14
1808 +#define VLYNQ_R_INT_PENDING_REG_PTR VLYNQ_REMOTE_REGS_OFFSET + 0x14
1809 +
1810 +#define VLYNQ_REV_REG *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_REV_OFFSET))
1811 +#define VLYNQ_CTRL_REG *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_CTRL_OFFSET))
1812 +#define VLYNQ_STATUS_REG *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_STATUS_OFFSET))
1813 +#define VLYNQ_INT_STAT_REG *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_INT_STAT_OFFSET))
1814 +#define VLYNQ_INT_PEND_REG *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_INT_PEND_OFFSET))
1815 +#define VLYNQ_INT_PTR_REG *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_INT_PTR_OFFSET))
1816 +#define VLYNQ_TXMAP_REG *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_TXMAP_OFFSET))
1817 +
1818 +/** map takes on values between 1 to VLYNQ_MAX_MEMORY_REGIONS **/
1819 +#define VLYNQ_RXMAP_SIZE_REG(map) \
1820 + *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_RX0MAP_SIZE_REG_OFFSET+( (map-1)<<3)))
1821 +
1822 +/** map takes on values between 1 to VLYNQ_MAX_MEMORY_REGIONS **/
1823 +#define VLYNQ_RXMAP_OFFSET_REG(map) \
1824 + *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_RX0MAP_OFFSET_REG_OFFSET+( (map-1)<<3)))
1825 +
1826 +#define VLYNQ_CHIP_VER_REG *((volatile unsigned int *)(VLYNQ_BASE+VLYNQ_CHIP_VER_OFFSET))
1827 +
1828 +/* 0 =< ivr <= 31; currently ivr < VLYNQ_IVR_MAXIVR=8) */
1829 +#define VLYNQ_IVR_OFFSET(ivr) \
1830 + (VLYNQ_BASE + VLYNQ_IVR_REGS_OFFSET +((((unsigned)(ivr)) & 31) & ~3) )
1831 +
1832 +#define VLYNQ_IVR_03TO00_REG *((volatile unsigned int*) (VLYNQ_IVR_OFFSET(0)) )
1833 +#define VLYNQ_IVR_07TO04_REG *((volatile unsigned int*) (VLYNQ_IVR_OFFSET(4)) )
1834 +/*** Can be extended for 11TO08...31TO28 when all 31 are supported**/
1835 +
1836 +#define VLYNQ_IVR_INTEN(ivr) (((unsigned int)(0x80)) << ((((unsigned)(ivr)) % 4) * 8))
1837 +#define VLYNQ_IVR_INTTYPE(ivr) (((unsigned int)(0x40)) << ((((unsigned)(ivr)) % 4) * 8))
1838 +#define VLYNQ_IVR_INTPOL(ivr) (((unsigned int)(0x20)) << ((((unsigned)(ivr)) % 4) * 8))
1839 +#define VLYNQ_IVR_INTVEC(ivr) (((unsigned int)(0x1F)) << ((((unsigned)(ivr)) % 4) * 8))
1840 +#define VLYNQ_IVR_INTALL(ivr) (((unsigned int)(0xFF)) << ((((unsigned)(ivr)) % 4) * 8))
1841 +
1842 +
1843 +
1844 +/*********************************
1845 + * Remote VLYNQ register set *
1846 + *********************************/
1847 +
1848 +#define VLYNQ_R_REV_OFFSET 0x0080
1849 +#define VLYNQ_R_CTRL_OFFSET 0x0084
1850 +#define VLYNQ_R_STATUS_OFFSET 0x0088
1851 +#define VLYNQ_R_INT_STAT_OFFSET 0x0090
1852 +#define VLYNQ_R_INT_PEND_OFFSET 0x0094
1853 +#define VLYNQ_R_INT_PTR_OFFSET 0x0098
1854 +#define VLYNQ_R_TXMAP_OFFSET 0x009c
1855 +
1856 +#define VLYNQ_R_RX0MAP_SIZE_REG_OFFSET 0x00A0
1857 +#define VLYNQ_R_RX0MAP_OFFSET_REG_OFFSET 0x00A4
1858 +
1859 +#define VLYNQ_R_CHIP_VER_OFFSET 0x00C0
1860 +#define VLYNQ_R_IVR_REGS_OFFSET 0x00E0
1861 +
1862 +#define VLYNQ_R_REV_REG *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_REV_OFFSET))
1863 +#define VLYNQ_R_CTRL_REG *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_CTRL_OFFSET))
1864 +#define VLYNQ_R_STATUS_REG *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_STATUS_OFFSET))
1865 +#define VLYNQ_R_INT_STAT_REG *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_INT_STAT_OFFSET))
1866 +#define VLYNQ_R_INT_PEND_REG *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_INT_PEND_OFFSET))
1867 +#define VLYNQ_R_INT_PTR_REG *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_INT_PTR_OFFSET))
1868 +#define VLYNQ_R_TXMAP_REG *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_TXMAP_OFFSET))
1869 +
1870 +/** map takes on values between 1 to VLYNQ_MAX_MEMORY_REGIONS **/
1871 +#define VLYNQ_R_RXMAP_SIZE_REG(map) \
1872 + *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_RX0MAP_SIZE_REG_OFFSET + ((map-1)<<3)))
1873 +
1874 +/** map takes on values between 1 to VLYNQ_MAX_MEMORY_REGIONS **/
1875 +#define VLYNQ_R_RXMAP_OFFSET_REG(map) \
1876 + *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_RX0MAP_OFFSET_REG_OFFSET + ((map-1)<<3)))
1877 +
1878 +#define VLYNQ_R_CHIP_VER_REG *((volatile unsigned int *)(VLYNQ_BASE + VLYNQ_R_CHIP_VER_OFFSET)
1879 +
1880 +#define VLYNQ_R_IVR_OFFSET(ivr) \
1881 + (VLYNQ_BASE + VLYNQ_R_IVR_REGS_OFFSET +((((unsigned)(ivr)) & 31) & ~3))
1882 +
1883 +
1884 +/*** Can be extended for 11TO08...31TO28 when all 31 are supported**/
1885 +#define VLYNQ_R_IVR_03TO00_REG *((volatile unsigned int*) (VLYNQ_R_IVR_OFFSET(0)) )
1886 +#define VLYNQ_R_IVR_07TO04_REG *((volatile unsigned int*) (VLYNQ_R_IVR_OFFSET(4)) )
1887 +
1888 +
1889 +/****End of remote register set definition******/
1890 +
1891 +
1892 +/*** Masks for individual register fields ***/
1893 +
1894 +#define VLYNQ_MODULE_ID_MASK 0xffff0000
1895 +#define VLYNQ_MAJOR_REV_MASK 0x0000ff00
1896 +#define VLYNQ_MINOR_REV_MASK 0x000000ff
1897 +
1898 +
1899 +#define VLYNQ_CTL_ILOOP_MASK 0x00000002
1900 +#define VLYNQ_CTL_INT2CFG_MASK 0x00000080
1901 +#define VLYNQ_CTL_INTVEC_MASK 0x00001f00
1902 +#define VLYNQ_CTL_INTEN_MASK 0x00002000
1903 +#define VLYNQ_CTL_INTLOCAL_MASK 0x00004000
1904 +#define VLYNQ_CTL_CLKDIR_MASK 0x00008000
1905 +#define VLYNQ_CTL_CLKDIV_MASK 0x00070000
1906 +#define VLYNQ_CTL_MODE_MASK 0x00e00000
1907 +
1908 +
1909 +#define VLYNQ_STS_LINK_MASK 0x00000001 /* Link is active */
1910 +#define VLYNQ_STS_MPEND_MASK 0x00000002 /* Pending master requests */
1911 +#define VLYNQ_STS_SPEND_MASK 0x00000004 /* Pending slave requests */
1912 +#define VLYNQ_STS_NFEMPTY0_MASK 0x00000008 /* Master data FIFO not empty */
1913 +#define VLYNQ_STS_NFEMPTY1_MASK 0x00000010 /* Master command FIFO not empty */
1914 +#define VLYNQ_STS_NFEMPTY2_MASK 0x00000020 /* Slave data FIFO not empty */
1915 +#define VLYNQ_STS_NFEMPTY3_MASK 0x00000040 /* Slave command FIFO not empty */
1916 +#define VLYNQ_STS_LERROR_MASK 0x00000080 /* Local error, w/c */
1917 +#define VLYNQ_STS_RERROR_MASK 0x00000100 /* remote error w/c */
1918 +#define VLYNQ_STS_OFLOW_MASK 0x00000200
1919 +#define VLYNQ_STS_IFLOW_MASK 0x00000400
1920 +#define VLYNQ_STS_MODESUP_MASK 0x00E00000 /* Highest mode supported */
1921 +#define VLYNQ_STS_SWIDTH_MASK 0x07000000 /* Used for reading the width of VLYNQ bus */
1922 +#define VLYNQ_STS_DEBUG_MASK 0xE0000000
1923 +
1924 +#define VLYNQ_CTL_INTVEC_SHIFT 0x08
1925 +#define VLYNQ_CTL_INTEN_SHIFT 0x0D
1926 +#define VLYNQ_CTL_INT2CFG_SHIFT 0x07
1927 +#define VLYNQ_CTL_INTLOCAL_SHIFT 0x0E
1928 +
1929 +#define VLYNQ_CTL_INTFIELDS_CLEAR_MASK 0x7F80
1930 +
1931 +#define VLYNQ_CHIPVER_DEVREV_MASK 0xffff0000
1932 +#define VLYNQ_CHIPVER_DEVID_MASK 0x0000ffff
1933 +
1934 +#define VLYNQ_IVR_INTEN_MASK 0x80
1935 +#define VLYNQ_IVR_INTTYPE_MASK 0x40
1936 +#define VLYNQ_IVR_INTPOL_MASK 0x20
1937 +
1938 +
1939 +/**** Helper macros ****/
1940 +
1941 +#define VLYNQ_RESETCB(arg) \
1942 + if( pdev->reset_cb != NULL) \
1943 + { \
1944 + (pdev->reset_cb)(pdev, (arg)); \
1945 + }
1946 +
1947 +#define VLYNQ_STATUS_FLD_WIDTH(sts) (((sts) & VLYNQ_STS_SWIDTH_MASK) >> 24 )
1948 +#define VLYNQ_CTL_INTVEC(x) (((x) & 31) << 8 )
1949 +
1950 +#define VLYNQ_INRANGE(x,hi,lo) (((x) <= (hi)) && ((x) >= (lo)))
1951 +#define VLYNQ_OUTRANGE(x,hi,lo) (((x) > (hi)) || ((x) < (lo)))
1952 +
1953 +#define VLYNQ_ALIGN4(x) (x)=(x)&(~3)
1954 +
1955 +
1956 +/*************************************
1957 + * Enums *
1958 + *************************************/
1959 +
1960 +/* Initialization options define what operations are
1961 + * undertaken during vlynq module initialization */
1962 +typedef enum
1963 +{
1964 + /* Init host local memory regions.This allows
1965 + * local host access remote memory regions */
1966 + VLYNQ_INIT_LOCAL_MEM_REGIONS = 0x01,
1967 + /* Init host remote memory regions.This allows
1968 + * remote device access local memory regions */
1969 + VLYNQ_INIT_REMOTE_MEM_REGIONS =0x02,
1970 + /* Init local interrupt config*/
1971 + VLYNQ_INIT_LOCAL_INTERRUPTS =0x04,
1972 + /* Init remote interrupt config*/
1973 + VLYNQ_INIT_REMOTE_INTERRUPTS =0x08,
1974 + /* Check link during initialization*/
1975 + VLYNQ_INIT_CHECK_LINK =0x10,
1976 + /* configure clock during init */
1977 + VLYNQ_INIT_CONFIG_CLOCK =0x20,
1978 + /* Clear errors during init */
1979 + VLYNQ_INIT_CLEAR_ERRORS =0x40,
1980 + /* All options */
1981 + VLYNQ_INIT_PERFORM_ALL =0x7F
1982 +}VLYNQ_INIT_OPTIONS;
1983 +
1984 +
1985 +/* VLYNQ_DEV_TYPE identifies local or remote device */
1986 +typedef enum
1987 +{
1988 + VLYNQ_LOCAL_DVC = 0, /* vlynq local device (SOC's vlynq module) */
1989 + VLYNQ_REMOTE_DVC = 1 /* vlynq remote device (remote vlynq module) */
1990 +}VLYNQ_DEV_TYPE;
1991 +
1992 +
1993 +/* VLYNQ_CLK_SOURCE identifies the vlynq module clock source */
1994 +typedef enum
1995 +{
1996 + VLYNQ_CLK_SOURCE_NONE = 0, /* do not initialize clock generator*/
1997 + VLYNQ_CLK_SOURCE_LOCAL = 1, /* clock is generated by local machine */
1998 + VLYNQ_CLK_SOURCE_REMOTE = 2 /* clock is generated by remote machine */
1999 +}VLYNQ_CLK_SOURCE;
2000 +
2001 +
2002 +/* VLYNQ_DRV_STATE indicates the current driver state */
2003 +typedef enum
2004 +{
2005 + VLYNQ_DRV_STATE_UNINIT = 0, /* driver is uninitialized */
2006 + VLYNQ_DRV_STATE_ININIT = 1, /* VLYNQ is being initialized */
2007 + VLYNQ_DRV_STATE_RUN = 2, /* VLYNQ is running properly */
2008 + VLYNQ_DRV_STATE_HOLD = 3, /* driver stopped temporarily */
2009 + VLYNQ_DRV_STATE_ERROR = 4 /* driver stopped on unrecoverable error */
2010 +}VLYNQ_DRV_STATE;
2011 +
2012 +
2013 +/* VLYNQ_BUS_WIDTH identifies the vlynq module bus width */
2014 +typedef enum
2015 +{
2016 + VLYNQ_BUS_WIDTH_3 = 3,
2017 + VLYNQ_BUS_WIDTH_5 = 5,
2018 + VLYNQ_BUS_WIDTH_7 = 7,
2019 + VLYNQ_BUS_WIDTH_9 = 9
2020 +}VLYNQ_BUS_WIDTH;
2021 +
2022 +
2023 +/* VLYNQ_LOCAL_INT_CONFIG indicates whether the local vlynq
2024 + * interrupts are processed by the host or passed on to the
2025 + * remote device.
2026 + */
2027 +typedef enum
2028 +{
2029 + VLYNQ_INT_REMOTE = 0, /* Interrupt packets sent to remote, intlocal=0 */
2030 + VLYNQ_INT_LOCAL = 1 /* Interrupts are handled locally, intlocal=1 */
2031 +}VLYNQ_LOCAL_INT_CONFIG;
2032 +
2033 +
2034 +/* VLYNQ_REMOTE_INT_CONFIG indicates whether the remote
2035 + * interrupts are to be handled by the SOC system ISR
2036 + * or via the vlynq root ISR
2037 + */
2038 +typedef enum
2039 +{
2040 + VLYNQ_INT_ROOT_ISR = 0, /* remote ints handled via vlynq root ISR */
2041 + VLYNQ_INT_SYSTEM_ISR = 1 /* remote ints handled via system ISR */
2042 +}VLYNQ_REMOTE_INT_CONFIG;
2043 +
2044 +
2045 +/* VLYNQ_INTR_POLARITY - vlynq interrupt polarity setting */
2046 +typedef enum
2047 +{
2048 + VLYNQ_INTR_ACTIVE_HIGH = 0,
2049 + VLYNQ_INTR_ACTIVE_LOW = 1
2050 +}VLYNQ_INTR_POLARITY;
2051 +
2052 +
2053 +/* VLYNQ_INTR_TYPE - vlynq interrupt type */
2054 +typedef enum
2055 +{
2056 + VLYNQ_INTR_LEVEL = 0,
2057 + VLYNQ_INTR_PULSED = 1
2058 +}VLYNQ_INTR_TYPE;
2059 +
2060 +
2061 +/* VLYNQ_RESET_MODE - vlynq reset mode */
2062 +typedef enum
2063 +{
2064 + VLYNQ_RESET_ASSERT, /* hold device in reset state */
2065 + VLYNQ_RESET_DEASSERT, /* release device from reset state */
2066 + VLYNQ_RESET_INITFAIL, /* handle the device in case driver initialization fails */
2067 + VLYNQ_RESET_LINKESTABLISH, /* handle the device in case driver established link */
2068 + VLYNQ_RESET_INITFAIL2, /* Driver initialization failed but VLYNQ link exist. */
2069 + VLYNQ_RESET_INITOK /* Driver initialization finished OK. */
2070 +}VLYNQ_RESET_MODE;
2071 +
2072 +
2073 +
2074 +/*************************************
2075 + * Typedefs *
2076 + *************************************/
2077 +
2078 +struct VLYNQ_DEV_t; /*forward declaration*/
2079 +
2080 +/*--------Function Pointers defintions -----------*/
2081 +
2082 +/* prototype for interrupt handler definition */
2083 +typedef void (*VLYNQ_INTR_CNTRL_ISR)(void *arg1,void *arg2,void *arg3);
2084 +
2085 +typedef void
2086 +(*VLYNQ_RESET_REMOTE)(struct VLYNQ_DEV_t *pDev, VLYNQ_RESET_MODE mode);
2087 +
2088 +typedef void
2089 +(*VLYNQ_REPORT_CB)( struct VLYNQ_DEV_t *pDev, /* This VLYNQ */
2090 + VLYNQ_DEV_TYPE aSrcDvc, /* Event Cause -local/remote? */
2091 + unsigned int dwStatRegVal); /* Value of the relevant status register */
2092 +
2093 +
2094 +/*-------Structure Definitions------------*/
2095 +
2096 +typedef struct VLYNQ_MEMORY_MAP_t
2097 +{
2098 + unsigned int Txmap;
2099 + unsigned int RxOffset[VLYNQ_MAX_MEMORY_REGIONS];
2100 + unsigned int RxSize[VLYNQ_MAX_MEMORY_REGIONS];
2101 +}VLYNQ_MEMORY_MAP;
2102 +
2103 +
2104 +/**VLYNQ_INTERRUPT_CNTRL - defines the vlynq module interrupt
2105 + * settings in vlynq Control register */
2106 +typedef struct VLYNQ_INTERRUPT_CNTRL_t
2107 +{
2108 + /* vlynq interrupts handled by host or remote - maps to
2109 + * intLocal bit in vlynq control register */
2110 + VLYNQ_LOCAL_INT_CONFIG intLocal;
2111 +
2112 + /* remote interrupts handled by vlynq isr or host system
2113 + * interrupt controller - maps to the int2Cfg in vlynq
2114 + * control register */
2115 + VLYNQ_REMOTE_INT_CONFIG intRemote;
2116 +
2117 + /* bit in pending/set register used for module interrupts*/
2118 + unsigned int map_vector;
2119 +
2120 + /* used only if remote interrupts are to be handled by system ISR*/
2121 + unsigned int intr_ptr;
2122 +
2123 +}VLYNQ_INTERRUPT_CNTRL;
2124 +
2125 +
2126 +/* VLYNQ_INTR_CNTRL_ICB - defines the Interrupt control block which hold
2127 + * the interrupt dispatch table. The vlynq_root_isr() indexes into this
2128 + * table to identify the ISR to be invoked
2129 + */
2130 +typedef struct VLYNQ_INTR_CNTRL_ICB_t
2131 +{
2132 + VLYNQ_INTR_CNTRL_ISR isr; /* Clear errors during initialization */
2133 + void *arg1 ; /* Arg 1 for the ISR */
2134 + void *arg2 ; /* Arg 2 for the ISR */
2135 + void *arg3 ; /* Arg 3 for the ISR */
2136 + unsigned int isrCount; /* number of ISR invocations so far */
2137 + struct VLYNQ_INTR_CNTRL_ICB_t *next;
2138 +}VLYNQ_INTR_CNTRL_ICB;
2139 +
2140 +/* overlay of vlynq register set */
2141 +typedef struct VLYNQ_REG_SET_t
2142 +{
2143 + unsigned int revision; /*offset : 0x00 */
2144 + unsigned int control; /* 0x04*/
2145 + unsigned int status; /* 0x08*/
2146 + unsigned int pad1; /* 0x0c*/
2147 + unsigned int intStatus; /*0x10*/
2148 + unsigned int intPending; /*0x14*/
2149 + unsigned int intPtr; /*0x18*/
2150 + unsigned int txMap; /*0x1C*/
2151 + unsigned int rxSize1; /*0x20*/
2152 + unsigned int rxOffset1; /*0x24*/
2153 + unsigned int rxSize2; /*0x28*/
2154 + unsigned int rxOffset2; /*0x2C*/
2155 + unsigned int rxSize3; /*0x30*/
2156 + unsigned int rxOffset3; /*0x34*/
2157 + unsigned int rxSize4; /*0x38*/
2158 + unsigned int rxOffset4; /*0x3C*/
2159 + unsigned int chipVersion; /*0x40*/
2160 + unsigned int pad2[8];
2161 + unsigned int ivr30; /*0x60*/
2162 + unsigned int ivr74; /*0x64*/
2163 + unsigned int pad3[7];
2164 +}VLYNQ_REG_SET;
2165 +
2166 +
2167 +typedef struct VLYNQ_DEV_t
2168 +{
2169 + /** module index:1,2,3... used for debugging purposes */
2170 + unsigned int dev_idx;
2171 +
2172 + /*VLYNQ module base address */
2173 + unsigned int module_base;
2174 +
2175 + /* clock source selection */
2176 + VLYNQ_CLK_SOURCE clk_source;
2177 +
2178 + /* Clock Divider.Val=1 to 8. VLYNQ_clk = VBUSCLK/clk_div */
2179 + unsigned int clk_div;
2180 +
2181 + /* State of the VLYNQ driver, set to VLYNQ_DRV_STATE_UNINIT, when initializing */
2182 + VLYNQ_DRV_STATE state;
2183 +
2184 + /* Valid VLYNQ bus width, filled by driver */
2185 + VLYNQ_BUS_WIDTH width;
2186 +
2187 + /* local memory mapping */
2188 + VLYNQ_MEMORY_MAP local_mem;
2189 +
2190 + /* remote memory mapping */
2191 + VLYNQ_MEMORY_MAP remote_mem;
2192 +
2193 + /* Local module interrupt params */
2194 + VLYNQ_INTERRUPT_CNTRL local_irq;
2195 +
2196 + /* remote module interrupt params */
2197 + VLYNQ_INTERRUPT_CNTRL remote_irq;
2198 +
2199 + /*** ICB related fields **/
2200 +
2201 + /* Sizeof of ICB = VLYNQ_NUM_INT_BITS(for 32 bits in IntPending) +
2202 + * expansion slots for shared interrupts*/
2203 + VLYNQ_INTR_CNTRL_ICB pIntrCB[VLYNQ_NUM_INT_BITS + VLYNQ_IVR_CHAIN_SLOTS];
2204 + VLYNQ_INTR_CNTRL_ICB *freelist;
2205 +
2206 + /* table holding mapping between intVector and the bit position the interrupt
2207 + * is mapped to(mapVector)*/
2208 + char vector_map[32];
2209 +
2210 + /* user callback for vlynq events, NULL if unused */
2211 + VLYNQ_REPORT_CB report_cb;
2212 +
2213 + /* user callback for resetting/realeasing remote device */
2214 + VLYNQ_RESET_REMOTE reset_cb;
2215 +
2216 + /*** Handles provided for direct access to register set if need be
2217 + * Must be intialized to point to appropriate address during
2218 + * vlynq_init */
2219 + volatile VLYNQ_REG_SET * local;
2220 + volatile VLYNQ_REG_SET * remote;
2221 +
2222 + unsigned int intCount; /* number of interrupts generated so far */
2223 + unsigned int isrCount; /* number of ISR invocations so far */
2224 +}VLYNQ_DEV;
2225 +
2226 +
2227 +typedef struct VLYNQ_ISR_ARGS_t
2228 +{
2229 + int irq;
2230 + void * arg;
2231 + void * regset;
2232 +}VLYNQ_ISR_ARGS;
2233 +
2234 +
2235 +/****************************************
2236 + * Function Prototypes *
2237 + * API exported by generic vlynq driver *
2238 + ****************************************/
2239 +/* Initialization function */
2240 +int vlynq_init( VLYNQ_DEV *pdev, VLYNQ_INIT_OPTIONS options);
2241 +
2242 +/* Check vlynq link */
2243 +unsigned int vlynq_link_check( VLYNQ_DEV * pdev);
2244 +
2245 +/* Set interrupt vector in local or remote device */
2246 +int vlynq_interrupt_vector_set( VLYNQ_DEV *pdev,
2247 + unsigned int int_vector,
2248 + unsigned int map_vector,
2249 + VLYNQ_DEV_TYPE dev,
2250 + VLYNQ_INTR_POLARITY pol,
2251 + VLYNQ_INTR_TYPE type);
2252 +
2253 +
2254 +int vlynq_interrupt_vector_cntl( VLYNQ_DEV *pdev,
2255 + unsigned int int_vector,
2256 + VLYNQ_DEV_TYPE dev,
2257 + unsigned int enable);
2258 +
2259 +unsigned int vlynq_interrupt_get_count( VLYNQ_DEV *pdev,
2260 + unsigned int map_vector);
2261 +
2262 +int vlynq_install_isr( VLYNQ_DEV *pdev,
2263 + unsigned int map_vector,
2264 + VLYNQ_INTR_CNTRL_ISR isr,
2265 + void *arg1, void *arg2, void *arg3);
2266 +
2267 +int vlynq_uninstall_isr( VLYNQ_DEV *pdev,
2268 + unsigned int map_vector,
2269 + void *arg1, void *arg2, void *arg3);
2270 +
2271 +
2272 +void vlynq_root_isr(void *arg);
2273 +
2274 +void vlynq_delay(unsigned int clktime);
2275 +
2276 +/* The following functions, provide better granularity in setting
2277 + * interrupt parameters. (for better support of linux INT Controller)
2278 + * Note: The interrupt source is identified by "map_vector"- the bit
2279 + * position in interrupt status register*/
2280 +
2281 +int vlynq_interrupt_vector_map(VLYNQ_DEV * pdev,
2282 + VLYNQ_DEV_TYPE dev,
2283 + unsigned int int_vector,
2284 + unsigned int map_vector);
2285 +
2286 +int vlynq_interrupt_set_polarity(VLYNQ_DEV * pdev,
2287 + VLYNQ_DEV_TYPE dev,
2288 + unsigned int map_vector,
2289 + VLYNQ_INTR_POLARITY pol);
2290 +
2291 +int vlynq_interrupt_get_polarity( VLYNQ_DEV *pdev ,
2292 + VLYNQ_DEV_TYPE dev_type,
2293 + unsigned int map_vector);
2294 +
2295 +int vlynq_interrupt_set_type(VLYNQ_DEV * pdev,
2296 + VLYNQ_DEV_TYPE dev,
2297 + unsigned int map_vector,
2298 + VLYNQ_INTR_TYPE type);
2299 +
2300 +int vlynq_interrupt_get_type( VLYNQ_DEV *pdev,
2301 + VLYNQ_DEV_TYPE dev_type,
2302 + unsigned int map_vector);
2303 +
2304 +int vlynq_interrupt_enable(VLYNQ_DEV* pdev,
2305 + VLYNQ_DEV_TYPE dev,
2306 + unsigned int map_vector);
2307 +
2308 +int vlynq_interrupt_disable(VLYNQ_DEV * pdev,
2309 + VLYNQ_DEV_TYPE dev,
2310 + unsigned int map_vector);
2311 +
2312 +
2313 +
2314 +
2315 +
2316 +#endif /* _VLYNQ_HAL_H_ */
Personal OpenWRT clone
This page took 0.202445 seconds and 5 git commands to generate.