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