Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ft1000_hw.c
Go to the documentation of this file.
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 #include <linux/init.h>
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/netdevice.h>
13 #include <linux/etherdevice.h>
14 #include <linux/usb.h>
15 #include "ft1000_usb.h"
16 #include <linux/types.h>
17 
18 #define HARLEY_READ_REGISTER 0x0
19 #define HARLEY_WRITE_REGISTER 0x01
20 #define HARLEY_READ_DPRAM_32 0x02
21 #define HARLEY_READ_DPRAM_LOW 0x03
22 #define HARLEY_READ_DPRAM_HIGH 0x04
23 #define HARLEY_WRITE_DPRAM_32 0x05
24 #define HARLEY_WRITE_DPRAM_LOW 0x06
25 #define HARLEY_WRITE_DPRAM_HIGH 0x07
26 
27 #define HARLEY_READ_OPERATION 0xc1
28 #define HARLEY_WRITE_OPERATION 0x41
29 
30 //#define JDEBUG
31 
32 static int ft1000_reset(struct net_device *ft1000dev);
33 static int ft1000_submit_rx_urb(struct ft1000_info *info);
34 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev);
35 static int ft1000_open (struct net_device *dev);
36 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev);
37 static int ft1000_chkcard (struct ft1000_device *dev);
38 
39 static u8 tempbuffer[1600];
40 
41 #define MAX_RCV_LOOP 100
42 
43 //---------------------------------------------------------------------------
44 // Function: ft1000_control
45 //
46 // Parameters: ft1000_device - device structure
47 // pipe - usb control message pipe
48 // request - control request
49 // requesttype - control message request type
50 // value - value to be written or 0
51 // index - register index
52 // data - data buffer to hold the read/write values
53 // size - data size
54 // timeout - control message time out value
55 //
56 // Returns: STATUS_SUCCESS - success
57 // STATUS_FAILURE - failure
58 //
59 // Description: This function sends a control message via USB interface synchronously
60 //
61 // Notes:
62 //
63 //---------------------------------------------------------------------------
64 static int ft1000_control(struct ft1000_device *ft1000dev, unsigned int pipe,
65  u8 request, u8 requesttype, u16 value, u16 index,
66  void *data, u16 size, int timeout)
67 {
68  u16 ret;
69 
70  if ((ft1000dev == NULL) || (ft1000dev->dev == NULL)) {
71  DEBUG("ft1000dev or ft1000dev->dev == NULL, failure\n");
72  return -ENODEV;
73  }
74 
75  ret = usb_control_msg(ft1000dev->dev, pipe, request, requesttype,
76  value, index, data, size, timeout);
77 
78  if (ret > 0)
79  ret = 0;
80 
81  return ret;
82 }
83 
84 //---------------------------------------------------------------------------
85 // Function: ft1000_read_register
86 //
87 // Parameters: ft1000_device - device structure
88 // Data - data buffer to hold the value read
89 // nRegIndex - register index
90 //
91 // Returns: STATUS_SUCCESS - success
92 // STATUS_FAILURE - failure
93 //
94 // Description: This function returns the value in a register
95 //
96 // Notes:
97 //
98 //---------------------------------------------------------------------------
99 
100 int ft1000_read_register(struct ft1000_device *ft1000dev, u16* Data,
101  u16 nRegIndx)
102 {
103  int ret = STATUS_SUCCESS;
104 
105  ret = ft1000_control(ft1000dev,
106  usb_rcvctrlpipe(ft1000dev->dev, 0),
107  HARLEY_READ_REGISTER,
108  HARLEY_READ_OPERATION,
109  0,
110  nRegIndx,
111  Data,
112  2,
113  USB_CTRL_GET_TIMEOUT);
114 
115  return ret;
116 }
117 
118 //---------------------------------------------------------------------------
119 // Function: ft1000_write_register
120 //
121 // Parameters: ft1000_device - device structure
122 // value - value to write into a register
123 // nRegIndex - register index
124 //
125 // Returns: STATUS_SUCCESS - success
126 // STATUS_FAILURE - failure
127 //
128 // Description: This function writes the value in a register
129 //
130 // Notes:
131 //
132 //---------------------------------------------------------------------------
133 int ft1000_write_register(struct ft1000_device *ft1000dev, u16 value,
134  u16 nRegIndx)
135 {
136  int ret = STATUS_SUCCESS;
137 
138  ret = ft1000_control(ft1000dev,
139  usb_sndctrlpipe(ft1000dev->dev, 0),
140  HARLEY_WRITE_REGISTER,
141  HARLEY_WRITE_OPERATION,
142  value,
143  nRegIndx,
144  NULL,
145  0,
146  USB_CTRL_SET_TIMEOUT);
147 
148  return ret;
149 }
150 
151 //---------------------------------------------------------------------------
152 // Function: ft1000_read_dpram32
153 //
154 // Parameters: ft1000_device - device structure
155 // indx - starting address to read
156 // buffer - data buffer to hold the data read
157 // cnt - number of byte read from DPRAM
158 //
159 // Returns: STATUS_SUCCESS - success
160 // STATUS_FAILURE - failure
161 //
162 // Description: This function read a number of bytes from DPRAM
163 //
164 // Notes:
165 //
166 //---------------------------------------------------------------------------
167 
168 int ft1000_read_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer,
169  u16 cnt)
170 {
171  int ret = STATUS_SUCCESS;
172 
173  ret = ft1000_control(ft1000dev,
174  usb_rcvctrlpipe(ft1000dev->dev, 0),
175  HARLEY_READ_DPRAM_32,
176  HARLEY_READ_OPERATION,
177  0,
178  indx,
179  buffer,
180  cnt,
181  USB_CTRL_GET_TIMEOUT);
182 
183  return ret;
184 }
185 
186 //---------------------------------------------------------------------------
187 // Function: ft1000_write_dpram32
188 //
189 // Parameters: ft1000_device - device structure
190 // indx - starting address to write the data
191 // buffer - data buffer to write into DPRAM
192 // cnt - number of bytes to write
193 //
194 // Returns: STATUS_SUCCESS - success
195 // STATUS_FAILURE - failure
196 //
197 // Description: This function writes into DPRAM a number of bytes
198 //
199 // Notes:
200 //
201 //---------------------------------------------------------------------------
202 int ft1000_write_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer,
203  u16 cnt)
204 {
205  int ret = STATUS_SUCCESS;
206 
207  if (cnt % 4)
208  cnt += cnt - (cnt % 4);
209 
210  ret = ft1000_control(ft1000dev,
211  usb_sndctrlpipe(ft1000dev->dev, 0),
212  HARLEY_WRITE_DPRAM_32,
213  HARLEY_WRITE_OPERATION,
214  0,
215  indx,
216  buffer,
217  cnt,
218  USB_CTRL_SET_TIMEOUT);
219 
220  return ret;
221 }
222 
223 //---------------------------------------------------------------------------
224 // Function: ft1000_read_dpram16
225 //
226 // Parameters: ft1000_device - device structure
227 // indx - starting address to read
228 // buffer - data buffer to hold the data read
229 // hightlow - high or low 16 bit word
230 //
231 // Returns: STATUS_SUCCESS - success
232 // STATUS_FAILURE - failure
233 //
234 // Description: This function read 16 bits from DPRAM
235 //
236 // Notes:
237 //
238 //---------------------------------------------------------------------------
239 int ft1000_read_dpram16(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer,
240  u8 highlow)
241 {
242  int ret = STATUS_SUCCESS;
243  u8 request;
244 
245  if (highlow == 0)
246  request = HARLEY_READ_DPRAM_LOW;
247  else
248  request = HARLEY_READ_DPRAM_HIGH;
249 
250  ret = ft1000_control(ft1000dev,
251  usb_rcvctrlpipe(ft1000dev->dev, 0),
252  request,
253  HARLEY_READ_OPERATION,
254  0,
255  indx,
256  buffer,
257  2,
258  USB_CTRL_GET_TIMEOUT);
259 
260  return ret;
261 }
262 
263 //---------------------------------------------------------------------------
264 // Function: ft1000_write_dpram16
265 //
266 // Parameters: ft1000_device - device structure
267 // indx - starting address to write the data
268 // value - 16bits value to write
269 // hightlow - high or low 16 bit word
270 //
271 // Returns: STATUS_SUCCESS - success
272 // STATUS_FAILURE - failure
273 //
274 // Description: This function writes into DPRAM a number of bytes
275 //
276 // Notes:
277 //
278 //---------------------------------------------------------------------------
279 int ft1000_write_dpram16(struct ft1000_device *ft1000dev, u16 indx, u16 value, u8 highlow)
280 {
281  int ret = STATUS_SUCCESS;
282  u8 request;
283 
284  if (highlow == 0)
285  request = HARLEY_WRITE_DPRAM_LOW;
286  else
287  request = HARLEY_WRITE_DPRAM_HIGH;
288 
289  ret = ft1000_control(ft1000dev,
290  usb_sndctrlpipe(ft1000dev->dev, 0),
291  request,
292  HARLEY_WRITE_OPERATION,
293  value,
294  indx,
295  NULL,
296  0,
297  USB_CTRL_SET_TIMEOUT);
298 
299  return ret;
300 }
301 
302 //---------------------------------------------------------------------------
303 // Function: fix_ft1000_read_dpram32
304 //
305 // Parameters: ft1000_device - device structure
306 // indx - starting address to read
307 // buffer - data buffer to hold the data read
308 //
309 //
310 // Returns: STATUS_SUCCESS - success
311 // STATUS_FAILURE - failure
312 //
313 // Description: This function read DPRAM 4 words at a time
314 //
315 // Notes:
316 //
317 //---------------------------------------------------------------------------
318 int fix_ft1000_read_dpram32(struct ft1000_device *ft1000dev, u16 indx,
319  u8 *buffer)
320 {
321  u8 buf[16];
322  u16 pos;
323  int ret = STATUS_SUCCESS;
324 
325  pos = (indx / 4) * 4;
326  ret = ft1000_read_dpram32(ft1000dev, pos, buf, 16);
327 
328  if (ret == STATUS_SUCCESS) {
329  pos = (indx % 4) * 4;
330  *buffer++ = buf[pos++];
331  *buffer++ = buf[pos++];
332  *buffer++ = buf[pos++];
333  *buffer++ = buf[pos++];
334  } else {
335  DEBUG("fix_ft1000_read_dpram32: DPRAM32 Read failed\n");
336  *buffer++ = 0;
337  *buffer++ = 0;
338  *buffer++ = 0;
339  *buffer++ = 0;
340  }
341 
342  return ret;
343 }
344 
345 
346 //---------------------------------------------------------------------------
347 // Function: fix_ft1000_write_dpram32
348 //
349 // Parameters: ft1000_device - device structure
350 // indx - starting address to write
351 // buffer - data buffer to write
352 //
353 //
354 // Returns: STATUS_SUCCESS - success
355 // STATUS_FAILURE - failure
356 //
357 // Description: This function write to DPRAM 4 words at a time
358 //
359 // Notes:
360 //
361 //---------------------------------------------------------------------------
362 int fix_ft1000_write_dpram32(struct ft1000_device *ft1000dev, u16 indx, u8 *buffer)
363 {
364  u16 pos1;
365  u16 pos2;
366  u16 i;
367  u8 buf[32];
368  u8 resultbuffer[32];
369  u8 *pdata;
370  int ret = STATUS_SUCCESS;
371 
372  pos1 = (indx / 4) * 4;
373  pdata = buffer;
374  ret = ft1000_read_dpram32(ft1000dev, pos1, buf, 16);
375 
376  if (ret == STATUS_SUCCESS) {
377  pos2 = (indx % 4)*4;
378  buf[pos2++] = *buffer++;
379  buf[pos2++] = *buffer++;
380  buf[pos2++] = *buffer++;
381  buf[pos2++] = *buffer++;
382  ret = ft1000_write_dpram32(ft1000dev, pos1, buf, 16);
383  } else {
384  DEBUG("fix_ft1000_write_dpram32: DPRAM32 Read failed\n");
385  return ret;
386  }
387 
388  ret = ft1000_read_dpram32(ft1000dev, pos1, (u8 *)&resultbuffer[0], 16);
389 
390  if (ret == STATUS_SUCCESS) {
391  buffer = pdata;
392  for (i = 0; i < 16; i++) {
393  if (buf[i] != resultbuffer[i])
394  ret = STATUS_FAILURE;
395  }
396  }
397 
398  if (ret == STATUS_FAILURE) {
399  ret = ft1000_write_dpram32(ft1000dev, pos1,
400  (u8 *)&tempbuffer[0], 16);
401  ret = ft1000_read_dpram32(ft1000dev, pos1,
402  (u8 *)&resultbuffer[0], 16);
403  if (ret == STATUS_SUCCESS) {
404  buffer = pdata;
405  for (i = 0; i < 16; i++) {
406  if (tempbuffer[i] != resultbuffer[i]) {
407  ret = STATUS_FAILURE;
408  DEBUG("%s Failed to write\n",
409  __func__);
410  }
411  }
412  }
413  }
414 
415  return ret;
416 }
417 
418 
419 //------------------------------------------------------------------------
420 //
421 // Function: card_reset_dsp
422 //
423 // Synopsis: This function is called to reset or activate the DSP
424 //
425 // Arguments: value - reset or activate
426 //
427 // Returns: None
428 //-----------------------------------------------------------------------
429 static void card_reset_dsp(struct ft1000_device *ft1000dev, bool value)
430 {
431  u16 status = STATUS_SUCCESS;
432  u16 tempword;
433 
434  status = ft1000_write_register(ft1000dev, HOST_INTF_BE,
435  FT1000_REG_SUP_CTRL);
436  status = ft1000_read_register(ft1000dev, &tempword,
437  FT1000_REG_SUP_CTRL);
438 
439  if (value) {
440  DEBUG("Reset DSP\n");
441  status = ft1000_read_register(ft1000dev, &tempword,
442  FT1000_REG_RESET);
443  tempword |= DSP_RESET_BIT;
444  status = ft1000_write_register(ft1000dev, tempword,
445  FT1000_REG_RESET);
446  } else {
447  DEBUG("Activate DSP\n");
448  status = ft1000_read_register(ft1000dev, &tempword,
449  FT1000_REG_RESET);
450  tempword |= DSP_ENCRYPTED;
451  tempword &= ~DSP_UNENCRYPTED;
452  status = ft1000_write_register(ft1000dev, tempword,
453  FT1000_REG_RESET);
454  status = ft1000_read_register(ft1000dev, &tempword,
455  FT1000_REG_RESET);
456  tempword &= ~EFUSE_MEM_DISABLE;
457  tempword &= ~DSP_RESET_BIT;
458  status = ft1000_write_register(ft1000dev, tempword,
459  FT1000_REG_RESET);
460  status = ft1000_read_register(ft1000dev, &tempword,
461  FT1000_REG_RESET);
462  }
463 }
464 
465 //---------------------------------------------------------------------------
466 // Function: card_send_command
467 //
468 // Parameters: ft1000_device - device structure
469 // ptempbuffer - command buffer
470 // size - command buffer size
471 //
472 // Returns: STATUS_SUCCESS - success
473 // STATUS_FAILURE - failure
474 //
475 // Description: This function sends a command to ASIC
476 //
477 // Notes:
478 //
479 //---------------------------------------------------------------------------
480 void card_send_command(struct ft1000_device *ft1000dev, void *ptempbuffer,
481  int size)
482 {
483  unsigned short temp;
484  unsigned char *commandbuf;
485 
486  DEBUG("card_send_command: enter card_send_command... size=%d\n", size);
487 
488  commandbuf = kmalloc(size + 2, GFP_KERNEL);
489  memcpy((void *)commandbuf + 2, (void *)ptempbuffer, size);
490 
491  ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
492 
493  if (temp & 0x0100)
494  msleep(10);
495 
496  /* check for odd word */
497  size = size + 2;
498 
499  /* Must force to be 32 bit aligned */
500  if (size % 4)
501  size += 4 - (size % 4);
502 
503  ft1000_write_dpram32(ft1000dev, 0, commandbuf, size);
504  msleep(1);
505  ft1000_write_register(ft1000dev, FT1000_DB_DPRAM_TX,
506  FT1000_REG_DOORBELL);
507  msleep(1);
508 
509  ft1000_read_register(ft1000dev, &temp, FT1000_REG_DOORBELL);
510 
511  if ((temp & 0x0100) == 0) {
512  //DEBUG("card_send_command: Message sent\n");
513  }
514 
515 }
516 
517 //--------------------------------------------------------------------------
518 //
519 // Function: dsp_reload
520 //
521 // Synopsis: This function is called to load or reload the DSP
522 //
523 // Arguments: ft1000dev - device structure
524 //
525 // Returns: None
526 //-----------------------------------------------------------------------
527 int dsp_reload(struct ft1000_device *ft1000dev)
528 {
529  u16 status;
530  u16 tempword;
531  u32 templong;
532 
533  struct ft1000_info *pft1000info;
534 
535  pft1000info = netdev_priv(ft1000dev->net);
536 
537  pft1000info->CardReady = 0;
538 
539  /* Program Interrupt Mask register */
540  status = ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_SUP_IMASK);
541 
542  status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
543  tempword |= ASIC_RESET_BIT;
544  status = ft1000_write_register(ft1000dev, tempword, FT1000_REG_RESET);
545  msleep(1000);
546  status = ft1000_read_register(ft1000dev, &tempword, FT1000_REG_RESET);
547  DEBUG("Reset Register = 0x%x\n", tempword);
548 
549  /* Toggle DSP reset */
550  card_reset_dsp(ft1000dev, 1);
551  msleep(1000);
552  card_reset_dsp(ft1000dev, 0);
553  msleep(1000);
554 
555  status =
556  ft1000_write_register(ft1000dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
557 
558  /* Let's check for FEFE */
559  status =
560  ft1000_read_dpram32(ft1000dev, FT1000_MAG_DPRAM_FEFE_INDX,
561  (u8 *) &templong, 4);
562  DEBUG("templong (fefe) = 0x%8x\n", templong);
563 
564  /* call codeloader */
565  status = scram_dnldr(ft1000dev, pFileStart, FileLength);
566 
567  if (status != STATUS_SUCCESS)
568  return -EIO;
569 
570  msleep(1000);
571 
572  DEBUG("dsp_reload returned\n");
573 
574  return 0;
575 }
576 
577 //---------------------------------------------------------------------------
578 //
579 // Function: ft1000_reset_asic
580 // Description: This function will call the Card Service function to reset the
581 // ASIC.
582 // Input:
583 // dev - device structure
584 // Output:
585 // none
586 //
587 //---------------------------------------------------------------------------
588 static void ft1000_reset_asic(struct net_device *dev)
589 {
590  struct ft1000_info *info = netdev_priv(dev);
591  struct ft1000_device *ft1000dev = info->pFt1000Dev;
592  u16 tempword;
593 
594  DEBUG("ft1000_hw:ft1000_reset_asic called\n");
595 
596  /* Let's use the register provided by the Magnemite ASIC to reset the
597  * ASIC and DSP.
598  */
599  ft1000_write_register(ft1000dev, (DSP_RESET_BIT | ASIC_RESET_BIT),
600  FT1000_REG_RESET);
601 
602  mdelay(1);
603 
604  /* set watermark to -1 in order to not generate an interrupt */
605  ft1000_write_register(ft1000dev, 0xffff, FT1000_REG_MAG_WATERMARK);
606 
607  /* clear interrupts */
608  ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
609  DEBUG("ft1000_hw: interrupt status register = 0x%x\n", tempword);
610  ft1000_write_register(ft1000dev, tempword, FT1000_REG_SUP_ISR);
611  ft1000_read_register(ft1000dev, &tempword, FT1000_REG_SUP_ISR);
612  DEBUG("ft1000_hw: interrupt status register = 0x%x\n", tempword);
613 }
614 
615 
616 //---------------------------------------------------------------------------
617 //
618 // Function: ft1000_reset_card
619 // Description: This function will reset the card
620 // Input:
621 // dev - device structure
622 // Output:
623 // status - FALSE (card reset fail)
624 // TRUE (card reset successful)
625 //
626 //---------------------------------------------------------------------------
627 static int ft1000_reset_card(struct net_device *dev)
628 {
629  struct ft1000_info *info = netdev_priv(dev);
630  struct ft1000_device *ft1000dev = info->pFt1000Dev;
631  u16 tempword;
632  struct prov_record *ptr;
633 
634  DEBUG("ft1000_hw:ft1000_reset_card called.....\n");
635 
636  info->fCondResetPend = 1;
637  info->CardReady = 0;
638  info->fProvComplete = 0;
639 
640  /* Make sure we free any memory reserve for provisioning */
641  while (list_empty(&info->prov_list) == 0) {
642  DEBUG("ft1000_reset_card:deleting provisioning record\n");
643  ptr =
644  list_entry(info->prov_list.next, struct prov_record, list);
645  list_del(&ptr->list);
646  kfree(ptr->pprov_data);
647  kfree(ptr);
648  }
649 
650  DEBUG("ft1000_hw:ft1000_reset_card: reset asic\n");
651  ft1000_reset_asic(dev);
652 
653  DEBUG("ft1000_hw:ft1000_reset_card: call dsp_reload\n");
654  dsp_reload(ft1000dev);
655 
656  DEBUG("dsp reload successful\n");
657 
658  mdelay(10);
659 
660  /* Initialize DSP heartbeat area */
661  ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag,
662  FT1000_MAG_HI_HO_INDX);
663  ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (u8 *) &tempword,
664  FT1000_MAG_HI_HO_INDX);
665  DEBUG("ft1000_hw:ft1000_reset_card:hi_ho value = 0x%x\n", tempword);
666 
667  info->CardReady = 1;
668 
669  info->fCondResetPend = 0;
670 
671  return TRUE;
672 }
673 
674 static const struct net_device_ops ftnet_ops =
675 {
676  .ndo_open = &ft1000_open,
677  .ndo_stop = &ft1000_close,
678  .ndo_start_xmit = &ft1000_start_xmit,
679  .ndo_get_stats = &ft1000_netdev_stats,
680 };
681 
682 
683 //---------------------------------------------------------------------------
684 // Function: init_ft1000_netdev
685 //
686 // Parameters: ft1000dev - device structure
687 //
688 //
689 // Returns: STATUS_SUCCESS - success
690 // STATUS_FAILURE - failure
691 //
692 // Description: This function initialize the network device
693 //
694 // Notes:
695 //
696 //---------------------------------------------------------------------------
697 int init_ft1000_netdev(struct ft1000_device *ft1000dev)
698 {
699  struct net_device *netdev;
700  struct ft1000_info *pInfo = NULL;
701  struct dpram_blk *pdpram_blk;
702  int i, ret_val;
703  struct list_head *cur, *tmp;
704  char card_nr[2];
705  unsigned long gCardIndex = 0;
706 
707  DEBUG("Enter init_ft1000_netdev...\n");
708 
709  netdev = alloc_etherdev(sizeof(struct ft1000_info));
710  if (!netdev) {
711  DEBUG("init_ft1000_netdev: can not allocate network device\n");
712  return -ENOMEM;
713  }
714 
715  pInfo = netdev_priv(netdev);
716 
717  memset(pInfo, 0, sizeof(struct ft1000_info));
718 
719  dev_alloc_name(netdev, netdev->name);
720 
721  DEBUG("init_ft1000_netdev: network device name is %s\n", netdev->name);
722 
723  if (strncmp(netdev->name, "eth", 3) == 0) {
724  card_nr[0] = netdev->name[3];
725  card_nr[1] = '\0';
726  ret_val = strict_strtoul(card_nr, 10, &gCardIndex);
727  if (ret_val) {
728  printk(KERN_ERR "Can't parse netdev\n");
729  goto err_net;
730  }
731 
732  pInfo->CardNumber = gCardIndex;
733  DEBUG("card number = %d\n", pInfo->CardNumber);
734  } else {
735  printk(KERN_ERR "ft1000: Invalid device name\n");
736  ret_val = -ENXIO;
737  goto err_net;
738  }
739 
740  memset(&pInfo->stats, 0, sizeof(struct net_device_stats));
741 
742  spin_lock_init(&pInfo->dpram_lock);
743  pInfo->pFt1000Dev = ft1000dev;
744  pInfo->DrvErrNum = 0;
745  pInfo->registered = 1;
746  pInfo->ft1000_reset = ft1000_reset;
747  pInfo->mediastate = 0;
748  pInfo->fifo_cnt = 0;
749  pInfo->DeviceCreated = FALSE;
750  pInfo->CardReady = 0;
751  pInfo->DSP_TIME[0] = 0;
752  pInfo->DSP_TIME[1] = 0;
753  pInfo->DSP_TIME[2] = 0;
754  pInfo->DSP_TIME[3] = 0;
755  pInfo->fAppMsgPend = 0;
756  pInfo->fCondResetPend = 0;
757  pInfo->usbboot = 0;
758  pInfo->dspalive = 0;
759  memset(&pInfo->tempbuf[0], 0, sizeof(pInfo->tempbuf));
760 
761  INIT_LIST_HEAD(&pInfo->prov_list);
762 
763  INIT_LIST_HEAD(&pInfo->nodes.list);
764 
765  netdev->netdev_ops = &ftnet_ops;
766 
767  ft1000dev->net = netdev;
768 
769  DEBUG("Initialize free_buff_lock and freercvpool\n");
770  spin_lock_init(&free_buff_lock);
771 
772  /* initialize a list of buffers to be use for queuing
773  * up receive command data
774  */
775  INIT_LIST_HEAD(&freercvpool);
776 
777  /* create list of free buffers */
778  for (i = 0; i < NUM_OF_FREE_BUFFERS; i++) {
779  /* Get memory for DPRAM_DATA link list */
780  pdpram_blk = kmalloc(sizeof(struct dpram_blk), GFP_KERNEL);
781  if (pdpram_blk == NULL) {
782  ret_val = -ENOMEM;
783  goto err_free;
784  }
785  /* Get a block of memory to store command data */
786  pdpram_blk->pbuffer = kmalloc(MAX_CMD_SQSIZE, GFP_KERNEL);
787  if (pdpram_blk->pbuffer == NULL) {
788  ret_val = -ENOMEM;
789  kfree(pdpram_blk);
790  goto err_free;
791  }
792  /* link provisioning data */
793  list_add_tail(&pdpram_blk->list, &freercvpool);
794  }
795  numofmsgbuf = NUM_OF_FREE_BUFFERS;
796 
797  return 0;
798 
799 err_free:
800  list_for_each_safe(cur, tmp, &freercvpool) {
801  pdpram_blk = list_entry(cur, struct dpram_blk, list);
802  list_del(&pdpram_blk->list);
803  kfree(pdpram_blk->pbuffer);
804  kfree(pdpram_blk);
805  }
806 err_net:
807  free_netdev(netdev);
808  return ret_val;
809 }
810 
811 //---------------------------------------------------------------------------
812 // Function: reg_ft1000_netdev
813 //
814 // Parameters: ft1000dev - device structure
815 //
816 //
817 // Returns: STATUS_SUCCESS - success
818 // STATUS_FAILURE - failure
819 //
820 // Description: This function register the network driver
821 //
822 // Notes:
823 //
824 //---------------------------------------------------------------------------
825 int reg_ft1000_netdev(struct ft1000_device *ft1000dev,
826  struct usb_interface *intf)
827 {
828  struct net_device *netdev;
829  struct ft1000_info *pInfo;
830  int rc;
831 
832  netdev = ft1000dev->net;
833  pInfo = netdev_priv(ft1000dev->net);
834  DEBUG("Enter reg_ft1000_netdev...\n");
835 
836  ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
837 
838  usb_set_intfdata(intf, pInfo);
839  SET_NETDEV_DEV(netdev, &intf->dev);
840 
841  rc = register_netdev(netdev);
842  if (rc) {
843  DEBUG("reg_ft1000_netdev: could not register network device\n");
844  free_netdev(netdev);
845  return rc;
846  }
847 
848  ft1000_create_dev(ft1000dev);
849 
850  DEBUG("reg_ft1000_netdev returned\n");
851 
852  pInfo->CardReady = 1;
853 
854  return 0;
855 }
856 
857 static int ft1000_reset(struct net_device *dev)
858 {
859  ft1000_reset_card(dev);
860  return 0;
861 }
862 
863 //---------------------------------------------------------------------------
864 // Function: ft1000_usb_transmit_complete
865 //
866 // Parameters: urb - transmitted usb urb
867 //
868 //
869 // Returns: none
870 //
871 // Description: This is the callback function when a urb is transmitted
872 //
873 // Notes:
874 //
875 //---------------------------------------------------------------------------
876 static void ft1000_usb_transmit_complete(struct urb *urb)
877 {
878 
879  struct ft1000_device *ft1000dev = urb->context;
880 
881  if (urb->status)
882  pr_err("%s: TX status %d\n", ft1000dev->net->name, urb->status);
883 
884  netif_wake_queue(ft1000dev->net);
885 }
886 
887 //---------------------------------------------------------------------------
888 //
889 // Function: ft1000_copy_down_pkt
890 // Description: This function will take an ethernet packet and convert it to
891 // a Flarion packet prior to sending it to the ASIC Downlink
892 // FIFO.
893 // Input:
894 // dev - device structure
895 // packet - address of ethernet packet
896 // len - length of IP packet
897 // Output:
898 // status - FAILURE
899 // SUCCESS
900 //
901 //---------------------------------------------------------------------------
902 static int ft1000_copy_down_pkt(struct net_device *netdev, u8 * packet, u16 len)
903 {
904  struct ft1000_info *pInfo = netdev_priv(netdev);
905  struct ft1000_device *pFt1000Dev = pInfo->pFt1000Dev;
906 
907  int count, ret;
908  u8 *t;
909  struct pseudo_hdr hdr;
910 
911  if (!pInfo->CardReady) {
912  DEBUG("ft1000_copy_down_pkt::Card Not Ready\n");
913  return -ENODEV;
914  }
915 
916  count = sizeof(struct pseudo_hdr) + len;
917  if (count > MAX_BUF_SIZE) {
918  DEBUG("Error:ft1000_copy_down_pkt:Message Size Overflow!\n");
919  DEBUG("size = %d\n", count);
920  return -EINVAL;
921  }
922 
923  if (count % 4)
924  count = count + (4 - (count % 4));
925 
926  memset(&hdr, 0, sizeof(struct pseudo_hdr));
927 
928  hdr.length = ntohs(count);
929  hdr.source = 0x10;
930  hdr.destination = 0x20;
931  hdr.portdest = 0x20;
932  hdr.portsrc = 0x10;
933  hdr.sh_str_id = 0x91;
934  hdr.control = 0x00;
935 
936  hdr.checksum = hdr.length ^ hdr.source ^ hdr.destination ^
937  hdr.portdest ^ hdr.portsrc ^ hdr.sh_str_id ^ hdr.control;
938 
939  memcpy(&pFt1000Dev->tx_buf[0], &hdr, sizeof(hdr));
940  memcpy(&(pFt1000Dev->tx_buf[sizeof(struct pseudo_hdr)]), packet, len);
941 
942  netif_stop_queue(netdev);
943 
944  usb_fill_bulk_urb(pFt1000Dev->tx_urb,
945  pFt1000Dev->dev,
946  usb_sndbulkpipe(pFt1000Dev->dev,
947  pFt1000Dev->bulk_out_endpointAddr),
948  pFt1000Dev->tx_buf, count,
949  ft1000_usb_transmit_complete, (void *)pFt1000Dev);
950 
951  t = (u8 *) pFt1000Dev->tx_urb->transfer_buffer;
952 
953  ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
954 
955  if (ret) {
956  DEBUG("ft1000 failed tx_urb %d\n", ret);
957  return ret;
958  } else {
959  pInfo->stats.tx_packets++;
960  pInfo->stats.tx_bytes += (len + 14);
961  }
962 
963  return 0;
964 }
965 
966 
967 //---------------------------------------------------------------------------
968 // Function: ft1000_start_xmit
969 //
970 // Parameters: skb - socket buffer to be sent
971 // dev - network device
972 //
973 //
974 // Returns: none
975 //
976 // Description: transmit a ethernet packet
977 //
978 // Notes:
979 //
980 //---------------------------------------------------------------------------
981 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
982 {
983  struct ft1000_info *pInfo = netdev_priv(dev);
984  struct ft1000_device *pFt1000Dev = pInfo->pFt1000Dev;
985  u8 *pdata;
986  int maxlen, pipe;
987 
988  if (skb == NULL) {
989  DEBUG("ft1000_hw: ft1000_start_xmit:skb == NULL!!!\n");
990  return NETDEV_TX_OK;
991  }
992 
993  if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
994  DEBUG("network driver is closed, return\n");
995  goto err;
996  }
997 
998  pipe =
999  usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
1000  maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
1001 
1002  pdata = (u8 *) skb->data;
1003 
1004  if (pInfo->mediastate == 0) {
1005  /* Drop packet is mediastate is down */
1006  DEBUG("ft1000_hw:ft1000_start_xmit:mediastate is down\n");
1007  goto err;
1008  }
1009 
1010  if ((skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE)) {
1011  /* Drop packet which has invalid size */
1012  DEBUG("ft1000_hw:ft1000_start_xmit:invalid ethernet length\n");
1013  goto err;
1014  }
1015 
1016  ft1000_copy_down_pkt(dev, (pdata + ENET_HEADER_SIZE - 2),
1017  skb->len - ENET_HEADER_SIZE + 2);
1018 
1019 err:
1020  dev_kfree_skb(skb);
1021 
1022  return NETDEV_TX_OK;
1023 }
1024 
1025 
1026 //---------------------------------------------------------------------------
1027 //
1028 // Function: ft1000_copy_up_pkt
1029 // Description: This function will take a packet from the FIFO up link and
1030 // convert it into an ethernet packet and deliver it to the IP stack
1031 // Input:
1032 // urb - the receiving usb urb
1033 //
1034 // Output:
1035 // status - FAILURE
1036 // SUCCESS
1037 //
1038 //---------------------------------------------------------------------------
1039 static int ft1000_copy_up_pkt(struct urb *urb)
1040 {
1041  struct ft1000_info *info = urb->context;
1042  struct ft1000_device *ft1000dev = info->pFt1000Dev;
1043  struct net_device *net = ft1000dev->net;
1044 
1045  u16 tempword;
1046  u16 len;
1047  u16 lena;
1048  struct sk_buff *skb;
1049  u16 i;
1050  u8 *pbuffer = NULL;
1051  u8 *ptemp = NULL;
1052  u16 *chksum;
1053 
1054  if (ft1000dev->status & FT1000_STATUS_CLOSING) {
1055  DEBUG("network driver is closed, return\n");
1056  return STATUS_SUCCESS;
1057  }
1058  // Read length
1059  len = urb->transfer_buffer_length;
1060  lena = urb->actual_length;
1061 
1062  chksum = (u16 *) ft1000dev->rx_buf;
1063 
1064  tempword = *chksum++;
1065  for (i = 1; i < 7; i++)
1066  tempword ^= *chksum++;
1067 
1068  if (tempword != *chksum) {
1069  info->stats.rx_errors++;
1070  ft1000_submit_rx_urb(info);
1071  return STATUS_FAILURE;
1072  }
1073 
1074  skb = dev_alloc_skb(len + 12 + 2);
1075 
1076  if (skb == NULL) {
1077  DEBUG("ft1000_copy_up_pkt: No Network buffers available\n");
1078  info->stats.rx_errors++;
1079  ft1000_submit_rx_urb(info);
1080  return STATUS_FAILURE;
1081  }
1082 
1083  pbuffer = (u8 *) skb_put(skb, len + 12);
1084 
1085  /* subtract the number of bytes read already */
1086  ptemp = pbuffer;
1087 
1088  /* fake MAC address */
1089  *pbuffer++ = net->dev_addr[0];
1090  *pbuffer++ = net->dev_addr[1];
1091  *pbuffer++ = net->dev_addr[2];
1092  *pbuffer++ = net->dev_addr[3];
1093  *pbuffer++ = net->dev_addr[4];
1094  *pbuffer++ = net->dev_addr[5];
1095  *pbuffer++ = 0x00;
1096  *pbuffer++ = 0x07;
1097  *pbuffer++ = 0x35;
1098  *pbuffer++ = 0xff;
1099  *pbuffer++ = 0xff;
1100  *pbuffer++ = 0xfe;
1101 
1102  memcpy(pbuffer, ft1000dev->rx_buf + sizeof(struct pseudo_hdr),
1103  len - sizeof(struct pseudo_hdr));
1104 
1105  skb->dev = net;
1106 
1107  skb->protocol = eth_type_trans(skb, net);
1108  skb->ip_summed = CHECKSUM_UNNECESSARY;
1109  netif_rx(skb);
1110 
1111  info->stats.rx_packets++;
1112  /* Add on 12 bytes for MAC address which was removed */
1113  info->stats.rx_bytes += (lena + 12);
1114 
1115  ft1000_submit_rx_urb(info);
1116 
1117  return SUCCESS;
1118 }
1119 
1120 
1121 //---------------------------------------------------------------------------
1122 //
1123 // Function: ft1000_submit_rx_urb
1124 // Description: the receiving function of the network driver
1125 //
1126 // Input:
1127 // info - a private structure contains the device information
1128 //
1129 // Output:
1130 // status - FAILURE
1131 // SUCCESS
1132 //
1133 //---------------------------------------------------------------------------
1134 static int ft1000_submit_rx_urb(struct ft1000_info *info)
1135 {
1136  int result;
1137  struct ft1000_device *pFt1000Dev = info->pFt1000Dev;
1138 
1139  if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
1140  DEBUG("network driver is closed, return\n");
1141  return -ENODEV;
1142  }
1143 
1144  usb_fill_bulk_urb(pFt1000Dev->rx_urb,
1145  pFt1000Dev->dev,
1146  usb_rcvbulkpipe(pFt1000Dev->dev,
1147  pFt1000Dev->bulk_in_endpointAddr),
1148  pFt1000Dev->rx_buf, MAX_BUF_SIZE,
1149  (usb_complete_t) ft1000_copy_up_pkt, info);
1150 
1151  result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC);
1152 
1153  if (result) {
1154  pr_err("ft1000_submit_rx_urb: submitting rx_urb %d failed\n",
1155  result);
1156  return result;
1157  }
1158 
1159  return 0;
1160 }
1161 
1162 
1163 //---------------------------------------------------------------------------
1164 // Function: ft1000_open
1165 //
1166 // Parameters:
1167 // dev - network device
1168 //
1169 //
1170 // Returns: none
1171 //
1172 // Description: open the network driver
1173 //
1174 // Notes:
1175 //
1176 //---------------------------------------------------------------------------
1177 static int ft1000_open(struct net_device *dev)
1178 {
1179  struct ft1000_info *pInfo = netdev_priv(dev);
1180  struct timeval tv;
1181 
1182  DEBUG("ft1000_open is called for card %d\n", pInfo->CardNumber);
1183 
1184  pInfo->stats.rx_bytes = 0;
1185  pInfo->stats.tx_bytes = 0;
1186  pInfo->stats.rx_packets = 0;
1187  pInfo->stats.tx_packets = 0;
1188  do_gettimeofday(&tv);
1189  pInfo->ConTm = tv.tv_sec;
1190  pInfo->ProgConStat = 0;
1191 
1192  netif_start_queue(dev);
1193 
1194  netif_carrier_on(dev);
1195 
1196  return ft1000_submit_rx_urb(pInfo);
1197 }
1198 
1199 //---------------------------------------------------------------------------
1200 // Function: ft1000_close
1201 //
1202 // Parameters:
1203 // net - network device
1204 //
1205 //
1206 // Returns: none
1207 //
1208 // Description: close the network driver
1209 //
1210 // Notes:
1211 //
1212 //---------------------------------------------------------------------------
1213 int ft1000_close(struct net_device *net)
1214 {
1215  struct ft1000_info *pInfo = netdev_priv(net);
1216  struct ft1000_device *ft1000dev = pInfo->pFt1000Dev;
1217 
1218  ft1000dev->status |= FT1000_STATUS_CLOSING;
1219 
1220  DEBUG("ft1000_close: pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
1221  netif_carrier_off(net);
1222  netif_stop_queue(net);
1223  ft1000dev->status &= ~FT1000_STATUS_CLOSING;
1224 
1225  pInfo->ProgConStat = 0xff;
1226 
1227  return 0;
1228 }
1229 
1230 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
1231 {
1232  struct ft1000_info *info = netdev_priv(dev);
1233 
1234  return &(info->stats);
1235 }
1236 
1237 
1238 //---------------------------------------------------------------------------
1239 //
1240 // Function: ft1000_chkcard
1241 // Description: This function will check if the device is presently available on
1242 // the system.
1243 // Input:
1244 // dev - device structure
1245 // Output:
1246 // status - FALSE (device is not present)
1247 // TRUE (device is present)
1248 //
1249 //---------------------------------------------------------------------------
1250 static int ft1000_chkcard(struct ft1000_device *dev)
1251 {
1252  u16 tempword;
1253  u16 status;
1254  struct ft1000_info *info = netdev_priv(dev->net);
1255 
1256  if (info->fCondResetPend) {
1257  DEBUG
1258  ("ft1000_hw:ft1000_chkcard:Card is being reset, return FALSE\n");
1259  return TRUE;
1260  }
1261  /* Mask register is used to check for device presence since it is never
1262  * set to zero.
1263  */
1264  status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
1265  if (tempword == 0) {
1266  DEBUG
1267  ("ft1000_hw:ft1000_chkcard: IMASK = 0 Card not detected\n");
1268  return FALSE;
1269  }
1270  /* The system will return the value of 0xffff for the version register
1271  * if the device is not present.
1272  */
1273  status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
1274  if (tempword != 0x1b01) {
1275  dev->status |= FT1000_STATUS_CLOSING;
1276  DEBUG
1277  ("ft1000_hw:ft1000_chkcard: Version = 0xffff Card not detected\n");
1278  return FALSE;
1279  }
1280  return TRUE;
1281 }
1282 
1283 //---------------------------------------------------------------------------
1284 //
1285 // Function: ft1000_receive_cmd
1286 // Description: This function will read a message from the dpram area.
1287 // Input:
1288 // dev - network device structure
1289 // pbuffer - caller supply address to buffer
1290 // pnxtph - pointer to next pseudo header
1291 // Output:
1292 // Status = 0 (unsuccessful)
1293 // = 1 (successful)
1294 //
1295 //---------------------------------------------------------------------------
1296 static bool ft1000_receive_cmd(struct ft1000_device *dev, u16 *pbuffer,
1297  int maxsz, u16 *pnxtph)
1298 {
1299  u16 size, ret;
1300  u16 *ppseudohdr;
1301  int i;
1302  u16 tempword;
1303 
1304  ret =
1305  ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *) &size,
1306  FT1000_MAG_PH_LEN_INDX);
1307  size = ntohs(size) + PSEUDOSZ;
1308  if (size > maxsz) {
1309  DEBUG("FT1000:ft1000_receive_cmd:Invalid command length = %d\n",
1310  size);
1311  return FALSE;
1312  } else {
1313  ppseudohdr = (u16 *) pbuffer;
1314  ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE,
1315  FT1000_REG_DPRAM_ADDR);
1316  ret =
1317  ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1318  pbuffer++;
1319  ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE + 1,
1320  FT1000_REG_DPRAM_ADDR);
1321  for (i = 0; i <= (size >> 2); i++) {
1322  ret =
1323  ft1000_read_register(dev, pbuffer,
1324  FT1000_REG_MAG_DPDATAL);
1325  pbuffer++;
1326  ret =
1327  ft1000_read_register(dev, pbuffer,
1328  FT1000_REG_MAG_DPDATAH);
1329  pbuffer++;
1330  }
1331  /* copy odd aligned word */
1332  ret =
1333  ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1334 
1335  pbuffer++;
1336  ret =
1337  ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1338 
1339  pbuffer++;
1340  if (size & 0x0001) {
1341  /* copy odd byte from fifo */
1342  ret =
1343  ft1000_read_register(dev, &tempword,
1344  FT1000_REG_DPRAM_DATA);
1345  *pbuffer = ntohs(tempword);
1346  }
1347  /* Check if pseudo header checksum is good
1348  * Calculate pseudo header checksum
1349  */
1350  tempword = *ppseudohdr++;
1351  for (i = 1; i < 7; i++)
1352  tempword ^= *ppseudohdr++;
1353 
1354  if ((tempword != *ppseudohdr))
1355  return FALSE;
1356 
1357  return TRUE;
1358  }
1359 }
1360 
1361 static int ft1000_dsp_prov(void *arg)
1362 {
1363  struct ft1000_device *dev = (struct ft1000_device *)arg;
1364  struct ft1000_info *info = netdev_priv(dev->net);
1365  u16 tempword;
1366  u16 len;
1367  u16 i = 0;
1368  struct prov_record *ptr;
1369  struct pseudo_hdr *ppseudo_hdr;
1370  u16 *pmsg;
1371  u16 status;
1372  u16 TempShortBuf[256];
1373 
1374  DEBUG("*** DspProv Entered\n");
1375 
1376  while (list_empty(&info->prov_list) == 0) {
1377  DEBUG("DSP Provisioning List Entry\n");
1378 
1379  /* Check if doorbell is available */
1380  DEBUG("check if doorbell is cleared\n");
1381  status =
1382  ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1383  if (status) {
1384  DEBUG("ft1000_dsp_prov::ft1000_read_register error\n");
1385  break;
1386  }
1387 
1388  while (tempword & FT1000_DB_DPRAM_TX) {
1389  mdelay(10);
1390  i++;
1391  if (i == 10) {
1392  DEBUG("FT1000:ft1000_dsp_prov:message drop\n");
1393  return STATUS_FAILURE;
1394  }
1395  ft1000_read_register(dev, &tempword,
1396  FT1000_REG_DOORBELL);
1397  }
1398 
1399  if (!(tempword & FT1000_DB_DPRAM_TX)) {
1400  DEBUG("*** Provision Data Sent to DSP\n");
1401 
1402  /* Send provisioning data */
1403  ptr =
1404  list_entry(info->prov_list.next, struct prov_record,
1405  list);
1406  len = *(u16 *) ptr->pprov_data;
1407  len = htons(len);
1408  len += PSEUDOSZ;
1409 
1410  pmsg = (u16 *) ptr->pprov_data;
1411  ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1412  /* Insert slow queue sequence number */
1413  ppseudo_hdr->seq_num = info->squeseqnum++;
1414  ppseudo_hdr->portsrc = 0;
1415  /* Calculate new checksum */
1416  ppseudo_hdr->checksum = *pmsg++;
1417  for (i = 1; i < 7; i++) {
1418  ppseudo_hdr->checksum ^= *pmsg++;
1419  }
1420 
1421  TempShortBuf[0] = 0;
1422  TempShortBuf[1] = htons(len);
1423  memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1424 
1425  status =
1426  ft1000_write_dpram32(dev, 0,
1427  (u8 *) &TempShortBuf[0],
1428  (unsigned short)(len + 2));
1429  status =
1430  ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1431  FT1000_REG_DOORBELL);
1432 
1433  list_del(&ptr->list);
1434  kfree(ptr->pprov_data);
1435  kfree(ptr);
1436  }
1437  msleep(10);
1438  }
1439 
1440  DEBUG("DSP Provisioning List Entry finished\n");
1441 
1442  msleep(100);
1443 
1444  info->fProvComplete = 1;
1445  info->CardReady = 1;
1446 
1447  return STATUS_SUCCESS;
1448 }
1449 
1450 static int ft1000_proc_drvmsg(struct ft1000_device *dev, u16 size)
1451 {
1452  struct ft1000_info *info = netdev_priv(dev->net);
1453  u16 msgtype;
1454  u16 tempword;
1455  struct media_msg *pmediamsg;
1456  struct dsp_init_msg *pdspinitmsg;
1457  struct drv_msg *pdrvmsg;
1458  u16 i;
1459  struct pseudo_hdr *ppseudo_hdr;
1460  u16 *pmsg;
1461  u16 status;
1462  union {
1463  u8 byte[2];
1464  u16 wrd;
1465  } convert;
1466 
1467  char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1468  if (!cmdbuffer)
1469  return STATUS_FAILURE;
1470 
1471  status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1472 
1473 #ifdef JDEBUG
1474  DEBUG("ft1000_proc_drvmsg:cmdbuffer\n");
1475  for (i = 0; i < size; i += 5) {
1476  if ((i + 5) < size)
1477  DEBUG("0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n", cmdbuffer[i],
1478  cmdbuffer[i + 1], cmdbuffer[i + 2],
1479  cmdbuffer[i + 3], cmdbuffer[i + 4]);
1480  else {
1481  for (j = i; j < size; j++)
1482  DEBUG("0x%x ", cmdbuffer[j]);
1483  DEBUG("\n");
1484  break;
1485  }
1486  }
1487 #endif
1488  pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1489  msgtype = ntohs(pdrvmsg->type);
1490  DEBUG("ft1000_proc_drvmsg:Command message type = 0x%x\n", msgtype);
1491  switch (msgtype) {
1492  case MEDIA_STATE:{
1493  DEBUG
1494  ("ft1000_proc_drvmsg:Command message type = MEDIA_STATE");
1495 
1496  pmediamsg = (struct media_msg *)&cmdbuffer[0];
1497  if (info->ProgConStat != 0xFF) {
1498  if (pmediamsg->state) {
1499  DEBUG("Media is up\n");
1500  if (info->mediastate == 0) {
1501  if (info->NetDevRegDone) {
1502  netif_wake_queue(dev->
1503  net);
1504  }
1505  info->mediastate = 1;
1506  }
1507  } else {
1508  DEBUG("Media is down\n");
1509  if (info->mediastate == 1) {
1510  info->mediastate = 0;
1511  if (info->NetDevRegDone) {
1512  }
1513  info->ConTm = 0;
1514  }
1515  }
1516  } else {
1517  DEBUG("Media is down\n");
1518  if (info->mediastate == 1) {
1519  info->mediastate = 0;
1520  info->ConTm = 0;
1521  }
1522  }
1523  break;
1524  }
1525  case DSP_INIT_MSG:{
1526  DEBUG
1527  ("ft1000_proc_drvmsg:Command message type = DSP_INIT_MSG");
1528 
1529  pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1530  memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1531  DEBUG("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n",
1532  info->DspVer[0], info->DspVer[1], info->DspVer[2],
1533  info->DspVer[3]);
1534  memcpy(info->HwSerNum, pdspinitmsg->HwSerNum,
1535  HWSERNUMSZ);
1536  memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1537  memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1538  DEBUG("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n",
1539  info->eui64[0], info->eui64[1], info->eui64[2],
1540  info->eui64[3], info->eui64[4], info->eui64[5],
1541  info->eui64[6], info->eui64[7]);
1542  dev->net->dev_addr[0] = info->eui64[0];
1543  dev->net->dev_addr[1] = info->eui64[1];
1544  dev->net->dev_addr[2] = info->eui64[2];
1545  dev->net->dev_addr[3] = info->eui64[5];
1546  dev->net->dev_addr[4] = info->eui64[6];
1547  dev->net->dev_addr[5] = info->eui64[7];
1548 
1549  if (ntohs(pdspinitmsg->length) ==
1550  (sizeof(struct dsp_init_msg) - 20)) {
1551  memcpy(info->ProductMode,
1552  pdspinitmsg->ProductMode, MODESZ);
1553  memcpy(info->RfCalVer, pdspinitmsg->RfCalVer,
1554  CALVERSZ);
1555  memcpy(info->RfCalDate, pdspinitmsg->RfCalDate,
1556  CALDATESZ);
1557  DEBUG("RFCalVer = 0x%2x 0x%2x\n",
1558  info->RfCalVer[0], info->RfCalVer[1]);
1559  }
1560  break;
1561  }
1562  case DSP_PROVISION:{
1563  DEBUG
1564  ("ft1000_proc_drvmsg:Command message type = DSP_PROVISION\n");
1565 
1566  /* kick off dspprov routine to start provisioning
1567  * Send provisioning data to DSP
1568  */
1569  if (list_empty(&info->prov_list) == 0) {
1570  info->fProvComplete = 0;
1571  status = ft1000_dsp_prov(dev);
1572  if (status != STATUS_SUCCESS)
1573  goto out;
1574  } else {
1575  info->fProvComplete = 1;
1576  status =
1577  ft1000_write_register(dev, FT1000_DB_HB,
1578  FT1000_REG_DOORBELL);
1579  DEBUG
1580  ("FT1000:drivermsg:No more DSP provisioning data in dsp image\n");
1581  }
1582  DEBUG("ft1000_proc_drvmsg:DSP PROVISION is done\n");
1583  break;
1584  }
1585  case DSP_STORE_INFO:{
1586  DEBUG
1587  ("ft1000_proc_drvmsg:Command message type = DSP_STORE_INFO");
1588 
1589  DEBUG("FT1000:drivermsg:Got DSP_STORE_INFO\n");
1590  tempword = ntohs(pdrvmsg->length);
1591  info->DSPInfoBlklen = tempword;
1592  if (tempword < (MAX_DSP_SESS_REC - 4)) {
1593  pmsg = (u16 *) &pdrvmsg->data[0];
1594  for (i = 0; i < ((tempword + 1) / 2); i++) {
1595  DEBUG
1596  ("FT1000:drivermsg:dsp info data = 0x%x\n",
1597  *pmsg);
1598  info->DSPInfoBlk[i + 10] = *pmsg++;
1599  }
1600  } else {
1601  info->DSPInfoBlklen = 0;
1602  }
1603  break;
1604  }
1605  case DSP_GET_INFO:{
1606  DEBUG("FT1000:drivermsg:Got DSP_GET_INFO\n");
1607  /* copy dsp info block to dsp */
1608  info->DrvMsgPend = 1;
1609  /* allow any outstanding ioctl to finish */
1610  mdelay(10);
1611  status =
1612  ft1000_read_register(dev, &tempword,
1613  FT1000_REG_DOORBELL);
1614  if (tempword & FT1000_DB_DPRAM_TX) {
1615  mdelay(10);
1616  status =
1617  ft1000_read_register(dev, &tempword,
1618  FT1000_REG_DOORBELL);
1619  if (tempword & FT1000_DB_DPRAM_TX) {
1620  mdelay(10);
1621  status =
1622  ft1000_read_register(dev, &tempword,
1623  FT1000_REG_DOORBELL);
1624  if (tempword & FT1000_DB_DPRAM_TX)
1625  break;
1626  }
1627  }
1628  /* Put message into Slow Queue
1629  * Form Pseudo header
1630  */
1631  pmsg = (u16 *) info->DSPInfoBlk;
1632  *pmsg++ = 0;
1633  *pmsg++ =
1634  htons(info->DSPInfoBlklen + 20 +
1635  info->DSPInfoBlklen);
1636  ppseudo_hdr =
1637  (struct pseudo_hdr *)(u16 *) &info->DSPInfoBlk[2];
1638  ppseudo_hdr->length =
1639  htons(info->DSPInfoBlklen + 4 +
1640  info->DSPInfoBlklen);
1641  ppseudo_hdr->source = 0x10;
1642  ppseudo_hdr->destination = 0x20;
1643  ppseudo_hdr->portdest = 0;
1644  ppseudo_hdr->portsrc = 0;
1645  ppseudo_hdr->sh_str_id = 0;
1646  ppseudo_hdr->control = 0;
1647  ppseudo_hdr->rsvd1 = 0;
1648  ppseudo_hdr->rsvd2 = 0;
1649  ppseudo_hdr->qos_class = 0;
1650  /* Insert slow queue sequence number */
1651  ppseudo_hdr->seq_num = info->squeseqnum++;
1652  /* Insert application id */
1653  ppseudo_hdr->portsrc = 0;
1654  /* Calculate new checksum */
1655  ppseudo_hdr->checksum = *pmsg++;
1656  for (i = 1; i < 7; i++)
1657  ppseudo_hdr->checksum ^= *pmsg++;
1658 
1659  info->DSPInfoBlk[10] = 0x7200;
1660  info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1661  status =
1662  ft1000_write_dpram32(dev, 0,
1663  (u8 *) &info->DSPInfoBlk[0],
1664  (unsigned short)(info->
1665  DSPInfoBlklen
1666  + 22));
1667  status =
1668  ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1669  FT1000_REG_DOORBELL);
1670  info->DrvMsgPend = 0;
1671 
1672  break;
1673  }
1674 
1675  case GET_DRV_ERR_RPT_MSG:{
1676  DEBUG("FT1000:drivermsg:Got GET_DRV_ERR_RPT_MSG\n");
1677  /* copy driver error message to dsp */
1678  info->DrvMsgPend = 1;
1679  /* allow any outstanding ioctl to finish */
1680  mdelay(10);
1681  status =
1682  ft1000_read_register(dev, &tempword,
1683  FT1000_REG_DOORBELL);
1684  if (tempword & FT1000_DB_DPRAM_TX) {
1685  mdelay(10);
1686  status =
1687  ft1000_read_register(dev, &tempword,
1688  FT1000_REG_DOORBELL);
1689  if (tempword & FT1000_DB_DPRAM_TX)
1690  mdelay(10);
1691  }
1692 
1693  if ((tempword & FT1000_DB_DPRAM_TX) == 0) {
1694  /* Put message into Slow Queue
1695  * Form Pseudo header
1696  */
1697  pmsg = (u16 *) &tempbuffer[0];
1698  ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1699  ppseudo_hdr->length = htons(0x0012);
1700  ppseudo_hdr->source = 0x10;
1701  ppseudo_hdr->destination = 0x20;
1702  ppseudo_hdr->portdest = 0;
1703  ppseudo_hdr->portsrc = 0;
1704  ppseudo_hdr->sh_str_id = 0;
1705  ppseudo_hdr->control = 0;
1706  ppseudo_hdr->rsvd1 = 0;
1707  ppseudo_hdr->rsvd2 = 0;
1708  ppseudo_hdr->qos_class = 0;
1709  /* Insert slow queue sequence number */
1710  ppseudo_hdr->seq_num = info->squeseqnum++;
1711  /* Insert application id */
1712  ppseudo_hdr->portsrc = 0;
1713  /* Calculate new checksum */
1714  ppseudo_hdr->checksum = *pmsg++;
1715  for (i = 1; i < 7; i++)
1716  ppseudo_hdr->checksum ^= *pmsg++;
1717 
1718  pmsg = (u16 *) &tempbuffer[16];
1719  *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1720  *pmsg++ = htons(0x000e);
1721  *pmsg++ = htons(info->DSP_TIME[0]);
1722  *pmsg++ = htons(info->DSP_TIME[1]);
1723  *pmsg++ = htons(info->DSP_TIME[2]);
1724  *pmsg++ = htons(info->DSP_TIME[3]);
1725  convert.byte[0] = info->DspVer[0];
1726  convert.byte[1] = info->DspVer[1];
1727  *pmsg++ = convert.wrd;
1728  convert.byte[0] = info->DspVer[2];
1729  convert.byte[1] = info->DspVer[3];
1730  *pmsg++ = convert.wrd;
1731  *pmsg++ = htons(info->DrvErrNum);
1732 
1733  card_send_command(dev,
1734  (unsigned char *)&tempbuffer[0],
1735  (u16) (0x0012 + PSEUDOSZ));
1736  info->DrvErrNum = 0;
1737  }
1738  info->DrvMsgPend = 0;
1739 
1740  break;
1741  }
1742 
1743  default:
1744  break;
1745  }
1746 
1747  status = STATUS_SUCCESS;
1748 out:
1749  kfree(cmdbuffer);
1750  DEBUG("return from ft1000_proc_drvmsg\n");
1751  return status;
1752 }
1753 
1754 int ft1000_poll(void* dev_id)
1755 {
1756  struct ft1000_device *dev = (struct ft1000_device *)dev_id;
1757  struct ft1000_info *info = netdev_priv(dev->net);
1758 
1759  u16 tempword;
1760  u16 status;
1761  u16 size;
1762  int i;
1763  u16 data;
1764  u16 modulo;
1765  u16 portid;
1766  u16 nxtph;
1767  struct dpram_blk *pdpram_blk;
1768  struct pseudo_hdr *ppseudo_hdr;
1769  unsigned long flags;
1770 
1771  if (ft1000_chkcard(dev) == FALSE) {
1772  DEBUG("ft1000_poll::ft1000_chkcard: failed\n");
1773  return STATUS_FAILURE;
1774  }
1775 
1776  status = ft1000_read_register (dev, &tempword, FT1000_REG_DOORBELL);
1777 
1778  if ( !status )
1779  {
1780 
1781  if (tempword & FT1000_DB_DPRAM_RX) {
1782 
1783  status = ft1000_read_dpram16(dev, 0x200, (u8 *)&data, 0);
1784  size = ntohs(data) + 16 + 2;
1785  if (size % 4) {
1786  modulo = 4 - (size % 4);
1787  size = size + modulo;
1788  }
1789  status = ft1000_read_dpram16(dev, 0x201, (u8 *)&portid, 1);
1790  portid &= 0xff;
1791 
1792  if (size < MAX_CMD_SQSIZE) {
1793  switch (portid)
1794  {
1795  case DRIVERID:
1796  DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1797 
1798  status = ft1000_proc_drvmsg (dev, size);
1799  if (status != STATUS_SUCCESS )
1800  return status;
1801  break;
1802  case DSPBCMSGID:
1803  // This is a dsp broadcast message
1804  // Check which application has registered for dsp broadcast messages
1805 
1806  for (i=0; i<MAX_NUM_APP; i++) {
1807  if ( (info->app_info[i].DspBCMsgFlag) && (info->app_info[i].fileobject) &&
1808  (info->app_info[i].NumOfMsg < MAX_MSG_LIMIT) )
1809  {
1810  nxtph = FT1000_DPRAM_RX_BASE + 2;
1811  pdpram_blk = ft1000_get_buffer (&freercvpool);
1812  if (pdpram_blk != NULL) {
1813  if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1814  ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1815  // Put message into the appropriate application block
1816  info->app_info[i].nRxMsg++;
1817  spin_lock_irqsave(&free_buff_lock, flags);
1818  list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
1819  info->app_info[i].NumOfMsg++;
1820  spin_unlock_irqrestore(&free_buff_lock, flags);
1821  wake_up_interruptible(&info->app_info[i].wait_dpram_msg);
1822  }
1823  else {
1824  info->app_info[i].nRxMsgMiss++;
1825  // Put memory back to free pool
1826  ft1000_free_buffer(pdpram_blk, &freercvpool);
1827  DEBUG("pdpram_blk::ft1000_get_buffer NULL\n");
1828  }
1829  }
1830  else {
1831  DEBUG("Out of memory in free receive command pool\n");
1832  info->app_info[i].nRxMsgMiss++;
1833  }
1834  }
1835  }
1836  break;
1837  default:
1838  pdpram_blk = ft1000_get_buffer (&freercvpool);
1839 
1840  if (pdpram_blk != NULL) {
1841  if ( ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE, &nxtph) ) {
1842  ppseudo_hdr = (struct pseudo_hdr *)pdpram_blk->pbuffer;
1843  // Search for correct application block
1844  for (i=0; i<MAX_NUM_APP; i++) {
1845  if (info->app_info[i].app_id == ppseudo_hdr->portdest) {
1846  break;
1847  }
1848  }
1849 
1850  if (i == MAX_NUM_APP) {
1851  DEBUG("FT1000:ft1000_parse_dpram_msg: No application matching id = %d\n", ppseudo_hdr->portdest);
1852  // Put memory back to free pool
1853  ft1000_free_buffer(pdpram_blk, &freercvpool);
1854  }
1855  else {
1856  if (info->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
1857  // Put memory back to free pool
1858  ft1000_free_buffer(pdpram_blk, &freercvpool);
1859  }
1860  else {
1861  info->app_info[i].nRxMsg++;
1862  // Put message into the appropriate application block
1863  list_add_tail(&pdpram_blk->list, &info->app_info[i].app_sqlist);
1864  info->app_info[i].NumOfMsg++;
1865  }
1866  }
1867  }
1868  else {
1869  // Put memory back to free pool
1870  ft1000_free_buffer(pdpram_blk, &freercvpool);
1871  }
1872  }
1873  else {
1874  DEBUG("Out of memory in free receive command pool\n");
1875  }
1876  break;
1877  }
1878  }
1879  else {
1880  DEBUG("FT1000:dpc:Invalid total length for SlowQ = %d\n", size);
1881  }
1882  status = ft1000_write_register (dev, FT1000_DB_DPRAM_RX, FT1000_REG_DOORBELL);
1883  }
1884  else if (tempword & FT1000_DSP_ASIC_RESET) {
1885 
1886  // Let's reset the ASIC from the Host side as well
1887  status = ft1000_write_register (dev, ASIC_RESET_BIT, FT1000_REG_RESET);
1888  status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
1889  i = 0;
1890  while (tempword & ASIC_RESET_BIT) {
1891  status = ft1000_read_register (dev, &tempword, FT1000_REG_RESET);
1892  msleep(10);
1893  i++;
1894  if (i==100)
1895  break;
1896  }
1897  if (i==100) {
1898  DEBUG("Unable to reset ASIC\n");
1899  return STATUS_SUCCESS;
1900  }
1901  msleep(10);
1902  // Program WMARK register
1903  status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
1904  // clear ASIC reset doorbell
1905  status = ft1000_write_register (dev, FT1000_DSP_ASIC_RESET, FT1000_REG_DOORBELL);
1906  msleep(10);
1907  }
1908  else if (tempword & FT1000_ASIC_RESET_REQ) {
1909  DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
1910 
1911  // clear ASIC reset request from DSP
1912  status = ft1000_write_register (dev, FT1000_ASIC_RESET_REQ, FT1000_REG_DOORBELL);
1913  status = ft1000_write_register (dev, HOST_INTF_BE, FT1000_REG_SUP_CTRL);
1914  // copy dsp session record from Adapter block
1915  status = ft1000_write_dpram32 (dev, 0, (u8 *)&info->DSPSess.Rec[0], 1024);
1916  // Program WMARK register
1917  status = ft1000_write_register (dev, 0x600, FT1000_REG_MAG_WATERMARK);
1918  // ring doorbell to tell DSP that ASIC is out of reset
1919  status = ft1000_write_register (dev, FT1000_ASIC_RESET_DSP, FT1000_REG_DOORBELL);
1920  }
1921  else if (tempword & FT1000_DB_COND_RESET) {
1922  DEBUG("ft1000_poll: FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
1923 
1924  if (info->fAppMsgPend == 0) {
1925  // Reset ASIC and DSP
1926 
1927  status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER0, (u8 *)&(info->DSP_TIME[0]), FT1000_MAG_DSP_TIMER0_INDX);
1928  status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER1, (u8 *)&(info->DSP_TIME[1]), FT1000_MAG_DSP_TIMER1_INDX);
1929  status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER2, (u8 *)&(info->DSP_TIME[2]), FT1000_MAG_DSP_TIMER2_INDX);
1930  status = ft1000_read_dpram16(dev, FT1000_MAG_DSP_TIMER3, (u8 *)&(info->DSP_TIME[3]), FT1000_MAG_DSP_TIMER3_INDX);
1931  info->CardReady = 0;
1932  info->DrvErrNum = DSP_CONDRESET_INFO;
1933  DEBUG("ft1000_hw:DSP conditional reset requested\n");
1934  info->ft1000_reset(dev->net);
1935  }
1936  else {
1937  info->fProvComplete = 0;
1938  info->fCondResetPend = 1;
1939  }
1940 
1941  ft1000_write_register(dev, FT1000_DB_COND_RESET, FT1000_REG_DOORBELL);
1942  }
1943 
1944  }
1945 
1946  return STATUS_SUCCESS;
1947 
1948 }
Generated on Thu Jan 10 2013 14:28:23 for Linux Kernel by   doxygen 1.8.2