]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - drivers/staging/ft1000/ft1000-usb/ft1000_hw.c
projects / mirror_ubuntu-zesty-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
pinctrl: sirf: move sgpio lock into state container
[mirror_ubuntu-zesty-kernel.git] / drivers / staging / ft1000 / ft1000-usb / ft1000_hw.c
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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, (void *)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 */
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. */
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
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
455 ft1000dev->fCondResetPend = true;
456 info->CardReady = 0;
457 ft1000dev->fProvComplete = false;
458
459 /* Make sure we free any memory reserve for provisioning */
460 while (list_empty(&info->prov_list) == 0) {
461 pr_debug("deleting provisioning record\n");
462 ptr =
463 list_entry(info->prov_list.next, struct prov_record, list);
464 list_del(&ptr->list);
465 kfree(ptr->pprov_data);
466 kfree(ptr);
467 }
468
469 pr_debug("reset asic\n");
470 ft1000_reset_asic(dev);
471
472 pr_debug("call dsp_reload\n");
473 dsp_reload(ft1000dev);
474
475 pr_debug("dsp reload successful\n");
476
477 mdelay(10);
478
479 /* Initialize DSP heartbeat area */
480 ft1000_write_dpram16(ft1000dev, FT1000_MAG_HI_HO, ho_mag,
481 FT1000_MAG_HI_HO_INDX);
482 ft1000_read_dpram16(ft1000dev, FT1000_MAG_HI_HO, (u8 *)&tempword,
483 FT1000_MAG_HI_HO_INDX);
484 pr_debug("hi_ho value = 0x%x\n", tempword);
485
486 info->CardReady = 1;
487
488 ft1000dev->fCondResetPend = false;
489
490 return TRUE;
491 }
492
493 /* callback function when a urb is transmitted */
494 static void ft1000_usb_transmit_complete(struct urb *urb)
495 {
496
497 struct ft1000_usb *ft1000dev = urb->context;
498
499 if (urb->status)
500 pr_err("%s: TX status %d\n", ft1000dev->net->name, urb->status);
501
502 netif_wake_queue(ft1000dev->net);
503 }
504
505 /* take an ethernet packet and convert it to a Flarion
506 * packet prior to sending it to the ASIC Downlink FIFO.
507 */
508 static int ft1000_copy_down_pkt(struct net_device *netdev, u8 *packet, u16 len)
509 {
510 struct ft1000_info *pInfo = netdev_priv(netdev);
511 struct ft1000_usb *pFt1000Dev = pInfo->priv;
512
513 int count, ret;
514 u8 *t;
515 struct pseudo_hdr hdr;
516
517 if (!pInfo->CardReady) {
518 pr_debug("Card Not Ready\n");
519 return -ENODEV;
520 }
521
522 count = sizeof(struct pseudo_hdr) + len;
523 if (count > MAX_BUF_SIZE) {
524 pr_debug("Message Size Overflow! size = %d\n", count);
525 return -EINVAL;
526 }
527
528 if (count % 4)
529 count = count + (4 - (count % 4));
530
531 memset(&hdr, 0, sizeof(struct pseudo_hdr));
532
533 hdr.length = ntohs(count);
534 hdr.source = 0x10;
535 hdr.destination = 0x20;
536 hdr.portdest = 0x20;
537 hdr.portsrc = 0x10;
538 hdr.sh_str_id = 0x91;
539 hdr.control = 0x00;
540
541 hdr.checksum = hdr.length ^ hdr.source ^ hdr.destination ^
542 hdr.portdest ^ hdr.portsrc ^ hdr.sh_str_id ^ hdr.control;
543
544 memcpy(&pFt1000Dev->tx_buf[0], &hdr, sizeof(hdr));
545 memcpy(&(pFt1000Dev->tx_buf[sizeof(struct pseudo_hdr)]), packet, len);
546
547 netif_stop_queue(netdev);
548
549 usb_fill_bulk_urb(pFt1000Dev->tx_urb,
550 pFt1000Dev->dev,
551 usb_sndbulkpipe(pFt1000Dev->dev,
552 pFt1000Dev->bulk_out_endpointAddr),
553 pFt1000Dev->tx_buf, count,
554 ft1000_usb_transmit_complete, (void *)pFt1000Dev);
555
556 t = (u8 *)pFt1000Dev->tx_urb->transfer_buffer;
557
558 ret = usb_submit_urb(pFt1000Dev->tx_urb, GFP_ATOMIC);
559
560 if (ret) {
561 pr_debug("failed tx_urb %d\n", ret);
562 return ret;
563 }
564 pInfo->stats.tx_packets++;
565 pInfo->stats.tx_bytes += (len + 14);
566
567 return 0;
568 }
569
570 /* transmit an ethernet packet
571 * Parameters: skb - socket buffer to be sent
572 * dev - network device
573 */
574 static int ft1000_start_xmit(struct sk_buff *skb, struct net_device *dev)
575 {
576 struct ft1000_info *pInfo = netdev_priv(dev);
577 struct ft1000_usb *pFt1000Dev = pInfo->priv;
578 u8 *pdata;
579 int maxlen, pipe;
580
581 if (skb == NULL) {
582 pr_debug("skb == NULL!!!\n");
583 return NETDEV_TX_OK;
584 }
585
586 if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
587 pr_debug("network driver is closed, return\n");
588 goto err;
589 }
590
591 pipe =
592 usb_sndbulkpipe(pFt1000Dev->dev, pFt1000Dev->bulk_out_endpointAddr);
593 maxlen = usb_maxpacket(pFt1000Dev->dev, pipe, usb_pipeout(pipe));
594
595 pdata = (u8 *)skb->data;
596
597 if (pInfo->mediastate == 0) {
598 /* Drop packet is mediastate is down */
599 pr_debug("mediastate is down\n");
600 goto err;
601 }
602
603 if ((skb->len < ENET_HEADER_SIZE) || (skb->len > ENET_MAX_SIZE)) {
604 /* Drop packet which has invalid size */
605 pr_debug("invalid ethernet length\n");
606 goto err;
607 }
608
609 ft1000_copy_down_pkt(dev, (pdata + ENET_HEADER_SIZE - 2),
610 skb->len - ENET_HEADER_SIZE + 2);
611
612 err:
613 dev_kfree_skb(skb);
614
615 return NETDEV_TX_OK;
616 }
617
618 /* open the network driver */
619 static int ft1000_open(struct net_device *dev)
620 {
621 struct ft1000_info *pInfo = netdev_priv(dev);
622 struct ft1000_usb *pFt1000Dev = pInfo->priv;
623 struct timeval tv;
624
625 pr_debug("ft1000_open is called for card %d\n", pFt1000Dev->CardNumber);
626
627 pInfo->stats.rx_bytes = 0;
628 pInfo->stats.tx_bytes = 0;
629 pInfo->stats.rx_packets = 0;
630 pInfo->stats.tx_packets = 0;
631 do_gettimeofday(&tv);
632 pInfo->ConTm = tv.tv_sec;
633 pInfo->ProgConStat = 0;
634
635 netif_start_queue(dev);
636
637 netif_carrier_on(dev);
638
639 return ft1000_submit_rx_urb(pInfo);
640 }
641
642 static struct net_device_stats *ft1000_netdev_stats(struct net_device *dev)
643 {
644 struct ft1000_info *info = netdev_priv(dev);
645
646 return &(info->stats);
647 }
648
649 static const struct net_device_ops ftnet_ops = {
650 .ndo_open = &ft1000_open,
651 .ndo_stop = &ft1000_close,
652 .ndo_start_xmit = &ft1000_start_xmit,
653 .ndo_get_stats = &ft1000_netdev_stats,
654 };
655
656 /* initialize the network device */
657 static int ft1000_reset(void *dev)
658 {
659 ft1000_reset_card(dev);
660 return 0;
661 }
662
663 int init_ft1000_netdev(struct ft1000_usb *ft1000dev)
664 {
665 struct net_device *netdev;
666 struct ft1000_info *pInfo = NULL;
667 struct dpram_blk *pdpram_blk;
668 int i, ret_val;
669 struct list_head *cur, *tmp;
670 char card_nr[2];
671 u8 gCardIndex = 0;
672
673 netdev = alloc_etherdev(sizeof(struct ft1000_info));
674 if (!netdev) {
675 pr_debug("can not allocate network device\n");
676 return -ENOMEM;
677 }
678
679 pInfo = netdev_priv(netdev);
680
681 memset(pInfo, 0, sizeof(struct ft1000_info));
682
683 dev_alloc_name(netdev, netdev->name);
684
685 pr_debug("network device name is %s\n", netdev->name);
686
687 if (strncmp(netdev->name, "eth", 3) == 0) {
688 card_nr[0] = netdev->name[3];
689 card_nr[1] = '\0';
690 ret_val = kstrtou8(card_nr, 10, &gCardIndex);
691 if (ret_val) {
692 netdev_err(ft1000dev->net, "Can't parse netdev\n");
693 goto err_net;
694 }
695
696 ft1000dev->CardNumber = gCardIndex;
697 pr_debug("card number = %d\n", ft1000dev->CardNumber);
698 } else {
699 netdev_err(ft1000dev->net, "ft1000: Invalid device name\n");
700 ret_val = -ENXIO;
701 goto err_net;
702 }
703
704 memset(&pInfo->stats, 0, sizeof(struct net_device_stats));
705
706 spin_lock_init(&pInfo->dpram_lock);
707 pInfo->priv = ft1000dev;
708 pInfo->DrvErrNum = 0;
709 pInfo->registered = 1;
710 pInfo->ft1000_reset = ft1000_reset;
711 pInfo->mediastate = 0;
712 pInfo->fifo_cnt = 0;
713 ft1000dev->DeviceCreated = FALSE;
714 pInfo->CardReady = 0;
715 pInfo->DSP_TIME[0] = 0;
716 pInfo->DSP_TIME[1] = 0;
717 pInfo->DSP_TIME[2] = 0;
718 pInfo->DSP_TIME[3] = 0;
719 ft1000dev->fAppMsgPend = false;
720 ft1000dev->fCondResetPend = false;
721 ft1000dev->usbboot = 0;
722 ft1000dev->dspalive = 0;
723 memset(&ft1000dev->tempbuf[0], 0, sizeof(ft1000dev->tempbuf));
724
725 INIT_LIST_HEAD(&pInfo->prov_list);
726
727 INIT_LIST_HEAD(&ft1000dev->nodes.list);
728
729 netdev->netdev_ops = &ftnet_ops;
730
731 ft1000dev->net = netdev;
732
733 pr_debug("Initialize free_buff_lock and freercvpool\n");
734 spin_lock_init(&free_buff_lock);
735
736 /* initialize a list of buffers to be use for queuing
737 * up receive command data
738 */
739 INIT_LIST_HEAD(&freercvpool);
740
741 /* create list of free buffers */
742 for (i = 0; i < NUM_OF_FREE_BUFFERS; i++) {
743 /* Get memory for DPRAM_DATA link list */
744 pdpram_blk = kmalloc(sizeof(struct dpram_blk), GFP_KERNEL);
745 if (pdpram_blk == NULL) {
746 ret_val = -ENOMEM;
747 goto err_free;
748 }
749 /* Get a block of memory to store command data */
750 pdpram_blk->pbuffer = kmalloc(MAX_CMD_SQSIZE, GFP_KERNEL);
751 if (pdpram_blk->pbuffer == NULL) {
752 ret_val = -ENOMEM;
753 kfree(pdpram_blk);
754 goto err_free;
755 }
756 /* link provisioning data */
757 list_add_tail(&pdpram_blk->list, &freercvpool);
758 }
759 numofmsgbuf = NUM_OF_FREE_BUFFERS;
760
761 return 0;
762
763 err_free:
764 list_for_each_safe(cur, tmp, &freercvpool) {
765 pdpram_blk = list_entry(cur, struct dpram_blk, list);
766 list_del(&pdpram_blk->list);
767 kfree(pdpram_blk->pbuffer);
768 kfree(pdpram_blk);
769 }
770 err_net:
771 free_netdev(netdev);
772 return ret_val;
773 }
774
775 /* register the network driver */
776 int reg_ft1000_netdev(struct ft1000_usb *ft1000dev,
777 struct usb_interface *intf)
778 {
779 struct net_device *netdev;
780 struct ft1000_info *pInfo;
781 int rc;
782
783 netdev = ft1000dev->net;
784 pInfo = netdev_priv(ft1000dev->net);
785
786 ft1000_read_register(ft1000dev, &pInfo->AsicID, FT1000_REG_ASIC_ID);
787
788 usb_set_intfdata(intf, pInfo);
789 SET_NETDEV_DEV(netdev, &intf->dev);
790
791 rc = register_netdev(netdev);
792 if (rc) {
793 pr_debug("could not register network device\n");
794 free_netdev(netdev);
795 return rc;
796 }
797
798 ft1000_create_dev(ft1000dev);
799
800 pInfo->CardReady = 1;
801
802 return 0;
803 }
804
805 /* take a packet from the FIFO up link and
806 * convert it into an ethernet packet and deliver it to the IP stack
807 */
808 static int ft1000_copy_up_pkt(struct urb *urb)
809 {
810 struct ft1000_info *info = urb->context;
811 struct ft1000_usb *ft1000dev = info->priv;
812 struct net_device *net = ft1000dev->net;
813
814 u16 tempword;
815 u16 len;
816 u16 lena;
817 struct sk_buff *skb;
818 u16 i;
819 u8 *pbuffer = NULL;
820 u8 *ptemp = NULL;
821 u16 *chksum;
822
823 if (ft1000dev->status & FT1000_STATUS_CLOSING) {
824 pr_debug("network driver is closed, return\n");
825 return 0;
826 }
827 /* Read length */
828 len = urb->transfer_buffer_length;
829 lena = urb->actual_length;
830
831 chksum = (u16 *)ft1000dev->rx_buf;
832
833 tempword = *chksum++;
834 for (i = 1; i < 7; i++)
835 tempword ^= *chksum++;
836
837 if (tempword != *chksum) {
838 info->stats.rx_errors++;
839 ft1000_submit_rx_urb(info);
840 return -1;
841 }
842
843 skb = dev_alloc_skb(len + 12 + 2);
844
845 if (skb == NULL) {
846 pr_debug("No Network buffers available\n");
847 info->stats.rx_errors++;
848 ft1000_submit_rx_urb(info);
849 return -1;
850 }
851
852 pbuffer = (u8 *)skb_put(skb, len + 12);
853
854 /* subtract the number of bytes read already */
855 ptemp = pbuffer;
856
857 /* fake MAC address */
858 *pbuffer++ = net->dev_addr[0];
859 *pbuffer++ = net->dev_addr[1];
860 *pbuffer++ = net->dev_addr[2];
861 *pbuffer++ = net->dev_addr[3];
862 *pbuffer++ = net->dev_addr[4];
863 *pbuffer++ = net->dev_addr[5];
864 *pbuffer++ = 0x00;
865 *pbuffer++ = 0x07;
866 *pbuffer++ = 0x35;
867 *pbuffer++ = 0xff;
868 *pbuffer++ = 0xff;
869 *pbuffer++ = 0xfe;
870
871 memcpy(pbuffer, ft1000dev->rx_buf + sizeof(struct pseudo_hdr),
872 len - sizeof(struct pseudo_hdr));
873
874 skb->dev = net;
875
876 skb->protocol = eth_type_trans(skb, net);
877 skb->ip_summed = CHECKSUM_UNNECESSARY;
878 netif_rx(skb);
879
880 info->stats.rx_packets++;
881 /* Add on 12 bytes for MAC address which was removed */
882 info->stats.rx_bytes += (lena + 12);
883
884 ft1000_submit_rx_urb(info);
885
886 return 0;
887 }
888
889
890 /* the receiving function of the network driver */
891 static int ft1000_submit_rx_urb(struct ft1000_info *info)
892 {
893 int result;
894 struct ft1000_usb *pFt1000Dev = info->priv;
895
896 if (pFt1000Dev->status & FT1000_STATUS_CLOSING) {
897 pr_debug("network driver is closed, return\n");
898 return -ENODEV;
899 }
900
901 usb_fill_bulk_urb(pFt1000Dev->rx_urb,
902 pFt1000Dev->dev,
903 usb_rcvbulkpipe(pFt1000Dev->dev,
904 pFt1000Dev->bulk_in_endpointAddr),
905 pFt1000Dev->rx_buf, MAX_BUF_SIZE,
906 (usb_complete_t)ft1000_copy_up_pkt, info);
907
908 result = usb_submit_urb(pFt1000Dev->rx_urb, GFP_ATOMIC);
909
910 if (result) {
911 pr_err("submitting rx_urb %d failed\n", result);
912 return result;
913 }
914
915 return 0;
916 }
917
918 /* close the network driver */
919 int ft1000_close(struct net_device *net)
920 {
921 struct ft1000_info *pInfo = netdev_priv(net);
922 struct ft1000_usb *ft1000dev = pInfo->priv;
923
924 ft1000dev->status |= FT1000_STATUS_CLOSING;
925
926 pr_debug("pInfo=%p, ft1000dev=%p\n", pInfo, ft1000dev);
927 netif_carrier_off(net);
928 netif_stop_queue(net);
929 ft1000dev->status &= ~FT1000_STATUS_CLOSING;
930
931 pInfo->ProgConStat = 0xff;
932
933 return 0;
934 }
935
936 /* check if the device is presently available on the system. */
937 static int ft1000_chkcard(struct ft1000_usb *dev)
938 {
939 u16 tempword;
940 int status;
941
942 if (dev->fCondResetPend) {
943 pr_debug("Card is being reset, return FALSE\n");
944 return TRUE;
945 }
946 /* Mask register is used to check for device presence since it is never
947 * set to zero.
948 */
949 status = ft1000_read_register(dev, &tempword, FT1000_REG_SUP_IMASK);
950 if (tempword == 0) {
951 pr_debug("IMASK = 0 Card not detected\n");
952 return FALSE;
953 }
954 /* The system will return the value of 0xffff for the version register
955 * if the device is not present.
956 */
957 status = ft1000_read_register(dev, &tempword, FT1000_REG_ASIC_ID);
958 if (tempword != 0x1b01) {
959 dev->status |= FT1000_STATUS_CLOSING;
960 pr_debug("Version = 0xffff Card not detected\n");
961 return FALSE;
962 }
963 return TRUE;
964 }
965
966 /* read a message from the dpram area.
967 * Input:
968 * dev - network device structure
969 * pbuffer - caller supply address to buffer
970 */
971 static bool ft1000_receive_cmd(struct ft1000_usb *dev, u16 *pbuffer,
972 int maxsz)
973 {
974 u16 size;
975 int ret;
976 u16 *ppseudohdr;
977 int i;
978 u16 tempword;
979
980 ret =
981 ft1000_read_dpram16(dev, FT1000_MAG_PH_LEN, (u8 *)&size,
982 FT1000_MAG_PH_LEN_INDX);
983 size = ntohs(size) + PSEUDOSZ;
984 if (size > maxsz) {
985 pr_debug("Invalid command length = %d\n", size);
986 return FALSE;
987 }
988 ppseudohdr = (u16 *)pbuffer;
989 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE,
990 FT1000_REG_DPRAM_ADDR);
991 ret =
992 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
993 pbuffer++;
994 ft1000_write_register(dev, FT1000_DPRAM_MAG_RX_BASE + 1,
995 FT1000_REG_DPRAM_ADDR);
996 for (i = 0; i <= (size >> 2); i++) {
997 ret =
998 ft1000_read_register(dev, pbuffer,
999 FT1000_REG_MAG_DPDATAL);
1000 pbuffer++;
1001 ret =
1002 ft1000_read_register(dev, pbuffer,
1003 FT1000_REG_MAG_DPDATAH);
1004 pbuffer++;
1005 }
1006 /* copy odd aligned word */
1007 ret =
1008 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAL);
1009
1010 pbuffer++;
1011 ret =
1012 ft1000_read_register(dev, pbuffer, FT1000_REG_MAG_DPDATAH);
1013
1014 pbuffer++;
1015 if (size & 0x0001) {
1016 /* copy odd byte from fifo */
1017 ret =
1018 ft1000_read_register(dev, &tempword,
1019 FT1000_REG_DPRAM_DATA);
1020 *pbuffer = ntohs(tempword);
1021 }
1022 /* Check if pseudo header checksum is good
1023 * Calculate pseudo header checksum
1024 */
1025 tempword = *ppseudohdr++;
1026 for (i = 1; i < 7; i++)
1027 tempword ^= *ppseudohdr++;
1028
1029 if (tempword != *ppseudohdr)
1030 return FALSE;
1031
1032 return TRUE;
1033 }
1034
1035 static int ft1000_dsp_prov(void *arg)
1036 {
1037 struct ft1000_usb *dev = (struct ft1000_usb *)arg;
1038 struct ft1000_info *info = netdev_priv(dev->net);
1039 u16 tempword;
1040 u16 len;
1041 u16 i = 0;
1042 struct prov_record *ptr;
1043 struct pseudo_hdr *ppseudo_hdr;
1044 u16 *pmsg;
1045 int status;
1046 u16 TempShortBuf[256];
1047
1048 while (list_empty(&info->prov_list) == 0) {
1049 pr_debug("DSP Provisioning List Entry\n");
1050
1051 /* Check if doorbell is available */
1052 pr_debug("check if doorbell is cleared\n");
1053 status =
1054 ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1055 if (status) {
1056 pr_debug("ft1000_read_register error\n");
1057 break;
1058 }
1059
1060 while (tempword & FT1000_DB_DPRAM_TX) {
1061 mdelay(10);
1062 i++;
1063 if (i == 10) {
1064 pr_debug("message drop\n");
1065 return -1;
1066 }
1067 ft1000_read_register(dev, &tempword,
1068 FT1000_REG_DOORBELL);
1069 }
1070
1071 if (!(tempword & FT1000_DB_DPRAM_TX)) {
1072 pr_debug("*** Provision Data Sent to DSP\n");
1073
1074 /* Send provisioning data */
1075 ptr =
1076 list_entry(info->prov_list.next, struct prov_record,
1077 list);
1078 len = *(u16 *)ptr->pprov_data;
1079 len = htons(len);
1080 len += PSEUDOSZ;
1081
1082 pmsg = (u16 *)ptr->pprov_data;
1083 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1084 /* Insert slow queue sequence number */
1085 ppseudo_hdr->seq_num = info->squeseqnum++;
1086 ppseudo_hdr->portsrc = 0;
1087 /* Calculate new checksum */
1088 ppseudo_hdr->checksum = *pmsg++;
1089 for (i = 1; i < 7; i++)
1090 ppseudo_hdr->checksum ^= *pmsg++;
1091
1092 TempShortBuf[0] = 0;
1093 TempShortBuf[1] = htons(len);
1094 memcpy(&TempShortBuf[2], ppseudo_hdr, len);
1095
1096 status =
1097 ft1000_write_dpram32(dev, 0,
1098 (u8 *)&TempShortBuf[0],
1099 (unsigned short)(len + 2));
1100 status =
1101 ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1102 FT1000_REG_DOORBELL);
1103
1104 list_del(&ptr->list);
1105 kfree(ptr->pprov_data);
1106 kfree(ptr);
1107 }
1108 usleep_range(9000, 11000);
1109 }
1110
1111 pr_debug("DSP Provisioning List Entry finished\n");
1112
1113 msleep(100);
1114
1115 dev->fProvComplete = true;
1116 info->CardReady = 1;
1117
1118 return 0;
1119 }
1120
1121 static int ft1000_proc_drvmsg(struct ft1000_usb *dev, u16 size)
1122 {
1123 struct ft1000_info *info = netdev_priv(dev->net);
1124 u16 msgtype;
1125 u16 tempword;
1126 struct media_msg *pmediamsg;
1127 struct dsp_init_msg *pdspinitmsg;
1128 struct drv_msg *pdrvmsg;
1129 u16 i;
1130 struct pseudo_hdr *ppseudo_hdr;
1131 u16 *pmsg;
1132 int status;
1133 union {
1134 u8 byte[2];
1135 u16 wrd;
1136 } convert;
1137
1138 char *cmdbuffer = kmalloc(1600, GFP_KERNEL);
1139
1140 if (!cmdbuffer)
1141 return -ENOMEM;
1142
1143 status = ft1000_read_dpram32(dev, 0x200, cmdbuffer, size);
1144
1145 #ifdef JDEBUG
1146 print_hex_dump_debug("cmdbuffer: ", HEX_DUMP_OFFSET, 16, 1,
1147 cmdbuffer, size, true);
1148 #endif
1149 pdrvmsg = (struct drv_msg *)&cmdbuffer[2];
1150 msgtype = ntohs(pdrvmsg->type);
1151 pr_debug("Command message type = 0x%x\n", msgtype);
1152 switch (msgtype) {
1153 case MEDIA_STATE:{
1154 pr_debug("Command message type = MEDIA_STATE\n");
1155 pmediamsg = (struct media_msg *)&cmdbuffer[0];
1156 if (info->ProgConStat != 0xFF) {
1157 if (pmediamsg->state) {
1158 pr_debug("Media is up\n");
1159 if (info->mediastate == 0) {
1160 if (dev->NetDevRegDone)
1161 netif_wake_queue(dev->net);
1162 info->mediastate = 1;
1163 }
1164 } else {
1165 pr_debug("Media is down\n");
1166 if (info->mediastate == 1) {
1167 info->mediastate = 0;
1168 if (dev->NetDevRegDone)
1169 info->ConTm = 0;
1170 }
1171 }
1172 } else {
1173 pr_debug("Media is down\n");
1174 if (info->mediastate == 1) {
1175 info->mediastate = 0;
1176 info->ConTm = 0;
1177 }
1178 }
1179 break;
1180 }
1181 case DSP_INIT_MSG:{
1182 pr_debug("Command message type = DSP_INIT_MSG\n");
1183 pdspinitmsg = (struct dsp_init_msg *)&cmdbuffer[2];
1184 memcpy(info->DspVer, pdspinitmsg->DspVer, DSPVERSZ);
1185 pr_debug("DSPVER = 0x%2x 0x%2x 0x%2x 0x%2x\n",
1186 info->DspVer[0], info->DspVer[1], info->DspVer[2],
1187 info->DspVer[3]);
1188 memcpy(info->HwSerNum, pdspinitmsg->HwSerNum,
1189 HWSERNUMSZ);
1190 memcpy(info->Sku, pdspinitmsg->Sku, SKUSZ);
1191 memcpy(info->eui64, pdspinitmsg->eui64, EUISZ);
1192 pr_debug("EUI64=%2x.%2x.%2x.%2x.%2x.%2x.%2x.%2x\n",
1193 info->eui64[0], info->eui64[1], info->eui64[2],
1194 info->eui64[3], info->eui64[4], info->eui64[5],
1195 info->eui64[6], info->eui64[7]);
1196 dev->net->dev_addr[0] = info->eui64[0];
1197 dev->net->dev_addr[1] = info->eui64[1];
1198 dev->net->dev_addr[2] = info->eui64[2];
1199 dev->net->dev_addr[3] = info->eui64[5];
1200 dev->net->dev_addr[4] = info->eui64[6];
1201 dev->net->dev_addr[5] = info->eui64[7];
1202
1203 if (ntohs(pdspinitmsg->length) ==
1204 (sizeof(struct dsp_init_msg) - 20)) {
1205 memcpy(info->ProductMode, pdspinitmsg->ProductMode,
1206 MODESZ);
1207 memcpy(info->RfCalVer, pdspinitmsg->RfCalVer, CALVERSZ);
1208 memcpy(info->RfCalDate, pdspinitmsg->RfCalDate,
1209 CALDATESZ);
1210 pr_debug("RFCalVer = 0x%2x 0x%2x\n",
1211 info->RfCalVer[0], info->RfCalVer[1]);
1212 }
1213 break;
1214 }
1215 case DSP_PROVISION:{
1216 pr_debug("Command message type = DSP_PROVISION\n");
1217
1218 /* kick off dspprov routine to start provisioning
1219 * Send provisioning data to DSP
1220 */
1221 if (list_empty(&info->prov_list) == 0) {
1222 dev->fProvComplete = false;
1223 status = ft1000_dsp_prov(dev);
1224 if (status != 0)
1225 goto out;
1226 } else {
1227 dev->fProvComplete = true;
1228 status = ft1000_write_register(dev, FT1000_DB_HB,
1229 FT1000_REG_DOORBELL);
1230 pr_debug("No more DSP provisioning data in dsp image\n");
1231 }
1232 pr_debug("DSP PROVISION is done\n");
1233 break;
1234 }
1235 case DSP_STORE_INFO:{
1236 pr_debug("Command message type = DSP_STORE_INFO");
1237 tempword = ntohs(pdrvmsg->length);
1238 info->DSPInfoBlklen = tempword;
1239 if (tempword < (MAX_DSP_SESS_REC - 4)) {
1240 pmsg = (u16 *)&pdrvmsg->data[0];
1241 for (i = 0; i < ((tempword + 1) / 2); i++) {
1242 pr_debug("dsp info data = 0x%x\n", *pmsg);
1243 info->DSPInfoBlk[i + 10] = *pmsg++;
1244 }
1245 } else {
1246 info->DSPInfoBlklen = 0;
1247 }
1248 break;
1249 }
1250 case DSP_GET_INFO:{
1251 pr_debug("Got DSP_GET_INFO\n");
1252 /* copy dsp info block to dsp */
1253 dev->DrvMsgPend = 1;
1254 /* allow any outstanding ioctl to finish */
1255 mdelay(10);
1256 status = ft1000_read_register(dev, &tempword,
1257 FT1000_REG_DOORBELL);
1258 if (tempword & FT1000_DB_DPRAM_TX) {
1259 mdelay(10);
1260 status = ft1000_read_register(dev, &tempword,
1261 FT1000_REG_DOORBELL);
1262 if (tempword & FT1000_DB_DPRAM_TX) {
1263 mdelay(10);
1264 status = ft1000_read_register(dev, &tempword,
1265 FT1000_REG_DOORBELL);
1266 if (tempword & FT1000_DB_DPRAM_TX)
1267 break;
1268 }
1269 }
1270 /* Put message into Slow Queue Form Pseudo header */
1271 pmsg = (u16 *)info->DSPInfoBlk;
1272 *pmsg++ = 0;
1273 *pmsg++ = htons(info->DSPInfoBlklen + 20 + info->DSPInfoBlklen);
1274 ppseudo_hdr =
1275 (struct pseudo_hdr *)(u16 *)&info->DSPInfoBlk[2];
1276 ppseudo_hdr->length = htons(info->DSPInfoBlklen + 4
1277 + info->DSPInfoBlklen);
1278 ppseudo_hdr->source = 0x10;
1279 ppseudo_hdr->destination = 0x20;
1280 ppseudo_hdr->portdest = 0;
1281 ppseudo_hdr->portsrc = 0;
1282 ppseudo_hdr->sh_str_id = 0;
1283 ppseudo_hdr->control = 0;
1284 ppseudo_hdr->rsvd1 = 0;
1285 ppseudo_hdr->rsvd2 = 0;
1286 ppseudo_hdr->qos_class = 0;
1287 /* Insert slow queue sequence number */
1288 ppseudo_hdr->seq_num = info->squeseqnum++;
1289 /* Insert application id */
1290 ppseudo_hdr->portsrc = 0;
1291 /* Calculate new checksum */
1292 ppseudo_hdr->checksum = *pmsg++;
1293 for (i = 1; i < 7; i++)
1294 ppseudo_hdr->checksum ^= *pmsg++;
1295
1296 info->DSPInfoBlk[10] = 0x7200;
1297 info->DSPInfoBlk[11] = htons(info->DSPInfoBlklen);
1298 status = ft1000_write_dpram32(dev, 0,
1299 (u8 *)&info->DSPInfoBlk[0],
1300 (unsigned short)(info->DSPInfoBlklen + 22));
1301 status = ft1000_write_register(dev, FT1000_DB_DPRAM_TX,
1302 FT1000_REG_DOORBELL);
1303 dev->DrvMsgPend = 0;
1304 break;
1305 }
1306 case GET_DRV_ERR_RPT_MSG:{
1307 pr_debug("Got GET_DRV_ERR_RPT_MSG\n");
1308 /* copy driver error message to dsp */
1309 dev->DrvMsgPend = 1;
1310 /* allow any outstanding ioctl to finish */
1311 mdelay(10);
1312 status = ft1000_read_register(dev, &tempword,
1313 FT1000_REG_DOORBELL);
1314 if (tempword & FT1000_DB_DPRAM_TX) {
1315 mdelay(10);
1316 status = ft1000_read_register(dev, &tempword,
1317 FT1000_REG_DOORBELL);
1318 if (tempword & FT1000_DB_DPRAM_TX)
1319 mdelay(10);
1320 }
1321 if ((tempword & FT1000_DB_DPRAM_TX) == 0) {
1322 /* Put message into Slow Queue Form Pseudo header */
1323 pmsg = (u16 *)&tempbuffer[0];
1324 ppseudo_hdr = (struct pseudo_hdr *)pmsg;
1325 ppseudo_hdr->length = htons(0x0012);
1326 ppseudo_hdr->source = 0x10;
1327 ppseudo_hdr->destination = 0x20;
1328 ppseudo_hdr->portdest = 0;
1329 ppseudo_hdr->portsrc = 0;
1330 ppseudo_hdr->sh_str_id = 0;
1331 ppseudo_hdr->control = 0;
1332 ppseudo_hdr->rsvd1 = 0;
1333 ppseudo_hdr->rsvd2 = 0;
1334 ppseudo_hdr->qos_class = 0;
1335 /* Insert slow queue sequence number */
1336 ppseudo_hdr->seq_num = info->squeseqnum++;
1337 /* Insert application id */
1338 ppseudo_hdr->portsrc = 0;
1339 /* Calculate new checksum */
1340 ppseudo_hdr->checksum = *pmsg++;
1341 for (i = 1; i < 7; i++)
1342 ppseudo_hdr->checksum ^= *pmsg++;
1343
1344 pmsg = (u16 *)&tempbuffer[16];
1345 *pmsg++ = htons(RSP_DRV_ERR_RPT_MSG);
1346 *pmsg++ = htons(0x000e);
1347 *pmsg++ = htons(info->DSP_TIME[0]);
1348 *pmsg++ = htons(info->DSP_TIME[1]);
1349 *pmsg++ = htons(info->DSP_TIME[2]);
1350 *pmsg++ = htons(info->DSP_TIME[3]);
1351 convert.byte[0] = info->DspVer[0];
1352 convert.byte[1] = info->DspVer[1];
1353 *pmsg++ = convert.wrd;
1354 convert.byte[0] = info->DspVer[2];
1355 convert.byte[1] = info->DspVer[3];
1356 *pmsg++ = convert.wrd;
1357 *pmsg++ = htons(info->DrvErrNum);
1358
1359 status = card_send_command(dev, (unsigned char *)&tempbuffer[0],
1360 (u16)(0x0012 + PSEUDOSZ));
1361 if (status)
1362 goto out;
1363 info->DrvErrNum = 0;
1364 }
1365 dev->DrvMsgPend = 0;
1366 break;
1367 }
1368 default:
1369 break;
1370 }
1371
1372 status = 0;
1373 out:
1374 kfree(cmdbuffer);
1375 return status;
1376 }
1377
1378 /* Check which application has registered for dsp broadcast messages */
1379 static int dsp_broadcast_msg_id(struct ft1000_usb *dev)
1380 {
1381 struct dpram_blk *pdpram_blk;
1382 unsigned long flags;
1383 int i;
1384
1385 for (i = 0; i < MAX_NUM_APP; i++) {
1386 if ((dev->app_info[i].DspBCMsgFlag)
1387 && (dev->app_info[i].fileobject)
1388 && (dev->app_info[i].NumOfMsg
1389 < MAX_MSG_LIMIT)) {
1390 pdpram_blk = ft1000_get_buffer(&freercvpool);
1391 if (pdpram_blk == NULL) {
1392 pr_debug("Out of memory in free receive command pool\n");
1393 dev->app_info[i].nRxMsgMiss++;
1394 return -1;
1395 }
1396 if (ft1000_receive_cmd(dev, pdpram_blk->pbuffer,
1397 MAX_CMD_SQSIZE)) {
1398 /* Put message into the
1399 * appropriate application block
1400 */
1401 dev->app_info[i].nRxMsg++;
1402 spin_lock_irqsave(&free_buff_lock, flags);
1403 list_add_tail(&pdpram_blk->list,
1404 &dev->app_info[i] .app_sqlist);
1405 dev->app_info[i].NumOfMsg++;
1406 spin_unlock_irqrestore(&free_buff_lock, flags);
1407 wake_up_interruptible(&dev->app_info[i]
1408 .wait_dpram_msg);
1409 } else {
1410 dev->app_info[i].nRxMsgMiss++;
1411 ft1000_free_buffer(pdpram_blk, &freercvpool);
1412 pr_debug("ft1000_get_buffer NULL\n");
1413 return -1;
1414 }
1415 }
1416 }
1417 return 0;
1418 }
1419
1420 static int handle_misc_portid(struct ft1000_usb *dev)
1421 {
1422 struct dpram_blk *pdpram_blk;
1423 int i;
1424
1425 pdpram_blk = ft1000_get_buffer(&freercvpool);
1426 if (pdpram_blk == NULL) {
1427 pr_debug("Out of memory in free receive command pool\n");
1428 return -1;
1429 }
1430 if (!ft1000_receive_cmd(dev, pdpram_blk->pbuffer, MAX_CMD_SQSIZE))
1431 goto exit_failure;
1432
1433 /* Search for correct application block */
1434 for (i = 0; i < MAX_NUM_APP; i++) {
1435 if (dev->app_info[i].app_id == ((struct pseudo_hdr *)
1436 pdpram_blk->pbuffer)->portdest)
1437 break;
1438 }
1439 if (i == MAX_NUM_APP) {
1440 pr_debug("No application matching id = %d\n",
1441 ((struct pseudo_hdr *)pdpram_blk->pbuffer)->portdest);
1442 goto exit_failure;
1443 } else if (dev->app_info[i].NumOfMsg > MAX_MSG_LIMIT) {
1444 goto exit_failure;
1445 } else {
1446 dev->app_info[i].nRxMsg++;
1447 /* Put message into the appropriate application block */
1448 list_add_tail(&pdpram_blk->list, &dev->app_info[i].app_sqlist);
1449 dev->app_info[i].NumOfMsg++;
1450 }
1451 return 0;
1452
1453 exit_failure:
1454 ft1000_free_buffer(pdpram_blk, &freercvpool);
1455 return -1;
1456 }
1457
1458 int ft1000_poll(void *dev_id)
1459 {
1460 struct ft1000_usb *dev = (struct ft1000_usb *)dev_id;
1461 struct ft1000_info *info = netdev_priv(dev->net);
1462 u16 tempword;
1463 int status;
1464 u16 size;
1465 int i;
1466 u16 data;
1467 u16 modulo;
1468 u16 portid;
1469
1470 if (ft1000_chkcard(dev) == FALSE) {
1471 pr_debug("failed\n");
1472 return -1;
1473 }
1474 status = ft1000_read_register(dev, &tempword, FT1000_REG_DOORBELL);
1475 if (!status) {
1476 if (tempword & FT1000_DB_DPRAM_RX) {
1477 status = ft1000_read_dpram16(dev,
1478 0x200, (u8 *)&data, 0);
1479 size = ntohs(data) + 16 + 2;
1480 if (size % 4) {
1481 modulo = 4 - (size % 4);
1482 size = size + modulo;
1483 }
1484 status = ft1000_read_dpram16(dev, 0x201,
1485 (u8 *)&portid, 1);
1486 portid &= 0xff;
1487 if (size < MAX_CMD_SQSIZE) {
1488 switch (portid) {
1489 case DRIVERID:
1490 pr_debug("FT1000_REG_DOORBELL message type: FT1000_DB_DPRAM_RX : portid DRIVERID\n");
1491 status = ft1000_proc_drvmsg(dev, size);
1492 if (status != 0)
1493 return status;
1494 break;
1495 case DSPBCMSGID:
1496 status = dsp_broadcast_msg_id(dev);
1497 break;
1498 default:
1499 status = handle_misc_portid(dev);
1500 break;
1501 }
1502 } else
1503 pr_debug("Invalid total length for SlowQ = %d\n",
1504 size);
1505 status = ft1000_write_register(dev,
1506 FT1000_DB_DPRAM_RX,
1507 FT1000_REG_DOORBELL);
1508 } else if (tempword & FT1000_DSP_ASIC_RESET) {
1509 /* Let's reset the ASIC from the Host side as well */
1510 status = ft1000_write_register(dev, ASIC_RESET_BIT,
1511 FT1000_REG_RESET);
1512 status = ft1000_read_register(dev, &tempword,
1513 FT1000_REG_RESET);
1514 i = 0;
1515 while (tempword & ASIC_RESET_BIT) {
1516 status = ft1000_read_register(dev, &tempword,
1517 FT1000_REG_RESET);
1518 usleep_range(9000, 11000);
1519 i++;
1520 if (i == 100)
1521 break;
1522 }
1523 if (i == 100) {
1524 pr_debug("Unable to reset ASIC\n");
1525 return 0;
1526 }
1527 usleep_range(9000, 11000);
1528 /* Program WMARK register */
1529 status = ft1000_write_register(dev, 0x600,
1530 FT1000_REG_MAG_WATERMARK);
1531 /* clear ASIC reset doorbell */
1532 status = ft1000_write_register(dev,
1533 FT1000_DSP_ASIC_RESET,
1534 FT1000_REG_DOORBELL);
1535 usleep_range(9000, 11000);
1536 } else if (tempword & FT1000_ASIC_RESET_REQ) {
1537 pr_debug("FT1000_REG_DOORBELL message type: FT1000_ASIC_RESET_REQ\n");
1538 /* clear ASIC reset request from DSP */
1539 status = ft1000_write_register(dev,
1540 FT1000_ASIC_RESET_REQ,
1541 FT1000_REG_DOORBELL);
1542 status = ft1000_write_register(dev, HOST_INTF_BE,
1543 FT1000_REG_SUP_CTRL);
1544 /* copy dsp session record from Adapter block */
1545 status = ft1000_write_dpram32(dev, 0,
1546 (u8 *)&info->DSPSess.Rec[0], 1024);
1547 status = ft1000_write_register(dev, 0x600,
1548 FT1000_REG_MAG_WATERMARK);
1549 /* ring doorbell to tell DSP that
1550 * ASIC is out of reset
1551 * */
1552 status = ft1000_write_register(dev,
1553 FT1000_ASIC_RESET_DSP,
1554 FT1000_REG_DOORBELL);
1555 } else if (tempword & FT1000_DB_COND_RESET) {
1556 pr_debug("FT1000_REG_DOORBELL message type: FT1000_DB_COND_RESET\n");
1557 if (!dev->fAppMsgPend) {
1558 /* Reset ASIC and DSP */
1559 status = ft1000_read_dpram16(dev,
1560 FT1000_MAG_DSP_TIMER0,
1561 (u8 *)&(info->DSP_TIME[0]),
1562 FT1000_MAG_DSP_TIMER0_INDX);
1563 status = ft1000_read_dpram16(dev,
1564 FT1000_MAG_DSP_TIMER1,
1565 (u8 *)&(info->DSP_TIME[1]),
1566 FT1000_MAG_DSP_TIMER1_INDX);
1567 status = ft1000_read_dpram16(dev,
1568 FT1000_MAG_DSP_TIMER2,
1569 (u8 *)&(info->DSP_TIME[2]),
1570 FT1000_MAG_DSP_TIMER2_INDX);
1571 status = ft1000_read_dpram16(dev,
1572 FT1000_MAG_DSP_TIMER3,
1573 (u8 *)&(info->DSP_TIME[3]),
1574 FT1000_MAG_DSP_TIMER3_INDX);
1575 info->CardReady = 0;
1576 info->DrvErrNum = DSP_CONDRESET_INFO;
1577 pr_debug("DSP conditional reset requested\n");
1578 info->ft1000_reset(dev->net);
1579 } else {
1580 dev->fProvComplete = false;
1581 dev->fCondResetPend = true;
1582 }
1583 ft1000_write_register(dev, FT1000_DB_COND_RESET,
1584 FT1000_REG_DOORBELL);
1585 }
1586 }
1587 return 0;
1588 }
ubuntu-zesty-kernel mirror