Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ft1000_download.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 // 20090926; aelias; removed compiler warnings; 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 <linux/vmalloc.h>
18 #include "ft1000_usb.h"
19 
20 
21 #define DWNLD_HANDSHAKE_LOC 0x02
22 #define DWNLD_TYPE_LOC 0x04
23 #define DWNLD_SIZE_MSW_LOC 0x06
24 #define DWNLD_SIZE_LSW_LOC 0x08
25 #define DWNLD_PS_HDR_LOC 0x0A
26 
27 #define MAX_DSP_WAIT_LOOPS 40
28 #define DSP_WAIT_SLEEP_TIME 1000 /* 1 millisecond */
29 #define DSP_WAIT_DISPATCH_LVL 50 /* 50 usec */
30 
31 #define HANDSHAKE_TIMEOUT_VALUE 0xF1F1
32 #define HANDSHAKE_RESET_VALUE 0xFEFE /* When DSP requests startover */
33 #define HANDSHAKE_RESET_VALUE_USB 0xFE7E /* When DSP requests startover */
34 #define HANDSHAKE_DSP_BL_READY 0xFEFE /* At start DSP writes this when bootloader ready */
35 #define HANDSHAKE_DSP_BL_READY_USB 0xFE7E /* At start DSP writes this when bootloader ready */
36 #define HANDSHAKE_DRIVER_READY 0xFFFF /* Driver writes after receiving 0xFEFE */
37 #define HANDSHAKE_SEND_DATA 0x0000 /* DSP writes this when ready for more data */
38 
39 #define HANDSHAKE_REQUEST 0x0001 /* Request from DSP */
40 #define HANDSHAKE_RESPONSE 0x0000 /* Satisfied DSP request */
41 
42 #define REQUEST_CODE_LENGTH 0x0000
43 #define REQUEST_RUN_ADDRESS 0x0001
44 #define REQUEST_CODE_SEGMENT 0x0002 /* In WORD count */
45 #define REQUEST_DONE_BL 0x0003
46 #define REQUEST_DONE_CL 0x0004
47 #define REQUEST_VERSION_INFO 0x0005
48 #define REQUEST_CODE_BY_VERSION 0x0006
49 #define REQUEST_MAILBOX_DATA 0x0007
50 #define REQUEST_FILE_CHECKSUM 0x0008
51 
52 #define STATE_START_DWNLD 0x01
53 #define STATE_BOOT_DWNLD 0x02
54 #define STATE_CODE_DWNLD 0x03
55 #define STATE_DONE_DWNLD 0x04
56 #define STATE_SECTION_PROV 0x05
57 #define STATE_DONE_PROV 0x06
58 #define STATE_DONE_FILE 0x07
59 
60 #define MAX_LENGTH 0x7f0
61 
62 // Temporary download mechanism for Magnemite
63 #define DWNLD_MAG_TYPE_LOC 0x00
64 #define DWNLD_MAG_LEN_LOC 0x01
65 #define DWNLD_MAG_ADDR_LOC 0x02
66 #define DWNLD_MAG_CHKSUM_LOC 0x03
67 #define DWNLD_MAG_VAL_LOC 0x04
68 
69 #define HANDSHAKE_MAG_DSP_BL_READY 0xFEFE0000 /* At start DSP writes this when bootloader ready */
70 #define HANDSHAKE_MAG_DSP_ENTRY 0x01000000 /* Dsp writes this to request for entry address */
71 #define HANDSHAKE_MAG_DSP_DATA 0x02000000 /* Dsp writes this to request for data block */
72 #define HANDSHAKE_MAG_DSP_DONE 0x03000000 /* Dsp writes this to indicate download done */
73 
74 #define HANDSHAKE_MAG_DRV_READY 0xFFFF0000 /* Driver writes this to indicate ready to download */
75 #define HANDSHAKE_MAG_DRV_DATA 0x02FECDAB /* Driver writes this to indicate data available to DSP */
76 #define HANDSHAKE_MAG_DRV_ENTRY 0x01FECDAB /* Driver writes this to indicate entry point to DSP */
77 
78 #define HANDSHAKE_MAG_TIMEOUT_VALUE 0xF1F1
79 
80 
81 // New Magnemite downloader
82 #define DWNLD_MAG1_HANDSHAKE_LOC 0x00
83 #define DWNLD_MAG1_TYPE_LOC 0x01
84 #define DWNLD_MAG1_SIZE_LOC 0x02
85 #define DWNLD_MAG1_PS_HDR_LOC 0x03
86 
87 struct dsp_file_hdr {
88  long version_id; // Version ID of this image format.
89  long package_id; // Package ID of code release.
90  long build_date; // Date/time stamp when file was built.
91  long commands_offset; // Offset to attached commands in Pseudo Hdr format.
92  long loader_offset; // Offset to bootloader code.
93  long loader_code_address; // Start address of bootloader.
94  long loader_code_end; // Where bootloader code ends.
95  long loader_code_size;
96  long version_data_offset; // Offset were scrambled version data begins.
97  long version_data_size; // Size, in words, of scrambled version data.
98  long nDspImages; // Number of DSP images in file.
99 };
100 
101 #pragma pack(1)
102 struct dsp_image_info {
103  long coff_date; // Date/time when DSP Coff image was built.
104  long begin_offset; // Offset in file where image begins.
105  long end_offset; // Offset in file where image begins.
106  long run_address; // On chip Start address of DSP code.
107  long image_size; // Size of image.
108  long version; // Embedded version # of DSP code.
109  unsigned short checksum; // DSP File checksum
110  unsigned short pad1;
111 };
112 
113 
114 //---------------------------------------------------------------------------
115 // Function: check_usb_db
116 //
117 // Parameters: struct ft1000_device - device structure
118 //
119 // Returns: 0 - success
120 //
121 // Description: This function checks if the doorbell register is cleared
122 //
123 // Notes:
124 //
125 //---------------------------------------------------------------------------
126 static u32 check_usb_db (struct ft1000_device *ft1000dev)
127 {
128  int loopcnt;
129  u16 temp;
130  u32 status;
131 
132  loopcnt = 0;
133 
134  while (loopcnt < 10) {
135  status = ft1000_read_register(ft1000dev, &temp,
136  FT1000_REG_DOORBELL);
137  DEBUG("check_usb_db: read FT1000_REG_DOORBELL value is %x\n",
138  temp);
139  if (temp & 0x0080) {
140  DEBUG("FT1000:Got checkusb doorbell\n");
141  status = ft1000_write_register(ft1000dev, 0x0080,
142  FT1000_REG_DOORBELL);
143  status = ft1000_write_register(ft1000dev, 0x0100,
144  FT1000_REG_DOORBELL);
145  status = ft1000_write_register(ft1000dev, 0x8000,
146  FT1000_REG_DOORBELL);
147  break;
148  } else {
149  loopcnt++;
150  msleep(10);
151  }
152 
153  }
154 
155  loopcnt = 0;
156  while (loopcnt < 20) {
157  status = ft1000_read_register(ft1000dev, &temp,
158  FT1000_REG_DOORBELL);
159  DEBUG("FT1000:check_usb_db:Doorbell = 0x%x\n", temp);
160  if (temp & 0x8000) {
161  loopcnt++;
162  msleep(10);
163  } else {
164  DEBUG("check_usb_db: door bell is cleared, return 0\n");
165  return 0;
166  }
167  }
168 
169  return HANDSHAKE_MAG_TIMEOUT_VALUE;
170 }
171 
172 //---------------------------------------------------------------------------
173 // Function: get_handshake
174 //
175 // Parameters: struct ft1000_device - device structure
176 // u16 expected_value - the handshake value expected
177 //
178 // Returns: handshakevalue - success
179 // HANDSHAKE_TIMEOUT_VALUE - failure
180 //
181 // Description: This function gets the handshake and compare with the expected value
182 //
183 // Notes:
184 //
185 //---------------------------------------------------------------------------
186 static u16 get_handshake(struct ft1000_device *ft1000dev, u16 expected_value)
187 {
188  u16 handshake;
189  int loopcnt;
190  u32 status = 0;
191  struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net);
192 
193  loopcnt = 0;
194 
195  while (loopcnt < 100) {
196  /* Need to clear downloader doorbell if Hartley ASIC */
197  status = ft1000_write_register(ft1000dev, FT1000_DB_DNLD_RX,
198  FT1000_REG_DOORBELL);
199  if (pft1000info->fcodeldr) {
200  DEBUG(" get_handshake: fcodeldr is %d\n",
201  pft1000info->fcodeldr);
202  pft1000info->fcodeldr = 0;
203  status = check_usb_db(ft1000dev);
204  if (status != STATUS_SUCCESS) {
205  DEBUG("get_handshake: check_usb_db failed\n");
206  status = STATUS_FAILURE;
207  break;
208  }
209  status = ft1000_write_register(ft1000dev,
210  FT1000_DB_DNLD_RX,
211  FT1000_REG_DOORBELL);
212  }
213 
214  status = ft1000_read_dpram16(ft1000dev,
215  DWNLD_MAG1_HANDSHAKE_LOC, (u8 *)&handshake, 1);
216  handshake = ntohs(handshake);
217 
218  if (status)
219  return HANDSHAKE_TIMEOUT_VALUE;
220 
221  if ((handshake == expected_value) ||
222  (handshake == HANDSHAKE_RESET_VALUE_USB)) {
223  return handshake;
224  } else {
225  loopcnt++;
226  msleep(10);
227  }
228  }
229 
230  return HANDSHAKE_TIMEOUT_VALUE;
231 }
232 
233 //---------------------------------------------------------------------------
234 // Function: put_handshake
235 //
236 // Parameters: struct ft1000_device - device structure
237 // u16 handshake_value - handshake to be written
238 //
239 // Returns: none
240 //
241 // Description: This function write the handshake value to the handshake location
242 // in DPRAM
243 //
244 // Notes:
245 //
246 //---------------------------------------------------------------------------
247 static void put_handshake(struct ft1000_device *ft1000dev,u16 handshake_value)
248 {
249  u32 tempx;
250  u16 tempword;
251  u32 status;
252 
253  tempx = (u32)handshake_value;
254  tempx = ntohl(tempx);
255 
256  tempword = (u16)(tempx & 0xffff);
257  status = ft1000_write_dpram16(ft1000dev, DWNLD_MAG1_HANDSHAKE_LOC,
258  tempword, 0);
259  tempword = (u16)(tempx >> 16);
260  status = ft1000_write_dpram16(ft1000dev, DWNLD_MAG1_HANDSHAKE_LOC,
261  tempword, 1);
262  status = ft1000_write_register(ft1000dev, FT1000_DB_DNLD_TX,
263  FT1000_REG_DOORBELL);
264 }
265 
266 static u16 get_handshake_usb(struct ft1000_device *ft1000dev, u16 expected_value)
267 {
268  u16 handshake;
269  int loopcnt;
270  u16 temp;
271  u32 status = 0;
272 
273  struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net);
274  loopcnt = 0;
275  handshake = 0;
276 
277  while (loopcnt < 100) {
278  if (pft1000info->usbboot == 2) {
279  status = ft1000_read_dpram32(ft1000dev, 0,
280  (u8 *)&(pft1000info->tempbuf[0]), 64);
281  for (temp = 0; temp < 16; temp++) {
282  DEBUG("tempbuf %d = 0x%x\n", temp,
283  pft1000info->tempbuf[temp]);
284  }
285  status = ft1000_read_dpram16(ft1000dev,
286  DWNLD_MAG1_HANDSHAKE_LOC,
287  (u8 *)&handshake, 1);
288  DEBUG("handshake from read_dpram16 = 0x%x\n",
289  handshake);
290  if (pft1000info->dspalive == pft1000info->tempbuf[6]) {
291  handshake = 0;
292  } else {
293  handshake = pft1000info->tempbuf[1];
294  pft1000info->dspalive =
295  pft1000info->tempbuf[6];
296  }
297  } else {
298  status = ft1000_read_dpram16(ft1000dev,
299  DWNLD_MAG1_HANDSHAKE_LOC,
300  (u8 *)&handshake, 1);
301  }
302 
303  loopcnt++;
304  msleep(10);
305  handshake = ntohs(handshake);
306  if ((handshake == expected_value) ||
307  (handshake == HANDSHAKE_RESET_VALUE_USB))
308  return handshake;
309  }
310 
311  return HANDSHAKE_TIMEOUT_VALUE;
312 }
313 
314 static void put_handshake_usb(struct ft1000_device *ft1000dev,u16 handshake_value)
315 {
316  int i;
317 
318  for (i=0; i<1000; i++);
319 }
320 
321 //---------------------------------------------------------------------------
322 // Function: get_request_type
323 //
324 // Parameters: struct ft1000_device - device structure
325 //
326 // Returns: request type - success
327 //
328 // Description: This function returns the request type
329 //
330 // Notes:
331 //
332 //---------------------------------------------------------------------------
333 static u16 get_request_type(struct ft1000_device *ft1000dev)
334 {
335  u16 request_type;
336  u32 status;
337  u16 tempword;
338  u32 tempx;
339  struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net);
340 
341  if (pft1000info->bootmode == 1) {
342  status = fix_ft1000_read_dpram32(ft1000dev,
343  DWNLD_MAG1_TYPE_LOC, (u8 *)&tempx);
344  tempx = ntohl(tempx);
345  } else {
346  tempx = 0;
347  status = ft1000_read_dpram16(ft1000dev,
348  DWNLD_MAG1_TYPE_LOC, (u8 *)&tempword, 1);
349  tempx |= (tempword << 16);
350  tempx = ntohl(tempx);
351  }
352  request_type = (u16)tempx;
353 
354  return request_type;
355 }
356 
357 static u16 get_request_type_usb(struct ft1000_device *ft1000dev)
358 {
359  u16 request_type;
360  u32 status;
361  u16 tempword;
362  u32 tempx;
363  struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net);
364 
365  if (pft1000info->bootmode == 1) {
366  status = fix_ft1000_read_dpram32(ft1000dev,
367  DWNLD_MAG1_TYPE_LOC, (u8 *)&tempx);
368  tempx = ntohl(tempx);
369  } else {
370  if (pft1000info->usbboot == 2) {
371  tempx = pft1000info->tempbuf[2];
372  tempword = pft1000info->tempbuf[3];
373  } else {
374  tempx = 0;
375  status = ft1000_read_dpram16(ft1000dev,
376  DWNLD_MAG1_TYPE_LOC,
377  (u8 *)&tempword, 1);
378  }
379  tempx |= (tempword << 16);
380  tempx = ntohl(tempx);
381  }
382  request_type = (u16)tempx;
383 
384  return request_type;
385 }
386 
387 //---------------------------------------------------------------------------
388 // Function: get_request_value
389 //
390 // Parameters: struct ft1000_device - device structure
391 //
392 // Returns: request value - success
393 //
394 // Description: This function returns the request value
395 //
396 // Notes:
397 //
398 //---------------------------------------------------------------------------
399 static long get_request_value(struct ft1000_device *ft1000dev)
400 {
401  u32 value;
402  u16 tempword;
403  u32 status;
404  struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net);
405 
406  if (pft1000info->bootmode == 1) {
407  status = fix_ft1000_read_dpram32(ft1000dev,
408  DWNLD_MAG1_SIZE_LOC, (u8 *)&value);
409  value = ntohl(value);
410  } else {
411  status = ft1000_read_dpram16(ft1000dev,
412  DWNLD_MAG1_SIZE_LOC, (u8 *)&tempword, 0);
413  value = tempword;
414  status = ft1000_read_dpram16(ft1000dev,
415  DWNLD_MAG1_SIZE_LOC, (u8 *)&tempword, 1);
416  value |= (tempword << 16);
417  value = ntohl(value);
418  }
419 
420  return value;
421 }
422 
423 
424 //---------------------------------------------------------------------------
425 // Function: put_request_value
426 //
427 // Parameters: struct ft1000_device - device structure
428 // long lvalue - value to be put into DPRAM location DWNLD_MAG1_SIZE_LOC
429 //
430 // Returns: none
431 //
432 // Description: This function writes a value to DWNLD_MAG1_SIZE_LOC
433 //
434 // Notes:
435 //
436 //---------------------------------------------------------------------------
437 static void put_request_value(struct ft1000_device *ft1000dev, long lvalue)
438 {
439  u32 tempx;
440  u32 status;
441 
442  tempx = ntohl(lvalue);
443  status = fix_ft1000_write_dpram32(ft1000dev, DWNLD_MAG1_SIZE_LOC,
444  (u8 *)&tempx);
445 }
446 
447 
448 
449 //---------------------------------------------------------------------------
450 // Function: hdr_checksum
451 //
452 // Parameters: struct pseudo_hdr *pHdr - Pseudo header pointer
453 //
454 // Returns: checksum - success
455 //
456 // Description: This function returns the checksum of the pseudo header
457 //
458 // Notes:
459 //
460 //---------------------------------------------------------------------------
461 static u16 hdr_checksum(struct pseudo_hdr *pHdr)
462 {
463  u16 *usPtr = (u16 *)pHdr;
464  u16 chksum;
465 
466 
467  chksum = ((((((usPtr[0] ^ usPtr[1]) ^ usPtr[2]) ^ usPtr[3]) ^
468  usPtr[4]) ^ usPtr[5]) ^ usPtr[6]);
469 
470  return chksum;
471 }
472 
473 static int check_buffers(u16 *buff_w, u16 *buff_r, int len, int offset)
474 {
475  int i;
476 
477  for (i = 0; i < len; i++) {
478  if (buff_w[i] != buff_r[i + offset])
479  return -1;
480  }
481 
482  return 0;
483 }
484 
485 //---------------------------------------------------------------------------
486 // Function: write_blk
487 //
488 // Parameters: struct ft1000_device - device structure
489 // u16 **pUsFile - DSP image file pointer in u16
490 // u8 **pUcFile - DSP image file pointer in u8
491 // long word_length - length of the buffer to be written
492 // to DPRAM
493 //
494 // Returns: STATUS_SUCCESS - success
495 // STATUS_FAILURE - failure
496 //
497 // Description: This function writes a block of DSP image to DPRAM
498 //
499 // Notes:
500 //
501 //---------------------------------------------------------------------------
502 static u32 write_blk (struct ft1000_device *ft1000dev, u16 **pUsFile, u8 **pUcFile, long word_length)
503 {
504  u32 Status = STATUS_SUCCESS;
505  u16 dpram;
506  int loopcnt, i, j;
507  u16 tempword;
508  u16 tempbuffer[64];
509  u16 resultbuffer[64];
510  struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net);
511 
512  //DEBUG("FT1000:download:start word_length = %d\n",(int)word_length);
513  dpram = (u16)DWNLD_MAG1_PS_HDR_LOC;
514  tempword = *(*pUsFile);
515  (*pUsFile)++;
516  Status = ft1000_write_dpram16(ft1000dev, dpram, tempword, 0);
517  tempword = *(*pUsFile);
518  (*pUsFile)++;
519  Status = ft1000_write_dpram16(ft1000dev, dpram++, tempword, 1);
520 
521  *pUcFile = *pUcFile + 4;
522  word_length--;
523  tempword = (u16)word_length;
524  word_length = (word_length / 16) + 1;
525  for (; word_length > 0; word_length--) /* In words */
526  {
527  loopcnt = 0;
528 
529  for (i=0; i<32; i++)
530  {
531  if (tempword != 0)
532  {
533  tempbuffer[i++] = *(*pUsFile);
534  (*pUsFile)++;
535  tempbuffer[i] = *(*pUsFile);
536  (*pUsFile)++;
537  *pUcFile = *pUcFile + 4;
538  loopcnt++;
539  tempword--;
540  }
541  else
542  {
543  tempbuffer[i++] = 0;
544  tempbuffer[i] = 0;
545  }
546  }
547 
548  //DEBUG("write_blk: loopcnt is %d\n", loopcnt);
549  //DEBUG("write_blk: bootmode = %d\n", bootmode);
550  //DEBUG("write_blk: dpram = %x\n", dpram);
551  if (pft1000info->bootmode == 0)
552  {
553  if (dpram >= 0x3F4)
554  Status = ft1000_write_dpram32 (ft1000dev, dpram, (u8 *)&tempbuffer[0], 8);
555  else
556  Status = ft1000_write_dpram32 (ft1000dev, dpram, (u8 *)&tempbuffer[0], 64);
557  }
558  else
559  {
560  for (j=0; j<10; j++)
561  {
562  Status = ft1000_write_dpram32 (ft1000dev, dpram, (u8 *)&tempbuffer[0], 64);
563  if (Status == STATUS_SUCCESS)
564  {
565  // Work around for ASIC bit stuffing problem.
566  if ( (tempbuffer[31] & 0xfe00) == 0xfe00)
567  {
568  Status = ft1000_write_dpram32(ft1000dev, dpram+12, (u8 *)&tempbuffer[24], 64);
569  }
570  // Let's check the data written
571  Status = ft1000_read_dpram32 (ft1000dev, dpram, (u8 *)&resultbuffer[0], 64);
572  if ( (tempbuffer[31] & 0xfe00) == 0xfe00)
573  {
574  if (check_buffers(tempbuffer, resultbuffer, 28, 0)) {
575  DEBUG("FT1000:download:DPRAM write failed 1 during bootloading\n");
576  msleep(10);
577  Status = STATUS_FAILURE;
578  break;
579  }
580  Status = ft1000_read_dpram32 (ft1000dev, dpram+12, (u8 *)&resultbuffer[0], 64);
581 
582  if (check_buffers(tempbuffer, resultbuffer, 16, 24)) {
583  DEBUG("FT1000:download:DPRAM write failed 2 during bootloading\n");
584  msleep(10);
585  Status = STATUS_FAILURE;
586  break;
587  }
588 
589  }
590  else
591  {
592  if (check_buffers(tempbuffer, resultbuffer, 32, 0)) {
593  DEBUG("FT1000:download:DPRAM write failed 3 during bootloading\n");
594  msleep(10);
595  Status = STATUS_FAILURE;
596  break;
597  }
598 
599  }
600 
601  if (Status == STATUS_SUCCESS)
602  break;
603 
604  }
605  }
606 
607  if (Status != STATUS_SUCCESS)
608  {
609  DEBUG("FT1000:download:Write failed tempbuffer[31] = 0x%x\n", tempbuffer[31]);
610  break;
611  }
612 
613  }
614  dpram = dpram + loopcnt;
615  }
616 
617  return Status;
618 }
619 
620 static void usb_dnld_complete (struct urb *urb)
621 {
622  //DEBUG("****** usb_dnld_complete\n");
623 }
624 
625 //---------------------------------------------------------------------------
626 // Function: write_blk_fifo
627 //
628 // Parameters: struct ft1000_device - device structure
629 // u16 **pUsFile - DSP image file pointer in u16
630 // u8 **pUcFile - DSP image file pointer in u8
631 // long word_length - length of the buffer to be written
632 // to DPRAM
633 //
634 // Returns: STATUS_SUCCESS - success
635 // STATUS_FAILURE - failure
636 //
637 // Description: This function writes a block of DSP image to DPRAM
638 //
639 // Notes:
640 //
641 //---------------------------------------------------------------------------
642 static u32 write_blk_fifo(struct ft1000_device *ft1000dev, u16 **pUsFile,
643  u8 **pUcFile, long word_length)
644 {
645  u32 Status = STATUS_SUCCESS;
646  int byte_length;
647 
648  byte_length = word_length * 4;
649 
650  if (byte_length && ((byte_length % 64) == 0))
651  byte_length += 4;
652 
653  if (byte_length < 64)
654  byte_length = 68;
655 
656  usb_init_urb(ft1000dev->tx_urb);
657  memcpy(ft1000dev->tx_buf, *pUcFile, byte_length);
658  usb_fill_bulk_urb(ft1000dev->tx_urb,
659  ft1000dev->dev,
660  usb_sndbulkpipe(ft1000dev->dev,
661  ft1000dev->bulk_out_endpointAddr),
662  ft1000dev->tx_buf, byte_length, usb_dnld_complete,
663  (void *)ft1000dev);
664 
665  usb_submit_urb(ft1000dev->tx_urb, GFP_ATOMIC);
666 
667  *pUsFile = *pUsFile + (word_length << 1);
668  *pUcFile = *pUcFile + (word_length << 2);
669 
670  return Status;
671 }
672 
673 //---------------------------------------------------------------------------
674 //
675 // Function: scram_dnldr
676 //
677 // Synopsis: Scramble downloader for Harley based ASIC via USB interface
678 //
679 // Arguments: pFileStart - pointer to start of file
680 // FileLength - file length
681 //
682 // Returns: status - return code
683 //---------------------------------------------------------------------------
684 
685 u16 scram_dnldr(struct ft1000_device *ft1000dev, void *pFileStart,
686  u32 FileLength)
687 {
688  u16 status = STATUS_SUCCESS;
689  u32 state;
690  u16 handshake;
691  struct pseudo_hdr *pseudo_header;
692  u16 pseudo_header_len;
693  long word_length;
694  u16 request;
695  u16 temp;
696  u16 tempword;
697 
698  struct dsp_file_hdr *file_hdr;
699  struct dsp_image_info *dsp_img_info = NULL;
700  long requested_version;
701  bool correct_version;
702  struct drv_msg *mailbox_data;
703  u16 *data = NULL;
704  u16 *s_file = NULL;
705  u8 *c_file = NULL;
706  u8 *boot_end = NULL, *code_end = NULL;
707  int image;
708  long loader_code_address, loader_code_size = 0;
709  long run_address = 0, run_size = 0;
710 
711  u32 templong;
712  u32 image_chksum = 0;
713 
714  u16 dpram = 0;
715  u8 *pbuffer;
716  struct prov_record *pprov_record;
717  struct ft1000_info *pft1000info = netdev_priv(ft1000dev->net);
718 
719  DEBUG("Entered scram_dnldr...\n");
720 
721  pft1000info->fcodeldr = 0;
722  pft1000info->usbboot = 0;
723  pft1000info->dspalive = 0xffff;
724 
725  //
726  // Get version id of file, at first 4 bytes of file, for newer files.
727  //
728 
729  state = STATE_START_DWNLD;
730 
731  file_hdr = (struct dsp_file_hdr *)pFileStart;
732 
733  ft1000_write_register(ft1000dev, 0x800, FT1000_REG_MAG_WATERMARK);
734 
735  s_file = (u16 *) (pFileStart + file_hdr->loader_offset);
736  c_file = (u8 *) (pFileStart + file_hdr->loader_offset);
737 
738  boot_end = (u8 *) (pFileStart + file_hdr->loader_code_end);
739 
740  loader_code_address = file_hdr->loader_code_address;
741  loader_code_size = file_hdr->loader_code_size;
742  correct_version = FALSE;
743 
744  while ((status == STATUS_SUCCESS) && (state != STATE_DONE_FILE)) {
745  switch (state) {
746  case STATE_START_DWNLD:
747  DEBUG("FT1000:STATE_START_DWNLD\n");
748  if (pft1000info->usbboot)
749  handshake =
750  get_handshake_usb(ft1000dev,
751  HANDSHAKE_DSP_BL_READY);
752  else
753  handshake =
754  get_handshake(ft1000dev,
755  HANDSHAKE_DSP_BL_READY);
756 
757  if (handshake == HANDSHAKE_DSP_BL_READY) {
758  DEBUG
759  ("scram_dnldr: handshake is HANDSHAKE_DSP_BL_READY, call put_handshake(HANDSHAKE_DRIVER_READY)\n");
760  put_handshake(ft1000dev,
761  HANDSHAKE_DRIVER_READY);
762  } else {
763  DEBUG
764  ("FT1000:download:Download error: Handshake failed\n");
765  status = STATUS_FAILURE;
766  }
767 
768  state = STATE_BOOT_DWNLD;
769 
770  break;
771 
772  case STATE_BOOT_DWNLD:
773  DEBUG("FT1000:STATE_BOOT_DWNLD\n");
774  pft1000info->bootmode = 1;
775  handshake = get_handshake(ft1000dev, HANDSHAKE_REQUEST);
776  if (handshake == HANDSHAKE_REQUEST) {
777  /*
778  * Get type associated with the request.
779  */
780  request = get_request_type(ft1000dev);
781  switch (request) {
782  case REQUEST_RUN_ADDRESS:
783  DEBUG("FT1000:REQUEST_RUN_ADDRESS\n");
784  put_request_value(ft1000dev,
785  loader_code_address);
786  break;
787  case REQUEST_CODE_LENGTH:
788  DEBUG("FT1000:REQUEST_CODE_LENGTH\n");
789  put_request_value(ft1000dev,
790  loader_code_size);
791  break;
792  case REQUEST_DONE_BL:
793  DEBUG("FT1000:REQUEST_DONE_BL\n");
794  /* Reposition ptrs to beginning of code section */
795  s_file = (u16 *) (boot_end);
796  c_file = (u8 *) (boot_end);
797  //DEBUG("FT1000:download:s_file = 0x%8x\n", (int)s_file);
798  //DEBUG("FT1000:download:c_file = 0x%8x\n", (int)c_file);
799  state = STATE_CODE_DWNLD;
800  pft1000info->fcodeldr = 1;
801  break;
802  case REQUEST_CODE_SEGMENT:
803  //DEBUG("FT1000:REQUEST_CODE_SEGMENT\n");
804  word_length =
805  get_request_value(ft1000dev);
806  //DEBUG("FT1000:word_length = 0x%x\n", (int)word_length);
807  //NdisMSleep (100);
808  if (word_length > MAX_LENGTH) {
809  DEBUG
810  ("FT1000:download:Download error: Max length exceeded\n");
811  status = STATUS_FAILURE;
812  break;
813  }
814  if ((word_length * 2 + c_file) >
815  boot_end) {
816  /*
817  * Error, beyond boot code range.
818  */
819  DEBUG
820  ("FT1000:download:Download error: Requested len=%d exceeds BOOT code boundary.\n",
821  (int)word_length);
822  status = STATUS_FAILURE;
823  break;
824  }
825  /*
826  * Position ASIC DPRAM auto-increment pointer.
827  */
828  dpram = (u16) DWNLD_MAG1_PS_HDR_LOC;
829  if (word_length & 0x1)
830  word_length++;
831  word_length = word_length / 2;
832 
833  status =
834  write_blk(ft1000dev, &s_file,
835  &c_file, word_length);
836  //DEBUG("write_blk returned %d\n", status);
837  break;
838  default:
839  DEBUG
840  ("FT1000:download:Download error: Bad request type=%d in BOOT download state.\n",
841  request);
842  status = STATUS_FAILURE;
843  break;
844  }
845  if (pft1000info->usbboot)
846  put_handshake_usb(ft1000dev,
847  HANDSHAKE_RESPONSE);
848  else
849  put_handshake(ft1000dev,
850  HANDSHAKE_RESPONSE);
851  } else {
852  DEBUG
853  ("FT1000:download:Download error: Handshake failed\n");
854  status = STATUS_FAILURE;
855  }
856 
857  break;
858 
859  case STATE_CODE_DWNLD:
860  //DEBUG("FT1000:STATE_CODE_DWNLD\n");
861  pft1000info->bootmode = 0;
862  if (pft1000info->usbboot)
863  handshake =
864  get_handshake_usb(ft1000dev,
865  HANDSHAKE_REQUEST);
866  else
867  handshake =
868  get_handshake(ft1000dev, HANDSHAKE_REQUEST);
869  if (handshake == HANDSHAKE_REQUEST) {
870  /*
871  * Get type associated with the request.
872  */
873  if (pft1000info->usbboot)
874  request =
875  get_request_type_usb(ft1000dev);
876  else
877  request = get_request_type(ft1000dev);
878  switch (request) {
879  case REQUEST_FILE_CHECKSUM:
880  DEBUG
881  ("FT1000:download:image_chksum = 0x%8x\n",
882  image_chksum);
883  put_request_value(ft1000dev,
884  image_chksum);
885  break;
886  case REQUEST_RUN_ADDRESS:
887  DEBUG
888  ("FT1000:download: REQUEST_RUN_ADDRESS\n");
889  if (correct_version) {
890  DEBUG
891  ("FT1000:download:run_address = 0x%8x\n",
892  (int)run_address);
893  put_request_value(ft1000dev,
894  run_address);
895  } else {
896  DEBUG
897  ("FT1000:download:Download error: Got Run address request before image offset request.\n");
898  status = STATUS_FAILURE;
899  break;
900  }
901  break;
902  case REQUEST_CODE_LENGTH:
903  DEBUG
904  ("FT1000:download:REQUEST_CODE_LENGTH\n");
905  if (correct_version) {
906  DEBUG
907  ("FT1000:download:run_size = 0x%8x\n",
908  (int)run_size);
909  put_request_value(ft1000dev,
910  run_size);
911  } else {
912  DEBUG
913  ("FT1000:download:Download error: Got Size request before image offset request.\n");
914  status = STATUS_FAILURE;
915  break;
916  }
917  break;
918  case REQUEST_DONE_CL:
919  pft1000info->usbboot = 3;
920  /* Reposition ptrs to beginning of provisioning section */
921  s_file =
922  (u16 *) (pFileStart +
923  file_hdr->commands_offset);
924  c_file =
925  (u8 *) (pFileStart +
926  file_hdr->commands_offset);
927  state = STATE_DONE_DWNLD;
928  break;
929  case REQUEST_CODE_SEGMENT:
930  //DEBUG("FT1000:download: REQUEST_CODE_SEGMENT - CODELOADER\n");
931  if (!correct_version) {
932  DEBUG
933  ("FT1000:download:Download error: Got Code Segment request before image offset request.\n");
934  status = STATUS_FAILURE;
935  break;
936  }
937 
938  word_length =
939  get_request_value(ft1000dev);
940  //DEBUG("FT1000:download:word_length = %d\n", (int)word_length);
941  if (word_length > MAX_LENGTH) {
942  DEBUG
943  ("FT1000:download:Download error: Max length exceeded\n");
944  status = STATUS_FAILURE;
945  break;
946  }
947  if ((word_length * 2 + c_file) >
948  code_end) {
949  /*
950  * Error, beyond boot code range.
951  */
952  DEBUG
953  ("FT1000:download:Download error: Requested len=%d exceeds DSP code boundary.\n",
954  (int)word_length);
955  status = STATUS_FAILURE;
956  break;
957  }
958  /*
959  * Position ASIC DPRAM auto-increment pointer.
960  */
961  dpram = (u16) DWNLD_MAG1_PS_HDR_LOC;
962  if (word_length & 0x1)
963  word_length++;
964  word_length = word_length / 2;
965 
966  write_blk_fifo(ft1000dev, &s_file,
967  &c_file, word_length);
968  if (pft1000info->usbboot == 0)
969  pft1000info->usbboot++;
970  if (pft1000info->usbboot == 1) {
971  tempword = 0;
972  ft1000_write_dpram16(ft1000dev,
973  DWNLD_MAG1_PS_HDR_LOC,
974  tempword,
975  0);
976  }
977 
978  break;
979 
980  case REQUEST_MAILBOX_DATA:
981  DEBUG
982  ("FT1000:download: REQUEST_MAILBOX_DATA\n");
983  // Convert length from byte count to word count. Make sure we round up.
984  word_length =
985  (long)(pft1000info->DSPInfoBlklen +
986  1) / 2;
987  put_request_value(ft1000dev,
988  word_length);
989  mailbox_data =
990  (struct drv_msg *)&(pft1000info->
991  DSPInfoBlk[0]);
992  /*
993  * Position ASIC DPRAM auto-increment pointer.
994  */
995 
996  data = (u16 *) & mailbox_data->data[0];
997  dpram = (u16) DWNLD_MAG1_PS_HDR_LOC;
998  if (word_length & 0x1)
999  word_length++;
1000 
1001  word_length = (word_length / 2);
1002 
1003  for (; word_length > 0; word_length--) { /* In words */
1004 
1005  templong = *data++;
1006  templong |= (*data++ << 16);
1007  status =
1008  fix_ft1000_write_dpram32
1009  (ft1000dev, dpram++,
1010  (u8 *) & templong);
1011 
1012  }
1013  break;
1014 
1015  case REQUEST_VERSION_INFO:
1016  DEBUG
1017  ("FT1000:download:REQUEST_VERSION_INFO\n");
1018  word_length =
1019  file_hdr->version_data_size;
1020  put_request_value(ft1000dev,
1021  word_length);
1022  /*
1023  * Position ASIC DPRAM auto-increment pointer.
1024  */
1025 
1026  s_file =
1027  (u16 *) (pFileStart +
1028  file_hdr->
1029  version_data_offset);
1030 
1031  dpram = (u16) DWNLD_MAG1_PS_HDR_LOC;
1032  if (word_length & 0x1)
1033  word_length++;
1034 
1035  word_length = (word_length / 2);
1036 
1037  for (; word_length > 0; word_length--) { /* In words */
1038 
1039  templong = ntohs(*s_file++);
1040  temp = ntohs(*s_file++);
1041  templong |= (temp << 16);
1042  status =
1043  fix_ft1000_write_dpram32
1044  (ft1000dev, dpram++,
1045  (u8 *) & templong);
1046 
1047  }
1048  break;
1049 
1050  case REQUEST_CODE_BY_VERSION:
1051  DEBUG
1052  ("FT1000:download:REQUEST_CODE_BY_VERSION\n");
1053  correct_version = FALSE;
1054  requested_version =
1055  get_request_value(ft1000dev);
1056 
1057  dsp_img_info =
1058  (struct dsp_image_info *)(pFileStart
1059  +
1060  sizeof
1061  (struct
1062  dsp_file_hdr));
1063 
1064  for (image = 0;
1065  image < file_hdr->nDspImages;
1066  image++) {
1067 
1068  if (dsp_img_info->version ==
1069  requested_version) {
1070  correct_version = TRUE;
1071  DEBUG
1072  ("FT1000:download: correct_version is TRUE\n");
1073  s_file =
1074  (u16 *) (pFileStart
1075  +
1076  dsp_img_info->
1077  begin_offset);
1078  c_file =
1079  (u8 *) (pFileStart +
1080  dsp_img_info->
1081  begin_offset);
1082  code_end =
1083  (u8 *) (pFileStart +
1084  dsp_img_info->
1085  end_offset);
1086  run_address =
1087  dsp_img_info->
1088  run_address;
1089  run_size =
1090  dsp_img_info->
1091  image_size;
1092  image_chksum =
1093  (u32) dsp_img_info->
1094  checksum;
1095  break;
1096  }
1097  dsp_img_info++;
1098 
1099  } //end of for
1100 
1101  if (!correct_version) {
1102  /*
1103  * Error, beyond boot code range.
1104  */
1105  DEBUG
1106  ("FT1000:download:Download error: Bad Version Request = 0x%x.\n",
1107  (int)requested_version);
1108  status = STATUS_FAILURE;
1109  break;
1110  }
1111  break;
1112 
1113  default:
1114  DEBUG
1115  ("FT1000:download:Download error: Bad request type=%d in CODE download state.\n",
1116  request);
1117  status = STATUS_FAILURE;
1118  break;
1119  }
1120  if (pft1000info->usbboot)
1121  put_handshake_usb(ft1000dev,
1122  HANDSHAKE_RESPONSE);
1123  else
1124  put_handshake(ft1000dev,
1125  HANDSHAKE_RESPONSE);
1126  } else {
1127  DEBUG
1128  ("FT1000:download:Download error: Handshake failed\n");
1129  status = STATUS_FAILURE;
1130  }
1131 
1132  break;
1133 
1134  case STATE_DONE_DWNLD:
1135  DEBUG("FT1000:download:Code loader is done...\n");
1136  state = STATE_SECTION_PROV;
1137  break;
1138 
1139  case STATE_SECTION_PROV:
1140  DEBUG("FT1000:download:STATE_SECTION_PROV\n");
1141  pseudo_header = (struct pseudo_hdr *)c_file;
1142 
1143  if (pseudo_header->checksum ==
1144  hdr_checksum(pseudo_header)) {
1145  if (pseudo_header->portdest !=
1146  0x80 /* Dsp OAM */ ) {
1147  state = STATE_DONE_PROV;
1148  break;
1149  }
1150  pseudo_header_len = ntohs(pseudo_header->length); /* Byte length for PROV records */
1151 
1152  // Get buffer for provisioning data
1153  pbuffer =
1154  kmalloc((pseudo_header_len +
1155  sizeof(struct pseudo_hdr)),
1156  GFP_ATOMIC);
1157  if (pbuffer) {
1158  memcpy(pbuffer, (void *)c_file,
1159  (u32) (pseudo_header_len +
1160  sizeof(struct
1161  pseudo_hdr)));
1162  // link provisioning data
1163  pprov_record =
1164  kmalloc(sizeof(struct prov_record),
1165  GFP_ATOMIC);
1166  if (pprov_record) {
1167  pprov_record->pprov_data =
1168  pbuffer;
1169  list_add_tail(&pprov_record->
1170  list,
1171  &pft1000info->
1172  prov_list);
1173  // Move to next entry if available
1174  c_file =
1175  (u8 *) ((unsigned long)
1176  c_file +
1177  (u32) ((pseudo_header_len + 1) & 0xFFFFFFFE) + sizeof(struct pseudo_hdr));
1178  if ((unsigned long)(c_file) -
1179  (unsigned long)(pFileStart)
1180  >=
1181  (unsigned long)FileLength) {
1182  state = STATE_DONE_FILE;
1183  }
1184  } else {
1185  kfree(pbuffer);
1186  status = STATUS_FAILURE;
1187  }
1188  } else {
1189  status = STATUS_FAILURE;
1190  }
1191  } else {
1192  /* Checksum did not compute */
1193  status = STATUS_FAILURE;
1194  }
1195  DEBUG
1196  ("ft1000:download: after STATE_SECTION_PROV, state = %d, status= %d\n",
1197  state, status);
1198  break;
1199 
1200  case STATE_DONE_PROV:
1201  DEBUG("FT1000:download:STATE_DONE_PROV\n");
1202  state = STATE_DONE_FILE;
1203  break;
1204 
1205  default:
1206  status = STATUS_FAILURE;
1207  break;
1208  } /* End Switch */
1209 
1210  if (status != STATUS_SUCCESS) {
1211  break;
1212  }
1213 
1214 /****
1215  // Check if Card is present
1216  status = Harley_Read_Register(&temp, FT1000_REG_SUP_IMASK);
1217  if ( (status != NDIS_STATUS_SUCCESS) || (temp == 0x0000) ) {
1218  break;
1219  }
1220 
1221  status = Harley_Read_Register(&temp, FT1000_REG_ASIC_ID);
1222  if ( (status != NDIS_STATUS_SUCCESS) || (temp == 0xffff) ) {
1223  break;
1224  }
1225 ****/
1226 
1227  } /* End while */
1228 
1229  DEBUG("Download exiting with status = 0x%8x\n", status);
1230  ft1000_write_register(ft1000dev, FT1000_DB_DNLD_TX,
1231  FT1000_REG_DOORBELL);
1232 
1233  return status;
1234 }
1235 
Generated on Thu Jan 10 2013 14:28:24 for Linux Kernel by   doxygen 1.8.2