?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: ft1000: remove trailing whitespace
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / ft1000 / ft1000-usb / ft1000_hw.c
blob51ed0dd95ac1a85a391473eeab896c0ead2957a3
1 //=====================================================
2 // CopyRight (C) 2007 Qualcomm Inc. All Rights Reserved.
3 //
4 //
5 // This file is part of Express Card USB Driver
6 //
7 // $Id:
8 //====================================================
9 // 20090926; aelias; removed compiler warnings & errors; ubuntu 9.04; 2.6.28-15-generic
10
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/netdevice.h>
15 #include <linux/etherdevice.h>
16 #include <linux/usb.h>
17 #include "ft1000_usb.h"
18 #include <linux/types.h>
19 //#include <asm/semaphore.h> //aelias [-] reason : file moved
20 //#include <linux/semaphore.h> //aelias [+] reason : file moved
21 //#include <asm/io.h>
22 //#include <linux/kthread.h>
23
24 #define HARLEY_READ_REGISTER 0x0
25 #define HARLEY_WRITE_REGISTER 0x01
26 #define HARLEY_READ_DPRAM_32 0x02
27 #define HARLEY_READ_DPRAM_LOW 0x03
28 #define HARLEY_READ_DPRAM_HIGH 0x04
29 #define HARLEY_WRITE_DPRAM_32 0x05
30 #define HARLEY_WRITE_DPRAM_LOW 0x06
31 #define HARLEY_WRITE_DPRAM_HIGH 0x07
32
33 #define HARLEY_READ_OPERATION 0xc1
34 #define HARLEY_WRITE_OPERATION 0x41
35
36 //#define JDEBUG
37
38
39 extern void *pFileStart;
40 extern ULONG FileLength;
41
42
43 extern int numofmsgbuf;
44
45
46 int ft1000_poll_thread(void *arg);
47
48 static void ft1000_hbchk(u_long data);
49 int ft1000_reset(struct net_device *ft1000dev);
50 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev);
51 static int ft1000_open (struct net_device *dev);
52 int ft1000_close (struct net_device *dev);
53 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev);
54 u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart, ULONG FileLength);
55 int ft1000_submit_rx_urb(PFT1000_INFO info);
56 static struct timer_list poll_timer[MAX_NUM_CARDS];
57 static int ft1000_chkcard (struct ft1000_device *dev);
58 /*
59 static const struct net_device_ops ft1000net_ops = {
60 .ndo_start_xmit = ft1000_start_xmit,
61 .ndo_get_stats = ft1000_netdev_stats,
62 .ndo_open = ft1000_open,
63 .ndo_stop = ft1000_close,
64 };
65 */
66
67 //Jim
68
69 static u8 tempbuffer[1600];
70 int gCardIndex;
71
72 #define MAX_RCV_LOOP 100
73
74
75 extern struct list_head freercvpool;
76 extern spinlock_t free_buff_lock; // lock to arbitrate free buffer list for receive command data
77
78 //end of Jim
79
80 extern int ft1000_CreateDevice(struct ft1000_device *dev);
81 extern PDPRAM_BLK ft1000_get_buffer (struct list_head *bufflist);
82 extern void ft1000_free_buffer (PDPRAM_BLK pdpram_blk, struct list_head *plist);
83
84
85 static int atoi(const char *s)
86 {
87 int k = 0;
88 int cnt;
89
90 k = 0;
91 cnt = 0;
92 while (*s != '\0' && *s >= '0' && *s <= '9') {
93 k = 10 * k + (*s - '0');
94 s++;
95 // Let's put a limit on this while loop to avoid deadlock scenario
96 if (cnt > 100)
97 break;
98 cnt++;
99 }
100 return k;
101 }
102 /****************************************************************
103 * ft1000_control_complete
104 ****************************************************************/
105 static void ft1000_control_complete(struct urb *urb)
106 {
107 struct ft1000_device *ft1000dev = (struct ft1000_device *)urb->context;
108
109 //DEBUG("FT1000_CONTROL_COMPLETE ENTERED\n");
110 if (ft1000dev == NULL )
111 {
112 DEBUG("NULL ft1000dev, failure\n");
113 return ;
114 }
115 else if ( ft1000dev->dev == NULL )
116 {
117 DEBUG("NULL ft1000dev->dev, failure\n");
118 return ;
119 }
120 //spin_lock(&ft1000dev->device_lock);
121
122 if(waitqueue_active(&ft1000dev->control_wait))
123 {
124 wake_up(&ft1000dev->control_wait);
125 }
126
127 //DEBUG("FT1000_CONTROL_COMPLETE RETURNED\n");
128 //spin_unlock(&ft1000dev->device_lock);
129 }
130
131 //---------------------------------------------------------------------------
132 // Function: ft1000_control
133 //
134 // Parameters: ft1000_device - device structure
135 // pipe - usb control message pipe
136 // request - control request
137 // requesttype - control message request type
138 // value - value to be written or 0
139 // index - register index
140 // data - data buffer to hold the read/write values
141 // size - data size
142 // timeout - control message time out value
143 //
144 // Returns: STATUS_SUCCESS - success
145 // STATUS_FAILURE - failure
146 //
147 // Description: This function sends a control message via USB interface synchronously
148 //
149 // Notes:
150 //
151 //---------------------------------------------------------------------------
152 static int ft1000_control(struct ft1000_device *ft1000dev,unsigned int pipe,
153 u8 request,
154 u8 requesttype,
155 u16 value,
156 u16 index,
157 void *data,
158 u16 size,
159 int timeout)
160 {
161 u16 ret;
162
163 if (ft1000dev == NULL )
164 {
165 DEBUG("NULL ft1000dev, failure\n");
166 return STATUS_FAILURE;
167 }
168 else if ( ft1000dev->dev == NULL )
169 {
170 DEBUG("NULL ft1000dev->dev, failure\n");
171 return STATUS_FAILURE;
172 }
173
174 ret = usb_control_msg(ft1000dev->dev,
175 pipe,
176 request,
177 requesttype,
178 value,
179 index,
180 data,
181 size,
182 LARGE_TIMEOUT);
183
184 if (ret>0)
185 ret = STATUS_SUCCESS;
186 else
187 ret = STATUS_FAILURE;
188
189
190 return ret;
191
192
193 }
194 //---------------------------------------------------------------------------
195 // Function: ft1000_read_register
196 //
197 // Parameters: ft1000_device - device structure
198 // Data - data buffer to hold the value read
199 // nRegIndex - register index
200 //
201 // Returns: STATUS_SUCCESS - success
202 // STATUS_FAILURE - failure
203 //
204 // Description: This function returns the value in a register
205 //
206 // Notes:
207 //
208 //---------------------------------------------------------------------------
209
210 u16 ft1000_read_register(struct ft1000_device *ft1000dev, short* Data, u16 nRegIndx)
211 {
212 u16 ret = STATUS_SUCCESS;
213
214 //DEBUG("ft1000_read_register: reg index is %d\n", nRegIndx);
215 //DEBUG("ft1000_read_register: spin_lock locked\n");
216 ret = ft1000_control(ft1000dev,
217 usb_rcvctrlpipe(ft1000dev->dev,0),
218 HARLEY_READ_REGISTER, //request --READ_REGISTER
219 HARLEY_READ_OPERATION, //requestType
220 0, //value
221 nRegIndx, //index
222 Data, //data
223 2, //data size
224 LARGE_TIMEOUT ); //timeout
225
226 //DEBUG("ft1000_read_register: ret is %d \n", ret);
227
228 //DEBUG("ft1000_read_register: data is %x \n", *Data);
229 if ( ret != STATUS_SUCCESS )
230 return STATUS_FAILURE;
231
232 return ret;
233
234 }
235
236 //---------------------------------------------------------------------------
237 // Function: ft1000_write_register
238 //
239 // Parameters: ft1000_device - device structure
240 // value - value to write into a register
241 // nRegIndex - register index
242 //
243 // Returns: STATUS_SUCCESS - success
244 // STATUS_FAILURE - failure
245 //
246 // Description: This function writes the value in a register
247 //
248 // Notes:
249 //
250 //---------------------------------------------------------------------------
251 u16 ft1000_write_register(struct ft1000_device *ft1000dev, USHORT value, u16 nRegIndx)
252 {
253 u16 ret = STATUS_SUCCESS;
254
255 //DEBUG("ft1000_write_register: value is: %d, reg index is: %d\n", value, nRegIndx);
256
257 ret = ft1000_control(ft1000dev,
258 usb_sndctrlpipe(ft1000dev->dev, 0),
259 HARLEY_WRITE_REGISTER, //request -- WRITE_REGISTER
260 HARLEY_WRITE_OPERATION, //requestType
261 value,
262 nRegIndx,
263 NULL,
264 0,
265 LARGE_TIMEOUT );
266
267 if ( ret != STATUS_SUCCESS )
268 return STATUS_FAILURE;
269
270 return ret;
271 }
272
273 //---------------------------------------------------------------------------
274 // Function: ft1000_read_dpram32
275 //
276 // Parameters: ft1000_device - device structure
277 // indx - starting address to read
278 // buffer - data buffer to hold the data read
279 // cnt - number of byte read from DPRAM
280 //
281 // Returns: STATUS_SUCCESS - success
282 // STATUS_FAILURE - failure
283 //
284 // Description: This function read a number of bytes from DPRAM
285 //
286 // Notes:
287 //
288 //---------------------------------------------------------------------------
289
290 u16 ft1000_read_dpram32(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer, USHORT cnt)
291 {
292 u16 ret = STATUS_SUCCESS;
293
294 //DEBUG("ft1000_read_dpram32: indx: %d cnt: %d\n", indx, cnt);
295 ret =ft1000_control(ft1000dev,
296 usb_rcvctrlpipe(ft1000dev->dev,0),
297 HARLEY_READ_DPRAM_32, //request --READ_DPRAM_32
298 HARLEY_READ_OPERATION, //requestType
299 0, //value
300 indx, //index
301 buffer, //data
302 cnt, //data size
303 LARGE_TIMEOUT ); //timeout
304
305 //DEBUG("ft1000_read_dpram32: ret is %d \n", ret);
306
307 //DEBUG("ft1000_read_dpram32: ret=%d \n", ret);
308 if ( ret != STATUS_SUCCESS )
309 return STATUS_FAILURE;
310
311 return ret;
312
313 }
314
315 //---------------------------------------------------------------------------
316 // Function: ft1000_write_dpram32
317 //
318 // Parameters: ft1000_device - device structure
319 // indx - starting address to write the data
320 // buffer - data buffer to write into DPRAM
321 // cnt - number of bytes to write
322 //
323 // Returns: STATUS_SUCCESS - success
324 // STATUS_FAILURE - failure
325 //
326 // Description: This function writes into DPRAM a number of bytes
327 //
328 // Notes:
329 //
330 //---------------------------------------------------------------------------
331 u16 ft1000_write_dpram32(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer, USHORT cnt)
332 {
333 u16 ret = STATUS_SUCCESS;
334
335 //DEBUG("ft1000_write_dpram32: indx: %d buffer: %x cnt: %d\n", indx, buffer, cnt);
336 if ( cnt % 4)
337 cnt += cnt - (cnt % 4);
338
339 ret = ft1000_control(ft1000dev,
340 usb_sndctrlpipe(ft1000dev->dev, 0),
341 HARLEY_WRITE_DPRAM_32, //request -- WRITE_DPRAM_32
342 HARLEY_WRITE_OPERATION, //requestType
343 0, //value
344 indx, //index
345 buffer, //buffer
346 cnt, //buffer size
347 LARGE_TIMEOUT );
348
349
350 if ( ret != STATUS_SUCCESS )
351 return STATUS_FAILURE;
352
353
354 return ret;
355 }
356
357 //---------------------------------------------------------------------------
358 // Function: ft1000_read_dpram16
359 //
360 // Parameters: ft1000_device - device structure
361 // indx - starting address to read
362 // buffer - data buffer to hold the data read
363 // hightlow - high or low 16 bit word
364 //
365 // Returns: STATUS_SUCCESS - success
366 // STATUS_FAILURE - failure
367 //
368 // Description: This function read 16 bits from DPRAM
369 //
370 // Notes:
371 //
372 //---------------------------------------------------------------------------
373 u16 ft1000_read_dpram16(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer, u8 highlow)
374 {
375 u16 ret = STATUS_SUCCESS;
376
377 //DEBUG("ft1000_read_dpram16: indx: %d hightlow: %d\n", indx, highlow);
378
379 u8 request;
380
381 if (highlow == 0 )
382 request = HARLEY_READ_DPRAM_LOW;
383 else
384 request = HARLEY_READ_DPRAM_HIGH;
385
386 ret = ft1000_control(ft1000dev,
387 usb_rcvctrlpipe(ft1000dev->dev,0),
388 request, //request --READ_DPRAM_H/L
389 HARLEY_READ_OPERATION, //requestType
390 0, //value
391 indx, //index
392 buffer, //data
393 2, //data size
394 LARGE_TIMEOUT ); //timeout
395
396 //DEBUG("ft1000_read_dpram16: ret is %d \n", ret);
397
398
399 //DEBUG("ft1000_read_dpram16: data is %x \n", *buffer);
400 if ( ret != STATUS_SUCCESS )
401 return STATUS_FAILURE;
402
403 return ret;
404
405 }
406
407 //---------------------------------------------------------------------------
408 // Function: ft1000_write_dpram16
409 //
410 // Parameters: ft1000_device - device structure
411 // indx - starting address to write the data
412 // value - 16bits value to write
413 // hightlow - high or low 16 bit word
414 //
415 // Returns: STATUS_SUCCESS - success
416 // STATUS_FAILURE - failure
417 //
418 // Description: This function writes into DPRAM a number of bytes
419 //
420 // Notes:
421 //
422 //---------------------------------------------------------------------------
423 u16 ft1000_write_dpram16(struct ft1000_device *ft1000dev, USHORT indx, USHORT value, u8 highlow)
424 {
425 u16 ret = STATUS_SUCCESS;
426
427
428
429 //DEBUG("ft1000_write_dpram16: indx: %d value: %d highlow: %d\n", indx, value, highlow);
430
431 u8 request;
432
433
434 if ( highlow == 0 )
435 request = HARLEY_WRITE_DPRAM_LOW;
436 else
437 request = HARLEY_WRITE_DPRAM_HIGH;
438
439 ret = ft1000_control(ft1000dev,
440 usb_sndctrlpipe(ft1000dev->dev, 0),
441 request, //request -- WRITE_DPRAM_H/L
442 HARLEY_WRITE_OPERATION, //requestType
443 value, //value
444 indx, //index
445 NULL, //buffer
446 0, //buffer size
447 LARGE_TIMEOUT );
448
449
450 if ( ret != STATUS_SUCCESS )
451 return STATUS_FAILURE;
452
453
454 return ret;
455 }
456
457 //---------------------------------------------------------------------------
458 // Function: fix_ft1000_read_dpram32
459 //
460 // Parameters: ft1000_device - device structure
461 // indx - starting address to read
462 // buffer - data buffer to hold the data read
463 //
464 //
465 // Returns: STATUS_SUCCESS - success
466 // STATUS_FAILURE - failure
467 //
468 // Description: This function read DPRAM 4 words at a time
469 //
470 // Notes:
471 //
472 //---------------------------------------------------------------------------
473 u16 fix_ft1000_read_dpram32(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer)
474 {
475 UCHAR tempbuffer[16];
476 USHORT pos;
477 u16 ret = STATUS_SUCCESS;
478
479 //DEBUG("fix_ft1000_read_dpram32: indx: %d \n", indx);
480 pos = (indx / 4)*4;
481 ret = ft1000_read_dpram32(ft1000dev, pos, (PUCHAR)&tempbuffer[0], 16);
482 if (ret == STATUS_SUCCESS)
483 {
484 pos = (indx % 4)*4;
485 *buffer++ = tempbuffer[pos++];
486 *buffer++ = tempbuffer[pos++];
487 *buffer++ = tempbuffer[pos++];
488 *buffer++ = tempbuffer[pos++];
489 }
490 else
491 {
492 DEBUG("fix_ft1000_read_dpram32: DPRAM32 Read failed\n");
493 *buffer++ = 0;
494 *buffer++ = 0;
495 *buffer++ = 0;
496 *buffer++ = 0;
497
498 }
499
500 //DEBUG("fix_ft1000_read_dpram32: data is %x \n", *buffer);
501 return ret;
502
503 }
504
505
506 //---------------------------------------------------------------------------
507 // Function: fix_ft1000_write_dpram32
508 //
509 // Parameters: ft1000_device - device structure
510 // indx - starting address to write
511 // buffer - data buffer to write
512 //
513 //
514 // Returns: STATUS_SUCCESS - success
515 // STATUS_FAILURE - failure
516 //
517 // Description: This function write to DPRAM 4 words at a time
518 //
519 // Notes:
520 //
521 //---------------------------------------------------------------------------
522 u16 fix_ft1000_write_dpram32(struct ft1000_device *ft1000dev, USHORT indx, PUCHAR buffer)
523 {
524 USHORT pos1;
525 USHORT pos2;
526 USHORT i;
527 UCHAR tempbuffer[32];
528 UCHAR resultbuffer[32];
529 PUCHAR pdata;
530 u16 ret = STATUS_SUCCESS;
531
532 //DEBUG("fix_ft1000_write_dpram32: Entered:\n");
533
534 pos1 = (indx / 4)*4;
535 pdata = buffer;
536 ret = ft1000_read_dpram32(ft1000dev, pos1, (PUCHAR)&tempbuffer[0], 16);
537 if (ret == STATUS_SUCCESS)
538 {
539 pos2 = (indx % 4)*4;
540 tempbuffer[pos2++] = *buffer++;
541 tempbuffer[pos2++] = *buffer++;
542 tempbuffer[pos2++] = *buffer++;
543 tempbuffer[pos2++] = *buffer++;
544 ret = ft1000_write_dpram32(ft1000dev, pos1, (PUCHAR)&tempbuffer[0], 16);
545 }
546 else
547 {
548 DEBUG("fix_ft1000_write_dpram32: DPRAM32 Read failed\n");
549
550 return ret;
551 }
552
553 ret = ft1000_read_dpram32(ft1000dev, pos1, (PUCHAR)&resultbuffer[0], 16);
554 if (ret == STATUS_SUCCESS)
555 {
556 buffer = pdata;
557 for (i=0; i<16; i++)
558 {
559 if (tempbuffer[i] != resultbuffer[i]){
560
561 ret = STATUS_FAILURE;
562 }
563 }
564 }
565
566 if (ret == STATUS_FAILURE)
567 {
568 ret = ft1000_write_dpram32(ft1000dev, pos1, (PUCHAR)&tempbuffer[0], 16);
569 ret = ft1000_read_dpram32(ft1000dev, pos1, (PUCHAR)&resultbuffer[0], 16);
570 if (ret == STATUS_SUCCESS)
571 {
572 buffer = pdata;
573 for (i=0; i<16; i++)
574 {
575 if (tempbuffer[i] != resultbuffer[i])
576 {
577 ret = STATUS_FAILURE;
578 DEBUG("fix_ft1000_write_dpram32 Failed to write\n");
579 }
580 }
581 }
582 }
583
584 return ret;
585
586 }
587
588
589 //------------------------------------------------------------------------
590 //
591 // Function: card_reset_dsp
592 //
593 // Synopsis: This function is called to reset or activate the DSP
594 //
595 // Arguments: value - reset or activate
596 //
597 // Returns: None
598 //-----------------------------------------------------------------------
599 void card_reset_dsp (struct ft1000_device *ft1000dev, BOOLEAN value)
600 {
601 u16 status = STATUS_SUCCESS;
602 USHORT tempword;
603
604 status = ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
605 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_CTRL);
606 if (value)
607 {
608 DEBUG("Reset DSP\n");
609 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
610 tempword |= DSP_RESET_BIT;
611 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
612 }
613 else
614 {
615 DEBUG("Activate DSP\n");
616 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
617 #if 1
618 tempword |= DSP_ENCRYPTED;
619 tempword &= ~DSP_UNENCRYPTED;
620 #else
621 tempword |= DSP_UNENCRYPTED;
622 tempword &= ~DSP_ENCRYPTED;
623 #endif
624 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
625 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
626 tempword &= ~EFUSE_MEM_DISABLE;
627 tempword &= ~DSP_RESET_BIT;
628 status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
629 status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
630 }
631 }
632
633 //---------------------------------------------------------------------------
634 // Function: CardSendCommand
635 //
636 // Parameters: ft1000_device - device structure
637 // ptempbuffer - command buffer
638 // size - command buffer size
639 //
640 // Returns: STATUS_SUCCESS - success
641 // STATUS_FAILURE - failure
642 //
643 // Description: This function sends a command to ASIC
644 //
645 // Notes:
646 //
647 //---------------------------------------------------------------------------
648 void CardSendCommand(struct ft1000_device *ft1000dev, unsigned char *ptempbuffer, int size)
649 {
650 unsigned short temp;
651 unsigned char *commandbuf;
652
653 DEBUG("CardSendCommand: enter CardSendCommand... size=%d\n", size);
654
655 commandbuf =(unsigned char*) kmalloc(size+2, GFP_KERNEL);
656 //memset((void*)commandbuf, 0, size+2);
657 memcpy((void*)commandbuf+2, (void*)ptempbuffer, size);
658
659 //DEBUG("CardSendCommand: Command Send\n");
660 /***
661 for (i=0; i<size+2; i++)
662 {
663 DEBUG("FT1000:ft1000_ChIoctl: data %d = 0x%x\n", i, *ptr++);
664 }
665 ***/
666
667 ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
668
669 if (temp & 0x0100)
670 {
671 msleep(10);
672 }
673
674 // check for odd word
675 size = size + 2;
676 if (size % 4)
677 {
678 // Must force to be 32 bit aligned
679 size += 4 - (size % 4);
680 }
681
682
683 //DEBUG("CardSendCommand: write dpram ... size=%d\n", size);
684 ft1000_write_dpram32(ft1000dev, 0,commandbuf, size);
685 msleep(1);
686 //DEBUG("CardSendCommand: write into doorbell ...\n");
687 ft1000_write_register(ft1000dev, FT1000_DB_DPRAM_TX ,FT1000_REG_DOORBELL) ;
688 msleep(1);
689
690 ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
691 //DEBUG("CardSendCommand: read doorbell ...temp=%x\n", temp);
692 if ( (temp & 0x0100) == 0)
693 {
694 //DEBUG("CardSendCommand: Message sent\n");
695 }
696
697 }
698
699
700 //--------------------------------------------------------------------------
701 //
702 // Function: dsp_reload
703 //
704 // Synopsis: This function is called to load or reload the DSP
705 //
706 // Arguments: ft1000dev - device structure
707 //
708 // Returns: None
709 //-----------------------------------------------------------------------
710 void dsp_reload (struct ft1000_device *ft1000dev)
711 {
712 u16 status;
713 USHORT tempword;
714 ULONG templong;
715
716 PFT1000_INFO pft1000info;
717
718 pft1000info = netdev_priv(ft1000dev->net);
719
720 pft1000info->CardReady = 0;
721 pft1000info->DSP_loading= 1;
722
723 // Program Interrupt Mask register
724 status = ft1000_write_register (ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
725
726 status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_RESET);
727 tempword |= ASIC_RESET_BIT;
728 status = ft1000_write_register (ft1000dev, tempword, FT1000_REG_RESET);
729 msleep(1000);
730 status = ft1000_read_register (ft1000dev, &tempword, FT1000_REG_RESET);
731 DEBUG("Reset Register = 0x%x\n", tempword);
732
733 // Toggle DSP reset
734 card_reset_dsp (ft1000dev, 1);
735 msleep(1000);
736 card_reset_dsp (ft1000dev, 0);
737 msleep(1000);
738
739 status = ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
740
741 // Let's check for FEFE
742 status = ft1000_read_dpram32 (ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX, (PUCHAR)&templong, 4);
743 DEBUG("templong (fefe) = 0x%8x\n", templong);
744
745 // call codeloader
746 status = scram_dnldr(ft1000dev, pFileStart, FileLength);
747
748 if ( status != STATUS_SUCCESS)
749 return;
750
751 msleep(1000);
752 pft1000info->DSP_loading= 0;
753
754 DEBUG("dsp_reload returned\n");
755
756
757 }
758
759 //---------------------------------------------------------------------------
760 //
761 // Function: ft1000_reset_asic
762 // Descripton: This function will call the Card Service function to reset the
763 // ASIC.
764 // Input:
765 // dev - device structure
766 // Output:
767 // none
768 //
769 //---------------------------------------------------------------------------
770 static void ft1000_reset_asic (struct net_device *dev)
771 {
772 FT1000_INFO *info = netdev_priv(dev);
773 struct ft1000_device *ft1000dev = info->pFt1000Dev;
774 u16 tempword;
775
776 DEBUG("ft1000_hw:ft1000_reset_asic called\n");
777
778 info->ASICResetNum++;
779
780 // Let's use the register provided by the Magnemite ASIC to reset the
781 // ASIC and DSP.
782 ft1000_write_register(ft1000dev, (DSP_RESET_BIT | ASIC_RESET_BIT), FT1000_REG_RESET );
783
784 mdelay(1);
785
786 // set watermark to -1 in order to not generate an interrrupt
787 ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
788
789 // clear interrupts
790 ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_ISR);
791 DEBUG("ft1000_hw: interrupt status register = 0x%x\n",tempword);
792 ft1000_write_register (ft1000dev, tempword, FT1000_REG_SUP_ISR);
793 ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_ISR);
794 DEBUG("ft1000_hw: interrupt status register = 0x%x\n",tempword);
795
796 }
797 /*
798 //---------------------------------------------------------------------------
799 //
800 // Function: ft1000_disable_interrupts
801 // Descripton: This function will disable all interrupts.
802 // Input:
803 // dev - device structure
804 // Output:
805 // None.
806 //
807 //---------------------------------------------------------------------------
808 static void ft1000_disable_interrupts(struct net_device *dev) {
809 FT1000_INFO *info = netdev_priv(dev);
810 struct ft1000_device *ft1000dev = info->pFt1000Dev;
811 u16 tempword;
812
813 DEBUG("ft1000_hw: ft1000_disable_interrupts()\n");
814 ft1000_write_register (ft1000dev, ISR_MASK_ALL, FT1000_REG_SUP_IMASK);
815 ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_IMASK);
816 DEBUG("ft1000_hw:ft1000_disable_interrupts:current interrupt enable mask = 0x%x\n", tempword);
817 info->InterruptsEnabled = FALSE;
818 }
819
820 //---------------------------------------------------------------------------
821 //
822 // Function: ft1000_enable_interrupts
823 // Descripton: This function will enable interrupts base on the current interrupt mask.
824 // Input:
825 // dev - device structure
826 // Output:
827 // None.
828 //
829 //---------------------------------------------------------------------------
830 static void ft1000_enable_interrupts(struct net_device *dev) {
831 FT1000_INFO *info = netdev_priv(dev);
832 struct ft1000_device *ft1000dev = info->pFt1000Dev;
833 u16 tempword;
834
835 DEBUG("ft1000_hw:ft1000_enable_interrupts()\n");
836 ft1000_write_register (ft1000dev, info->CurrentInterruptEnableMask, FT1000_REG_SUP_IMASK);
837 ft1000_read_register (ft1000dev, &tempword, FT1000_REG_SUP_IMASK);
838 DEBUG("ft1000_hw:ft1000_enable_interrupts:current interrupt enable mask = 0x%x\n", tempword);
839 info->InterruptsEnabled = TRUE;
840 }
841 */
842
843 //---------------------------------------------------------------------------
844 //
845 // Function: ft1000_reset_card
846 // Descripton: This function will reset the card
847 // Input:
848 // dev - device structure
849 // Output:
850 // status - FALSE (card reset fail)
851 // TRUE (card reset successful)
852 //
853 //---------------------------------------------------------------------------
854 static int ft1000_reset_card (struct net_device *dev)
855 {
856 FT1000_INFO *info = netdev_priv(dev);
857 struct ft1000_device *ft1000dev = info->pFt1000Dev;
858 u16 tempword;
859 PPROV_RECORD ptr;
860
861 DEBUG("ft1000_hw:ft1000_reset_card called.....\n");
862
863 info->fCondResetPend = 1;
864 info->CardReady = 0;
865 info->fProvComplete = 0;
866 //ft1000_disable_interrupts(dev);
867
868 // Cancel heartbeat task since we are reloading the dsp
869 //del_timer(&poll_timer[info->CardNumber]);
870
871 // Make sure we free any memory reserve for provisioning
872 while (list_empty(&info->prov_list) == 0) {
873 DEBUG("ft1000_hw:ft1000_reset_card:deleting provisioning record\n");
874 ptr = list_entry(info->prov_list.next, PROV_RECORD, list);
875 list_del(&ptr->list);
876 kfree(ptr->pprov_data);
877 kfree(ptr);
878 }
879
880 DEBUG("ft1000_hw:ft1000_reset_card: reset asic\n");
881 //reset ASIC
882 ft1000_reset_asic(dev);
883
884 info->DSPResetNum++;
885
886 #if 0
887 DEBUG("ft1000_hw:ft1000_reset_card:resetting ASIC and DSP\n");
888 ft1000_write_register (ft1000dev, (DSP_RESET_BIT | ASIC_RESET_BIT), FT1000_REG_RESET );
889
890
891 // Copy DSP session record into info block if this is not a coldstart
892 //if (ft1000_card_present == 1) {
893 spin_lock_irqsave(&info->dpram_lock, flags);
894
895 ft1000_write_register(ft1000dev, FT1000_DPRAM_MAG_RX_BASE, FT1000_REG_DPRAM_ADDR);
896 for (i=0;i<MAX_DSP_SESS_REC/2; i++) {
897 //info->DSPSess.MagRec[i] = inl(dev->base_addr+FT1000_REG_MAG_DPDATA);
898 ft1000_read_dpram32(ft1000dev, FT1000_REG_MAG_DPDATA, (PCHAR)&(info->DSPSess.MagRec[i]), 4);
899 }
900
901 spin_unlock_irqrestore(&info->dpram_lock, flags);
902 //}
903 info->squeseqnum = 0;
904
905 DEBUG("ft1000_hw:ft1000_reset_card:resetting ASIC\n");
906 mdelay(10);
907 //reset ASIC
908 ft1000_reset_asic(dev);
909
910 info->DSPResetNum++;
911
912 DEBUG("ft1000_hw:ft1000_reset_card:downloading dsp image\n");
913
914
915 // Put dsp in reset and take ASIC out of reset
916 DEBUG("ft1000_hw:ft1000_reset_card:Put DSP in reset and take ASIC out of reset\n");
917 ft1000_write_register (ft1000dev, DSP_RESET_BIT, FT1000_REG_RESET);
918
919 // Setting MAGNEMITE ASIC to big endian mode
920 ft1000_write_register (ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
921
922 // Take DSP out of reset
923
924 ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
925 tempword |= DSP_ENCRYPTED;
926 tempword &= ~DSP_UNENCRYPTED;
927 ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
928 tempword &= ~EFUSE_MEM_DISABLE;
929 ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
930 tempword &= ~DSP_RESET_BIT;
931 ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
932
933
934 // FLARION_DSP_ACTIVE;
935 mdelay(10);
936 DEBUG("ft1000_hw:ft1000_reset_card:Take DSP out of reset\n");
937
938 // Wait for 0xfefe indicating dsp ready before starting download
939 for (i=0; i<50; i++) {
940 //tempword = ft1000_read_dpram_mag_16(dev, FT1000_MAG_DPRAM_FEFE, FT1000_MAG_DPRAM_FEFE_INDX);
941 ft1000_read_dpram32 (ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX, (PUCHAR)&templong, 4);
942 if (tempword == 0xfefe) {
943 break;
944 }
945 mdelay(20);
946 }
947
948 if (i==50) {
949 DEBUG("ft1000_hw:ft1000_reset_card:No FEFE detected from DSP\n");
950 return FALSE;
951 }
952
953
954 #endif
955
956 DEBUG("ft1000_hw:ft1000_reset_card: call dsp_reload\n");
957 dsp_reload(ft1000dev);
958
959 DEBUG("dsp reload successful\n");
960
961
962 mdelay(10);
963
964 // Initialize DSP heartbeat area to ho
965 ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag, FT1000_MAG_HI_HO_INDX);
966 ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (PCHAR)&tempword, FT1000_MAG_HI_HO_INDX);
967 DEBUG("ft1000_hw:ft1000_reset_card:hi_ho value = 0x%x\n", tempword);
968
969
970
971 info->CardReady = 1;
972 //ft1000_enable_interrupts(dev);
973 /* Schedule heartbeat process to run every 2 seconds */
974 //poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
975 //poll_timer[info->CardNumber].data = (u_long)dev;
976 //add_timer(&poll_timer[info->CardNumber]);
977
978 info->fCondResetPend = 0;
979 return TRUE;
980
981 }
982
983
984 //mbelian
985 #ifdef HAVE_NET_DEVICE_OPS
986 static const struct net_device_ops ftnet_ops =
987 {
988 .ndo_open = &ft1000_open,
989 .ndo_stop = &ft1000_close,
990 .ndo_start_xmit = &ft1000_start_xmit,
991 .ndo_get_stats = &ft1000_netdev_stats,
992 };
993 #endif
994
995
996 //---------------------------------------------------------------------------
997 // Function: init_ft1000_netdev
998 //
999 // Parameters: ft1000dev - device structure
1000 //
1001 //
1002 // Returns: STATUS_SUCCESS - success
1003 // STATUS_FAILURE - failure
1004 //
1005 // Description: This function initialize the network device
1006 //
1007 // Notes:
1008 //
1009 //---------------------------------------------------------------------------
1010 u16 init_ft1000_netdev(struct ft1000_device *ft1000dev)
1011 {
1012 struct net_device *netdev;
1013 FT1000_INFO *pInfo = NULL;
1014 PDPRAM_BLK pdpram_blk;
1015 int i;
1016
1017 gCardIndex=0; //mbelian
1018
1019 DEBUG("Enter init_ft1000_netdev...\n");
1020
1021
1022 netdev = alloc_etherdev( sizeof(FT1000_INFO));
1023 if (!netdev )
1024 {
1025 DEBUG("init_ft1000_netdev: can not allocate network device\n");
1026 return STATUS_FAILURE;
1027 }
1028
1029 //pInfo = (PFT1000_INFO)netdev->priv;
1030 pInfo = (FT1000_INFO *) netdev_priv (netdev);
1031
1032 //DEBUG("init_ft1000_netdev: gFt1000Info=%x, netdev=%x, ft1000dev=%x\n", gFt1000Info, netdev, ft1000dev);
1033
1034 memset (pInfo, 0, sizeof(FT1000_INFO));
1035
1036 dev_alloc_name(netdev, netdev->name);
1037
1038 //for the first inserted card, decide the card index beginning number, in case there are existing network interfaces
1039 if ( gCardIndex == 0 )
1040 {
1041 DEBUG("init_ft1000_netdev: network device name is %s\n", netdev->name);
1042
1043 if ( strncmp(netdev->name,"eth", 3) == 0) {
1044 //pInfo->CardNumber = atoi(&netdev->name[3]);
1045 gCardIndex = atoi(&netdev->name[3]);
1046 pInfo->CardNumber = gCardIndex;
1047 DEBUG("card number = %d\n", pInfo->CardNumber);
1048 }
1049 else {
1050 printk(KERN_ERR "ft1000: Invalid device name\n");
1051 kfree(netdev);
1052 return STATUS_FAILURE;
1053 }
1054 }
1055 else
1056 {
1057 //not the first inserted card, increase card number by 1
1058 /*gCardIndex ++;*/
1059 pInfo->CardNumber = gCardIndex;
1060 /*DEBUG("card number = %d\n", pInfo->CardNumber);*/ //mbelian
1061 }
1062
1063 memset(&pInfo->stats, 0, sizeof(struct net_device_stats) );
1064
1065 spin_lock_init(&pInfo->dpram_lock);
1066 pInfo->pFt1000Dev = ft1000dev;
1067 pInfo->DrvErrNum = 0;
1068 pInfo->ASICResetNum = 0;
1069 pInfo->registered = 1;
1070 pInfo->ft1000_reset = ft1000_reset;
1071 pInfo->mediastate = 0;
1072 pInfo->fifo_cnt = 0;
1073 pInfo->DeviceCreated = FALSE;
1074 pInfo->DeviceMajor = 0;
1075 pInfo->CurrentInterruptEnableMask = ISR_DEFAULT_MASK;
1076 pInfo->InterruptsEnabled = FALSE;
1077 pInfo->CardReady = 0;
1078 pInfo->DSP_loading = 0;
1079 pInfo->DSP_TIME[0] = 0;
1080 pInfo->DSP_TIME[1] = 0;
1081 pInfo->DSP_TIME[2] = 0;
1082 pInfo->DSP_TIME[3] = 0;
1083 pInfo->fAppMsgPend = 0;
1084 pInfo->fCondResetPend = 0;
1085 pInfo->usbboot = 0;
1086 pInfo->dspalive = 0;
1087 for (i=0;i<32 ;i++ )
1088 {
1089 pInfo->tempbuf[i] = 0;
1090 }
1091
1092 INIT_LIST_HEAD(&pInfo->prov_list);
1093
1094 //mbelian
1095 #ifdef HAVE_NET_DEVICE_OPS
1096 netdev->netdev_ops = &ftnet_ops;
1097 #else
1098 netdev->hard_start_xmit = &ft1000_start_xmit;
1099 netdev->get_stats = &ft1000_netdev_stats;
1100 netdev->open = &ft1000_open;
1101 netdev->stop = &ft1000_close;
1102 #endif
1103
1104 //netif_stop_queue(netdev); //mbelian
1105
1106
1107 ft1000dev->net = netdev;
1108
1109
1110
1111 //init free_buff_lock, freercvpool, numofmsgbuf, pdpram_blk
1112 //only init once per card
1113 //Jim
1114 DEBUG("Initialize free_buff_lock and freercvpool\n");
1115 spin_lock_init(&free_buff_lock);
1116
1117 // initialize a list of buffers to be use for queuing up receive command data
1118 INIT_LIST_HEAD (&freercvpool);
1119
1120 // create list of free buffers
1121 for (i=0; i<NUM_OF_FREE_BUFFERS; i++) {
1122 // Get memory for DPRAM_DATA link list
1123 pdpram_blk = kmalloc ( sizeof(DPRAM_BLK), GFP_KERNEL );
1124 // Get a block of memory to store command data
1125 pdpram_blk->pbuffer = kmalloc ( MAX_CMD_SQSIZE, GFP_KERNEL );
1126 // link provisioning data
1127 list_add_tail (&pdpram_blk->list, &freercvpool);
1128 }
1129 numofmsgbuf = NUM_OF_FREE_BUFFERS;
1130
1131
1132 return STATUS_SUCCESS;
1133
1134 }
1135
1136
1137
1138 //---------------------------------------------------------------------------
1139 // Function: reg_ft1000_netdev
1140 //
1141 // Parameters: ft1000dev - device structure
1142 //
1143 //
1144 // Returns: STATUS_SUCCESS - success
1145 // STATUS_FAILURE - failure
1146 //
1147 // Description: This function register the network driver
1148 //
1149 // Notes:
1150 //
1151 //---------------------------------------------------------------------------
1152 u16 reg_ft1000_netdev(struct ft1000_device *ft1000dev, struct usb_interface *intf)
1153 {
1154 struct net_device *netdev;
1155 FT1000_INFO *pInfo;
1156 int i, rc;
1157
1158 netdev = ft1000dev->net;
1159 pInfo = netdev_priv(ft1000dev->net);
1160 DEBUG("Enter reg_ft1000_netdev...\n");
1161
1162
1163 ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
1164
1165 usb_set_intfdata(intf, pInfo);
1166 SET_NETDEV_DEV(netdev, &intf->dev);
1167
1168 rc = register_netdev(netdev);
1169 if (rc)
1170 {
1171 DEBUG("reg_ft1000_netdev: could not register network device\n");
1172 free_netdev(netdev);
1173 return STATUS_FAILURE;
1174 }
1175
1176
1177 //Create character device, implemented by Jim
1178 ft1000_CreateDevice(ft1000dev);
1179
1180 //INIT_LIST_HEAD(&pInfo->prov_list);
1181
1182 for (i=0; i<MAX_NUM_CARDS; i++) {
1183 poll_timer[i].function = ft1000_hbchk;
1184 }
1185
1186
1187 //hard code MAC address for now
1188 /**
1189 netdev->dev_addr[0] = 0;
1190 netdev->dev_addr[1] = 7;
1191 netdev->dev_addr[2] = 0x35;
1192 netdev->dev_addr[3] = 0x84;
1193 netdev->dev_addr[4] = 0;
1194 netdev->dev_addr[5] = 0x20 + pInfo->CardNumber;
1195 **/
1196
1197 DEBUG ("reg_ft1000_netdev returned\n");
1198
1199 pInfo->CardReady = 1;
1200
1201
1202 return STATUS_SUCCESS;
1203 }
1204
1205 int ft1000_reset(struct net_device *dev)
1206 {
1207 ft1000_reset_card(dev);
1208 return 0;
1209 }
1210
1211 //---------------------------------------------------------------------------
1212 // Function: ft1000_usb_transmit_complete
1213 //
1214 // Parameters: urb - transmitted usb urb
1215 //
1216 //
1217 // Returns: none
1218 //
1219 // Description: This is the callback function when a urb is transmitted
1220 //
1221 // Notes:
1222 //
1223 //---------------------------------------------------------------------------
1224 static void ft1000_usb_transmit_complete(struct urb *urb)
1225 {
1226
1227 struct ft1000_device *ft1000dev = urb->context;
1228
1229 //DEBUG("ft1000_usb_transmit_complete entered\n");
1230 // Jim spin_lock(&ft1000dev->device_lock);
1231
1232 if (urb->status)
1233 printk("%s: TX status %d\n", ft1000dev->net->name, urb->status);
1234
1235 netif_wake_queue(ft1000dev->net);
1236
1237 //Jim spin_unlock(&ft1000dev->device_lock);
1238 //DEBUG("Return from ft1000_usb_transmit_complete\n");
1239 }
1240
1241
1242 /****************************************************************
1243 * ft1000_control
1244 ****************************************************************/
1245 static int ft1000_read_fifo_reg(struct ft1000_device *ft1000dev,unsigned int pipe,
1246 u8 request,
1247 u8 requesttype,
1248 u16 value,
1249 u16 index,
1250 void *data,
1251 u16 size,
1252 int timeout)
1253 {
1254 u16 ret;
1255
1256 DECLARE_WAITQUEUE(wait, current);
1257 struct urb *urb;
1258 struct usb_ctrlrequest *dr;
1259 int status;
1260
1261 if (ft1000dev == NULL )
1262 {
1263 DEBUG("NULL ft1000dev, failure\n");
1264 return STATUS_FAILURE;
1265 }
1266 else if ( ft1000dev->dev == NULL )
1267 {
1268 DEBUG("NULL ft1000dev->dev, failure\n");
1269 return STATUS_FAILURE;
1270 }
1271
1272 spin_lock(&ft1000dev->device_lock);
1273
1274 /*DECLARE_WAITQUEUE(wait, current);
1275 struct urb *urb;
1276 struct usb_ctrlrequest *dr;
1277 int status;*/
1278
1279 if(in_interrupt())
1280 {
1281 spin_unlock(&ft1000dev->device_lock);
1282 return -EBUSY;
1283 }
1284
1285 urb = usb_alloc_urb(0, GFP_KERNEL);
1286 dr = kmalloc(sizeof(struct usb_ctrlrequest), in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
1287
1288 if(!urb || !dr)
1289 {
1290 if(urb) kfree(urb);
1291 spin_unlock(&ft1000dev->device_lock);
1292 return -ENOMEM;
1293 }
1294
1295
1296
1297 dr->bRequestType = requesttype;
1298 dr->bRequest = request;
1299 dr->wValue = value;
1300 dr->wIndex = index;
1301 dr->wLength = size;
1302
1303 usb_fill_control_urb(urb, ft1000dev->dev, pipe, (char*)dr, (void*)data, size, (void *)ft1000_control_complete, (void*)ft1000dev);
1304
1305
1306 init_waitqueue_head(&ft1000dev->control_wait);
1307
1308 //current->state = TASK_INTERRUPTIBLE; //mbelian
1309 set_current_state(TASK_INTERRUPTIBLE);
1310
1311 add_wait_queue(&ft1000dev->control_wait, &wait);
1312
1313
1314
1315
1316 status = usb_submit_urb(urb, GFP_KERNEL);
1317
1318 if(status)
1319 {
1320 usb_free_urb(urb);
1321 kfree(dr);
1322 remove_wait_queue(&ft1000dev->control_wait, &wait);
1323 spin_unlock(&ft1000dev->device_lock);
1324 return status;
1325 }
1326
1327 if(urb->status == -EINPROGRESS)
1328 {
1329 while(timeout && urb->status == -EINPROGRESS)
1330 {
1331 status = timeout = schedule_timeout(timeout);
1332 }
1333 }
1334 else
1335 {
1336 status = 1;
1337 }
1338
1339 remove_wait_queue(&ft1000dev->control_wait, &wait);
1340
1341 if(!status)
1342 {
1343 usb_unlink_urb(urb);
1344 printk("ft1000 timeout\n");
1345 status = -ETIMEDOUT;
1346 }
1347 else
1348 {
1349 status = urb->status;
1350
1351 if(urb->status)
1352 {
1353 printk("ft1000 control message failed (urb addr: %x) with error number: %i\n", (int)urb, (int)status);
1354
1355 usb_clear_halt(ft1000dev->dev, usb_rcvctrlpipe(ft1000dev->dev, 0));
1356 usb_clear_halt(ft1000dev->dev, usb_sndctrlpipe(ft1000dev->dev, 0));
1357 usb_unlink_urb(urb);
1358 }
1359 }
1360
1361
1362
1363 usb_free_urb(urb);
1364 kfree(dr);
1365 spin_unlock(&ft1000dev->device_lock);
1366 return ret;
1367
1368
1369 }
1370
1371 //---------------------------------------------------------------------------
1372 // Function: ft1000_read_fifo_len
1373 //
1374 // Parameters: ft1000dev - device structure
1375 //
1376 //
1377 // Returns: none
1378 //
1379 // Description: read the fifo length register content
1380 //
1381 // Notes:
1382 //
1383 //---------------------------------------------------------------------------
1384 static inline u16 ft1000_read_fifo_len (struct net_device *dev)
1385 {
1386 u16 temp;
1387 u16 ret;
1388
1389 //FT1000_INFO *info = (PFT1000_INFO)dev->priv;
1390 FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev);
1391 struct ft1000_device *ft1000dev = info->pFt1000Dev;
1392 // DEBUG("ft1000_read_fifo_len: enter ft1000dev %x\n", ft1000dev); //aelias [-] reason: warning: format ???%x??? expects type ???unsigned int???, but argument 2 has type ???struct ft1000_device *???
1393 DEBUG("ft1000_read_fifo_len: enter ft1000dev %x\n", (unsigned int)ft1000dev); //aelias [+] reason: up
1394 //ft1000_read_register(ft1000dev, &temp, FT1000_REG_MAG_UFSR);
1395
1396 ret = STATUS_SUCCESS;
1397
1398 ret = ft1000_read_fifo_reg(ft1000dev,
1399 usb_rcvctrlpipe(ft1000dev->dev,0),
1400 HARLEY_READ_REGISTER,
1401 HARLEY_READ_OPERATION,
1402 0,
1403 FT1000_REG_MAG_UFSR,
1404 &temp,
1405 2,
1406 LARGE_TIMEOUT);
1407
1408 if (ret>0)
1409 ret = STATUS_SUCCESS;
1410 else
1411 ret = STATUS_FAILURE;
1412
1413 DEBUG("ft1000_read_fifo_len: returned %d\n", temp);
1414
1415 return (temp- 16);
1416
1417 }
1418
1419
1420 //---------------------------------------------------------------------------
1421 //
1422 // Function: ft1000_copy_down_pkt
1423 // Descripton: This function will take an ethernet packet and convert it to
1424 // a Flarion packet prior to sending it to the ASIC Downlink
1425 // FIFO.
1426 // Input:
1427 // dev - device structure
1428 // packet - address of ethernet packet
1429 // len - length of IP packet
1430 // Output:
1431 // status - FAILURE
1432 // SUCCESS
1433 //
1434 //---------------------------------------------------------------------------
1435 int ft1000_copy_down_pkt (struct net_device *netdev, u8 *packet, u16 len)
1436 {
1437 FT1000_INFO *pInfo = netdev_priv(netdev);
1438 struct ft1000_device *pFt1000Dev = pInfo->pFt1000Dev;
1439
1440
1441 int i, count, ret;
1442 USHORT *pTemp;
1443 USHORT checksum;
1444 u8 *t;
1445
1446 if (!pInfo->CardReady)
1447 {
1448
1449 DEBUG("ft1000_copy_down_pkt::Card Not Ready\n");
1450 return STATUS_FAILURE;
1451
1452 }
1453
1454
1455 //DEBUG("ft1000_copy_down_pkt() entered, len = %d\n", len);
1456
1457 #if 0
1458 // Check if there is room on the FIFO
1459 if ( len > ft1000_read_fifo_len (netdev) )
1460 {
1461 udelay(10);
1462 if ( len > ft1000_read_fifo_len (netdev) )
1463 {
1464 udelay(20);
1465 }
1466
1467 if ( len > ft1000_read_fifo_len (netdev) )
1468 {
1469 udelay(20);
1470 }
1471
1472 if ( len > ft1000_read_fifo_len (netdev) )
1473 {
1474 udelay(20);
1475 }
1476
1477 if ( len > ft1000_read_fifo_len (netdev) )
1478 {
1479 udelay(20);
1480 }
1481
1482 if ( len > ft1000_read_fifo_len (netdev) )
1483 {
1484 udelay(20);
1485 }
1486
1487 if ( len > ft1000_read_fifo_len (netdev) )
1488 {
1489 DEBUG("ft1000_hw:ft1000_copy_down_pkt:Transmit FIFO is fulli - pkt drop\n");
1490 pInfo->stats.tx_errors++;
1491 return STATUS_SUCCESS;
1492 }
1493 }
1494 #endif
1495
1496 count = sizeof (PSEUDO_HDR) + len;
1497 if(count > MAX_BUF_SIZE)
1498 {
1499 DEBUG("Error:ft1000_copy_down_pkt:Message Size Overflow!\n");
1500 DEBUG("size = %d\n", count);
1501 return STATUS_FAILURE;
1502 }
1503
1504 if ( count % 4)
1505 count = count + (4- (count %4) );
1506
1507 pTemp = (PUSHORT)&(pFt1000Dev->tx_buf[0]);
1508 *pTemp ++ = ntohs(count);
1509 *pTemp ++ = 0x1020;
1510 *pTemp ++ = 0x2010;
1511 *pTemp ++ = 0x9100;
1512 *pTemp ++ = 0;
1513 *pTemp ++ = 0;
1514 *pTemp ++ = 0;
1515 pTemp = (PUSHORT)&(pFt1000Dev->tx_buf[0]);
1516 checksum = *pTemp ++;
1517 for (i=1; i<7; i++)
1518 {
1519 checksum ^= *pTemp ++;
1520 }
1521 *pTemp++ = checksum;
1522 memcpy (&(pFt1000Dev->tx_buf[sizeof(PSEUDO_HDR)]), packet, len);
1523
1524 //usb_init_urb(pFt1000Dev->tx_urb); //mbelian
1525
1526 netif_stop_queue(netdev);
1527
1528 //DEBUG ("ft1000_copy_down_pkt: count = %d\n", count);
1529
1530 usb_fill_bulk_urb(pFt1000Dev->tx_urb,
1531 pFt1000Dev->dev,
1532 usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr),
1533 pFt1000Dev->tx_buf,
1534 count,
1535 ft1000_usb_transmit_complete,
1536 (void*)pFt1000Dev);
1537
1538 t = (u8 *)pFt1000Dev->tx_urb->transfer_buffer;
1539 //DEBUG("transfer_length=%d\n", pFt1000Dev->tx_urb->transfer_buffer_length);
1540 /*for (i=0; i<count; i++ )
1541 {
1542 DEBUG("%x ", *t++ );
1543 }*/
1544
1545
1546 ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
1547 if(ret)
1548 {
1549 DEBUG("ft1000 failed tx_urb %d\n", ret);
1550
1551 /* pInfo->stats.tx_errors++;
1552
1553 netif_start_queue(netdev); */ //mbelian
1554 return STATUS_FAILURE;
1555
1556 }
1557 else
1558 {
1559 //DEBUG("ft1000 sucess tx_urb %d\n", ret);
1560
1561 pInfo->stats.tx_packets++;
1562 pInfo->stats.tx_bytes += (len+14);
1563 }
1564
1565 //DEBUG("ft1000_copy_down_pkt() exit\n");
1566
1567 return STATUS_SUCCESS;
1568 }
1569
1570 //---------------------------------------------------------------------------
1571 // Function: ft1000_start_xmit
1572 //
1573 // Parameters: skb - socket buffer to be sent
1574 // dev - network device
1575 //
1576 //
1577 // Returns: none
1578 //
1579 // Description: transmit a ethernet packet
1580 //
1581 // Notes:
1582 //
1583 //---------------------------------------------------------------------------
1584 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
1585 {
1586 FT1000_INFO *pInfo = netdev_priv(dev);
1587 struct ft1000_device *pFt1000Dev= pInfo->pFt1000Dev;
1588 u8 *pdata;
1589 int maxlen, pipe;
1590
1591
1592 //DEBUG(" ft1000_start_xmit() entered\n");
1593
1594 if ( skb == NULL )
1595 {
1596 DEBUG ("ft1000_hw: ft1000_start_xmit:skb == NULL!!!\n" );
1597 return STATUS_FAILURE;
1598 }
1599
1600 if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1601 {
1602 DEBUG("network driver is closed, return\n");
1603 dev_kfree_skb(skb);
1604 //usb_kill_urb(pFt1000Dev->tx_urb); //mbelian
1605 return STATUS_SUCCESS;
1606 }
1607
1608 //DEBUG("ft1000_start_xmit 1:length of packet = %d\n", skb->len);
1609 pipe = usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
1610 maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
1611 //DEBUG("ft1000_start_xmit 2: pipe=%d dev->maxpacket = %d\n", pipe, maxlen);
1612
1613 pdata = (u8 *)skb->data;
1614 /*for (i=0; i<skb->len; i++)
1615 DEBUG("skb->data[%d]=%x ", i, *(skb->data+i));
1616
1617 DEBUG("\n");*/
1618
1619
1620 if (pInfo->mediastate == 0)
1621 {
1622 /* Drop packet is mediastate is down */
1623 DEBUG("ft1000_hw:ft1000_start_xmit:mediastate is down\n");
1624 dev_kfree_skb(skb);
1625 return STATUS_SUCCESS;
1626 }
1627
1628 if ( (skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE) )
1629 {
1630 /* Drop packet which has invalid size */
1631 DEBUG("ft1000_hw:ft1000_start_xmit:invalid ethernet length\n");
1632 dev_kfree_skb(skb);
1633 return STATUS_SUCCESS;
1634 }
1635 //mbelian
1636 if(ft1000_copy_down_pkt (dev, (pdata+ENET_HEADER_SIZE-2), skb->len - ENET_HEADER_SIZE + 2) == STATUS_FAILURE)
1637 {
1638 dev_kfree_skb(skb);
1639 return STATUS_SUCCESS;
1640 }
1641
1642 dev_kfree_skb(skb);
1643 //DEBUG(" ft1000_start_xmit() exit\n");
1644
1645 return 0;
1646 }
1647
1648 //---------------------------------------------------------------------------
1649 //
1650 // Function: ft1000_copy_up_pkt
1651 // Descripton: This function will take a packet from the FIFO up link and
1652 // convert it into an ethernet packet and deliver it to the IP stack
1653 // Input:
1654 // urb - the receving usb urb
1655 //
1656 // Output:
1657 // status - FAILURE
1658 // SUCCESS
1659 //
1660 //---------------------------------------------------------------------------
1661 int ft1000_copy_up_pkt (struct urb *urb)
1662 {
1663 PFT1000_INFO info = urb->context;
1664 struct ft1000_device *ft1000dev = info->pFt1000Dev;
1665 struct net_device *net = ft1000dev->net;
1666
1667 u16 tempword;
1668 u16 len;
1669 u16 lena; //mbelian
1670 struct sk_buff *skb;
1671 u16 i;
1672 u8 *pbuffer=NULL;
1673 u8 *ptemp=NULL;
1674 u16 *chksum;
1675
1676
1677 //DEBUG("ft1000_copy_up_pkt entered\n");
1678
1679 if ( ft1000dev->status & FT1000_STATUS_CLOSING)
1680 {
1681 DEBUG("network driver is closed, return\n");
1682 return STATUS_SUCCESS;
1683 }
1684
1685 // Read length
1686 len = urb->transfer_buffer_length;
1687 lena = urb->actual_length; //mbelian
1688 //DEBUG("ft1000_copy_up_pkt: transfer_buffer_length=%d, actual_buffer_len=%d\n",
1689 // urb->transfer_buffer_length, urb->actual_length);
1690
1691 chksum = (PUSHORT)ft1000dev->rx_buf;
1692
1693 tempword = *chksum++;
1694 for (i=1; i<7; i++)
1695 {
1696 tempword ^= *chksum++;
1697 }
1698
1699 if (tempword != *chksum)
1700 {
1701 info->stats.rx_errors ++;
1702 ft1000_submit_rx_urb(info);
1703 return STATUS_FAILURE;
1704 }
1705
1706
1707 //DEBUG("ft1000_copy_up_pkt: checksum is correct %x\n", *chksum);
1708
1709 skb = dev_alloc_skb(len+12+2);
1710
1711 if (skb == NULL)
1712 {
1713 DEBUG("ft1000_copy_up_pkt: No Network buffers available\n");
1714 info->stats.rx_errors++;
1715 ft1000_submit_rx_urb(info);
1716 return STATUS_FAILURE;
1717 }
1718
1719 pbuffer = (u8 *)skb_put(skb, len+12);
1720
1721 //subtract the number of bytes read already
1722 ptemp = pbuffer;
1723
1724 // fake MAC address
1725 *pbuffer++ = net->dev_addr[0];
1726 *pbuffer++ = net->dev_addr[1];
1727 *pbuffer++ = net->dev_addr[2];
1728 *pbuffer++ = net->dev_addr[3];
1729 *pbuffer++ = net->dev_addr[4];
1730 *pbuffer++ = net->dev_addr[5];
1731 *pbuffer++ = 0x00;
1732 *pbuffer++ = 0x07;
1733 *pbuffer++ = 0x35;
1734 *pbuffer++ = 0xff;
1735 *pbuffer++ = 0xff;
1736 *pbuffer++ = 0xfe;
1737
1738
1739
1740
1741 memcpy(pbuffer, ft1000dev->rx_buf+sizeof(PSEUDO_HDR), len-sizeof(PSEUDO_HDR));
1742
1743 //DEBUG("ft1000_copy_up_pkt: Data passed to Protocol layer\n");
1744 /*for (i=0; i<len+12; i++)
1745 {
1746 DEBUG("ft1000_copy_up_pkt: Protocol Data: 0x%x\n ", *ptemp++);
1747 }*/
1748
1749 skb->dev = net;
1750
1751 skb->protocol = eth_type_trans(skb, net);
1752 skb->ip_summed = CHECKSUM_UNNECESSARY;
1753 netif_rx(skb);
1754
1755 info->stats.rx_packets++;
1756 // Add on 12 bytes for MAC address which was removed
1757 info->stats.rx_bytes += (lena+12); //mbelian
1758
1759 ft1000_submit_rx_urb(info);
1760 //DEBUG("ft1000_copy_up_pkt exited\n");
1761 return SUCCESS;
1762 }
1763
1764 //---------------------------------------------------------------------------
1765 //
1766 // Function: ft1000_submit_rx_urb
1767 // Descripton: the receiving function of the network driver
1768 //
1769 // Input:
1770 // info - a private structure contains the device information
1771 //
1772 // Output:
1773 // status - FAILURE
1774 // SUCCESS
1775 //
1776 //---------------------------------------------------------------------------
1777 int ft1000_submit_rx_urb(PFT1000_INFO info)
1778 {
1779 int result;
1780 struct ft1000_device *pFt1000Dev = info->pFt1000Dev;
1781
1782 //netif_carrier_on(pFt1000Dev->net);
1783
1784 //DEBUG ("ft1000_submit_rx_urb entered: sizeof rx_urb is %d\n", sizeof(*pFt1000Dev->rx_urb));
1785 if ( pFt1000Dev->status & FT1000_STATUS_CLOSING)
1786 {
1787 DEBUG("network driver is closed, return\n");
1788 //usb_kill_urb(pFt1000Dev->rx_urb); //mbelian
1789 return STATUS_SUCCESS;
1790 }
1791 //memset(pFt1000Dev->rx_urb, 0, sizeof(*pFt1000Dev->rx_urb));
1792 //usb_init_urb(pFt1000Dev->rx_urb);//mbelian
1793
1794 //spin_lock_init(&pFt1000Dev->rx_urb->lock);
1795
1796 usb_fill_bulk_urb(pFt1000Dev->rx_urb,
1797 pFt1000Dev->dev,
1798 usb_rcvbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_in_endpointAddr),
1799 pFt1000Dev->rx_buf,
1800 MAX_BUF_SIZE,
1801 (usb_complete_t)ft1000_copy_up_pkt,
1802 info);
1803
1804
1805 if((result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC)))
1806 {
1807 printk("ft1000_submit_rx_urb: submitting rx_urb %d failed\n", result);
1808 return STATUS_FAILURE;
1809 }
1810
1811 //DEBUG("ft1000_submit_rx_urb exit: result=%d\n", result);
1812
1813 return STATUS_SUCCESS;
1814 }
1815
1816 //---------------------------------------------------------------------------
1817 // Function: ft1000_open
1818 //
1819 // Parameters:
1820 // dev - network device
1821 //
1822 //
1823 // Returns: none
1824 //
1825 // Description: open the network driver
1826 //
1827 // Notes:
1828 //
1829 //---------------------------------------------------------------------------
1830 static int ft1000_open (struct net_device *dev)
1831 {
1832 FT1000_INFO *pInfo = (FT1000_INFO *)netdev_priv(dev);
1833 struct timeval tv; //mbelian
1834
1835 DEBUG("ft1000_open is called for card %d\n", pInfo->CardNumber);
1836 //DEBUG("ft1000_open: dev->addr=%x, dev->addr_len=%d\n", dev->addr, dev->addr_len);
1837
1838 pInfo->stats.rx_bytes = 0; //mbelian
1839 pInfo->stats.tx_bytes = 0; //mbelian
1840 pInfo->stats.rx_packets = 0; //mbelian
1841 pInfo->stats.tx_packets = 0; //mbelian
1842 do_gettimeofday(&tv);
1843 pInfo->ConTm = tv.tv_sec;
1844 pInfo->ProgConStat = 0; //mbelian
1845
1846
1847 netif_start_queue(dev);
1848
1849 //netif_device_attach(dev);
1850
1851 netif_carrier_on(dev); //mbelian
1852
1853 ft1000_submit_rx_urb(pInfo);
1854 return 0;
1855 }
1856
1857 //---------------------------------------------------------------------------
1858 // Function: ft1000_close
1859 //
1860 // Parameters:
1861 // net - network device
1862 //
1863 //
1864 // Returns: none
1865 //
1866 // Description: close the network driver
1867 //
1868 // Notes:
1869 //
1870 //---------------------------------------------------------------------------
1871 int ft1000_close(struct net_device *net)
1872 {
1873 FT1000_INFO *pInfo = (FT1000_INFO *) netdev_priv (net);
1874 struct ft1000_device *ft1000dev = pInfo->pFt1000Dev;
1875
1876 //DEBUG ("ft1000_close: netdev->refcnt=%d\n", net->refcnt);
1877
1878 ft1000dev->status |= FT1000_STATUS_CLOSING;
1879
1880 //DEBUG("ft1000_close: calling usb_kill_urb \n");
1881 //usb_kill_urb(ft1000dev->rx_urb);
1882 //usb_kill_urb(ft1000dev->tx_urb);
1883
1884
1885 DEBUG("ft1000_close: pInfo=%x, ft1000dev=%x\n", (int)pInfo, (int)ft1000dev);
1886 netif_carrier_off(net);//mbelian
1887 netif_stop_queue(net);
1888 //DEBUG("ft1000_close: netif_stop_queue called\n");
1889 ft1000dev->status &= ~FT1000_STATUS_CLOSING;
1890
1891 pInfo->ProgConStat = 0xff; //mbelian
1892
1893
1894 return 0;
1895 }
1896
1897 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
1898 {
1899 FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev);
1900 //struct ft1000_device *ft1000dev = info->pFt1000Dev;
1901
1902 //return &(ft1000dev->stats);//mbelian
1903 return &(info->stats); //mbelian
1904 }
1905
1906
1907 /*********************************************************************************
1908 Jim
1909 */
1910
1911
1912 //---------------------------------------------------------------------------
1913 //
1914 // Function: ft1000_chkcard
1915 // Descripton: This function will check if the device is presently available on
1916 // the system.
1917 // Input:
1918 // dev - device structure
1919 // Output:
1920 // status - FALSE (device is not present)
1921 // TRUE (device is present)
1922 //
1923 //---------------------------------------------------------------------------
1924 static int ft1000_chkcard (struct ft1000_device *dev) {
1925 u16 tempword;
1926 u16 status;
1927 FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev->net);
1928
1929 if (info->fCondResetPend)
1930 {
1931 DEBUG("ft1000_hw:ft1000_chkcard:Card is being reset, return FALSE\n");
1932 return TRUE;
1933 }
1934
1935 // Mask register is used to check for device presence since it is never
1936 // set to zero.
1937 status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
1938 //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_SUP_IMASK = %x\n", tempword);
1939 if (tempword == 0) {
1940 DEBUG("ft1000_hw:ft1000_chkcard: IMASK = 0 Card not detected\n");
1941 return FALSE;
1942 }
1943
1944 // The system will return the value of 0xffff for the version register
1945 // if the device is not present.
1946 status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
1947 //DEBUG("ft1000_hw:ft1000_chkcard: read FT1000_REG_ASIC_ID = %x\n", tempword);
1948 //pxu if (tempword == 0xffff) {
1949 if (tempword != 0x1b01 ){
1950 dev->status |= FT1000_STATUS_CLOSING; //mbelian
1951 DEBUG("ft1000_hw:ft1000_chkcard: Version = 0xffff Card not detected\n");
1952 return FALSE;
1953 }
1954 return TRUE;
1955 }
1956
1957 //---------------------------------------------------------------------------
1958 //
1959 // Function: ft1000_hbchk
1960 // Descripton: This function will perform the heart beat check of the DSP as
1961 // well as the ASIC.
1962 // Input:
1963 // dev - device structure
1964 // Output:
1965 // none
1966 //
1967 //---------------------------------------------------------------------------
1968 static void ft1000_hbchk(u_long data)
1969 {
1970 struct ft1000_device *dev = (struct ft1000_device *)data;
1971
1972 FT1000_INFO *info;
1973 USHORT tempword;
1974 u16 status;
1975 info = (FT1000_INFO *) netdev_priv (dev->net);
1976
1977 DEBUG("ft1000_hbchk called for CardNumber = %d CardReady = %d\n", info->CardNumber, info->CardReady);
1978
1979 if (info->fCondResetPend == 1) {
1980 // Reset ASIC and DSP
1981 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
1982 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
1983 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
1984 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
1985
1986 info->DrvErrNum = DSP_CONDRESET_INFO;
1987 DEBUG("ft1000_hw:DSP conditional reset requested\n");
1988 ft1000_reset_card(dev->net);
1989 info->fCondResetPend = 0;
1990 /* Schedule this module to run every 2 seconds */
1991
1992 poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
1993 poll_timer[info->CardNumber].data = (u_long)dev;
1994 add_timer(&poll_timer[info->CardNumber]);
1995
1996
1997
1998 return;
1999 }
2000
2001 if (info->CardReady == 1) {
2002 // Perform dsp heartbeat check
2003 status = ntohs(ft1000_read_dpram16(dev, FT1000_MAG_HI_HO, (PUCHAR)&tempword, FT1000_MAG_HI_HO_INDX));
2004 DEBUG("ft1000_hw:ft1000_hbchk:hi_ho value = 0x%x\n", tempword);
2005 // Let's perform another check if ho is not detected
2006 if (tempword != ho) {
2007 status = ntohs(ft1000_read_dpram16(dev, FT1000_MAG_HI_HO, (PUCHAR)&tempword,FT1000_MAG_HI_HO_INDX));
2008 }
2009 if (tempword != ho) {
2010 printk(KERN_INFO "ft1000: heartbeat failed - no ho detected\n");
2011 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2012 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2013 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2014 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2015 info->DrvErrNum = DSP_HB_INFO;
2016 if (ft1000_reset_card(dev->net) == 0) {
2017 printk(KERN_INFO "ft1000: Hardware Failure Detected - PC Card disabled\n");
2018 info->ProgConStat = 0xff;
2019 return;
2020 }
2021 /* Schedule this module to run every 2 seconds */
2022 poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
2023 poll_timer[info->CardNumber].data = (u_long)dev;
2024 add_timer(&poll_timer[info->CardNumber]);
2025 return;
2026 }
2027
2028 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2029 // Let's check doorbell again if fail
2030 if (tempword & FT1000_DB_HB) {
2031 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2032 }
2033 if (tempword & FT1000_DB_HB) {
2034 printk(KERN_INFO "ft1000: heartbeat doorbell not clear by firmware\n");
2035 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2036 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2037 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2038 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2039 info->DrvErrNum = DSP_HB_INFO;
2040 if (ft1000_reset_card(dev->net) == 0) {
2041 printk(KERN_INFO "ft1000: Hardware Failure Detected - PC Card disabled\n");
2042 info->ProgConStat = 0xff;
2043 return;
2044 }
2045 /* Schedule this module to run every 2 seconds */
2046 poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
2047 poll_timer[info->CardNumber].data = (u_long)dev;
2048 add_timer(&poll_timer[info->CardNumber]);
2049 return;
2050 }
2051
2052 // Set dedicated area to hi and ring appropriate doorbell according
2053 // to hi/ho heartbeat protocol
2054 ft1000_write_dpram16(dev, FT1000_MAG_HI_HO, hi_mag, FT1000_MAG_HI_HO_INDX);
2055
2056 status = ntohs(ft1000_read_dpram16(dev, FT1000_MAG_HI_HO, (PUCHAR)&tempword, FT1000_MAG_HI_HO_INDX));
2057 // Let's write hi again if fail
2058 if (tempword != hi) {
2059 ft1000_write_dpram16(dev, FT1000_MAG_HI_HO, hi_mag, FT1000_MAG_HI_HO_INDX);
2060 status = ntohs(ft1000_read_dpram16(dev, FT1000_MAG_HI_HO, (PUCHAR)&tempword, FT1000_MAG_HI_HO_INDX));
2061
2062 }
2063 if (tempword != hi) {
2064 printk(KERN_INFO "ft1000: heartbeat failed - cannot write hi into DPRAM\n");
2065 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2066 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2067 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2068 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2069
2070 info->DrvErrNum = DSP_HB_INFO;
2071 if (ft1000_reset_card(dev->net) == 0) {
2072 printk(KERN_INFO "ft1000: Hardware Failure Detected - PC Card disabled\n");
2073 info->ProgConStat = 0xff;
2074 return;
2075 }
2076 /* Schedule this module to run every 2 seconds */
2077 poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
2078 poll_timer[info->CardNumber].data = (u_long)dev;
2079 add_timer(&poll_timer[info->CardNumber]);
2080 return;
2081 }
2082 ft1000_write_register(dev, FT1000_DB_HB, FT1000_REG_DOORBELL);
2083
2084 }
2085
2086 /* Schedule this module to run every 2 seconds */
2087 poll_timer[info->CardNumber].expires = jiffies + (2*HZ);
2088 poll_timer[info->CardNumber].data = (u_long)dev;
2089 add_timer(&poll_timer[info->CardNumber]);
2090 }
2091
2092 //---------------------------------------------------------------------------
2093 //
2094 // Function: ft1000_receive_cmd
2095 // Descripton: This function will read a message from the dpram area.
2096 // Input:
2097 // dev - network device structure
2098 // pbuffer - caller supply address to buffer
2099 // pnxtph - pointer to next pseudo header
2100 // Output:
2101 // Status = 0 (unsuccessful)
2102 // = 1 (successful)
2103 //
2104 //---------------------------------------------------------------------------
2105 BOOLEAN ft1000_receive_cmd (struct ft1000_device *dev, u16 *pbuffer, int maxsz, u16 *pnxtph) {
2106 u16 size, ret;
2107 u16 *ppseudohdr;
2108 int i;
2109 u16 tempword;
2110
2111 ret = ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (PUCHAR)&size, FT1000_MAG_PH_LEN_INDX);
2112 size = ntohs(size) + PSEUDOSZ;
2113 if (size > maxsz) {
2114 DEBUG("FT1000:ft1000_receive_cmd:Invalid command length = %d\n", size);
2115 return FALSE;
2116 }
2117 else {
2118 ppseudohdr = (u16 *)pbuffer;
2119 //spin_lock_irqsave (&info->dpram_lock, flags);
2120 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE, FT1000_REG_DPRAM_ADDR);
2121 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
2122 //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
2123 pbuffer++;
2124 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE+1, FT1000_REG_DPRAM_ADDR);
2125 for (i=0; i<=(size>>2); i++) {
2126 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
2127 pbuffer++;
2128 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
2129 pbuffer++;
2130 }
2131 //copy odd aligned word
2132 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
2133 //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
2134 pbuffer++;
2135 ret = ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
2136 //DEBUG("ft1000_hw:received data = 0x%x\n", *pbuffer);
2137 pbuffer++;
2138 if (size & 0x0001) {
2139 //copy odd byte from fifo
2140 ret = ft1000_read_register(dev, &tempword, FT1000_REG_DPRAM_DATA);
2141 *pbuffer = ntohs(tempword);
2142 }
2143 //spin_unlock_irqrestore(&info->dpram_lock, flags);
2144
2145 // Check if pseudo header checksum is good
2146 // Calculate pseudo header checksum
2147 tempword = *ppseudohdr++;
2148 for (i=1; i<7; i++) {
2149 tempword ^= *ppseudohdr++;
2150 }
2151 if ( (tempword != *ppseudohdr) ) {
2152 return FALSE;
2153 }
2154
2155
2156 #if 0
2157 DEBUG("ft1000_receive_cmd:pbuffer\n");
2158 for(i = 0; i < size; i+=5)
2159 {
2160 if( (i + 5) < size )
2161 DEBUG("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", tempbuffer[i], tempbuffer[i+1], tempbuffer[i+2], tempbuffer[i+3], tempbuffer[i+4]);
2162 else
2163 {
2164 for (j = i; j < size; j++)
2165 DEBUG("0x%x ", tempbuffer[j]);
2166 DEBUG("\n");
2167 break;
2168 }
2169 }
2170
2171 #endif
2172
2173 return TRUE;
2174 }
2175 }
2176
2177
2178 int ft1000_dsp_prov(void *arg)
2179 {
2180 struct ft1000_device *dev = (struct ft1000_device *)arg;
2181 FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev->net);
2182 u16 tempword;
2183 u16 len;
2184 u16 i=0;
2185 PPROV_RECORD ptr;
2186 PPSEUDO_HDR ppseudo_hdr;
2187 PUSHORT pmsg;
2188 u16 status;
2189 USHORT TempShortBuf [256];
2190
2191 DEBUG("*** DspProv Entered\n");
2192
2193 while ( list_empty(&info->prov_list) == 0
2194 /*&& !kthread_should_stop() */)
2195 {
2196 DEBUG("DSP Provisioning List Entry\n");
2197
2198 // Check if doorbell is available
2199 DEBUG("check if doorbell is cleared\n");
2200 status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
2201 if (status)
2202 {
2203 DEBUG("ft1000_dsp_prov::ft1000_read_register error\n");
2204 break;
2205 }
2206
2207 while (tempword & FT1000_DB_DPRAM_TX) {
2208 mdelay(10);
2209 i++;
2210 if (i==10) {
2211 DEBUG("FT1000:ft1000_dsp_prov:message drop\n");
2212 return STATUS_FAILURE;
2213 }
2214 ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2215 }
2216
2217 if ( !(tempword & FT1000_DB_DPRAM_TX) ) {
2218 DEBUG("*** Provision Data Sent to DSP\n");
2219
2220 // Send provisioning data
2221 ptr = list_entry(info->prov_list.next, PROV_RECORD, list);
2222 len = *(u16 *)ptr->pprov_data;
2223 len = htons(len);
2224 len += PSEUDOSZ;
2225 //len = htons(len);
2226
2227 pmsg = (PUSHORT)ptr->pprov_data;
2228 ppseudo_hdr = (PPSEUDO_HDR)pmsg;
2229 // Insert slow queue sequence number
2230 ppseudo_hdr->seq_num = info->squeseqnum++;
2231 ppseudo_hdr->portsrc = 0;
2232 // Calculate new checksum
2233 ppseudo_hdr->checksum = *pmsg++;
2234 //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
2235 for (i=1; i<7; i++) {
2236 ppseudo_hdr->checksum ^= *pmsg++;
2237 //DEBUG("checksum = 0x%x\n", ppseudo_hdr->checksum);
2238 }
2239
2240 TempShortBuf[0] = 0;
2241 TempShortBuf[1] = htons (len);
2242 memcpy(&TempShortBuf[2], ppseudo_hdr, len);
2243
2244 status = ft1000_write_dpram32 (dev, 0, (PUCHAR)&TempShortBuf[0], (unsigned short)(len+2));
2245 status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
2246
2247 list_del(&ptr->list);
2248 kfree(ptr->pprov_data);
2249 kfree(ptr);
2250 }
2251 msleep(10);
2252 }
2253
2254 DEBUG("DSP Provisioning List Entry finished\n");
2255
2256 msleep(100);
2257
2258 info->fProvComplete = 1;
2259 info->CardReady = 1;
2260 info->DSP_loading= 0;
2261 return STATUS_SUCCESS;
2262
2263 }
2264
2265
2266 int ft1000_proc_drvmsg (struct ft1000_device *dev, u16 size) {
2267 FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev->net);
2268 u16 msgtype;
2269 u16 tempword;
2270 PMEDIAMSG pmediamsg;
2271 PDSPINITMSG pdspinitmsg;
2272 PDRVMSG pdrvmsg;
2273 u16 i;
2274 PPSEUDO_HDR ppseudo_hdr;
2275 PUSHORT pmsg;
2276 u16 status;
2277 //struct timeval tv; //mbelian
2278 union {
2279 u8 byte[2];
2280 u16 wrd;
2281 } convert;
2282
2283
2284 char cmdbuffer[1600];
2285
2286 status = ft1000_read_dpram32(dev, 0x200, (PUCHAR)&cmdbuffer[0], size);
2287
2288
2289 //if (ft1000_receive_cmd(dev, &cmdbuffer[0], MAX_CMD_SQSIZE, &tempword))
2290 {
2291
2292 #ifdef JDEBUG
2293 DEBUG("ft1000_proc_drvmsg:cmdbuffer\n");
2294 for(i = 0; i < size; i+=5)
2295 {
2296 if( (i + 5) < size )
2297 DEBUG("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", cmdbuffer[i], cmdbuffer[i+1], cmdbuffer[i+2], cmdbuffer[i+3], cmdbuffer[i+4]);
2298 else
2299 {
2300 for (j = i; j < size; j++)
2301 DEBUG("0x%x ", cmdbuffer[j]);
2302 DEBUG("\n");
2303 break;
2304 }
2305 }
2306 #endif
2307 pdrvmsg = (PDRVMSG)&cmdbuffer[2];
2308 msgtype = ntohs(pdrvmsg->type);
2309 DEBUG("ft1000_proc_drvmsg:Command message type = 0x%x\n", msgtype);
2310 switch (msgtype) {
2311 case MEDIA_STATE: {
2312 DEBUG("ft1000_proc_drvmsg:Command message type = MEDIA_STATE");
2313
2314 pmediamsg = (PMEDIAMSG)&cmdbuffer[0];
2315 if (info->ProgConStat != 0xFF) {
2316 if (pmediamsg->state) {
2317 DEBUG("Media is up\n");
2318 if (info->mediastate == 0) {
2319 if ( info->NetDevRegDone )
2320 {
2321 //netif_carrier_on(dev->net);//mbelian
2322 netif_wake_queue(dev->net);
2323 }
2324 info->mediastate = 1;
2325 /*do_gettimeofday(&tv);
2326 info->ConTm = tv.tv_sec;*/ //mbelian
2327 }
2328 }
2329 else {
2330 DEBUG("Media is down\n");
2331 if (info->mediastate == 1) {
2332 info->mediastate = 0;
2333 if ( info->NetDevRegDone )
2334 {
2335 //netif_carrier_off(dev->net); mbelian
2336 //netif_stop_queue(dev->net);
2337 }
2338 info->ConTm = 0;
2339 }
2340 }
2341 }
2342 else {
2343 DEBUG("Media is down\n");
2344 if (info->mediastate == 1) {
2345 info->mediastate = 0;
2346 if ( info->NetDevRegDone)
2347 {
2348 //netif_carrier_off(dev->net); //mbelian
2349 //netif_stop_queue(dev->net);
2350 }
2351 info->ConTm = 0;
2352 }
2353 }
2354 break;
2355 }
2356 case DSP_INIT_MSG: {
2357 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_INIT_MSG");
2358
2359 pdspinitmsg = (PDSPINITMSG)&cmdbuffer[2];
2360 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
2361 DEBUG("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n", info->DspVer[0], info->DspVer[1], info->DspVer[2], info->DspVer[3]);
2362 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum, HWSERNUMSZ);
2363 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
2364 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
2365 DEBUG("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n", info->eui64[0],info->eui64[1], info->eui64[2], info->eui64[3], info->eui64[4], info->eui64[5],info->eui64[6], info->eui64[7]);
2366 dev->net->dev_addr[0] = info->eui64[0];
2367 dev->net->dev_addr[1] = info->eui64[1];
2368 dev->net->dev_addr[2] = info->eui64[2];
2369 dev->net->dev_addr[3] = info->eui64[5];
2370 dev->net->dev_addr[4] = info->eui64[6];
2371 dev->net->dev_addr[5] = info->eui64[7];
2372
2373 if (ntohs(pdspinitmsg->length) == (sizeof(DSPINITMSG) - 20) ) {
2374 memcpy(info->ProductMode, pdspinitmsg->ProductMode, MODESZ);
2375 memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
2376 memcpy(info->RfCalDate, pdspinitmsg->RfCalDate, CALDATESZ);
2377 DEBUG("RFCalVer = 0x%2x 0x%2x\n", info->RfCalVer[0], info->RfCalVer[1]);
2378 }
2379 break;
2380 }
2381 case DSP_PROVISION: {
2382 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_PROVISION\n");
2383
2384 // kick off dspprov routine to start provisioning
2385 // Send provisioning data to DSP
2386 if (list_empty(&info->prov_list) == 0)
2387 {
2388 info->fProvComplete = 0;
2389 status = ft1000_dsp_prov(dev);
2390 if (status != STATUS_SUCCESS)
2391 return status;
2392 }
2393 else {
2394 info->fProvComplete = 1;
2395 status = ft1000_write_register (dev, FT1000_DB_HB, FT1000_REG_DOORBELL);
2396 DEBUG("FT1000:drivermsg:No more DSP provisioning data in dsp image\n");
2397 }
2398 DEBUG("ft1000_proc_drvmsg:DSP PROVISION is done\n");
2399 break;
2400 }
2401 case DSP_STORE_INFO: {
2402 DEBUG("ft1000_proc_drvmsg:Command message type = DSP_STORE_INFO");
2403
2404 DEBUG("FT1000:drivermsg:Got DSP_STORE_INFO\n");
2405 tempword = ntohs(pdrvmsg->length);
2406 info->DSPInfoBlklen = tempword;
2407 if (tempword < (MAX_DSP_SESS_REC-4) ) {
2408 pmsg = (PUSHORT)&pdrvmsg->data[0];
2409 for (i=0; i<((tempword+1)/2); i++) {
2410 DEBUG("FT1000:drivermsg:dsp info data = 0x%x\n", *pmsg);
2411 info->DSPInfoBlk[i+10] = *pmsg++;
2412 }
2413 }
2414 else {
2415 info->DSPInfoBlklen = 0;
2416 }
2417 break;
2418 }
2419 case DSP_GET_INFO: {
2420 DEBUG("FT1000:drivermsg:Got DSP_GET_INFO\n");
2421 // copy dsp info block to dsp
2422 info->DrvMsgPend = 1;
2423 // allow any outstanding ioctl to finish
2424 mdelay(10);
2425 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2426 if (tempword & FT1000_DB_DPRAM_TX) {
2427 mdelay(10);
2428 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2429 if (tempword & FT1000_DB_DPRAM_TX) {
2430 mdelay(10);
2431 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2432 if (tempword & FT1000_DB_DPRAM_TX) {
2433 break;
2434 }
2435 }
2436 }
2437
2438 // Put message into Slow Queue
2439 // Form Pseudo header
2440 pmsg = (PUSHORT)info->DSPInfoBlk;
2441 *pmsg++ = 0;
2442 *pmsg++ = htons(info->DSPInfoBlklen+20+info->DSPInfoBlklen);
2443 ppseudo_hdr = (PPSEUDO_HDR)(PUSHORT)&info->DSPInfoBlk[2];
2444 ppseudo_hdr->length = htons(info->DSPInfoBlklen+4+info->DSPInfoBlklen);
2445 ppseudo_hdr->source = 0x10;
2446 ppseudo_hdr->destination = 0x20;
2447 ppseudo_hdr->portdest = 0;
2448 ppseudo_hdr->portsrc = 0;
2449 ppseudo_hdr->sh_str_id = 0;
2450 ppseudo_hdr->control = 0;
2451 ppseudo_hdr->rsvd1 = 0;
2452 ppseudo_hdr->rsvd2 = 0;
2453 ppseudo_hdr->qos_class = 0;
2454 // Insert slow queue sequence number
2455 ppseudo_hdr->seq_num = info->squeseqnum++;
2456 // Insert application id
2457 ppseudo_hdr->portsrc = 0;
2458 // Calculate new checksum
2459 ppseudo_hdr->checksum = *pmsg++;
2460 for (i=1; i<7; i++) {
2461 ppseudo_hdr->checksum ^= *pmsg++;
2462 }
2463 info->DSPInfoBlk[10] = 0x7200;
2464 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
2465 status = ft1000_write_dpram32 (dev, 0, (PUCHAR)&info->DSPInfoBlk[0], (unsigned short)(info->DSPInfoBlklen+22));
2466 status = ft1000_write_register (dev, FT1000_DB_DPRAM_TX, FT1000_REG_DOORBELL);
2467 info->DrvMsgPend = 0;
2468
2469 break;
2470 }
2471
2472 case GET_DRV_ERR_RPT_MSG: {
2473 DEBUG("FT1000:drivermsg:Got GET_DRV_ERR_RPT_MSG\n");
2474 // copy driver error message to dsp
2475 info->DrvMsgPend = 1;
2476 // allow any outstanding ioctl to finish
2477 mdelay(10);
2478 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2479 if (tempword & FT1000_DB_DPRAM_TX) {
2480 mdelay(10);
2481 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
2482 if (tempword & FT1000_DB_DPRAM_TX) {
2483 mdelay(10);
2484 }
2485 }
2486
2487 if ( (tempword & FT1000_DB_DPRAM_TX) == 0) {
2488 // Put message into Slow Queue
2489 // Form Pseudo header
2490 pmsg = (PUSHORT)&tempbuffer[0];
2491 ppseudo_hdr = (PPSEUDO_HDR)pmsg;
2492 ppseudo_hdr->length = htons(0x0012);
2493 ppseudo_hdr->source = 0x10;
2494 ppseudo_hdr->destination = 0x20;
2495 ppseudo_hdr->portdest = 0;
2496 ppseudo_hdr->portsrc = 0;
2497 ppseudo_hdr->sh_str_id = 0;
2498 ppseudo_hdr->control = 0;
2499 ppseudo_hdr->rsvd1 = 0;
2500 ppseudo_hdr->rsvd2 = 0;
2501 ppseudo_hdr->qos_class = 0;
2502 // Insert slow queue sequence number
2503 ppseudo_hdr->seq_num = info->squeseqnum++;
2504 // Insert application id
2505 ppseudo_hdr->portsrc = 0;
2506 // Calculate new checksum
2507 ppseudo_hdr->checksum = *pmsg++;
2508 for (i=1; i<7; i++) {
2509 ppseudo_hdr->checksum ^= *pmsg++;
2510 }
2511 pmsg = (PUSHORT)&tempbuffer[16];
2512 *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
2513 *pmsg++ = htons(0x000e);
2514 *pmsg++ = htons(info->DSP_TIME[0]);
2515 *pmsg++ = htons(info->DSP_TIME[1]);
2516 *pmsg++ = htons(info->DSP_TIME[2]);
2517 *pmsg++ = htons(info->DSP_TIME[3]);
2518 convert.byte[0] = info->DspVer[0];
2519 convert.byte[1] = info->DspVer[1];
2520 *pmsg++ = convert.wrd;
2521 convert.byte[0] = info->DspVer[2];
2522 convert.byte[1] = info->DspVer[3];
2523 *pmsg++ = convert.wrd;
2524 *pmsg++ = htons(info->DrvErrNum);
2525
2526 CardSendCommand (dev, (unsigned char*)&tempbuffer[0], (USHORT)(0x0012 + PSEUDOSZ));
2527 info->DrvErrNum = 0;
2528 }
2529 info->DrvMsgPend = 0;
2530
2531 break;
2532 }
2533
2534 default:
2535 break;
2536 }
2537
2538 }
2539
2540 DEBUG("return from ft1000_proc_drvmsg\n");
2541 return STATUS_SUCCESS;
2542 }
2543
2544
2545
2546 int ft1000_poll(void* dev_id) {
2547
2548 //FT1000_INFO *info = (PFT1000_INFO)((struct net_device *)dev_id)->priv;
2549 //struct ft1000_device *dev = (struct ft1000_device *)info->pFt1000Dev;
2550 struct ft1000_device *dev = (struct ft1000_device *)dev_id;
2551 FT1000_INFO *info = (FT1000_INFO *) netdev_priv (dev->net);
2552
2553 u16 tempword;
2554 u16 status;
2555 u16 size;
2556 int i;
2557 USHORT data;
2558 USHORT modulo;
2559 USHORT portid;
2560 u16 nxtph;
2561 PDPRAM_BLK pdpram_blk;
2562 PPSEUDO_HDR ppseudo_hdr;
2563 unsigned long flags;
2564
2565 //DEBUG("Enter ft1000_poll...\n");
2566 if (ft1000_chkcard(dev) == FALSE) {
2567 DEBUG("ft1000_poll::ft1000_chkcard: failed\n");
2568 return STATUS_FAILURE;
2569 }
2570
2571 status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
2572 // DEBUG("ft1000_poll: read FT1000_REG_DOORBELL message 0x%x\n", tempword);
2573
2574 //while ( (tempword) && (!status) ) {
2575 if ( !status )
2576 {
2577
2578 if (tempword & FT1000_DB_DPRAM_RX) {
2579 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX\n");
2580
2581 status = ft1000_read_dpram16(dev, 0x200, (PUCHAR)&data, 0);
2582 //DEBUG("ft1000_poll:FT1000_DB_DPRAM_RX:ft1000_read_dpram16:size = 0x%x\n", data);
2583 size = ntohs(data) + 16 + 2; //wai
2584 if (size % 4) {
2585 modulo = 4 - (size % 4);
2586 size = size + modulo;
2587 }
2588 status = ft1000_read_dpram16(dev, 0x201, (PUCHAR)&portid, 1);
2589 portid &= 0xff;
2590 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid 0x%x\n", portid);
2591
2592 if (size < MAX_CMD_SQSIZE) {
2593 switch (portid)
2594 {
2595 case DRIVERID:
2596 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
2597
2598 status = ft1000_proc_drvmsg (dev, size);
2599 if (status != STATUS_SUCCESS )
2600 return status;
2601 break;
2602 case DSPBCMSGID:
2603 // This is a dsp broadcast message
2604 // Check which application has registered for dsp broadcast messages
2605 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DSPBCMSGID\n");
2606
2607 for (i=0; i<MAX_NUM_APP; i++) {
2608 if ( (info->app_info[i].DspBCMsgFlag) && (info->app_info[i].fileobject) &&
2609 (info->app_info[i].NumOfMsg < MAX_MSG_LIMIT) )
2610 {
2611 //DEBUG("Dsp broadcast message detected for app id %d\n", i);
2612 nxtph = FT1000_DPRAM_RX_BASE + 2;
2613 pdpram_blk = ft1000_get_buffer (&freercvpool);
2614 if (pdpram_blk != NULL) {
2615 if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
2616 ppseudo_hdr = (PPSEUDO_HDR)pdpram_blk->pbuffer;
2617 // Put message into the appropriate application block
2618 info->app_info[i].nRxMsg++;
2619 spin_lock_irqsave(&free_buff_lock, flags);
2620 list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
2621 info->app_info[i].NumOfMsg++;
2622 spin_unlock_irqrestore(&free_buff_lock, flags);
2623 wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
2624 }
2625 else {
2626 info->app_info[i].nRxMsgMiss++;
2627 // Put memory back to free pool
2628 ft1000_free_buffer(pdpram_blk, &freercvpool);
2629 DEBUG("pdpram_blk::ft1000_get_buffer NULL\n");
2630 }
2631 }
2632 else {
2633 DEBUG("Out of memory in free receive command pool\n");
2634 info->app_info[i].nRxMsgMiss++;
2635 }//endof if (pdpram_blk != NULL)
2636 }//endof if
2637 //else
2638 // DEBUG("app_info mismatch\n");
2639 }// endof for
2640 break;
2641 default:
2642 pdpram_blk = ft1000_get_buffer (&freercvpool);
2643 //DEBUG("Memory allocated = 0x%8x\n", (u32)pdpram_blk);
2644 if (pdpram_blk != NULL) {
2645 if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
2646 ppseudo_hdr = (PPSEUDO_HDR)pdpram_blk->pbuffer;
2647 // Search for correct application block
2648 for (i=0; i<MAX_NUM_APP; i++) {
2649 if (info->app_info[i].app_id == ppseudo_hdr->portdest) {
2650 break;
2651 }
2652 }
2653
2654 if (i==(MAX_NUM_APP-1)) { // aelias [+] reason: was out of array boundary
2655 info->app_info[i].nRxMsgMiss++;
2656 DEBUG("FT1000:ft1000_parse_dpram_msg: No application matching id = %d\n", ppseudo_hdr->portdest);
2657 // Put memory back to free pool
2658 ft1000_free_buffer(pdpram_blk, &freercvpool);
2659 }
2660 else {
2661 if (info->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
2662 // Put memory back to free pool
2663 ft1000_free_buffer(pdpram_blk, &freercvpool);
2664 }
2665 else {
2666 info->app_info[i].nRxMsg++;
2667 // Put message into the appropriate application block
2668 //pxu spin_lock_irqsave(&free_buff_lock, flags);
2669 list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
2670 info->app_info[i].NumOfMsg++;
2671 //pxu spin_unlock_irqrestore(&free_buff_lock, flags);
2672 //pxu wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
2673 }
2674 }
2675 }
2676 else {
2677 // Put memory back to free pool
2678 ft1000_free_buffer(pdpram_blk, &freercvpool);
2679 }
2680 }
2681 else {
2682 DEBUG("Out of memory in free receive command pool\n");
2683 }
2684 break;
2685 } //end of switch
2686 } //endof if (size < MAX_CMD_SQSIZE)
2687 else {
2688 DEBUG("FT1000:dpc:Invalid total length for SlowQ = %d\n", size);
2689 }
2690 status = ft1000_write_register (dev, FT1000_DB_DPRAM_RX, FT1000_REG_DOORBELL);
2691 }
2692 else if (tempword & FT1000_DSP_ASIC_RESET) {
2693 //DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DSP_ASIC_RESET\n");
2694
2695 // Let's reset the ASIC from the Host side as well
2696 status = ft1000_write_register (dev, ASIC_RESET_BIT, FT1000_REG_RESET);
2697 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
2698 i = 0;
2699 while (tempword & ASIC_RESET_BIT) {
2700 status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
2701 msleep(10);
2702 i++;
2703 if (i==100)
2704 break;
2705 }
2706 if (i==100) {
2707 DEBUG("Unable to reset ASIC\n");
2708 return STATUS_SUCCESS;
2709 }
2710 msleep(10);
2711 // Program WMARK register
2712 status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2713 // clear ASIC reset doorbell
2714 status = ft1000_write_register (dev, FT1000_DSP_ASIC_RESET, FT1000_REG_DOORBELL);
2715 msleep(10);
2716 }
2717 else if (tempword & FT1000_ASIC_RESET_REQ) {
2718 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
2719
2720 // clear ASIC reset request from DSP
2721 status = ft1000_write_register (dev, FT1000_ASIC_RESET_REQ, FT1000_REG_DOORBELL);
2722 status = ft1000_write_register (dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
2723 // copy dsp session record from Adapter block
2724 status = ft1000_write_dpram32 (dev, 0, (PUCHAR)&info->DSPSess.Rec[0], 1024);
2725 // Program WMARK register
2726 status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
2727 // ring doorbell to tell DSP that ASIC is out of reset
2728 status = ft1000_write_register (dev, FT1000_ASIC_RESET_DSP, FT1000_REG_DOORBELL);
2729 }
2730 else if (tempword & FT1000_DB_COND_RESET) {
2731 DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
2732 //By Jim
2733 // Reset ASIC and DSP
2734 //MAG
2735 if (info->fAppMsgPend == 0) {
2736 // Reset ASIC and DSP
2737
2738 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (PUCHAR)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
2739 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (PUCHAR)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
2740 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (PUCHAR)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
2741 status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (PUCHAR)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
2742 info->CardReady = 0;
2743 info->DrvErrNum = DSP_CONDRESET_INFO;
2744 DEBUG("ft1000_hw:DSP conditional reset requested\n");
2745 info->ft1000_reset(dev->net);
2746 }
2747 else {
2748 info->fProvComplete = 0;
2749 info->fCondResetPend = 1;
2750 }
2751
2752 ft1000_write_register(dev, FT1000_DB_COND_RESET, FT1000_REG_DOORBELL);
2753 }
2754
2755 }//endof if ( !status )
2756
2757 //DEBUG("return from ft1000_poll.\n");
2758 return STATUS_SUCCESS;
2759
2760 }
2761
2762 /*end of Jim*/
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree