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