projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix brcm63xx support. Now a kernel is booting, detecting the flash, and can probably...
[openwrt.git] / target / linux / brcm63xx-2.6 / patches / 001-brcm_boards.patch
1 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/bcm63xx_flash.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/bcm63xx_flash.c
2 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/bcm63xx_flash.c 1970-01-01 01:00:00.000000000 +0100
3 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/bcm63xx_flash.c 2006-07-07 22:16:32.000000000 +0200
4 @@ -0,0 +1,775 @@
5 +/*
6 +<:copyright-gpl
7 + Copyright 2002 Broadcom Corp. All Rights Reserved.
8 +
9 + This program is free software; you can distribute it and/or modify it
10 + under the terms of the GNU General Public License (Version 2) as
11 + published by the Free Software Foundation.
12 +
13 + This program is distributed in the hope it will be useful, but WITHOUT
14 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 + for more details.
17 +
18 + You should have received a copy of the GNU General Public License along
19 + with this program; if not, write to the Free Software Foundation, Inc.,
20 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
21 +:>
22 +*/
23 +/*
24 + ***************************************************************************
25 + * File Name : bcm63xx_flash.c
26 + *
27 + * Description: This file contains the flash device driver APIs for bcm63xx board.
28 + *
29 + * Created on : 8/10/2002 seanl: use cfiflash.c, cfliflash.h (AMD specific)
30 + *
31 + ***************************************************************************/
32 +
33 +
34 +/* Includes. */
35 +#include <linux/fs.h>
36 +#include <linux/capability.h>
37 +#include <linux/slab.h>
38 +#include <linux/errno.h>
39 +#include <linux/module.h>
40 +#include <asm/uaccess.h>
41 +
42 +#include <bcm_map_part.h>
43 +#include <board.h>
44 +#define BCMTAG_EXE_USE
45 +#include <bcmTag.h>
46 +#include "cfiflash.h"
47 +#include "boardparms.h"
48 +
49 +//#define DEBUG_FLASH
50 +
51 +static FLASH_ADDR_INFO fInfo;
52 +static int flashInitialized = 0;
53 +
54 +void *retriedKmalloc(size_t size)
55 +{
56 + void *pBuf;
57 + int tryCount = 0;
58 +
59 + // try 1000 times before quit
60 + while (((pBuf = kmalloc(size, GFP_KERNEL)) == NULL) && (tryCount++ < 1000))
61 + {
62 + current->state = TASK_INTERRUPTIBLE;
63 + schedule_timeout(HZ/10);
64 + }
65 + if (tryCount >= 1000)
66 + pBuf = NULL;
67 + else
68 + memset(pBuf, 0, size);
69 +
70 + return pBuf;
71 +}
72 +
73 +void retriedKfree(void *pBuf)
74 +{
75 + kfree(pBuf);
76 +}
77 +
78 +/***************************************************************************
79 +// Function Name: getCrc32
80 +// Description : caculate the CRC 32 of the given data.
81 +// Parameters : pdata - array of data.
82 +// size - number of input data bytes.
83 +// crc - either CRC32_INIT_VALUE or previous return value.
84 +// Returns : crc.
85 +****************************************************************************/
86 +UINT32 getCrc32(byte *pdata, UINT32 size, UINT32 crc)
87 +{
88 + while (size-- > 0)
89 + crc = (crc >> 8) ^ Crc32_table[(crc ^ *pdata++) & 0xff];
90 +
91 + return crc;
92 +}
93 +
94 +// get the nvram start addr
95 +//
96 +unsigned long get_nvram_start_addr(void)
97 +{
98 + return ((unsigned long)
99 + (flash_get_memptr(fInfo.flash_nvram_start_blk) + fInfo.flash_nvram_blk_offset));
100 +}
101 +
102 +// get the scratch_pad start addr
103 +//
104 +unsigned long get_scratch_pad_start_addr(void)
105 +{
106 + return ((unsigned long)
107 + (flash_get_memptr(fInfo.flash_scratch_pad_start_blk) + fInfo.flash_scratch_pad_blk_offset));
108 +}
109 +
110 +
111 +
112 +/* *********************************************************************
113 + * kerSysImageTagGet()
114 + * Get the image tag
115 + * Input parameters:
116 + * none
117 + * Return value:
118 + * point to tag -- Found
119 + * NULL -- failed
120 + ********************************************************************* */
121 +PFILE_TAG kerSysImageTagGet(void)
122 +{
123 + int i;
124 + int totalBlks = flash_get_numsectors();
125 + UINT32 crc;
126 + unsigned char *sectAddr;
127 + PFILE_TAG pTag;
128 +
129 +#if defined(DEBUG_FLASH)
130 + printk("totalblks in tagGet=%d\n", totalBlks);
131 +#endif
132 +
133 + // start from 2nd blk, assume 1st one is always CFE
134 + for (i = 1; i < totalBlks; i++)
135 + {
136 + sectAddr = flash_get_memptr((byte) i);
137 + crc = CRC32_INIT_VALUE;
138 + crc = getCrc32(sectAddr, (UINT32)TAG_LEN-TOKEN_LEN, crc);
139 + pTag = (PFILE_TAG) sectAddr;
140 +
141 +#if defined(DEBUG_FLASH)
142 + printk("Check Tag crc on blk [%d]\n", i);
143 +#endif
144 +
145 + if (crc == (UINT32)(*(UINT32*)(pTag->tagValidationToken)))
146 + return pTag;
147 + }
148 +
149 + return (PFILE_TAG) NULL;
150 +}
151 +
152 +// Initialize the flash and fill out the fInfo structure
153 +void kerSysFlashInit( void )
154 +{
155 + int i = 0;
156 + int totalBlks = 0;
157 + int totalSize = 0;
158 + int startAddr = 0;
159 + int usedBlkSize = 0;
160 + NVRAM_DATA nvramData;
161 + UINT32 crc = CRC32_INIT_VALUE, savedCrc;
162 + PFILE_TAG pTag = NULL;
163 + unsigned long kernelEndAddr = 0;
164 + unsigned long spAddr = 0;
165 +
166 + if (flashInitialized)
167 + return;
168 +
169 + flashInitialized = 1;
170 + flash_init();
171 +
172 + totalBlks = flash_get_numsectors();
173 + totalSize = flash_get_total_size();
174 +
175 + printk("Total Flash size: %dK with %d sectors\n", totalSize/1024, totalBlks);
176 +
177 + /* nvram is always at the end of flash */
178 + fInfo.flash_nvram_length = FLASH45_LENGTH_NVRAM;
179 + fInfo.flash_nvram_start_blk = 0; /* always the first block */
180 + fInfo.flash_nvram_number_blk = 1; /*always fits in the first block */
181 + fInfo.flash_nvram_blk_offset = NVRAM_DATA_OFFSET;
182 +
183 + // check nvram CRC
184 + memcpy((char *)&nvramData, (char *)get_nvram_start_addr(), sizeof(NVRAM_DATA));
185 + savedCrc = nvramData.ulCheckSum;
186 + nvramData.ulCheckSum = 0;
187 + crc = getCrc32((char *)&nvramData, (UINT32) sizeof(NVRAM_DATA), crc);
188 +
189 + BpSetBoardId( nvramData.szBoardId );
190 +
191 + fInfo.flash_persistent_length = NVRAM_PSI_DEFAULT;
192 + if (savedCrc != crc)
193 + {
194 + printk("***Board is not initialized****: Using the default PSI size: %d\n",
195 + fInfo.flash_persistent_length);
196 + }
197 + else
198 + {
199 + unsigned long ulPsiSize;
200 + if( BpGetPsiSize( &ulPsiSize ) == BP_SUCCESS )
201 + fInfo.flash_persistent_length = ulPsiSize;
202 + else
203 + {
204 + printk("***Board id is not set****: Using the default PSI size: %d\n",
205 + fInfo.flash_persistent_length);
206 + }
207 + }
208 +
209 + fInfo.flash_persistent_length *= ONEK;
210 + startAddr = totalSize - fInfo.flash_persistent_length;
211 + fInfo.flash_persistent_start_blk = flash_get_blk(startAddr+FLASH_BASE_ADDR_REG);
212 + fInfo.flash_persistent_number_blk = totalBlks - fInfo.flash_persistent_start_blk;
213 + // save abs SP address (Scratch Pad). it is before PSI
214 + spAddr = startAddr - SP_MAX_LEN ;
215 + // find out the offset in the start_blk
216 + usedBlkSize = 0;
217 + for (i = fInfo.flash_persistent_start_blk;
218 + i < (fInfo.flash_persistent_start_blk + fInfo.flash_persistent_number_blk); i++)
219 + {
220 + usedBlkSize += flash_get_sector_size((byte) i);
221 + }
222 + fInfo.flash_persistent_blk_offset = usedBlkSize - fInfo.flash_persistent_length;
223 +
224 + // get the info for sp
225 + if (!(pTag = kerSysImageTagGet()))
226 + {
227 + printk("Failed to read image tag from flash\n");
228 + return;
229 + }
230 + kernelEndAddr = (unsigned long) simple_strtoul(pTag->kernelAddress, NULL, 10) + \
231 + (unsigned long) simple_strtoul(pTag->kernelLen, NULL, 10);
232 +
233 + // make suer sp does not share kernel block
234 + fInfo.flash_scratch_pad_start_blk = flash_get_blk(spAddr+FLASH_BASE_ADDR_REG);
235 + if (fInfo.flash_scratch_pad_start_blk != flash_get_blk(kernelEndAddr))
236 + {
237 + fInfo.flash_scratch_pad_length = SP_MAX_LEN;
238 + if (fInfo.flash_persistent_start_blk == fInfo.flash_scratch_pad_start_blk) // share blk
239 + {
240 +#if 1 /* do not used scratch pad unless it's in its own sector */
241 + printk("Scratch pad is not used for this flash part.\n");
242 + fInfo.flash_scratch_pad_length = 0; // no sp
243 +#else /* allow scratch pad to share a sector with another section such as PSI */
244 + fInfo.flash_scratch_pad_number_blk = 1;
245 + fInfo.flash_scratch_pad_blk_offset = fInfo.flash_persistent_blk_offset - fInfo.flash_scratch_pad_length;
246 +#endif
247 + }
248 + else // on different blk
249 + {
250 + fInfo.flash_scratch_pad_number_blk = fInfo.flash_persistent_start_blk\
251 + - fInfo.flash_scratch_pad_start_blk;
252 + // find out the offset in the start_blk
253 + usedBlkSize = 0;
254 + for (i = fInfo.flash_scratch_pad_start_blk;
255 + i < (fInfo.flash_scratch_pad_start_blk + fInfo.flash_scratch_pad_number_blk); i++)
256 + usedBlkSize += flash_get_sector_size((byte) i);
257 + fInfo.flash_scratch_pad_blk_offset = usedBlkSize - fInfo.flash_scratch_pad_length;
258 + }
259 + }
260 + else
261 + {
262 + printk("No flash for scratch pad!\n");
263 + fInfo.flash_scratch_pad_length = 0; // no sp
264 + }
265 +
266 +#if defined(DEBUG_FLASH)
267 + printk("fInfo.flash_scratch_pad_start_blk = %d\n", fInfo.flash_scratch_pad_start_blk);
268 + printk("fInfo.flash_scratch_pad_number_blk = %d\n", fInfo.flash_scratch_pad_number_blk);
269 + printk("fInfo.flash_scratch_pad_length = 0x%x\n", fInfo.flash_scratch_pad_length);
270 + printk("fInfo.flash_scratch_pad_blk_offset = 0x%x\n", (unsigned int)fInfo.flash_scratch_pad_blk_offset);
271 +
272 + printk("fInfo.flash_nvram_start_blk = %d\n", fInfo.flash_nvram_start_blk);
273 + printk("fInfo.flash_nvram_blk_offset = 0x%x\n", (unsigned int)fInfo.flash_nvram_blk_offset);
274 + printk("fInfo.flash_nvram_number_blk = %d\n", fInfo.flash_nvram_number_blk);
275 +
276 + printk("psi startAddr = %x\n", startAddr+FLASH_BASE_ADDR_REG);
277 + printk("fInfo.flash_persistent_start_blk = %d\n", fInfo.flash_persistent_start_blk);
278 + printk("fInfo.flash_persistent_blk_offset = 0x%x\n", (unsigned int)fInfo.flash_persistent_blk_offset);
279 + printk("fInfo.flash_persistent_number_blk = %d\n", fInfo.flash_persistent_number_blk);
280 +#endif
281 +
282 +}
283 +
284 +
285 +
286 +/***********************************************************************
287 + * Function Name: kerSysFlashAddrInfoGet
288 + * Description : Fills in a structure with information about the NVRAM
289 + * and persistent storage sections of flash memory.
290 + * Fro physmap.c to mount the fs vol.
291 + * Returns : None.
292 + ***********************************************************************/
293 +void kerSysFlashAddrInfoGet(PFLASH_ADDR_INFO pflash_addr_info)
294 +{
295 + pflash_addr_info->flash_nvram_blk_offset = fInfo.flash_nvram_blk_offset;
296 + pflash_addr_info->flash_nvram_length = fInfo.flash_nvram_length;
297 + pflash_addr_info->flash_nvram_number_blk = fInfo.flash_nvram_number_blk;
298 + pflash_addr_info->flash_nvram_start_blk = fInfo.flash_nvram_start_blk;
299 + pflash_addr_info->flash_persistent_blk_offset = fInfo.flash_persistent_blk_offset;
300 + pflash_addr_info->flash_persistent_length = fInfo.flash_persistent_length;
301 + pflash_addr_info->flash_persistent_number_blk = fInfo.flash_persistent_number_blk;
302 + pflash_addr_info->flash_persistent_start_blk = fInfo.flash_persistent_start_blk;
303 +}
304 +
305 +
306 +// get shared blks into *** pTempBuf *** which has to be released bye the caller!
307 +// return: if pTempBuf != NULL, poits to the data with the dataSize of the buffer
308 +// !NULL -- ok
309 +// NULL -- fail
310 +static char *getSharedBlks(int start_blk, int end_blk)
311 +{
312 + int i = 0;
313 + int usedBlkSize = 0;
314 + int sect_size = 0;
315 + char *pTempBuf = NULL;
316 + char *pBuf = NULL;
317 +
318 + for (i = start_blk; i < end_blk; i++)
319 + usedBlkSize += flash_get_sector_size((byte) i);
320 +
321 +#if defined(DEBUG_FLASH)
322 + printk("usedBlkSize = %d\n", usedBlkSize);
323 +#endif
324 +
325 + if ((pTempBuf = (char *) retriedKmalloc(usedBlkSize)) == NULL)
326 + {
327 + printk("failed to allocate memory with size: %d\n", usedBlkSize);
328 + return pTempBuf;
329 + }
330 +
331 + pBuf = pTempBuf;
332 + for (i = start_blk; i < end_blk; i++)
333 + {
334 + sect_size = flash_get_sector_size((byte) i);
335 +
336 +#if defined(DEBUG_FLASH)
337 + printk("i = %d, sect_size = %d, end_blk = %d\n", i, sect_size, end_blk);
338 +#endif
339 + flash_read_buf((byte)i, 0, pBuf, sect_size);
340 + pBuf += sect_size;
341 + }
342 +
343 + return pTempBuf;
344 +}
345 +
346 +
347 +
348 +// Set the pTempBuf to flash from start_blk to end_blk
349 +// return:
350 +// 0 -- ok
351 +// -1 -- fail
352 +static int setSharedBlks(int start_blk, int end_blk, char *pTempBuf)
353 +{
354 + int i = 0;
355 + int sect_size = 0;
356 + int sts = 0;
357 + char *pBuf = pTempBuf;
358 +
359 + for (i = start_blk; i < end_blk; i++)
360 + {
361 + sect_size = flash_get_sector_size((byte) i);
362 + flash_sector_erase_int(i);
363 + if (flash_write_buf(i, 0, pBuf, sect_size) != sect_size)
364 + {
365 + printk("Error writing flash sector %d.", i);
366 + sts = -1;
367 + break;
368 + }
369 + pBuf += sect_size;
370 + }
371 +
372 + return sts;
373 +}
374 +
375 +
376 +
377 +/*******************************************************************************
378 + * NVRAM functions
379 + *******************************************************************************/
380 +
381 +// get nvram data
382 +// return:
383 +// 0 - ok
384 +// -1 - fail
385 +int kerSysNvRamGet(char *string, int strLen, int offset)
386 +{
387 + char *pBuf = NULL;
388 +
389 + if (!flashInitialized)
390 + kerSysFlashInit();
391 +
392 + if (strLen > FLASH45_LENGTH_NVRAM)
393 + return -1;
394 +
395 + if ((pBuf = getSharedBlks(fInfo.flash_nvram_start_blk,
396 + (fInfo.flash_nvram_start_blk + fInfo.flash_nvram_number_blk))) == NULL)
397 + return -1;
398 +
399 + // get string off the memory buffer
400 + memcpy(string, (pBuf + fInfo.flash_nvram_blk_offset + offset), strLen);
401 +
402 + retriedKfree(pBuf);
403 +
404 + return 0;
405 +}
406 +
407 +
408 +// set nvram
409 +// return:
410 +// 0 - ok
411 +// -1 - fail
412 +int kerSysNvRamSet(char *string, int strLen, int offset)
413 +{
414 + int sts = 0;
415 + char *pBuf = NULL;
416 +
417 + if (strLen > FLASH45_LENGTH_NVRAM)
418 + return -1;
419 +
420 + if ((pBuf = getSharedBlks(fInfo.flash_nvram_start_blk,
421 + (fInfo.flash_nvram_start_blk + fInfo.flash_nvram_number_blk))) == NULL)
422 + return -1;
423 +
424 + // set string to the memory buffer
425 + memcpy((pBuf + fInfo.flash_nvram_blk_offset + offset), string, strLen);
426 +
427 + if (setSharedBlks(fInfo.flash_nvram_start_blk,
428 + (fInfo.flash_nvram_number_blk + fInfo.flash_nvram_start_blk), pBuf) != 0)
429 + sts = -1;
430 +
431 + retriedKfree(pBuf);
432 +
433 + return sts;
434 +}
435 +
436 +
437 +/***********************************************************************
438 + * Function Name: kerSysEraseNvRam
439 + * Description : Erase the NVRAM storage section of flash memory.
440 + * Returns : 1 -- ok, 0 -- fail
441 + ***********************************************************************/
442 +int kerSysEraseNvRam(void)
443 +{
444 + int sts = 1;
445 + char *tempStorage = retriedKmalloc(FLASH45_LENGTH_NVRAM);
446 +
447 + // just write the whole buf with '0xff' to the flash
448 + if (!tempStorage)
449 + sts = 0;
450 + else
451 + {
452 + memset(tempStorage, 0xff, FLASH45_LENGTH_NVRAM);
453 + if (kerSysNvRamSet(tempStorage, FLASH45_LENGTH_NVRAM, 0) != 0)
454 + sts = 0;
455 + retriedKfree(tempStorage);
456 + }
457 +
458 + return sts;
459 +}
460 +
461 +
462 +/*******************************************************************************
463 + * PSI functions
464 + *******************************************************************************/
465 +// get psi data
466 +// return:
467 +// 0 - ok
468 +// -1 - fail
469 +int kerSysPersistentGet(char *string, int strLen, int offset)
470 +{
471 + char *pBuf = NULL;
472 +
473 + if (strLen > fInfo.flash_persistent_length)
474 + return -1;
475 +
476 + if ((pBuf = getSharedBlks(fInfo.flash_persistent_start_blk,
477 + (fInfo.flash_persistent_start_blk + fInfo.flash_persistent_number_blk))) == NULL)
478 + return -1;
479 +
480 + // get string off the memory buffer
481 + memcpy(string, (pBuf + fInfo.flash_persistent_blk_offset + offset), strLen);
482 +
483 + retriedKfree(pBuf);
484 +
485 + return 0;
486 +}
487 +
488 +
489 +// set psi
490 +// return:
491 +// 0 - ok
492 +// -1 - fail
493 +int kerSysPersistentSet(char *string, int strLen, int offset)
494 +{
495 + int sts = 0;
496 + char *pBuf = NULL;
497 +
498 + if (strLen > fInfo.flash_persistent_length)
499 + return -1;
500 +
501 + if ((pBuf = getSharedBlks(fInfo.flash_persistent_start_blk,
502 + (fInfo.flash_persistent_start_blk + fInfo.flash_persistent_number_blk))) == NULL)
503 + return -1;
504 +
505 + // set string to the memory buffer
506 + memcpy((pBuf + fInfo.flash_persistent_blk_offset + offset), string, strLen);
507 +
508 + if (setSharedBlks(fInfo.flash_persistent_start_blk,
509 + (fInfo.flash_persistent_number_blk + fInfo.flash_persistent_start_blk), pBuf) != 0)
510 + sts = -1;
511 +
512 + retriedKfree(pBuf);
513 +
514 + return sts;
515 +}
516 +
517 +
518 +// flash bcm image
519 +// return:
520 +// 0 - ok
521 +// !0 - the sector number fail to be flashed (should not be 0)
522 +int kerSysBcmImageSet( int flash_start_addr, char *string, int size)
523 +{
524 + int sts;
525 + int sect_size;
526 + int blk_start;
527 + int i;
528 + char *pTempBuf = NULL;
529 + int whole_image = 0;
530 +
531 + blk_start = flash_get_blk(flash_start_addr);
532 + if( blk_start < 0 )
533 + return( -1 );
534 +
535 + if (flash_start_addr == FLASH_BASE && size > FLASH45_LENGTH_BOOT_ROM)
536 + whole_image = 1;
537 +
538 + /* write image to flash memory */
539 + do
540 + {
541 + sect_size = flash_get_sector_size(blk_start);
542 +// NOTE: for memory problem in multiple PVC configuration, temporary get rid of kmalloc this 64K for now.
543 +// if ((pTempBuf = (char *)retriedKmalloc(sect_size)) == NULL)
544 +// {
545 +// printk("Failed to allocate memory with size: %d. Reset the router...\n", sect_size);
546 +// kerSysMipsSoftReset(); // reset the board right away.
547 +// }
548 + // for whole image, no check on psi
549 + if (!whole_image && blk_start == fInfo.flash_persistent_start_blk) // share the blk with psi
550 + {
551 + if (size > (sect_size - fInfo.flash_persistent_length))
552 + {
553 + printk("Image is too big\n");
554 + break; // image is too big. Can not overwrite to nvram
555 + }
556 + if ((pTempBuf = (char *)retriedKmalloc(sect_size)) == NULL)
557 + {
558 + printk("Failed to allocate memory with size: %d. Reset the router...\n", sect_size);
559 + kerSysMipsSoftReset(); // reset the board right away.
560 + }
561 + flash_read_buf((byte)blk_start, 0, pTempBuf, sect_size);
562 + if (copy_from_user((void *)pTempBuf,(void *)string, size) != 0)
563 + break; // failed ?
564 + flash_sector_erase_int(blk_start); // erase blk before flash
565 + if (flash_write_buf(blk_start, 0, pTempBuf, sect_size) == sect_size)
566 + size = 0; // break out and say all is ok
567 + retriedKfree(pTempBuf);
568 + break;
569 + }
570 +
571 + flash_sector_erase_int(blk_start); // erase blk before flash
572 +
573 + if (sect_size > size)
574 + {
575 + if (size & 1)
576 + size++;
577 + sect_size = size;
578 + }
579 +
580 + if ((i = flash_write_buf(blk_start, 0, string, sect_size)) != sect_size) {
581 + break;
582 + }
583 + blk_start++;
584 + string += sect_size;
585 + size -= sect_size;
586 + } while (size > 0);
587 +
588 + if (whole_image)
589 + {
590 + // If flashing a whole image, erase to end of flash.
591 + int total_blks = flash_get_numsectors();
592 + while( blk_start < total_blks )
593 + {
594 + flash_sector_erase_int(blk_start);
595 + blk_start++;
596 + }
597 + }
598 + if (pTempBuf)
599 + retriedKfree(pTempBuf);
600 +
601 + if( size == 0 )
602 + sts = 0; // ok
603 + else
604 + sts = blk_start; // failed to flash this sector
605 +
606 + return sts;
607 +}
608 +
609 +/*******************************************************************************
610 + * SP functions
611 + *******************************************************************************/
612 +// get sp data. NOTE: memcpy work here -- not using copy_from/to_user
613 +// return:
614 +// 0 - ok
615 +// -1 - fail
616 +int kerSysScratchPadGet(char *tokenId, char *tokBuf, int bufLen)
617 +{
618 + PSP_HEADER pHead = NULL;
619 + PSP_TOKEN pToken = NULL;
620 + char *pBuf = NULL;
621 + char *pShareBuf = NULL;
622 + char *startPtr = NULL;
623 + char *endPtr = NULL;
624 + char *spEndPtr = NULL;
625 + int sts = -1;
626 +
627 + if (fInfo.flash_scratch_pad_length == 0)
628 + return sts;
629 +
630 + if (bufLen >= (fInfo.flash_scratch_pad_length - sizeof(SP_HEADER) - sizeof(SP_TOKEN)))
631 + {
632 + printk("Exceed scratch pad space by %d\n", bufLen - fInfo.flash_scratch_pad_length \
633 + - sizeof(SP_HEADER) - sizeof(SP_TOKEN));
634 + return sts;
635 + }
636 +
637 + if ((pShareBuf = getSharedBlks(fInfo.flash_scratch_pad_start_blk,
638 + (fInfo.flash_scratch_pad_start_blk + fInfo.flash_scratch_pad_number_blk))) == NULL)
639 + return sts;
640 +
641 + // pBuf points to SP buf
642 + pBuf = pShareBuf + fInfo.flash_scratch_pad_blk_offset;
643 +
644 + pHead = (PSP_HEADER) pBuf;
645 + if (memcmp(pHead->SPMagicNum, MAGIC_NUMBER, MAGIC_NUM_LEN) != 0)
646 + {
647 + printk("Scrap pad is not initialized.\n");
648 + return sts;
649 + }
650 +
651 + // search up to SPUsedLen for the token
652 + startPtr = pBuf + sizeof(SP_HEADER);
653 + endPtr = pBuf + pHead->SPUsedLen;
654 + spEndPtr = pBuf + SP_MAX_LEN;
655 + while (startPtr < endPtr && startPtr < spEndPtr)
656 + {
657 + pToken = (PSP_TOKEN) startPtr;
658 + if (strncmp(pToken->tokenName, tokenId, TOKEN_NAME_LEN) == 0)
659 + {
660 + memcpy(tokBuf, startPtr + sizeof(SP_TOKEN), bufLen);
661 + sts = 0;
662 + break;
663 + }
664 + // get next token
665 + startPtr += sizeof(SP_TOKEN) + pToken->tokenLen;
666 + }
667 +
668 + retriedKfree(pShareBuf);
669 +
670 + return sts;
671 +}
672 +
673 +
674 +// set sp. NOTE: memcpy work here -- not using copy_from/to_user
675 +// return:
676 +// 0 - ok
677 +// -1 - fail
678 +int kerSysScratchPadSet(char *tokenId, char *tokBuf, int bufLen)
679 +{
680 + PSP_TOKEN pToken = NULL;
681 + PSP_HEADER pHead = NULL;
682 + char *pShareBuf = NULL;
683 + char *pBuf = NULL;
684 + SP_HEADER SPHead;
685 + SP_TOKEN SPToken;
686 + char *curPtr;
687 + int sts = -1;
688 +
689 + if (fInfo.flash_scratch_pad_length == 0)
690 + return sts;
691 +
692 + if (bufLen >= (fInfo.flash_scratch_pad_length - sizeof(SP_HEADER) - sizeof(SP_TOKEN)))
693 + {
694 + printk("Exceed scratch pad space by %d\n", bufLen - fInfo.flash_scratch_pad_length \
695 + - sizeof(SP_HEADER) - sizeof(SP_TOKEN));
696 + return sts;
697 + }
698 +
699 + if ((pShareBuf = getSharedBlks(fInfo.flash_scratch_pad_start_blk,
700 + (fInfo.flash_scratch_pad_start_blk + fInfo.flash_scratch_pad_number_blk))) == NULL)
701 + return sts;
702 +
703 + // pBuf points to SP buf
704 + pBuf = pShareBuf + fInfo.flash_scratch_pad_blk_offset;
705 + pHead = (PSP_HEADER) pBuf;
706 +
707 + // form header info. SPUsedLen later on...
708 + memset((char *)&SPHead, 0, sizeof(SP_HEADER));
709 + memcpy(SPHead.SPMagicNum, MAGIC_NUMBER, MAGIC_NUM_LEN);
710 + SPHead.SPVersion = SP_VERSION;
711 +
712 + // form token info.
713 + memset((char*)&SPToken, 0, sizeof(SP_TOKEN));
714 + strncpy(SPToken.tokenName, tokenId, TOKEN_NAME_LEN - 1);
715 + SPToken.tokenLen = bufLen;
716 + if (memcmp(pHead->SPMagicNum, MAGIC_NUMBER, MAGIC_NUM_LEN) != 0)
717 + {
718 + // new sp, so just flash the token
719 + printk("No Scrap pad found. Initialize scratch pad...\n");
720 + SPHead.SPUsedLen = sizeof(SP_HEADER) + sizeof(SP_TOKEN) + bufLen;
721 + memcpy(pBuf, (char *)&SPHead, sizeof(SP_HEADER));
722 + curPtr = pBuf + sizeof(SP_HEADER);
723 + memcpy(curPtr, (char *)&SPToken, sizeof(SP_TOKEN));
724 + curPtr += sizeof(SP_TOKEN);
725 + memcpy(curPtr, tokBuf, bufLen);
726 + }
727 + else
728 + {
729 + // need search for the token, if exist with same size overwrite it. if sizes differ,
730 + // move over the later token data over and put the new one at the end
731 + char *endPtr = pBuf + pHead->SPUsedLen;
732 + char *spEndPtr = pBuf + SP_MAX_LEN;
733 + curPtr = pBuf + sizeof(SP_HEADER);
734 + while (curPtr < endPtr && curPtr < spEndPtr)
735 + {
736 + pToken = (PSP_TOKEN) curPtr;
737 + if (strncmp(pToken->tokenName, tokenId, TOKEN_NAME_LEN) == 0)
738 + {
739 + if (pToken->tokenLen == bufLen) // overwirte it
740 + {
741 + memcpy((curPtr+sizeof(SP_TOKEN)), tokBuf, bufLen);
742 + break;
743 + }
744 + else // move later data over and put the new token at the end
745 + {
746 + memcpy((curPtr+sizeof(SP_TOKEN)), tokBuf, bufLen); // ~~~
747 + break;
748 + }
749 + }
750 + else // not same token ~~~
751 + {
752 + }
753 + // get next token
754 + curPtr += sizeof(SP_TOKEN) + pToken->tokenLen;
755 + } // end while
756 + SPHead.SPUsedLen = sizeof(SP_HEADER) + sizeof(SP_TOKEN) + bufLen; // ~~~
757 + if (SPHead.SPUsedLen > SP_MAX_LEN)
758 + {
759 + printk("No more Scratch pad space left! Over limit by %d bytes\n", SPHead.SPUsedLen - SP_MAX_LEN);
760 + return sts;
761 + }
762 +
763 + } // else if not new sp
764 +
765 + sts = setSharedBlks(fInfo.flash_scratch_pad_start_blk,
766 + (fInfo.flash_scratch_pad_number_blk + fInfo.flash_scratch_pad_start_blk), pShareBuf);
767 +
768 + retriedKfree(pShareBuf);
769 +
770 + return sts;
771 +
772 +
773 +}
774 +
775 +int kerSysFlashSizeGet(void)
776 +{
777 + return flash_get_total_size();
778 +}
779 +
780 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/bcm63xx_led.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/bcm63xx_led.c
781 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/bcm63xx_led.c 1970-01-01 01:00:00.000000000 +0100
782 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/bcm63xx_led.c 2006-07-07 22:16:32.000000000 +0200
783 @@ -0,0 +1,582 @@
784 +/*
785 +<:copyright-gpl
786 + Copyright 2002 Broadcom Corp. All Rights Reserved.
787 +
788 + This program is free software; you can distribute it and/or modify it
789 + under the terms of the GNU General Public License (Version 2) as
790 + published by the Free Software Foundation.
791 +
792 + This program is distributed in the hope it will be useful, but WITHOUT
793 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
794 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
795 + for more details.
796 +
797 + You should have received a copy of the GNU General Public License along
798 + with this program; if not, write to the Free Software Foundation, Inc.,
799 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
800 +:>
801 +*/
802 +/***************************************************************************
803 + * File Name : bcm63xx_led.c
804 + *
805 + * Description:
806 + *
807 + * This file contains bcm963xx board led control API functions.
808 + *
809 + * To use it, do the following
810 + *
811 + * 1). define in the board.c the following led mappping (this is for 6345GW board):
812 + * const LED_MAP_PAIR cLedMapping45GW[] =
813 + * { // led name Initial state physical pin (ledMask)
814 + * {kLedUsb, kLedStateOff, GPIO_LED_PIN_7},
815 + * {kLedAdsl, kLedStateOff, GPIO_LED_PIN_8},
816 + * {kLedPPP, kLedStateOff, GPIO_LED_PIN_9}, // PPP and WanData share PIN_9
817 + * {kLedWanData, kLedStateOff, GPIO_LED_PIN_9},
818 + * {kLedWireless, kLedStateOff, GPIO_LED_PIN_10},
819 + * {kLedEnd, kLedStateOff, 0 } // NOTE: kLedEnd has to be at the end.
820 + *
821 + * 2). };To initialize led API and initial state of the leds, call the following function with the mapping
822 + * pointer from the above struct
823 + *
824 + * boardLedInit((PLED_MAP_PAIR) &cLedMapping45R);
825 + *
826 + * 3). Sample call for kernel mode:
827 + *
828 + * kerSysLedCtrl(kLedAdsl, kLedStateBlinkOnce); // kLedxxx defines in board.h
829 + *
830 + * 4). Sample call for user mode
831 + *
832 + * sysLedCtrl(kLedAdsl, kLedStateBlinkOnce); // kLedxxx defines in board_api.h
833 + *
834 + *
835 + * Created on : 10/28/2002 seanl
836 + *
837 + ***************************************************************************/
838 +
839 +/* Includes. */
840 +#include <linux/init.h>
841 +#include <linux/fs.h>
842 +#include <linux/capability.h>
843 +#include <linux/slab.h>
844 +#include <linux/errno.h>
845 +#include <linux/module.h>
846 +#include <linux/netdevice.h>
847 +#include <asm/uaccess.h>
848 +
849 +#include <bcm_map_part.h>
850 +#include <board.h>
851 +
852 +#define k100ms (HZ / 10) // ~100 ms
853 +#define kFastBlinkCount 0 // ~100ms
854 +#define kSlowBlinkCount 5 // ~600ms
855 +
856 +#define MAX_VIRT_LEDS 12
857 +
858 +// uncomment // for debug led
859 +//#define DEBUG_LED
860 +
861 +// global variables:
862 +struct timer_list gLedTimer;
863 +int gTimerOn = FALSE;
864 +int gLedCount = 0;
865 +
866 +typedef struct ledinfo
867 +{
868 + unsigned short ledMask; // mask for led: ie. giop 10 = 0x0400
869 + unsigned short ledActiveLow; // GPIO bit reset to turn on LED
870 + unsigned short ledMaskFail; // mask for led: ie. giop 10 = 0x0400
871 + unsigned short ledActiveLowFail;// GPIO bit reset to turn on LED
872 + BOARD_LED_STATE ledState; // current led state
873 + BOARD_LED_STATE savedLedState; // used in blink once for restore to the orignal ledState
874 + int blinkCountDown; // if == 0, do blink (toggle). Is assgined value and dec by 1 at each timer.
875 +} LED_INFO, *PLED_INFO;
876 +
877 +static PLED_INFO gLed = NULL;
878 +static PLED_INFO gpVirtLeds[MAX_VIRT_LEDS];
879 +static HANDLE_LED_FUNC gLedHwFunc[MAX_VIRT_LEDS];
880 +static HANDLE_LED_FUNC gLedHwFailFunc[MAX_VIRT_LEDS];
881 +
882 +#if 0 /* BROKEN */
883 +#if defined(CONFIG_BCM96348) || defined(CONFIG_BCM96338)
884 +static int gLedOffInBridgeMode = 1;
885 +#elif defined(CONFIG_BCM96345)
886 +static int gLedOffInBridgeMode = 0;
887 +#endif
888 +#endif
889 +
890 +void ledTimerExpire(void);
891 +int initLedInfo( PLED_MAP_PAIR pCurMap, PLED_INFO pCurLed );
892 +
893 +//**************************************************************************************
894 +// LED operations
895 +//**************************************************************************************
896 +
897 +// turn led on and set the ledState
898 +void ledOn(PLED_INFO pLed)
899 +{
900 + if( pLed->ledMask )
901 + {
902 + GPIO->GPIODir |= pLed->ledMask; // turn on the direction bit in case was turned off by some one
903 + if( pLed->ledActiveLow )
904 + GPIO->GPIOio &= ~pLed->ledMask; // turn on the led
905 + else
906 + GPIO->GPIOio |= pLed->ledMask; // turn on the led
907 + pLed->ledState = pLed->savedLedState = kLedStateOn;
908 + }
909 +}
910 +
911 +
912 +// turn led off and set the ledState
913 +void ledOff(PLED_INFO pLed)
914 +{
915 + if( pLed->ledMask )
916 + {
917 + GPIO->GPIODir |= pLed->ledMask; // turn on the direction bit in case was turned off by some one
918 + if( pLed->ledActiveLow )
919 + GPIO->GPIOio |= pLed->ledMask; // turn off the led
920 + else
921 + GPIO->GPIOio &= ~pLed->ledMask; // turn off the led
922 + pLed->ledState = pLed->savedLedState = kLedStateOff;
923 + }
924 +}
925 +
926 +// turn led on and set the ledState
927 +void ledOnFail(PLED_INFO pLed)
928 +{
929 + if( pLed->ledMaskFail )
930 + {
931 + GPIO->GPIODir |= pLed->ledMaskFail; // turn on the direction bit in case was turned off by some one
932 + if( pLed->ledActiveLowFail )
933 + GPIO->GPIOio &= ~pLed->ledMaskFail;// turn on the led
934 + else
935 + GPIO->GPIOio |= pLed->ledMaskFail; // turn on the led
936 + pLed->ledState = pLed->savedLedState = kLedStateFail;
937 + }
938 +}
939 +
940 +
941 +// turn led off and set the ledState
942 +void ledOffFail(PLED_INFO pLed)
943 +{
944 + if( pLed->ledMaskFail )
945 + {
946 + GPIO->GPIODir |= pLed->ledMaskFail; // turn on the direction bit in case was turned off by some one
947 + if( pLed->ledActiveLowFail )
948 + GPIO->GPIOio |= pLed->ledMaskFail; // turn off the led
949 + else
950 + GPIO->GPIOio &= ~pLed->ledMaskFail;// turn off the led
951 + pLed->ledState = pLed->savedLedState = kLedStateOff;
952 + }
953 +}
954 +
955 +
956 +// toggle the led and return the current ledState
957 +BOARD_LED_STATE ledToggle(PLED_INFO pLed)
958 +{
959 + GPIO->GPIODir |= pLed->ledMask; // turn on the direction bit in case was turned off by some one
960 + if (GPIO->GPIOio & pLed->ledMask)
961 + {
962 + GPIO->GPIOio &= ~(pLed->ledMask);
963 + return( (pLed->ledActiveLow) ? kLedStateOn : kLedStateOff );
964 + }
965 + else
966 + {
967 + GPIO->GPIOio |= pLed->ledMask;
968 + return( (pLed->ledActiveLow) ? kLedStateOff : kLedStateOn );
969 + }
970 +}
971 +
972 +
973 +// led timer. Will return if timer is already on
974 +void ledTimerStart(void)
975 +{
976 + if (gTimerOn)
977 + return;
978 +
979 +#if defined(DEBUG_LED)
980 + printk("led: add_timer\n");
981 +#endif
982 +
983 + init_timer(&gLedTimer);
984 + gLedTimer.function = (void*)ledTimerExpire;
985 + gLedTimer.expires = jiffies + k100ms; // timer expires in ~100ms
986 + add_timer (&gLedTimer);
987 + gTimerOn = TRUE;
988 +}
989 +
990 +
991 +// led timer expire kicks in about ~100ms and perform the led operation according to the ledState and
992 +// restart the timer according to ledState
993 +void ledTimerExpire(void)
994 +{
995 + int i;
996 + PLED_INFO pCurLed;
997 +
998 + gTimerOn = FALSE;
999 +
1000 + for (i = 0, pCurLed = gLed; i < gLedCount; i++, pCurLed++)
1001 + {
1002 +#if defined(DEBUG_LED)
1003 + printk("led[%d]: Mask=0x%04x, State = %d, blcd=%d\n", i, pCurLed->ledMask, pCurLed->ledState, pCurLed->blinkCountDown);
1004 +#endif
1005 + switch (pCurLed->ledState)
1006 + {
1007 + case kLedStateOn:
1008 + case kLedStateOff:
1009 + case kLedStateFail:
1010 + pCurLed->blinkCountDown = 0; // reset the blink count down
1011 + break;
1012 +
1013 + case kLedStateBlinkOnce:
1014 + ledToggle(pCurLed);
1015 + pCurLed->blinkCountDown = 0; // reset to 0
1016 + pCurLed->ledState = pCurLed->savedLedState;
1017 + if (pCurLed->ledState == kLedStateSlowBlinkContinues ||
1018 + pCurLed->ledState == kLedStateFastBlinkContinues)
1019 + ledTimerStart(); // start timer if in blinkContinues stats
1020 + break;
1021 +
1022 + case kLedStateSlowBlinkContinues:
1023 + if (pCurLed->blinkCountDown-- == 0)
1024 + {
1025 + pCurLed->blinkCountDown = kSlowBlinkCount;
1026 + ledToggle(pCurLed);
1027 + }
1028 + ledTimerStart();
1029 + break;
1030 +
1031 + case kLedStateFastBlinkContinues:
1032 + if (pCurLed->blinkCountDown-- == 0)
1033 + {
1034 + pCurLed->blinkCountDown = kFastBlinkCount;
1035 + ledToggle(pCurLed);
1036 + }
1037 + ledTimerStart();
1038 + break;
1039 +
1040 + default:
1041 + printk("Invalid state = %d\n", pCurLed->ledState);
1042 + }
1043 + }
1044 +}
1045 +
1046 +// initialize the gLedCount and allocate and fill gLed struct
1047 +void __init boardLedInit(PLED_MAP_PAIR cLedMapping)
1048 +{
1049 + PLED_MAP_PAIR p1, p2;
1050 + PLED_INFO pCurLed;
1051 + int needTimer = FALSE;
1052 + int alreadyUsed = 0;
1053 +
1054 +#if defined(CONFIG_BCM96348) || defined(CONFIG_BCM96338)
1055 + /* Set blink rate for BCM6348/BCM6338 hardware LEDs. */
1056 + GPIO->LEDCtrl &= ~LED_INTERVAL_SET_MASK;
1057 + GPIO->LEDCtrl |= LED_INTERVAL_SET_80MS;
1058 +#endif
1059 +
1060 + memset( gpVirtLeds, 0x00, sizeof(gpVirtLeds) );
1061 + memset( gLedHwFunc, 0x00, sizeof(gLedHwFunc) );
1062 + memset( gLedHwFailFunc, 0x00, sizeof(gLedHwFailFunc) );
1063 +
1064 + gLedCount = 0;
1065 +
1066 + // Check for multiple LED names and multiple LED GPIO pins that share the
1067 + // same physical board LED.
1068 + for( p1 = cLedMapping; p1->ledName != kLedEnd; p1++ )
1069 + {
1070 + alreadyUsed = 0;
1071 + for( p2 = cLedMapping; p2 != p1; p2++ )
1072 + {
1073 + if( (p1->ledMask && p1->ledMask == p2->ledMask) ||
1074 + (p1->ledMaskFail && p1->ledMaskFail == p2->ledMaskFail) )
1075 + {
1076 + alreadyUsed = 1;
1077 + break;
1078 + }
1079 + }
1080 +
1081 + if( alreadyUsed == 0 )
1082 + gLedCount++;
1083 + }
1084 +
1085 + gLed = (PLED_INFO) kmalloc((gLedCount * sizeof(LED_INFO)), GFP_KERNEL);
1086 + if( gLed == NULL )
1087 + {
1088 + printk( "LED memory allocation error.\n" );
1089 + return;
1090 + }
1091 +
1092 + memset( gLed, 0x00, gLedCount * sizeof(LED_INFO) );
1093 +
1094 + // initial the gLed with unique ledMask and initial state. If more than 1 ledNames share the physical led
1095 + // (ledMask) the first defined led's ledInitState will be used.
1096 + pCurLed = gLed;
1097 + for( p1 = cLedMapping; p1->ledName != kLedEnd; p1++ )
1098 + {
1099 + if( (int) p1->ledName > MAX_VIRT_LEDS )
1100 + continue;
1101 +
1102 + alreadyUsed = 0;
1103 + for( p2 = cLedMapping; p2 != p1; p2++ )
1104 + {
1105 + if( (p1->ledMask && p1->ledMask == p2->ledMask) ||
1106 + (p1->ledMaskFail && p1->ledMaskFail == p2->ledMaskFail) )
1107 + {
1108 + alreadyUsed = 1;
1109 + break;
1110 + }
1111 + }
1112 +
1113 + if( alreadyUsed == 0 )
1114 + {
1115 + // Initialize the board LED for the first time.
1116 + needTimer = initLedInfo( p1, pCurLed );
1117 + gpVirtLeds[(int) p1->ledName] = pCurLed;
1118 + pCurLed++;
1119 + }
1120 + else
1121 + {
1122 + PLED_INFO pLed;
1123 + for( pLed = gLed; pLed != pCurLed; pLed++ )
1124 + {
1125 + // Find the LED_INFO structure that has already been initialized.
1126 + if((pLed->ledMask && pLed->ledMask == p1->ledMask) ||
1127 + (pLed->ledMaskFail && pLed->ledMaskFail==p1->ledMaskFail))
1128 + {
1129 + // The board LED has already been initialized but possibly
1130 + // not completely initialized.
1131 + if( p1->ledMask )
1132 + {
1133 + pLed->ledMask = p1->ledMask;
1134 + pLed->ledActiveLow = p1->ledActiveLow;
1135 + }
1136 + if( p1->ledMaskFail )
1137 + {
1138 + pLed->ledMaskFail = p1->ledMaskFail;
1139 + pLed->ledActiveLowFail = p1->ledActiveLowFail;
1140 + }
1141 + gpVirtLeds[(int) p1->ledName] = pLed;
1142 + break;
1143 + }
1144 + }
1145 + }
1146 + }
1147 +
1148 + if (needTimer)
1149 + ledTimerStart();
1150 +
1151 +#if defined(DEBUG_LED)
1152 + int i;
1153 + for (i=0; i < gLedCount; i++)
1154 + printk("initLed: led[%d]: mask=0x%04x, state=%d\n", i,(gLed+i)->ledMask, (gLed+i)->ledState);
1155 +#endif
1156 +
1157 +}
1158 +
1159 +// Initialize a structure that contains information about a physical board LED
1160 +// control. The board LED may contain more than one GPIO pin to control a
1161 +// normal condition (green) or a failure condition (red).
1162 +int initLedInfo( PLED_MAP_PAIR pCurMap, PLED_INFO pCurLed )
1163 +{
1164 + int needTimer = FALSE;
1165 + pCurLed->ledState = pCurLed->savedLedState = pCurMap->ledInitState;
1166 + pCurLed->ledMask = pCurMap->ledMask;
1167 + pCurLed->ledActiveLow = pCurMap->ledActiveLow;
1168 + pCurLed->ledMaskFail = pCurMap->ledMaskFail;
1169 + pCurLed->ledActiveLowFail = pCurMap->ledActiveLowFail;
1170 +
1171 + switch (pCurLed->ledState)
1172 + {
1173 + case kLedStateOn:
1174 + pCurLed->blinkCountDown = 0; // reset the blink count down
1175 + ledOn(pCurLed);
1176 + break;
1177 + case kLedStateOff:
1178 + pCurLed->blinkCountDown = 0; // reset the blink count down
1179 + ledOff(pCurLed);
1180 + break;
1181 + case kLedStateFail:
1182 + pCurLed->blinkCountDown = 0; // reset the blink count down
1183 + ledOnFail(pCurLed);
1184 + break;
1185 + case kLedStateBlinkOnce:
1186 + pCurLed->blinkCountDown = 1;
1187 + needTimer = TRUE;
1188 + break;
1189 + case kLedStateSlowBlinkContinues:
1190 + pCurLed->blinkCountDown = kSlowBlinkCount;
1191 + needTimer = TRUE;
1192 + break;
1193 + case kLedStateFastBlinkContinues:
1194 + pCurLed->blinkCountDown = kFastBlinkCount;
1195 + needTimer = TRUE;
1196 + break;
1197 + default:
1198 + printk("Invalid state = %d\n", pCurLed->ledState);
1199 + }
1200 +
1201 + return( needTimer );
1202 +}
1203 +
1204 +#if 0 /* BROKEN */
1205 +// Determines if there is at least one interface in bridge mode. Bridge mode
1206 +// is determined by the cfm convention of naming bridge interfaces nas17
1207 +// through nas24.
1208 +static int isBridgedProtocol(void)
1209 +{
1210 + extern int dev_get(const char *name);
1211 + const int firstBridgeId = 17;
1212 + const int lastBridgeId = 24;
1213 + int i;
1214 + int ret = FALSE;
1215 + char name[16];
1216 +
1217 + for( i = firstBridgeId; i <= lastBridgeId; i++ )
1218 + {
1219 + sprintf( name, "nas%d", i );
1220 +
1221 + if( dev_get(name) )
1222 + {
1223 + ret = TRUE;
1224 + break;
1225 + }
1226 + }
1227 +
1228 + return(ret);
1229 +}
1230 +#endif
1231 +
1232 +// led ctrl. Maps the ledName to the corresponding ledInfoPtr and perform the led operation
1233 +void boardLedCtrl(BOARD_LED_NAME ledName, BOARD_LED_STATE ledState)
1234 +{
1235 + PLED_INFO ledInfoPtr;
1236 +
1237 + // do the mapping from virtual to physical led
1238 + if( (int) ledName < MAX_VIRT_LEDS )
1239 + ledInfoPtr = gpVirtLeds[(int) ledName];
1240 + else
1241 + ledInfoPtr = NULL;
1242 +
1243 + if (ledInfoPtr == NULL)
1244 + return;
1245 +
1246 + if( ledState != kLedStateFail && gLedHwFunc[(int) ledName] )
1247 + {
1248 + (*gLedHwFunc[(int) ledName]) (ledName, ledState);
1249 + ledOffFail(ledInfoPtr);
1250 + return;
1251 + }
1252 + else
1253 + if( ledState == kLedStateFail && gLedHwFailFunc[(int) ledName] )
1254 + {
1255 + (*gLedHwFailFunc[(int) ledName]) (ledName, ledState);
1256 + ledOff(ledInfoPtr);
1257 + return;
1258 + }
1259 +
1260 +#if 0 /* BROKEN */
1261 + // Do not blink the WAN Data LED if at least one interface is in bridge mode.
1262 + if(gLedOffInBridgeMode == 1 && (ledName == kLedWanData || ledName == kLedPPP))
1263 + {
1264 + static int BridgedProtocol = -1;
1265 +
1266 + if( BridgedProtocol == -1 )
1267 + BridgedProtocol = isBridgedProtocol();
1268 +
1269 + if( BridgedProtocol == TRUE )
1270 + return;
1271 + }
1272 +#endif
1273 +
1274 + // If the state is kLedStateFail and there is not a failure LED defined
1275 + // in the board parameters, change the state to kLedStateFastBlinkContinues.
1276 + if( ledState == kLedStateFail && ledInfoPtr->ledMaskFail == 0 )
1277 + ledState = kLedStateFastBlinkContinues;
1278 +
1279 + switch (ledState)
1280 + {
1281 + case kLedStateOn:
1282 + // First, turn off the complimentary (failure) LED GPIO.
1283 + if( ledInfoPtr->ledMaskFail )
1284 + ledOffFail(ledInfoPtr);
1285 + else
1286 + if( gLedHwFailFunc[(int) ledName] )
1287 + (*gLedHwFailFunc[(int) ledName]) (ledName, kLedStateOff);
1288 +
1289 + // Next, turn on the specified LED GPIO.
1290 + ledOn(ledInfoPtr);
1291 + break;
1292 +
1293 + case kLedStateOff:
1294 + // First, turn off the complimentary (failure) LED GPIO.
1295 + if( ledInfoPtr->ledMaskFail )
1296 + ledOffFail(ledInfoPtr);
1297 + else
1298 + if( gLedHwFailFunc[(int) ledName] )
1299 + (*gLedHwFailFunc[(int) ledName]) (ledName, kLedStateOff);
1300 +
1301 + // Next, turn off the specified LED GPIO.
1302 + ledOff(ledInfoPtr);
1303 + break;
1304 +
1305 + case kLedStateFail:
1306 + // First, turn off the complimentary (normal) LED GPIO.
1307 + if( ledInfoPtr->ledMask )
1308 + ledOff(ledInfoPtr);
1309 + else
1310 + if( gLedHwFunc[(int) ledName] )
1311 + (*gLedHwFunc[(int) ledName]) (ledName, kLedStateOff);
1312 +
1313 + // Next, turn on (red) the specified LED GPIO.
1314 + ledOnFail(ledInfoPtr);
1315 + break;
1316 +
1317 + case kLedStateBlinkOnce:
1318 + // skip blinkOnce if it is already in Slow/Fast blink continues state
1319 + if (ledInfoPtr->savedLedState == kLedStateSlowBlinkContinues ||
1320 + ledInfoPtr->savedLedState == kLedStateFastBlinkContinues)
1321 + ;
1322 + else
1323 + {
1324 + if (ledInfoPtr->blinkCountDown == 0) // skip the call if it is 1
1325 + {
1326 + ledToggle(ledInfoPtr);
1327 + ledInfoPtr->blinkCountDown = 1; // it will be reset to 0 when timer expires
1328 + ledInfoPtr->ledState = kLedStateBlinkOnce;
1329 + ledTimerStart();
1330 + }
1331 + }
1332 + break;
1333 +
1334 + case kLedStateSlowBlinkContinues:
1335 + ledInfoPtr->blinkCountDown = kSlowBlinkCount;
1336 + ledInfoPtr->ledState = kLedStateSlowBlinkContinues;
1337 + ledInfoPtr->savedLedState = kLedStateSlowBlinkContinues;
1338 + ledTimerStart();
1339 + break;
1340 +
1341 + case kLedStateFastBlinkContinues:
1342 + ledInfoPtr->blinkCountDown = kFastBlinkCount;
1343 + ledInfoPtr->ledState = kLedStateFastBlinkContinues;
1344 + ledInfoPtr->savedLedState = kLedStateFastBlinkContinues;
1345 + ledTimerStart();
1346 + break;
1347 +
1348 + default:
1349 + printk("Invalid led state\n");
1350 + }
1351 +}
1352 +
1353 +// This function is called for an LED that is controlled by hardware.
1354 +void kerSysLedRegisterHwHandler( BOARD_LED_NAME ledName,
1355 + HANDLE_LED_FUNC ledHwFunc, int ledFailType )
1356 +{
1357 + if( (int) ledName < MAX_VIRT_LEDS )
1358 + {
1359 + if( ledFailType == 1 )
1360 + gLedHwFailFunc[(int) ledName] = ledHwFunc;
1361 + else
1362 + gLedHwFunc[(int) ledName] = ledHwFunc;
1363 + }
1364 +}
1365 +
1366 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/board.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/board.c
1367 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/board.c 1970-01-01 01:00:00.000000000 +0100
1368 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/board.c 2006-07-07 22:16:43.000000000 +0200
1369 @@ -0,0 +1,1614 @@
1370 +/*
1371 +<:copyright-gpl
1372 + Copyright 2002 Broadcom Corp. All Rights Reserved.
1373 +
1374 + This program is free software; you can distribute it and/or modify it
1375 + under the terms of the GNU General Public License (Version 2) as
1376 + published by the Free Software Foundation.
1377 +
1378 + This program is distributed in the hope it will be useful, but WITHOUT
1379 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1380 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
1381 + for more details.
1382 +
1383 + You should have received a copy of the GNU General Public License along
1384 + with this program; if not, write to the Free Software Foundation, Inc.,
1385 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
1386 +:>
1387 +*/
1388 +/***************************************************************************
1389 + * File Name : board.c
1390 + *
1391 + * Description: This file contains Linux character device driver entry
1392 + * for the board related ioctl calls: flash, get free kernel
1393 + * page and dump kernel memory, etc.
1394 + *
1395 + * Created on : 2/20/2002 seanl: use cfiflash.c, cfliflash.h (AMD specific)
1396 + *
1397 + ***************************************************************************/
1398 +
1399 +
1400 +/* Includes. */
1401 +#include <linux/version.h>
1402 +#include <linux/init.h>
1403 +#include <linux/fs.h>
1404 +#include <linux/interrupt.h>
1405 +#include <linux/capability.h>
1406 +#include <linux/slab.h>
1407 +#include <linux/errno.h>
1408 +#include <linux/module.h>
1409 +#include <linux/pagemap.h>
1410 +#include <asm/uaccess.h>
1411 +#include <linux/wait.h>
1412 +#include <linux/poll.h>
1413 +#include <linux/sched.h>
1414 +#include <linux/list.h>
1415 +#include <linux/if.h>
1416 +
1417 +#include <bcm_map_part.h>
1418 +#include <board.h>
1419 +#include <bcmTag.h>
1420 +#include "boardparms.h"
1421 +#include "cfiflash.h"
1422 +#include "bcm_intr.h"
1423 +#include "board.h"
1424 +#include "bcm_map_part.h"
1425 +
1426 +/* Typedefs. */
1427 +#if defined (NON_CONSECUTIVE_MAC)
1428 +// used to be the last octet. Now changed to the first 5 bits of the the forth octet
1429 +// to reduced the duplicated MAC addresses.
1430 +#define CHANGED_OCTET 3
1431 +#define SHIFT_BITS 3
1432 +#else
1433 +#define CHANGED_OCTET 1
1434 +#define SHIFT_BITS 0
1435 +#endif
1436 +
1437 +#if defined (WIRELESS)
1438 +#define SES_BTN_PRESSED 0x00000001
1439 +#define SES_EVENTS SES_BTN_PRESSED /*OR all values if any*/
1440 +#define SES_LED_OFF 0
1441 +#define SES_LED_ON 1
1442 +#define SES_LED_BLINK 2
1443 +#endif
1444 +
1445 +typedef struct
1446 +{
1447 + unsigned long ulId;
1448 + char chInUse;
1449 + char chReserved[3];
1450 +} MAC_ADDR_INFO, *PMAC_ADDR_INFO;
1451 +
1452 +typedef struct
1453 +{
1454 + unsigned long ulSdramSize;
1455 + unsigned long ulPsiSize;
1456 + unsigned long ulNumMacAddrs;
1457 + unsigned long ucaBaseMacAddr[NVRAM_MAC_ADDRESS_LEN];
1458 + MAC_ADDR_INFO MacAddrs[1];
1459 +} NVRAM_INFO, *PNVRAM_INFO;
1460 +
1461 +typedef struct
1462 +{
1463 + unsigned long eventmask;
1464 +} BOARD_IOC, *PBOARD_IOC;
1465 +
1466 +
1467 +/*Dyinggasp callback*/
1468 +typedef void (*cb_dgasp_t)(void *arg);
1469 +typedef struct _CB_DGASP__LIST
1470 +{
1471 + struct list_head list;
1472 + char name[IFNAMSIZ];
1473 + cb_dgasp_t cb_dgasp_fn;
1474 + void *context;
1475 +}CB_DGASP_LIST , *PCB_DGASP_LIST;
1476 +
1477 +
1478 +static LED_MAP_PAIR LedMapping[] =
1479 +{ // led name Initial state physical pin (ledMask)
1480 + {kLedEnd, kLedStateOff, 0, 0, 0, 0},
1481 + {kLedEnd, kLedStateOff, 0, 0, 0, 0},
1482 + {kLedEnd, kLedStateOff, 0, 0, 0, 0},
1483 + {kLedEnd, kLedStateOff, 0, 0, 0, 0},
1484 + {kLedEnd, kLedStateOff, 0, 0, 0, 0},
1485 + {kLedEnd, kLedStateOff, 0, 0, 0, 0},
1486 + {kLedEnd, kLedStateOff, 0, 0, 0, 0},
1487 + {kLedEnd, kLedStateOff, 0, 0, 0, 0},
1488 + {kLedEnd, kLedStateOff, 0, 0, 0, 0} // NOTE: kLedEnd has to be at the end.
1489 +};
1490 +
1491 +/* Externs. */
1492 +extern struct file fastcall *fget_light(unsigned int fd, int *fput_needed);
1493 +extern unsigned int nr_free_pages (void);
1494 +extern const char *get_system_type(void);
1495 +extern void kerSysFlashInit(void);
1496 +extern unsigned long get_nvram_start_addr(void);
1497 +extern unsigned long get_scratch_pad_start_addr(void);
1498 +extern unsigned long getMemorySize(void);
1499 +extern void __init boardLedInit(PLED_MAP_PAIR);
1500 +extern void boardLedCtrl(BOARD_LED_NAME, BOARD_LED_STATE);
1501 +extern void kerSysLedRegisterHandler( BOARD_LED_NAME ledName,
1502 + HANDLE_LED_FUNC ledHwFunc, int ledFailType );
1503 +
1504 +/* Prototypes. */
1505 +void __init InitNvramInfo( void );
1506 +static int board_open( struct inode *inode, struct file *filp );
1507 +static int board_ioctl( struct inode *inode, struct file *flip, unsigned int command, unsigned long arg );
1508 +static ssize_t board_read(struct file *filp, char __user *buffer, size_t count, loff_t *ppos);
1509 +static unsigned int board_poll(struct file *filp, struct poll_table_struct *wait);
1510 +static int board_release(struct inode *inode, struct file *filp);
1511 +
1512 +static BOARD_IOC* borad_ioc_alloc(void);
1513 +static void borad_ioc_free(BOARD_IOC* board_ioc);
1514 +
1515 +/* DyingGasp function prototype */
1516 +static void __init kerSysDyingGaspMapIntr(void);
1517 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
1518 +static irqreturn_t kerSysDyingGaspIsr(int irq, void * dev_id, struct pt_regs * regs);
1519 +#else
1520 +static unsigned int kerSysDyingGaspIsr(void);
1521 +#endif
1522 +static void __init kerSysInitDyingGaspHandler( void );
1523 +static void __exit kerSysDeinitDyingGaspHandler( void );
1524 +/* -DyingGasp function prototype - */
1525 +
1526 +
1527 +#if defined (WIRELESS)
1528 +static irqreturn_t sesBtn_isr(int irq, void *dev_id, struct pt_regs *ptregs);
1529 +static void __init sesBtn_mapGpio(void);
1530 +static void __init sesBtn_mapIntr(int context);
1531 +static unsigned int sesBtn_poll(struct file *file, struct poll_table_struct *wait);
1532 +static ssize_t sesBtn_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos);
1533 +static void __init sesLed_mapGpio(void);
1534 +static void sesLed_ctrl(int action);
1535 +static void __init ses_board_init(void);
1536 +static void __exit ses_board_deinit(void);
1537 +#endif
1538 +
1539 +static PNVRAM_INFO g_pNvramInfo = NULL;
1540 +static int g_ledInitialized = 0;
1541 +static wait_queue_head_t g_board_wait_queue;
1542 +static CB_DGASP_LIST *g_cb_dgasp_list_head = NULL;
1543 +
1544 +static int g_wakeup_monitor = 0;
1545 +static struct file *g_monitor_file = NULL;
1546 +static struct task_struct *g_monitor_task = NULL;
1547 +static unsigned int (*g_orig_fop_poll)
1548 + (struct file *, struct poll_table_struct *) = NULL;
1549 +
1550 +static struct file_operations board_fops =
1551 +{
1552 + open: board_open,
1553 + ioctl: board_ioctl,
1554 + poll: board_poll,
1555 + read: board_read,
1556 + release: board_release,
1557 +};
1558 +
1559 +uint32 board_major = 0;
1560 +
1561 +#if defined (WIRELESS)
1562 +static unsigned short sesBtn_irq = BP_NOT_DEFINED;
1563 +static unsigned short sesBtn_gpio = BP_NOT_DEFINED;
1564 +static unsigned short sesLed_gpio = BP_NOT_DEFINED;
1565 +#endif
1566 +
1567 +#if defined(MODULE)
1568 +int init_module(void)
1569 +{
1570 + return( brcm_board_init() );
1571 +}
1572 +
1573 +void cleanup_module(void)
1574 +{
1575 + if (MOD_IN_USE)
1576 + printk("brcm flash: cleanup_module failed because module is in use\n");
1577 + else
1578 + brcm_board_cleanup();
1579 +}
1580 +#endif //MODULE
1581 +
1582 +
1583 +
1584 +static int __init brcm_board_init( void )
1585 +{
1586 + typedef int (*BP_LED_FUNC) (unsigned short *);
1587 + static struct BpLedInformation
1588 + {
1589 + BOARD_LED_NAME ledName;
1590 + BP_LED_FUNC bpFunc;
1591 + BP_LED_FUNC bpFuncFail;
1592 + } bpLedInfo[] =
1593 + {{kLedAdsl, BpGetAdslLedGpio, BpGetAdslFailLedGpio},
1594 + {kLedWireless, BpGetWirelessLedGpio, NULL},
1595 + {kLedUsb, BpGetUsbLedGpio, NULL},
1596 + {kLedHpna, BpGetHpnaLedGpio, NULL},
1597 + {kLedWanData, BpGetWanDataLedGpio, NULL},
1598 + {kLedPPP, BpGetPppLedGpio, BpGetPppFailLedGpio},
1599 + {kLedVoip, BpGetVoipLedGpio, NULL},
1600 + {kLedSes, BpGetWirelessSesLedGpio, NULL},
1601 + {kLedEnd, NULL, NULL}
1602 + };
1603 +
1604 + int ret;
1605 +
1606 + ret = register_chrdev(BOARD_DRV_MAJOR, "bcrmboard", &board_fops );
1607 + if (ret < 0)
1608 + printk( "brcm_board_init(major %d): fail to register device.\n",BOARD_DRV_MAJOR);
1609 + else
1610 + {
1611 + PLED_MAP_PAIR pLedMap = LedMapping;
1612 + unsigned short gpio;
1613 + struct BpLedInformation *pInfo;
1614 +
1615 + printk("brcmboard: brcm_board_init entry\n");
1616 + board_major = BOARD_DRV_MAJOR;
1617 + InitNvramInfo();
1618 +
1619 + for( pInfo = bpLedInfo; pInfo->ledName != kLedEnd; pInfo++ )
1620 + {
1621 + if( pInfo->bpFunc && (*pInfo->bpFunc) (&gpio) == BP_SUCCESS )
1622 + {
1623 + pLedMap->ledName = pInfo->ledName;
1624 + pLedMap->ledMask = GPIO_NUM_TO_MASK(gpio);
1625 + pLedMap->ledActiveLow = (gpio & BP_ACTIVE_LOW) ? 1 : 0;
1626 + }
1627 + if( pInfo->bpFuncFail && (*pInfo->bpFuncFail) (&gpio) == BP_SUCCESS )
1628 + {
1629 + pLedMap->ledName = pInfo->ledName;
1630 + pLedMap->ledMaskFail = GPIO_NUM_TO_MASK(gpio);
1631 + pLedMap->ledActiveLowFail = (gpio & BP_ACTIVE_LOW) ? 1 : 0;
1632 + }
1633 + if( pLedMap->ledName != kLedEnd )
1634 + pLedMap++;
1635 + }
1636 +
1637 + init_waitqueue_head(&g_board_wait_queue);
1638 +#if defined (WIRELESS)
1639 + ses_board_init();
1640 +#endif
1641 + kerSysInitDyingGaspHandler();
1642 + kerSysDyingGaspMapIntr();
1643 +
1644 + boardLedInit(LedMapping);
1645 + g_ledInitialized = 1;
1646 + }
1647 +
1648 + return ret;
1649 +}
1650 +
1651 +void __init InitNvramInfo( void )
1652 +{
1653 + PNVRAM_DATA pNvramData = (PNVRAM_DATA) get_nvram_start_addr();
1654 + unsigned long ulNumMacAddrs = pNvramData->ulNumMacAddrs;
1655 +
1656 + if( ulNumMacAddrs > 0 && ulNumMacAddrs <= NVRAM_MAC_COUNT_MAX )
1657 + {
1658 + unsigned long ulNvramInfoSize =
1659 + sizeof(NVRAM_INFO) + ((sizeof(MAC_ADDR_INFO) - 1) * ulNumMacAddrs);
1660 +
1661 + g_pNvramInfo = (PNVRAM_INFO) kmalloc( ulNvramInfoSize, GFP_KERNEL );
1662 +
1663 + if( g_pNvramInfo )
1664 + {
1665 + unsigned long ulPsiSize;
1666 + if( BpGetPsiSize( &ulPsiSize ) != BP_SUCCESS )
1667 + ulPsiSize = NVRAM_PSI_DEFAULT;
1668 + memset( g_pNvramInfo, 0x00, ulNvramInfoSize );
1669 + g_pNvramInfo->ulPsiSize = ulPsiSize * 1024;
1670 + g_pNvramInfo->ulNumMacAddrs = pNvramData->ulNumMacAddrs;
1671 + memcpy( g_pNvramInfo->ucaBaseMacAddr, pNvramData->ucaBaseMacAddr,
1672 + NVRAM_MAC_ADDRESS_LEN );
1673 + g_pNvramInfo->ulSdramSize = getMemorySize();
1674 + }
1675 + else
1676 + printk("ERROR - Could not allocate memory for NVRAM data\n");
1677 + }
1678 + else
1679 + printk("ERROR - Invalid number of MAC addresses (%ld) is configured.\n",
1680 + ulNumMacAddrs);
1681 +}
1682 +
1683 +void __exit brcm_board_cleanup( void )
1684 +{
1685 + printk("brcm_board_cleanup()\n");
1686 +
1687 + if (board_major != -1)
1688 + {
1689 +#if defined (WIRELESS)
1690 + ses_board_deinit();
1691 +#endif
1692 + kerSysDeinitDyingGaspHandler();
1693 + unregister_chrdev(board_major, "board_ioctl");
1694 + }
1695 +}
1696 +
1697 +static BOARD_IOC* borad_ioc_alloc(void)
1698 +{
1699 + BOARD_IOC *board_ioc =NULL;
1700 + board_ioc = (BOARD_IOC*) kmalloc( sizeof(BOARD_IOC) , GFP_KERNEL );
1701 + if(board_ioc)
1702 + {
1703 + memset(board_ioc, 0, sizeof(BOARD_IOC));
1704 + }
1705 + return board_ioc;
1706 +}
1707 +
1708 +static void borad_ioc_free(BOARD_IOC* board_ioc)
1709 +{
1710 + if(board_ioc)
1711 + {
1712 + kfree(board_ioc);
1713 + }
1714 +}
1715 +
1716 +
1717 +static int board_open( struct inode *inode, struct file *filp )
1718 +{
1719 + filp->private_data = borad_ioc_alloc();
1720 +
1721 + if (filp->private_data == NULL)
1722 + return -ENOMEM;
1723 +
1724 + return( 0 );
1725 +}
1726 +
1727 +static int board_release(struct inode *inode, struct file *filp)
1728 +{
1729 + BOARD_IOC *board_ioc = filp->private_data;
1730 +
1731 + wait_event_interruptible(g_board_wait_queue, 1);
1732 + borad_ioc_free(board_ioc);
1733 +
1734 + return( 0 );
1735 +}
1736 +
1737 +
1738 +static unsigned int board_poll(struct file *filp, struct poll_table_struct *wait)
1739 +{
1740 + unsigned int mask = 0;
1741 +#if defined (WIRELESS)
1742 + BOARD_IOC *board_ioc = filp->private_data;
1743 +#endif
1744 +
1745 + poll_wait(filp, &g_board_wait_queue, wait);
1746 +#if defined (WIRELESS)
1747 + if(board_ioc->eventmask & SES_EVENTS){
1748 + mask |= sesBtn_poll(filp, wait);
1749 + }
1750 +#endif
1751 +
1752 + return mask;
1753 +}
1754 +
1755 +
1756 +static ssize_t board_read(struct file *filp, char __user *buffer, size_t count, loff_t *ppos)
1757 +{
1758 +#if defined (WIRELESS)
1759 + BOARD_IOC *board_ioc = filp->private_data;
1760 + if(board_ioc->eventmask & SES_EVENTS){
1761 + return sesBtn_read(filp, buffer, count, ppos);
1762 + }
1763 +#endif
1764 + return 0;
1765 +}
1766 +
1767 +//**************************************************************************************
1768 +// Utitlities for dump memory, free kernel pages, mips soft reset, etc.
1769 +//**************************************************************************************
1770 +
1771 +/***********************************************************************
1772 + * Function Name: dumpaddr
1773 + * Description : Display a hex dump of the specified address.
1774 + ***********************************************************************/
1775 +void dumpaddr( unsigned char *pAddr, int nLen )
1776 +{
1777 + static char szHexChars[] = "0123456789abcdef";
1778 + char szLine[80];
1779 + char *p = szLine;
1780 + unsigned char ch, *q;
1781 + int i, j;
1782 + unsigned long ul;
1783 +
1784 + while( nLen > 0 )
1785 + {
1786 + sprintf( szLine, "%8.8lx: ", (unsigned long) pAddr );
1787 + p = szLine + strlen(szLine);
1788 +
1789 + for(i = 0; i < 16 && nLen > 0; i += sizeof(long), nLen -= sizeof(long))
1790 + {
1791 + ul = *(unsigned long *) &pAddr[i];
1792 + q = (unsigned char *) &ul;
1793 + for( j = 0; j < sizeof(long); j++ )
1794 + {
1795 + *p++ = szHexChars[q[j] >> 4];
1796 + *p++ = szHexChars[q[j] & 0x0f];
1797 + *p++ = ' ';
1798 + }
1799 + }
1800 +
1801 + for( j = 0; j < 16 - i; j++ )
1802 + *p++ = ' ', *p++ = ' ', *p++ = ' ';
1803 +
1804 + *p++ = ' ', *p++ = ' ', *p++ = ' ';
1805 +
1806 + for( j = 0; j < i; j++ )
1807 + {
1808 + ch = pAddr[j];
1809 + *p++ = (ch > ' ' && ch < '~') ? ch : '.';
1810 + }
1811 +
1812 + *p++ = '\0';
1813 + printk( "%s\r\n", szLine );
1814 +
1815 + pAddr += i;
1816 + }
1817 + printk( "\r\n" );
1818 +} /* dumpaddr */
1819 +
1820 +
1821 +void kerSysMipsSoftReset(void)
1822 +{
1823 +#if defined(CONFIG_BCM96348)
1824 + if (PERF->RevID == 0x634800A1) {
1825 + typedef void (*FNPTR) (void);
1826 + FNPTR bootaddr = (FNPTR) FLASH_BASE;
1827 + int i;
1828 +
1829 + /* Disable interrupts. */
1830 + cli();
1831 +
1832 + /* Reset all blocks. */
1833 + PERF->BlockSoftReset &= ~BSR_ALL_BLOCKS;
1834 + for( i = 0; i < 1000000; i++ )
1835 + ;
1836 + PERF->BlockSoftReset |= BSR_ALL_BLOCKS;
1837 + /* Jump to the power on address. */
1838 + (*bootaddr) ();
1839 + }
1840 + else
1841 + PERF->pll_control |= SOFT_RESET; // soft reset mips
1842 +#else
1843 + PERF->pll_control |= SOFT_RESET; // soft reset mips
1844 +#endif
1845 +}
1846 +
1847 +
1848 +int kerSysGetMacAddress( unsigned char *pucaMacAddr, unsigned long ulId )
1849 +{
1850 + int nRet = 0;
1851 + PMAC_ADDR_INFO pMai = NULL;
1852 + PMAC_ADDR_INFO pMaiFreeNoId = NULL;
1853 + PMAC_ADDR_INFO pMaiFreeId = NULL;
1854 + unsigned long i = 0, ulIdxNoId = 0, ulIdxId = 0, shiftedIdx = 0;
1855 +
1856 + for( i = 0, pMai = g_pNvramInfo->MacAddrs; i < g_pNvramInfo->ulNumMacAddrs;
1857 + i++, pMai++ )
1858 + {
1859 + if( ulId == pMai->ulId || ulId == MAC_ADDRESS_ANY )
1860 + {
1861 + /* This MAC address has been used by the caller in the past. */
1862 + memcpy( pucaMacAddr, g_pNvramInfo->ucaBaseMacAddr,
1863 + NVRAM_MAC_ADDRESS_LEN );
1864 + shiftedIdx = i;
1865 + pucaMacAddr[NVRAM_MAC_ADDRESS_LEN - CHANGED_OCTET] += (shiftedIdx << SHIFT_BITS);
1866 + pMai->chInUse = 1;
1867 + pMaiFreeNoId = pMaiFreeId = NULL;
1868 + break;
1869 + }
1870 + else
1871 + if( pMai->chInUse == 0 )
1872 + {
1873 + if( pMai->ulId == 0 && pMaiFreeNoId == NULL )
1874 + {
1875 + /* This is an available MAC address that has never been
1876 + * used.
1877 + */
1878 + pMaiFreeNoId = pMai;
1879 + ulIdxNoId = i;
1880 + }
1881 + else
1882 + if( pMai->ulId != 0 && pMaiFreeId == NULL )
1883 + {
1884 + /* This is an available MAC address that has been used
1885 + * before. Use addresses that have never been used
1886 + * first, before using this one.
1887 + */
1888 + pMaiFreeId = pMai;
1889 + ulIdxId = i;
1890 + }
1891 + }
1892 + }
1893 +
1894 + if( pMaiFreeNoId || pMaiFreeId )
1895 + {
1896 + /* An available MAC address was found. */
1897 + memcpy(pucaMacAddr, g_pNvramInfo->ucaBaseMacAddr,NVRAM_MAC_ADDRESS_LEN);
1898 + if( pMaiFreeNoId )
1899 + {
1900 + shiftedIdx = ulIdxNoId;
1901 + pucaMacAddr[NVRAM_MAC_ADDRESS_LEN - CHANGED_OCTET] += (shiftedIdx << SHIFT_BITS);
1902 + pMaiFreeNoId->ulId = ulId;
1903 + pMaiFreeNoId->chInUse = 1;
1904 + }
1905 + else
1906 + {
1907 + shiftedIdx = ulIdxId;
1908 + pucaMacAddr[NVRAM_MAC_ADDRESS_LEN - CHANGED_OCTET] += (shiftedIdx << SHIFT_BITS);
1909 + pMaiFreeId->ulId = ulId;
1910 + pMaiFreeId->chInUse = 1;
1911 + }
1912 + }
1913 + else
1914 + if( i == g_pNvramInfo->ulNumMacAddrs )
1915 + nRet = -EADDRNOTAVAIL;
1916 +
1917 + return( nRet );
1918 +} /* kerSysGetMacAddr */
1919 +
1920 +int kerSysReleaseMacAddress( unsigned char *pucaMacAddr )
1921 +{
1922 + int nRet = -EINVAL;
1923 + unsigned long ulIdx = 0;
1924 + int idx = (pucaMacAddr[NVRAM_MAC_ADDRESS_LEN - CHANGED_OCTET] -
1925 + g_pNvramInfo->ucaBaseMacAddr[NVRAM_MAC_ADDRESS_LEN - CHANGED_OCTET]);
1926 +
1927 + // if overflow 255 (negitive), add 256 to have the correct index
1928 + if (idx < 0)
1929 + idx += 256;
1930 + ulIdx = (unsigned long) (idx >> SHIFT_BITS);
1931 +
1932 + if( ulIdx < g_pNvramInfo->ulNumMacAddrs )
1933 + {
1934 + PMAC_ADDR_INFO pMai = &g_pNvramInfo->MacAddrs[ulIdx];
1935 + if( pMai->chInUse == 1 )
1936 + {
1937 + pMai->chInUse = 0;
1938 + nRet = 0;
1939 + }
1940 + }
1941 +
1942 + return( nRet );
1943 +} /* kerSysReleaseMacAddr */
1944 +
1945 +int kerSysGetSdramSize( void )
1946 +{
1947 + return( (int) g_pNvramInfo->ulSdramSize );
1948 +} /* kerSysGetSdramSize */
1949 +
1950 +
1951 +void kerSysLedCtrl(BOARD_LED_NAME ledName, BOARD_LED_STATE ledState)
1952 +{
1953 + if (g_ledInitialized)
1954 + boardLedCtrl(ledName, ledState);
1955 +}
1956 +
1957 +unsigned int kerSysMonitorPollHook( struct file *f, struct poll_table_struct *t)
1958 +{
1959 + int mask = (*g_orig_fop_poll) (f, t);
1960 +
1961 + if( g_wakeup_monitor == 1 && g_monitor_file == f )
1962 + {
1963 + /* If g_wakeup_monitor is non-0, the user mode application needs to
1964 + * return from a blocking select function. Return POLLPRI which will
1965 + * cause the select to return with the exception descriptor set.
1966 + */
1967 + mask |= POLLPRI;
1968 + g_wakeup_monitor = 0;
1969 + }
1970 +
1971 + return( mask );
1972 +}
1973 +
1974 +/* Put the user mode application that monitors link state on a run queue. */
1975 +void kerSysWakeupMonitorTask( void )
1976 +{
1977 + g_wakeup_monitor = 1;
1978 + if( g_monitor_task )
1979 + wake_up_process( g_monitor_task );
1980 +}
1981 +
1982 +//<<JUNHON, 2004/09/15, get reset button status , tim hou , 05/04/12
1983 +int kerSysGetResetHold(void)
1984 +{
1985 + unsigned short gpio;
1986 +
1987 + if( BpGetPressAndHoldResetGpio( &gpio ) == BP_SUCCESS )
1988 + {
1989 +#if defined(CONFIG_BCM96338)
1990 + unsigned long gpio_mask = GPIO_NUM_TO_MASK(gpio);
1991 + volatile unsigned long *gpio_reg = &GPIO->GPIOio;
1992 +#endif
1993 +#if defined(CONFIG_BCM96345)
1994 + unsigned short gpio_mask = GPIO_NUM_TO_MASK(gpio);
1995 + volatile unsigned short *gpio_reg = &GPIO->GPIOio;
1996 +#endif
1997 +#if defined(CONFIG_BCM96348)
1998 + unsigned long gpio_mask = GPIO_NUM_TO_MASK(gpio);
1999 + volatile unsigned long *gpio_reg = &GPIO->GPIOio;
2000 +
2001 + if( (gpio & ~BP_ACTIVE_MASK) >= 32 )
2002 + {
2003 + gpio_mask = GPIO_NUM_TO_MASK_HIGH(gpio);
2004 + gpio_reg = &GPIO->GPIOio_high;
2005 + }
2006 +#endif
2007 + //printk("gpio=%04x,gpio_mask=%04x,gpio_reg=%04x\n",gpio,gpio_mask,*gpio_reg);
2008 + if(*gpio_reg & gpio_mask) //press down
2009 + return RESET_BUTTON_UP;
2010 + }
2011 + return RESET_BUTTON_PRESSDOWN;
2012 +}
2013 +//<<JUNHON, 2004/09/15
2014 +
2015 +//********************************************************************************************
2016 +// misc. ioctl calls come to here. (flash, led, reset, kernel memory access, etc.)
2017 +//********************************************************************************************
2018 +static int board_ioctl( struct inode *inode, struct file *flip,
2019 + unsigned int command, unsigned long arg )
2020 +{
2021 + int ret = 0;
2022 + BOARD_IOCTL_PARMS ctrlParms;
2023 + unsigned char ucaMacAddr[NVRAM_MAC_ADDRESS_LEN];
2024 + int allowedSize;
2025 +
2026 + switch (command)
2027 + {
2028 + case BOARD_IOCTL_FLASH_INIT:
2029 + // not used for now. kerSysBcmImageInit();
2030 + break;
2031 +
2032 +
2033 + case BOARD_IOCTL_FLASH_WRITE:
2034 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0)
2035 + {
2036 + NVRAM_DATA SaveNvramData;
2037 + PNVRAM_DATA pNvramData = (PNVRAM_DATA) get_nvram_start_addr();
2038 +
2039 + switch (ctrlParms.action)
2040 + {
2041 + case SCRATCH_PAD:
2042 + ret = kerSysScratchPadSet(ctrlParms.string, ctrlParms.buf, ctrlParms.offset);
2043 + break;
2044 +
2045 + case PERSISTENT:
2046 + ret = kerSysPersistentSet(ctrlParms.string, ctrlParms.strLen, ctrlParms.offset);
2047 + break;
2048 +
2049 + case NVRAM:
2050 + ret = kerSysNvRamSet(ctrlParms.string, ctrlParms.strLen, ctrlParms.offset);
2051 + break;
2052 +
2053 + case BCM_IMAGE_CFE:
2054 + if( ctrlParms.strLen <= 0 || ctrlParms.strLen > FLASH45_LENGTH_BOOT_ROM )
2055 + {
2056 + printk("Illegal CFE size [%d]. Size allowed: [%d]\n",
2057 + ctrlParms.strLen, FLASH45_LENGTH_BOOT_ROM);
2058 + ret = -1;
2059 + break;
2060 + }
2061 +
2062 + // save NVRAM data into a local structure
2063 + memcpy( &SaveNvramData, pNvramData, sizeof(NVRAM_DATA) );
2064 +
2065 + // set memory type field
2066 + BpGetSdramSize( (unsigned long *) &ctrlParms.string[SDRAM_TYPE_ADDRESS_OFFSET] );
2067 +
2068 + ret = kerSysBcmImageSet(ctrlParms.offset, ctrlParms.string, ctrlParms.strLen);
2069 +
2070 + // if nvram is not valid, restore the current nvram settings
2071 + if( BpSetBoardId( pNvramData->szBoardId ) != BP_SUCCESS &&
2072 + *(unsigned long *) pNvramData == NVRAM_DATA_ID )
2073 + {
2074 + kerSysNvRamSet((char *) &SaveNvramData, sizeof(SaveNvramData), 0);
2075 + }
2076 + break;
2077 +
2078 + case BCM_IMAGE_FS:
2079 + allowedSize = (int) flash_get_total_size() - \
2080 + FLASH_RESERVED_AT_END - TAG_LEN - FLASH45_LENGTH_BOOT_ROM;
2081 + if( ctrlParms.strLen <= 0 || ctrlParms.strLen > allowedSize)
2082 + {
2083 + printk("Illegal root file system size [%d]. Size allowed: [%d]\n",
2084 + ctrlParms.strLen, allowedSize);
2085 + ret = -1;
2086 + break;
2087 + }
2088 + ret = kerSysBcmImageSet(ctrlParms.offset, ctrlParms.string, ctrlParms.strLen);
2089 + kerSysMipsSoftReset();
2090 + break;
2091 +
2092 + case BCM_IMAGE_KERNEL: // not used for now.
2093 + break;
2094 + case BCM_IMAGE_WHOLE:
2095 + if(ctrlParms.strLen <= 0)
2096 + {
2097 + printk("Illegal flash image size [%d].\n", ctrlParms.strLen);
2098 + ret = -1;
2099 + break;
2100 + }
2101 +
2102 + // save NVRAM data into a local structure
2103 + memcpy( &SaveNvramData, pNvramData, sizeof(NVRAM_DATA) );
2104 +
2105 + ret = kerSysBcmImageSet(ctrlParms.offset, ctrlParms.string, ctrlParms.strLen);
2106 +
2107 + // if nvram is not valid, restore the current nvram settings
2108 + if( BpSetBoardId( pNvramData->szBoardId ) != BP_SUCCESS &&
2109 + *(unsigned long *) pNvramData == NVRAM_DATA_ID )
2110 + {
2111 + kerSysNvRamSet((char *) &SaveNvramData, sizeof(SaveNvramData), 0);
2112 + }
2113 +
2114 + kerSysMipsSoftReset();
2115 + break;
2116 +
2117 + default:
2118 + ret = -EINVAL;
2119 + printk("flash_ioctl_command: invalid command %d\n", ctrlParms.action);
2120 + break;
2121 + }
2122 + ctrlParms.result = ret;
2123 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2124 + }
2125 + else
2126 + ret = -EFAULT;
2127 + break;
2128 +
2129 + case BOARD_IOCTL_FLASH_READ:
2130 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0)
2131 + {
2132 + switch (ctrlParms.action)
2133 + {
2134 + case SCRATCH_PAD:
2135 + ret = kerSysScratchPadGet(ctrlParms.string, ctrlParms.buf, ctrlParms.offset);
2136 + break;
2137 +
2138 + case PERSISTENT:
2139 + ret = kerSysPersistentGet(ctrlParms.string, ctrlParms.strLen, ctrlParms.offset);
2140 + break;
2141 +
2142 + case NVRAM:
2143 + ret = kerSysNvRamGet(ctrlParms.string, ctrlParms.strLen, ctrlParms.offset);
2144 + break;
2145 +
2146 + case FLASH_SIZE:
2147 + ret = kerSysFlashSizeGet();
2148 + break;
2149 +
2150 + default:
2151 + ret = -EINVAL;
2152 + printk("Not supported. invalid command %d\n", ctrlParms.action);
2153 + break;
2154 + }
2155 + ctrlParms.result = ret;
2156 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2157 + }
2158 + else
2159 + ret = -EFAULT;
2160 + break;
2161 +
2162 + case BOARD_IOCTL_GET_NR_PAGES:
2163 + ctrlParms.result = nr_free_pages() + get_page_cache_size();
2164 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2165 + ret = 0;
2166 + break;
2167 +
2168 + case BOARD_IOCTL_DUMP_ADDR:
2169 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0)
2170 + {
2171 + dumpaddr( (unsigned char *) ctrlParms.string, ctrlParms.strLen );
2172 + ctrlParms.result = 0;
2173 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2174 + ret = 0;
2175 + }
2176 + else
2177 + ret = -EFAULT;
2178 + break;
2179 +
2180 + case BOARD_IOCTL_SET_MEMORY:
2181 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0)
2182 + {
2183 + unsigned long *pul = (unsigned long *) ctrlParms.string;
2184 + unsigned short *pus = (unsigned short *) ctrlParms.string;
2185 + unsigned char *puc = (unsigned char *) ctrlParms.string;
2186 + switch( ctrlParms.strLen )
2187 + {
2188 + case 4:
2189 + *pul = (unsigned long) ctrlParms.offset;
2190 + break;
2191 + case 2:
2192 + *pus = (unsigned short) ctrlParms.offset;
2193 + break;
2194 + case 1:
2195 + *puc = (unsigned char) ctrlParms.offset;
2196 + break;
2197 + }
2198 + dumpaddr( (unsigned char *) ctrlParms.string, sizeof(long) );
2199 + ctrlParms.result = 0;
2200 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2201 + ret = 0;
2202 + }
2203 + else
2204 + ret = -EFAULT;
2205 + break;
2206 +
2207 + case BOARD_IOCTL_MIPS_SOFT_RESET:
2208 + kerSysMipsSoftReset();
2209 + break;
2210 +
2211 + case BOARD_IOCTL_LED_CTRL:
2212 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0)
2213 + {
2214 + kerSysLedCtrl((BOARD_LED_NAME)ctrlParms.strLen, (BOARD_LED_STATE)ctrlParms.offset);
2215 + ret = 0;
2216 + }
2217 + break;
2218 +
2219 + case BOARD_IOCTL_GET_ID:
2220 + if (copy_from_user((void*)&ctrlParms, (void*)arg,
2221 + sizeof(ctrlParms)) == 0)
2222 + {
2223 + if( ctrlParms.string )
2224 + {
2225 + char *p = (char *) get_system_type();
2226 + if( strlen(p) + 1 < ctrlParms.strLen )
2227 + ctrlParms.strLen = strlen(p) + 1;
2228 + __copy_to_user(ctrlParms.string, p, ctrlParms.strLen);
2229 + }
2230 +
2231 + ctrlParms.result = 0;
2232 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms,
2233 + sizeof(BOARD_IOCTL_PARMS));
2234 + }
2235 + break;
2236 +
2237 + case BOARD_IOCTL_GET_MAC_ADDRESS:
2238 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0)
2239 + {
2240 + ctrlParms.result = kerSysGetMacAddress( ucaMacAddr,
2241 + ctrlParms.offset );
2242 +
2243 + if( ctrlParms.result == 0 )
2244 + {
2245 + __copy_to_user(ctrlParms.string, ucaMacAddr,
2246 + sizeof(ucaMacAddr));
2247 + }
2248 +
2249 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms,
2250 + sizeof(BOARD_IOCTL_PARMS));
2251 + ret = 0;
2252 + }
2253 + else
2254 + ret = -EFAULT;
2255 + break;
2256 +
2257 + case BOARD_IOCTL_RELEASE_MAC_ADDRESS:
2258 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0)
2259 + {
2260 + if (copy_from_user((void*)ucaMacAddr, (void*)ctrlParms.string, \
2261 + NVRAM_MAC_ADDRESS_LEN) == 0)
2262 + {
2263 + ctrlParms.result = kerSysReleaseMacAddress( ucaMacAddr );
2264 + }
2265 + else
2266 + {
2267 + ctrlParms.result = -EACCES;
2268 + }
2269 +
2270 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms,
2271 + sizeof(BOARD_IOCTL_PARMS));
2272 + ret = 0;
2273 + }
2274 + else
2275 + ret = -EFAULT;
2276 + break;
2277 +
2278 + case BOARD_IOCTL_GET_PSI_SIZE:
2279 + ctrlParms.result = (int) g_pNvramInfo->ulPsiSize;
2280 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2281 + ret = 0;
2282 + break;
2283 +
2284 + case BOARD_IOCTL_GET_SDRAM_SIZE:
2285 + ctrlParms.result = (int) g_pNvramInfo->ulSdramSize;
2286 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2287 + ret = 0;
2288 + break;
2289 +
2290 + case BOARD_IOCTL_GET_BASE_MAC_ADDRESS:
2291 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0)
2292 + {
2293 + __copy_to_user(ctrlParms.string, g_pNvramInfo->ucaBaseMacAddr, NVRAM_MAC_ADDRESS_LEN);
2294 + ctrlParms.result = 0;
2295 +
2296 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms,
2297 + sizeof(BOARD_IOCTL_PARMS));
2298 + ret = 0;
2299 + }
2300 + else
2301 + ret = -EFAULT;
2302 + break;
2303 +
2304 + case BOARD_IOCTL_GET_CHIP_ID:
2305 + ctrlParms.result = (int) (PERF->RevID & 0xFFFF0000) >> 16;
2306 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2307 + ret = 0;
2308 + break;
2309 +
2310 + case BOARD_IOCTL_GET_NUM_ENET: {
2311 + ETHERNET_MAC_INFO EnetInfos[BP_MAX_ENET_MACS];
2312 + int i, numeth = 0;
2313 + if (BpGetEthernetMacInfo(EnetInfos, BP_MAX_ENET_MACS) == BP_SUCCESS) {
2314 + for( i = 0; i < BP_MAX_ENET_MACS; i++) {
2315 + if (EnetInfos[i].ucPhyType != BP_ENET_NO_PHY) {
2316 + numeth++;
2317 + }
2318 + }
2319 + ctrlParms.result = numeth;
2320 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2321 + ret = 0;
2322 + }
2323 + else {
2324 + ret = -EFAULT;
2325 + }
2326 + break;
2327 + }
2328 +
2329 + case BOARD_IOCTL_GET_CFE_VER:
2330 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0) {
2331 + char *vertag = (char *)(FLASH_BASE + CFE_VERSION_OFFSET);
2332 + if (ctrlParms.strLen < CFE_VERSION_SIZE) {
2333 + ctrlParms.result = 0;
2334 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2335 + ret = -EFAULT;
2336 + }
2337 + else if (strncmp(vertag, "cfe-v", 5)) { // no tag info in flash
2338 + ctrlParms.result = 0;
2339 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2340 + ret = 0;
2341 + }
2342 + else {
2343 + ctrlParms.result = 1;
2344 + __copy_to_user(ctrlParms.string, vertag+CFE_VERSION_MARK_SIZE, CFE_VERSION_SIZE);
2345 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2346 + ret = 0;
2347 + }
2348 + }
2349 + else {
2350 + ret = -EFAULT;
2351 + }
2352 + break;
2353 +
2354 + case BOARD_IOCTL_GET_ENET_CFG:
2355 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0) {
2356 + ETHERNET_MAC_INFO EnetInfos[BP_MAX_ENET_MACS];
2357 + if (BpGetEthernetMacInfo(EnetInfos, BP_MAX_ENET_MACS) == BP_SUCCESS) {
2358 + if (ctrlParms.strLen == sizeof(EnetInfos)) {
2359 + __copy_to_user(ctrlParms.string, EnetInfos, sizeof(EnetInfos));
2360 + ctrlParms.result = 0;
2361 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2362 + ret = 0;
2363 + } else
2364 + ret = -EFAULT;
2365 + }
2366 + else {
2367 + ret = -EFAULT;
2368 + }
2369 + break;
2370 + }
2371 + else {
2372 + ret = -EFAULT;
2373 + }
2374 + break;
2375 +//<<JUNHON, 2004/09/15, get reset button status , tim hou , 05/04/12
2376 + case BOARD_IOCTL_GET_RESETHOLD:
2377 + ctrlParms.result = kerSysGetResetHold();
2378 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2379 + ret = 0;
2380 + break;
2381 +//>>JUNHON, 2004/09/15
2382 +
2383 +
2384 +#if defined (WIRELESS)
2385 + case BOARD_IOCTL_GET_WLAN_ANT_INUSE:
2386 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0) {
2387 + unsigned short antInUse = 0;
2388 + if (BpGetWirelessAntInUse(&antInUse) == BP_SUCCESS) {
2389 + if (ctrlParms.strLen == sizeof(antInUse)) {
2390 + __copy_to_user(ctrlParms.string, &antInUse, sizeof(antInUse));
2391 + ctrlParms.result = 0;
2392 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2393 + ret = 0;
2394 + } else
2395 + ret = -EFAULT;
2396 + }
2397 + else {
2398 + ret = -EFAULT;
2399 + }
2400 + break;
2401 + }
2402 + else {
2403 + ret = -EFAULT;
2404 + }
2405 + break;
2406 +#endif
2407 + case BOARD_IOCTL_SET_TRIGGER_EVENT:
2408 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0) {
2409 + BOARD_IOC *board_ioc = (BOARD_IOC *)flip->private_data;
2410 + ctrlParms.result = -EFAULT;
2411 + ret = -EFAULT;
2412 + if (ctrlParms.strLen == sizeof(unsigned long)) {
2413 + board_ioc->eventmask |= *((int*)ctrlParms.string);
2414 +#if defined (WIRELESS)
2415 + if((board_ioc->eventmask & SES_EVENTS)) {
2416 + if(sesBtn_irq != BP_NOT_DEFINED) {
2417 + BcmHalInterruptEnable(sesBtn_irq);
2418 + ctrlParms.result = 0;
2419 + ret = 0;
2420 + }
2421 + }
2422 +#endif
2423 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2424 + }
2425 + break;
2426 + }
2427 + else {
2428 + ret = -EFAULT;
2429 + }
2430 + break;
2431 +
2432 + case BOARD_IOCTL_GET_TRIGGER_EVENT:
2433 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0) {
2434 + BOARD_IOC *board_ioc = (BOARD_IOC *)flip->private_data;
2435 + if (ctrlParms.strLen == sizeof(unsigned long)) {
2436 + __copy_to_user(ctrlParms.string, &board_ioc->eventmask, sizeof(unsigned long));
2437 + ctrlParms.result = 0;
2438 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2439 + ret = 0;
2440 + } else
2441 + ret = -EFAULT;
2442 +
2443 + break;
2444 + }
2445 + else {
2446 + ret = -EFAULT;
2447 + }
2448 + break;
2449 +
2450 + case BOARD_IOCTL_UNSET_TRIGGER_EVENT:
2451 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0) {
2452 + if (ctrlParms.strLen == sizeof(unsigned long)) {
2453 + BOARD_IOC *board_ioc = (BOARD_IOC *)flip->private_data;
2454 + board_ioc->eventmask &= (~(*((int*)ctrlParms.string)));
2455 + ctrlParms.result = 0;
2456 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2457 + ret = 0;
2458 + } else
2459 + ret = -EFAULT;
2460 +
2461 + break;
2462 + }
2463 + else {
2464 + ret = -EFAULT;
2465 + }
2466 + break;
2467 +#if defined (WIRELESS)
2468 + case BOARD_IOCTL_SET_SES_LED:
2469 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0) {
2470 + if (ctrlParms.strLen == sizeof(int)) {
2471 + sesLed_ctrl(*(int*)ctrlParms.string);
2472 + ctrlParms.result = 0;
2473 + __copy_to_user((BOARD_IOCTL_PARMS*)arg, &ctrlParms, sizeof(BOARD_IOCTL_PARMS));
2474 + ret = 0;
2475 + } else
2476 + ret = -EFAULT;
2477 +
2478 + break;
2479 + }
2480 + else {
2481 + ret = -EFAULT;
2482 + }
2483 + break;
2484 +#endif
2485 +
2486 + case BOARD_IOCTL_SET_MONITOR_FD:
2487 + if (copy_from_user((void*)&ctrlParms, (void*)arg, sizeof(ctrlParms)) == 0) {
2488 + int fput_needed = 0;
2489 +
2490 + g_monitor_file = fget_light( ctrlParms.offset, &fput_needed );
2491 + if( g_monitor_file ) {
2492 + /* Hook this file descriptor's poll function in order to set
2493 + * the exception descriptor when there is a change in link
2494 + * state.
2495 + */
2496 + g_monitor_task = current;
2497 + g_orig_fop_poll = g_monitor_file->f_op->poll;
2498 + g_monitor_file->f_op->poll = kerSysMonitorPollHook;
2499 + }
2500 + }
2501 + break;
2502 +
2503 + case BOARD_IOCTL_WAKEUP_MONITOR_TASK:
2504 + kerSysWakeupMonitorTask();
2505 + break;
2506 +
2507 + default:
2508 + ret = -EINVAL;
2509 + ctrlParms.result = 0;
2510 + printk("board_ioctl: invalid command %x, cmd %d .\n",command,_IOC_NR(command));
2511 + break;
2512 +
2513 + } /* switch */
2514 +
2515 + return (ret);
2516 +
2517 +} /* board_ioctl */
2518 +
2519 +/***************************************************************************
2520 + * SES Button ISR/GPIO/LED functions.
2521 + ***************************************************************************/
2522 +#if defined (WIRELESS)
2523 +static irqreturn_t sesBtn_isr(int irq, void *dev_id, struct pt_regs *ptregs)
2524 +{
2525 +#if defined(_BCM96338_) || defined(CONFIG_BCM96338)
2526 + unsigned long gpio_mask = GPIO_NUM_TO_MASK(sesBtn_gpio);
2527 + volatile unsigned long *gpio_reg = &GPIO->GPIOio;
2528 +#endif
2529 +#if defined(_BCM96345_) || defined(CONFIG_BCM96345)
2530 + unsigned short gpio_mask = GPIO_NUM_TO_MASK(sesBtn_gpio);
2531 + volatile unsigned short *gpio_reg = &GPIO->GPIOio;
2532 +#endif
2533 +#if defined(_BCM96348_) || defined (CONFIG_BCM96348)
2534 + unsigned long gpio_mask = GPIO_NUM_TO_MASK(sesBtn_gpio);
2535 + volatile unsigned long *gpio_reg = &GPIO->GPIOio;
2536 +
2537 + if( (sesBtn_gpio & ~BP_ACTIVE_MASK) >= 32 )
2538 + {
2539 + gpio_mask = GPIO_NUM_TO_MASK_HIGH(sesBtn_gpio);
2540 + gpio_reg = &GPIO->GPIOio_high;
2541 + }
2542 +#endif
2543 +
2544 + if (!(*gpio_reg & gpio_mask)){
2545 + wake_up_interruptible(&g_board_wait_queue);
2546 + return IRQ_RETVAL(1);
2547 + } else {
2548 + return IRQ_RETVAL(0);
2549 + }
2550 +}
2551 +
2552 +static void __init sesBtn_mapGpio()
2553 +{
2554 + if( BpGetWirelessSesBtnGpio(&sesBtn_gpio) == BP_SUCCESS )
2555 + {
2556 + printk("SES: Button GPIO 0x%x is enabled\n", sesBtn_gpio);
2557 + }
2558 +}
2559 +
2560 +static void __init sesBtn_mapIntr(int context)
2561 +{
2562 + if( BpGetWirelessSesExtIntr(&sesBtn_irq) == BP_SUCCESS )
2563 + {
2564 + printk("SES: Button Interrupt 0x%x is enabled\n", sesBtn_irq);
2565 + }
2566 + else
2567 + return;
2568 +
2569 + sesBtn_irq += INTERRUPT_ID_EXTERNAL_0;
2570 +
2571 + if (BcmHalMapInterrupt((FN_HANDLER)sesBtn_isr, context, sesBtn_irq)) {
2572 + printk("SES: Interrupt mapping failed\n");
2573 + }
2574 + BcmHalInterruptEnable(sesBtn_irq);
2575 +}
2576 +
2577 +
2578 +static unsigned int sesBtn_poll(struct file *file, struct poll_table_struct *wait)
2579 +{
2580 +#if defined(_BCM96338_) || defined(CONFIG_BCM96338)
2581 + unsigned long gpio_mask = GPIO_NUM_TO_MASK(sesBtn_gpio);
2582 + volatile unsigned long *gpio_reg = &GPIO->GPIOio;
2583 +#endif
2584 +#if defined(_BCM96345_) || defined(CONFIG_BCM96345)
2585 + unsigned short gpio_mask = GPIO_NUM_TO_MASK(sesBtn_gpio);
2586 + volatile unsigned short *gpio_reg = &GPIO->GPIOio;
2587 +#endif
2588 +#if defined(_BCM96348_) || defined (CONFIG_BCM96348)
2589 + unsigned long gpio_mask = GPIO_NUM_TO_MASK(sesBtn_gpio);
2590 + volatile unsigned long *gpio_reg = &GPIO->GPIOio;
2591 +
2592 + if( (sesBtn_gpio & ~BP_ACTIVE_MASK) >= 32 )
2593 + {
2594 + gpio_mask = GPIO_NUM_TO_MASK_HIGH(sesBtn_gpio);
2595 + gpio_reg = &GPIO->GPIOio_high;
2596 + }
2597 +#endif
2598 +
2599 + if (!(*gpio_reg & gpio_mask)){
2600 + return POLLIN;
2601 + }
2602 + return 0;
2603 +}
2604 +
2605 +static ssize_t sesBtn_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2606 +{
2607 + volatile unsigned int event=0;
2608 + ssize_t ret=0;
2609 +
2610 +#if defined(_BCM96338_) || defined (CONFIG_BCM96338)
2611 + unsigned long gpio_mask = GPIO_NUM_TO_MASK(sesBtn_gpio);
2612 + volatile unsigned long *gpio_reg = &GPIO->GPIOio;
2613 +#endif
2614 +#if defined(_BCM96345_) || defined (CONFIG_BCM96345)
2615 + unsigned short gpio_mask = GPIO_NUM_TO_MASK(sesBtn_gpio);
2616 + volatile unsigned short *gpio_reg = &GPIO->GPIOio;
2617 +#endif
2618 +#if defined(_BCM96348_) || defined (CONFIG_BCM96348)
2619 + unsigned long gpio_mask = GPIO_NUM_TO_MASK(sesBtn_gpio);
2620 + volatile unsigned long *gpio_reg = &GPIO->GPIOio;
2621 +
2622 + if( (sesBtn_gpio & ~BP_ACTIVE_MASK) >= 32 )
2623 + {
2624 + gpio_mask = GPIO_NUM_TO_MASK_HIGH(sesBtn_gpio);
2625 + gpio_reg = &GPIO->GPIOio_high;
2626 + }
2627 +#endif
2628 +
2629 + if(*gpio_reg & gpio_mask){
2630 + BcmHalInterruptEnable(sesBtn_irq);
2631 + return ret;
2632 + }
2633 + event = SES_EVENTS;
2634 + __copy_to_user((char*)buffer, (char*)&event, sizeof(event));
2635 + BcmHalInterruptEnable(sesBtn_irq);
2636 + count -= sizeof(event);
2637 + buffer += sizeof(event);
2638 + ret += sizeof(event);
2639 + return ret;
2640 +}
2641 +
2642 +static void __init sesLed_mapGpio()
2643 +{
2644 + if( BpGetWirelessSesBtnGpio(&sesLed_gpio) == BP_SUCCESS )
2645 + {
2646 + printk("SES: LED GPIO 0x%x is enabled\n", sesBtn_gpio);
2647 + }
2648 +}
2649 +
2650 +static void sesLed_ctrl(int action)
2651 +{
2652 +
2653 + //char status = ((action >> 8) & 0xff); /* extract status */
2654 + //char event = ((action >> 16) & 0xff); /* extract event */
2655 + //char blinktype = ((action >> 24) & 0xff); /* extract blink type for SES_LED_BLINK */
2656 +
2657 + BOARD_LED_STATE led;
2658 +
2659 + if(sesLed_gpio == BP_NOT_DEFINED)
2660 + return;
2661 +
2662 + action &= 0xff; /* extract led */
2663 +
2664 + //printk("blinktype=%d, event=%d, status=%d\n",(int)blinktype, (int)event, (int)status);
2665 +
2666 + switch (action)
2667 + {
2668 + case SES_LED_ON:
2669 + //printk("SES: led on\n");
2670 + led = kLedStateOn;
2671 + break;
2672 + case SES_LED_BLINK:
2673 + //printk("SES: led blink\n");
2674 + led = kLedStateSlowBlinkContinues;
2675 + break;
2676 + case SES_LED_OFF:
2677 + default:
2678 + //printk("SES: led off\n");
2679 + led = kLedStateOff;
2680 + }
2681 +
2682 + kerSysLedCtrl(kLedSes, led);
2683 +}
2684 +
2685 +static void __init ses_board_init()
2686 +{
2687 + sesBtn_mapGpio();
2688 + sesBtn_mapIntr(0);
2689 + sesLed_mapGpio();
2690 +}
2691 +static void __exit ses_board_deinit()
2692 +{
2693 + if(sesBtn_irq)
2694 + BcmHalInterruptDisable(sesBtn_irq);
2695 +}
2696 +#endif
2697 +
2698 +/***************************************************************************
2699 + * Dying gasp ISR and functions.
2700 + ***************************************************************************/
2701 +#define KERSYS_DBG printk
2702 +
2703 +#if defined(CONFIG_BCM96345)
2704 +#define CYCLE_PER_US 70
2705 +#elif defined(CONFIG_BCM96348) || defined(CONFIG_BCM96338)
2706 +/* The BCM6348 cycles per microsecond is really variable since the BCM6348
2707 + * MIPS speed can vary depending on the PLL settings. However, an appoximate
2708 + * value of 120 will still work OK for the test being done.
2709 + */
2710 +#define CYCLE_PER_US 120
2711 +#endif
2712 +#define DG_GLITCH_TO (100*CYCLE_PER_US)
2713 +
2714 +static void __init kerSysDyingGaspMapIntr()
2715 +{
2716 + unsigned long ulIntr;
2717 +
2718 +#if defined(CONFIG_BCM96348) || defined(_BCM96348_) || defined(CONFIG_BCM96338) || defined(_BCM96338_)
2719 + if( BpGetAdslDyingGaspExtIntr( &ulIntr ) == BP_SUCCESS ) {
2720 + BcmHalMapInterrupt((FN_HANDLER)kerSysDyingGaspIsr, 0, INTERRUPT_ID_DG);
2721 + BcmHalInterruptEnable( INTERRUPT_ID_DG );
2722 + }
2723 +#elif defined(CONFIG_BCM96345) || defined(_BCM96345_)
2724 + if( BpGetAdslDyingGaspExtIntr( &ulIntr ) == BP_SUCCESS ) {
2725 + ulIntr += INTERRUPT_ID_EXTERNAL_0;
2726 + BcmHalMapInterrupt((FN_HANDLER)kerSysDyingGaspIsr, 0, ulIntr);
2727 + BcmHalInterruptEnable( ulIntr );
2728 + }
2729 +#endif
2730 +
2731 +}
2732 +
2733 +void kerSysSetWdTimer(ulong timeUs)
2734 +{
2735 + TIMER->WatchDogDefCount = timeUs * (FPERIPH/1000000);
2736 + TIMER->WatchDogCtl = 0xFF00;
2737 + TIMER->WatchDogCtl = 0x00FF;
2738 +}
2739 +
2740 +ulong kerSysGetCycleCount(void)
2741 +{
2742 + ulong cnt;
2743 +#ifdef _WIN32_WCE
2744 + cnt = 0;
2745 +#else
2746 + __asm volatile("mfc0 %0, $9":"=d"(cnt));
2747 +#endif
2748 + return(cnt);
2749 +}
2750 +
2751 +static Bool kerSysDyingGaspCheckPowerLoss(void)
2752 +{
2753 + ulong clk0;
2754 + ulong ulIntr;
2755 +
2756 + ulIntr = 0;
2757 + clk0 = kerSysGetCycleCount();
2758 +
2759 + UART->Data = 'D';
2760 + UART->Data = '%';
2761 + UART->Data = 'G';
2762 +
2763 +#if defined(CONFIG_BCM96345)
2764 + BpGetAdslDyingGaspExtIntr( &ulIntr );
2765 +
2766 + do {
2767 + ulong clk1;
2768 +
2769 + clk1 = kerSysGetCycleCount(); /* time cleared */
2770 + /* wait a little to get new reading */
2771 + while ((kerSysGetCycleCount()-clk1) < CYCLE_PER_US*2)
2772 + ;
2773 + } while ((0 == (PERF->ExtIrqCfg & (1 << (ulIntr + EI_STATUS_SHFT)))) && ((kerSysGetCycleCount() - clk0) < DG_GLITCH_TO));
2774 +
2775 + if (PERF->ExtIrqCfg & (1 << (ulIntr + EI_STATUS_SHFT))) { /* power glitch */
2776 + BcmHalInterruptEnable( ulIntr + INTERRUPT_ID_EXTERNAL_0);
2777 + KERSYS_DBG(" - Power glitch detected. Duration: %ld us\n", (kerSysGetCycleCount() - clk0)/CYCLE_PER_US);
2778 + return 0;
2779 + }
2780 +#elif (defined(CONFIG_BCM96348) || defined(CONFIG_BCM96338)) && !defined(VXWORKS)
2781 + do {
2782 + ulong clk1;
2783 +
2784 + clk1 = kerSysGetCycleCount(); /* time cleared */
2785 + /* wait a little to get new reading */
2786 + while ((kerSysGetCycleCount()-clk1) < CYCLE_PER_US*2)
2787 + ;
2788 + } while ((PERF->IrqStatus & (1 << (INTERRUPT_ID_DG - INTERNAL_ISR_TABLE_OFFSET))) && ((kerSysGetCycleCount() - clk0) < DG_GLITCH_TO));
2789 +
2790 + if (!(PERF->IrqStatus & (1 << (INTERRUPT_ID_DG - INTERNAL_ISR_TABLE_OFFSET)))) {
2791 + BcmHalInterruptEnable( INTERRUPT_ID_DG );
2792 + KERSYS_DBG(" - Power glitch detected. Duration: %ld us\n", (kerSysGetCycleCount() - clk0)/CYCLE_PER_US);
2793 + return 0;
2794 + }
2795 +#endif
2796 + return 1;
2797 +}
2798 +
2799 +static void kerSysDyingGaspShutdown( void )
2800 +{
2801 + kerSysSetWdTimer(1000000);
2802 +#if defined(CONFIG_BCM96345)
2803 + PERF->blkEnables &= ~(EMAC_CLK_EN | USB_CLK_EN | CPU_CLK_EN);
2804 +#elif defined(CONFIG_BCM96348)
2805 + PERF->blkEnables &= ~(EMAC_CLK_EN | USBS_CLK_EN | USBH_CLK_EN | SAR_CLK_EN);
2806 +#endif
2807 +}
2808 +
2809 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
2810 +static irqreturn_t kerSysDyingGaspIsr(int irq, void * dev_id, struct pt_regs * regs)
2811 +#else
2812 +static unsigned int kerSysDyingGaspIsr(void)
2813 +#endif
2814 +{
2815 + struct list_head *pos;
2816 + CB_DGASP_LIST *tmp, *dsl = NULL;
2817 +
2818 + if (kerSysDyingGaspCheckPowerLoss()) {
2819 +
2820 + /* first to turn off everything other than dsl */
2821 + list_for_each(pos, &g_cb_dgasp_list_head->list) {
2822 + tmp = list_entry(pos, CB_DGASP_LIST, list);
2823 + if(strncmp(tmp->name, "dsl", 3)) {
2824 + (tmp->cb_dgasp_fn)(tmp->context);
2825 + }else {
2826 + dsl = tmp;
2827 + }
2828 + }
2829 +
2830 + /* now send dgasp */
2831 + if(dsl)
2832 + (dsl->cb_dgasp_fn)(dsl->context);
2833 +
2834 + /* reset and shutdown system */
2835 + kerSysDyingGaspShutdown();
2836 + }
2837 +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0))
2838 +return( IRQ_HANDLED );
2839 +#else
2840 + return( 1 );
2841 +#endif
2842 +}
2843 +
2844 +static void __init kerSysInitDyingGaspHandler( void )
2845 +{
2846 + CB_DGASP_LIST *new_node;
2847 +
2848 + if( g_cb_dgasp_list_head != NULL) {
2849 + printk("Error: kerSysInitDyingGaspHandler: list head is not null\n");
2850 + return;
2851 + }
2852 + new_node= (CB_DGASP_LIST *)kmalloc(sizeof(CB_DGASP_LIST), GFP_KERNEL);
2853 + memset(new_node, 0x00, sizeof(CB_DGASP_LIST));
2854 + INIT_LIST_HEAD(&new_node->list);
2855 + g_cb_dgasp_list_head = new_node;
2856 +
2857 +} /* kerSysInitDyingGaspHandler */
2858 +
2859 +static void __exit kerSysDeinitDyingGaspHandler( void )
2860 +{
2861 + struct list_head *pos;
2862 + CB_DGASP_LIST *tmp;
2863 +
2864 + if(g_cb_dgasp_list_head == NULL)
2865 + return;
2866 +
2867 + list_for_each(pos, &g_cb_dgasp_list_head->list) {
2868 + tmp = list_entry(pos, CB_DGASP_LIST, list);
2869 + list_del(pos);
2870 + kfree(tmp);
2871 + }
2872 +
2873 + kfree(g_cb_dgasp_list_head);
2874 + g_cb_dgasp_list_head = NULL;
2875 +
2876 +} /* kerSysDeinitDyingGaspHandler */
2877 +
2878 +void kerSysRegisterDyingGaspHandler(char *devname, void *cbfn, void *context)
2879 +{
2880 + CB_DGASP_LIST *new_node;
2881 +
2882 + if( g_cb_dgasp_list_head == NULL) {
2883 + printk("Error: kerSysRegisterDyingGaspHandler: list head is null\n");
2884 + return;
2885 + }
2886 +
2887 + if( devname == NULL || cbfn == NULL ) {
2888 + printk("Error: kerSysRegisterDyingGaspHandler: register info not enough (%s,%x,%x)\n", devname, (unsigned int)cbfn, (unsigned int)context);
2889 + return;
2890 + }
2891 +
2892 + new_node= (CB_DGASP_LIST *)kmalloc(sizeof(CB_DGASP_LIST), GFP_KERNEL);
2893 + memset(new_node, 0x00, sizeof(CB_DGASP_LIST));
2894 + INIT_LIST_HEAD(&new_node->list);
2895 + strncpy(new_node->name, devname, IFNAMSIZ);
2896 + new_node->cb_dgasp_fn = (cb_dgasp_t)cbfn;
2897 + new_node->context = context;
2898 + list_add(&new_node->list, &g_cb_dgasp_list_head->list);
2899 +
2900 + printk("dgasp: kerSysRegisterDyingGaspHandler: %s registered \n", devname);
2901 +
2902 +} /* kerSysRegisterDyingGaspHandler */
2903 +
2904 +void kerSysDeregisterDyingGaspHandler(char *devname)
2905 +{
2906 + struct list_head *pos;
2907 + CB_DGASP_LIST *tmp;
2908 +
2909 + if(g_cb_dgasp_list_head == NULL) {
2910 + printk("Error: kerSysDeregisterDyingGaspHandler: list head is null\n");
2911 + return;
2912 + }
2913 +
2914 + if(devname == NULL) {
2915 + printk("Error: kerSysDeregisterDyingGaspHandler: devname is null\n");
2916 + return;
2917 + }
2918 +
2919 + printk("kerSysDeregisterDyingGaspHandler: %s is deregistering\n", devname);
2920 +
2921 + list_for_each(pos, &g_cb_dgasp_list_head->list) {
2922 + tmp = list_entry(pos, CB_DGASP_LIST, list);
2923 + if(!strcmp(tmp->name, devname)) {
2924 + list_del(pos);
2925 + kfree(tmp);
2926 + printk("kerSysDeregisterDyingGaspHandler: %s is deregistered\n", devname);
2927 + return;
2928 + }
2929 + }
2930 + printk("kerSysDeregisterDyingGaspHandler: %s not (de)registered\n", devname);
2931 +
2932 +} /* kerSysDeregisterDyingGaspHandler */
2933 +
2934 +/***************************************************************************
2935 + * MACRO to call driver initialization and cleanup functions.
2936 + ***************************************************************************/
2937 +module_init( brcm_board_init );
2938 +module_exit( brcm_board_cleanup );
2939 +
2940 +EXPORT_SYMBOL(kerSysNvRamGet);
2941 +EXPORT_SYMBOL(dumpaddr);
2942 +EXPORT_SYMBOL(kerSysGetMacAddress);
2943 +EXPORT_SYMBOL(kerSysReleaseMacAddress);
2944 +EXPORT_SYMBOL(kerSysGetSdramSize);
2945 +EXPORT_SYMBOL(kerSysLedCtrl);
2946 +//<<JUNHON, 2004/09/15, get reset button status , tim hou , 05/04/12
2947 +EXPORT_SYMBOL(kerSysGetResetHold);
2948 +//>>JUNHON, 2004/09/15
2949 +EXPORT_SYMBOL(kerSysLedRegisterHwHandler);
2950 +EXPORT_SYMBOL(BpGetBoardIds);
2951 +EXPORT_SYMBOL(BpGetSdramSize);
2952 +EXPORT_SYMBOL(BpGetPsiSize);
2953 +EXPORT_SYMBOL(BpGetEthernetMacInfo);
2954 +EXPORT_SYMBOL(BpGetRj11InnerOuterPairGpios);
2955 +EXPORT_SYMBOL(BpGetPressAndHoldResetGpio);
2956 +EXPORT_SYMBOL(BpGetVoipResetGpio);
2957 +EXPORT_SYMBOL(BpGetVoipIntrGpio);
2958 +EXPORT_SYMBOL(BpGetPcmciaResetGpio);
2959 +EXPORT_SYMBOL(BpGetRtsCtsUartGpios);
2960 +EXPORT_SYMBOL(BpGetAdslLedGpio);
2961 +EXPORT_SYMBOL(BpGetAdslFailLedGpio);
2962 +EXPORT_SYMBOL(BpGetWirelessLedGpio);
2963 +EXPORT_SYMBOL(BpGetUsbLedGpio);
2964 +EXPORT_SYMBOL(BpGetHpnaLedGpio);
2965 +EXPORT_SYMBOL(BpGetWanDataLedGpio);
2966 +EXPORT_SYMBOL(BpGetPppLedGpio);
2967 +EXPORT_SYMBOL(BpGetPppFailLedGpio);
2968 +EXPORT_SYMBOL(BpGetVoipLedGpio);
2969 +EXPORT_SYMBOL(BpGetWirelessExtIntr);
2970 +EXPORT_SYMBOL(BpGetAdslDyingGaspExtIntr);
2971 +EXPORT_SYMBOL(BpGetVoipExtIntr);
2972 +EXPORT_SYMBOL(BpGetHpnaExtIntr);
2973 +EXPORT_SYMBOL(BpGetHpnaChipSelect);
2974 +EXPORT_SYMBOL(BpGetVoipChipSelect);
2975 +EXPORT_SYMBOL(BpGetWirelessSesBtnGpio);
2976 +EXPORT_SYMBOL(BpGetWirelessSesExtIntr);
2977 +EXPORT_SYMBOL(BpGetWirelessSesLedGpio);
2978 +EXPORT_SYMBOL(kerSysRegisterDyingGaspHandler);
2979 +EXPORT_SYMBOL(kerSysDeregisterDyingGaspHandler);
2980 +EXPORT_SYMBOL(kerSysGetCycleCount);
2981 +EXPORT_SYMBOL(kerSysSetWdTimer);
2982 +EXPORT_SYMBOL(kerSysWakeupMonitorTask);
2983 +
2984 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/boardparms.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/boardparms.c
2985 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/boardparms.c 1970-01-01 01:00:00.000000000 +0100
2986 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/boardparms.c 2006-07-07 22:16:11.000000000 +0200
2987 @@ -0,0 +1,2391 @@
2988 +/*
2989 +<:copyright-gpl
2990 +
2991 + Copyright 2003 Broadcom Corp. All Rights Reserved.
2992 +
2993 + This program is free software; you can distribute it and/or modify it
2994 + under the terms of the GNU General Public License (Version 2) as
2995 + published by the Free Software Foundation.
2996 +
2997 + This program is distributed in the hope it will be useful, but WITHOUT
2998 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
2999 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
3000 + for more details.
3001 +
3002 + You should have received a copy of the GNU General Public License along
3003 + with this program; if not, write to the Free Software Foundation, Inc.,
3004 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
3005 +
3006 +:>
3007 +*/
3008 +/**************************************************************************
3009 + * File Name : boardparms.c
3010 + *
3011 + * Description: This file contains the implementation for the BCM63xx board
3012 + * parameter access functions.
3013 + *
3014 + * Updates : 07/14/2003 Created.
3015 + ***************************************************************************/
3016 +
3017 +/* Includes. */
3018 +#include "boardparms.h"
3019 +
3020 +/* Defines. */
3021 +
3022 +/* Default psi size in K bytes */
3023 +#define BP_PSI_DEFAULT_SIZE 24
3024 +
3025 +/* Typedefs */
3026 +typedef struct boardparameters
3027 +{
3028 + char szBoardId[BP_BOARD_ID_LEN]; /* board id string */
3029 + ETHERNET_MAC_INFO EnetMacInfos[BP_MAX_ENET_MACS];
3030 + VOIP_DSP_INFO VoIPDspInfo[BP_MAX_VOIP_DSP];
3031 + unsigned short usSdramSize; /* SDRAM size and type */
3032 + unsigned short usPsiSize; /* persistent storage in K bytes */
3033 + unsigned short usGpioRj11InnerPair; /* GPIO pin or not defined */
3034 + unsigned short usGpioRj11OuterPair; /* GPIO pin or not defined */
3035 + unsigned short usGpioPressAndHoldReset; /* GPIO pin or not defined */
3036 + unsigned short usGpioPcmciaReset; /* GPIO pin or not defined */
3037 + unsigned short usGpioUartRts; /* GPIO pin or not defined */
3038 + unsigned short usGpioUartCts; /* GPIO pin or not defined */
3039 + unsigned short usGpioLedAdsl; /* GPIO pin or not defined */
3040 + unsigned short usGpioLedAdslFail; /* GPIO pin or not defined */
3041 + unsigned short usGpioLedWireless; /* GPIO pin or not defined */
3042 + unsigned short usGpioLedUsb; /* GPIO pin or not defined */
3043 + unsigned short usGpioLedHpna; /* GPIO pin or not defined */
3044 + unsigned short usGpioLedWanData; /* GPIO pin or not defined */
3045 + unsigned short usGpioLedPpp; /* GPIO pin or not defined */
3046 + unsigned short usGpioLedPppFail; /* GPIO pin or not defined */
3047 + unsigned short usGpioLedBlPowerOn; /* GPIO pin or not defined */
3048 + unsigned short usGpioLedBlAlarm; /* GPIO pin or not defined */
3049 + unsigned short usGpioLedBlResetCfg; /* GPIO pin or not defined */
3050 + unsigned short usGpioLedBlStop; /* GPIO pin or not defined */
3051 + unsigned short usExtIntrWireless; /* ext intr or not defined */
3052 + unsigned short usExtIntrAdslDyingGasp; /* ext intr or not defined */
3053 + unsigned short usExtIntrHpna; /* ext intr or not defined */
3054 + unsigned short usCsHpna; /* chip select not defined */
3055 + unsigned short usAntInUseWireless; /* antenna in use or not defined */
3056 + unsigned short usGpioSesBtnWireless; /* GPIO pin or not defined */
3057 + unsigned short usExtIntrSesBtnWireless; /* ext intr or not defined */
3058 + unsigned short usGpioLedSesWireless; /* GPIO pin or not defined */
3059 +} BOARD_PARAMETERS, *PBOARD_PARAMETERS;
3060 +
3061 +/* Variables */
3062 +#if defined(_BCM96338_) || defined(CONFIG_BCM96338)
3063 +static BOARD_PARAMETERS g_bcm96338sv =
3064 +{
3065 + "96338SV", /* szBoardId */
3066 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3067 + 0x01, /* ucPhyAddress */
3068 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3069 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3070 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3071 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3072 + BP_NOT_DEFINED, /* usGpioPhyReset */
3073 + 0x01, /* numSwitchPorts */
3074 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3075 + BP_NOT_DEFINED}, /* usReverseMii */
3076 + {BP_ENET_NO_PHY}}, /* ucPhyType */
3077 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3078 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3079 + BP_MEMORY_16MB_1_CHIP, /* usSdramSize */
3080 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3081 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3082 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3083 + BP_NOT_DEFINED, /* usGpioPressAndHoldReset */
3084 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3085 + BP_NOT_DEFINED, /* usGpioUartRts */
3086 + BP_NOT_DEFINED, /* usGpioUartCts */
3087 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3088 + BP_NOT_DEFINED, /* usGpioLedAdslFail */
3089 + BP_NOT_DEFINED, /* usGpioLedWireless */
3090 + BP_NOT_DEFINED, /* usGpioLedUsb */
3091 + BP_NOT_DEFINED, /* usGpioLedHpna */
3092 + BP_NOT_DEFINED, /* usGpioLedWanData */
3093 + BP_NOT_DEFINED, /* usGpioLedPpp */
3094 + BP_NOT_DEFINED, /* usGpioLedPppFail */
3095 + BP_NOT_DEFINED, /* usGpioLedBlPowerOn */
3096 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3097 + BP_NOT_DEFINED, /* usGpioLedBlResetCfg */
3098 + BP_NOT_DEFINED, /* usGpioLedBlStop */
3099 + BP_NOT_DEFINED, /* usExtIntrWireless */
3100 + BP_HW_DEFINED, /* usExtIntrAdslDyingGasp */
3101 + BP_NOT_DEFINED, /* usExtIntrHpna */
3102 + BP_NOT_DEFINED, /* usCsHpna */
3103 + BP_NOT_DEFINED, /* usAntInUseWireless */
3104 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3105 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3106 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3107 +};
3108 +static BOARD_PARAMETERS g_bcm96338l2m8m =
3109 +{
3110 + "96338L-2M-8M", /* szBoardId */
3111 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3112 + 0x01, /* ucPhyAddress */
3113 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3114 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3115 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3116 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3117 + BP_NOT_DEFINED, /* usGpioPhyReset */
3118 + 0x01, /* numSwitchPorts */
3119 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3120 + BP_NOT_DEFINED}, /* usReverseMii */
3121 + {BP_ENET_NO_PHY}}, /* ucPhyType */
3122 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3123 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3124 + BP_MEMORY_8MB_1_CHIP, /* usSdramSize */
3125 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3126 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3127 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3128 + BP_NOT_DEFINED, /* usGpioPressAndHoldReset */
3129 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3130 + BP_NOT_DEFINED, /* usGpioUartRts */
3131 + BP_NOT_DEFINED, /* usGpioUartCts */
3132 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3133 + BP_GPIO_2_AL, /* usGpioLedAdslFail */
3134 + BP_NOT_DEFINED, /* usGpioLedWireless */
3135 + BP_NOT_DEFINED, /* usGpioLedUsb */
3136 + BP_NOT_DEFINED, /* usGpioLedHpna */
3137 + BP_GPIO_3_AL, /* usGpioLedWanData */
3138 + BP_GPIO_3_AL, /* usGpioLedPpp */
3139 + BP_GPIO_4_AL, /* usGpioLedPppFail */
3140 + BP_GPIO_0_AL, /* usGpioLedBlPowerOn */
3141 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3142 + BP_GPIO_3_AL, /* usGpioLedBlResetCfg */
3143 + BP_GPIO_1_AL, /* usGpioLedBlStop */
3144 + BP_NOT_DEFINED, /* usExtIntrWireless */
3145 + BP_HW_DEFINED, /* usExtIntrAdslDyingGasp */
3146 + BP_NOT_DEFINED, /* usExtIntrHpna */
3147 + BP_NOT_DEFINED, /* usCsHpna */
3148 + BP_NOT_DEFINED, /* usAntInUseWireless */
3149 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3150 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3151 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3152 +};
3153 +static PBOARD_PARAMETERS g_BoardParms[] =
3154 + {&g_bcm96338sv, &g_bcm96338l2m8m, 0};
3155 +#endif
3156 +
3157 +#if defined(_BCM96345_) || defined(CONFIG_BCM96345)
3158 +static BOARD_PARAMETERS g_bcm96345r =
3159 +{
3160 + "96345R", /* szBoardId */
3161 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3162 + 0x01, /* ucPhyAddress */
3163 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3164 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3165 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3166 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3167 + BP_NOT_DEFINED, /* usGpioPhyReset */
3168 + 0x01, /* numSwitchPorts */
3169 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3170 + BP_NOT_DEFINED}, /* usReverseMii */
3171 + {BP_ENET_NO_PHY}}, /* ucPhyType */
3172 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3173 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3174 + BP_MEMORY_8MB_1_CHIP, /* usSdramSize */
3175 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3176 + BP_GPIO_11_AH, /* usGpioRj11InnerPair */
3177 + BP_GPIO_12_AH, /* usGpioRj11OuterPair */
3178 + BP_GPIO_13_AH, /* usGpioPressAndHoldReset */
3179 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3180 + BP_NOT_DEFINED, /* usGpioUartRts */
3181 + BP_NOT_DEFINED, /* usGpioUartCts */
3182 + BP_GPIO_8_AH, /* usGpioLedAdsl */
3183 + BP_NOT_DEFINED, /* usGpioLedAdslFail */
3184 + BP_NOT_DEFINED, /* usGpioLedWireless */
3185 + BP_NOT_DEFINED, /* usGpioLedUsb */
3186 + BP_NOT_DEFINED, /* usGpioLedHpna */
3187 + BP_GPIO_8_AH, /* usGpioLedWanData */
3188 + BP_GPIO_9_AH, /* usGpioLedPpp */
3189 + BP_NOT_DEFINED, /* usGpioLedPppFail */
3190 + BP_NOT_DEFINED, /* usGpioLedBlPowerOn */
3191 + BP_GPIO_10_AH, /* usGpioLedBlAlarm */
3192 + BP_GPIO_9_AH, /* usGpioLedBlResetCfg */
3193 + BP_GPIO_8_AH, /* usGpioLedBlStop */
3194 + BP_NOT_DEFINED, /* usExtIntrWireless */
3195 + BP_EXT_INTR_0, /* usExtIntrAdslDyingGasp */
3196 + BP_NOT_DEFINED, /* usExtIntrHpna */
3197 + BP_NOT_DEFINED, /* usCsHpna */
3198 + BP_NOT_DEFINED, /* usAntInUseWireless */
3199 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3200 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3201 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3202 +};
3203 +
3204 +static BOARD_PARAMETERS g_bcm96345gw2 =
3205 +{
3206 + /* A hardware jumper determines whether GPIO 13 is used for Press and Hold
3207 + * Reset or RTS.
3208 + */
3209 + "96345GW2", /* szBoardId */
3210 + {{BP_ENET_EXTERNAL_SWITCH, /* ucPhyType */
3211 + 0x00, /* ucPhyAddress */
3212 + BP_GPIO_0_AH, /* usGpioPhySpiSck */
3213 + BP_GPIO_4_AH, /* usGpioPhySpiSs */
3214 + BP_GPIO_12_AH, /* usGpioPhySpiMosi */
3215 + BP_GPIO_11_AH, /* usGpioPhySpiMiso */
3216 + BP_NOT_DEFINED, /* usGpioPhyReset */
3217 + 0x04, /* numSwitchPorts */
3218 + BP_ENET_CONFIG_GPIO, /* usConfigType */
3219 + BP_ENET_REVERSE_MII}, /* usReverseMii */
3220 + {BP_ENET_NO_PHY}}, /* ucPhyType */
3221 + {{BP_VOIP_DSP, /* ucDspType */
3222 + 0x00, /* ucDspAddress */
3223 + BP_EXT_INTR_1, /* usExtIntrVoip */
3224 + BP_GPIO_6_AH, /* usGpioVoipReset */
3225 + BP_GPIO_15_AH, /* usGpioVoipIntr */
3226 + BP_NOT_DEFINED, /* usGpioLedVoip */
3227 + BP_CS_2}, /* usCsVoip */
3228 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3229 + BP_MEMORY_16MB_1_CHIP, /* usSdramSize */
3230 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3231 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3232 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3233 + BP_GPIO_13_AH, /* usGpioPressAndHoldReset */
3234 + BP_GPIO_2_AH, /* usGpioPcmciaReset */
3235 + BP_GPIO_13_AH, /* usGpioUartRts */
3236 + BP_GPIO_9_AH, /* usGpioUartCts */
3237 + BP_GPIO_8_AH, /* usGpioLedAdsl */
3238 + BP_NOT_DEFINED, /* usGpioLedAdslFail */
3239 + BP_NOT_DEFINED, /* usGpioLedWireless */
3240 + BP_GPIO_7_AH, /* usGpioLedUsb */
3241 + BP_NOT_DEFINED, /* usGpioLedHpna */
3242 + BP_GPIO_8_AH, /* usGpioLedWanData */
3243 + BP_NOT_DEFINED, /* usGpioLedPpp */
3244 + BP_NOT_DEFINED, /* usGpioLedPppFail */
3245 + BP_NOT_DEFINED, /* usGpioLedBlPowerOn */
3246 + BP_GPIO_10_AH, /* usGpioLedBlAlarm */
3247 + BP_GPIO_7_AH, /* usGpioLedBlResetCfg */
3248 + BP_GPIO_8_AH, /* usGpioLedBlStop */
3249 + BP_EXT_INTR_2, /* usExtIntrWireless */
3250 + BP_EXT_INTR_0, /* usExtIntrAdslDyingGasp */
3251 + BP_NOT_DEFINED, /* usExtIntrHpna */
3252 + BP_NOT_DEFINED, /* usCsHpna */
3253 + BP_WLAN_ANT_MAIN, /* usAntInUseWireless */
3254 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3255 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3256 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3257 +};
3258 +
3259 +static BOARD_PARAMETERS g_bcm96345gw =
3260 +{
3261 + "96345GW", /* szBoardId */
3262 + {{BP_ENET_EXTERNAL_SWITCH, /* ucPhyType */
3263 + 0x00, /* ucPhyAddress */
3264 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3265 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3266 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3267 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3268 + BP_NOT_DEFINED, /* usGpioPhyReset */
3269 + 0x04, /* numSwitchPorts */
3270 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3271 + BP_ENET_NO_REVERSE_MII}, /* usReverseMii */
3272 + {BP_ENET_NO_PHY}}, /* ucPhyType */
3273 + {{BP_VOIP_DSP, /* ucDspType */
3274 + 0x00, /* ucDspAddress */
3275 + BP_EXT_INTR_1, /* usExtIntrVoip */
3276 + BP_GPIO_6_AH, /* usGpioVoipReset */
3277 + BP_GPIO_15_AH, /* usGpioVoipIntr */
3278 + BP_NOT_DEFINED, /* usGpioLedVoip */
3279 + BP_CS_2}, /* usCsVoip */
3280 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3281 + BP_MEMORY_16MB_1_CHIP, /* usSdramSize */
3282 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3283 + BP_GPIO_11_AH, /* usGpioRj11InnerPair */
3284 + BP_GPIO_1_AH, /* usGpioRj11OuterPair */
3285 + BP_GPIO_13_AH, /* usGpioPressAndHoldReset */
3286 + BP_GPIO_2_AH, /* usGpioPcmciaReset */
3287 + BP_NOT_DEFINED, /* usGpioUartRts */
3288 + BP_NOT_DEFINED, /* usGpioUartCts */
3289 + BP_GPIO_8_AH, /* usGpioLedAdsl */
3290 + BP_NOT_DEFINED, /* usGpioLedAdslFail */
3291 + BP_GPIO_10_AH, /* usGpioLedWireless */
3292 + BP_GPIO_7_AH, /* usGpioLedUsb */
3293 + BP_NOT_DEFINED, /* usGpioLedHpna */
3294 + BP_GPIO_8_AH, /* usGpioLedWanData */
3295 + BP_NOT_DEFINED, /* usGpioLedPpp */
3296 + BP_NOT_DEFINED, /* usGpioLedPppFail */
3297 + BP_NOT_DEFINED, /* usGpioLedBlPowerOn */
3298 + BP_GPIO_9_AH, /* usGpioLedBlAlarm */
3299 + BP_GPIO_10_AH, /* usGpioLedBlResetCfg */
3300 + BP_GPIO_8_AH, /* usGpioLedBlStop */
3301 + BP_EXT_INTR_2, /* usExtIntrWireless */
3302 + BP_EXT_INTR_0, /* usExtIntrAdslDyingGasp */
3303 + BP_EXT_INTR_3, /* usExtIntrHpna */
3304 + BP_CS_1, /* usCsHpna */
3305 + BP_WLAN_ANT_MAIN, /* usAntInUseWireless */
3306 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3307 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3308 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3309 +};
3310 +
3311 +static BOARD_PARAMETERS g_bcm96335r =
3312 +{
3313 + "96335R", /* szBoardId */
3314 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3315 + 0x01, /* ucPhyAddress */
3316 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3317 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3318 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3319 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3320 + BP_NOT_DEFINED, /* usGpioPhyReset */
3321 + 0x01, /* numSwitchPorts */
3322 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3323 + BP_NOT_DEFINED}, /* usReverseMii */
3324 + {BP_ENET_NO_PHY}}, /* ucPhyType */
3325 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3326 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3327 + BP_MEMORY_8MB_1_CHIP, /* usSdramSize */
3328 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3329 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3330 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3331 + BP_GPIO_14_AH, /* usGpioPressAndHoldReset */
3332 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3333 + BP_NOT_DEFINED, /* usGpioUartRts */
3334 + BP_NOT_DEFINED, /* usGpioUartCts */
3335 + BP_GPIO_9_AH, /* usGpioLedAdsl */
3336 + BP_NOT_DEFINED, /* usGpioLedAdslFail */
3337 + BP_NOT_DEFINED, /* usGpioLedWireless */
3338 + BP_NOT_DEFINED, /* usGpioLedUsb */
3339 + BP_NOT_DEFINED, /* usGpioLedHpna */
3340 + BP_GPIO_9_AH, /* usGpioLedWanData */
3341 + BP_GPIO_8_AH, /* usGpioLedPpp */
3342 + BP_NOT_DEFINED, /* usGpioLedPppFail */
3343 + BP_NOT_DEFINED, /* usGpioLedBlPowerOn */
3344 + BP_GPIO_10_AH, /* usGpioLedBlAlarm */
3345 + BP_GPIO_8_AH, /* usGpioLedBlResetCfg */
3346 + BP_GPIO_9_AH, /* usGpioLedBlStop */
3347 + BP_NOT_DEFINED, /* usExtIntrWireless */
3348 + BP_NOT_DEFINED, /* usExtIntrAdslDyingGasp */
3349 + BP_NOT_DEFINED, /* usExtIntrHpna */
3350 + BP_NOT_DEFINED, /* usCsHpna */
3351 + BP_NOT_DEFINED, /* usAntInUseWireless */
3352 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3353 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3354 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3355 +};
3356 +
3357 +static BOARD_PARAMETERS g_bcm96345r0 =
3358 +{
3359 + "96345R0", /* szBoardId */
3360 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3361 + 0x01, /* ucPhyAddress */
3362 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3363 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3364 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3365 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3366 + BP_NOT_DEFINED, /* usGpioPhyReset */
3367 + 0x01, /* numSwitchPorts */
3368 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3369 + BP_NOT_DEFINED}, /* usReverseMii */
3370 + {BP_ENET_NO_PHY}}, /* ucPhyType */
3371 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3372 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3373 + BP_MEMORY_8MB_1_CHIP, /* usSdramSize */
3374 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3375 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3376 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3377 + BP_NOT_DEFINED, /* usGpioPressAndHoldReset */
3378 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3379 + BP_NOT_DEFINED, /* usGpioUartRts */
3380 + BP_NOT_DEFINED, /* usGpioUartCts */
3381 + BP_GPIO_8_AH, /* usGpioLedAdsl */
3382 + BP_NOT_DEFINED, /* usGpioLedAdslFail */
3383 + BP_NOT_DEFINED, /* usGpioLedWireless */
3384 + BP_NOT_DEFINED, /* usGpioLedUsb */
3385 + BP_NOT_DEFINED, /* usGpioLedHpna */
3386 + BP_GPIO_9_AH, /* usGpioLedWanData */
3387 + BP_GPIO_9_AH, /* usGpioLedPpp */
3388 + BP_NOT_DEFINED, /* usGpioLedPppFail */
3389 + BP_NOT_DEFINED, /* usGpioLedBlPowerOn */
3390 + BP_GPIO_9_AH, /* usGpioLedBlAlarm */
3391 + BP_GPIO_8_AH, /* usGpioLedBlResetCfg */
3392 + BP_GPIO_8_AH, /* usGpioLedBlStop */
3393 + BP_NOT_DEFINED, /* usExtIntrWireless */
3394 + BP_NOT_DEFINED, /* usExtIntrAdslDyingGasp */
3395 + BP_NOT_DEFINED, /* usExtIntrHpna */
3396 + BP_NOT_DEFINED, /* usCsHpna */
3397 + BP_NOT_DEFINED, /* usAntInUseWireless */
3398 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3399 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3400 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3401 +};
3402 +
3403 +static BOARD_PARAMETERS g_bcm96345rs =
3404 +{
3405 + "96345RS", /* szBoardId */
3406 + {{BP_ENET_EXTERNAL_SWITCH, /* ucPhyType */
3407 + 0x00, /* ucPhyAddress */
3408 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3409 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3410 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3411 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3412 + BP_NOT_DEFINED, /* usGpioPhyReset */
3413 + 0x01, /* numSwitchPorts */
3414 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3415 + BP_ENET_NO_REVERSE_MII}, /* usReverseMii */
3416 + {BP_ENET_NO_PHY}}, /* ucPhyType */
3417 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3418 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3419 + BP_MEMORY_8MB_1_CHIP, /* usSdramSize */
3420 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3421 + BP_GPIO_11_AH, /* usGpioRj11InnerPair */
3422 + BP_GPIO_12_AH, /* usGpioRj11OuterPair */
3423 + BP_GPIO_13_AH, /* usGpioPressAndHoldReset */
3424 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3425 + BP_NOT_DEFINED, /* usGpioUartRts */
3426 + BP_NOT_DEFINED, /* usGpioUartCts */
3427 + BP_GPIO_8_AH, /* usGpioLedAdsl */
3428 + BP_NOT_DEFINED, /* usGpioLedAdslFail */
3429 + BP_NOT_DEFINED, /* usGpioLedWireless */
3430 + BP_NOT_DEFINED, /* usGpioLedUsb */
3431 + BP_NOT_DEFINED, /* usGpioLedHpna */
3432 + BP_GPIO_8_AH, /* usGpioLedWanData */
3433 + BP_GPIO_9_AH, /* usGpioLedPpp */
3434 + BP_NOT_DEFINED, /* usGpioLedPppFail */
3435 + BP_NOT_DEFINED, /* usGpioLedBlPowerOn */
3436 + BP_GPIO_10_AH, /* usGpioLedBlAlarm */
3437 + BP_GPIO_9_AH, /* usGpioLedBlResetCfg */
3438 + BP_GPIO_8_AH, /* usGpioLedBlStop */
3439 + BP_NOT_DEFINED, /* usExtIntrWireless */
3440 + BP_EXT_INTR_0, /* usExtIntrAdslDyingGasp */
3441 + BP_NOT_DEFINED, /* usExtIntrHpna */
3442 + BP_NOT_DEFINED, /* usCsHpna */
3443 + BP_NOT_DEFINED, /* usAntInUseWireless */
3444 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3445 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3446 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3447 +};
3448 +
3449 +static PBOARD_PARAMETERS g_BoardParms[] =
3450 + {&g_bcm96345r, &g_bcm96345gw2, &g_bcm96345gw, &g_bcm96335r, &g_bcm96345r0,
3451 + &g_bcm96345rs, 0};
3452 +#endif
3453 +
3454 +#if defined(_BCM96348_) || defined(CONFIG_BCM96348)
3455 +
3456 +static BOARD_PARAMETERS g_bcm96348r =
3457 +{
3458 + "96348R", /* szBoardId */
3459 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3460 + 0x01, /* ucPhyAddress */
3461 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3462 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3463 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3464 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3465 + BP_NOT_DEFINED, /* usGpioPhyReset */
3466 + 0x01, /* numSwitchPorts */
3467 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3468 + BP_NOT_DEFINED}, /* usReverseMii */
3469 + {BP_ENET_NO_PHY}}, /* ucPhyType */
3470 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3471 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3472 + BP_MEMORY_8MB_1_CHIP, /* usSdramSize */
3473 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3474 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3475 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3476 + BP_GPIO_7_AH, /* usGpioPressAndHoldReset */
3477 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3478 + BP_NOT_DEFINED, /* usGpioUartRts */
3479 + BP_NOT_DEFINED, /* usGpioUartCts */
3480 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3481 + BP_GPIO_2_AL, /* usGpioLedAdslFail */
3482 + BP_NOT_DEFINED, /* usGpioLedWireless */
3483 + BP_NOT_DEFINED, /* usGpioLedUsb */
3484 + BP_NOT_DEFINED, /* usGpioLedHpna */
3485 + BP_GPIO_3_AL, /* usGpioLedWanData */
3486 + BP_GPIO_3_AL, /* usGpioLedPpp */
3487 + BP_GPIO_4_AL, /* usGpioLedPppFail */
3488 + BP_GPIO_0_AL, /* usGpioLedBlPowerOn */
3489 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3490 + BP_GPIO_3_AL, /* usGpioLedBlResetCfg */
3491 + BP_GPIO_1_AL, /* usGpioLedBlStop */
3492 + BP_NOT_DEFINED, /* usExtIntrWireless */
3493 + BP_HW_DEFINED, /* usExtIntrAdslDyingGasp */
3494 + BP_NOT_DEFINED, /* usExtIntrHpna */
3495 + BP_NOT_DEFINED, /* usCsHpna */
3496 + BP_NOT_DEFINED, /* usAntInUseWireless */
3497 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3498 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3499 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3500 +};
3501 +
3502 +static BOARD_PARAMETERS g_bcm96348lv =
3503 +{
3504 + "96348LV", /* szBoardId */
3505 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3506 + 0x01, /* ucPhyAddress */
3507 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3508 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3509 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3510 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3511 + BP_NOT_DEFINED, /* usGpioPhyReset */
3512 + 0x01, /* numSwitchPorts */
3513 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3514 + BP_NOT_DEFINED}, /* usReverseMii */
3515 + {BP_ENET_EXTERNAL_PHY, /* ucPhyType */
3516 + 0x02, /* ucPhyAddress */
3517 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3518 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3519 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3520 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3521 + BP_GPIO_5_AL, /* usGpioPhyReset */
3522 + 0x01, /* numSwitchPorts */
3523 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3524 + BP_NOT_DEFINED}}, /* usReverseMii */
3525 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3526 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3527 + BP_MEMORY_16MB_2_CHIP, /* usSdramSize */
3528 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3529 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3530 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3531 + BP_GPIO_7_AH, /* usGpioPressAndHoldReset */
3532 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3533 + BP_NOT_DEFINED, /* usGpioUartRts */
3534 + BP_NOT_DEFINED, /* usGpioUartCts */
3535 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3536 + BP_GPIO_2_AL, /* usGpioLedAdslFail */
3537 + BP_NOT_DEFINED, /* usGpioLedWireless */
3538 + BP_NOT_DEFINED, /* usGpioLedUsb */
3539 + BP_NOT_DEFINED, /* usGpioLedHpna */
3540 + BP_GPIO_3_AL, /* usGpioLedWanData */
3541 + BP_GPIO_3_AL, /* usGpioLedPpp */
3542 + BP_GPIO_4_AL, /* usGpioLedPppFail */
3543 + BP_GPIO_0_AL, /* usGpioLedBlPowerOn */
3544 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3545 + BP_GPIO_3_AL, /* usGpioLedBlResetCfg */
3546 + BP_GPIO_1_AL, /* usGpioLedBlStop */
3547 + BP_NOT_DEFINED, /* usExtIntrWireless */
3548 + BP_NOT_DEFINED, /* usExtIntrAdslDyingGasp */
3549 + BP_NOT_DEFINED, /* usExtIntrHpna */
3550 + BP_NOT_DEFINED, /* usCsHpna */
3551 + BP_NOT_DEFINED, /* usAntInUseWireless */
3552 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3553 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3554 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3555 +};
3556 +
3557 +static BOARD_PARAMETERS g_bcm96348gw =
3558 +{
3559 + "96348GW", /* szBoardId */
3560 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3561 + 0x01, /* ucPhyAddress */
3562 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3563 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3564 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3565 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3566 + BP_NOT_DEFINED, /* usGpioPhyReset */
3567 + 0x01, /* numSwitchPorts */
3568 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3569 + BP_NOT_DEFINED}, /* usReverseMii */
3570 + {BP_ENET_EXTERNAL_SWITCH, /* ucPhyType */
3571 + 0x00, /* ucPhyAddress */
3572 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3573 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3574 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3575 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3576 + BP_NOT_DEFINED, /* usGpioPhyReset */
3577 + 0x03, /* numSwitchPorts */
3578 + BP_ENET_CONFIG_SPI_SSB_0, /* usConfigType */
3579 + BP_ENET_REVERSE_MII}}, /* usReverseMii */
3580 + {{BP_VOIP_DSP, /* ucDspType */
3581 + 0x00, /* ucDspAddress */
3582 + BP_EXT_INTR_2, /* usExtIntrVoip */
3583 + BP_GPIO_6_AH, /* usGpioVoipReset */
3584 + BP_GPIO_34_AH, /* usGpioVoipIntr */
3585 + BP_NOT_DEFINED, /* usGpioLedVoip */
3586 + BP_CS_2}, /* usCsVoip */
3587 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3588 + BP_MEMORY_16MB_2_CHIP, /* usSdramSize */
3589 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3590 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3591 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3592 + BP_GPIO_33_AL, /* usGpioPressAndHoldReset */
3593 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3594 + BP_NOT_DEFINED, /* usGpioUartRts */
3595 + BP_NOT_DEFINED, /* usGpioUartCts */
3596 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3597 + BP_GPIO_2_AL, /* usGpioLedAdslFail */
3598 + BP_NOT_DEFINED, /* usGpioLedWireless */
3599 + BP_NOT_DEFINED, /* usGpioLedUsb */
3600 + BP_NOT_DEFINED, /* usGpioLedHpna */
3601 + BP_GPIO_3_AL, /* usGpioLedWanData */
3602 + BP_GPIO_3_AL, /* usGpioLedPpp */
3603 + BP_GPIO_4_AL, /* usGpioLedPppFail */
3604 + BP_GPIO_0_AL, /* usGpioLedBlPowerOn */
3605 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3606 + BP_GPIO_3_AL, /* usGpioLedBlResetCfg */
3607 + BP_GPIO_1_AL, /* usGpioLedBlStop */
3608 + BP_NOT_DEFINED, /* usExtIntrWireless */
3609 + BP_HW_DEFINED, /* usExtIntrAdslDyingGasp */
3610 + BP_NOT_DEFINED, /* usExtIntrHpna */
3611 + BP_NOT_DEFINED, /* usCsHpna */
3612 + BP_WLAN_ANT_MAIN, /* usAntInUseWireless */
3613 + BP_NOT_DEFINED, /* BP_GPIO_35_AH, */ /* usGpioSesBtnWireless */
3614 + BP_NOT_DEFINED, /* BP_EXT_INTR_3, */ /* usExtIntrSesBtnWireless */
3615 + BP_NOT_DEFINED /* BP_GPIO_0_AL */ /* usGpioLedSesWireless */
3616 +};
3617 +
3618 +
3619 +static BOARD_PARAMETERS g_bcm96348gw_10 =
3620 +{
3621 + "96348GW-10", /* szBoardId */
3622 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3623 + 0x01, /* ucPhyAddress */
3624 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3625 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3626 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3627 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3628 + BP_NOT_DEFINED, /* usGpioPhyReset */
3629 + 0x01, /* numSwitchPorts */
3630 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3631 + BP_NOT_DEFINED}, /* usReverseMii */
3632 + {BP_ENET_EXTERNAL_SWITCH, /* ucPhyType */
3633 + 0x00, /* ucPhyAddress */
3634 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3635 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3636 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3637 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3638 + BP_NOT_DEFINED, /* usGpioPhyReset */
3639 + 0x03, /* numSwitchPorts */
3640 + BP_ENET_CONFIG_SPI_SSB_1, /* usConfigType */
3641 + BP_ENET_REVERSE_MII}}, /* usReverseMii */
3642 + {{BP_VOIP_DSP, /* ucDspType */
3643 + 0x00, /* ucDspAddress */
3644 + BP_EXT_INTR_2, /* usExtIntrVoip */
3645 + BP_GPIO_6_AH, /* usGpioVoipReset */
3646 + BP_GPIO_34_AH, /* usGpioVoipIntr */
3647 + BP_NOT_DEFINED, /* usGpioLedVoip */
3648 + BP_CS_2}, /* usCsVoip */
3649 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3650 + BP_MEMORY_16MB_2_CHIP, /* usSdramSize */
3651 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3652 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3653 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3654 + BP_GPIO_33_AL, /* usGpioPressAndHoldReset */
3655 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3656 + BP_NOT_DEFINED, /* usGpioUartRts */
3657 + BP_NOT_DEFINED, /* usGpioUartCts */
3658 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3659 + BP_GPIO_2_AL, /* usGpioLedAdslFail */
3660 + BP_NOT_DEFINED, /* usGpioLedWireless */
3661 + BP_NOT_DEFINED, /* usGpioLedUsb */
3662 + BP_NOT_DEFINED, /* usGpioLedHpna */
3663 + BP_GPIO_3_AL, /* usGpioLedWanData */
3664 + BP_GPIO_3_AL, /* usGpioLedPpp */
3665 + BP_GPIO_4_AL, /* usGpioLedPppFail */
3666 + BP_GPIO_0_AL, /* usGpioLedBlPowerOn */
3667 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3668 + BP_GPIO_3_AL, /* usGpioLedBlResetCfg */
3669 + BP_GPIO_1_AL, /* usGpioLedBlStop */
3670 + BP_NOT_DEFINED, /* usExtIntrWireless */
3671 + BP_HW_DEFINED, /* usExtIntrAdslDyingGasp */
3672 + BP_NOT_DEFINED, /* usExtIntrHpna */
3673 + BP_NOT_DEFINED, /* usCsHpna */
3674 + BP_WLAN_ANT_MAIN, /* usAntInUseWireless */
3675 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3676 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3677 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3678 +};
3679 +
3680 +static BOARD_PARAMETERS g_bcm96348gw_11 =
3681 +{
3682 + "96348GW-11", /* szBoardId */
3683 + {{BP_ENET_NO_PHY}, /* ucPhyType */
3684 + {BP_ENET_EXTERNAL_SWITCH, /* ucPhyType */
3685 + 0x00, /* ucPhyAddress */
3686 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3687 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3688 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3689 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3690 + BP_NOT_DEFINED, /* usGpioPhyReset */
3691 + 0x04, /* numSwitchPorts */
3692 + BP_ENET_CONFIG_SPI_SSB_1, /* usConfigType */
3693 + BP_ENET_REVERSE_MII}}, /* usReverseMii */
3694 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3695 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3696 + BP_MEMORY_16MB_2_CHIP, /* usSdramSize */
3697 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3698 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3699 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3700 + BP_GPIO_33_AL, /* usGpioPressAndHoldReset */
3701 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3702 + BP_NOT_DEFINED, /* usGpioUartRts */
3703 + BP_NOT_DEFINED, /* usGpioUartCts */
3704 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3705 + BP_GPIO_2_AL, /* usGpioLedAdslFail */
3706 + BP_NOT_DEFINED, /* usGpioLedWireless */
3707 + BP_NOT_DEFINED, /* usGpioLedUsb */
3708 + BP_NOT_DEFINED, /* usGpioLedHpna */
3709 + BP_GPIO_3_AL, /* usGpioLedWanData */
3710 + BP_GPIO_3_AL, /* usGpioLedPpp */
3711 + BP_GPIO_4_AL, /* usGpioLedPppFail */
3712 + BP_GPIO_0_AL, /* usGpioLedBlPowerOn */
3713 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3714 + BP_GPIO_3_AL, /* usGpioLedBlResetCfg */
3715 + BP_GPIO_1_AL, /* usGpioLedBlStop */
3716 + BP_NOT_DEFINED, /* usExtIntrWireless */
3717 + BP_HW_DEFINED, /* usExtIntrAdslDyingGasp */
3718 + BP_NOT_DEFINED, /* usExtIntrHpna */
3719 + BP_NOT_DEFINED, /* usCsHpna */
3720 + BP_NOT_DEFINED, /* usAntInUseWireless */
3721 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3722 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3723 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3724 +};
3725 +
3726 +static BOARD_PARAMETERS g_bcm96348sv =
3727 +{
3728 + "96348SV", /* szBoardId */
3729 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3730 + 0x01, /* ucPhyAddress */
3731 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3732 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3733 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3734 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3735 + BP_NOT_DEFINED, /* usGpioPhyReset */
3736 + 0x01, /* numSwitchPorts */
3737 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3738 + BP_NOT_DEFINED}, /* usReverseMii */
3739 + {BP_ENET_EXTERNAL_PHY, /* ucPhyType */
3740 + 0x1f, /* ucPhyAddress */
3741 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3742 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3743 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3744 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3745 + BP_NOT_DEFINED, /* usGpioPhyReset */
3746 + 0x01, /* numSwitchPorts */
3747 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3748 + BP_NOT_DEFINED}}, /* usReverseMii */
3749 + {{BP_VOIP_NO_DSP}, /* ucDspType */
3750 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3751 + BP_MEMORY_32MB_2_CHIP, /* usSdramSize */
3752 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3753 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3754 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3755 + BP_NOT_DEFINED, /* usGpioPressAndHoldReset */
3756 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3757 + BP_NOT_DEFINED, /* usGpioUartRts */
3758 + BP_NOT_DEFINED, /* usGpioUartCts */
3759 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3760 + BP_NOT_DEFINED, /* usGpioLedAdslFail */
3761 + BP_NOT_DEFINED, /* usGpioLedWireless */
3762 + BP_NOT_DEFINED, /* usGpioLedUsb */
3763 + BP_NOT_DEFINED, /* usGpioLedHpna */
3764 + BP_NOT_DEFINED, /* usGpioLedWanData */
3765 + BP_NOT_DEFINED, /* usGpioLedPpp */
3766 + BP_NOT_DEFINED, /* usGpioLedPppFail */
3767 + BP_NOT_DEFINED, /* usGpioLedBlPowerOn */
3768 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3769 + BP_NOT_DEFINED, /* usGpioLedBlResetCfg */
3770 + BP_NOT_DEFINED, /* usGpioLedBlStop */
3771 + BP_NOT_DEFINED, /* usExtIntrWireless */
3772 + BP_HW_DEFINED, /* usExtIntrAdslDyingGasp */
3773 + BP_NOT_DEFINED, /* usExtIntrHpna */
3774 + BP_NOT_DEFINED, /* usCsHpna */
3775 + BP_NOT_DEFINED, /* usAntInUseWireless */
3776 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3777 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3778 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3779 +};
3780 +
3781 +
3782 +static BOARD_PARAMETERS g_bcm96348gw_dualDsp =
3783 +{
3784 + "96348GW-DualDSP", /* szBoardId */
3785 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3786 + 0x01, /* ucPhyAddress */
3787 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3788 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3789 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3790 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3791 + BP_NOT_DEFINED, /* usGpioPhyReset */
3792 + 0x01, /* numSwitchPorts */
3793 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3794 + BP_NOT_DEFINED}, /* usReverseMii */
3795 + {BP_ENET_EXTERNAL_SWITCH, /* ucPhyType */
3796 + 0x00, /* ucPhyAddress */
3797 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3798 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3799 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3800 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3801 + BP_NOT_DEFINED, /* usGpioPhyReset */
3802 + 0x03, /* numSwitchPorts */
3803 + BP_ENET_CONFIG_SPI_SSB_1, /* usConfigType */
3804 + BP_ENET_REVERSE_MII}}, /* usReverseMii */
3805 + {{BP_VOIP_DSP, /* ucDspType */
3806 + 0x00, /* ucDspAddress */
3807 + BP_EXT_INTR_2, /* usExtIntrVoip */
3808 + BP_UNEQUIPPED, /* usGpioVoipReset */
3809 + BP_GPIO_34_AH, /* usGpioVoipIntr */
3810 + BP_NOT_DEFINED, /* usGpioLedVoip */
3811 + BP_CS_2}, /* usCsVoip */
3812 + {BP_VOIP_DSP, /* ucDspType */
3813 + 0x01, /* ucDspAddress */
3814 + BP_EXT_INTR_3, /* usExtIntrVoip */
3815 + BP_UNEQUIPPED , /* usGpioVoipReset */
3816 + BP_GPIO_35_AH, /* usGpioVoipIntr */
3817 + BP_NOT_DEFINED, /* usGpioLedVoip */
3818 + BP_CS_3}}, /* usCsVoip */
3819 + BP_MEMORY_16MB_2_CHIP, /* usSdramSize */
3820 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3821 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3822 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3823 + BP_GPIO_33_AL, /* usGpioPressAndHoldReset */
3824 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3825 + BP_NOT_DEFINED, /* usGpioUartRts */
3826 + BP_NOT_DEFINED, /* usGpioUartCts */
3827 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3828 + BP_GPIO_2_AL, /* usGpioLedAdslFail */
3829 + BP_NOT_DEFINED, /* usGpioLedWireless */
3830 + BP_NOT_DEFINED, /* usGpioLedUsb */
3831 + BP_NOT_DEFINED, /* usGpioLedHpna */
3832 + BP_GPIO_3_AL, /* usGpioLedWanData */
3833 + BP_GPIO_3_AL, /* usGpioLedPpp */
3834 + BP_GPIO_4_AL, /* usGpioLedPppFail */
3835 + BP_GPIO_0_AL, /* usGpioLedBlPowerOn */
3836 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3837 + BP_GPIO_3_AL, /* usGpioLedBlResetCfg */
3838 + BP_GPIO_1_AL, /* usGpioLedBlStop */
3839 + BP_NOT_DEFINED, /* usExtIntrWireless */
3840 + BP_HW_DEFINED, /* usExtIntrAdslDyingGasp */
3841 + BP_NOT_DEFINED, /* usExtIntrHpna */
3842 + BP_NOT_DEFINED, /* usCsHpna */
3843 + BP_WLAN_ANT_MAIN, /* usAntInUseWireless */
3844 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3845 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3846 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3847 +};
3848 +
3849 +
3850 +static BOARD_PARAMETERS g_bcmCustom_01 =
3851 +{
3852 + "BCMCUST_01", /* szBoardId */
3853 + {{BP_ENET_INTERNAL_PHY, /* ucPhyType */
3854 + 0x01, /* ucPhyAddress */
3855 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3856 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3857 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3858 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3859 + BP_NOT_DEFINED, /* usGpioPhyReset */
3860 + 0x01, /* numSwitchPorts */
3861 + BP_ENET_CONFIG_MDIO, /* usConfigType */
3862 + BP_NOT_DEFINED}, /* usReverseMii */
3863 + {BP_ENET_NO_PHY, /* ucPhyType */
3864 + 0x00, /* ucPhyAddress */
3865 + BP_NOT_DEFINED, /* usGpioPhySpiSck */
3866 + BP_NOT_DEFINED, /* usGpioPhySpiSs */
3867 + BP_NOT_DEFINED, /* usGpioPhySpiMosi */
3868 + BP_NOT_DEFINED, /* usGpioPhySpiMiso */
3869 + BP_NOT_DEFINED, /* usGpioPhyReset */
3870 + 0x01, /* numSwitchPorts */
3871 + BP_ENET_CONFIG_SPI_SSB_1, /* usConfigType */
3872 + BP_ENET_REVERSE_MII}}, /* usReverseMii */
3873 + {{BP_VOIP_DSP, /* ucDspType */
3874 + 0x00, /* ucDspAddress */
3875 + BP_EXT_INTR_2, /* usExtIntrVoip */
3876 + BP_GPIO_36_AH, /* usGpioVoipReset */
3877 + BP_GPIO_34_AL, /* usGpioVoipIntr */
3878 + BP_NOT_DEFINED, /* usGpioLedVoip */
3879 + BP_CS_2}, /* usCsVoip */
3880 + {BP_VOIP_NO_DSP}}, /* ucDspType */
3881 + BP_MEMORY_16MB_2_CHIP, /* usSdramSize */
3882 + BP_PSI_DEFAULT_SIZE, /* usPsiSize */
3883 + BP_NOT_DEFINED, /* usGpioRj11InnerPair */
3884 + BP_NOT_DEFINED, /* usGpioRj11OuterPair */
3885 + BP_GPIO_33_AL, /* usGpioPressAndHoldReset */
3886 + BP_NOT_DEFINED, /* usGpioPcmciaReset */
3887 + BP_NOT_DEFINED, /* usGpioUartRts */
3888 + BP_NOT_DEFINED, /* usGpioUartCts */
3889 + BP_NOT_DEFINED, /* usGpioLedAdsl */
3890 + BP_GPIO_2_AL, /* usGpioLedAdslFail */
3891 + BP_NOT_DEFINED, /* usGpioLedWireless */
3892 + BP_NOT_DEFINED, /* usGpioLedUsb */
3893 + BP_NOT_DEFINED, /* usGpioLedHpna */
3894 + BP_GPIO_3_AL, /* usGpioLedWanData */
3895 + BP_GPIO_3_AL, /* usGpioLedPpp */
3896 + BP_GPIO_4_AL, /* usGpioLedPppFail */
3897 + BP_GPIO_0_AL, /* usGpioLedBlPowerOn */
3898 + BP_NOT_DEFINED, /* usGpioLedBlAlarm */
3899 + BP_GPIO_3_AL, /* usGpioLedBlResetCfg */
3900 + BP_GPIO_1_AL, /* usGpioLedBlStop */
3901 + BP_NOT_DEFINED, /* usExtIntrWireless */
3902 + BP_NOT_DEFINED, /* usExtIntrAdslDyingGasp */
3903 + BP_NOT_DEFINED, /* usExtIntrHpna */
3904 + BP_NOT_DEFINED, /* usCsHpna */
3905 + BP_NOT_DEFINED, /* usAntInUseWireless */
3906 + BP_NOT_DEFINED, /* usGpioSesBtnWireless */
3907 + BP_NOT_DEFINED, /* usExtIntrSesBtnWireless */
3908 + BP_NOT_DEFINED /* usGpioLedSesWireless */
3909 +};
3910 +
3911 +static PBOARD_PARAMETERS g_BoardParms[] =
3912 + {&g_bcm96348r, &g_bcm96348lv, &g_bcm96348gw, &g_bcm96348gw_10,
3913 + &g_bcm96348gw_11, &g_bcm96348sv, &g_bcm96348gw_dualDsp,
3914 + &g_bcmCustom_01, 0};
3915 +#endif
3916 +
3917 +static PBOARD_PARAMETERS g_pCurrentBp = 0;
3918 +
3919 +/**************************************************************************
3920 + * Name : bpstrcmp
3921 + *
3922 + * Description: String compare for this file so it does not depend on an OS.
3923 + * (Linux kernel and CFE share this source file.)
3924 + *
3925 + * Parameters : [IN] dest - destination string
3926 + * [IN] src - source string
3927 + *
3928 + * Returns : -1 - dest < src, 1 - dest > src, 0 dest == src
3929 + ***************************************************************************/
3930 +static int bpstrcmp(const char *dest,const char *src);
3931 +static int bpstrcmp(const char *dest,const char *src)
3932 +{
3933 + while (*src && *dest)
3934 + {
3935 + if (*dest < *src) return -1;
3936 + if (*dest > *src) return 1;
3937 + dest++;
3938 + src++;
3939 + }
3940 +
3941 + if (*dest && !*src) return 1;
3942 + if (!*dest && *src) return -1;
3943 + return 0;
3944 +} /* bpstrcmp */
3945 +
3946 +/**************************************************************************
3947 + * Name : BpGetVoipDspConfig
3948 + *
3949 + * Description: Gets the DSP configuration from the board parameter
3950 + * structure for a given DSP index.
3951 + *
3952 + * Parameters : [IN] dspNum - DSP index (number)
3953 + *
3954 + * Returns : Pointer to DSP configuration block if found/valid, NULL
3955 + * otherwise.
3956 + ***************************************************************************/
3957 +VOIP_DSP_INFO *BpGetVoipDspConfig( unsigned char dspNum );
3958 +VOIP_DSP_INFO *BpGetVoipDspConfig( unsigned char dspNum )
3959 +{
3960 + VOIP_DSP_INFO *pDspConfig = 0;
3961 + int i;
3962 +
3963 + if( g_pCurrentBp )
3964 + {
3965 + for( i = 0 ; i < BP_MAX_VOIP_DSP ; i++ )
3966 + {
3967 + if( g_pCurrentBp->VoIPDspInfo[i].ucDspType != BP_VOIP_NO_DSP &&
3968 + g_pCurrentBp->VoIPDspInfo[i].ucDspAddress == dspNum )
3969 + {
3970 + pDspConfig = &g_pCurrentBp->VoIPDspInfo[i];
3971 + break;
3972 + }
3973 + }
3974 + }
3975 +
3976 + return pDspConfig;
3977 +}
3978 +
3979 +
3980 +/**************************************************************************
3981 + * Name : BpSetBoardId
3982 + *
3983 + * Description: This function find the BOARD_PARAMETERS structure for the
3984 + * specified board id string and assigns it to a global, static
3985 + * variable.
3986 + *
3987 + * Parameters : [IN] pszBoardId - Board id string that is saved into NVRAM.
3988 + *
3989 + * Returns : BP_SUCCESS - Success, value is returned.
3990 + * BP_BOARD_ID_NOT_FOUND - Error, board id input string does not
3991 + * have a board parameters configuration record.
3992 + ***************************************************************************/
3993 +int BpSetBoardId( char *pszBoardId )
3994 +{
3995 + int nRet = BP_BOARD_ID_NOT_FOUND;
3996 + PBOARD_PARAMETERS *ppBp;
3997 +
3998 + for( ppBp = g_BoardParms; *ppBp; ppBp++ )
3999 + {
4000 + if( !bpstrcmp((*ppBp)->szBoardId, pszBoardId) )
4001 + {
4002 + g_pCurrentBp = *ppBp;
4003 + nRet = BP_SUCCESS;
4004 + break;
4005 + }
4006 + }
4007 +
4008 + return( nRet );
4009 +} /* BpSetBoardId */
4010 +
4011 +/**************************************************************************
4012 + * Name : BpGetBoardIds
4013 + *
4014 + * Description: This function returns all of the supported board id strings.
4015 + *
4016 + * Parameters : [OUT] pszBoardIds - Address of a buffer that the board id
4017 + * strings are returned in. Each id starts at BP_BOARD_ID_LEN
4018 + * boundary.
4019 + * [IN] nBoardIdsSize - Number of BP_BOARD_ID_LEN elements that
4020 + * were allocated in pszBoardIds.
4021 + *
4022 + * Returns : Number of board id strings returned.
4023 + ***************************************************************************/
4024 +int BpGetBoardIds( char *pszBoardIds, int nBoardIdsSize )
4025 +{
4026 + PBOARD_PARAMETERS *ppBp;
4027 + int i;
4028 + char *src;
4029 + char *dest;
4030 +
4031 + for( i = 0, ppBp = g_BoardParms; *ppBp && nBoardIdsSize;
4032 + i++, ppBp++, nBoardIdsSize--, pszBoardIds += BP_BOARD_ID_LEN )
4033 + {
4034 + dest = pszBoardIds;
4035 + src = (*ppBp)->szBoardId;
4036 + while( *src )
4037 + *dest++ = *src++;
4038 + *dest = '\0';
4039 + }
4040 +
4041 + return( i );
4042 +} /* BpGetBoardIds */
4043 +
4044 +/**************************************************************************
4045 + * Name : BpGetEthernetMacInfo
4046 + *
4047 + * Description: This function returns all of the supported board id strings.
4048 + *
4049 + * Parameters : [OUT] pEnetInfos - Address of an array of ETHERNET_MAC_INFO
4050 + * buffers.
4051 + * [IN] nNumEnetInfos - Number of ETHERNET_MAC_INFO elements that
4052 + * are pointed to by pEnetInfos.
4053 + *
4054 + * Returns : BP_SUCCESS - Success, value is returned.
4055 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4056 + ***************************************************************************/
4057 +int BpGetEthernetMacInfo( PETHERNET_MAC_INFO pEnetInfos, int nNumEnetInfos )
4058 +{
4059 + int i, nRet;
4060 +
4061 + if( g_pCurrentBp )
4062 + {
4063 + for( i = 0; i < nNumEnetInfos; i++, pEnetInfos++ )
4064 + {
4065 + if( i < BP_MAX_ENET_MACS )
4066 + {
4067 + unsigned char *src = (unsigned char *)
4068 + &g_pCurrentBp->EnetMacInfos[i];
4069 + unsigned char *dest = (unsigned char *) pEnetInfos;
4070 + int len = sizeof(ETHERNET_MAC_INFO);
4071 + while( len-- )
4072 + *dest++ = *src++;
4073 + }
4074 + else
4075 + pEnetInfos->ucPhyType = BP_ENET_NO_PHY;
4076 + }
4077 +
4078 + nRet = BP_SUCCESS;
4079 + }
4080 + else
4081 + {
4082 + for( i = 0; i < nNumEnetInfos; i++, pEnetInfos++ )
4083 + pEnetInfos->ucPhyType = BP_ENET_NO_PHY;
4084 +
4085 + nRet = BP_BOARD_ID_NOT_SET;
4086 + }
4087 +
4088 + return( nRet );
4089 +} /* BpGetEthernetMacInfo */
4090 +
4091 +/**************************************************************************
4092 + * Name : BpGetSdramSize
4093 + *
4094 + * Description: This function returns a constant that describees the board's
4095 + * SDRAM type and size.
4096 + *
4097 + * Parameters : [OUT] pulSdramSize - Address of short word that the SDRAM size
4098 + * is returned in.
4099 + *
4100 + * Returns : BP_SUCCESS - Success, value is returned.
4101 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4102 + ***************************************************************************/
4103 +int BpGetSdramSize( unsigned long *pulSdramSize )
4104 +{
4105 + int nRet;
4106 +
4107 + if( g_pCurrentBp )
4108 + {
4109 + *pulSdramSize = g_pCurrentBp->usSdramSize;
4110 + nRet = BP_SUCCESS;
4111 + }
4112 + else
4113 + {
4114 + *pulSdramSize = BP_NOT_DEFINED;
4115 + nRet = BP_BOARD_ID_NOT_SET;
4116 + }
4117 +
4118 + return( nRet );
4119 +} /* BpGetSdramSize */
4120 +
4121 +/**************************************************************************
4122 + * Name : BpGetPsiSize
4123 + *
4124 + * Description: This function returns the persistent storage size in K bytes.
4125 + *
4126 + * Parameters : [OUT] pulPsiSize - Address of short word that the persistent
4127 + * storage size is returned in.
4128 + *
4129 + * Returns : BP_SUCCESS - Success, value is returned.
4130 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4131 + ***************************************************************************/
4132 +int BpGetPsiSize( unsigned long *pulPsiSize )
4133 +{
4134 + int nRet;
4135 +
4136 + if( g_pCurrentBp )
4137 + {
4138 + *pulPsiSize = g_pCurrentBp->usPsiSize;
4139 + nRet = BP_SUCCESS;
4140 + }
4141 + else
4142 + {
4143 + *pulPsiSize = BP_NOT_DEFINED;
4144 + nRet = BP_BOARD_ID_NOT_SET;
4145 + }
4146 +
4147 + return( nRet );
4148 +} /* BpGetPsiSize */
4149 +
4150 +/**************************************************************************
4151 + * Name : BpGetRj11InnerOuterPairGpios
4152 + *
4153 + * Description: This function returns the GPIO pin assignments for changing
4154 + * between the RJ11 inner pair and RJ11 outer pair.
4155 + *
4156 + * Parameters : [OUT] pusInner - Address of short word that the RJ11 inner pair
4157 + * GPIO pin is returned in.
4158 + * [OUT] pusOuter - Address of short word that the RJ11 outer pair
4159 + * GPIO pin is returned in.
4160 + *
4161 + * Returns : BP_SUCCESS - Success, values are returned.
4162 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4163 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4164 + * for the board.
4165 + ***************************************************************************/
4166 +int BpGetRj11InnerOuterPairGpios( unsigned short *pusInner,
4167 + unsigned short *pusOuter )
4168 +{
4169 + int nRet;
4170 +
4171 + if( g_pCurrentBp )
4172 + {
4173 + *pusInner = g_pCurrentBp->usGpioRj11InnerPair;
4174 + *pusOuter = g_pCurrentBp->usGpioRj11OuterPair;
4175 +
4176 + if( g_pCurrentBp->usGpioRj11InnerPair != BP_NOT_DEFINED &&
4177 + g_pCurrentBp->usGpioRj11OuterPair != BP_NOT_DEFINED )
4178 + {
4179 + nRet = BP_SUCCESS;
4180 + }
4181 + else
4182 + {
4183 + nRet = BP_VALUE_NOT_DEFINED;
4184 + }
4185 + }
4186 + else
4187 + {
4188 + *pusInner = *pusOuter = BP_NOT_DEFINED;
4189 + nRet = BP_BOARD_ID_NOT_SET;
4190 + }
4191 +
4192 + return( nRet );
4193 +} /* BpGetRj11InnerOuterPairGpios */
4194 +
4195 +/**************************************************************************
4196 + * Name : BpGetPressAndHoldResetGpio
4197 + *
4198 + * Description: This function returns the GPIO pin assignment for the press
4199 + * and hold reset button.
4200 + *
4201 + * Parameters : [OUT] pusValue - Address of short word that the press and hold
4202 + * reset button GPIO pin is returned in.
4203 + *
4204 + * Returns : BP_SUCCESS - Success, value is returned.
4205 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4206 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4207 + * for the board.
4208 + ***************************************************************************/
4209 +int BpGetPressAndHoldResetGpio( unsigned short *pusValue )
4210 +{
4211 + int nRet;
4212 +
4213 + if( g_pCurrentBp )
4214 + {
4215 + *pusValue = g_pCurrentBp->usGpioPressAndHoldReset;
4216 +
4217 + if( g_pCurrentBp->usGpioPressAndHoldReset != BP_NOT_DEFINED )
4218 + {
4219 + nRet = BP_SUCCESS;
4220 + }
4221 + else
4222 + {
4223 + nRet = BP_VALUE_NOT_DEFINED;
4224 + }
4225 + }
4226 + else
4227 + {
4228 + *pusValue = BP_NOT_DEFINED;
4229 + nRet = BP_BOARD_ID_NOT_SET;
4230 + }
4231 +
4232 + return( nRet );
4233 +} /* BpGetPressAndHoldResetGpio */
4234 +
4235 +/**************************************************************************
4236 + * Name : BpGetVoipResetGpio
4237 + *
4238 + * Description: This function returns the GPIO pin assignment for the VOIP
4239 + * Reset operation.
4240 + *
4241 + * Parameters : [OUT] pusValue - Address of short word that the VOIP reset
4242 + * GPIO pin is returned in.
4243 + * [IN] dspNum - Address of the DSP to query.
4244 + *
4245 + * Returns : BP_SUCCESS - Success, value is returned.
4246 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4247 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4248 + * for the board.
4249 + ***************************************************************************/
4250 +int BpGetVoipResetGpio( unsigned char dspNum, unsigned short *pusValue )
4251 +{
4252 + int nRet;
4253 +
4254 + if( g_pCurrentBp )
4255 + {
4256 + VOIP_DSP_INFO *pDspInfo = BpGetVoipDspConfig( dspNum );
4257 +
4258 + if( pDspInfo )
4259 + {
4260 + *pusValue = pDspInfo->usGpioVoipReset;
4261 +
4262 + if( *pusValue != BP_NOT_DEFINED ||
4263 + *pusValue == BP_UNEQUIPPED )
4264 + {
4265 + nRet = BP_SUCCESS;
4266 + }
4267 + else
4268 + {
4269 + nRet = BP_VALUE_NOT_DEFINED;
4270 + }
4271 + }
4272 + else
4273 + {
4274 + *pusValue = BP_NOT_DEFINED;
4275 + nRet = BP_BOARD_ID_NOT_FOUND;
4276 + }
4277 + }
4278 + else
4279 + {
4280 + *pusValue = BP_NOT_DEFINED;
4281 + nRet = BP_BOARD_ID_NOT_SET;
4282 + }
4283 +
4284 + return( nRet );
4285 +} /* BpGetVoipResetGpio */
4286 +
4287 +/**************************************************************************
4288 + * Name : BpGetVoipIntrGpio
4289 + *
4290 + * Description: This function returns the GPIO pin assignment for VoIP interrupt.
4291 + *
4292 + * Parameters : [OUT] pusValue - Address of short word that the VOIP interrupt
4293 + * GPIO pin is returned in.
4294 + * [IN] dspNum - Address of the DSP to query.
4295 + *
4296 + * Returns : BP_SUCCESS - Success, value is returned.
4297 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4298 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4299 + * for the board.
4300 + ***************************************************************************/
4301 +int BpGetVoipIntrGpio( unsigned char dspNum, unsigned short *pusValue )
4302 +{
4303 + int nRet;
4304 +
4305 + if( g_pCurrentBp )
4306 + {
4307 + VOIP_DSP_INFO *pDspInfo = BpGetVoipDspConfig( dspNum );
4308 +
4309 + if( pDspInfo )
4310 + {
4311 + *pusValue = pDspInfo->usGpioVoipIntr;
4312 +
4313 + if( *pusValue != BP_NOT_DEFINED )
4314 + {
4315 + nRet = BP_SUCCESS;
4316 + }
4317 + else
4318 + {
4319 + nRet = BP_VALUE_NOT_DEFINED;
4320 + }
4321 + }
4322 + else
4323 + {
4324 + *pusValue = BP_NOT_DEFINED;
4325 + nRet = BP_BOARD_ID_NOT_FOUND;
4326 + }
4327 + }
4328 + else
4329 + {
4330 + *pusValue = BP_NOT_DEFINED;
4331 + nRet = BP_BOARD_ID_NOT_SET;
4332 + }
4333 +
4334 + return( nRet );
4335 +} /* BpGetVoipIntrGpio */
4336 +
4337 +/**************************************************************************
4338 + * Name : BpGetPcmciaResetGpio
4339 + *
4340 + * Description: This function returns the GPIO pin assignment for the PCMCIA
4341 + * Reset operation.
4342 + *
4343 + * Parameters : [OUT] pusValue - Address of short word that the PCMCIA reset
4344 + * GPIO pin is returned in.
4345 + *
4346 + * Returns : BP_SUCCESS - Success, value is returned.
4347 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4348 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4349 + * for the board.
4350 + ***************************************************************************/
4351 +int BpGetPcmciaResetGpio( unsigned short *pusValue )
4352 +{
4353 + int nRet;
4354 +
4355 + if( g_pCurrentBp )
4356 + {
4357 + *pusValue = g_pCurrentBp->usGpioPcmciaReset;
4358 +
4359 + if( g_pCurrentBp->usGpioPcmciaReset != BP_NOT_DEFINED )
4360 + {
4361 + nRet = BP_SUCCESS;
4362 + }
4363 + else
4364 + {
4365 + nRet = BP_VALUE_NOT_DEFINED;
4366 + }
4367 + }
4368 + else
4369 + {
4370 + *pusValue = BP_NOT_DEFINED;
4371 + nRet = BP_BOARD_ID_NOT_SET;
4372 + }
4373 +
4374 + return( nRet );
4375 +} /* BpGetPcmciaResetGpio */
4376 +
4377 +/**************************************************************************
4378 + * Name : BpGetUartRtsCtsGpios
4379 + *
4380 + * Description: This function returns the GPIO pin assignments for RTS and CTS
4381 + * UART signals.
4382 + *
4383 + * Parameters : [OUT] pusRts - Address of short word that the UART RTS GPIO
4384 + * pin is returned in.
4385 + * [OUT] pusCts - Address of short word that the UART CTS GPIO
4386 + * pin is returned in.
4387 + *
4388 + * Returns : BP_SUCCESS - Success, values are returned.
4389 + * BP_BOARD_ID_NOT_SET - Error, board id input string does not
4390 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4391 + * for the board.
4392 + ***************************************************************************/
4393 +int BpGetRtsCtsUartGpios( unsigned short *pusRts, unsigned short *pusCts )
4394 +{
4395 + int nRet;
4396 +
4397 + if( g_pCurrentBp )
4398 + {
4399 + *pusRts = g_pCurrentBp->usGpioUartRts;
4400 + *pusCts = g_pCurrentBp->usGpioUartCts;
4401 +
4402 + if( g_pCurrentBp->usGpioUartRts != BP_NOT_DEFINED &&
4403 + g_pCurrentBp->usGpioUartCts != BP_NOT_DEFINED )
4404 + {
4405 + nRet = BP_SUCCESS;
4406 + }
4407 + else
4408 + {
4409 + nRet = BP_VALUE_NOT_DEFINED;
4410 + }
4411 + }
4412 + else
4413 + {
4414 + *pusRts = *pusCts = BP_NOT_DEFINED;
4415 + nRet = BP_BOARD_ID_NOT_SET;
4416 + }
4417 +
4418 + return( nRet );
4419 +} /* BpGetUartRtsCtsGpios */
4420 +
4421 +/**************************************************************************
4422 + * Name : BpGetAdslLedGpio
4423 + *
4424 + * Description: This function returns the GPIO pin assignment for the ADSL
4425 + * LED.
4426 + *
4427 + * Parameters : [OUT] pusValue - Address of short word that the ADSL LED
4428 + * GPIO pin is returned in.
4429 + *
4430 + * Returns : BP_SUCCESS - Success, value is returned.
4431 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4432 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4433 + * for the board.
4434 + ***************************************************************************/
4435 +int BpGetAdslLedGpio( unsigned short *pusValue )
4436 +{
4437 + int nRet;
4438 +
4439 + if( g_pCurrentBp )
4440 + {
4441 + *pusValue = g_pCurrentBp->usGpioLedAdsl;
4442 +
4443 + if( g_pCurrentBp->usGpioLedAdsl != BP_NOT_DEFINED )
4444 + {
4445 + nRet = BP_SUCCESS;
4446 + }
4447 + else
4448 + {
4449 + nRet = BP_VALUE_NOT_DEFINED;
4450 + }
4451 + }
4452 + else
4453 + {
4454 + *pusValue = BP_NOT_DEFINED;
4455 + nRet = BP_BOARD_ID_NOT_SET;
4456 + }
4457 +
4458 + return( nRet );
4459 +} /* BpGetAdslLedGpio */
4460 +
4461 +/**************************************************************************
4462 + * Name : BpGetAdslFailLedGpio
4463 + *
4464 + * Description: This function returns the GPIO pin assignment for the ADSL
4465 + * LED that is used when there is a DSL connection failure.
4466 + *
4467 + * Parameters : [OUT] pusValue - Address of short word that the ADSL LED
4468 + * GPIO pin is returned in.
4469 + *
4470 + * Returns : BP_SUCCESS - Success, value is returned.
4471 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4472 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4473 + * for the board.
4474 + ***************************************************************************/
4475 +int BpGetAdslFailLedGpio( unsigned short *pusValue )
4476 +{
4477 + int nRet;
4478 +
4479 + if( g_pCurrentBp )
4480 + {
4481 + *pusValue = g_pCurrentBp->usGpioLedAdslFail;
4482 +
4483 + if( g_pCurrentBp->usGpioLedAdslFail != BP_NOT_DEFINED )
4484 + {
4485 + nRet = BP_SUCCESS;
4486 + }
4487 + else
4488 + {
4489 + nRet = BP_VALUE_NOT_DEFINED;
4490 + }
4491 + }
4492 + else
4493 + {
4494 + *pusValue = BP_NOT_DEFINED;
4495 + nRet = BP_BOARD_ID_NOT_SET;
4496 + }
4497 +
4498 + return( nRet );
4499 +} /* BpGetAdslFailLedGpio */
4500 +
4501 +/**************************************************************************
4502 + * Name : BpGetWirelessLedGpio
4503 + *
4504 + * Description: This function returns the GPIO pin assignment for the Wireless
4505 + * LED.
4506 + *
4507 + * Parameters : [OUT] pusValue - Address of short word that the Wireless LED
4508 + * GPIO pin is returned in.
4509 + *
4510 + * Returns : BP_SUCCESS - Success, value is returned.
4511 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4512 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4513 + * for the board.
4514 + ***************************************************************************/
4515 +int BpGetWirelessLedGpio( unsigned short *pusValue )
4516 +{
4517 + int nRet;
4518 +
4519 + if( g_pCurrentBp )
4520 + {
4521 + *pusValue = g_pCurrentBp->usGpioLedWireless;
4522 +
4523 + if( g_pCurrentBp->usGpioLedWireless != BP_NOT_DEFINED )
4524 + {
4525 + nRet = BP_SUCCESS;
4526 + }
4527 + else
4528 + {
4529 + nRet = BP_VALUE_NOT_DEFINED;
4530 + }
4531 + }
4532 + else
4533 + {
4534 + *pusValue = BP_NOT_DEFINED;
4535 + nRet = BP_BOARD_ID_NOT_SET;
4536 + }
4537 +
4538 + return( nRet );
4539 +} /* BpGetWirelessLedGpio */
4540 +
4541 +/**************************************************************************
4542 + * Name : BpGetWirelessAntInUse
4543 + *
4544 + * Description: This function returns the antennas in use for wireless
4545 + *
4546 + * Parameters : [OUT] pusValue - Address of short word that the Wireless Antenna
4547 + * is in use.
4548 + *
4549 + * Returns : BP_SUCCESS - Success, value is returned.
4550 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4551 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4552 + * for the board.
4553 + ***************************************************************************/
4554 +int BpGetWirelessAntInUse( unsigned short *pusValue )
4555 +{
4556 + int nRet;
4557 +
4558 + if( g_pCurrentBp )
4559 + {
4560 + *pusValue = g_pCurrentBp->usAntInUseWireless;
4561 +
4562 + if( g_pCurrentBp->usAntInUseWireless != BP_NOT_DEFINED )
4563 + {
4564 + nRet = BP_SUCCESS;
4565 + }
4566 + else
4567 + {
4568 + nRet = BP_VALUE_NOT_DEFINED;
4569 + }
4570 + }
4571 + else
4572 + {
4573 + *pusValue = BP_NOT_DEFINED;
4574 + nRet = BP_BOARD_ID_NOT_SET;
4575 + }
4576 +
4577 + return( nRet );
4578 +} /* BpGetWirelessAntInUse */
4579 +
4580 +/**************************************************************************
4581 + * Name : BpGetWirelessSesBtnGpio
4582 + *
4583 + * Description: This function returns the GPIO pin assignment for the Wireless
4584 + * Ses Button.
4585 + *
4586 + * Parameters : [OUT] pusValue - Address of short word that the Wireless LED
4587 + * GPIO pin is returned in.
4588 + *
4589 + * Returns : BP_SUCCESS - Success, value is returned.
4590 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4591 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4592 + * for the board.
4593 + ***************************************************************************/
4594 +int BpGetWirelessSesBtnGpio( unsigned short *pusValue )
4595 +{
4596 + int nRet;
4597 +
4598 + if( g_pCurrentBp )
4599 + {
4600 + *pusValue = g_pCurrentBp->usGpioSesBtnWireless;
4601 +
4602 + if( g_pCurrentBp->usGpioSesBtnWireless != BP_NOT_DEFINED )
4603 + {
4604 + nRet = BP_SUCCESS;
4605 + }
4606 + else
4607 + {
4608 + nRet = BP_VALUE_NOT_DEFINED;
4609 + }
4610 + }
4611 + else
4612 + {
4613 + *pusValue = BP_NOT_DEFINED;
4614 + nRet = BP_BOARD_ID_NOT_SET;
4615 + }
4616 +
4617 + return( nRet );
4618 +} /* BpGetWirelessSesBtnGpio */
4619 +
4620 +/**************************************************************************
4621 + * Name : BpGetWirelessSesExtIntr
4622 + *
4623 + * Description: This function returns the external interrupt number for the
4624 + * Wireless Ses Button.
4625 + *
4626 + * Parameters : [OUT] pusValue - Address of short word that the Wireless Ses
4627 + * external interrup is returned in.
4628 + *
4629 + * Returns : BP_SUCCESS - Success, value is returned.
4630 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4631 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4632 + * for the board.
4633 + ***************************************************************************/
4634 +int BpGetWirelessSesExtIntr( unsigned short *pusValue )
4635 +{
4636 + int nRet;
4637 +
4638 + if( g_pCurrentBp )
4639 + {
4640 + *pusValue = g_pCurrentBp->usExtIntrSesBtnWireless;
4641 +
4642 + if( g_pCurrentBp->usExtIntrSesBtnWireless != BP_NOT_DEFINED )
4643 + {
4644 + nRet = BP_SUCCESS;
4645 + }
4646 + else
4647 + {
4648 + nRet = BP_VALUE_NOT_DEFINED;
4649 + }
4650 + }
4651 + else
4652 + {
4653 + *pusValue = BP_NOT_DEFINED;
4654 + nRet = BP_BOARD_ID_NOT_SET;
4655 + }
4656 +
4657 + return( nRet );
4658 +
4659 +} /* BpGetWirelessSesExtIntr */
4660 +
4661 +/**************************************************************************
4662 + * Name : BpGetWirelessSesLedGpio
4663 + *
4664 + * Description: This function returns the GPIO pin assignment for the Wireless
4665 + * Ses Led.
4666 + *
4667 + * Parameters : [OUT] pusValue - Address of short word that the Wireless Ses
4668 + * Led GPIO pin is returned in.
4669 + *
4670 + * Returns : BP_SUCCESS - Success, value is returned.
4671 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4672 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4673 + * for the board.
4674 + ***************************************************************************/
4675 +int BpGetWirelessSesLedGpio( unsigned short *pusValue )
4676 +{
4677 + int nRet;
4678 +
4679 + if( g_pCurrentBp )
4680 + {
4681 + *pusValue = g_pCurrentBp->usGpioLedSesWireless;
4682 +
4683 + if( g_pCurrentBp->usGpioLedSesWireless != BP_NOT_DEFINED )
4684 + {
4685 + nRet = BP_SUCCESS;
4686 + }
4687 + else
4688 + {
4689 + nRet = BP_VALUE_NOT_DEFINED;
4690 + }
4691 + }
4692 + else
4693 + {
4694 + *pusValue = BP_NOT_DEFINED;
4695 + nRet = BP_BOARD_ID_NOT_SET;
4696 + }
4697 +
4698 + return( nRet );
4699 +
4700 +} /* BpGetWirelessSesLedGpio */
4701 +
4702 +/**************************************************************************
4703 + * Name : BpGetUsbLedGpio
4704 + *
4705 + * Description: This function returns the GPIO pin assignment for the USB
4706 + * LED.
4707 + *
4708 + * Parameters : [OUT] pusValue - Address of short word that the USB LED
4709 + * GPIO pin is returned in.
4710 + *
4711 + * Returns : BP_SUCCESS - Success, value is returned.
4712 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4713 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4714 + * for the board.
4715 + ***************************************************************************/
4716 +int BpGetUsbLedGpio( unsigned short *pusValue )
4717 +{
4718 + int nRet;
4719 +
4720 + if( g_pCurrentBp )
4721 + {
4722 + *pusValue = g_pCurrentBp->usGpioLedUsb;
4723 +
4724 + if( g_pCurrentBp->usGpioLedUsb != BP_NOT_DEFINED )
4725 + {
4726 + nRet = BP_SUCCESS;
4727 + }
4728 + else
4729 + {
4730 + nRet = BP_VALUE_NOT_DEFINED;
4731 + }
4732 + }
4733 + else
4734 + {
4735 + *pusValue = BP_NOT_DEFINED;
4736 + nRet = BP_BOARD_ID_NOT_SET;
4737 + }
4738 +
4739 + return( nRet );
4740 +} /* BpGetUsbLedGpio */
4741 +
4742 +/**************************************************************************
4743 + * Name : BpGetHpnaLedGpio
4744 + *
4745 + * Description: This function returns the GPIO pin assignment for the HPNA
4746 + * LED.
4747 + *
4748 + * Parameters : [OUT] pusValue - Address of short word that the HPNA LED
4749 + * GPIO pin is returned in.
4750 + *
4751 + * Returns : BP_SUCCESS - Success, value is returned.
4752 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4753 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4754 + * for the board.
4755 + ***************************************************************************/
4756 +int BpGetHpnaLedGpio( unsigned short *pusValue )
4757 +{
4758 + int nRet;
4759 +
4760 + if( g_pCurrentBp )
4761 + {
4762 + *pusValue = g_pCurrentBp->usGpioLedHpna;
4763 +
4764 + if( g_pCurrentBp->usGpioLedHpna != BP_NOT_DEFINED )
4765 + {
4766 + nRet = BP_SUCCESS;
4767 + }
4768 + else
4769 + {
4770 + nRet = BP_VALUE_NOT_DEFINED;
4771 + }
4772 + }
4773 + else
4774 + {
4775 + *pusValue = BP_NOT_DEFINED;
4776 + nRet = BP_BOARD_ID_NOT_SET;
4777 + }
4778 +
4779 + return( nRet );
4780 +} /* BpGetHpnaLedGpio */
4781 +
4782 +/**************************************************************************
4783 + * Name : BpGetWanDataLedGpio
4784 + *
4785 + * Description: This function returns the GPIO pin assignment for the WAN Data
4786 + * LED.
4787 + *
4788 + * Parameters : [OUT] pusValue - Address of short word that the WAN Data LED
4789 + * GPIO pin is returned in.
4790 + *
4791 + * Returns : BP_SUCCESS - Success, value is returned.
4792 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4793 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4794 + * for the board.
4795 + ***************************************************************************/
4796 +int BpGetWanDataLedGpio( unsigned short *pusValue )
4797 +{
4798 + int nRet;
4799 +
4800 + if( g_pCurrentBp )
4801 + {
4802 + *pusValue = g_pCurrentBp->usGpioLedWanData;
4803 +
4804 + if( g_pCurrentBp->usGpioLedWanData != BP_NOT_DEFINED )
4805 + {
4806 + nRet = BP_SUCCESS;
4807 + }
4808 + else
4809 + {
4810 + nRet = BP_VALUE_NOT_DEFINED;
4811 + }
4812 + }
4813 + else
4814 + {
4815 + *pusValue = BP_NOT_DEFINED;
4816 + nRet = BP_BOARD_ID_NOT_SET;
4817 + }
4818 +
4819 + return( nRet );
4820 +} /* BpGetWanDataLedGpio */
4821 +
4822 +/**************************************************************************
4823 + * Name : BpGetPppLedGpio
4824 + *
4825 + * Description: This function returns the GPIO pin assignment for the PPP
4826 + * LED.
4827 + *
4828 + * Parameters : [OUT] pusValue - Address of short word that the PPP LED
4829 + * GPIO pin is returned in.
4830 + *
4831 + * Returns : BP_SUCCESS - Success, value is returned.
4832 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4833 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4834 + * for the board.
4835 + ***************************************************************************/
4836 +int BpGetPppLedGpio( unsigned short *pusValue )
4837 +{
4838 + int nRet;
4839 +
4840 + if( g_pCurrentBp )
4841 + {
4842 + *pusValue = g_pCurrentBp->usGpioLedPpp;
4843 +
4844 + if( g_pCurrentBp->usGpioLedPpp != BP_NOT_DEFINED )
4845 + {
4846 + nRet = BP_SUCCESS;
4847 + }
4848 + else
4849 + {
4850 + nRet = BP_VALUE_NOT_DEFINED;
4851 + }
4852 + }
4853 + else
4854 + {
4855 + *pusValue = BP_NOT_DEFINED;
4856 + nRet = BP_BOARD_ID_NOT_SET;
4857 + }
4858 +
4859 + return( nRet );
4860 +} /* BpGetPppLedGpio */
4861 +
4862 +/**************************************************************************
4863 + * Name : BpGetPppFailLedGpio
4864 + *
4865 + * Description: This function returns the GPIO pin assignment for the PPP
4866 + * LED that is used when there is a PPP connection failure.
4867 + *
4868 + * Parameters : [OUT] pusValue - Address of short word that the PPP LED
4869 + * GPIO pin is returned in.
4870 + *
4871 + * Returns : BP_SUCCESS - Success, value is returned.
4872 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4873 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4874 + * for the board.
4875 + ***************************************************************************/
4876 +int BpGetPppFailLedGpio( unsigned short *pusValue )
4877 +{
4878 + int nRet;
4879 +
4880 + if( g_pCurrentBp )
4881 + {
4882 + *pusValue = g_pCurrentBp->usGpioLedPppFail;
4883 +
4884 + if( g_pCurrentBp->usGpioLedPppFail != BP_NOT_DEFINED )
4885 + {
4886 + nRet = BP_SUCCESS;
4887 + }
4888 + else
4889 + {
4890 + nRet = BP_VALUE_NOT_DEFINED;
4891 + }
4892 + }
4893 + else
4894 + {
4895 + *pusValue = BP_NOT_DEFINED;
4896 + nRet = BP_BOARD_ID_NOT_SET;
4897 + }
4898 +
4899 + return( nRet );
4900 +} /* BpGetPppFailLedGpio */
4901 +
4902 +/**************************************************************************
4903 + * Name : BpGetBootloaderPowerOnLedGpio
4904 + *
4905 + * Description: This function returns the GPIO pin assignment for the power
4906 + * on LED that is set by the bootloader.
4907 + *
4908 + * Parameters : [OUT] pusValue - Address of short word that the alarm LED
4909 + * GPIO pin is returned in.
4910 + *
4911 + * Returns : BP_SUCCESS - Success, value is returned.
4912 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4913 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4914 + * for the board.
4915 + ***************************************************************************/
4916 +int BpGetBootloaderPowerOnLedGpio( unsigned short *pusValue )
4917 +{
4918 + int nRet;
4919 +
4920 + if( g_pCurrentBp )
4921 + {
4922 + *pusValue = g_pCurrentBp->usGpioLedBlPowerOn;
4923 +
4924 + if( g_pCurrentBp->usGpioLedBlPowerOn != BP_NOT_DEFINED )
4925 + {
4926 + nRet = BP_SUCCESS;
4927 + }
4928 + else
4929 + {
4930 + nRet = BP_VALUE_NOT_DEFINED;
4931 + }
4932 + }
4933 + else
4934 + {
4935 + *pusValue = BP_NOT_DEFINED;
4936 + nRet = BP_BOARD_ID_NOT_SET;
4937 + }
4938 +
4939 + return( nRet );
4940 +} /* BpGetBootloaderPowerOn */
4941 +
4942 +/**************************************************************************
4943 + * Name : BpGetBootloaderAlarmLedGpio
4944 + *
4945 + * Description: This function returns the GPIO pin assignment for the alarm
4946 + * LED that is set by the bootloader.
4947 + *
4948 + * Parameters : [OUT] pusValue - Address of short word that the alarm LED
4949 + * GPIO pin is returned in.
4950 + *
4951 + * Returns : BP_SUCCESS - Success, value is returned.
4952 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4953 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4954 + * for the board.
4955 + ***************************************************************************/
4956 +int BpGetBootloaderAlarmLedGpio( unsigned short *pusValue )
4957 +{
4958 + int nRet;
4959 +
4960 + if( g_pCurrentBp )
4961 + {
4962 + *pusValue = g_pCurrentBp->usGpioLedBlAlarm;
4963 +
4964 + if( g_pCurrentBp->usGpioLedBlAlarm != BP_NOT_DEFINED )
4965 + {
4966 + nRet = BP_SUCCESS;
4967 + }
4968 + else
4969 + {
4970 + nRet = BP_VALUE_NOT_DEFINED;
4971 + }
4972 + }
4973 + else
4974 + {
4975 + *pusValue = BP_NOT_DEFINED;
4976 + nRet = BP_BOARD_ID_NOT_SET;
4977 + }
4978 +
4979 + return( nRet );
4980 +} /* BpGetBootloaderAlarmLedGpio */
4981 +
4982 +/**************************************************************************
4983 + * Name : BpGetBootloaderResetCfgLedGpio
4984 + *
4985 + * Description: This function returns the GPIO pin assignment for the reset
4986 + * configuration LED that is set by the bootloader.
4987 + *
4988 + * Parameters : [OUT] pusValue - Address of short word that the reset
4989 + * configuration LED GPIO pin is returned in.
4990 + *
4991 + * Returns : BP_SUCCESS - Success, value is returned.
4992 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
4993 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
4994 + * for the board.
4995 + ***************************************************************************/
4996 +int BpGetBootloaderResetCfgLedGpio( unsigned short *pusValue )
4997 +{
4998 + int nRet;
4999 +
5000 + if( g_pCurrentBp )
5001 + {
5002 + *pusValue = g_pCurrentBp->usGpioLedBlResetCfg;
5003 +
5004 + if( g_pCurrentBp->usGpioLedBlResetCfg != BP_NOT_DEFINED )
5005 + {
5006 + nRet = BP_SUCCESS;
5007 + }
5008 + else
5009 + {
5010 + nRet = BP_VALUE_NOT_DEFINED;
5011 + }
5012 + }
5013 + else
5014 + {
5015 + *pusValue = BP_NOT_DEFINED;
5016 + nRet = BP_BOARD_ID_NOT_SET;
5017 + }
5018 +
5019 + return( nRet );
5020 +} /* BpGetBootloaderResetCfgLedGpio */
5021 +
5022 +/**************************************************************************
5023 + * Name : BpGetBootloaderStopLedGpio
5024 + *
5025 + * Description: This function returns the GPIO pin assignment for the break
5026 + * into bootloader LED that is set by the bootloader.
5027 + *
5028 + * Parameters : [OUT] pusValue - Address of short word that the break into
5029 + * bootloader LED GPIO pin is returned in.
5030 + *
5031 + * Returns : BP_SUCCESS - Success, value is returned.
5032 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5033 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5034 + * for the board.
5035 + ***************************************************************************/
5036 +int BpGetBootloaderStopLedGpio( unsigned short *pusValue )
5037 +{
5038 + int nRet;
5039 +
5040 + if( g_pCurrentBp )
5041 + {
5042 + *pusValue = g_pCurrentBp->usGpioLedBlStop;
5043 +
5044 + if( g_pCurrentBp->usGpioLedBlStop != BP_NOT_DEFINED )
5045 + {
5046 + nRet = BP_SUCCESS;
5047 + }
5048 + else
5049 + {
5050 + nRet = BP_VALUE_NOT_DEFINED;
5051 + }
5052 + }
5053 + else
5054 + {
5055 + *pusValue = BP_NOT_DEFINED;
5056 + nRet = BP_BOARD_ID_NOT_SET;
5057 + }
5058 +
5059 + return( nRet );
5060 +} /* BpGetBootloaderStopLedGpio */
5061 +
5062 +/**************************************************************************
5063 + * Name : BpGetVoipLedGpio
5064 + *
5065 + * Description: This function returns the GPIO pin assignment for the VOIP
5066 + * LED.
5067 + *
5068 + * Parameters : [OUT] pusValue - Address of short word that the VOIP LED
5069 + * GPIO pin is returned in.
5070 + *
5071 + * Returns : BP_SUCCESS - Success, value is returned.
5072 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5073 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5074 + * for the board.
5075 + *
5076 + * Note : The VoIP structure would allow for having one LED per DSP
5077 + * however, the board initialization function assumes only one
5078 + * LED per functionality (ie one LED for VoIP). Therefore in
5079 + * order to keep this tidy and simple we do not make usage of the
5080 + * one-LED-per-DSP function. Instead, we assume that the LED for
5081 + * VoIP is unique and associated with DSP 0 (always present on
5082 + * any VoIP platform). If changing this to a LED-per-DSP function
5083 + * then one need to update the board initialization driver in
5084 + * bcmdrivers\opensource\char\board\bcm963xx\impl1
5085 + ***************************************************************************/
5086 +int BpGetVoipLedGpio( unsigned short *pusValue )
5087 +{
5088 + int nRet;
5089 +
5090 + if( g_pCurrentBp )
5091 + {
5092 + VOIP_DSP_INFO *pDspInfo = BpGetVoipDspConfig( 0 );
5093 +
5094 + if( pDspInfo )
5095 + {
5096 + *pusValue = pDspInfo->usGpioLedVoip;
5097 +
5098 + if( *pusValue != BP_NOT_DEFINED )
5099 + {
5100 + nRet = BP_SUCCESS;
5101 + }
5102 + else
5103 + {
5104 + nRet = BP_VALUE_NOT_DEFINED;
5105 + }
5106 + }
5107 + else
5108 + {
5109 + *pusValue = BP_NOT_DEFINED;
5110 + nRet = BP_BOARD_ID_NOT_FOUND;
5111 + }
5112 + }
5113 + else
5114 + {
5115 + *pusValue = BP_NOT_DEFINED;
5116 + nRet = BP_BOARD_ID_NOT_SET;
5117 + }
5118 +
5119 + return( nRet );
5120 +} /* BpGetVoipLedGpio */
5121 +
5122 +/**************************************************************************
5123 + * Name : BpGetWirelessExtIntr
5124 + *
5125 + * Description: This function returns the Wireless external interrupt number.
5126 + *
5127 + * Parameters : [OUT] pulValue - Address of short word that the wireless
5128 + * external interrupt number is returned in.
5129 + *
5130 + * Returns : BP_SUCCESS - Success, value is returned.
5131 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5132 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5133 + * for the board.
5134 + ***************************************************************************/
5135 +int BpGetWirelessExtIntr( unsigned long *pulValue )
5136 +{
5137 + int nRet;
5138 +
5139 + if( g_pCurrentBp )
5140 + {
5141 + *pulValue = g_pCurrentBp->usExtIntrWireless;
5142 +
5143 + if( g_pCurrentBp->usExtIntrWireless != BP_NOT_DEFINED )
5144 + {
5145 + nRet = BP_SUCCESS;
5146 + }
5147 + else
5148 + {
5149 + nRet = BP_VALUE_NOT_DEFINED;
5150 + }
5151 + }
5152 + else
5153 + {
5154 + *pulValue = BP_NOT_DEFINED;
5155 + nRet = BP_BOARD_ID_NOT_SET;
5156 + }
5157 +
5158 + return( nRet );
5159 +} /* BpGetWirelessExtIntr */
5160 +
5161 +/**************************************************************************
5162 + * Name : BpGetAdslDyingGaspExtIntr
5163 + *
5164 + * Description: This function returns the ADSL Dying Gasp external interrupt
5165 + * number.
5166 + *
5167 + * Parameters : [OUT] pulValue - Address of short word that the ADSL Dying Gasp
5168 + * external interrupt number is returned in.
5169 + *
5170 + * Returns : BP_SUCCESS - Success, value is returned.
5171 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5172 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5173 + * for the board.
5174 + ***************************************************************************/
5175 +int BpGetAdslDyingGaspExtIntr( unsigned long *pulValue )
5176 +{
5177 + int nRet;
5178 +
5179 + if( g_pCurrentBp )
5180 + {
5181 + *pulValue = g_pCurrentBp->usExtIntrAdslDyingGasp;
5182 +
5183 + if( g_pCurrentBp->usExtIntrAdslDyingGasp != BP_NOT_DEFINED )
5184 + {
5185 + nRet = BP_SUCCESS;
5186 + }
5187 + else
5188 + {
5189 + nRet = BP_VALUE_NOT_DEFINED;
5190 + }
5191 + }
5192 + else
5193 + {
5194 + *pulValue = BP_NOT_DEFINED;
5195 + nRet = BP_BOARD_ID_NOT_SET;
5196 + }
5197 +
5198 + return( nRet );
5199 +} /* BpGetAdslDyingGaspExtIntr */
5200 +
5201 +/**************************************************************************
5202 + * Name : BpGetVoipExtIntr
5203 + *
5204 + * Description: This function returns the VOIP external interrupt number.
5205 + *
5206 + * Parameters : [OUT] pulValue - Address of short word that the VOIP
5207 + * external interrupt number is returned in.
5208 + * [IN] dspNum - Address of the DSP to query.
5209 + *
5210 + * Returns : BP_SUCCESS - Success, value is returned.
5211 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5212 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5213 + * for the board.
5214 + ***************************************************************************/
5215 +int BpGetVoipExtIntr( unsigned char dspNum, unsigned long *pulValue )
5216 +{
5217 + int nRet;
5218 +
5219 + if( g_pCurrentBp )
5220 + {
5221 + VOIP_DSP_INFO *pDspInfo = BpGetVoipDspConfig( dspNum );
5222 +
5223 + if( pDspInfo )
5224 + {
5225 + *pulValue = pDspInfo->usExtIntrVoip;
5226 +
5227 + if( *pulValue != BP_NOT_DEFINED )
5228 + {
5229 + nRet = BP_SUCCESS;
5230 + }
5231 + else
5232 + {
5233 + nRet = BP_VALUE_NOT_DEFINED;
5234 + }
5235 + }
5236 + else
5237 + {
5238 + *pulValue = BP_NOT_DEFINED;
5239 + nRet = BP_BOARD_ID_NOT_FOUND;
5240 + }
5241 + }
5242 + else
5243 + {
5244 + *pulValue = BP_NOT_DEFINED;
5245 + nRet = BP_BOARD_ID_NOT_SET;
5246 + }
5247 +
5248 + return( nRet );
5249 +} /* BpGetVoipExtIntr */
5250 +
5251 +/**************************************************************************
5252 + * Name : BpGetHpnaExtIntr
5253 + *
5254 + * Description: This function returns the HPNA external interrupt number.
5255 + *
5256 + * Parameters : [OUT] pulValue - Address of short word that the HPNA
5257 + * external interrupt number is returned in.
5258 + *
5259 + * Returns : BP_SUCCESS - Success, value is returned.
5260 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5261 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5262 + * for the board.
5263 + ***************************************************************************/
5264 +int BpGetHpnaExtIntr( unsigned long *pulValue )
5265 +{
5266 + int nRet;
5267 +
5268 + if( g_pCurrentBp )
5269 + {
5270 + *pulValue = g_pCurrentBp->usExtIntrHpna;
5271 +
5272 + if( g_pCurrentBp->usExtIntrHpna != BP_NOT_DEFINED )
5273 + {
5274 + nRet = BP_SUCCESS;
5275 + }
5276 + else
5277 + {
5278 + nRet = BP_VALUE_NOT_DEFINED;
5279 + }
5280 + }
5281 + else
5282 + {
5283 + *pulValue = BP_NOT_DEFINED;
5284 + nRet = BP_BOARD_ID_NOT_SET;
5285 + }
5286 +
5287 + return( nRet );
5288 +} /* BpGetHpnaExtIntr */
5289 +
5290 +/**************************************************************************
5291 + * Name : BpGetHpnaChipSelect
5292 + *
5293 + * Description: This function returns the HPNA chip select number.
5294 + *
5295 + * Parameters : [OUT] pulValue - Address of short word that the HPNA
5296 + * chip select number is returned in.
5297 + *
5298 + * Returns : BP_SUCCESS - Success, value is returned.
5299 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5300 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5301 + * for the board.
5302 + ***************************************************************************/
5303 +int BpGetHpnaChipSelect( unsigned long *pulValue )
5304 +{
5305 + int nRet;
5306 +
5307 + if( g_pCurrentBp )
5308 + {
5309 + *pulValue = g_pCurrentBp->usCsHpna;
5310 +
5311 + if( g_pCurrentBp->usCsHpna != BP_NOT_DEFINED )
5312 + {
5313 + nRet = BP_SUCCESS;
5314 + }
5315 + else
5316 + {
5317 + nRet = BP_VALUE_NOT_DEFINED;
5318 + }
5319 + }
5320 + else
5321 + {
5322 + *pulValue = BP_NOT_DEFINED;
5323 + nRet = BP_BOARD_ID_NOT_SET;
5324 + }
5325 +
5326 + return( nRet );
5327 +} /* BpGetHpnaChipSelect */
5328 +
5329 +/**************************************************************************
5330 + * Name : BpGetVoipChipSelect
5331 + *
5332 + * Description: This function returns the VOIP chip select number.
5333 + *
5334 + * Parameters : [OUT] pulValue - Address of short word that the VOIP
5335 + * chip select number is returned in.
5336 + * [IN] dspNum - Address of the DSP to query.
5337 + *
5338 + * Returns : BP_SUCCESS - Success, value is returned.
5339 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5340 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5341 + * for the board.
5342 + ***************************************************************************/
5343 +int BpGetVoipChipSelect( unsigned char dspNum, unsigned long *pulValue )
5344 +{
5345 + int nRet;
5346 +
5347 + if( g_pCurrentBp )
5348 + {
5349 + VOIP_DSP_INFO *pDspInfo = BpGetVoipDspConfig( dspNum );
5350 +
5351 + if( pDspInfo )
5352 + {
5353 + *pulValue = pDspInfo->usCsVoip;
5354 +
5355 + if( *pulValue != BP_NOT_DEFINED )
5356 + {
5357 + nRet = BP_SUCCESS;
5358 + }
5359 + else
5360 + {
5361 + nRet = BP_VALUE_NOT_DEFINED;
5362 + }
5363 + }
5364 + else
5365 + {
5366 + *pulValue = BP_NOT_DEFINED;
5367 + nRet = BP_BOARD_ID_NOT_FOUND;
5368 + }
5369 + }
5370 + else
5371 + {
5372 + *pulValue = BP_NOT_DEFINED;
5373 + nRet = BP_BOARD_ID_NOT_SET;
5374 + }
5375 +
5376 + return( nRet );
5377 +} /* BpGetVoipChipSelect */
5378 +
5379 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/boardparms.h linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/boardparms.h
5380 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/boardparms.h 1970-01-01 01:00:00.000000000 +0100
5381 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/boardparms.h 2006-07-07 22:16:11.000000000 +0200
5382 @@ -0,0 +1,766 @@
5383 +/*
5384 +<:copyright-gpl
5385 +
5386 + Copyright 2003 Broadcom Corp. All Rights Reserved.
5387 +
5388 + This program is free software; you can distribute it and/or modify it
5389 + under the terms of the GNU General Public License (Version 2) as
5390 + published by the Free Software Foundation.
5391 +
5392 + This program is distributed in the hope it will be useful, but WITHOUT
5393 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
5394 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
5395 + for more details.
5396 +
5397 + You should have received a copy of the GNU General Public License along
5398 + with this program; if not, write to the Free Software Foundation, Inc.,
5399 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
5400 +
5401 +:>
5402 +*/
5403 +/**************************************************************************
5404 + * File Name : boardparms.h
5405 + *
5406 + * Description: This file contains definitions and function prototypes for
5407 + * the BCM63xx board parameter access functions.
5408 + *
5409 + * Updates : 07/14/2003 Created.
5410 + ***************************************************************************/
5411 +
5412 +#if !defined(_BOARDPARMS_H)
5413 +#define _BOARDPARMS_H
5414 +
5415 +#if __cplusplus
5416 +extern "C" {
5417 +#endif
5418 +
5419 +/* Return codes. */
5420 +#define BP_SUCCESS 0
5421 +#define BP_BOARD_ID_NOT_FOUND 1
5422 +#define BP_VALUE_NOT_DEFINED 2
5423 +#define BP_BOARD_ID_NOT_SET 3
5424 +
5425 +/* Values for BpGetSdramSize. */
5426 +#define BP_MEMORY_8MB_1_CHIP 0
5427 +#define BP_MEMORY_16MB_1_CHIP 1
5428 +#define BP_MEMORY_32MB_1_CHIP 2
5429 +#define BP_MEMORY_64MB_2_CHIP 3
5430 +#define BP_MEMORY_32MB_2_CHIP 4
5431 +#define BP_MEMORY_16MB_2_CHIP 5
5432 +
5433 +/* Values for EthernetMacInfo PhyType. */
5434 +#define BP_ENET_NO_PHY 0
5435 +#define BP_ENET_INTERNAL_PHY 1
5436 +#define BP_ENET_EXTERNAL_PHY 2
5437 +#define BP_ENET_EXTERNAL_SWITCH 3
5438 +
5439 +/* Values for EthernetMacInfo Configuration type. */
5440 +#define BP_ENET_CONFIG_MDIO 0 /* Internal PHY, External PHY, Switch+(no GPIO, no SPI, no MDIO Pseudo phy */
5441 +#define BP_ENET_CONFIG_GPIO 1 /* Bcm96345GW board + Bcm5325M/E */
5442 +#define BP_ENET_CONFIG_MDIO_PSEUDO_PHY 2 /* Bcm96348GW board + Bcm5325E */
5443 +#define BP_ENET_CONFIG_SPI_SSB_0 3 /* Bcm96348GW board + Bcm5325M/E */
5444 +#define BP_ENET_CONFIG_SPI_SSB_1 4 /* Bcm96348GW board + Bcm5325M/E */
5445 +#define BP_ENET_CONFIG_SPI_SSB_2 5 /* Bcm96348GW board + Bcm5325M/E */
5446 +#define BP_ENET_CONFIG_SPI_SSB_3 6 /* Bcm96348GW board + Bcm5325M/E */
5447 +
5448 +/* Values for EthernetMacInfo Reverse MII. */
5449 +#define BP_ENET_NO_REVERSE_MII 0
5450 +#define BP_ENET_REVERSE_MII 1
5451 +
5452 +/* Values for VoIPDSPInfo DSPType. */
5453 +#define BP_VOIP_NO_DSP 0
5454 +#define BP_VOIP_DSP 1
5455 +
5456 +
5457 +/* Values for GPIO pin assignments (AH = Active High, AL = Active Low). */
5458 +#define BP_ACTIVE_MASK 0x8000
5459 +#define BP_ACTIVE_HIGH 0x0000
5460 +#define BP_ACTIVE_LOW 0x8000
5461 +#define BP_GPIO_0_AH (0 | BP_ACTIVE_HIGH)
5462 +#define BP_GPIO_0_AL (0 | BP_ACTIVE_LOW)
5463 +#define BP_GPIO_1_AH (1 | BP_ACTIVE_HIGH)
5464 +#define BP_GPIO_1_AL (1 | BP_ACTIVE_LOW)
5465 +#define BP_GPIO_2_AH (2 | BP_ACTIVE_HIGH)
5466 +#define BP_GPIO_2_AL (2 | BP_ACTIVE_LOW)
5467 +#define BP_GPIO_3_AH (3 | BP_ACTIVE_HIGH)
5468 +#define BP_GPIO_3_AL (3 | BP_ACTIVE_LOW)
5469 +#define BP_GPIO_4_AH (4 | BP_ACTIVE_HIGH)
5470 +#define BP_GPIO_4_AL (4 | BP_ACTIVE_LOW)
5471 +#define BP_GPIO_5_AH (5 | BP_ACTIVE_HIGH)
5472 +#define BP_GPIO_5_AL (5 | BP_ACTIVE_LOW)
5473 +#define BP_GPIO_6_AH (6 | BP_ACTIVE_HIGH)
5474 +#define BP_GPIO_6_AL (6 | BP_ACTIVE_LOW)
5475 +#define BP_GPIO_7_AH (7 | BP_ACTIVE_HIGH)
5476 +#define BP_GPIO_7_AL (7 | BP_ACTIVE_LOW)
5477 +#define BP_GPIO_8_AH (8 | BP_ACTIVE_HIGH)
5478 +#define BP_GPIO_8_AL (8 | BP_ACTIVE_LOW)
5479 +#define BP_GPIO_9_AH (9 | BP_ACTIVE_HIGH)
5480 +#define BP_GPIO_9_AL (9 | BP_ACTIVE_LOW)
5481 +#define BP_GPIO_10_AH (10 | BP_ACTIVE_HIGH)
5482 +#define BP_GPIO_10_AL (10 | BP_ACTIVE_LOW)
5483 +#define BP_GPIO_11_AH (11 | BP_ACTIVE_HIGH)
5484 +#define BP_GPIO_11_AL (11 | BP_ACTIVE_LOW)
5485 +#define BP_GPIO_12_AH (12 | BP_ACTIVE_HIGH)
5486 +#define BP_GPIO_12_AL (12 | BP_ACTIVE_LOW)
5487 +#define BP_GPIO_13_AH (13 | BP_ACTIVE_HIGH)
5488 +#define BP_GPIO_13_AL (13 | BP_ACTIVE_LOW)
5489 +#define BP_GPIO_14_AH (14 | BP_ACTIVE_HIGH)
5490 +#define BP_GPIO_14_AL (14 | BP_ACTIVE_LOW)
5491 +#define BP_GPIO_15_AH (15 | BP_ACTIVE_HIGH)
5492 +#define BP_GPIO_15_AL (15 | BP_ACTIVE_LOW)
5493 +#define BP_GPIO_16_AH (16 | BP_ACTIVE_HIGH)
5494 +#define BP_GPIO_16_AL (16 | BP_ACTIVE_LOW)
5495 +#define BP_GPIO_17_AH (17 | BP_ACTIVE_HIGH)
5496 +#define BP_GPIO_17_AL (17 | BP_ACTIVE_LOW)
5497 +#define BP_GPIO_18_AH (18 | BP_ACTIVE_HIGH)
5498 +#define BP_GPIO_18_AL (18 | BP_ACTIVE_LOW)
5499 +#define BP_GPIO_19_AH (19 | BP_ACTIVE_HIGH)
5500 +#define BP_GPIO_19_AL (19 | BP_ACTIVE_LOW)
5501 +#define BP_GPIO_20_AH (20 | BP_ACTIVE_HIGH)
5502 +#define BP_GPIO_20_AL (20 | BP_ACTIVE_LOW)
5503 +#define BP_GPIO_21_AH (21 | BP_ACTIVE_HIGH)
5504 +#define BP_GPIO_21_AL (21 | BP_ACTIVE_LOW)
5505 +#define BP_GPIO_22_AH (22 | BP_ACTIVE_HIGH)
5506 +#define BP_GPIO_22_AL (22 | BP_ACTIVE_LOW)
5507 +#define BP_GPIO_23_AH (23 | BP_ACTIVE_HIGH)
5508 +#define BP_GPIO_23_AL (23 | BP_ACTIVE_LOW)
5509 +#define BP_GPIO_24_AH (24 | BP_ACTIVE_HIGH)
5510 +#define BP_GPIO_24_AL (24 | BP_ACTIVE_LOW)
5511 +#define BP_GPIO_25_AH (25 | BP_ACTIVE_HIGH)
5512 +#define BP_GPIO_25_AL (25 | BP_ACTIVE_LOW)
5513 +#define BP_GPIO_26_AH (26 | BP_ACTIVE_HIGH)
5514 +#define BP_GPIO_26_AL (26 | BP_ACTIVE_LOW)
5515 +#define BP_GPIO_27_AH (27 | BP_ACTIVE_HIGH)
5516 +#define BP_GPIO_27_AL (27 | BP_ACTIVE_LOW)
5517 +#define BP_GPIO_28_AH (28 | BP_ACTIVE_HIGH)
5518 +#define BP_GPIO_28_AL (28 | BP_ACTIVE_LOW)
5519 +#define BP_GPIO_29_AH (29 | BP_ACTIVE_HIGH)
5520 +#define BP_GPIO_29_AL (29 | BP_ACTIVE_LOW)
5521 +#define BP_GPIO_30_AH (30 | BP_ACTIVE_HIGH)
5522 +#define BP_GPIO_30_AL (30 | BP_ACTIVE_LOW)
5523 +#define BP_GPIO_31_AH (31 | BP_ACTIVE_HIGH)
5524 +#define BP_GPIO_31_AL (31 | BP_ACTIVE_LOW)
5525 +#define BP_GPIO_32_AH (32 | BP_ACTIVE_HIGH)
5526 +#define BP_GPIO_32_AL (32 | BP_ACTIVE_LOW)
5527 +#define BP_GPIO_33_AH (33 | BP_ACTIVE_HIGH)
5528 +#define BP_GPIO_33_AL (33 | BP_ACTIVE_LOW)
5529 +#define BP_GPIO_34_AH (34 | BP_ACTIVE_HIGH)
5530 +#define BP_GPIO_34_AL (34 | BP_ACTIVE_LOW)
5531 +#define BP_GPIO_35_AH (35 | BP_ACTIVE_HIGH)
5532 +#define BP_GPIO_35_AL (35 | BP_ACTIVE_LOW)
5533 +#define BP_GPIO_36_AH (36 | BP_ACTIVE_HIGH)
5534 +#define BP_GPIO_36_AL (36 | BP_ACTIVE_LOW)
5535 +
5536 +/* Values for external interrupt assignments. */
5537 +#define BP_EXT_INTR_0 0
5538 +#define BP_EXT_INTR_1 1
5539 +#define BP_EXT_INTR_2 2
5540 +#define BP_EXT_INTR_3 3
5541 +
5542 +/* Values for chip select assignments. */
5543 +#define BP_CS_0 0
5544 +#define BP_CS_1 1
5545 +#define BP_CS_2 2
5546 +#define BP_CS_3 3
5547 +
5548 +/* Value for GPIO and external interrupt fields that are not used. */
5549 +#define BP_NOT_DEFINED 0xffff
5550 +#define BP_HW_DEFINED 0xfff0
5551 +#define BP_UNEQUIPPED 0xfff1
5552 +
5553 +/* Maximum size of the board id string. */
5554 +#define BP_BOARD_ID_LEN 16
5555 +
5556 +/* Maximum number of Ethernet MACs. */
5557 +#define BP_MAX_ENET_MACS 2
5558 +
5559 +/* Maximum number of VoIP DSPs. */
5560 +#define BP_MAX_VOIP_DSP 2
5561 +
5562 +/* Wireless Antenna Settings. */
5563 +#define BP_WLAN_ANT_MAIN 0
5564 +#define BP_WLAN_ANT_AUX 1
5565 +#define BP_WLAN_ANT_BOTH 3
5566 +
5567 +#if !defined(__ASSEMBLER__)
5568 +
5569 +/* Information about an Ethernet MAC. If ucPhyType is BP_ENET_NO_PHY,
5570 + * then the other fields are not valid.
5571 + */
5572 +typedef struct EthernetMacInfo
5573 +{
5574 + unsigned char ucPhyType; /* BP_ENET_xxx */
5575 + unsigned char ucPhyAddress; /* 0 to 31 */
5576 + unsigned short usGpioPhySpiSck; /* GPIO pin or not defined */
5577 + unsigned short usGpioPhySpiSs; /* GPIO pin or not defined */
5578 + unsigned short usGpioPhySpiMosi; /* GPIO pin or not defined */
5579 + unsigned short usGpioPhySpiMiso; /* GPIO pin or not defined */
5580 + unsigned short usGpioPhyReset; /* GPIO pin or not defined (96348LV) */
5581 + unsigned short numSwitchPorts; /* Number of PHY ports */
5582 + unsigned short usConfigType; /* Configuration type */
5583 + unsigned short usReverseMii; /* Reverse MII */
5584 +} ETHERNET_MAC_INFO, *PETHERNET_MAC_INFO;
5585 +
5586 +
5587 +/* Information about VoIP DSPs. If ucDspType is BP_VOIP_NO_DSP,
5588 + * then the other fields are not valid.
5589 + */
5590 +typedef struct VoIPDspInfo
5591 +{
5592 + unsigned char ucDspType;
5593 + unsigned char ucDspAddress;
5594 + unsigned short usExtIntrVoip;
5595 + unsigned short usGpioVoipReset;
5596 + unsigned short usGpioVoipIntr;
5597 + unsigned short usGpioLedVoip;
5598 + unsigned short usCsVoip;
5599 +
5600 +} VOIP_DSP_INFO;
5601 +
5602 +
5603 +/**************************************************************************
5604 + * Name : BpSetBoardId
5605 + *
5606 + * Description: This function find the BOARD_PARAMETERS structure for the
5607 + * specified board id string and assigns it to a global, static
5608 + * variable.
5609 + *
5610 + * Parameters : [IN] pszBoardId - Board id string that is saved into NVRAM.
5611 + *
5612 + * Returns : BP_SUCCESS - Success, value is returned.
5613 + * BP_BOARD_ID_NOT_FOUND - Error, board id input string does not
5614 + * have a board parameters configuration record.
5615 + ***************************************************************************/
5616 +int BpSetBoardId( char *pszBoardId );
5617 +
5618 +/**************************************************************************
5619 + * Name : BpGetBoardIds
5620 + *
5621 + * Description: This function returns all of the supported board id strings.
5622 + *
5623 + * Parameters : [OUT] pszBoardIds - Address of a buffer that the board id
5624 + * strings are returned in. Each id starts at BP_BOARD_ID_LEN
5625 + * boundary.
5626 + * [IN] nBoardIdsSize - Number of BP_BOARD_ID_LEN elements that
5627 + * were allocated in pszBoardIds.
5628 + *
5629 + * Returns : Number of board id strings returned.
5630 + ***************************************************************************/
5631 +int BpGetBoardIds( char *pszBoardIds, int nBoardIdsSize );
5632 +
5633 +/**************************************************************************
5634 + * Name : BpGetEthernetMacInfo
5635 + *
5636 + * Description: This function returns all of the supported board id strings.
5637 + *
5638 + * Parameters : [OUT] pEnetInfos - Address of an array of ETHERNET_MAC_INFO
5639 + * buffers.
5640 + * [IN] nNumEnetInfos - Number of ETHERNET_MAC_INFO elements that
5641 + * are pointed to by pEnetInfos.
5642 + *
5643 + * Returns : BP_SUCCESS - Success, value is returned.
5644 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5645 + ***************************************************************************/
5646 +int BpGetEthernetMacInfo( PETHERNET_MAC_INFO pEnetInfos, int nNumEnetInfos );
5647 +
5648 +/**************************************************************************
5649 + * Name : BpGetSdramSize
5650 + *
5651 + * Description: This function returns a constant that describees the board's
5652 + * SDRAM type and size.
5653 + *
5654 + * Parameters : [OUT] pulSdramSize - Address of short word that the SDRAM size
5655 + * is returned in.
5656 + *
5657 + * Returns : BP_SUCCESS - Success, value is returned.
5658 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5659 + ***************************************************************************/
5660 +int BpGetSdramSize( unsigned long *pulSdramSize );
5661 +
5662 +/**************************************************************************
5663 + * Name : BpGetPsiSize
5664 + *
5665 + * Description: This function returns the persistent storage size in K bytes.
5666 + *
5667 + * Parameters : [OUT] pulPsiSize - Address of short word that the persistent
5668 + * storage size is returned in.
5669 + *
5670 + * Returns : BP_SUCCESS - Success, value is returned.
5671 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5672 + ***************************************************************************/
5673 +int BpGetPsiSize( unsigned long *pulPsiSize );
5674 +
5675 +/**************************************************************************
5676 + * Name : BpGetRj11InnerOuterPairGpios
5677 + *
5678 + * Description: This function returns the GPIO pin assignments for changing
5679 + * between the RJ11 inner pair and RJ11 outer pair.
5680 + *
5681 + * Parameters : [OUT] pusInner - Address of short word that the RJ11 inner pair
5682 + * GPIO pin is returned in.
5683 + * [OUT] pusOuter - Address of short word that the RJ11 outer pair
5684 + * GPIO pin is returned in.
5685 + *
5686 + * Returns : BP_SUCCESS - Success, values are returned.
5687 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5688 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5689 + * for the board.
5690 + ***************************************************************************/
5691 +int BpGetRj11InnerOuterPairGpios( unsigned short *pusInner,
5692 + unsigned short *pusOuter );
5693 +
5694 +/**************************************************************************
5695 + * Name : BpGetPressAndHoldResetGpio
5696 + *
5697 + * Description: This function returns the GPIO pin assignment for the press
5698 + * and hold reset button.
5699 + *
5700 + * Parameters : [OUT] pusValue - Address of short word that the press and hold
5701 + * reset button GPIO pin is returned in.
5702 + *
5703 + * Returns : BP_SUCCESS - Success, value is returned.
5704 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5705 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5706 + * for the board.
5707 + ***************************************************************************/
5708 +int BpGetPressAndHoldResetGpio( unsigned short *pusValue );
5709 +
5710 +/**************************************************************************
5711 + * Name : BpGetVoipResetGpio
5712 + *
5713 + * Description: This function returns the GPIO pin assignment for the VOIP
5714 + * Reset operation.
5715 + *
5716 + * Parameters : [OUT] pusValue - Address of short word that the VOIP reset
5717 + * GPIO pin is returned in.
5718 + * [IN] dspNum - Address of the DSP to query.
5719 + *
5720 + * Returns : BP_SUCCESS - Success, value is returned.
5721 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5722 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5723 + * for the board.
5724 + ***************************************************************************/
5725 +int BpGetVoipResetGpio( unsigned char dspNum, unsigned short *pusValue );
5726 +
5727 +/**************************************************************************
5728 + * Name : BpGetVoipIntrGpio
5729 + *
5730 + * Description: This function returns the GPIO pin assignment for VoIP interrupt.
5731 + *
5732 + * Parameters : [OUT] pusValue - Address of short word that the VOIP interrupt
5733 + * GPIO pin is returned in.
5734 + * [IN] dspNum - Address of the DSP to query.
5735 + *
5736 + * Returns : BP_SUCCESS - Success, value is returned.
5737 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5738 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5739 + * for the board.
5740 + ***************************************************************************/
5741 +int BpGetVoipIntrGpio( unsigned char dspNum, unsigned short *pusValue );
5742 +
5743 +/**************************************************************************
5744 + * Name : BpGetPcmciaResetGpio
5745 + *
5746 + * Description: This function returns the GPIO pin assignment for the PCMCIA
5747 + * Reset operation.
5748 + *
5749 + * Parameters : [OUT] pusValue - Address of short word that the PCMCIA reset
5750 + * GPIO pin is returned in.
5751 + *
5752 + * Returns : BP_SUCCESS - Success, value is returned.
5753 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5754 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5755 + * for the board.
5756 + ***************************************************************************/
5757 +int BpGetPcmciaResetGpio( unsigned short *pusValue );
5758 +
5759 +/**************************************************************************
5760 + * Name : BpGetUartRtsCtsGpios
5761 + *
5762 + * Description: This function returns the GPIO pin assignments for RTS and CTS
5763 + * UART signals.
5764 + *
5765 + * Parameters : [OUT] pusRts - Address of short word that the UART RTS GPIO
5766 + * pin is returned in.
5767 + * [OUT] pusCts - Address of short word that the UART CTS GPIO
5768 + * pin is returned in.
5769 + *
5770 + * Returns : BP_SUCCESS - Success, values are returned.
5771 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5772 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5773 + * for the board.
5774 + ***************************************************************************/
5775 +int BpGetRtsCtsUartGpios( unsigned short *pusRts, unsigned short *pusCts );
5776 +
5777 +/**************************************************************************
5778 + * Name : BpGetAdslLedGpio
5779 + *
5780 + * Description: This function returns the GPIO pin assignment for the ADSL
5781 + * LED.
5782 + *
5783 + * Parameters : [OUT] pusValue - Address of short word that the ADSL LED
5784 + * GPIO pin is returned in.
5785 + *
5786 + * Returns : BP_SUCCESS - Success, value is returned.
5787 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5788 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5789 + * for the board.
5790 + ***************************************************************************/
5791 +int BpGetAdslLedGpio( unsigned short *pusValue );
5792 +
5793 +/**************************************************************************
5794 + * Name : BpGetAdslFailLedGpio
5795 + *
5796 + * Description: This function returns the GPIO pin assignment for the ADSL
5797 + * LED that is used when there is a DSL connection failure.
5798 + *
5799 + * Parameters : [OUT] pusValue - Address of short word that the ADSL LED
5800 + * GPIO pin is returned in.
5801 + *
5802 + * Returns : BP_SUCCESS - Success, value is returned.
5803 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5804 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5805 + * for the board.
5806 + ***************************************************************************/
5807 +int BpGetAdslFailLedGpio( unsigned short *pusValue );
5808 +
5809 +/**************************************************************************
5810 + * Name : BpGetWirelessLedGpio
5811 + *
5812 + * Description: This function returns the GPIO pin assignment for the Wireless
5813 + * LED.
5814 + *
5815 + * Parameters : [OUT] pusValue - Address of short word that the Wireless LED
5816 + * GPIO pin is returned in.
5817 + *
5818 + * Returns : BP_SUCCESS - Success, value is returned.
5819 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5820 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5821 + * for the board.
5822 + ***************************************************************************/
5823 +int BpGetWirelessLedGpio( unsigned short *pusValue );
5824 +
5825 +/**************************************************************************
5826 + * Name : BpGetWirelessAntInUse
5827 + *
5828 + * Description: This function returns the antennas in use for wireless
5829 + *
5830 + * Parameters : [OUT] pusValue - Address of short word that the Wireless Antenna
5831 + * is in use.
5832 + *
5833 + * Returns : BP_SUCCESS - Success, value is returned.
5834 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5835 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5836 + * for the board.
5837 + ***************************************************************************/
5838 +int BpGetWirelessAntInUse( unsigned short *pusValue );
5839 +
5840 +/**************************************************************************
5841 + * Name : BpGetWirelessSesBtnGpio
5842 + *
5843 + * Description: This function returns the GPIO pin assignment for the Wireless
5844 + * Ses Button.
5845 + *
5846 + * Parameters : [OUT] pusValue - Address of short word that the Wireless Ses
5847 + * Button GPIO pin is returned in.
5848 + *
5849 + * Returns : BP_SUCCESS - Success, value is returned.
5850 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5851 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5852 + * for the board.
5853 + ***************************************************************************/
5854 +int BpGetWirelessSesBtnGpio( unsigned short *pusValue );
5855 +
5856 +/**************************************************************************
5857 + * Name : BpGetWirelessSesExtIntr
5858 + *
5859 + * Description: This function returns the external interrupt number for the
5860 + * Wireless Ses Button.
5861 + *
5862 + * Parameters : [OUT] pusValue - Address of short word that the Wireless Ses
5863 + * external interrup is returned in.
5864 + *
5865 + * Returns : BP_SUCCESS - Success, value is returned.
5866 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5867 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5868 + * for the board.
5869 + ***************************************************************************/
5870 +int BpGetWirelessSesExtIntr( unsigned short *pusValue );
5871 +
5872 +/**************************************************************************
5873 + * Name : BpGetWirelessSesLedGpio
5874 + *
5875 + * Description: This function returns the GPIO pin assignment for the Wireless
5876 + * Ses Led.
5877 + *
5878 + * Parameters : [OUT] pusValue - Address of short word that the Wireless Ses
5879 + * Led GPIO pin is returned in.
5880 + *
5881 + * Returns : BP_SUCCESS - Success, value is returned.
5882 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5883 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5884 + * for the board.
5885 + ***************************************************************************/
5886 +int BpGetWirelessSesLedGpio( unsigned short *pusValue );
5887 +
5888 +/**************************************************************************
5889 + * Name : BpGetUsbLedGpio
5890 + *
5891 + * Description: This function returns the GPIO pin assignment for the USB
5892 + * LED.
5893 + *
5894 + * Parameters : [OUT] pusValue - Address of short word that the USB LED
5895 + * GPIO pin is returned in.
5896 + *
5897 + * Returns : BP_SUCCESS - Success, value is returned.
5898 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5899 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5900 + * for the board.
5901 + ***************************************************************************/
5902 +int BpGetUsbLedGpio( unsigned short *pusValue );
5903 +
5904 +/**************************************************************************
5905 + * Name : BpGetHpnaLedGpio
5906 + *
5907 + * Description: This function returns the GPIO pin assignment for the HPNA
5908 + * LED.
5909 + *
5910 + * Parameters : [OUT] pusValue - Address of short word that the HPNA LED
5911 + * GPIO pin is returned in.
5912 + *
5913 + * Returns : BP_SUCCESS - Success, value is returned.
5914 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5915 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5916 + * for the board.
5917 + ***************************************************************************/
5918 +int BpGetHpnaLedGpio( unsigned short *pusValue );
5919 +
5920 +/**************************************************************************
5921 + * Name : BpGetWanDataLedGpio
5922 + *
5923 + * Description: This function returns the GPIO pin assignment for the WAN Data
5924 + * LED.
5925 + *
5926 + * Parameters : [OUT] pusValue - Address of short word that the WAN Data LED
5927 + * GPIO pin is returned in.
5928 + *
5929 + * Returns : BP_SUCCESS - Success, value is returned.
5930 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5931 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5932 + * for the board.
5933 + ***************************************************************************/
5934 +int BpGetWanDataLedGpio( unsigned short *pusValue );
5935 +
5936 +/**************************************************************************
5937 + * Name : BpGetPppLedGpio
5938 + *
5939 + * Description: This function returns the GPIO pin assignment for the PPP
5940 + * LED.
5941 + *
5942 + * Parameters : [OUT] pusValue - Address of short word that the PPP LED
5943 + * GPIO pin is returned in.
5944 + *
5945 + * Returns : BP_SUCCESS - Success, value is returned.
5946 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5947 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5948 + * for the board.
5949 + ***************************************************************************/
5950 +int BpGetPppLedGpio( unsigned short *pusValue );
5951 +
5952 +/**************************************************************************
5953 + * Name : BpGetPppFailLedGpio
5954 + *
5955 + * Description: This function returns the GPIO pin assignment for the PPP
5956 + * LED that is used when there is a PPP connection failure.
5957 + *
5958 + * Parameters : [OUT] pusValue - Address of short word that the PPP LED
5959 + * GPIO pin is returned in.
5960 + *
5961 + * Returns : BP_SUCCESS - Success, value is returned.
5962 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5963 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5964 + * for the board.
5965 + ***************************************************************************/
5966 +int BpGetPppFailLedGpio( unsigned short *pusValue );
5967 +
5968 +/**************************************************************************
5969 + * Name : BpGetVoipLedGpio
5970 + *
5971 + * Description: This function returns the GPIO pin assignment for the VOIP
5972 + * LED.
5973 + *
5974 + * Parameters : [OUT] pusValue - Address of short word that the VOIP LED
5975 + * GPIO pin is returned in.
5976 + *
5977 + * Returns : BP_SUCCESS - Success, value is returned.
5978 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5979 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5980 + * for the board.
5981 + ***************************************************************************/
5982 +int BpGetVoipLedGpio( unsigned short *pusValue );
5983 +
5984 +/**************************************************************************
5985 + * Name : BpGetBootloaderPowerOnLedGpio
5986 + *
5987 + * Description: This function returns the GPIO pin assignment for the power
5988 + * on LED that is set by the bootloader.
5989 + *
5990 + * Parameters : [OUT] pusValue - Address of short word that the alarm LED
5991 + * GPIO pin is returned in.
5992 + *
5993 + * Returns : BP_SUCCESS - Success, value is returned.
5994 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
5995 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
5996 + * for the board.
5997 + ***************************************************************************/
5998 +int BpGetBootloaderPowerOnLedGpio( unsigned short *pusValue );
5999 +
6000 +/**************************************************************************
6001 + * Name : BpGetBootloaderAlarmLedGpio
6002 + *
6003 + * Description: This function returns the GPIO pin assignment for the alarm
6004 + * LED that is set by the bootloader.
6005 + *
6006 + * Parameters : [OUT] pusValue - Address of short word that the alarm LED
6007 + * GPIO pin is returned in.
6008 + *
6009 + * Returns : BP_SUCCESS - Success, value is returned.
6010 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
6011 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
6012 + * for the board.
6013 + ***************************************************************************/
6014 +int BpGetBootloaderAlarmLedGpio( unsigned short *pusValue );
6015 +
6016 +/**************************************************************************
6017 + * Name : BpGetBootloaderResetCfgLedGpio
6018 + *
6019 + * Description: This function returns the GPIO pin assignment for the reset
6020 + * configuration LED that is set by the bootloader.
6021 + *
6022 + * Parameters : [OUT] pusValue - Address of short word that the reset
6023 + * configuration LED GPIO pin is returned in.
6024 + *
6025 + * Returns : BP_SUCCESS - Success, value is returned.
6026 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
6027 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
6028 + * for the board.
6029 + ***************************************************************************/
6030 +int BpGetBootloaderResetCfgLedGpio( unsigned short *pusValue );
6031 +
6032 +/**************************************************************************
6033 + * Name : BpGetBootloaderStopLedGpio
6034 + *
6035 + * Description: This function returns the GPIO pin assignment for the break
6036 + * into bootloader LED that is set by the bootloader.
6037 + *
6038 + * Parameters : [OUT] pusValue - Address of short word that the break into
6039 + * bootloader LED GPIO pin is returned in.
6040 + *
6041 + * Returns : BP_SUCCESS - Success, value is returned.
6042 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
6043 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
6044 + * for the board.
6045 + ***************************************************************************/
6046 +int BpGetBootloaderStopLedGpio( unsigned short *pusValue );
6047 +
6048 +/**************************************************************************
6049 + * Name : BpGetWirelessExtIntr
6050 + *
6051 + * Description: This function returns the Wireless external interrupt number.
6052 + *
6053 + * Parameters : [OUT] pulValue - Address of short word that the wireless
6054 + * external interrupt number is returned in.
6055 + *
6056 + * Returns : BP_SUCCESS - Success, value is returned.
6057 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
6058 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
6059 + * for the board.
6060 + ***************************************************************************/
6061 +int BpGetWirelessExtIntr( unsigned long *pulValue );
6062 +
6063 +/**************************************************************************
6064 + * Name : BpGetAdslDyingGaspExtIntr
6065 + *
6066 + * Description: This function returns the ADSL Dying Gasp external interrupt
6067 + * number.
6068 + *
6069 + * Parameters : [OUT] pulValue - Address of short word that the ADSL Dying Gasp
6070 + * external interrupt number is returned in.
6071 + *
6072 + * Returns : BP_SUCCESS - Success, value is returned.
6073 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
6074 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
6075 + * for the board.
6076 + ***************************************************************************/
6077 +int BpGetAdslDyingGaspExtIntr( unsigned long *pulValue );
6078 +
6079 +/**************************************************************************
6080 + * Name : BpGetVoipExtIntr
6081 + *
6082 + * Description: This function returns the VOIP external interrupt number.
6083 + *
6084 + * Parameters : [OUT] pulValue - Address of short word that the VOIP
6085 + * external interrupt number is returned in.
6086 + * [IN] dspNum - Address of the DSP to query.
6087 + *
6088 + * Returns : BP_SUCCESS - Success, value is returned.
6089 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
6090 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
6091 + * for the board.
6092 + ***************************************************************************/
6093 +int BpGetVoipExtIntr( unsigned char dspNum, unsigned long *pulValue );
6094 +
6095 +/**************************************************************************
6096 + * Name : BpGetHpnaExtIntr
6097 + *
6098 + * Description: This function returns the HPNA external interrupt number.
6099 + *
6100 + * Parameters : [OUT] pulValue - Address of short word that the HPNA
6101 + * external interrupt number is returned in.
6102 + *
6103 + * Returns : BP_SUCCESS - Success, value is returned.
6104 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
6105 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
6106 + * for the board.
6107 + ***************************************************************************/
6108 +int BpGetHpnaExtIntr( unsigned long *pulValue );
6109 +
6110 +/**************************************************************************
6111 + * Name : BpGetHpnaChipSelect
6112 + *
6113 + * Description: This function returns the HPNA chip select number.
6114 + *
6115 + * Parameters : [OUT] pulValue - Address of short word that the HPNA
6116 + * chip select number is returned in.
6117 + *
6118 + * Returns : BP_SUCCESS - Success, value is returned.
6119 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
6120 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
6121 + * for the board.
6122 + ***************************************************************************/
6123 +int BpGetHpnaChipSelect( unsigned long *pulValue );
6124 +
6125 +/**************************************************************************
6126 + * Name : BpGetVoipChipSelect
6127 + *
6128 + * Description: This function returns the VOIP chip select number.
6129 + *
6130 + * Parameters : [OUT] pulValue - Address of short word that the VOIP
6131 + * chip select number is returned in.
6132 + * [IN] dspNum - Address of the DSP to query.
6133 + *
6134 + * Returns : BP_SUCCESS - Success, value is returned.
6135 + * BP_BOARD_ID_NOT_SET - Error, BpSetBoardId has not been called.
6136 + * BP_VALUE_NOT_DEFINED - At least one return value is not defined
6137 + * for the board.
6138 + ***************************************************************************/
6139 +int BpGetVoipChipSelect( unsigned char dspNum, unsigned long *pulValue );
6140 +
6141 +#endif /* __ASSEMBLER__ */
6142 +
6143 +#if __cplusplus
6144 +}
6145 +#endif
6146 +
6147 +#endif /* _BOARDPARMS_H */
6148 +
6149 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/cfiflash.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/cfiflash.c
6150 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/cfiflash.c 1970-01-01 01:00:00.000000000 +0100
6151 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/cfiflash.c 2006-07-07 22:17:24.000000000 +0200
6152 @@ -0,0 +1,692 @@
6153 +/************************************************************************/
6154 +/* */
6155 +/* AMD CFI Enabled Flash Memory Drivers */
6156 +/* File name: CFIFLASH.C */
6157 +/* Revision: 1.0 5/07/98 */
6158 +/* */
6159 +/* Copyright (c) 1998 ADVANCED MICRO DEVICES, INC. All Rights Reserved. */
6160 +/* This software is unpublished and contains the trade secrets and */
6161 +/* confidential proprietary information of AMD. Unless otherwise */
6162 +/* provided in the Software Agreement associated herewith, it is */
6163 +/* licensed in confidence "AS IS" and is not to be reproduced in whole */
6164 +/* or part by any means except for backup. Use, duplication, or */
6165 +/* disclosure by the Government is subject to the restrictions in */
6166 +/* paragraph (b) (3) (B) of the Rights in Technical Data and Computer */
6167 +/* Software clause in DFAR 52.227-7013 (a) (Oct 1988). */
6168 +/* Software owned by */
6169 +/* Advanced Micro Devices, Inc., */
6170 +/* One AMD Place, */
6171 +/* P.O. Box 3453 */
6172 +/* Sunnyvale, CA 94088-3453. */
6173 +/************************************************************************/
6174 +/* This software constitutes a basic shell of source code for */
6175 +/* programming all AMD Flash components. AMD */
6176 +/* will not be responsible for misuse or illegal use of this */
6177 +/* software for devices not supported herein. AMD is providing */
6178 +/* this source code "AS IS" and will not be responsible for */
6179 +/* issues arising from incorrect user implementation of the */
6180 +/* source code herein. It is the user's responsibility to */
6181 +/* properly design-in this source code. */
6182 +/* */
6183 +/************************************************************************/
6184 +#ifdef _CFE_
6185 +#include "lib_types.h"
6186 +#include "lib_printf.h"
6187 +#include "lib_string.h"
6188 +#include "cfe_timer.h"
6189 +#define printk printf
6190 +#else // linux
6191 +#include <linux/param.h>
6192 +#include <linux/sched.h>
6193 +#include <linux/timer.h>
6194 +#endif
6195 +
6196 +#include "cfiflash.h"
6197 +
6198 +static int flash_wait(WORD sector, int offset, UINT16 data);
6199 +static UINT16 flash_get_device_id(void);
6200 +static int flash_get_cfi(struct cfi_query *query, UINT16 *cfi_struct, int flashFamily);
6201 +static int flash_write(WORD sector, int offset, byte *buf, int nbytes);
6202 +static void flash_command(int command, WORD sector, int offset, UINT16 data);
6203 +
6204 +/*********************************************************************/
6205 +/* 'meminfo' should be a pointer, but most C compilers will not */
6206 +/* allocate static storage for a pointer without calling */
6207 +/* non-portable functions such as 'new'. We also want to avoid */
6208 +/* the overhead of passing this pointer for every driver call. */
6209 +/* Systems with limited heap space will need to do this. */
6210 +/*********************************************************************/
6211 +struct flashinfo meminfo; /* Flash information structure */
6212 +static int flashFamily = FLASH_UNDEFINED;
6213 +static int totalSize = 0;
6214 +static struct cfi_query query;
6215 +
6216 +static UINT16 cfi_data_struct_29W160[] = {
6217 + 0x0020, 0x0049, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
6218 + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
6219 + 0x0051, 0x0052, 0x0059, 0x0002, 0x0000, 0x0040, 0x0000, 0x0000,
6220 + 0x0000, 0x0000, 0x0000, 0x0027, 0x0036, 0x0000, 0x0000, 0x0004,
6221 + 0x0000, 0x000a, 0x0000, 0x0004, 0x0000, 0x0003, 0x0000, 0x0015,
6222 + 0x0002, 0x0000, 0x0000, 0x0000, 0x0004, 0x0000, 0x0000, 0x0040,
6223 + 0x0000, 0x0001, 0x0000, 0x0020, 0x0000, 0x0000, 0x0000, 0x0080,
6224 + 0x0000, 0x001e, 0x0000, 0x0000, 0x0001, 0xffff, 0xffff, 0xffff,
6225 + 0x0050, 0x0052, 0x0049, 0x0031, 0x0030, 0x0000, 0x0002, 0x0001,
6226 + 0x0001, 0x0004, 0x0000, 0x0000, 0x0000, 0xffff, 0xffff, 0x0002,
6227 + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
6228 + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
6229 + 0xffff, 0x0888, 0x252b, 0x8c84, 0x7dbc, 0xffff, 0xffff, 0xffff,
6230 + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
6231 + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
6232 + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff
6233 +};
6234 +
6235 +
6236 +/*********************************************************************/
6237 +/* Init_flash is used to build a sector table from the information */
6238 +/* provided through the CFI query. This information is translated */
6239 +/* from erase_block information to base:offset information for each */
6240 +/* individual sector. This information is then stored in the meminfo */
6241 +/* structure, and used throughout the driver to access sector */
6242 +/* information. */
6243 +/* */
6244 +/* This is more efficient than deriving the sector base:offset */
6245 +/* information every time the memory map switches (since on the */
6246 +/* development platform can only map 64k at a time). If the entire */
6247 +/* flash memory array can be mapped in, then the addition static */
6248 +/* allocation for the meminfo structure can be eliminated, but the */
6249 +/* drivers will have to be re-written. */
6250 +/* */
6251 +/* The meminfo struct occupies 653 bytes of heap space, depending */
6252 +/* on the value of the define MAXSECTORS. Adjust to suit */
6253 +/* application */
6254 +/*********************************************************************/
6255 +byte flash_init(void)
6256 +{
6257 + int i=0, j=0, count=0;
6258 + int basecount=0L;
6259 + UINT16 device_id;
6260 + int flipCFIGeometry = FALSE;
6261 +
6262 + /* First, assume
6263 + * a single 8k sector for sector 0. This is to allow
6264 + * the system to perform memory mapping to the device,
6265 + * even though the actual physical layout is unknown.
6266 + * Once mapped in, the CFI query will produce all
6267 + * relevant information.
6268 + */
6269 + meminfo.addr = 0L;
6270 + meminfo.areg = 0;
6271 + meminfo.nsect = 1;
6272 + meminfo.bank1start = 0;
6273 + meminfo.bank2start = 0;
6274 +
6275 + meminfo.sec[0].size = 8192;
6276 + meminfo.sec[0].base = 0x00000;
6277 + meminfo.sec[0].bank = 1;
6278 +
6279 + flash_command(FLASH_RESET, 0, 0, 0);
6280 +
6281 + device_id = flash_get_device_id();
6282 +
6283 + switch (device_id) {
6284 + case ID_I28F160C3B:
6285 + case ID_I28F320C3B:
6286 + case ID_I28F160C3T:
6287 + case ID_I28F320C3T:
6288 + flashFamily = FLASH_INTEL;
6289 + break;
6290 + case ID_AM29DL800B:
6291 + case ID_AM29LV800B:
6292 + case ID_AM29LV400B:
6293 + case ID_AM29LV160B:
6294 + case ID_AM29LV320B:
6295 + case ID_MX29LV320AB:
6296 + case ID_AM29LV320MB:
6297 + case ID_AM29DL800T:
6298 + case ID_AM29LV800T:
6299 + case ID_AM29LV160T:
6300 + case ID_AM29LV320T:
6301 + case ID_MX29LV320AT:
6302 + case ID_AM29LV320MT:
6303 + flashFamily = FLASH_AMD;
6304 + break;
6305 + case ID_SST39VF1601:
6306 + case ID_SST39VF3201:
6307 + flashFamily = FLASH_SST;
6308 + break;
6309 + default:
6310 + printk("Flash memory not supported! Device id = %x\n", device_id);
6311 + return -1;
6312 + }
6313 +
6314 + if (flash_get_cfi(&query, 0, flashFamily) == -1) {
6315 + switch(device_id) {
6316 + case ID_AM29LV160T:
6317 + case ID_AM29LV160B:
6318 + flash_get_cfi(&query, cfi_data_struct_29W160, flashFamily);
6319 + break;
6320 + default:
6321 + printk("CFI data structure not found. Device id = %x\n", device_id);
6322 + return -1;
6323 + }
6324 + }
6325 +
6326 + // need to determine if it top or bottom boot here
6327 + switch (device_id)
6328 + {
6329 + case ID_AM29DL800B:
6330 + case ID_AM29LV800B:
6331 + case ID_AM29LV400B:
6332 + case ID_AM29LV160B:
6333 + case ID_AM29LV320B:
6334 + case ID_MX29LV320AB:
6335 + case ID_AM29LV320MB:
6336 + case ID_I28F160C3B:
6337 + case ID_I28F320C3B:
6338 + case ID_I28F160C3T:
6339 + case ID_I28F320C3T:
6340 + case ID_SST39VF1601:
6341 + case ID_SST39VF3201:
6342 + flipCFIGeometry = FALSE;
6343 + break;
6344 + case ID_AM29DL800T:
6345 + case ID_AM29LV800T:
6346 + case ID_AM29LV160T:
6347 + case ID_AM29LV320T:
6348 + case ID_MX29LV320AT:
6349 + case ID_AM29LV320MT:
6350 + flipCFIGeometry = TRUE;
6351 + break;
6352 + default:
6353 + printk("Flash memory not supported! Device id = %x\n", device_id);
6354 + return -1;
6355 + }
6356 +
6357 + count=0;basecount=0L;
6358 +
6359 + if (!flipCFIGeometry)
6360 + {
6361 + for (i=0; i<query.num_erase_blocks; i++) {
6362 + for(j=0; j<query.erase_block[i].num_sectors; j++) {
6363 + meminfo.sec[count].size = (int) query.erase_block[i].sector_size;
6364 + meminfo.sec[count].base = (int) basecount;
6365 + basecount += (int) query.erase_block[i].sector_size;
6366 + count++;
6367 + }
6368 + }
6369 + }
6370 + else
6371 + {
6372 + for (i = (query.num_erase_blocks - 1); i >= 0; i--) {
6373 + for(j=0; j<query.erase_block[i].num_sectors; j++) {
6374 + meminfo.sec[count].size = (int) query.erase_block[i].sector_size;
6375 + meminfo.sec[count].base = (int) basecount;
6376 + basecount += (int) query.erase_block[i].sector_size;
6377 + count++;
6378 + }
6379 + }
6380 + }
6381 +
6382 + meminfo.nsect = count;
6383 + totalSize = meminfo.sec[count-1].base + meminfo.sec[count-1].size;
6384 + return (0);
6385 +}
6386 +
6387 +/*********************************************************************/
6388 +/* Flash_sector_erase_int() is identical to flash_sector_erase(), */
6389 +/* except it will wait until the erase is completed before returning */
6390 +/* control to the calling function. This can be used in cases which */
6391 +/* require the program to hold until a sector is erased, without */
6392 +/* adding the wait check external to this function. */
6393 +/*********************************************************************/
6394 +byte flash_sector_erase_int(WORD sector)
6395 +{
6396 + int i;
6397 +
6398 + for( i = 0; i < 3; i++ ) {
6399 + flash_command(FLASH_SERASE, sector, 0, 0);
6400 + if (flash_wait(sector, 0, 0xffff) == STATUS_READY)
6401 + break;
6402 + }
6403 +
6404 + return(1);
6405 +}
6406 +
6407 +/*********************************************************************/
6408 +/* flash_read_buf() reads buffer of data from the specified */
6409 +/* offset from the sector parameter. */
6410 +/*********************************************************************/
6411 +int flash_read_buf(WORD sector, int offset,
6412 + byte *buffer, int numbytes)
6413 +{
6414 + byte *fwp;
6415 +
6416 + fwp = (byte *)flash_get_memptr(sector);
6417 +
6418 + while (numbytes) {
6419 + *buffer++ = *(fwp + offset);
6420 + numbytes--;
6421 + fwp++;
6422 + }
6423 +
6424 + return (1);
6425 +}
6426 +
6427 +/*********************************************************************/
6428 +/* flash_write_buf() utilizes */
6429 +/* the unlock bypass mode of the flash device. This can remove */
6430 +/* significant overhead from the bulk programming operation, and */
6431 +/* when programming bulk data a sizeable performance increase can be */
6432 +/* observed. */
6433 +/*********************************************************************/
6434 +int flash_write_buf(WORD sector, int offset, byte *buffer, int numbytes)
6435 +{
6436 + int ret = -1;
6437 + int i;
6438 + unsigned char *p = flash_get_memptr(sector) + offset;
6439 +
6440 + /* After writing the flash block, compare the contents to the source
6441 + * buffer. Try to write the sector successfully up to three times.
6442 + */
6443 + for( i = 0; i < 3; i++ ) {
6444 + ret = flash_write(sector, offset, buffer, numbytes);
6445 + if( !memcmp( p, buffer, numbytes ) )
6446 + break;
6447 + /* Erase and try again */
6448 + flash_sector_erase_int(sector);
6449 + ret = -1;
6450 + }
6451 +
6452 + if( ret == -1 )
6453 + printk( "Flash write error. Verify failed\n" );
6454 +
6455 + return( ret );
6456 +}
6457 +
6458 +/*********************************************************************/
6459 +/* Usefull funtion to return the number of sectors in the device. */
6460 +/* Can be used for functions which need to loop among all the */
6461 +/* sectors, or wish to know the number of the last sector. */
6462 +/*********************************************************************/
6463 +int flash_get_numsectors(void)
6464 +{
6465 + return meminfo.nsect;
6466 +}
6467 +
6468 +/*********************************************************************/
6469 +/* flash_get_sector_size() is provided for cases in which the size */
6470 +/* of a sector is required by a host application. The sector size */
6471 +/* (in bytes) is returned in the data location pointed to by the */
6472 +/* 'size' parameter. */
6473 +/*********************************************************************/
6474 +int flash_get_sector_size(WORD sector)
6475 +{
6476 + return meminfo.sec[sector].size;
6477 +}
6478 +
6479 +/*********************************************************************/
6480 +/* The purpose of flash_get_memptr() is to return a memory pointer */
6481 +/* which points to the beginning of memory space allocated for the */
6482 +/* flash. All function pointers are then referenced from this */
6483 +/* pointer. */
6484 +/* */
6485 +/* Different systems will implement this in different ways: */
6486 +/* possibilities include: */
6487 +/* - A direct memory pointer */
6488 +/* - A pointer to a memory map */
6489 +/* - A pointer to a hardware port from which the linear */
6490 +/* address is translated */
6491 +/* - Output of an MMU function / service */
6492 +/* */
6493 +/* Also note that this function expects the pointer to a specific */
6494 +/* sector of the device. This can be provided by dereferencing */
6495 +/* the pointer from a translated offset of the sector from a */
6496 +/* global base pointer (e.g. flashptr = base_pointer + sector_offset)*/
6497 +/* */
6498 +/* Important: Many AMD flash devices need both bank and or sector */
6499 +/* address bits to be correctly set (bank address bits are A18-A16, */
6500 +/* and sector address bits are A18-A12, or A12-A15). Flash parts */
6501 +/* which do not need these bits will ignore them, so it is safe to */
6502 +/* assume that every part will require these bits to be set. */
6503 +/*********************************************************************/
6504 +unsigned char *flash_get_memptr(WORD sector)
6505 +{
6506 + unsigned char *memptr = (unsigned char*)(FLASH_BASE_ADDR_REG + meminfo.sec[sector].base);
6507 +
6508 + return (memptr);
6509 +}
6510 +
6511 +/*********************************************************************/
6512 +/* The purpose of flash_get_blk() is to return a the block number */
6513 +/* for a given memory address. */
6514 +/*********************************************************************/
6515 +int flash_get_blk(int addr)
6516 +{
6517 + int blk_start, i;
6518 + int last_blk = flash_get_numsectors();
6519 + int relative_addr = addr - (int) FLASH_BASE_ADDR_REG;
6520 +
6521 + for(blk_start=0, i=0; i < relative_addr && blk_start < last_blk; blk_start++)
6522 + i += flash_get_sector_size(blk_start);
6523 +
6524 + if( i > relative_addr )
6525 + {
6526 + blk_start--; // last blk, dec by 1
6527 + }
6528 + else
6529 + if( blk_start == last_blk )
6530 + {
6531 + printk("Address is too big.\n");
6532 + blk_start = -1;
6533 + }
6534 +
6535 + return( blk_start );
6536 +}
6537 +
6538 +/************************************************************************/
6539 +/* The purpose of flash_get_total_size() is to return the total size of */
6540 +/* the flash */
6541 +/************************************************************************/
6542 +int flash_get_total_size()
6543 +{
6544 + return totalSize;
6545 +}
6546 +
6547 +/*********************************************************************/
6548 +/* Flash_command() is the main driver function. It performs */
6549 +/* every possible command available to AMD B revision */
6550 +/* flash parts. Note that this command is not used directly, but */
6551 +/* rather called through the API wrapper functions provided below. */
6552 +/*********************************************************************/
6553 +static void flash_command(int command, WORD sector, int offset, UINT16 data)
6554 +{
6555 + volatile UINT16 *flashptr;
6556 + volatile UINT16 *flashbase;
6557 +
6558 + flashptr = (UINT16 *) flash_get_memptr(sector);
6559 + flashbase = (UINT16 *) flash_get_memptr(0);
6560 +
6561 + switch (flashFamily) {
6562 + case FLASH_UNDEFINED:
6563 + /* These commands should work for AMD, Intel and SST flashes */
6564 + switch (command) {
6565 + case FLASH_RESET:
6566 + flashptr[0] = 0xF0;
6567 + flashptr[0] = 0xFF;
6568 + break;
6569 + case FLASH_READ_ID:
6570 + flashptr[0x5555] = 0xAA; /* unlock 1 */
6571 + flashptr[0x2AAA] = 0x55; /* unlock 2 */
6572 + flashptr[0x5555] = 0x90;
6573 + break;
6574 + default:
6575 + break;
6576 + }
6577 + break;
6578 + case FLASH_AMD:
6579 + switch (command) {
6580 + case FLASH_RESET:
6581 + flashptr[0] = 0xF0;
6582 + break;
6583 + case FLASH_READ_ID:
6584 + flashptr[0x555] = 0xAA; /* unlock 1 */
6585 + flashptr[0x2AA] = 0x55; /* unlock 2 */
6586 + flashptr[0x555] = 0x90;
6587 + break;
6588 + case FLASH_CFIQUERY:
6589 + flashptr[0x55] = 0x98;
6590 + break;
6591 + case FLASH_UB:
6592 + flashptr[0x555] = 0xAA; /* unlock 1 */
6593 + flashptr[0x2AA] = 0x55; /* unlock 2 */
6594 + flashptr[0x555] = 0x20;
6595 + break;
6596 + case FLASH_PROG:
6597 + flashptr[0] = 0xA0;
6598 + flashptr[offset/2] = data;
6599 + break;
6600 + case FLASH_UBRESET:
6601 + flashptr[0] = 0x90;
6602 + flashptr[0] = 0x00;
6603 + break;
6604 + case FLASH_SERASE:
6605 + flashptr[0x555] = 0xAA; /* unlock 1 */
6606 + flashptr[0x2AA] = 0x55; /* unlock 2 */
6607 + flashptr[0x555] = 0x80;
6608 + flashptr[0x555] = 0xAA;
6609 + flashptr[0x2AA] = 0x55;
6610 + flashptr[0] = 0x30;
6611 + break;
6612 + default:
6613 + break;
6614 + }
6615 + break;
6616 + case FLASH_INTEL:
6617 + switch (command) {
6618 + case FLASH_RESET:
6619 + flashptr[0] = 0xFF;
6620 + break;
6621 + case FLASH_READ_ID:
6622 + flashptr[0] = 0x90;
6623 + break;
6624 + case FLASH_CFIQUERY:
6625 + flashptr[0] = 0x98;
6626 + break;
6627 + case FLASH_PROG:
6628 + flashptr[0] = 0x40;
6629 + flashptr[offset/2] = data;
6630 + break;
6631 + case FLASH_SERASE:
6632 + flashptr[0] = 0x60;
6633 + flashptr[0] = 0xD0;
6634 + flashptr[0] = 0x20;
6635 + flashptr[0] = 0xD0;
6636 + break;
6637 + default:
6638 + break;
6639 + }
6640 + break;
6641 + case FLASH_SST:
6642 + switch (command) {
6643 + case FLASH_RESET:
6644 + flashbase[0x5555] = 0xAA; /* unlock 1 */
6645 + flashbase[0x2AAA] = 0x55; /* unlock 2 */
6646 + flashbase[0x5555] = 0xf0;
6647 + break;
6648 + case FLASH_READ_ID:
6649 + flashbase[0x5555] = 0xAA; /* unlock 1 */
6650 + flashbase[0x2AAA] = 0x55; /* unlock 2 */
6651 + flashbase[0x5555] = 0x90;
6652 + break;
6653 + case FLASH_CFIQUERY:
6654 + flashbase[0x5555] = 0xAA; /* unlock 1 */
6655 + flashbase[0x2AAA] = 0x55; /* unlock 2 */
6656 + flashbase[0x5555] = 0x98;
6657 + break;
6658 + case FLASH_UB:
6659 + break;
6660 + case FLASH_PROG:
6661 + flashbase[0x5555] = 0xAA; /* unlock 1 */
6662 + flashbase[0x2AAA] = 0x55; /* unlock 2 */
6663 + flashbase[0x5555] = 0xa0;
6664 + flashptr[offset/2] = data;
6665 + break;
6666 + case FLASH_UBRESET:
6667 + break;
6668 + case FLASH_SERASE:
6669 + flashbase[0x5555] = 0xAA; /* unlock 1 */
6670 + flashbase[0x2AAA] = 0x55; /* unlock 2 */
6671 + flashbase[0x5555] = 0x80;
6672 + flashbase[0x5555] = 0xAA;
6673 + flashbase[0x2AAA] = 0x55;
6674 + flashptr[0] = 0x30;
6675 + break;
6676 + default:
6677 + break;
6678 + }
6679 + break;
6680 + default:
6681 + break;
6682 + }
6683 +}
6684 +
6685 +/*********************************************************************/
6686 +/* flash_write extends the functionality of flash_program() by */
6687 +/* providing an faster way to program multiple data words, without */
6688 +/* needing the function overhead of looping algorithms which */
6689 +/* program word by word. This function utilizes fast pointers */
6690 +/* to quickly loop through bulk data. */
6691 +/*********************************************************************/
6692 +static int flash_write(WORD sector, int offset, byte *buf, int nbytes)
6693 +{
6694 + UINT16 *src;
6695 + src = (UINT16 *)buf;
6696 +
6697 + if ((nbytes | offset) & 1) {
6698 + return -1;
6699 + }
6700 +
6701 + flash_command(FLASH_UB, 0, 0, 0);
6702 + while (nbytes > 0) {
6703 + flash_command(FLASH_PROG, sector, offset, *src);
6704 + if (flash_wait(sector, offset, *src) != STATUS_READY)
6705 + break;
6706 + offset +=2;
6707 + nbytes -=2;
6708 + src++;
6709 + }
6710 + flash_command(FLASH_UBRESET, 0, 0, 0);
6711 +
6712 + return (byte*)src - buf;
6713 +}
6714 +
6715 +/*********************************************************************/
6716 +/* flash_wait utilizes the DQ6, DQ5, and DQ2 polling algorithms */
6717 +/* described in the flash data book. It can quickly ascertain the */
6718 +/* operational status of the flash device, and return an */
6719 +/* appropriate status code (defined in flash.h) */
6720 +/*********************************************************************/
6721 +static int flash_wait(WORD sector, int offset, UINT16 data)
6722 +{
6723 + volatile UINT16 *flashptr; /* flash window */
6724 + UINT16 d1;
6725 +
6726 + flashptr = (UINT16 *) flash_get_memptr(sector);
6727 +
6728 + if (flashFamily == FLASH_AMD || flashFamily == FLASH_SST) {
6729 +#if defined(_BCM96338_) || defined(CONFIG_BCM96338)
6730 + do {
6731 + d1 = flashptr[offset/2];
6732 + if (d1 == data)
6733 + return STATUS_READY;
6734 + } while (!(d1 & 0x20));
6735 +
6736 + d1 = flashptr[offset/2];
6737 +
6738 + if (d1 != data) {
6739 + flash_command(FLASH_RESET, 0, 0, 0);
6740 + return STATUS_TIMEOUT;
6741 + }
6742 +#else
6743 + do {
6744 + d1 = *flashptr; /* read data */
6745 + d1 ^= *flashptr; /* read it again and see what toggled */
6746 + if (d1 == 0) /* no toggles, nothing's happening */
6747 + return STATUS_READY;
6748 + } while (!(d1 & 0x20));
6749 +
6750 + d1 = *flashptr; /* read data */
6751 + d1 ^= *flashptr; /* read it again and see what toggled */
6752 +
6753 + if (d1 != 0) {
6754 + flash_command(FLASH_RESET, 0, 0, 0);
6755 + return STATUS_TIMEOUT;
6756 + }
6757 +#endif
6758 + } else if (flashFamily == FLASH_INTEL) {
6759 + flashptr[0] = 0x70;
6760 + /* Wait for completion */
6761 + while(!(*flashptr & 0x80));
6762 + if (*flashptr & 0x30) {
6763 + flashptr[0] = 0x50;
6764 + flash_command(FLASH_RESET, 0, 0, 0);
6765 + return STATUS_TIMEOUT;
6766 + }
6767 + flashptr[0] = 0x50;
6768 + flash_command(FLASH_RESET, 0, 0, 0);
6769 + }
6770 +
6771 + return STATUS_READY;
6772 +}
6773 +
6774 +/*********************************************************************/
6775 +/* flash_get_device_id() will perform an autoselect sequence on the */
6776 +/* flash device, and return the device id of the component. */
6777 +/* This function automatically resets to read mode. */
6778 +/*********************************************************************/
6779 +static UINT16 flash_get_device_id()
6780 +{
6781 + volatile UINT16 *fwp; /* flash window */
6782 + UINT16 answer;
6783 +
6784 + fwp = (UINT16 *)flash_get_memptr(0);
6785 +
6786 + flash_command(FLASH_READ_ID, 0, 0, 0);
6787 + answer = *(fwp + 1);
6788 + if (answer == ID_AM29LV320M) {
6789 + answer = *(fwp + 0xe);
6790 + answer = *(fwp + 0xf);
6791 + }
6792 +
6793 + flash_command(FLASH_RESET, 0, 0, 0);
6794 + return( (UINT16) answer );
6795 +}
6796 +
6797 +/*********************************************************************/
6798 +/* flash_get_cfi() is the main CFI workhorse function. Due to it's */
6799 +/* complexity and size it need only be called once upon */
6800 +/* initializing the flash system. Once it is called, all operations */
6801 +/* are performed by looking at the meminfo structure. */
6802 +/* All possible care was made to make this algorithm as efficient as */
6803 +/* possible. 90% of all operations are memory reads, and all */
6804 +/* calculations are done using bit-shifts when possible */
6805 +/*********************************************************************/
6806 +static int flash_get_cfi(struct cfi_query *query, UINT16 *cfi_struct, int flashFamily)
6807 +{
6808 + volatile UINT16 *fwp; /* flash window */
6809 + int i=0;
6810 +
6811 + flash_command(FLASH_CFIQUERY, 0, 0, 0);
6812 +
6813 + if (cfi_struct == 0)
6814 + fwp = (UINT16 *)flash_get_memptr(0);
6815 + else
6816 + fwp = cfi_struct;
6817 +
6818 + /* Initial house-cleaning */
6819 + for(i=0; i < 8; i++) {
6820 + query->erase_block[i].sector_size = 0;
6821 + query->erase_block[i].num_sectors = 0;
6822 + }
6823 +
6824 + /* If not 'QRY', then we dont have a CFI enabled device in the socket */
6825 + if( fwp[0x10] != 'Q' &&
6826 + fwp[0x11] != 'R' &&
6827 + fwp[0x12] != 'Y') {
6828 + flash_command(FLASH_RESET, 0, 0, 0);
6829 + return(-1);
6830 + }
6831 +
6832 + query->num_erase_blocks = fwp[0x2C];
6833 + if(flashFamily == FLASH_SST)
6834 + query->num_erase_blocks = 1;
6835 +
6836 + for(i=0; i < query->num_erase_blocks; i++) {
6837 + query->erase_block[i].num_sectors = fwp[(0x2D+(4*i))] + (fwp[0x2E + (4*i)] << 8);
6838 + query->erase_block[i].num_sectors++;
6839 + query->erase_block[i].sector_size = 256 * (256 * fwp[(0x30+(4*i))] + fwp[(0x2F+(4*i))]);
6840 + }
6841 +
6842 + flash_command(FLASH_RESET, 0, 0, 0);
6843 + return(1);
6844 +}
6845 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/cfiflash.h linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/cfiflash.h
6846 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/cfiflash.h 1970-01-01 01:00:00.000000000 +0100
6847 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/cfiflash.h 2006-07-07 22:17:24.000000000 +0200
6848 @@ -0,0 +1,150 @@
6849 +/************************************************************************/
6850 +/* */
6851 +/* AMD CFI Enabled Flash Memory Drivers */
6852 +/* File name: CFIFLASH.H */
6853 +/* Revision: 1.0 5/07/98 */
6854 +/* */
6855 +/* Copyright (c) 1998 ADVANCED MICRO DEVICES, INC. All Rights Reserved. */
6856 +/* This software is unpublished and contains the trade secrets and */
6857 +/* confidential proprietary information of AMD. Unless otherwise */
6858 +/* provided in the Software Agreement associated herewith, it is */
6859 +/* licensed in confidence "AS IS" and is not to be reproduced in whole */
6860 +/* or part by any means except for backup. Use, duplication, or */
6861 +/* disclosure by the Government is subject to the restrictions in */
6862 +/* paragraph (b) (3) (B) of the Rights in Technical Data and Computer */
6863 +/* Software clause in DFAR 52.227-7013 (a) (Oct 1988). */
6864 +/* Software owned by */
6865 +/* Advanced Micro Devices, Inc., */
6866 +/* One AMD Place, */
6867 +/* P.O. Box 3453 */
6868 +/* Sunnyvale, CA 94088-3453. */
6869 +/************************************************************************/
6870 +/* This software constitutes a basic shell of source code for */
6871 +/* programming all AMD Flash components. AMD */
6872 +/* will not be responsible for misuse or illegal use of this */
6873 +/* software for devices not supported herein. AMD is providing */
6874 +/* this source code "AS IS" and will not be responsible for */
6875 +/* issues arising from incorrect user implementation of the */
6876 +/* source code herein. It is the user's responsibility to */
6877 +/* properly design-in this source code. */
6878 +/* */
6879 +/************************************************************************/
6880 +#ifndef _CFIFLASH_H
6881 +#define _CFIFLASH_H
6882 +
6883 +#if defined __cplusplus
6884 +extern "C" {
6885 +#endif
6886 +
6887 +/* include board/CPU specific definitions */
6888 +#include "bcmtypes.h"
6889 +#include "board.h"
6890 +
6891 +#define FLASH_BASE_ADDR_REG FLASH_BASE
6892 +
6893 +#ifndef NULL
6894 +#define NULL 0
6895 +#endif
6896 +
6897 +#define MAXSECTORS 1024 /* maximum number of sectors supported */
6898 +
6899 +/* A structure for identifying a flash part. There is one for each
6900 + * of the flash part definitions. We need to keep track of the
6901 + * sector organization, the address register used, and the size
6902 + * of the sectors.
6903 + */
6904 +struct flashinfo {
6905 + char *name; /* "Am29DL800T", etc. */
6906 + unsigned long addr; /* physical address, once translated */
6907 + int areg; /* Can be set to zero for all parts */
6908 + int nsect; /* # of sectors -- 19 in LV, 22 in DL */
6909 + int bank1start; /* first sector # in bank 1 */
6910 + int bank2start; /* first sector # in bank 2, if DL part */
6911 + struct {
6912 + long size; /* # of bytes in this sector */
6913 + long base; /* offset from beginning of device */
6914 + int bank; /* 1 or 2 for DL; 1 for LV */
6915 + } sec[MAXSECTORS]; /* per-sector info */
6916 +};
6917 +
6918 +/*
6919 + * This structure holds all CFI query information as defined
6920 + * in the JEDEC standard. All information up to
6921 + * primary_extended_query is standard among all manufactures
6922 + * with CFI enabled devices.
6923 + */
6924 +
6925 +struct cfi_query {
6926 + int num_erase_blocks; /* Number of sector defs. */
6927 + struct {
6928 + unsigned long sector_size; /* byte size of sector */
6929 + int num_sectors; /* Num sectors of this size */
6930 + } erase_block[8]; /* Max of 256, but 8 is good */
6931 +};
6932 +
6933 +/* Standard Boolean declarations */
6934 +#define TRUE 1
6935 +#define FALSE 0
6936 +
6937 +/* Define different type of flash */
6938 +#define FLASH_UNDEFINED 0
6939 +#define FLASH_AMD 1
6940 +#define FLASH_INTEL 2
6941 +#define FLASH_SST 3
6942 +
6943 +/* Command codes for the flash_command routine */
6944 +#define FLASH_RESET 0 /* reset to read mode */
6945 +#define FLASH_READ_ID 1 /* read device ID */
6946 +#define FLASH_CFIQUERY 2 /* CFI query */
6947 +#define FLASH_UB 3 /* go into unlock bypass mode */
6948 +#define FLASH_PROG 4 /* program a word */
6949 +#define FLASH_UBRESET 5 /* reset to read mode from unlock bypass mode */
6950 +#define FLASH_SERASE 6 /* sector erase */
6951 +
6952 +/* Return codes from flash_status */
6953 +#define STATUS_READY 0 /* ready for action */
6954 +#define STATUS_TIMEOUT 1 /* operation timed out */
6955 +
6956 +/* A list of AMD compatible device ID's - add others as needed */
6957 +#define ID_AM29DL800T 0x224A
6958 +#define ID_AM29DL800B 0x22CB
6959 +#define ID_AM29LV800T 0x22DA
6960 +#define ID_AM29LV800B 0x225B
6961 +#define ID_AM29LV400B 0x22BA
6962 +
6963 +#define ID_AM29LV160B 0x2249
6964 +#define ID_AM29LV160T 0x22C4
6965 +
6966 +#define ID_AM29LV320T 0x22F6
6967 +#define ID_MX29LV320AT 0x22A7
6968 +#define ID_AM29LV320B 0x22F9
6969 +#define ID_MX29LV320AB 0x22A8
6970 +
6971 +#define ID_AM29LV320M 0x227E
6972 +#define ID_AM29LV320MB 0x2200
6973 +#define ID_AM29LV320MT 0x2201
6974 +
6975 +#define ID_SST39VF1601 0x234B
6976 +#define ID_SST39VF3201 0x235B
6977 +
6978 +/* A list of Intel compatible device ID's - add others as needed */
6979 +#define ID_I28F160C3T 0x88C2
6980 +#define ID_I28F160C3B 0x88C3
6981 +#define ID_I28F320C3T 0x88C4
6982 +#define ID_I28F320C3B 0x88C5
6983 +
6984 +extern byte flash_init(void);
6985 +extern int flash_write_buf(WORD sector, int offset, byte *buffer, int numbytes);
6986 +extern int flash_read_buf(WORD sector, int offset, byte *buffer, int numbytes);
6987 +extern byte flash_sector_erase_int(WORD sector);
6988 +extern int flash_get_numsectors(void);
6989 +extern int flash_get_sector_size(WORD sector);
6990 +extern int flash_get_total_size(void);
6991 +extern unsigned char *flash_get_memptr(WORD sector);
6992 +extern int flash_get_blk(int addr);
6993 +
6994 +#if defined __cplusplus
6995 +}
6996 +#endif
6997 +
6998 +#endif
6999 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/irq.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/irq.c
7000 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/irq.c 1970-01-01 01:00:00.000000000 +0100
7001 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/irq.c 2006-07-07 22:15:18.000000000 +0200
7002 @@ -0,0 +1,274 @@
7003 +/*
7004 +<:copyright-gpl
7005 + Copyright 2002 Broadcom Corp. All Rights Reserved.
7006 +
7007 + This program is free software; you can distribute it and/or modify it
7008 + under the terms of the GNU General Public License (Version 2) as
7009 + published by the Free Software Foundation.
7010 +
7011 + This program is distributed in the hope it will be useful, but WITHOUT
7012 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
7013 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
7014 + for more details.
7015 +
7016 + You should have received a copy of the GNU General Public License along
7017 + with this program; if not, write to the Free Software Foundation, Inc.,
7018 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
7019 +:>
7020 +*/
7021 +/*
7022 + * Interrupt control functions for Broadcom 963xx MIPS boards
7023 + */
7024 +
7025 +#include <asm/atomic.h>
7026 +
7027 +#include <linux/delay.h>
7028 +#include <linux/init.h>
7029 +#include <linux/ioport.h>
7030 +#include <linux/irq.h>
7031 +#include <linux/interrupt.h>
7032 +#include <linux/kernel.h>
7033 +#include <linux/slab.h>
7034 +#include <linux/module.h>
7035 +
7036 +#include <asm/irq.h>
7037 +#include <asm/mipsregs.h>
7038 +#include <asm/addrspace.h>
7039 +#include <asm/signal.h>
7040 +#include <bcm_map_part.h>
7041 +#include <bcm_intr.h>
7042 +
7043 +static void irq_dispatch_int(struct pt_regs *regs)
7044 +{
7045 + unsigned int pendingIrqs;
7046 + static unsigned int irqBit;
7047 + static unsigned int isrNumber = 31;
7048 +
7049 + pendingIrqs = PERF->IrqStatus & PERF->IrqMask;
7050 + if (!pendingIrqs) {
7051 + return;
7052 + }
7053 +
7054 + while (1) {
7055 + irqBit <<= 1;
7056 + isrNumber++;
7057 + if (isrNumber == 32) {
7058 + isrNumber = 0;
7059 + irqBit = 0x1;
7060 + }
7061 + if (pendingIrqs & irqBit) {
7062 + PERF->IrqMask &= ~irqBit; // mask
7063 + do_IRQ(isrNumber + INTERNAL_ISR_TABLE_OFFSET, regs);
7064 + break;
7065 + }
7066 + }
7067 +}
7068 +
7069 +static void irq_dispatch_ext(uint32 irq, struct pt_regs *regs)
7070 +{
7071 + if (!(PERF->ExtIrqCfg & (1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_MASK_SHFT)))) {
7072 + printk("**** Ext IRQ mask. Should not dispatch ****\n");
7073 + }
7074 + /* disable and clear interrupt in the controller */
7075 + PERF->ExtIrqCfg |= (1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_CLEAR_SHFT));
7076 + PERF->ExtIrqCfg &= ~(1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_MASK_SHFT));
7077 + do_IRQ(irq, regs);
7078 +}
7079 +
7080 +void brcm_irq_dispatch(struct pt_regs *regs)
7081 +{
7082 + u32 cause;
7083 + while((cause = (read_c0_cause()& CAUSEF_IP))) {
7084 + if (cause & CAUSEF_IP7)
7085 + do_IRQ(MIPS_TIMER_INT, regs);
7086 + else if (cause & CAUSEF_IP2)
7087 + irq_dispatch_int(regs);
7088 + else if (cause & CAUSEF_IP3)
7089 + irq_dispatch_ext(INTERRUPT_ID_EXTERNAL_0, regs);
7090 + else if (cause & CAUSEF_IP4)
7091 + irq_dispatch_ext(INTERRUPT_ID_EXTERNAL_1, regs);
7092 + else if (cause & CAUSEF_IP5)
7093 + irq_dispatch_ext(INTERRUPT_ID_EXTERNAL_2, regs);
7094 + else if (cause & CAUSEF_IP6)
7095 + irq_dispatch_ext(INTERRUPT_ID_EXTERNAL_3, regs);
7096 + cli();
7097 + }
7098 +}
7099 +
7100 +
7101 +void enable_brcm_irq(unsigned int irq)
7102 +{
7103 + unsigned long flags;
7104 +
7105 + local_irq_save(flags);
7106 + if( irq >= INTERNAL_ISR_TABLE_OFFSET ) {
7107 + PERF->IrqMask |= (1 << (irq - INTERNAL_ISR_TABLE_OFFSET));
7108 + }
7109 + else if (irq >= INTERRUPT_ID_EXTERNAL_0 && irq <= INTERRUPT_ID_EXTERNAL_3) {
7110 + /* enable and clear interrupt in the controller */
7111 + PERF->ExtIrqCfg |= (1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_CLEAR_SHFT));
7112 + PERF->ExtIrqCfg |= (1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_MASK_SHFT));
7113 + }
7114 + local_irq_restore(flags);
7115 +}
7116 +
7117 +void disable_brcm_irq(unsigned int irq)
7118 +{
7119 + unsigned long flags;
7120 +
7121 + local_irq_save(flags);
7122 + if( irq >= INTERNAL_ISR_TABLE_OFFSET ) {
7123 + PERF->IrqMask &= ~(1 << (irq - INTERNAL_ISR_TABLE_OFFSET));
7124 + }
7125 + else if (irq >= INTERRUPT_ID_EXTERNAL_0 && irq <= INTERRUPT_ID_EXTERNAL_3) {
7126 + /* disable interrupt in the controller */
7127 + PERF->ExtIrqCfg &= ~(1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_MASK_SHFT));
7128 + }
7129 + local_irq_restore(flags);
7130 +}
7131 +
7132 +void ack_brcm_irq(unsigned int irq)
7133 +{
7134 + /* Already done in brcm_irq_dispatch */
7135 +}
7136 +
7137 +unsigned int startup_brcm_irq(unsigned int irq)
7138 +{
7139 + enable_brcm_irq(irq);
7140 +
7141 + return 0; /* never anything pending */
7142 +}
7143 +
7144 +unsigned int startup_brcm_none(unsigned int irq)
7145 +{
7146 + return 0;
7147 +}
7148 +
7149 +void end_brcm_irq(unsigned int irq)
7150 +{
7151 + if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
7152 + enable_brcm_irq(irq);
7153 +}
7154 +
7155 +void end_brcm_none(unsigned int irq)
7156 +{
7157 +}
7158 +
7159 +#define ALLINTS_NOTIMER (IE_IRQ0 | IE_IRQ1 | IE_IRQ2 | IE_IRQ3 | IE_IRQ4)
7160 +
7161 +static void __init brcm_irq_setup(void)
7162 +{
7163 + extern asmlinkage void brcmIRQ(void);
7164 +
7165 + clear_c0_status(ST0_BEV);
7166 + set_except_vector(0, brcmIRQ);
7167 + change_c0_status(ST0_IM, ALLINTS_NOTIMER);
7168 +
7169 +#ifdef CONFIG_REMOTE_DEBUG
7170 + rs_kgdb_hook(0);
7171 +#endif
7172 +}
7173 +
7174 +static struct hw_interrupt_type brcm_irq_type = {
7175 + .typename = "MIPS",
7176 + .startup = startup_brcm_irq,
7177 + .shutdown = disable_brcm_irq,
7178 + .enable = enable_brcm_irq,
7179 + .disable = disable_brcm_irq,
7180 + .ack = ack_brcm_irq,
7181 + .end = end_brcm_irq,
7182 + .set_affinity = NULL
7183 +};
7184 +
7185 +static struct hw_interrupt_type brcm_irq_no_end_type = {
7186 + .typename = "MIPS",
7187 + .startup = startup_brcm_none,
7188 + .shutdown = disable_brcm_irq,
7189 + .enable = enable_brcm_irq,
7190 + .disable = disable_brcm_irq,
7191 + .ack = ack_brcm_irq,
7192 + .end = end_brcm_none,
7193 + .set_affinity = NULL
7194 +};
7195 +
7196 +void __init arch_init_irq(void)
7197 +{
7198 + int i;
7199 +
7200 + for (i = 0; i < NR_IRQS; i++) {
7201 + irq_desc[i].status = IRQ_DISABLED;
7202 + irq_desc[i].action = 0;
7203 + irq_desc[i].depth = 1;
7204 + irq_desc[i].handler = &brcm_irq_type;
7205 + }
7206 +
7207 + brcm_irq_setup();
7208 +}
7209 +
7210 +int request_external_irq(unsigned int irq,
7211 + FN_HANDLER handler,
7212 + unsigned long irqflags,
7213 + const char * devname,
7214 + void *dev_id)
7215 +{
7216 + unsigned long flags;
7217 +
7218 + local_irq_save(flags);
7219 +
7220 + PERF->ExtIrqCfg |= (1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_CLEAR_SHFT)); // Clear
7221 + PERF->ExtIrqCfg &= ~(1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_MASK_SHFT)); // Mask
7222 + PERF->ExtIrqCfg &= ~(1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_INSENS_SHFT)); // Edge insesnsitive
7223 + PERF->ExtIrqCfg |= (1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_LEVEL_SHFT)); // Level triggered
7224 + PERF->ExtIrqCfg &= ~(1 << (irq - INTERRUPT_ID_EXTERNAL_0 + EI_SENSE_SHFT)); // Low level
7225 +
7226 + local_irq_restore(flags);
7227 +
7228 + return( request_irq(irq, handler, irqflags, devname, dev_id) );
7229 +}
7230 +
7231 +/* VxWorks compatibility function(s). */
7232 +
7233 +unsigned int BcmHalMapInterrupt(FN_HANDLER pfunc, unsigned int param,
7234 + unsigned int interruptId)
7235 +{
7236 + int nRet = -1;
7237 + char *devname;
7238 +
7239 + devname = kmalloc(16, GFP_KERNEL);
7240 + if (devname)
7241 + sprintf( devname, "brcm_%d", interruptId );
7242 +
7243 + /* Set the IRQ description to not automatically enable the interrupt at
7244 + * the end of an ISR. The driver that handles the interrupt must
7245 + * explicitly call BcmHalInterruptEnable or enable_brcm_irq. This behavior
7246 + * is consistent with interrupt handling on VxWorks.
7247 + */
7248 + irq_desc[interruptId].handler = &brcm_irq_no_end_type;
7249 +
7250 + if( interruptId >= INTERNAL_ISR_TABLE_OFFSET )
7251 + {
7252 + nRet = request_irq( interruptId, pfunc, SA_SAMPLE_RANDOM | SA_INTERRUPT,
7253 + devname, (void *) param );
7254 + }
7255 + else if (interruptId >= INTERRUPT_ID_EXTERNAL_0 && interruptId <= INTERRUPT_ID_EXTERNAL_3)
7256 + {
7257 + nRet = request_external_irq( interruptId, pfunc, SA_SAMPLE_RANDOM | SA_INTERRUPT,
7258 + devname, (void *) param );
7259 + }
7260 +
7261 + return( nRet );
7262 +}
7263 +
7264 +
7265 +/* Debug function. */
7266 +
7267 +void dump_intr_regs(void)
7268 +{
7269 + printk("PERF->ExtIrqCfg [%08x]\n", *(&(PERF->ExtIrqCfg)));
7270 +}
7271 +
7272 +EXPORT_SYMBOL(enable_brcm_irq);
7273 +EXPORT_SYMBOL(disable_brcm_irq);
7274 +EXPORT_SYMBOL(request_external_irq);
7275 +EXPORT_SYMBOL(BcmHalMapInterrupt);
7276 +
7277 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/Kconfig linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/Kconfig
7278 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/Kconfig 1970-01-01 01:00:00.000000000 +0100
7279 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/Kconfig 2006-07-07 22:15:18.000000000 +0200
7280 @@ -0,0 +1,172 @@
7281 +# Kernel and Driver configuration for Broadcom Commengine ADSL board
7282 +choice
7283 + prompt "Broadcom Commengine ADSL board"
7284 + depends on MIPS_BRCM
7285 + default BCM96345
7286 + help
7287 + Select different Broadcom ADSL board
7288 +
7289 +config BCM96338
7290 + bool "96338 ADSL board"
7291 + select DMA_NONCOHERENT
7292 + select HW_HAS_PCI
7293 +
7294 +config BCM96345
7295 + bool "96345 ADSL board"
7296 + select DMA_NONCOHERENT
7297 + select HW_HAS_PCI
7298 +
7299 +config BCM96348
7300 + bool "96348 ADSL board"
7301 + select DMA_NONCOHERENT
7302 + select HW_HAS_PCI
7303 +
7304 +endchoice
7305 +
7306 +config BCM_BOARD
7307 + bool "Support for Broadcom Board"
7308 + depends on BCM96338 || BCM96345 || BCM96348
7309 +
7310 +config BCM_SERIAL
7311 + bool "Support for Serial Port"
7312 + depends on BCM96338 || BCM96345 || BCM96348
7313 +
7314 +config BCM_ENET
7315 + tristate "Support for Ethernet"
7316 + depends on BCM96338 || BCM96345 || BCM96348
7317 +
7318 +config BCM_USB
7319 + tristate "Support for USB"
7320 + depends on BCM96338 || BCM96345 || BCM96348
7321 +
7322 +config BCM_WLAN
7323 + tristate "Support for Wireless"
7324 + depends on BCM96338 || BCM96345 || BCM96348
7325 +
7326 +config BCM_PCI
7327 + bool "Support for PCI"
7328 + depends on BCM96338 || BCM96345 || BCM96348
7329 + select PCI
7330 +
7331 +config BCM_ATMAPI
7332 + tristate "Support for ATM"
7333 + depends on BCM96338 || BCM96345 || BCM96348
7334 +
7335 +config BCM_ATMTEST
7336 + tristate "Support for ATM Diagnostic"
7337 + depends on BCM96338 || BCM96345 || BCM96348
7338 +
7339 +config BCM_ADSL
7340 + tristate "Support for ADSL"
7341 + depends on BCM96338 || BCM96345 || BCM96348
7342 +
7343 +config BCM_ENDPOINT
7344 + tristate "Support for VOICE"
7345 + depends on BCM96338 || BCM96345 || BCM96348
7346 +
7347 +config BCM_PROCFS
7348 + tristate "Support for PROCFS"
7349 + depends on BCM96338 || BCM96345 || BCM96348
7350 +
7351 +config BCM_VDSL
7352 + tristate "Support for VDSL"
7353 + depends on BCM96338 || BCM96345 || BCM96348
7354 +
7355 +config BCM_SECURITY
7356 + tristate "Support for SECURITY"
7357 + depends on BCM96338 || BCM96345 || BCM96348
7358 +
7359 +config BCM_HPNA
7360 + tristate "Support for HPNA"
7361 + depends on BCM96338 || BCM96345 || BCM96348
7362 +
7363 +config BCM_BOARD_IMPL
7364 + int "Implementation index for ADSL Board"
7365 + depends on BCM96338 || BCM96345 || BCM96348
7366 +
7367 +config BCM_SERIAL_IMPL
7368 + int "Implementation index for Serial"
7369 + depends on BCM96338 || BCM96345 || BCM96348
7370 +
7371 +config BCM_ENET_IMPL
7372 + int "Implementation index for Ethernet"
7373 + depends on BCM96338 || BCM96345 || BCM96348
7374 +
7375 +config BCM_USB_IMPL
7376 + int "Implementation index for USB"
7377 + depends on BCM96338 || BCM96345 || BCM96348
7378 +
7379 +config BCM_WLAN_IMPL
7380 + int "Implementation index for WIRELESS"
7381 + depends on BCM96338 || BCM96345 || BCM96348
7382 +
7383 +config BCM_ATMAPI_IMPL
7384 + int "Implementation index for ATM"
7385 + depends on BCM96338 || BCM96345 || BCM96348
7386 +
7387 +config BCM_ATMTEST_IMPL
7388 + int "Implementation index for ATM Diagnostic"
7389 + depends on BCM96338 || BCM96345 || BCM96348
7390 +
7391 +config BCM_BLAA_IMPL
7392 + int "Implementation index for BLAA"
7393 + depends on BCM96338 || BCM96345 || BCM96348
7394 +
7395 +config BCM_ADSL_IMPL
7396 + int "Implementation index for ADSL"
7397 + depends on BCM96338 || BCM96345 || BCM96348
7398 +
7399 +config BCM_ENDPOINT_IMPL
7400 + int "Implementation index for VOICE"
7401 + depends on BCM96338 || BCM96345 || BCM96348
7402 +
7403 +config BCM_PROCFS_IMPL
7404 + int "Implementation index for PROCFS"
7405 + depends on BCM96338 || BCM96345 || BCM96348
7406 +
7407 +config BCM_VDSL_IMPL
7408 + int "Implementation index for VDSL"
7409 + depends on BCM96338 || BCM96345 || BCM96348
7410 +
7411 +config BCM_SECURITY_IMPL
7412 + int "Implementation index for SECURITY"
7413 + depends on BCM96338 || BCM96345 || BCM96348
7414 +
7415 +config BCM_HPNA_IMPL
7416 + int "Implementation index for HPNA"
7417 + depends on BCM96338 || BCM96345 || BCM96348
7418 +
7419 +choice
7420 + prompt "Root File System"
7421 + depends on MIPS_BRCM
7422 + default ROOTFS_SQUASHFS
7423 + help
7424 + Select root file system on the board flash.
7425 +
7426 +config ROOTFS_SQUASHFS
7427 + bool "SQUASHFS"
7428 +config ROOTFS_CRAMFS
7429 + bool "CRAMFS"
7430 +config ROOTFS_JFFS2
7431 + bool "JFFS2"
7432 +config ROOTFS_NFS
7433 + bool "NFS"
7434 +
7435 +endchoice
7436 +
7437 +config ROOT_FLASHFS
7438 + string "flash partition"
7439 + depends on ROOTFS_SQUASHFS || ROOTFS_CRAMFS || ROOTFS_JFFS2
7440 + default "root=31:0 ro noinitrd" if ROOTFS_SQUASHFS = y || ROOTFS_CRAMFS = y
7441 + default "root=31:2 ro noinitrd" if ROOTFS_JFFS2 = y
7442 + help
7443 + This is the root file system partition on flash memory
7444 +
7445 +config ROOT_NFS_DIR
7446 + string "NFS server path"
7447 + depends on ROOTFS_NFS
7448 + default "/opt/bcm96338/targets/96338R/fs" if BCM96338 = y
7449 + default "/opt/bcm96345/targets/96345R/fs" if BCM96345 = y
7450 + default "/opt/bcm96348/targets/96348R/fs" if BCM96348 = y
7451 + help
7452 + This is the path of NFS server (host system)
7453 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/Makefile linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/Makefile
7454 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/Makefile 1970-01-01 01:00:00.000000000 +0100
7455 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/Makefile 2006-07-07 22:18:20.000000000 +0200
7456 @@ -0,0 +1,23 @@
7457 +#
7458 +# Makefile for generic Broadcom MIPS boards
7459 +#
7460 +# Copyright (C) 2004 Broadcom Corporation
7461 +#
7462 +obj-y := irq.o prom.o setup.o time.o ser_init.o bcm63xx_flash.o bcm63xx_led.o board.o boardparms.o cfiflash.o
7463 +
7464 +SRCBASE := $(TOPDIR)
7465 +EXTRA_CFLAGS += -I$(SRCBASE)/include
7466 +#EXTRA_CFLAGS += -I$(INC_ADSLDRV_PATH) -DDBG
7467 +EXTRA_CFLAGS += -I$(INC_ADSLDRV_PATH)
7468 +
7469 +
7470 +ifeq "$(ADSL)" "ANNEX_B"
7471 +EXTRA_CFLAGS += -DADSL_ANNEXB
7472 +endif
7473 +ifeq "$(ADSL)" "SADSL"
7474 +EXTRA_CFLAGS += -DADSL_SADSL
7475 +endif
7476 +ifeq "$(ADSL)" "ANNEX_C"
7477 +EXTRA_CFLAGS += -DADSL_ANNEXC
7478 +endif
7479 +
7480 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/prom.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/prom.c
7481 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/prom.c 1970-01-01 01:00:00.000000000 +0100
7482 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/prom.c 2006-07-07 22:15:18.000000000 +0200
7483 @@ -0,0 +1,236 @@
7484 +/*
7485 +<:copyright-gpl
7486 + Copyright 2004 Broadcom Corp. All Rights Reserved.
7487 +
7488 + This program is free software; you can distribute it and/or modify it
7489 + under the terms of the GNU General Public License (Version 2) as
7490 + published by the Free Software Foundation.
7491 +
7492 + This program is distributed in the hope it will be useful, but WITHOUT
7493 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
7494 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
7495 + for more details.
7496 +
7497 + You should have received a copy of the GNU General Public License along
7498 + with this program; if not, write to the Free Software Foundation, Inc.,
7499 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
7500 +:>
7501 +*/
7502 +/*
7503 + * prom.c: PROM library initialization code.
7504 + *
7505 + */
7506 +#include <linux/init.h>
7507 +#include <linux/mm.h>
7508 +#include <linux/sched.h>
7509 +#include <linux/bootmem.h>
7510 +#include <linux/blkdev.h>
7511 +#include <asm/addrspace.h>
7512 +#include <asm/bootinfo.h>
7513 +#include <asm/cpu.h>
7514 +#include <asm/time.h>
7515 +
7516 +#include <bcm_map_part.h>
7517 +#include <board.h>
7518 +#include "boardparms.h"
7519 +#include "softdsl/AdslCoreDefs.h"
7520 +
7521 +
7522 +extern int do_syslog(int, char *, int);
7523 +extern void serial_init(void);
7524 +extern void __init InitNvramInfo( void );
7525 +/*extern void kerSysFlashInit( void );*/
7526 +/*extern unsigned long get_nvram_start_addr(void);*/
7527 +void __init create_root_nfs_cmdline( char *cmdline );
7528 +
7529 +#if defined(CONFIG_BCM96338)
7530 +#define CPU_CLOCK 240000000
7531 +#define MACH_BCM MACH_BCM96338
7532 +#endif
7533 +#if defined(CONFIG_BCM96345)
7534 +#define CPU_CLOCK 140000000
7535 +#define MACH_BCM MACH_BCM96345
7536 +#endif
7537 +#if defined(CONFIG_BCM96348)
7538 +void __init calculateCpuSpeed(void);
7539 +static unsigned long cpu_speed;
7540 +#define CPU_CLOCK cpu_speed
7541 +#define MACH_BCM MACH_BCM96348
7542 +#endif
7543 +
7544 +const char *get_system_type(void)
7545 +{/*
7546 + PNVRAM_DATA pNvramData = (PNVRAM_DATA) get_nvram_start_addr();
7547 +
7548 + return( pNvramData->szBoardId );*/
7549 + return "brcm63xx";
7550 +}
7551 +
7552 +unsigned long getMemorySize(void)
7553 +{
7554 + unsigned long ulSdramType = BOARD_SDRAM_TYPE;
7555 +
7556 + unsigned long ulSdramSize;
7557 +
7558 + switch( ulSdramType )
7559 + {
7560 + case BP_MEMORY_16MB_1_CHIP:
7561 + case BP_MEMORY_16MB_2_CHIP:
7562 + ulSdramSize = 16 * 1024 * 1024;
7563 + break;
7564 + case BP_MEMORY_32MB_1_CHIP:
7565 + case BP_MEMORY_32MB_2_CHIP:
7566 + ulSdramSize = 32 * 1024 * 1024;
7567 + break;
7568 + case BP_MEMORY_64MB_2_CHIP:
7569 + ulSdramSize = 64 * 1024 * 1024;
7570 + break;
7571 + default:
7572 + ulSdramSize = 8 * 1024 * 1024;
7573 + break;
7574 + }
7575 +
7576 + return ulSdramSize;
7577 +}
7578 +
7579 +/* --------------------------------------------------------------------------
7580 + Name: prom_init
7581 + -------------------------------------------------------------------------- */
7582 +void __init prom_init(void)
7583 +{
7584 + extern ulong r4k_interval;
7585 +
7586 + serial_init();
7587 +
7588 + /*kerSysFlashInit();*/
7589 +
7590 + do_syslog(8, NULL, 8);
7591 +
7592 + printk( "%s prom init\n", get_system_type() );
7593 +
7594 + PERF->IrqMask = 0;
7595 +
7596 + arcs_cmdline[0] = '\0';
7597 +#if 0
7598 +#if defined(CONFIG_ROOT_NFS)
7599 + create_root_nfs_cmdline( arcs_cmdline );
7600 +#endif
7601 +#elif defined(CONFIG_ROOT_FLASHFS)
7602 + strcpy(arcs_cmdline, CONFIG_ROOT_FLASHFS);
7603 +#endif
7604 +
7605 + add_memory_region(0, (getMemorySize() - ADSL_SDRAM_IMAGE_SIZE), BOOT_MEM_RAM);
7606 +
7607 +#if defined(CONFIG_BCM96348)
7608 + calculateCpuSpeed();
7609 +#endif
7610 + /* Count register increments every other clock */
7611 + r4k_interval = CPU_CLOCK / HZ / 2;
7612 + mips_hpt_frequency = CPU_CLOCK / 2;
7613 +
7614 + mips_machgroup = MACH_GROUP_BRCM;
7615 + mips_machtype = MACH_BCM;
7616 +}
7617 +
7618 +/* --------------------------------------------------------------------------
7619 + Name: prom_free_prom_memory
7620 +Abstract:
7621 + -------------------------------------------------------------------------- */
7622 +void __init prom_free_prom_memory(void)
7623 +{
7624 +
7625 +}
7626 +
7627 +#if 0
7628 +#if defined(CONFIG_ROOT_NFS)
7629 +/* This function reads in a line that looks something like this:
7630 + *
7631 + *
7632 + * CFE bootline=bcmEnet(0,0)host:vmlinux e=192.169.0.100:ffffff00 h=192.169.0.1
7633 + *
7634 + *
7635 + * and retuns in the cmdline parameter some that looks like this:
7636 + *
7637 + * CONFIG_CMDLINE="root=/dev/nfs nfsroot=192.168.0.1:/opt/targets/96345R/fs
7638 + * ip=192.168.0.100:192.168.0.1::255.255.255.0::eth0:off rw"
7639 + */
7640 +#define BOOT_LINE_ADDR 0x0
7641 +#define HEXDIGIT(d) ((d >= '0' && d <= '9') ? (d - '0') : ((d | 0x20) - 'W'))
7642 +#define HEXBYTE(b) (HEXDIGIT((b)[0]) << 4) + HEXDIGIT((b)[1])
7643 +extern unsigned long get_nvram_start_addr(void);
7644 +
7645 +void __init create_root_nfs_cmdline( char *cmdline )
7646 +{
7647 + char root_nfs_cl[] = "root=/dev/nfs nfsroot=%s:" CONFIG_ROOT_NFS_DIR
7648 + " ip=%s:%s::%s::eth0:off rw";
7649 +
7650 + char *localip = NULL;
7651 + char *hostip = NULL;
7652 + char mask[16] = "";
7653 + PNVRAM_DATA pNvramData = (PNVRAM_DATA) get_nvram_start_addr();
7654 + char bootline[128] = "";
7655 + char *p = bootline;
7656 +
7657 + memcpy(bootline, pNvramData->szBootline, sizeof(bootline));
7658 + while( *p )
7659 + {
7660 + if( p[0] == 'e' && p[1] == '=' )
7661 + {
7662 + /* Found local ip address */
7663 + p += 2;
7664 + localip = p;
7665 + while( *p && *p != ' ' && *p != ':' )
7666 + p++;
7667 + if( *p == ':' )
7668 + {
7669 + /* Found network mask (eg FFFFFF00 */
7670 + *p++ = '\0';
7671 + sprintf( mask, "%u.%u.%u.%u", HEXBYTE(p), HEXBYTE(p + 2),
7672 + HEXBYTE(p + 4), HEXBYTE(p + 6) );
7673 + p += 4;
7674 + }
7675 + else if( *p == ' ' )
7676 + *p++ = '\0';
7677 + }
7678 + else if( p[0] == 'h' && p[1] == '=' )
7679 + {
7680 + /* Found host ip address */
7681 + p += 2;
7682 + hostip = p;
7683 + while( *p && *p != ' ' )
7684 + p++;
7685 + if( *p == ' ' )
7686 + *p++ = '\0';
7687 + }
7688 + else
7689 + p++;
7690 + }
7691 +
7692 + if( localip && hostip )
7693 + sprintf( cmdline, root_nfs_cl, hostip, localip, hostip, mask );
7694 +}
7695 +#endif
7696 +#endif
7697 +
7698 +#if defined(CONFIG_BCM96348)
7699 +/* *********************************************************************
7700 + * calculateCpuSpeed()
7701 + * Calculate the BCM6348 CPU speed by reading the PLL strap register
7702 + * and applying the following formula:
7703 + * cpu_clk = (.25 * 64MHz freq) * (N1 + 1) * (N2 + 2) / (M1_CPU + 1)
7704 + * Input parameters:
7705 + * none
7706 + * Return value:
7707 + * none
7708 + ********************************************************************* */
7709 +void __init calculateCpuSpeed(void)
7710 +{
7711 + UINT32 pllStrap = PERF->PllStrap;
7712 + int n1 = (pllStrap & PLL_N1_MASK) >> PLL_N1_SHFT;
7713 + int n2 = (pllStrap & PLL_N2_MASK) >> PLL_N2_SHFT;
7714 + int m1cpu = (pllStrap & PLL_M1_CPU_MASK) >> PLL_M1_CPU_SHFT;
7715 +
7716 + cpu_speed = (16 * (n1 + 1) * (n2 + 2) / (m1cpu + 1)) * 1000000;
7717 +}
7718 +#endif
7719 +
7720 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/ser_init.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/ser_init.c
7721 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/ser_init.c 1970-01-01 01:00:00.000000000 +0100
7722 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/ser_init.c 2006-07-07 22:15:18.000000000 +0200
7723 @@ -0,0 +1,180 @@
7724 +/*
7725 +<:copyright-gpl
7726 + Copyright 2004 Broadcom Corp. All Rights Reserved.
7727 +
7728 + This program is free software; you can distribute it and/or modify it
7729 + under the terms of the GNU General Public License (Version 2) as
7730 + published by the Free Software Foundation.
7731 +
7732 + This program is distributed in the hope it will be useful, but WITHOUT
7733 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
7734 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
7735 + for more details.
7736 +
7737 + You should have received a copy of the GNU General Public License along
7738 + with this program; if not, write to the Free Software Foundation, Inc.,
7739 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
7740 +:>
7741 +*/
7742 +/*
7743 + * Broadcom bcm63xx serial port initialization, also prepare for printk
7744 + * by registering with console_init
7745 + *
7746 + */
7747 +
7748 +#include <linux/config.h>
7749 +#include <linux/init.h>
7750 +#include <linux/interrupt.h>
7751 +#include <linux/kernel.h>
7752 +#include <linux/types.h>
7753 +#include <linux/console.h>
7754 +#include <linux/sched.h>
7755 +
7756 +#include <asm/addrspace.h>
7757 +#include <asm/irq.h>
7758 +#include <asm/reboot.h>
7759 +#include <asm/gdb-stub.h>
7760 +#include <asm/mc146818rtc.h>
7761 +
7762 +#include <bcm_map_part.h>
7763 +#include <board.h>
7764 +
7765 +#define SER63XX_DEFAULT_BAUD 115200
7766 +#define BD_BCM63XX_TIMER_CLOCK_INPUT (FPERIPH)
7767 +#define stUart ((volatile Uart * const) UART_BASE)
7768 +
7769 +// Transmit interrupts
7770 +#define TXINT (TXFIFOEMT | TXUNDERR | TXOVFERR)
7771 +// Receive interrupts
7772 +#define RXINT (RXFIFONE | RXOVFERR)
7773 +
7774 +/* --------------------------------------------------------------------------
7775 + Name: serial_init
7776 + Purpose: Initalize the UART
7777 +-------------------------------------------------------------------------- */
7778 +void __init serial_init(void)
7779 +{
7780 + UINT32 tmpVal = SER63XX_DEFAULT_BAUD;
7781 + ULONG clockFreqHz;
7782 +
7783 +#if defined(CONFIG_BCM96345)
7784 + // Make sure clock is ticking
7785 + PERF->blkEnables |= UART_CLK_EN;
7786 +#endif
7787 +
7788 + /* Dissable channel's receiver and transmitter. */
7789 + stUart->control &= ~(BRGEN|TXEN|RXEN);
7790 +
7791 + /*--------------------------------------------------------------------*/
7792 + /* Write the table value to the clock select register. */
7793 + /* DPullen - this is the equation to use: */
7794 + /* value = clockFreqHz / baud / 32-1; */
7795 + /* (snmod) Actually you should also take into account any necessary */
7796 + /* rounding. Divide by 16, look at lsb, if 0, divide by 2 */
7797 + /* and subtract 1. If 1, just divide by 2 */
7798 + /*--------------------------------------------------------------------*/
7799 + clockFreqHz = BD_BCM63XX_TIMER_CLOCK_INPUT;
7800 + tmpVal = (clockFreqHz / tmpVal) / 16;
7801 + if( tmpVal & 0x01 )
7802 + tmpVal /= 2; //Rounding up, so sub is already accounted for
7803 + else
7804 + tmpVal = (tmpVal / 2) - 1; // Rounding down so we must sub 1
7805 + stUart->baudword = tmpVal;
7806 +
7807 + /* Finally, re-enable the transmitter and receiver. */
7808 + stUart->control |= (BRGEN|TXEN|RXEN);
7809 +
7810 + stUart->config = (BITS8SYM | ONESTOP);
7811 + // Set the FIFO interrupt depth ... stUart->fifocfg = 0xAA;
7812 + stUart->fifoctl = RSTTXFIFOS | RSTRXFIFOS;
7813 + stUart->intMask = 0;
7814 + stUart->intMask = RXINT | TXINT;
7815 +}
7816 +
7817 +
7818 +/* prom_putc()
7819 + * Output a character to the UART
7820 + */
7821 +void prom_putc(char c)
7822 +{
7823 + /* Wait for Tx uffer to empty */
7824 + while (! (READ16(stUart->intStatus) & TXFIFOEMT));
7825 + /* Send character */
7826 + stUart->Data = c;
7827 +}
7828 +
7829 +/* prom_puts()
7830 + * Write a string to the UART
7831 + */
7832 +void prom_puts(const char *s)
7833 +{
7834 + while (*s) {
7835 + if (*s == '\n') {
7836 + prom_putc('\r');
7837 + }
7838 + prom_putc(*s++);
7839 + }
7840 +}
7841 +
7842 +
7843 +/* prom_getc_nowait()
7844 + * Returns a character from the UART
7845 + * Returns -1 if no characters available or corrupted
7846 + */
7847 +int prom_getc_nowait(void)
7848 +{
7849 + uint16 uStatus;
7850 + int cData = -1;
7851 +
7852 + uStatus = READ16(stUart->intStatus);
7853 +
7854 + if (uStatus & RXFIFONE) { /* Do we have a character? */
7855 + cData = READ16(stUart->Data) & 0xff; /* Read character */
7856 + if (uStatus & (RXFRAMERR | RXPARERR)) { /* If we got an error, throw it away */
7857 + cData = -1;
7858 + }
7859 + }
7860 +
7861 + return cData;
7862 +}
7863 +
7864 +/* prom_getc()
7865 + * Returns a charcter from the serial port
7866 + * Will block until it receives a valid character
7867 +*/
7868 +char prom_getc(void)
7869 +{
7870 + int cData = -1;
7871 +
7872 + /* Loop until we get a valid character */
7873 + while(cData == -1) {
7874 + cData = prom_getc_nowait();
7875 + }
7876 + return (char) cData;
7877 +}
7878 +
7879 +/* prom_testc()
7880 + * Returns 0 if no characters available
7881 + */
7882 +int prom_testc(void)
7883 +{
7884 + uint16 uStatus;
7885 +
7886 + uStatus = READ16(stUart->intStatus);
7887 +
7888 + return (uStatus & RXFIFONE);
7889 +}
7890 +
7891 +#if CONFIG_REMOTE_DEBUG
7892 +/* Prevent other code from writing to the serial port */
7893 +void _putc(char c) { }
7894 +void _puts(const char *ptr) { }
7895 +#else
7896 +/* Low level outputs call prom routines */
7897 +void _putc(char c) {
7898 + prom_putc(c);
7899 +}
7900 +void _puts(const char *ptr) {
7901 + prom_puts(ptr);
7902 +}
7903 +#endif
7904 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/setup.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/setup.c
7905 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/setup.c 1970-01-01 01:00:00.000000000 +0100
7906 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/setup.c 2006-07-07 22:15:18.000000000 +0200
7907 @@ -0,0 +1,523 @@
7908 +/*
7909 +<:copyright-gpl
7910 + Copyright 2002 Broadcom Corp. All Rights Reserved.
7911 +
7912 + This program is free software; you can distribute it and/or modify it
7913 + under the terms of the GNU General Public License (Version 2) as
7914 + published by the Free Software Foundation.
7915 +
7916 + This program is distributed in the hope it will be useful, but WITHOUT
7917 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
7918 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
7919 + for more details.
7920 +
7921 + You should have received a copy of the GNU General Public License along
7922 + with this program; if not, write to the Free Software Foundation, Inc.,
7923 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
7924 +:>
7925 +*/
7926 +/*
7927 + * Generic setup routines for Broadcom 963xx MIPS boards
7928 + */
7929 +
7930 +#include <linux/config.h>
7931 +#include <linux/init.h>
7932 +#include <linux/interrupt.h>
7933 +#include <linux/kernel.h>
7934 +#include <linux/kdev_t.h>
7935 +#include <linux/types.h>
7936 +#include <linux/console.h>
7937 +#include <linux/sched.h>
7938 +#include <linux/mm.h>
7939 +#include <linux/slab.h>
7940 +#include <linux/module.h>
7941 +#include <linux/pm.h>
7942 +
7943 +#include <asm/addrspace.h>
7944 +#include <asm/bcache.h>
7945 +#include <asm/irq.h>
7946 +#include <asm/time.h>
7947 +#include <asm/reboot.h>
7948 +#include <asm/gdb-stub.h>
7949 +
7950 +extern void brcm_timer_setup(struct irqaction *irq);
7951 +extern unsigned long getMemorySize(void);
7952 +
7953 +#if defined(CONFIG_BCM96348) && defined(CONFIG_PCI)
7954 +#include <linux/pci.h>
7955 +#include <linux/delay.h>
7956 +#include <bcm_map_part.h>
7957 +#include <bcmpci.h>
7958 +
7959 +static volatile MpiRegisters * mpi = (MpiRegisters *)(MPI_BASE);
7960 +#endif
7961 +
7962 +/* This function should be in a board specific directory. For now,
7963 + * assume that all boards that include this file use a Broadcom chip
7964 + * with a soft reset bit in the PLL control register.
7965 + */
7966 +static void brcm_machine_restart(char *command)
7967 +{
7968 + const unsigned long ulSoftReset = 0x00000001;
7969 + unsigned long *pulPllCtrl = (unsigned long *) 0xfffe0008;
7970 + *pulPllCtrl |= ulSoftReset;
7971 +}
7972 +
7973 +static void brcm_machine_halt(void)
7974 +{
7975 + printk("System halted\n");
7976 + while (1);
7977 +}
7978 +
7979 +#if defined(CONFIG_BCM96348) && defined(CONFIG_PCI)
7980 +
7981 +static void mpi_SetLocalPciConfigReg(uint32 reg, uint32 value)
7982 +{
7983 + /* write index then value */
7984 + mpi->pcicfgcntrl = PCI_CFG_REG_WRITE_EN + reg;;
7985 + mpi->pcicfgdata = value;
7986 +}
7987 +
7988 +static uint32 mpi_GetLocalPciConfigReg(uint32 reg)
7989 +{
7990 + /* write index then get value */
7991 + mpi->pcicfgcntrl = PCI_CFG_REG_WRITE_EN + reg;;
7992 + return mpi->pcicfgdata;
7993 +}
7994 +
7995 +/*
7996 + * mpi_ResetPcCard: Set/Reset the PcCard
7997 + */
7998 +static void mpi_ResetPcCard(int cardtype, BOOL bReset)
7999 +{
8000 + if (cardtype == MPI_CARDTYPE_NONE) {
8001 + return;
8002 + }
8003 +
8004 + if (cardtype == MPI_CARDTYPE_CARDBUS) {
8005 + bReset = ! bReset;
8006 + }
8007 +
8008 + if (bReset) {
8009 + mpi->pcmcia_cntl1 = (mpi->pcmcia_cntl1 & ~PCCARD_CARD_RESET);
8010 + } else {
8011 + mpi->pcmcia_cntl1 = (mpi->pcmcia_cntl1 | PCCARD_CARD_RESET);
8012 + }
8013 +}
8014 +
8015 +/*
8016 + * mpi_ConfigCs: Configure an MPI/EBI chip select
8017 + */
8018 +static void mpi_ConfigCs(uint32 cs, uint32 base, uint32 size, uint32 flags)
8019 +{
8020 + mpi->cs[cs].base = ((base & 0x1FFFFFFF) | size);
8021 + mpi->cs[cs].config = flags;
8022 +}
8023 +
8024 +/*
8025 + * mpi_InitPcmciaSpace
8026 + */
8027 +static void mpi_InitPcmciaSpace(void)
8028 +{
8029 + // ChipSelect 4 controls PCMCIA Memory accesses
8030 + mpi_ConfigCs(PCMCIA_COMMON_BASE, pcmciaMem, EBI_SIZE_1M, (EBI_WORD_WIDE|EBI_ENABLE));
8031 + // ChipSelect 5 controls PCMCIA Attribute accesses
8032 + mpi_ConfigCs(PCMCIA_ATTRIBUTE_BASE, pcmciaAttr, EBI_SIZE_1M, (EBI_WORD_WIDE|EBI_ENABLE));
8033 + // ChipSelect 6 controls PCMCIA I/O accesses
8034 + mpi_ConfigCs(PCMCIA_IO_BASE, pcmciaIo, EBI_SIZE_64K, (EBI_WORD_WIDE|EBI_ENABLE));
8035 +
8036 + mpi->pcmcia_cntl2 = ((PCMCIA_ATTR_ACTIVE << RW_ACTIVE_CNT_BIT) |
8037 + (PCMCIA_ATTR_INACTIVE << INACTIVE_CNT_BIT) |
8038 + (PCMCIA_ATTR_CE_SETUP << CE_SETUP_CNT_BIT) |
8039 + (PCMCIA_ATTR_CE_HOLD << CE_HOLD_CNT_BIT));
8040 +
8041 + mpi->pcmcia_cntl2 |= (PCMCIA_HALFWORD_EN | PCMCIA_BYTESWAP_DIS);
8042 +}
8043 +
8044 +/*
8045 + * cardtype_vcc_detect: PC Card's card detect and voltage sense connection
8046 + *
8047 + * CD1#/ CD2#/ VS1#/ VS2#/ Card Initial Vcc
8048 + * CCD1# CCD2# CVS1 CVS2 Type
8049 + *
8050 + * GND GND open open 16-bit 5 vdc
8051 + *
8052 + * GND GND GND open 16-bit 3.3 vdc
8053 + *
8054 + * GND GND open GND 16-bit x.x vdc
8055 + *
8056 + * GND GND GND GND 16-bit 3.3 & x.x vdc
8057 + *
8058 + *====================================================================
8059 + *
8060 + * CVS1 GND CCD1# open CardBus 3.3 vdc
8061 + *
8062 + * GND CVS2 open CCD2# CardBus x.x vdc
8063 + *
8064 + * GND CVS1 CCD2# open CardBus y.y vdc
8065 + *
8066 + * GND CVS2 GND CCD2# CardBus 3.3 & x.x vdc
8067 + *
8068 + * CVS2 GND open CCD1# CardBus x.x & y.y vdc
8069 + *
8070 + * GND CVS1 CCD2# open CardBus 3.3, x.x & y.y vdc
8071 + *
8072 + */
8073 +static int cardtype_vcc_detect(void)
8074 +{
8075 + uint32 data32;
8076 + int cardtype;
8077 +
8078 + cardtype = MPI_CARDTYPE_NONE;
8079 + mpi->pcmcia_cntl1 = 0x0000A000; // Turn on the output enables and drive
8080 + // the CVS pins to 0.
8081 + data32 = mpi->pcmcia_cntl1;
8082 + switch (data32 & 0x00000003) // Test CD1# and CD2#, see if card is plugged in.
8083 + {
8084 + case 0x00000003: // No Card is in the slot.
8085 + printk("mpi: No Card is in the PCMCIA slot\n");
8086 + break;
8087 +
8088 + case 0x00000002: // Partial insertion, No CD2#.
8089 + printk("mpi: Card in the PCMCIA slot partial insertion, no CD2 signal\n");
8090 + break;
8091 +
8092 + case 0x00000001: // Partial insertion, No CD1#.
8093 + printk("mpi: Card in the PCMCIA slot partial insertion, no CD1 signal\n");
8094 + break;
8095 +
8096 + case 0x00000000:
8097 + mpi->pcmcia_cntl1 = 0x0000A0C0; // Turn off the CVS output enables and
8098 + // float the CVS pins.
8099 + mdelay(1);
8100 + data32 = mpi->pcmcia_cntl1;
8101 + // Read the Register.
8102 + switch (data32 & 0x0000000C) // See what is on the CVS pins.
8103 + {
8104 + case 0x00000000: // CVS1 and CVS2 are tied to ground, only 1 option.
8105 + printk("mpi: Detected 3.3 & x.x 16-bit PCMCIA card\n");
8106 + cardtype = MPI_CARDTYPE_PCMCIA;
8107 + break;
8108 +
8109 + case 0x00000004: // CVS1 is open or tied to CCD1/CCD2 and CVS2 is tied to ground.
8110 + // 2 valid voltage options.
8111 + switch (data32 & 0x00000003) // Test the values of CCD1 and CCD2.
8112 + {
8113 + case 0x00000003: // CCD1 and CCD2 are tied to 1 of the CVS pins.
8114 + // This is not a valid combination.
8115 + printk("mpi: Unknown card plugged into slot\n");
8116 + break;
8117 +
8118 + case 0x00000002: // CCD2 is tied to either CVS1 or CVS2.
8119 + mpi->pcmcia_cntl1 = 0x0000A080; // Drive CVS1 to a 0.
8120 + mdelay(1);
8121 + data32 = mpi->pcmcia_cntl1;
8122 + if (data32 & 0x00000002) { // CCD2 is tied to CVS2, not valid.
8123 + printk("mpi: Unknown card plugged into slot\n");
8124 + } else { // CCD2 is tied to CVS1.
8125 + printk("mpi: Detected 3.3, x.x and y.y Cardbus card\n");
8126 + cardtype = MPI_CARDTYPE_CARDBUS;
8127 + }
8128 + break;
8129 +
8130 + case 0x00000001: // CCD1 is tied to either CVS1 or CVS2.
8131 + // This is not a valid combination.
8132 + printk("mpi: Unknown card plugged into slot\n");
8133 + break;
8134 +
8135 + case 0x00000000: // CCD1 and CCD2 are tied to ground.
8136 + printk("mpi: Detected x.x vdc 16-bit PCMCIA card\n");
8137 + cardtype = MPI_CARDTYPE_PCMCIA;
8138 + break;
8139 + }
8140 + break;
8141 +
8142 + case 0x00000008: // CVS2 is open or tied to CCD1/CCD2 and CVS1 is tied to ground.
8143 + // 2 valid voltage options.
8144 + switch (data32 & 0x00000003) // Test the values of CCD1 and CCD2.
8145 + {
8146 + case 0x00000003: // CCD1 and CCD2 are tied to 1 of the CVS pins.
8147 + // This is not a valid combination.
8148 + printk("mpi: Unknown card plugged into slot\n");
8149 + break;
8150 +
8151 + case 0x00000002: // CCD2 is tied to either CVS1 or CVS2.
8152 + mpi->pcmcia_cntl1 = 0x0000A040; // Drive CVS2 to a 0.
8153 + mdelay(1);
8154 + data32 = mpi->pcmcia_cntl1;
8155 + if (data32 & 0x00000002) { // CCD2 is tied to CVS1, not valid.
8156 + printk("mpi: Unknown card plugged into slot\n");
8157 + } else {// CCD2 is tied to CVS2.
8158 + printk("mpi: Detected 3.3 and x.x Cardbus card\n");
8159 + cardtype = MPI_CARDTYPE_CARDBUS;
8160 + }
8161 + break;
8162 +
8163 + case 0x00000001: // CCD1 is tied to either CVS1 or CVS2.
8164 + // This is not a valid combination.
8165 + printk("mpi: Unknown card plugged into slot\n");
8166 + break;
8167 +
8168 + case 0x00000000: // CCD1 and CCD2 are tied to ground.
8169 + cardtype = MPI_CARDTYPE_PCMCIA;
8170 + printk("mpi: Detected 3.3 vdc 16-bit PCMCIA card\n");
8171 + break;
8172 + }
8173 + break;
8174 +
8175 + case 0x0000000C: // CVS1 and CVS2 are open or tied to CCD1/CCD2.
8176 + // 5 valid voltage options.
8177 +
8178 + switch (data32 & 0x00000003) // Test the values of CCD1 and CCD2.
8179 + {
8180 + case 0x00000003: // CCD1 and CCD2 are tied to 1 of the CVS pins.
8181 + // This is not a valid combination.
8182 + printk("mpi: Unknown card plugged into slot\n");
8183 + break;
8184 +
8185 + case 0x00000002: // CCD2 is tied to either CVS1 or CVS2.
8186 + // CCD1 is tied to ground.
8187 + mpi->pcmcia_cntl1 = 0x0000A040; // Drive CVS2 to a 0.
8188 + mdelay(1);
8189 + data32 = mpi->pcmcia_cntl1;
8190 + if (data32 & 0x00000002) { // CCD2 is tied to CVS1.
8191 + printk("mpi: Detected y.y vdc Cardbus card\n");
8192 + } else { // CCD2 is tied to CVS2.
8193 + printk("mpi: Detected x.x vdc Cardbus card\n");
8194 + }
8195 + cardtype = MPI_CARDTYPE_CARDBUS;
8196 + break;
8197 +
8198 + case 0x00000001: // CCD1 is tied to either CVS1 or CVS2.
8199 + // CCD2 is tied to ground.
8200 +
8201 + mpi->pcmcia_cntl1 = 0x0000A040; // Drive CVS2 to a 0.
8202 + mdelay(1);
8203 + data32 = mpi->pcmcia_cntl1;
8204 + if (data32 & 0x00000001) {// CCD1 is tied to CVS1.
8205 + printk("mpi: Detected 3.3 vdc Cardbus card\n");
8206 + } else { // CCD1 is tied to CVS2.
8207 + printk("mpi: Detected x.x and y.y Cardbus card\n");
8208 + }
8209 + cardtype = MPI_CARDTYPE_CARDBUS;
8210 + break;
8211 +
8212 + case 0x00000000: // CCD1 and CCD2 are tied to ground.
8213 + cardtype = MPI_CARDTYPE_PCMCIA;
8214 + printk("mpi: Detected 5 vdc 16-bit PCMCIA card\n");
8215 + break;
8216 + }
8217 + break;
8218 +
8219 + default:
8220 + printk("mpi: Unknown card plugged into slot\n");
8221 + break;
8222 +
8223 + }
8224 + }
8225 + return cardtype;
8226 +}
8227 +
8228 +/*
8229 + * mpi_DetectPcCard: Detect the plugged in PC-Card
8230 + * Return: < 0 => Unknown card detected
8231 + * 0 => No card detected
8232 + * 1 => 16-bit card detected
8233 + * 2 => 32-bit CardBus card detected
8234 + */
8235 +static int mpi_DetectPcCard(void)
8236 +{
8237 + int cardtype;
8238 +
8239 + cardtype = cardtype_vcc_detect();
8240 + switch(cardtype) {
8241 + case MPI_CARDTYPE_PCMCIA:
8242 + mpi->pcmcia_cntl1 &= ~0x0000e000; // disable enable bits
8243 + //mpi->pcmcia_cntl1 = (mpi->pcmcia_cntl1 & ~PCCARD_CARD_RESET);
8244 + mpi->pcmcia_cntl1 |= (PCMCIA_ENABLE | PCMCIA_GPIO_ENABLE);
8245 + mpi_InitPcmciaSpace();
8246 + mpi_ResetPcCard(cardtype, FALSE);
8247 + // Hold card in reset for 10ms
8248 + mdelay(10);
8249 + mpi_ResetPcCard(cardtype, TRUE);
8250 + // Let card come out of reset
8251 + mdelay(100);
8252 + break;
8253 + case MPI_CARDTYPE_CARDBUS:
8254 + // 8 => CardBus Enable
8255 + // 1 => PCI Slot Number
8256 + // C => Float VS1 & VS2
8257 + mpi->pcmcia_cntl1 = (mpi->pcmcia_cntl1 & 0xFFFF0000) |
8258 + CARDBUS_ENABLE |
8259 + (CARDBUS_SLOT << 8)|
8260 + VS2_OEN |
8261 + VS1_OEN;
8262 + /* access to this memory window will be to/from CardBus */
8263 + mpi->l2pmremap1 |= CARDBUS_MEM;
8264 +
8265 + // Need to reset the Cardbus Card. There's no CardManager to do this,
8266 + // and we need to be ready for PCI configuration.
8267 + mpi_ResetPcCard(cardtype, FALSE);
8268 + // Hold card in reset for 10ms
8269 + mdelay(10);
8270 + mpi_ResetPcCard(cardtype, TRUE);
8271 + // Let card come out of reset
8272 + mdelay(100);
8273 + break;
8274 + default:
8275 + break;
8276 + }
8277 + return cardtype;
8278 +}
8279 +
8280 +static int mpi_init(void)
8281 +{
8282 + unsigned long data;
8283 + unsigned int chipid;
8284 + unsigned int chiprev;
8285 + unsigned int sdramsize;
8286 +
8287 + chipid = (PERF->RevID & 0xFFFF0000) >> 16;
8288 + chiprev = (PERF->RevID & 0xFF);
8289 + sdramsize = getMemorySize();
8290 + /*
8291 + * Init the pci interface
8292 + */
8293 + data = GPIO->GPIOMode; // GPIO mode register
8294 + data |= GROUP2_PCI | GROUP1_MII_PCCARD; // PCI internal arbiter + Cardbus
8295 + GPIO->GPIOMode = data; // PCI internal arbiter
8296 +
8297 + /*
8298 + * In the BCM6348 CardBus support is defaulted to Slot 0
8299 + * because there is no external IDSEL for CardBus. To disable
8300 + * the CardBus and allow a standard PCI card in Slot 0
8301 + * set the cbus_idsel field to 0x1f.
8302 + */
8303 + /*
8304 + uData = mpi->pcmcia_cntl1;
8305 + uData |= CARDBUS_IDSEL;
8306 + mpi->pcmcia_cntl1 = uData;
8307 + */
8308 + // Setup PCI I/O Window range. Give 64K to PCI I/O
8309 + mpi->l2piorange = ~(BCM_PCI_IO_SIZE_64KB-1);
8310 + // UBUS to PCI I/O base address
8311 + mpi->l2piobase = BCM_PCI_IO_BASE & BCM_PCI_ADDR_MASK;
8312 + // UBUS to PCI I/O Window remap
8313 + mpi->l2pioremap = (BCM_PCI_IO_BASE | MEM_WINDOW_EN);
8314 +
8315 + // enable PCI related GPIO pins and data swap between system and PCI bus
8316 + mpi->locbuscntrl = (EN_PCI_GPIO | DIR_U2P_NOSWAP);
8317 +
8318 + /* Enable 6348 BusMaster and Memory access mode */
8319 + data = mpi_GetLocalPciConfigReg(PCI_COMMAND);
8320 + data |= (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
8321 + mpi_SetLocalPciConfigReg(PCI_COMMAND, data);
8322 +
8323 + /* Configure two 16 MByte PCI to System memory regions. */
8324 + /* These memory regions are used when PCI device is a bus master */
8325 + /* Accesses to the SDRAM from PCI bus will be "byte swapped" for this region */
8326 + mpi_SetLocalPciConfigReg(PCI_BASE_ADDRESS_3, BCM_HOST_MEM_SPACE1);
8327 + mpi->sp0remap = 0x0;
8328 +
8329 + /* Accesses to the SDRAM from PCI bus will not be "byte swapped" for this region */
8330 + mpi_SetLocalPciConfigReg(PCI_BASE_ADDRESS_4, BCM_HOST_MEM_SPACE2);
8331 + mpi->sp1remap = 0x0;
8332 + mpi->pcimodesel |= (PCI_BAR2_NOSWAP | 0x40);
8333 +
8334 + if ((chipid == 0x6348) && (chiprev == 0xb0)) {
8335 + mpi->sp0range = ~(sdramsize-1);
8336 + mpi->sp1range = ~(sdramsize-1);
8337 + }
8338 + /*
8339 + * Change 6348 PCI Cfg Reg. offset 0x40 to PCI memory read retry count infinity
8340 + * by set 0 in bit 8~15. This resolve read Bcm4306 srom return 0xffff in
8341 + * first read.
8342 + */
8343 + data = mpi_GetLocalPciConfigReg(BRCM_PCI_CONFIG_TIMER);
8344 + data &= ~BRCM_PCI_CONFIG_TIMER_RETRY_MASK;
8345 + data |= 0x00000080;
8346 + mpi_SetLocalPciConfigReg(BRCM_PCI_CONFIG_TIMER, data);
8347 +
8348 + /* enable pci interrupt */
8349 + mpi->locintstat |= (EXT_PCI_INT << 16);
8350 +
8351 + mpi_DetectPcCard();
8352 +
8353 + ioport_resource.start = BCM_PCI_IO_BASE;
8354 + ioport_resource.end = BCM_PCI_IO_BASE + BCM_PCI_IO_SIZE_64KB;
8355 +
8356 +#if defined(CONFIG_USB)
8357 + PERF->blkEnables |= USBH_CLK_EN;
8358 + mdelay(100);
8359 + *USBH_NON_OHCI = NON_OHCI_BYTE_SWAP;
8360 +#endif
8361 +
8362 + return 0;
8363 +}
8364 +#endif
8365 +
8366 +static int __init brcm63xx_setup(void)
8367 +{
8368 + extern int panic_timeout;
8369 +
8370 + _machine_restart = brcm_machine_restart;
8371 + _machine_halt = brcm_machine_halt;
8372 + pm_power_off = brcm_machine_halt;
8373 +
8374 + board_timer_setup = brcm_timer_setup;
8375 +
8376 + panic_timeout = 5;
8377 +
8378 +#if defined(CONFIG_BCM96348) && defined(CONFIG_PCI)
8379 + /* mpi initialization */
8380 + mpi_init();
8381 +#endif
8382 + return 0;
8383 +}
8384 +
8385 +void plat_setup(void)
8386 +{
8387 + brcm63xx_setup();
8388 +}
8389 +
8390 +/***************************************************************************
8391 + * C++ New and delete operator functions
8392 + ***************************************************************************/
8393 +
8394 +/* void *operator new(unsigned int sz) */
8395 +void *_Znwj(unsigned int sz)
8396 +{
8397 + return( kmalloc(sz, GFP_KERNEL) );
8398 +}
8399 +
8400 +/* void *operator new[](unsigned int sz)*/
8401 +void *_Znaj(unsigned int sz)
8402 +{
8403 + return( kmalloc(sz, GFP_KERNEL) );
8404 +}
8405 +
8406 +/* placement new operator */
8407 +/* void *operator new (unsigned int size, void *ptr) */
8408 +void *ZnwjPv(unsigned int size, void *ptr)
8409 +{
8410 + return ptr;
8411 +}
8412 +
8413 +/* void operator delete(void *m) */
8414 +void _ZdlPv(void *m)
8415 +{
8416 + kfree(m);
8417 +}
8418 +
8419 +/* void operator delete[](void *m) */
8420 +void _ZdaPv(void *m)
8421 +{
8422 + kfree(m);
8423 +}
8424 +
8425 +EXPORT_SYMBOL(_Znwj);
8426 +EXPORT_SYMBOL(_Znaj);
8427 +EXPORT_SYMBOL(ZnwjPv);
8428 +EXPORT_SYMBOL(_ZdlPv);
8429 +EXPORT_SYMBOL(_ZdaPv);
8430 +
8431 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/softdsl/AdslCoreDefs.h linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/softdsl/AdslCoreDefs.h
8432 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/softdsl/AdslCoreDefs.h 1970-01-01 01:00:00.000000000 +0100
8433 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/softdsl/AdslCoreDefs.h 2006-07-07 22:15:18.000000000 +0200
8434 @@ -0,0 +1,2 @@
8435 +#define ADSL_SDRAM_IMAGE_SIZE (384*1024)
8436 +
8437 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/time.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/time.c
8438 --- linux-2.6.16.7/arch/mips/brcm-boards/bcm963xx/time.c 1970-01-01 01:00:00.000000000 +0100
8439 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/bcm963xx/time.c 2006-07-07 22:15:18.000000000 +0200
8440 @@ -0,0 +1,277 @@
8441 +/*
8442 +<:copyright-gpl
8443 + Copyright 2004 Broadcom Corp. All Rights Reserved.
8444 +
8445 + This program is free software; you can distribute it and/or modify it
8446 + under the terms of the GNU General Public License (Version 2) as
8447 + published by the Free Software Foundation.
8448 +
8449 + This program is distributed in the hope it will be useful, but WITHOUT
8450 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
8451 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
8452 + for more details.
8453 +
8454 + You should have received a copy of the GNU General Public License along
8455 + with this program; if not, write to the Free Software Foundation, Inc.,
8456 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
8457 +:>
8458 +*/
8459 +/*
8460 + * Setup time for Broadcom 963xx MIPS boards
8461 + */
8462 +
8463 +#include <linux/config.h>
8464 +#include <linux/init.h>
8465 +#include <linux/kernel_stat.h>
8466 +#include <linux/sched.h>
8467 +#include <linux/spinlock.h>
8468 +#include <linux/interrupt.h>
8469 +#include <linux/module.h>
8470 +#include <linux/time.h>
8471 +#include <linux/timex.h>
8472 +
8473 +#include <asm/mipsregs.h>
8474 +#include <asm/ptrace.h>
8475 +#include <asm/div64.h>
8476 +#include <asm/time.h>
8477 +
8478 +#include <bcm_map_part.h>
8479 +#include <bcm_intr.h>
8480 +
8481 +unsigned long r4k_interval; /* Amount to increment compare reg each time */
8482 +static unsigned long r4k_cur; /* What counter should be at next timer irq */
8483 +
8484 +/* Cycle counter value at the previous timer interrupt.. */
8485 +static unsigned int timerhi = 0, timerlo = 0;
8486 +
8487 +extern volatile unsigned long wall_jiffies;
8488 +
8489 +/* Optional board-specific timer routine */
8490 +void (*board_timer_interrupt)(int irq, void *dev_id, struct pt_regs * regs);
8491 +
8492 +static inline void ack_r4ktimer(unsigned long newval)
8493 +{
8494 + write_c0_compare(newval);
8495 +}
8496 +
8497 +/*
8498 + * There are a lot of conceptually broken versions of the MIPS timer interrupt
8499 + * handler floating around. This one is rather different, but the algorithm
8500 + * is provably more robust.
8501 + */
8502 +static irqreturn_t brcm_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
8503 +{
8504 + unsigned int count;
8505 +
8506 + if (r4k_interval == 0)
8507 + goto null;
8508 +
8509 + do {
8510 + do_timer(regs);
8511 +
8512 + if (board_timer_interrupt)
8513 + board_timer_interrupt(irq, dev_id, regs);
8514 +
8515 + r4k_cur += r4k_interval;
8516 + ack_r4ktimer(r4k_cur);
8517 +
8518 + } while (((count = (unsigned long)read_c0_count())
8519 + - r4k_cur) < 0x7fffffff);
8520 +
8521 + if (!jiffies) {
8522 + /*
8523 + * If jiffies has overflowed in this timer_interrupt we must
8524 + * update the timer[hi]/[lo] to make do_fast_gettimeoffset()
8525 + * quotient calc still valid. -arca
8526 + */
8527 + timerhi = timerlo = 0;
8528 + } else {
8529 + /*
8530 + * The cycle counter is only 32 bit which is good for about
8531 + * a minute at current count rates of upto 150MHz or so.
8532 + */
8533 + timerhi += (count < timerlo); /* Wrap around */
8534 + timerlo = count;
8535 + }
8536 +
8537 + return IRQ_HANDLED;
8538 +
8539 +null:
8540 + ack_r4ktimer(0);
8541 + return IRQ_NONE;
8542 +}
8543 +
8544 +static struct irqaction brcm_timer_action = {
8545 + .handler = brcm_timer_interrupt,
8546 + .flags = SA_INTERRUPT,
8547 + .mask = CPU_MASK_NONE,
8548 + .name = "timer",
8549 + .next = NULL,
8550 + .dev_id = brcm_timer_interrupt,
8551 +};
8552 +
8553 +
8554 +void __init brcm_timer_setup(struct irqaction *irq)
8555 +{
8556 + r4k_cur = (read_c0_count() + r4k_interval);
8557 + write_c0_compare(r4k_cur);
8558 +
8559 + /* we are using the cpu counter for timer interrupts */
8560 + irq->handler = no_action; /* we use our own handler */
8561 + setup_irq(MIPS_TIMER_INT, &brcm_timer_action);
8562 + set_c0_status(IE_IRQ5);
8563 +}
8564 +
8565 +#if 0
8566 +/* This is for machines which generate the exact clock. */
8567 +#define USECS_PER_JIFFY (1000000/HZ)
8568 +#define USECS_PER_JIFFY_FRAC (0x100000000*1000000/HZ&0xffffffff)
8569 +
8570 +static void call_do_div64_32( unsigned long *res, unsigned int high,
8571 + unsigned int low, unsigned long base )
8572 +{
8573 + do_div64_32(*res, high, low, base);
8574 +}
8575 +
8576 +/*
8577 + * FIXME: Does playing with the RP bit in c0_status interfere with this code?
8578 + */
8579 +static unsigned long do_fast_gettimeoffset(void)
8580 +{
8581 + u32 count;
8582 + unsigned long res, tmp;
8583 +
8584 + /* Last jiffy when do_fast_gettimeoffset() was called. */
8585 + static unsigned long last_jiffies=0;
8586 + unsigned long quotient;
8587 +
8588 + /*
8589 + * Cached "1/(clocks per usec)*2^32" value.
8590 + * It has to be recalculated once each jiffy.
8591 + */
8592 + static unsigned long cached_quotient=0;
8593 +
8594 + tmp = jiffies;
8595 +
8596 + quotient = cached_quotient;
8597 +
8598 + if (tmp && last_jiffies != tmp) {
8599 + last_jiffies = tmp;
8600 +#ifdef CONFIG_CPU_MIPS32
8601 + if (last_jiffies != 0) {
8602 +
8603 + unsigned long r0;
8604 + /* gcc 3.0.1 gets an internal compiler error if there are two
8605 + * do_div64_32 inline macros. To work around this problem,
8606 + * do_div64_32 is called as a function.
8607 + */
8608 + call_do_div64_32(&r0, timerhi, timerlo, tmp);
8609 + call_do_div64_32(&quotient, USECS_PER_JIFFY,
8610 + USECS_PER_JIFFY_FRAC, r0);
8611 +
8612 + cached_quotient = quotient;
8613 +
8614 + }
8615 +#else
8616 + __asm__(".set\tnoreorder\n\t"
8617 + ".set\tnoat\n\t"
8618 + ".set\tmips3\n\t"
8619 + "lwu\t%0,%2\n\t"
8620 + "dsll32\t$1,%1,0\n\t"
8621 + "or\t$1,$1,%0\n\t"
8622 + "ddivu\t$0,$1,%3\n\t"
8623 + "mflo\t$1\n\t"
8624 + "dsll32\t%0,%4,0\n\t"
8625 + "nop\n\t"
8626 + "ddivu\t$0,%0,$1\n\t"
8627 + "mflo\t%0\n\t"
8628 + ".set\tmips0\n\t"
8629 + ".set\tat\n\t"
8630 + ".set\treorder"
8631 + :"=&r" (quotient)
8632 + :"r" (timerhi),
8633 + "m" (timerlo),
8634 + "r" (tmp),
8635 + "r" (USECS_PER_JIFFY)
8636 + :"$1");
8637 + cached_quotient = quotient;
8638 +#endif
8639 + }
8640 +
8641 + /* Get last timer tick in absolute kernel time */
8642 + count = read_c0_count();
8643 +
8644 + /* .. relative to previous jiffy (32 bits is enough) */
8645 + count -= timerlo;
8646 +
8647 + __asm__("multu\t%1,%2\n\t"
8648 + "mfhi\t%0"
8649 + :"=r" (res)
8650 + :"r" (count),
8651 + "r" (quotient));
8652 +
8653 + /*
8654 + * Due to possible jiffies inconsistencies, we need to check
8655 + * the result so that we'll get a timer that is monotonic.
8656 + */
8657 + if (res >= USECS_PER_JIFFY)
8658 + res = USECS_PER_JIFFY-1;
8659 +
8660 + return res;
8661 +}
8662 +
8663 +void do_gettimeofday(struct timeval *tv)
8664 +{
8665 + unsigned int flags;
8666 +
8667 + read_lock_irqsave (&xtime_lock, flags);
8668 + tv->tv_sec = xtime.tv_sec;
8669 + tv->tv_usec = xtime.tv_nsec/1000;
8670 + tv->tv_usec += do_fast_gettimeoffset();
8671 +
8672 + /*
8673 + * xtime is atomically updated in timer_bh. jiffies - wall_jiffies
8674 + * is nonzero if the timer bottom half hasnt executed yet.
8675 + */
8676 + if (jiffies - wall_jiffies)
8677 + tv->tv_usec += USECS_PER_JIFFY;
8678 +
8679 + read_unlock_irqrestore (&xtime_lock, flags);
8680 +
8681 + if (tv->tv_usec >= 1000000) {
8682 + tv->tv_usec -= 1000000;
8683 + tv->tv_sec++;
8684 + }
8685 +}
8686 +
8687 +EXPORT_SYMBOL(do_gettimeofday);
8688 +
8689 +int do_settimeofday(struct timespec *tv)
8690 +{
8691 + write_lock_irq (&xtime_lock);
8692 +
8693 + /* This is revolting. We need to set the xtime.tv_usec correctly.
8694 + * However, the value in this location is is value at the last tick.
8695 + * Discover what correction gettimeofday would have done, and then
8696 + * undo it!
8697 + */
8698 + tv->tv_nsec -= do_fast_gettimeoffset()*NSEC_PER_USEC;
8699 +
8700 + if (tv->tv_nsec < 0) {
8701 + tv->tv_nsec += 1000000*NSEC_PER_USEC;
8702 + tv->tv_sec--;
8703 + }
8704 +
8705 + xtime.tv_sec = tv->tv_sec;
8706 + xtime.tv_nsec = tv->tv_nsec;
8707 + time_adjust = 0; /* stop active adjtime() */
8708 + time_status |= STA_UNSYNC;
8709 + time_maxerror = NTP_PHASE_LIMIT;
8710 + time_esterror = NTP_PHASE_LIMIT;
8711 +
8712 + write_unlock_irq (&xtime_lock);
8713 +}
8714 +
8715 +EXPORT_SYMBOL(do_settimeofday);
8716 +
8717 +#endif
8718 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/generic/dbg_io.c linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/generic/dbg_io.c
8719 --- linux-2.6.16.7/arch/mips/brcm-boards/generic/dbg_io.c 1970-01-01 01:00:00.000000000 +0100
8720 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/generic/dbg_io.c 2006-07-07 22:15:18.000000000 +0200
8721 @@ -0,0 +1,260 @@
8722 +/*
8723 +<:copyright-gpl
8724 + Copyright 2003 Broadcom Corp. All Rights Reserved.
8725 +
8726 + This program is free software; you can distribute it and/or modify it
8727 + under the terms of the GNU General Public License (Version 2) as
8728 + published by the Free Software Foundation.
8729 +
8730 + This program is distributed in the hope it will be useful, but WITHOUT
8731 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
8732 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
8733 + for more details.
8734 +
8735 + You should have received a copy of the GNU General Public License along
8736 + with this program; if not, write to the Free Software Foundation, Inc.,
8737 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
8738 +:>
8739 +*/
8740 +
8741 +#include <linux/config.h>
8742 +#include <linux/tty.h>
8743 +#include <linux/major.h>
8744 +#include <linux/init.h>
8745 +#include <linux/console.h>
8746 +#include <linux/fs.h>
8747 +#include <linux/interrupt.h>
8748 +#include <linux/kernel.h>
8749 +#include <linux/types.h>
8750 +#include <linux/sched.h>
8751 +
8752 +#include <bcm_map_part.h>
8753 +
8754 +#undef PRNT /* define for debug printing */
8755 +
8756 +#define UART16550_BAUD_2400 2400
8757 +#define UART16550_BAUD_4800 4800
8758 +#define UART16550_BAUD_9600 9600
8759 +#define UART16550_BAUD_19200 19200
8760 +#define UART16550_BAUD_38400 38400
8761 +#define UART16550_BAUD_57600 57600
8762 +#define UART16550_BAUD_115200 115200
8763 +
8764 +#define UART16550_PARITY_NONE 0
8765 +#define UART16550_PARITY_ODD 0x08
8766 +#define UART16550_PARITY_EVEN 0x18
8767 +#define UART16550_PARITY_MARK 0x28
8768 +#define UART16550_PARITY_SPACE 0x38
8769 +
8770 +#define UART16550_DATA_5BIT 0x0
8771 +#define UART16550_DATA_6BIT 0x1
8772 +#define UART16550_DATA_7BIT 0x2
8773 +#define UART16550_DATA_8BIT 0x3
8774 +
8775 +#define UART16550_STOP_1BIT 0x0
8776 +#define UART16550_STOP_2BIT 0x4
8777 +
8778 +volatile Uart * stUart = UART_BASE;
8779 +
8780 +#define WRITE16(addr, value) ((*(volatile UINT16 *)((ULONG)&addr)) = value)
8781 +
8782 +/* Low level UART routines from promcon.c */
8783 +extern void prom_putc(char c);
8784 +extern char prom_getc(void);
8785 +extern int prom_getc_nowait(void);
8786 +extern int prom_testc(void);
8787 +
8788 +extern void set_debug_traps(void);
8789 +extern void breakpoint(void);
8790 +extern void enable_brcm_irq(unsigned int);
8791 +extern void set_async_breakpoint(unsigned int epc);
8792 +
8793 +#ifdef CONFIG_GDB_CONSOLE
8794 +extern void register_gdb_console(void);
8795 +#endif
8796 +
8797 +int gdb_initialized = 0;
8798 +
8799 +#define GDB_BUF_SIZE 512 /* power of 2, please */
8800 +
8801 +static char gdb_buf[GDB_BUF_SIZE] ;
8802 +static int gdb_buf_in_inx ;
8803 +static atomic_t gdb_buf_in_cnt ;
8804 +static int gdb_buf_out_inx ;
8805 +
8806 +void debugInit(uint32 baud, uint8 data, uint8 parity, uint8 stop)
8807 +{
8808 + /* Do nothing, assume boot loader has already set up serial port */
8809 + printk("debugInit called\n");
8810 +}
8811 +
8812 +/*
8813 + * Get a char if available, return -1 if nothing available.
8814 + * Empty the receive buffer first, then look at the interface hardware.
8815 + */
8816 +static int read_char(void)
8817 +{
8818 + if (atomic_read(&gdb_buf_in_cnt) != 0) /* intr routine has q'd chars */
8819 + {
8820 + int chr ;
8821 +
8822 + chr = gdb_buf[gdb_buf_out_inx++] ;
8823 + gdb_buf_out_inx &= (GDB_BUF_SIZE - 1) ;
8824 + atomic_dec(&gdb_buf_in_cnt) ;
8825 + return(chr) ;
8826 + }
8827 + return(prom_getc_nowait()) ; /* read from hardware */
8828 +} /* read_char */
8829 +
8830 +/*
8831 + * This is the receiver interrupt routine for the GDB stub.
8832 + * It will receive a limited number of characters of input
8833 + * from the gdb host machine and save them up in a buffer.
8834 + *
8835 + * When the gdb stub routine getDebugChar() is called it
8836 + * draws characters out of the buffer until it is empty and
8837 + * then reads directly from the serial port.
8838 + *
8839 + * We do not attempt to write chars from the interrupt routine
8840 + * since the stubs do all of that via putDebugChar() which
8841 + * writes one byte after waiting for the interface to become
8842 + * ready.
8843 + *
8844 + * The debug stubs like to run with interrupts disabled since,
8845 + * after all, they run as a consequence of a breakpoint in
8846 + * the kernel.
8847 + *
8848 + * Perhaps someone who knows more about the tty driver than I
8849 + * care to learn can make this work for any low level serial
8850 + * driver.
8851 + */
8852 +static void gdb_interrupt(int irq, void *dev_id, struct pt_regs * regs)
8853 +{
8854 + int chr ;
8855 + int more;
8856 + do
8857 + {
8858 + chr = prom_getc_nowait() ;
8859 + more = prom_testc();
8860 + if (chr < 0) continue ;
8861 +
8862 + /* If we receive a Ctrl-C then this is GDB trying to break in */
8863 + if (chr == 3)
8864 + {
8865 + /* Replace current instruction with breakpoint */
8866 + set_async_breakpoint(regs->cp0_epc);
8867 + //breakpoint();
8868 + }
8869 +
8870 +#ifdef PRNT
8871 + printk("gdb_interrupt: chr=%02x '%c', more = %x\n",
8872 + chr, chr > ' ' && chr < 0x7F ? chr : ' ', more) ;
8873 +#endif
8874 +
8875 + if (atomic_read(&gdb_buf_in_cnt) >= GDB_BUF_SIZE)
8876 + { /* buffer overflow, clear it */
8877 + gdb_buf_in_inx = 0 ;
8878 + atomic_set(&gdb_buf_in_cnt, 0) ;
8879 + gdb_buf_out_inx = 0 ;
8880 + break ;
8881 + }
8882 +
8883 + gdb_buf[gdb_buf_in_inx++] = chr ;
8884 + gdb_buf_in_inx &= (GDB_BUF_SIZE - 1) ;
8885 + atomic_inc(&gdb_buf_in_cnt) ;
8886 + }
8887 + while (more !=0);
8888 +
8889 +} /* gdb_interrupt */
8890 +
8891 +/*
8892 + * getDebugChar
8893 + *
8894 + * This is a GDB stub routine. It waits for a character from the
8895 + * serial interface and then returns it. If there is no serial
8896 + * interface connection then it returns a bogus value which will
8897 + * almost certainly cause the system to hang.
8898 + */
8899 +int getDebugChar(void)
8900 +{
8901 + volatile int chr ;
8902 +
8903 +#ifdef PRNT
8904 + printk("getDebugChar: ") ;
8905 +#endif
8906 +
8907 + while ( (chr = read_char()) < 0 ) ;
8908 +
8909 +#ifdef PRNT
8910 + printk("%c\n", chr > ' ' && chr < 0x7F ? chr : ' ') ;
8911 +#endif
8912 + return(chr) ;
8913 +
8914 +} /* getDebugChar */
8915 +
8916 +/*
8917 + * putDebugChar
8918 + *
8919 + * This is a GDB stub routine. It waits until the interface is ready
8920 + * to transmit a char and then sends it. If there is no serial
8921 + * interface connection then it simply returns to its caller, having
8922 + * pretended to send the char.
8923 + */
8924 +int putDebugChar(unsigned char chr)
8925 +{
8926 +#ifdef PRNT
8927 + printk("putDebugChar: chr=%02x '%c'\n", chr,
8928 + chr > ' ' && chr < 0x7F ? chr : ' ') ;
8929 +#endif
8930 +
8931 + prom_putc(chr) ; /* this routine will wait */
8932 + return 1;
8933 +
8934 +} /* putDebugChar */
8935 +
8936 +/* Just a NULL routine for testing. */
8937 +void gdb_null(void)
8938 +{
8939 +}
8940 +
8941 +void rs_kgdb_hook(int tty_no)
8942 +{
8943 + printk("rs_kgdb_hook: tty %d\n", tty_no);
8944 +
8945 + /* Call GDB routine to setup the exception vectors for the debugger */
8946 + set_debug_traps();
8947 +
8948 + printk("Breaking into debugger...\n");
8949 + breakpoint();
8950 + gdb_null() ;
8951 + printk("Connected.\n");
8952 +
8953 + gdb_initialized = 1;
8954 +
8955 +#ifdef CONFIG_GDB_CONSOLE
8956 + register_gdb_console();
8957 +#endif
8958 +}
8959 +
8960 +void kgdb_hook_irq()
8961 +{
8962 + int retval ;
8963 + uint16 uMask;
8964 +
8965 + printk("GDB: Hooking UART interrupt\n");
8966 +
8967 + retval = request_irq(INTERRUPT_ID_UART,
8968 + gdb_interrupt,
8969 + SA_INTERRUPT,
8970 + "GDB-stub", NULL);
8971 +
8972 + if (retval != 0)
8973 + printk("gdb_hook: request_irq(irq=%d) failed: %d\n", INTERRUPT_ID_UART, retval);
8974 +
8975 + // Enable UART config Rx not empty IRQ
8976 + uMask = READ16(stUart->intMask) ;
8977 + // printk("intMask: 0x%x\n", uMask);
8978 + WRITE16(stUart->intMask, uMask | RXFIFONE);
8979 +}
8980 +
8981 +
8982 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/generic/int-handler.S linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/generic/int-handler.S
8983 --- linux-2.6.16.7/arch/mips/brcm-boards/generic/int-handler.S 1970-01-01 01:00:00.000000000 +0100
8984 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/generic/int-handler.S 2006-07-07 22:15:18.000000000 +0200
8985 @@ -0,0 +1,59 @@
8986 +/*
8987 +<:copyright-gpl
8988 + Copyright 2002 Broadcom Corp. All Rights Reserved.
8989 +
8990 + This program is free software; you can distribute it and/or modify it
8991 + under the terms of the GNU General Public License (Version 2) as
8992 + published by the Free Software Foundation.
8993 +
8994 + This program is distributed in the hope it will be useful, but WITHOUT
8995 + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
8996 + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
8997 + for more details.
8998 +
8999 + You should have received a copy of the GNU General Public License along
9000 + with this program; if not, write to the Free Software Foundation, Inc.,
9001 + 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
9002 +:>
9003 +*/
9004 +/*
9005 + * Generic interrupt handler for Broadcom MIPS boards
9006 + */
9007 +
9008 +#include <linux/config.h>
9009 +
9010 +#include <asm/asm.h>
9011 +#include <asm/mipsregs.h>
9012 +#include <asm/regdef.h>
9013 +#include <asm/stackframe.h>
9014 +
9015 +/*
9016 + * MIPS IRQ Source
9017 + * -------- ------
9018 + * 0 Software (ignored)
9019 + * 1 Software (ignored)
9020 + * 2 Combined hardware interrupt (hw0)
9021 + * 3 Hardware
9022 + * 4 Hardware
9023 + * 5 Hardware
9024 + * 6 Hardware
9025 + * 7 R4k timer
9026 + */
9027 +
9028 + .text
9029 + .set noreorder
9030 + .set noat
9031 + .align 5
9032 + NESTED(brcmIRQ, PT_SIZE, sp)
9033 + SAVE_ALL
9034 + CLI
9035 + .set noreorder
9036 + .set at
9037 +
9038 + jal brcm_irq_dispatch
9039 + move a0, sp
9040 +
9041 + j ret_from_irq
9042 + nop
9043 +
9044 + END(brcmIRQ)
9045 diff -urN linux-2.6.16.7/arch/mips/brcm-boards/generic/Makefile linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/generic/Makefile
9046 --- linux-2.6.16.7/arch/mips/brcm-boards/generic/Makefile 1970-01-01 01:00:00.000000000 +0100
9047 +++ linux-2.6.16.7-brcm63xx/arch/mips/brcm-boards/generic/Makefile 2006-07-07 22:15:18.000000000 +0200
9048 @@ -0,0 +1,11 @@
9049 +#
9050 +# Makefile for generic Broadcom MIPS boards
9051 +#
9052 +# Copyright (C) 2001 Broadcom Corporation
9053 +#
9054 +obj-y := int-handler.o
9055 +
9056 +ifdef CONFIG_REMOTE_DEBUG
9057 +obj-y += dbg_io.o
9058 +endif
9059 +
Personal OpenWRT clone
This page took 0.446396 seconds and 5 git commands to generate.