?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / usb / Beceem_driver / src / Common / Bcmchar.c
blobf92f79c1c0039b4b050bd850e8880aa79bda8b1c
1 /*
2 * Bcmchar.c
3 *
4 *Copyright (C) 2010 Beceem Communications, Inc.
5 *
6 *This program is free software: you can redistribute it and/or modify
7 *it under the terms of the GNU General Public License version 2 as
8 *published by the Free Software Foundation.
9 *
10 *This program is distributed in the hope that it will be useful,but
11 *WITHOUT ANY WARRANTY; without even the implied warranty of
12 *MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 *See the GNU General Public License for more details.
14 *
15 *You should have received a copy of the GNU General Public License
16 *along with this program. If not, write to the Free Software Foundation, Inc.,
17 *51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 *
19 */
20
21
22 #include <headers.h>
23 /***************************************************************
24 * Function - bcm_char_open()
25 *
26 * Description - This is the "open" entry point for the character
27 * driver.
28 *
29 * Parameters - inode: Pointer to the Inode structure of char device
30 * filp : File pointer of the char device
31 *
32 * Returns - Zero(Success)
33 ****************************************************************/
34 static struct class *bcm_class = NULL;
35 static int bcm_char_open(struct inode *inode, struct file * filp)
36 {
37 PMINI_ADAPTER Adapter = NULL;
38 PPER_TARANG_DATA pTarang = NULL;
39
40 Adapter = GET_BCM_ADAPTER(gblpnetdev);
41 pTarang = (PPER_TARANG_DATA)kmalloc(sizeof(PER_TARANG_DATA), GFP_KERNEL);
42 if (!pTarang)
43 return -ENOMEM;
44
45 memset (pTarang, 0, sizeof(PER_TARANG_DATA));
46 pTarang->Adapter = Adapter;
47 pTarang->RxCntrlMsgBitMask = 0xFFFFFFFF & ~(1 << 0xB) ;
48
49 down(&Adapter->RxAppControlQueuelock);
50 pTarang->next = Adapter->pTarangs;
51 Adapter->pTarangs = pTarang;
52 up(&Adapter->RxAppControlQueuelock);
53
54 /* Store the Adapter structure */
55 filp->private_data = pTarang;
56
57 /*Start Queuing the control response Packets*/
58 atomic_inc(&Adapter->ApplicationRunning);
59 return 0;
60 }
61 static int bcm_char_release(struct inode *inode, struct file *filp)
62 {
63 PPER_TARANG_DATA pTarang, tmp, ptmp;
64 PMINI_ADAPTER Adapter=NULL;
65 struct sk_buff * pkt, * npkt;
66
67 pTarang = (PPER_TARANG_DATA)filp->private_data;
68
69 if(pTarang == NULL)
70 {
71 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "ptarang is null\n");
72 return 0;
73 }
74
75 Adapter = pTarang->Adapter;
76
77 down( &Adapter->RxAppControlQueuelock);
78
79 tmp = Adapter->pTarangs;
80 for ( ptmp = NULL; tmp; ptmp = tmp, tmp = tmp->next )
81 {
82 if ( tmp == pTarang )
83 break;
84 }
85
86 if ( tmp )
87 {
88 if ( !ptmp )
89 Adapter->pTarangs = tmp->next;
90 else
91 ptmp->next = tmp->next;
92 }
93
94 else
95 {
96 up( &Adapter->RxAppControlQueuelock);
97 return 0;
98 }
99
100 pkt = pTarang->RxAppControlHead;
101 while ( pkt )
102 {
103 npkt = pkt->next;
104 kfree_skb(pkt);
105 pkt = npkt;
106 }
107
108 up( &Adapter->RxAppControlQueuelock);
109
110 /*Stop Queuing the control response Packets*/
111 atomic_dec(&Adapter->ApplicationRunning);
112
113 bcm_kfree(pTarang);
114
115 /* remove this filp from the asynchronously notified filp's */
116 filp->private_data = NULL;
117 return 0;
118 }
119
120 static int bcm_char_read(struct file *filp, PCHAR buf, size_t size, loff_t *f_pos)
121 {
122 PPER_TARANG_DATA pTarang = (PPER_TARANG_DATA)filp->private_data;
123 PMINI_ADAPTER Adapter = pTarang->Adapter;
124 struct sk_buff* Packet = NULL;
125 UINT PktLen = 0;
126 int wait_ret_val=0;
127
128 wait_ret_val = wait_event_interruptible(Adapter->process_read_wait_queue,
129 (pTarang->RxAppControlHead || Adapter->device_removed));
130 if((wait_ret_val == -ERESTARTSYS))
131 {
132 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Exiting as i've been asked to exit!!!\n");
133 return wait_ret_val;
134 }
135
136 if(Adapter->device_removed)
137 {
138 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Device Removed... Killing the Apps...\n");
139 return -ENODEV;
140 }
141
142 if(FALSE == Adapter->fw_download_done)
143 return -EACCES;
144
145 down( &Adapter->RxAppControlQueuelock);
146
147 if(pTarang->RxAppControlHead)
148 {
149 Packet = pTarang->RxAppControlHead;
150 DEQUEUEPACKET(pTarang->RxAppControlHead,pTarang->RxAppControlTail);
151 pTarang->AppCtrlQueueLen--;
152 }
153
154 up(&Adapter->RxAppControlQueuelock);
155
156 if(Packet)
157 {
158 PktLen = Packet->len;
159 if(copy_to_user(buf, Packet->data, PktLen))
160 {
161 bcm_kfree_skb(Packet);
162 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "\nReturning from copy to user failure \n");
163 return -EFAULT;
164 }
165 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Read %d Bytes From Adapter packet = 0x%p by process %d!\n", PktLen, Packet, current->pid);
166 bcm_kfree_skb(Packet);
167 }
168
169 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "<====\n");
170 return PktLen;
171 }
172
173 static INT bcm_char_ioctl(struct inode *inode, struct file *filp,
174 UINT cmd, ULONG arg)
175 {
176 PPER_TARANG_DATA pTarang = (PPER_TARANG_DATA)filp->private_data;
177 PMINI_ADAPTER Adapter = pTarang->Adapter;
178 INT Status = STATUS_FAILURE;
179 IOCTL_BUFFER IoBuffer={0};
180 #ifndef BCM_SHM_INTERFACE
181 int timeout = 0;
182 #endif
183
184
185 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Parameters Passed to control IOCTL cmd=0x%X arg=0x%lX", cmd, arg);
186
187 if(_IOC_TYPE(cmd) != BCM_IOCTL)
188 return -EFAULT;
189 if(_IOC_DIR(cmd) & _IOC_READ)
190 Status = !access_ok(VERIFY_WRITE, (PVOID)arg, _IOC_SIZE(cmd));
191 else if (_IOC_DIR(cmd) & _IOC_WRITE)
192 Status = !access_ok(VERIFY_READ, (PVOID)arg, _IOC_SIZE(cmd));
193 else if (_IOC_NONE == (_IOC_DIR(cmd) & _IOC_NONE))
194 Status = STATUS_SUCCESS;
195
196 if(Status)
197 return -EFAULT;
198
199 if(Adapter->device_removed)
200 {
201 return -EFAULT;
202 }
203
204 if(FALSE == Adapter->fw_download_done)
205 {
206 switch (cmd)
207 {
208 case IOCTL_MAC_ADDR_REQ:
209 case IOCTL_LINK_REQ:
210 case IOCTL_CM_REQUEST:
211 case IOCTL_SS_INFO_REQ:
212 case IOCTL_SEND_CONTROL_MESSAGE:
213 case IOCTL_IDLE_REQ:
214 return -EACCES;
215 default:
216 break;
217 }
218 }
219
220 Status = vendorextnIoctl(Adapter, cmd, arg);
221 if(Status != CONTINUE_COMMON_PATH )
222 {
223 return Status;
224 }
225
226 switch(cmd){
227 // Rdms for Swin Idle...
228 case IOCTL_BCM_REGISTER_READ_PRIVATE:
229 {
230 RDM_BUFFER sRdmBuffer = {0};
231 PCHAR temp_buff = NULL;
232 UINT Bufflen = 0;
233 /* Copy Ioctl Buffer structure */
234 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
235 sizeof(IOCTL_BUFFER)))
236 {
237 Status = -EFAULT;
238 break;
239 }
240
241 Bufflen = IoBuffer.OutputLength + (4 - IoBuffer.OutputLength%4)%4;
242 temp_buff = (PCHAR)kmalloc(Bufflen, GFP_KERNEL);
243 if(!temp_buff)
244 {
245 return STATUS_FAILURE;
246 }
247 if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer,
248 IoBuffer.InputLength))
249 {
250 Status = -EFAULT;
251 break;
252 }
253
254 down(&Adapter->rdmWrmDevAccLock);
255 Status = rdmalt(Adapter, (UINT)sRdmBuffer.Register,
256 (PUINT)temp_buff, Bufflen);
257 up(&Adapter->rdmWrmDevAccLock);
258
259 if(Status != STATUS_SUCCESS)
260 {
261 bcm_kfree(temp_buff);
262 return Status;
263 }
264 if(copy_to_user((PCHAR)IoBuffer.OutputBuffer,
265 (PCHAR)temp_buff, (UINT)IoBuffer.OutputLength))
266 {
267 Status = -EFAULT;
268 }
269 bcm_kfree(temp_buff);
270 break;
271 }
272 case IOCTL_BCM_REGISTER_WRITE_PRIVATE:
273 {
274 WRM_BUFFER sWrmBuffer = {0};
275 UINT uiTempVar=0;
276 /* Copy Ioctl Buffer structure */
277
278 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
279 sizeof(IOCTL_BUFFER)))
280 {
281 Status = -EFAULT;
282 break;
283 }
284 /* Get WrmBuffer structure */
285 if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer,
286 IoBuffer.InputLength))
287 {
288 Status = -EFAULT;
289 break;
290 }
291 uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
292 if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
293 ((uiTempVar == EEPROM_REJECT_REG_1)||
294 (uiTempVar == EEPROM_REJECT_REG_2) ||
295 (uiTempVar == EEPROM_REJECT_REG_3) ||
296 (uiTempVar == EEPROM_REJECT_REG_4)))
297 {
298 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
299 Status = -EFAULT;
300 break;
301 }
302
303 down(&Adapter->rdmWrmDevAccLock);
304 Status = wrmalt(Adapter, (UINT)sWrmBuffer.Register,
305 (PUINT)sWrmBuffer.Data, sizeof(ULONG));
306 up(&Adapter->rdmWrmDevAccLock);
307
308 if(Status == STATUS_SUCCESS)
309 {
310 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"WRM Done\n");
311 }
312 else
313 {
314 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
315 Status = -EFAULT;
316 }
317 break;
318 }
319
320 case IOCTL_BCM_REGISTER_READ:
321 case IOCTL_BCM_EEPROM_REGISTER_READ:
322 {
323 RDM_BUFFER sRdmBuffer = {0};
324 PCHAR temp_buff = NULL;
325 UINT uiTempVar = 0;
326
327 if((Adapter->IdleMode == TRUE) ||
328 (Adapter->bShutStatus ==TRUE) ||
329 (Adapter->bPreparingForLowPowerMode ==TRUE))
330 {
331 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Rdms\n");
332 Status = -EACCES;
333 break;
334 }
335
336 /* Copy Ioctl Buffer structure */
337 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
338 sizeof(IOCTL_BUFFER)))
339 {
340 Status = -EFAULT;
341 break;
342 }
343
344 temp_buff = (PCHAR)kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
345 if(!temp_buff)
346 {
347 return STATUS_FAILURE;
348 }
349 if(copy_from_user(&sRdmBuffer, IoBuffer.InputBuffer,
350 IoBuffer.InputLength))
351 {
352 Status = -EFAULT;
353 break;
354 }
355 #ifdef BCM_SHM_INTERFACE
356 sRdmBuffer.Register |= 0xA0000000;
357 #endif
358 if(
359 #if !defined(BCM_SHM_INTERFACE)
360 (((ULONG)sRdmBuffer.Register & 0x0F000000) != 0x0F000000) ||
361 #else
362 (
363 ((ULONG)sRdmBuffer.Register < 0xAF000000)
364 ||
365 (((ULONG)sRdmBuffer.Register > 0xBFFFFFFF))
366 )||
367 #endif
368 ((ULONG)sRdmBuffer.Register & 0x3)
369 )
370 {
371 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Done On invalid Address : %x Access Denied.\n",
372 (int)sRdmBuffer.Register);
373 Status = -EINVAL;
374 break;
375 }
376
377 uiTempVar = sRdmBuffer.Register & EEPROM_REJECT_MASK;
378
379 down(&Adapter->rdmWrmDevAccLock);
380 Status = rdmaltWithLock(Adapter, (UINT)sRdmBuffer.Register,
381 (PUINT)temp_buff, IoBuffer.OutputLength);
382 up(&Adapter->rdmWrmDevAccLock);
383
384 if(Status != STATUS_SUCCESS)
385 {
386 bcm_kfree(temp_buff);
387 return Status;
388 }
389 if(copy_to_user((PCHAR)IoBuffer.OutputBuffer,
390 (PCHAR)temp_buff, (UINT)IoBuffer.OutputLength))
391 {
392 Status = -EFAULT;
393 }
394 bcm_kfree(temp_buff);
395 break;
396 }
397 case IOCTL_BCM_REGISTER_WRITE:
398 case IOCTL_BCM_EEPROM_REGISTER_WRITE:
399 {
400 WRM_BUFFER sWrmBuffer = {0};
401 UINT uiTempVar=0;
402
403 if((Adapter->IdleMode == TRUE) ||
404 (Adapter->bShutStatus ==TRUE) ||
405 (Adapter->bPreparingForLowPowerMode ==TRUE))
406 {
407 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Device in Idle Mode, Blocking Wrms\n");
408 Status = -EACCES;
409 break;
410 }
411 /* Copy Ioctl Buffer structure */
412 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
413 sizeof(IOCTL_BUFFER)))
414 {
415 Status = -EFAULT;
416 break;
417 }
418 /* Get WrmBuffer structure */
419 if(copy_from_user(&sWrmBuffer, IoBuffer.InputBuffer,
420 IoBuffer.InputLength))
421 {
422 Status = -EFAULT;
423 break;
424 }
425
426 #ifdef BCM_SHM_INTERFACE
427 sWrmBuffer.Register |= 0xA0000000;
428 #endif
429 if(
430 #if !defined(BCM_SHM_INTERFACE)
431
432 (((ULONG)sWrmBuffer.Register & 0x0F000000) != 0x0F000000) ||
433 #else
434 (
435 ((ULONG)sWrmBuffer.Register < 0xAF000000)
436 ||
437 (((ULONG)sWrmBuffer.Register > 0xBFFFFFFF))
438 )||
439 #endif
440 ((ULONG)sWrmBuffer.Register & 0x3)
441 )
442 {
443 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Done On invalid Address : %x Access Denied.\n",
444 (int)sWrmBuffer.Register);
445 Status = -EINVAL;
446 break;
447 }
448 uiTempVar = sWrmBuffer.Register & EEPROM_REJECT_MASK;
449 if(!((Adapter->pstargetparams->m_u32Customize) & VSG_MODE) &&
450 ((uiTempVar == EEPROM_REJECT_REG_1)||
451 (uiTempVar == EEPROM_REJECT_REG_2) ||
452 (uiTempVar == EEPROM_REJECT_REG_3) ||
453 (uiTempVar == EEPROM_REJECT_REG_4)) &&
454 (cmd == IOCTL_BCM_REGISTER_WRITE))
455 {
456 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "EEPROM Access Denied, not in VSG Mode\n");
457 Status = -EFAULT;
458 break;
459 }
460
461 down(&Adapter->rdmWrmDevAccLock);
462 Status = wrmaltWithLock(Adapter, (UINT)sWrmBuffer.Register,
463 (PUINT)sWrmBuffer.Data, sWrmBuffer.Length);
464 up(&Adapter->rdmWrmDevAccLock);
465
466 if(Status == STATUS_SUCCESS)
467 {
468 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "WRM Done\n");
469 }
470 else
471 {
472 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM Failed\n");
473 Status = -EFAULT;
474 }
475 break;
476 }
477 case IOCTL_BCM_GPIO_SET_REQUEST:
478 {
479 UCHAR ucResetValue[4];
480 UINT value =0;
481 UINT uiBit = 0;
482 UINT uiOperation = 0;
483
484 GPIO_INFO gpio_info = {0};
485 if((Adapter->IdleMode == TRUE) ||
486 (Adapter->bShutStatus ==TRUE) ||
487 (Adapter->bPreparingForLowPowerMode ==TRUE))
488 {
489 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode");
490 Status = -EACCES;
491 break;
492 }
493 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
494 {
495 Status = -EFAULT;
496 break;
497 }
498 if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
499 {
500 Status = -EFAULT;
501 break;
502 }
503 uiBit = gpio_info.uiGpioNumber;
504 uiOperation = gpio_info.uiGpioValue;
505
506 value= (1<<uiBit);
507
508 if(IsReqGpioIsLedInNVM(Adapter,value) ==FALSE)
509 {
510 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to LED !!!",value);
511 Status = -EINVAL;
512 break;
513 }
514
515
516 if(uiOperation)//Set - setting 1
517 {
518 //Set the gpio output register
519 Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_SET_REG ,
520 (PUINT)(&value), sizeof(UINT));
521 if(Status == STATUS_SUCCESS)
522 {
523 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Set the GPIO bit\n");
524 }
525 else
526 {
527 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to set the %dth GPIO \n",uiBit);
528 break;
529 }
530 }
531 else//Unset - setting 0
532 {
533 //Set the gpio output register
534 Status = wrmaltWithLock(Adapter,BCM_GPIO_OUTPUT_CLR_REG ,
535 (PUINT)(&value), sizeof(UINT));
536 if(Status == STATUS_SUCCESS)
537 {
538 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO bit\n");
539 }
540 else
541 {
542 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Failed to clear the %dth GPIO \n",uiBit);
543 break;
544 }
545 }
546
547 Status = rdmaltWithLock(Adapter, (UINT)GPIO_MODE_REGISTER,
548 (PUINT)ucResetValue, sizeof(UINT));
549 if (STATUS_SUCCESS != Status)
550 {
551 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO_MODE_REGISTER read failed");
552 break;
553 }
554 //Set the gpio mode register to output
555 *(UINT*)ucResetValue |= (1<<uiBit);
556 Status = wrmaltWithLock(Adapter,GPIO_MODE_REGISTER ,
557 (PUINT)ucResetValue, sizeof(UINT));
558 if(Status == STATUS_SUCCESS)
559 {
560 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Set the GPIO to output Mode\n");
561 }
562 else
563 {
564 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Failed to put GPIO in Output Mode\n");
565 break;
566 }
567 }
568 break;
569 case BCM_LED_THREAD_STATE_CHANGE_REQ:
570 {
571
572 USER_THREAD_REQ threadReq = {0};
573 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"User made LED thread InActive");
574
575 if((Adapter->IdleMode == TRUE) ||
576 (Adapter->bShutStatus ==TRUE) ||
577 (Adapter->bPreparingForLowPowerMode ==TRUE))
578 {
579 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"GPIO Can't be set/clear in Low power Mode");
580 Status = -EACCES;
581 break;
582 }
583 Status =copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
584 if(Status)
585 {
586 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
587 break;
588 }
589
590 Status= copy_from_user(&threadReq, IoBuffer.InputBuffer, IoBuffer.InputLength);
591 if(Status)
592 {
593 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the InputBuffer from user space err:%d",Status);
594 break;
595 }
596 //if LED thread is running(Actively or Inactively) set it state to make inactive
597 if(Adapter->LEDInfo.led_thread_running)
598 {
599 if(threadReq.ThreadState == LED_THREAD_ACTIVATION_REQ)
600 {
601 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Activating thread req");
602 Adapter->DriverState = LED_THREAD_ACTIVE;
603 }
604 else
605 {
606 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DeActivating Thread req.....");
607 Adapter->DriverState = LED_THREAD_INACTIVE;
608 }
609
610 //signal thread.
611 wake_up(&Adapter->LEDInfo.notify_led_event);
612
613 }
614 }
615 break;
616 case IOCTL_BCM_GPIO_STATUS_REQUEST:
617 {
618 ULONG uiBit = 0;
619 UCHAR ucRead[4];
620 GPIO_INFO gpio_info = {0};
621 if((Adapter->IdleMode == TRUE) ||
622 (Adapter->bShutStatus ==TRUE) ||
623 (Adapter->bPreparingForLowPowerMode ==TRUE))
624 {
625 Status = -EACCES;
626 break;
627 }
628 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
629 {
630 Status = -EFAULT;
631 break;
632 }
633 if(copy_from_user(&gpio_info, IoBuffer.InputBuffer, IoBuffer.InputLength))
634 {
635 Status = -EFAULT;
636 break;
637 }
638 uiBit = gpio_info.uiGpioNumber;
639 //Set the gpio output register
640 Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER,
641 (PUINT)ucRead, sizeof(UINT));
642 if(Status != STATUS_SUCCESS)
643 {
644 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "RDM Failed\n");
645 return Status;
646 }
647
648 }
649 break;
650 case IOCTL_BCM_GPIO_MULTI_REQUEST:
651 {
652 UCHAR ucResetValue[4];
653 GPIO_MULTI_INFO gpio_multi_info[MAX_IDX];
654 PGPIO_MULTI_INFO pgpio_multi_info = (PGPIO_MULTI_INFO)gpio_multi_info;
655
656 memset( pgpio_multi_info, 0, MAX_IDX * sizeof( GPIO_MULTI_INFO));
657
658 if((Adapter->IdleMode == TRUE) ||
659 (Adapter->bShutStatus ==TRUE) ||
660 (Adapter->bPreparingForLowPowerMode ==TRUE))
661 {
662 Status = -EINVAL;
663 break;
664 }
665 Status = copy_from_user( (PCHAR)&IoBuffer, ( PCHAR)arg, sizeof( IOCTL_BUFFER));
666 if(Status)
667 {
668 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
669 break;
670 }
671
672 Status = copy_from_user( &gpio_multi_info, IoBuffer.InputBuffer, IoBuffer.InputLength);
673 if(Status)
674 {
675 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer Contents from user space err:%d",Status);
676 break;
677 }
678 if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_info[WIMAX_IDX].uiGPIOMask)== FALSE)
679 {
680 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to NVM LED bit map<0x%X>!!!",pgpio_multi_info[WIMAX_IDX].uiGPIOMask,Adapter->gpioBitMap);
681 Status = -EINVAL;
682 break;
683 }
684
685 /* Set the gpio output register */
686
687 if( ( pgpio_multi_info[WIMAX_IDX].uiGPIOMask) &
688 ( pgpio_multi_info[WIMAX_IDX].uiGPIOCommand))
689 {
690 /* Set 1's in GPIO OUTPUT REGISTER */
691 *(UINT*) ucResetValue = pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
692 pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
693 pgpio_multi_info[WIMAX_IDX].uiGPIOValue;
694
695 if( *(UINT*) ucResetValue)
696 Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_SET_REG , (PUINT) ucResetValue, sizeof(ULONG));
697
698 if( Status != STATUS_SUCCESS)
699 {
700 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_SET_REG Failed.");
701 return Status;
702 }
703
704 /* Clear to 0's in GPIO OUTPUT REGISTER */
705 *(UINT*) ucResetValue = (pgpio_multi_info[WIMAX_IDX].uiGPIOMask &
706 pgpio_multi_info[WIMAX_IDX].uiGPIOCommand &
707 ( ~( pgpio_multi_info[WIMAX_IDX].uiGPIOValue)));
708
709 if( *(UINT*) ucResetValue)
710 Status = wrmaltWithLock( Adapter, BCM_GPIO_OUTPUT_CLR_REG , (PUINT) ucResetValue, sizeof(ULONG));
711
712 if( Status != STATUS_SUCCESS)
713 {
714 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to BCM_GPIO_OUTPUT_CLR_REG Failed." );
715 return Status;
716 }
717 }
718
719 if( pgpio_multi_info[WIMAX_IDX].uiGPIOMask)
720 {
721 Status = rdmaltWithLock(Adapter, (UINT)GPIO_PIN_STATE_REGISTER, (PUINT)ucResetValue, sizeof(UINT));
722
723 if(Status != STATUS_SUCCESS)
724 {
725 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"RDM to GPIO_PIN_STATE_REGISTER Failed.");
726 return Status;
727 }
728
729 pgpio_multi_info[WIMAX_IDX].uiGPIOValue = ( *(UINT*)ucResetValue &
730 pgpio_multi_info[WIMAX_IDX].uiGPIOMask);
731 }
732
733 Status = copy_to_user( (PCHAR)IoBuffer.OutputBuffer, &gpio_multi_info, IoBuffer.OutputLength);
734 if(Status)
735 {
736 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status);
737 break;
738 }
739 }
740 break;
741 case IOCTL_BCM_GPIO_MODE_REQUEST:
742 {
743 UCHAR ucResetValue[4];
744 GPIO_MULTI_MODE gpio_multi_mode[MAX_IDX];
745 PGPIO_MULTI_MODE pgpio_multi_mode = ( PGPIO_MULTI_MODE) gpio_multi_mode;
746
747 if((Adapter->IdleMode == TRUE) ||
748 (Adapter->bShutStatus ==TRUE) ||
749 (Adapter->bPreparingForLowPowerMode ==TRUE))
750 {
751 Status = -EINVAL;
752 break;
753 }
754 Status = copy_from_user( (PCHAR)&IoBuffer, ( PCHAR)arg, sizeof( IOCTL_BUFFER));
755 if(Status)
756 {
757 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer from user space err:%d",Status);
758 break;
759 }
760
761 Status = copy_from_user( &gpio_multi_mode, IoBuffer.InputBuffer, IoBuffer.InputLength);
762 if(Status)
763 {
764 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying the IOBufer Contents from user space err:%d",Status);
765 break;
766 }
767
768 Status = rdmaltWithLock( Adapter, ( UINT) GPIO_MODE_REGISTER, ( PUINT) ucResetValue, sizeof( UINT));
769 if( STATUS_SUCCESS != Status)
770 {
771 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Read of GPIO_MODE_REGISTER failed");
772 return Status;
773 }
774
775 //Validating the request
776 if(IsReqGpioIsLedInNVM(Adapter,pgpio_multi_mode[WIMAX_IDX].uiGPIOMask)== FALSE)
777 {
778 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Sorry, Requested GPIO<0x%X> is not correspond to NVM LED bit map<0x%X>!!!",pgpio_multi_mode[WIMAX_IDX].uiGPIOMask,Adapter->gpioBitMap);
779 Status = -EINVAL;
780 break;
781 }
782
783 if( pgpio_multi_mode[WIMAX_IDX].uiGPIOMask)
784 {
785 /* write all OUT's (1's) */
786 *( UINT*) ucResetValue |= ( pgpio_multi_mode[WIMAX_IDX].uiGPIOMode &
787 pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
788 /* write all IN's (0's) */
789 *( UINT*) ucResetValue &= ~( ( ~pgpio_multi_mode[WIMAX_IDX].uiGPIOMode) &
790 pgpio_multi_mode[WIMAX_IDX].uiGPIOMask);
791
792 /* Currently implemented return the modes of all GPIO's
793 * else needs to bit AND with mask
794 * */
795 pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *(UINT*)ucResetValue;
796
797 Status = wrmaltWithLock( Adapter, GPIO_MODE_REGISTER , ( PUINT) ucResetValue, sizeof( ULONG));
798 if( Status == STATUS_SUCCESS)
799 {
800 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "WRM to GPIO_MODE_REGISTER Done");
801 }
802 else
803 {
804 BCM_DEBUG_PRINT( Adapter,DBG_TYPE_PRINTK, 0, 0,"WRM to GPIO_MODE_REGISTER Failed");
805 Status = -EFAULT;
806 break;
807 }
808 }
809 else /* if uiGPIOMask is 0 then return mode register configuration */
810 {
811 pgpio_multi_mode[WIMAX_IDX].uiGPIOMode = *( UINT*) ucResetValue;
812 }
813 Status = copy_to_user( (PCHAR)IoBuffer.OutputBuffer, &gpio_multi_mode, IoBuffer.OutputLength);
814 if(Status)
815 {
816 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed while copying Content to IOBufer for user space err:%d",Status);
817 break;
818 }
819 }
820 break;
821
822 case IOCTL_MAC_ADDR_REQ:
823 case IOCTL_LINK_REQ:
824 case IOCTL_CM_REQUEST:
825 case IOCTL_SS_INFO_REQ:
826 case IOCTL_SEND_CONTROL_MESSAGE:
827 case IOCTL_IDLE_REQ:
828 {
829 PVOID pvBuffer=NULL;
830 /* Copy Ioctl Buffer structure */
831 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
832 sizeof(IOCTL_BUFFER)))
833 {
834 Status = -EFAULT;
835 break;
836 }
837 pvBuffer=kmalloc(IoBuffer.InputLength, GFP_KERNEL);
838 if(!pvBuffer)
839 {
840 return -ENOMEM;
841 }
842
843 if(copy_from_user(pvBuffer, IoBuffer.InputBuffer,
844 IoBuffer.InputLength))
845 {
846 Status = -EFAULT;
847 bcm_kfree(pvBuffer);
848 break;
849 }
850
851 down(&Adapter->LowPowerModeSync);
852 Status = wait_event_interruptible_timeout(Adapter->lowpower_mode_wait_queue,
853 !Adapter->bPreparingForLowPowerMode,
854 (1 * HZ));
855 if(Status == -ERESTARTSYS)
856 goto cntrlEnd;
857
858 if(Adapter->bPreparingForLowPowerMode)
859 {
860 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Preparing Idle Mode is still True - Hence Rejecting control message\n");
861 Status = STATUS_FAILURE ;
862 goto cntrlEnd ;
863 }
864 Status = CopyBufferToControlPacket(Adapter, (PVOID)pvBuffer);
865 cntrlEnd:
866 up(&Adapter->LowPowerModeSync);
867 bcm_kfree(pvBuffer);
868 break;
869 }
870 #ifndef BCM_SHM_INTERFACE
871 case IOCTL_BCM_BUFFER_DOWNLOAD_START:
872 {
873 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock) ;
874 if(NVMAccess)
875 {
876 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
877 return -EACCES;
878 }
879 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
880 if(!down_trylock(&Adapter->fw_download_sema))
881 {
882 Adapter->bBinDownloaded=FALSE;
883 Adapter->fw_download_process_pid=current->pid;
884 Adapter->bCfgDownloaded=FALSE;
885 Adapter->fw_download_done=FALSE;
886 netif_carrier_off(Adapter->dev);
887 netif_stop_queue(Adapter->dev);
888 down(&Adapter->rdmWrmDevAccLock);
889 Status = reset_card_proc(Adapter);
890
891 //Initializing the NVM.
892 BcmInitNVM(Adapter);
893 up(&Adapter->rdmWrmDevAccLock);
894
895 if(Status)
896 {
897 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "reset_card_proc Failed!\n");
898 up(&Adapter->fw_download_sema);
899 up(&Adapter->NVMRdmWrmLock);
900 break;
901 }
902 mdelay(10);
903 }
904 else
905 {
906
907 Status = -EBUSY;
908
909 }
910 up(&Adapter->NVMRdmWrmLock);
911 break;
912 }
913 case IOCTL_BCM_BUFFER_DOWNLOAD:
914 {
915 FIRMWARE_INFO *psFwInfo=NULL;
916 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Starting the firmware download PID =0x%x!!!!\n", current->pid);
917 do{
918 if(!down_trylock(&Adapter->fw_download_sema))
919 {
920 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid way to download buffer. Use Start and then call this!!!\n");
921 Status=-EINVAL;
922 break;
923 }
924 /* Copy Ioctl Buffer structure */
925 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
926 sizeof(IOCTL_BUFFER)))
927 {
928 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
929 Status = -EFAULT;
930 break;
931 }
932 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length for FW DLD is : %lx\n",
933 IoBuffer.InputLength);
934 psFwInfo=kmalloc(sizeof(*psFwInfo), GFP_KERNEL);
935 if(!psFwInfo)
936 {
937 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Failed to allocate buffer!!!!\n");
938 Status = -ENOMEM;
939 break;
940 }
941 if(copy_from_user(psFwInfo, IoBuffer.InputBuffer,
942 IoBuffer.InputLength))
943 {
944 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_from_user 2 failed\n");
945 Status = -EFAULT;
946 break;
947 }
948
949 if(!psFwInfo->pvMappedFirmwareAddress ||
950 (psFwInfo->u32FirmwareLength == 0))
951 {
952 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Something else is wrong %lu\n",
953 psFwInfo->u32FirmwareLength);
954 Status = -EINVAL;
955 break;
956 }
957
958
959 down(&Adapter->rdmWrmDevAccLock);
960 Status = bcm_ioctl_fw_download(Adapter, psFwInfo);
961 up(&Adapter->rdmWrmDevAccLock);
962
963 if(Status != STATUS_SUCCESS)
964 {
965 if(psFwInfo->u32StartingAddress==CONFIG_BEGIN_ADDR)
966 {
967 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Configuration File Upload Failed\n");
968 }
969 else
970 {
971 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "IOCTL: Firmware File Upload Failed\n");
972 }
973 //up(&Adapter->fw_download_sema);
974
975 if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)
976 {
977 Adapter->DriverState = DRIVER_INIT;
978 Adapter->LEDInfo.bLedInitDone = FALSE;
979 wake_up(&Adapter->LEDInfo.notify_led_event);
980 }
981 }
982 break ;
983 }while(0);
984
985 if(Status != STATUS_SUCCESS)
986 up(&Adapter->fw_download_sema);
987 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, OSAL_DBG, DBG_LVL_ALL, "IOCTL: Firmware File Uploaded\n");
988 bcm_kfree(psFwInfo);
989 break;
990 }
991 case IOCTL_BCM_BUFFER_DOWNLOAD_STOP:
992 {
993 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
994 if(NVMAccess)
995 {
996 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " FW download blocked as EEPROM Read/Write is in progress\n");
997 up(&Adapter->fw_download_sema);
998 return -EACCES;
999 }
1000 if(down_trylock(&Adapter->fw_download_sema))
1001 {
1002 Adapter->bBinDownloaded=TRUE;
1003 Adapter->bCfgDownloaded=TRUE;
1004 atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
1005 atomic_set(&Adapter->RxRollOverCount, 0);
1006 Adapter->CurrNumRecvDescs=0;
1007 Adapter->uiFirstInterrupt = 0;
1008
1009 //setting the Mips to Run
1010
1011 down(&Adapter->rdmWrmDevAccLock);
1012 Status = run_card_proc(Adapter);
1013 up(&Adapter->rdmWrmDevAccLock);
1014
1015 if(Status)
1016 {
1017 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Firm Download Failed\n");
1018 up(&Adapter->fw_download_sema);
1019 up(&Adapter->NVMRdmWrmLock);
1020 break;
1021 }
1022 else
1023 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Firm Download Over...\n");
1024 mdelay(10);
1025 /* Wait for MailBox Interrupt */
1026 if(StartInterruptUrb((PS_INTERFACE_ADAPTER)Adapter->pvInterfaceAdapter))
1027 {
1028 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Unable to send interrupt...\n");
1029 }
1030 timeout = 5*HZ;
1031 Adapter->waiting_to_fw_download_done = FALSE;
1032 wait_event_timeout(Adapter->ioctl_fw_dnld_wait_queue,
1033 Adapter->waiting_to_fw_download_done, timeout);
1034 Adapter->fw_download_process_pid=INVALID_PID;
1035 Adapter->fw_download_done=TRUE;
1036 atomic_set(&Adapter->CurrNumFreeTxDesc, 0);
1037 Adapter->CurrNumRecvDescs = 0;
1038 Adapter->PrevNumRecvDescs = 0;
1039 atomic_set(&Adapter->cntrlpktCnt,0);
1040 Adapter->LinkUpStatus = 0;
1041 Adapter->LinkStatus = 0;
1042
1043 if(Adapter->LEDInfo.led_thread_running & BCM_LED_THREAD_RUNNING_ACTIVELY)
1044 {
1045 Adapter->DriverState = FW_DOWNLOAD_DONE;
1046 wake_up(&Adapter->LEDInfo.notify_led_event);
1047 }
1048
1049 if(!timeout)
1050 {
1051 Status = -ENODEV;
1052 }
1053 }
1054 else
1055 {
1056 Status = -EINVAL;
1057 }
1058 up(&Adapter->fw_download_sema);
1059 up(&Adapter->NVMRdmWrmLock);
1060 break;
1061 }
1062 #endif
1063 case IOCTL_BE_BUCKET_SIZE:
1064 Adapter->BEBucketSize = *(PULONG)arg;
1065 Status = STATUS_SUCCESS;
1066 break;
1067
1068 case IOCTL_RTPS_BUCKET_SIZE:
1069 Adapter->rtPSBucketSize = *(PULONG)arg;
1070 Status = STATUS_SUCCESS;
1071 break;
1072 case IOCTL_CHIP_RESET:
1073 {
1074 INT NVMAccess = down_trylock(&Adapter->NVMRdmWrmLock);
1075 if(NVMAccess)
1076 {
1077 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, " IOCTL_BCM_CHIP_RESET not allowed as EEPROM Read/Write is in progress\n");
1078 return -EACCES;
1079 }
1080 down(&Adapter->RxAppControlQueuelock);
1081
1082 down(&Adapter->rdmWrmDevAccLock);
1083 Status = reset_card_proc(Adapter);
1084
1085 //Initializing the NVM.
1086 BcmInitNVM(Adapter);
1087 up(&Adapter->rdmWrmDevAccLock);
1088
1089 flushAllAppQ();
1090 up(&Adapter->RxAppControlQueuelock);
1091 up(&Adapter->NVMRdmWrmLock);
1092 ResetCounters(Adapter);
1093 break;
1094 }
1095 case IOCTL_QOS_THRESHOLD:
1096 {
1097 USHORT uiLoopIndex;
1098 for(uiLoopIndex = 0 ; uiLoopIndex < NO_OF_QUEUES ; uiLoopIndex++)
1099 {
1100 Adapter->PackInfo[uiLoopIndex].uiThreshold = *(PULONG)arg;
1101 }
1102 Status = STATUS_SUCCESS;
1103 break;
1104 }
1105
1106 case IOCTL_DUMP_PACKET_INFO:
1107
1108 DumpPackInfo(Adapter);
1109 DumpPhsRules(&Adapter->stBCMPhsContext);
1110 Status = STATUS_SUCCESS;
1111 break;
1112
1113 case IOCTL_GET_PACK_INFO:
1114 if(copy_to_user((PCHAR)arg, &Adapter->PackInfo,
1115 sizeof(PacketInfo)*NO_OF_QUEUES))
1116 {
1117 Status = -EFAULT;
1118 break;
1119 }
1120 Status = STATUS_SUCCESS;
1121 break;
1122 case IOCTL_BCM_SWITCH_TRANSFER_MODE:
1123 {
1124 UINT uiData = 0;
1125 if(copy_from_user(&uiData, (PUINT)arg, sizeof(UINT)))
1126 {
1127 Status = -EFAULT;
1128 break;
1129 }
1130 if(uiData) /* Allow All Packets */
1131 {
1132 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: ETH_PACKET_TUNNELING_MODE\n");
1133 Adapter->TransferMode = ETH_PACKET_TUNNELING_MODE;
1134 }
1135 else /* Allow IP only Packets */
1136 {
1137 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SWITCH_TRANSFER_MODE: IP_PACKET_ONLY_MODE\n");
1138 Adapter->TransferMode = IP_PACKET_ONLY_MODE;
1139 }
1140 Status = STATUS_SUCCESS;
1141 break;
1142 }
1143
1144 case IOCTL_BCM_GET_DRIVER_VERSION:
1145 {
1146 /* Copy Ioctl Buffer structure */
1147 if(copy_from_user((PCHAR)&IoBuffer,
1148 (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1149 {
1150 Status = -EFAULT;
1151 break;
1152 }
1153 if(copy_to_user((PUCHAR)IoBuffer.OutputBuffer,
1154 VER_FILEVERSION_STR, (UINT)IoBuffer.OutputLength))
1155 {
1156 Status = -EFAULT;
1157 break;
1158 }
1159 Status = STATUS_SUCCESS;
1160 break;
1161 }
1162 case IOCTL_BCM_GET_CURRENT_STATUS:
1163 {
1164 LINK_STATE *plink_state = NULL;
1165 /* Copy Ioctl Buffer structure */
1166 if(copy_from_user((PCHAR)&IoBuffer,
1167 (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1168 {
1169 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user failed..\n");
1170 Status = -EFAULT;
1171 break;
1172 }
1173 plink_state = (LINK_STATE*)arg;
1174 plink_state->bIdleMode = (UCHAR)Adapter->IdleMode;
1175 plink_state->bShutdownMode = Adapter->bShutStatus;
1176 plink_state->ucLinkStatus = (UCHAR)Adapter->LinkStatus;
1177 if(copy_to_user((PUCHAR)IoBuffer.OutputBuffer,
1178 (PUCHAR)plink_state, (UINT)IoBuffer.OutputLength))
1179 {
1180 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_to_user Failed..\n");
1181 Status = -EFAULT;
1182 break;
1183 }
1184 Status = STATUS_SUCCESS;
1185 break;
1186 }
1187 case IOCTL_BCM_SET_MAC_TRACING:
1188 {
1189 UINT tracing_flag;
1190 /* copy ioctl Buffer structure */
1191 if(copy_from_user((PCHAR)&IoBuffer,
1192 (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1193 {
1194 Status = -EFAULT;
1195 break;
1196 }
1197 if(copy_from_user((PCHAR)&tracing_flag,
1198 (PCHAR)IoBuffer.InputBuffer,sizeof(UINT)))
1199 {
1200 Status = -EFAULT;
1201 break;
1202 }
1203 if (tracing_flag)
1204 Adapter->pTarangs->MacTracingEnabled = TRUE;
1205 else
1206 Adapter->pTarangs->MacTracingEnabled = FALSE;
1207 break;
1208 }
1209 case IOCTL_BCM_GET_DSX_INDICATION:
1210 {
1211 ULONG ulSFId=0;
1212 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg,
1213 sizeof(IOCTL_BUFFER)))
1214 {
1215 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Invalid IO buffer!!!" );
1216 Status = -EFAULT;
1217 break;
1218 }
1219 if(IoBuffer.OutputLength < sizeof(stLocalSFAddIndicationAlt))
1220 {
1221 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Mismatch req: %lx needed is =0x%x!!!",
1222 IoBuffer.OutputLength, sizeof(stLocalSFAddIndicationAlt));
1223 return -EINVAL;
1224 }
1225 if(copy_from_user((PCHAR)&ulSFId, (PCHAR)IoBuffer.InputBuffer,
1226 sizeof(ulSFId)))
1227 {
1228 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Invalid SFID!!! %lu", ulSFId );
1229 Status = -EFAULT;
1230 break;
1231 }
1232 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Get DSX Data SF ID is =%lx\n", ulSFId );
1233 get_dsx_sf_data_to_application(Adapter, ulSFId,
1234 IoBuffer.OutputBuffer);
1235 Status=STATUS_SUCCESS;
1236 }
1237 break;
1238 case IOCTL_BCM_GET_HOST_MIBS:
1239 {
1240 PCHAR temp_buff;
1241
1242 if(copy_from_user((PCHAR)&IoBuffer,
1243 (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1244 {
1245 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy_from user for IoBuff failed\n");
1246 Status = -EFAULT;
1247 break;
1248 }
1249
1250 if(IoBuffer.OutputLength != sizeof(S_MIBS_HOST_STATS_MIBS))
1251 {
1252 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Length Check failed %lu %d\n", IoBuffer.OutputLength,
1253 sizeof(S_MIBS_HOST_STATS_MIBS));
1254 return -EINVAL;
1255 }
1256
1257 temp_buff = (PCHAR)kmalloc(IoBuffer.OutputLength, GFP_KERNEL);
1258
1259 if(!temp_buff)
1260 {
1261 return STATUS_FAILURE;
1262 }
1263
1264 Status = ProcessGetHostMibs(Adapter,
1265 (PUCHAR)temp_buff, IoBuffer.OutputLength);
1266
1267 Status = GetDroppedAppCntrlPktMibs((PVOID)temp_buff,
1268 (PPER_TARANG_DATA)filp->private_data);
1269
1270 if(copy_to_user((PCHAR)IoBuffer.OutputBuffer,(PCHAR)temp_buff,
1271 sizeof(S_MIBS_HOST_STATS_MIBS)))
1272 {
1273 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy to user failed\n");
1274 bcm_kfree(temp_buff);
1275 return -EFAULT;
1276 }
1277
1278 bcm_kfree(temp_buff);
1279 break;
1280 }
1281
1282 case IOCTL_BCM_WAKE_UP_DEVICE_FROM_IDLE:
1283 if((FALSE == Adapter->bTriedToWakeUpFromlowPowerMode) && (TRUE==Adapter->IdleMode))
1284 {
1285 Adapter->usIdleModePattern = ABORT_IDLE_MODE;
1286 Adapter->bWakeUpDevice = TRUE;
1287 wake_up(&Adapter->process_rx_cntrlpkt);
1288 #if 0
1289 Adapter->bTriedToWakeUpFromlowPowerMode = TRUE;
1290 InterfaceAbortIdlemode (Adapter, Adapter->usIdleModePattern);
1291 #endif
1292 }
1293 Status = STATUS_SUCCESS;
1294 break;
1295
1296 case IOCTL_BCM_BULK_WRM:
1297 {
1298 PBULKWRM_BUFFER pBulkBuffer;
1299 UINT uiTempVar=0;
1300 PCHAR pvBuffer = NULL;
1301
1302 if((Adapter->IdleMode == TRUE) ||
1303 (Adapter->bShutStatus ==TRUE) ||
1304 (Adapter->bPreparingForLowPowerMode ==TRUE))
1305 {
1306 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Device in Idle/Shutdown Mode, Blocking Wrms\n");
1307 Status = -EACCES;
1308 break;
1309 }
1310 /* Copy Ioctl Buffer structure */
1311 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1312 {
1313 Status = -EFAULT;
1314 break;
1315 }
1316
1317 pvBuffer=kmalloc(IoBuffer.InputLength, GFP_KERNEL);
1318 if(!pvBuffer)
1319 {
1320 return -ENOMEM;
1321 break;
1322 }
1323
1324 /* Get WrmBuffer structure */
1325 if(copy_from_user(pvBuffer, IoBuffer.InputBuffer, IoBuffer.InputLength))
1326 {
1327 bcm_kfree(pvBuffer);
1328 Status = -EFAULT;
1329 break;
1330 }
1331
1332 pBulkBuffer = (PBULKWRM_BUFFER)pvBuffer;
1333
1334 if(((ULONG)pBulkBuffer->Register & 0x0F000000) != 0x0F000000 ||
1335 ((ULONG)pBulkBuffer->Register & 0x3))
1336 {
1337 bcm_kfree(pvBuffer);
1338 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"WRM Done On invalid Address : %x Access Denied.\n",(int)pBulkBuffer->Register);
1339 Status = -EINVAL;
1340 break;
1341 }
1342
1343
1344 uiTempVar = pBulkBuffer->Register & EEPROM_REJECT_MASK;
1345 if(!((Adapter->pstargetparams->m_u32Customize)&VSG_MODE)
1346 && ((uiTempVar == EEPROM_REJECT_REG_1)||
1347 (uiTempVar == EEPROM_REJECT_REG_2) ||
1348 (uiTempVar == EEPROM_REJECT_REG_3) ||
1349 (uiTempVar == EEPROM_REJECT_REG_4)) &&
1350 (cmd == IOCTL_BCM_REGISTER_WRITE))
1351 {
1352 bcm_kfree(pvBuffer);
1353 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0,"EEPROM Access Denied, not in VSG Mode\n");
1354 Status = -EFAULT;
1355 break;
1356 }
1357
1358 down(&Adapter->rdmWrmDevAccLock);
1359
1360 if(pBulkBuffer->SwapEndian == FALSE)
1361 Status = wrmWithLock(Adapter, (UINT)pBulkBuffer->Register, (PCHAR)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1362
1363 else
1364 Status = wrmaltWithLock(Adapter, (UINT)pBulkBuffer->Register, (PUINT)pBulkBuffer->Values, IoBuffer.InputLength - 2*sizeof(ULONG));
1365
1366 up(&Adapter->rdmWrmDevAccLock);
1367
1368 if(Status != STATUS_SUCCESS)
1369 {
1370 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "WRM Failed\n");
1371 }
1372
1373 bcm_kfree(pvBuffer);
1374 break;
1375 }
1376
1377 case IOCTL_BCM_GET_NVM_SIZE:
1378 {
1379
1380 if(copy_from_user((unsigned char *)&IoBuffer,
1381 (unsigned char *)arg, sizeof(IOCTL_BUFFER)))
1382 {
1383 //IOLog("failed NVM first");
1384 Status = -EFAULT;
1385 break;
1386 }
1387 if(Adapter->eNVMType == NVM_EEPROM || Adapter->eNVMType == NVM_FLASH ) {
1388 if(copy_to_user(IoBuffer.OutputBuffer,
1389 (unsigned char *)&Adapter->uiNVMDSDSize, (UINT)sizeof(UINT)))
1390 {
1391 Status = -EFAULT;
1392 return Status;
1393 }
1394 }
1395
1396 Status = STATUS_SUCCESS ;
1397 }
1398 break;
1399
1400 case IOCTL_BCM_CAL_INIT :
1401 {
1402 UINT uiSectorSize = 0 ;
1403
1404 if(Adapter->eNVMType == NVM_FLASH)
1405 {
1406 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1407 if(Status)
1408 {
1409 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy From User space failed. status :%d", Status);
1410 return Status;
1411 }
1412 uiSectorSize = *((PUINT)(IoBuffer.InputBuffer));
1413 if((uiSectorSize < MIN_SECTOR_SIZE) || (uiSectorSize > MAX_SECTOR_SIZE))
1414 {
1415
1416 Status = copy_to_user(IoBuffer.OutputBuffer,
1417 (unsigned char *)&Adapter->uiSectorSize ,
1418 (UINT)sizeof(UINT));
1419 if(Status)
1420 {
1421 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1422 return Status;
1423 }
1424 }
1425 else
1426 {
1427 if(IsFlash2x(Adapter))
1428 {
1429 Status = copy_to_user(IoBuffer.OutputBuffer,
1430 (unsigned char *)&Adapter->uiSectorSize ,
1431 (UINT)sizeof(UINT));
1432 if(Status)
1433 {
1434 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Coping the sector size to use space failed. status:%d",Status);
1435 return Status;
1436 }
1437
1438 }
1439 else
1440 {
1441
1442 down(&Adapter->NVMRdmWrmLock);
1443
1444 if((Adapter->IdleMode == TRUE) ||
1445 (Adapter->bShutStatus ==TRUE) ||
1446 (Adapter->bPreparingForLowPowerMode ==TRUE))
1447 {
1448 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1449 up(&Adapter->NVMRdmWrmLock);
1450 return -EACCES;
1451 }
1452
1453 Adapter->uiSectorSize = uiSectorSize ;
1454 BcmUpdateSectorSize(Adapter,Adapter->uiSectorSize);
1455 up(&Adapter->NVMRdmWrmLock);
1456 }
1457 }
1458 Status = STATUS_SUCCESS ;
1459 }
1460 else
1461 {
1462 Status = STATUS_FAILURE;
1463 }
1464 }
1465 break;
1466 case IOCTL_BCM_SET_DEBUG :
1467 {
1468 USER_BCM_DBG_STATE sUserDebugState;
1469
1470 // BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Entered the ioctl %x \n", IOCTL_BCM_SET_DEBUG );
1471
1472 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In SET_DEBUG ioctl\n");
1473 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1474 if(Status)
1475 {
1476 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy from user failed\n");
1477 break;
1478 }
1479 Status = copy_from_user(&sUserDebugState,(USER_BCM_DBG_STATE *)IoBuffer.InputBuffer, sizeof(USER_BCM_DBG_STATE));
1480 if(Status)
1481 {
1482 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "Copy of IoBuffer.InputBuffer failed");
1483 return Status;
1484 }
1485
1486 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "IOCTL_BCM_SET_DEBUG: OnOff=%d Type = 0x%x ",
1487 sUserDebugState.OnOff, sUserDebugState.Type);
1488 //sUserDebugState.Subtype <<= 1;
1489 sUserDebugState.Subtype = 1 << sUserDebugState.Subtype;
1490 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "actual Subtype=0x%x\n", sUserDebugState.Subtype);
1491
1492 // Update new 'DebugState' in the Adapter
1493 Adapter->stDebugState.type |= sUserDebugState.Type;
1494 /* Subtype: A bitmap of 32 bits for Subtype per Type.
1495 * Valid indexes in 'subtype' array: 1,2,4,8
1496 * corresponding to valid Type values. Hence we can use the 'Type' field
1497 * as the index value, ignoring the array entries 0,3,5,6,7 !
1498 */
1499 if (sUserDebugState.OnOff)
1500 Adapter->stDebugState.subtype[sUserDebugState.Type] |= sUserDebugState.Subtype;
1501 else
1502 Adapter->stDebugState.subtype[sUserDebugState.Type] &= ~sUserDebugState.Subtype;
1503
1504 BCM_SHOW_DEBUG_BITMAP(Adapter);
1505
1506 }
1507 break;
1508 case IOCTL_BCM_NVM_READ:
1509 case IOCTL_BCM_NVM_WRITE:
1510 {
1511
1512 NVM_READWRITE stNVMReadWrite = {0};
1513 PUCHAR pReadData = NULL;
1514 PUCHAR pBuffertobeCopied = NULL;
1515 ULONG ulDSDMagicNumInUsrBuff = 0 ;
1516 struct timeval tv0, tv1;
1517 memset(&tv0,0,sizeof(struct timeval));
1518 memset(&tv1,0,sizeof(struct timeval));
1519 if((Adapter->eNVMType == NVM_FLASH) && (Adapter->uiFlashLayoutMajorVersion == 0))
1520 {
1521 BCM_DEBUG_PRINT(Adapter, DBG_TYPE_PRINTK, 0, 0,"The Flash Control Section is Corrupted. Hence Rejection on NVM Read/Write\n");
1522 Status = -EFAULT;
1523 break;
1524 }
1525
1526 if(IsFlash2x(Adapter))
1527 {
1528 if((Adapter->eActiveDSD != DSD0) &&
1529 (Adapter->eActiveDSD != DSD1) &&
1530 (Adapter->eActiveDSD != DSD2))
1531 {
1532 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"No DSD is active..hence NVM Command is blocked");
1533 return STATUS_FAILURE ;
1534 }
1535 }
1536
1537 /* Copy Ioctl Buffer structure */
1538
1539 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
1540 {
1541 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copy_from_user failed\n");
1542 Status = -EFAULT;
1543 break;
1544 }
1545 if(IOCTL_BCM_NVM_READ == cmd)
1546 pBuffertobeCopied = IoBuffer.OutputBuffer;
1547 else
1548 pBuffertobeCopied = IoBuffer.InputBuffer;
1549
1550 if(copy_from_user(&stNVMReadWrite, pBuffertobeCopied,sizeof(NVM_READWRITE)))
1551 {
1552 Status = -EFAULT;
1553 break;
1554 }
1555
1556 //
1557 // Deny the access if the offset crosses the cal area limit.
1558 //
1559 if((stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) > Adapter->uiNVMDSDSize)
1560 {
1561 //BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Can't allow access beyond NVM Size: 0x%x 0x%x\n", stNVMReadWrite.uiOffset ,
1562 // stNVMReadWrite.uiNumBytes);
1563 Status = STATUS_FAILURE;
1564 break;
1565 }
1566
1567 pReadData =(PCHAR)kmalloc(stNVMReadWrite.uiNumBytes, GFP_KERNEL);
1568
1569 if(!pReadData)
1570 return -ENOMEM;
1571
1572 memset(pReadData,0,stNVMReadWrite.uiNumBytes);
1573
1574 if(copy_from_user(pReadData, stNVMReadWrite.pBuffer,
1575 stNVMReadWrite.uiNumBytes))
1576 {
1577 Status = -EFAULT;
1578 bcm_kfree(pReadData);
1579 break;
1580 }
1581
1582 do_gettimeofday(&tv0);
1583 if(IOCTL_BCM_NVM_READ == cmd)
1584 {
1585 down(&Adapter->NVMRdmWrmLock);
1586
1587 if((Adapter->IdleMode == TRUE) ||
1588 (Adapter->bShutStatus ==TRUE) ||
1589 (Adapter->bPreparingForLowPowerMode ==TRUE))
1590 {
1591 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1592 up(&Adapter->NVMRdmWrmLock);
1593 bcm_kfree(pReadData);
1594 return -EACCES;
1595 }
1596
1597 Status = BeceemNVMRead(Adapter, (PUINT)pReadData,
1598 stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes);
1599
1600 up(&Adapter->NVMRdmWrmLock);
1601
1602 if(Status != STATUS_SUCCESS)
1603 {
1604 bcm_kfree(pReadData);
1605 return Status;
1606 }
1607 if(copy_to_user((PCHAR)stNVMReadWrite.pBuffer,
1608 (PCHAR)pReadData, (UINT)stNVMReadWrite.uiNumBytes))
1609 {
1610 bcm_kfree(pReadData);
1611 Status = -EFAULT;
1612 }
1613 }
1614 else
1615 {
1616
1617 down(&Adapter->NVMRdmWrmLock);
1618
1619 if((Adapter->IdleMode == TRUE) ||
1620 (Adapter->bShutStatus ==TRUE) ||
1621 (Adapter->bPreparingForLowPowerMode ==TRUE))
1622 {
1623 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1624 up(&Adapter->NVMRdmWrmLock);
1625 bcm_kfree(pReadData);
1626 return -EACCES;
1627 }
1628
1629 Adapter->bHeaderChangeAllowed = TRUE ;
1630 if(IsFlash2x(Adapter))
1631 {
1632 /*
1633 New Requirement:-
1634 DSD section updation will be allowed in two case:-
1635 1. if DSD sig is present in DSD header means dongle is ok and updation is fruitfull
1636 2. if point 1 failes then user buff should have DSD sig. this point ensures that if dongle is
1637 corrupted then user space program first modify the DSD header with valid DSD sig so
1638 that this as well as further write may be worthwhile.
1639
1640 This restriction has been put assuming that if DSD sig is corrupted, DSD
1641 data won't be considered valid.
1642
1643
1644 */
1645 Status = BcmFlash2xCorruptSig(Adapter,Adapter->eActiveDSD);
1646 if(Status != STATUS_SUCCESS)
1647 {
1648 if(( (stNVMReadWrite.uiOffset + stNVMReadWrite.uiNumBytes) != Adapter->uiNVMDSDSize ) ||
1649 (stNVMReadWrite.uiNumBytes < SIGNATURE_SIZE))
1650 {
1651 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1652 up(&Adapter->NVMRdmWrmLock);
1653 bcm_kfree(pReadData);
1654 return Status;
1655 }
1656
1657 ulDSDMagicNumInUsrBuff = ntohl(*(PUINT)(pReadData + stNVMReadWrite.uiNumBytes - SIGNATURE_SIZE));
1658 if(ulDSDMagicNumInUsrBuff != DSD_IMAGE_MAGIC_NUMBER)
1659 {
1660 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"DSD Sig is present neither in Flash nor User provided Input..");
1661 up(&Adapter->NVMRdmWrmLock);
1662 bcm_kfree(pReadData);
1663 return Status;
1664 }
1665 }
1666 }
1667 Status = BeceemNVMWrite(Adapter, (PUINT )pReadData,
1668 stNVMReadWrite.uiOffset, stNVMReadWrite.uiNumBytes, stNVMReadWrite.bVerify);
1669 if(IsFlash2x(Adapter))
1670 BcmFlash2xWriteSig(Adapter,Adapter->eActiveDSD);
1671
1672 Adapter->bHeaderChangeAllowed = FALSE ;
1673
1674 up(&Adapter->NVMRdmWrmLock);
1675
1676
1677 if(Status != STATUS_SUCCESS)
1678 {
1679 bcm_kfree(pReadData);
1680 return Status;
1681 }
1682 }
1683 do_gettimeofday(&tv1);
1684 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " timetaken by Write/read :%ld msec\n",(tv1.tv_sec - tv0.tv_sec)*1000 +(tv1.tv_usec - tv0.tv_usec)/1000);
1685
1686
1687 bcm_kfree(pReadData);
1688 Status = STATUS_SUCCESS;
1689 }
1690 break;
1691 case IOCTL_BCM_FLASH2X_SECTION_READ :
1692 {
1693
1694 FLASH2X_READWRITE sFlash2xRead = {0};
1695 PUCHAR pReadBuff = NULL ;
1696 UINT NOB = 0;
1697 UINT BuffSize = 0;
1698 UINT ReadBytes = 0;
1699 UINT ReadOffset = 0;
1700 PUCHAR OutPutBuff = NULL;
1701
1702 if(IsFlash2x(Adapter) != TRUE)
1703 {
1704 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1705 return -EINVAL;
1706 }
1707
1708 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_FLASH2X_SECTION_READ Called");
1709 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1710 if(Status)
1711 {
1712 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1713 return Status ;
1714 }
1715
1716 //Reading FLASH 2.x READ structure
1717 Status = copy_from_user((PUCHAR)&sFlash2xRead, (PUCHAR)IoBuffer.InputBuffer,sizeof(FLASH2X_READWRITE));
1718 if(Status)
1719 {
1720 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Input Buffer failed");
1721 return Status ;
1722 }
1723
1724
1725 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xRead.Section);
1726 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%x" ,sFlash2xRead.offset);
1727 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xRead.numOfBytes);
1728 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xRead.bVerify);
1729
1730 //This was internal to driver for raw read. now it has ben exposed to user space app.
1731 if(validateFlash2xReadWrite(Adapter,&sFlash2xRead) == FALSE)
1732 return STATUS_FAILURE ;
1733
1734 NOB = sFlash2xRead.numOfBytes;
1735 if(NOB > Adapter->uiSectorSize )
1736 BuffSize = Adapter->uiSectorSize;
1737 else
1738 BuffSize = NOB ;
1739
1740 ReadOffset = sFlash2xRead.offset ;
1741 OutPutBuff = (PUCHAR)(IoBuffer.OutputBuffer) ;
1742
1743
1744 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
1745 if(pReadBuff == NULL)
1746 {
1747 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1748 return -ENOMEM;
1749 }
1750 down(&Adapter->NVMRdmWrmLock);
1751
1752 if((Adapter->IdleMode == TRUE) ||
1753 (Adapter->bShutStatus ==TRUE) ||
1754 (Adapter->bPreparingForLowPowerMode ==TRUE))
1755 {
1756 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1757 up(&Adapter->NVMRdmWrmLock);
1758 bcm_kfree(pReadBuff);
1759 return -EACCES;
1760 }
1761
1762 while(NOB)
1763 {
1764
1765 if(NOB > Adapter->uiSectorSize )
1766 ReadBytes = Adapter->uiSectorSize;
1767 else
1768 ReadBytes = NOB;
1769
1770
1771 //Reading the data from Flash 2.x
1772
1773 Status = BcmFlash2xBulkRead(Adapter,(PUINT)pReadBuff,sFlash2xRead.Section,ReadOffset,ReadBytes);
1774 if(Status)
1775 {
1776 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Flash 2x read err with Status :%d", Status);
1777 break ;
1778 }
1779
1780 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
1781
1782 Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
1783 if(Status)
1784 {
1785 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Copy to use failed with status :%d", Status);
1786 break;
1787 }
1788 NOB = NOB - ReadBytes;
1789 if(NOB)
1790 {
1791 ReadOffset = ReadOffset + ReadBytes ;
1792 OutPutBuff = OutPutBuff + ReadBytes ;
1793 }
1794
1795 }
1796 up(&Adapter->NVMRdmWrmLock);
1797 bcm_kfree(pReadBuff);
1798
1799 }
1800 break ;
1801 case IOCTL_BCM_FLASH2X_SECTION_WRITE :
1802 {
1803 FLASH2X_READWRITE sFlash2xWrite = {0};
1804 PUCHAR pWriteBuff = NULL;
1805 PUCHAR InputAddr = NULL;
1806 UINT NOB = 0;
1807 UINT BuffSize = 0;
1808 UINT WriteOffset = 0;
1809 UINT WriteBytes = 0;
1810
1811 if(IsFlash2x(Adapter) != TRUE)
1812 {
1813 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1814 return -EINVAL;
1815 }
1816
1817 //First make this False so that we can enable the Sector Permission Check in BeceemFlashBulkWrite
1818 Adapter->bAllDSDWriteAllow = FALSE;
1819
1820
1821 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_FLASH2X_SECTION_WRITE Called");
1822 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1823 if(Status)
1824 {
1825 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1826 return Status;
1827 }
1828
1829 //Reading FLASH 2.x READ structure
1830 Status = copy_from_user((PCHAR)&sFlash2xWrite, (PCHAR)IoBuffer.InputBuffer, sizeof(FLASH2X_READWRITE));
1831 if(Status)
1832 {
1833 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Reading of output Buffer from IOCTL buffer fails");
1834 return Status;
1835 }
1836
1837 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.Section :%x" ,sFlash2xWrite.Section);
1838 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.offset :%d" ,sFlash2xWrite.offset);
1839 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.numOfBytes :%x" ,sFlash2xWrite.numOfBytes);
1840 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\nsFlash2xRead.bVerify :%x\n" ,sFlash2xWrite.bVerify);
1841 #if 0
1842 if((sFlash2xWrite.Section == ISO_IMAGE1) ||(sFlash2xWrite.Section == ISO_IMAGE2) ||
1843 (sFlash2xWrite.Section == DSD0) || (sFlash2xWrite.Section == DSD1) || (sFlash2xWrite.Section == DSD2))
1844 {
1845 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"ISO/DSD Image write is not allowed.... ");
1846 return STATUS_FAILURE ;
1847 }
1848 #endif
1849 if((sFlash2xWrite.Section != VSA0) && (sFlash2xWrite.Section != VSA1) &&
1850 (sFlash2xWrite.Section != VSA2) )
1851 {
1852 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Only VSA write is allowed");
1853 return -EINVAL;
1854 }
1855
1856 if(validateFlash2xReadWrite(Adapter,&sFlash2xWrite) == FALSE)
1857 return STATUS_FAILURE ;
1858
1859 InputAddr = (PCHAR)(sFlash2xWrite.pDataBuff) ;
1860 WriteOffset = sFlash2xWrite.offset ;
1861 NOB = sFlash2xWrite.numOfBytes;
1862
1863 if(NOB > Adapter->uiSectorSize )
1864 BuffSize = Adapter->uiSectorSize;
1865 else
1866 BuffSize = NOB ;
1867
1868 pWriteBuff = (PCHAR)kmalloc(BuffSize, GFP_KERNEL);
1869 if(pWriteBuff == NULL)
1870 {
1871 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
1872 return -ENOMEM;
1873 }
1874
1875 //extracting the remainder of the given offset.
1876 WriteBytes = Adapter->uiSectorSize ;
1877 if(WriteOffset % Adapter->uiSectorSize)
1878 WriteBytes =Adapter->uiSectorSize - (WriteOffset % Adapter->uiSectorSize);
1879 if(NOB < WriteBytes)
1880 WriteBytes = NOB;
1881
1882 down(&Adapter->NVMRdmWrmLock);
1883
1884 if((Adapter->IdleMode == TRUE) ||
1885 (Adapter->bShutStatus ==TRUE) ||
1886 (Adapter->bPreparingForLowPowerMode ==TRUE))
1887 {
1888 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1889 up(&Adapter->NVMRdmWrmLock);
1890 bcm_kfree(pWriteBuff);
1891 return -EACCES;
1892 }
1893
1894 BcmFlash2xCorruptSig(Adapter,sFlash2xWrite.Section);
1895 do
1896 {
1897 Status = copy_from_user(pWriteBuff,InputAddr,WriteBytes);
1898 if(Status)
1899 {
1900 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to user failed with status :%d", Status);
1901 break ;
1902 }
1903 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pWriteBuff,WriteBytes);
1904 //Writing the data from Flash 2.x
1905 Status = BcmFlash2xBulkWrite(Adapter,(PUINT)pWriteBuff,sFlash2xWrite.Section,WriteOffset,WriteBytes,sFlash2xWrite.bVerify);
1906
1907 if(Status)
1908 {
1909 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
1910 break ;
1911 }
1912
1913 NOB = NOB - WriteBytes;
1914 if(NOB)
1915 {
1916 WriteOffset = WriteOffset + WriteBytes ;
1917 InputAddr = InputAddr + WriteBytes ;
1918 if(NOB > Adapter->uiSectorSize )
1919 WriteBytes = Adapter->uiSectorSize;
1920 else
1921 WriteBytes = NOB;
1922 }
1923
1924
1925 } while(NOB > 0);
1926 BcmFlash2xWriteSig(Adapter,sFlash2xWrite.Section);
1927 up(&Adapter->NVMRdmWrmLock);
1928 bcm_kfree(pWriteBuff);
1929 }
1930 break ;
1931 case IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP :
1932 {
1933
1934 PFLASH2X_BITMAP psFlash2xBitMap = NULL ;
1935 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_GET_FLASH2X_SECTION_BITMAP Called");
1936
1937 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1938 if(Status)
1939 {
1940 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1941 return Status;
1942 }
1943 if(IoBuffer.OutputLength != sizeof(FLASH2X_BITMAP))
1944 {
1945 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Structure size mismatch Lib :0x%lx Driver :0x%x ",IoBuffer.OutputLength, sizeof(FLASH2X_BITMAP));
1946 break;
1947 }
1948
1949 psFlash2xBitMap = (PFLASH2X_BITMAP)kzalloc(sizeof(FLASH2X_BITMAP), GFP_KERNEL);
1950 if(psFlash2xBitMap == NULL)
1951 {
1952 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory is not available");
1953 return -ENOMEM ;
1954 }
1955 //Reading the Flash Sectio Bit map
1956 down(&Adapter->NVMRdmWrmLock);
1957
1958 if((Adapter->IdleMode == TRUE) ||
1959 (Adapter->bShutStatus ==TRUE) ||
1960 (Adapter->bPreparingForLowPowerMode ==TRUE))
1961 {
1962 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
1963 up(&Adapter->NVMRdmWrmLock);
1964 bcm_kfree(psFlash2xBitMap);
1965 return -EACCES;
1966 }
1967
1968 BcmGetFlash2xSectionalBitMap(Adapter, psFlash2xBitMap);
1969 up(&Adapter->NVMRdmWrmLock);
1970 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)psFlash2xBitMap, sizeof(FLASH2X_BITMAP));
1971 if(Status)
1972 {
1973 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x bitMap failed");
1974 bcm_kfree(psFlash2xBitMap);
1975 return Status;
1976 }
1977 bcm_kfree(psFlash2xBitMap);
1978 }
1979 break ;
1980 case IOCTL_BCM_SET_ACTIVE_SECTION :
1981 {
1982 FLASH2X_SECTION_VAL eFlash2xSectionVal = 0;
1983 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_SET_ACTIVE_SECTION Called");
1984
1985 if(IsFlash2x(Adapter) != TRUE)
1986 {
1987 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
1988 return -EINVAL;
1989 }
1990
1991 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
1992 if(Status)
1993 {
1994 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
1995 return Status;
1996 }
1997
1998 Status = copy_from_user((PCHAR)&eFlash2xSectionVal,(PCHAR)IoBuffer.InputBuffer, sizeof(INT));
1999 if(Status)
2000 {
2001 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
2002 return Status;
2003 }
2004
2005 down(&Adapter->NVMRdmWrmLock);
2006
2007 if((Adapter->IdleMode == TRUE) ||
2008 (Adapter->bShutStatus ==TRUE) ||
2009 (Adapter->bPreparingForLowPowerMode ==TRUE))
2010 {
2011 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2012 up(&Adapter->NVMRdmWrmLock);
2013 return -EACCES;
2014 }
2015
2016 Status = BcmSetActiveSection(Adapter,eFlash2xSectionVal);
2017 if(Status)
2018 {
2019 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Failed to make it's priority Highest. Status %d", Status);
2020 }
2021 up(&Adapter->NVMRdmWrmLock);
2022 }
2023 break ;
2024 case IOCTL_BCM_IDENTIFY_ACTIVE_SECTION :
2025 {
2026 //Right Now we are taking care of only DSD
2027 Adapter->bAllDSDWriteAllow = FALSE ;
2028 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_IDENTIFY_ACTIVE_SECTION called");
2029
2030 #if 0
2031 SECTION_TYPE section = 0 ;
2032
2033
2034 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_IDENTIFY_ACTIVE_SECTION Called");
2035 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2036 if(Status)
2037 {
2038 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of IOCTL BUFFER failed");
2039 return Status;
2040 }
2041 Status = copy_from_user((PCHAR)section,(PCHAR)&IoBuffer, sizeof(INT));
2042 if(Status)
2043 {
2044 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Copy of section type failed failed");
2045 return Status;
2046 }
2047 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", section);
2048 if(section == DSD)
2049 Adapter->ulFlashCalStart = Adapter->uiActiveDSDOffsetAtFwDld ;
2050 else
2051 Status = STATUS_FAILURE ;
2052 #endif
2053 Status = STATUS_SUCCESS ;
2054 }
2055 break ;
2056 case IOCTL_BCM_COPY_SECTION :
2057 {
2058 FLASH2X_COPY_SECTION sCopySectStrut = {0};
2059 Status = STATUS_SUCCESS;
2060 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "IOCTL_BCM_COPY_SECTION Called");
2061
2062 Adapter->bAllDSDWriteAllow = FALSE ;
2063
2064 if(IsFlash2x(Adapter) != TRUE)
2065 {
2066 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
2067 return -EINVAL;
2068 }
2069
2070 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2071 if(Status)
2072 {
2073 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed Status :%d", Status);
2074 return Status;
2075 }
2076
2077 Status = copy_from_user((PCHAR)&sCopySectStrut,(PCHAR)IoBuffer.InputBuffer, sizeof(FLASH2X_COPY_SECTION));
2078 if(Status)
2079 {
2080 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of Copy_Section_Struct failed with Status :%d", Status);
2081 return Status;
2082 }
2083 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Source SEction :%x", sCopySectStrut.SrcSection);
2084 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "Destination SEction :%x", sCopySectStrut.DstSection);
2085 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "offset :%x", sCopySectStrut.offset);
2086 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "NOB :%x", sCopySectStrut.numOfBytes);
2087
2088
2089 if(IsSectionExistInFlash(Adapter,sCopySectStrut.SrcSection) == FALSE)
2090 {
2091 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Source Section<%x> does not exixt in Flash ", sCopySectStrut.SrcSection);
2092 return -EINVAL;
2093 }
2094
2095 if(IsSectionExistInFlash(Adapter,sCopySectStrut.DstSection) == FALSE)
2096 {
2097 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Destinatio Section<%x> does not exixt in Flash ", sCopySectStrut.DstSection);
2098 return -EINVAL;
2099 }
2100
2101 if(sCopySectStrut.SrcSection == sCopySectStrut.DstSection)
2102 {
2103 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Source and Destination section should be different");
2104 return -EINVAL;
2105 }
2106
2107 down(&Adapter->NVMRdmWrmLock);
2108
2109 if((Adapter->IdleMode == TRUE) ||
2110 (Adapter->bShutStatus ==TRUE) ||
2111 (Adapter->bPreparingForLowPowerMode ==TRUE))
2112 {
2113 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2114 up(&Adapter->NVMRdmWrmLock);
2115 return -EACCES;
2116 }
2117
2118 if(sCopySectStrut.SrcSection == ISO_IMAGE1 || sCopySectStrut.SrcSection == ISO_IMAGE2)
2119 {
2120 if(IsNonCDLessDevice(Adapter))
2121 {
2122 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Device is Non-CDLess hence won't have ISO !!");
2123 Status = -EINVAL ;
2124 }
2125 else if(sCopySectStrut.numOfBytes == 0)
2126 {
2127 Status = BcmCopyISO(Adapter,sCopySectStrut);
2128 }
2129 else
2130 {
2131 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Partial Copy of ISO section is not Allowed..");
2132 Status = STATUS_FAILURE ;
2133 }
2134 up(&Adapter->NVMRdmWrmLock);
2135 return Status;
2136 }
2137
2138 Status = BcmCopySection(Adapter, sCopySectStrut.SrcSection,
2139 sCopySectStrut.DstSection,sCopySectStrut.offset,sCopySectStrut.numOfBytes);
2140 up(&Adapter->NVMRdmWrmLock);
2141 }
2142 break ;
2143 case IOCTL_BCM_GET_FLASH_CS_INFO :
2144 {
2145 Status = STATUS_SUCCESS;
2146 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_GET_FLASH_CS_INFO Called");
2147
2148 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2149 if(Status)
2150 {
2151 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2152 break;
2153 }
2154 if(Adapter->eNVMType != NVM_FLASH)
2155 {
2156 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Connected device does not have flash");
2157 Status = -EINVAL;
2158 break;
2159 }
2160
2161 if(IsFlash2x(Adapter) == TRUE)
2162 {
2163
2164 if(IoBuffer.OutputLength < sizeof(FLASH2X_CS_INFO))
2165 {
2166 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Passed buffer size:0x%lX is insufficient for the CS structure.. \nRequired size :0x%x ",IoBuffer.OutputLength, sizeof(FLASH2X_CS_INFO));
2167 Status = -EINVAL;
2168 break;
2169 }
2170
2171 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)Adapter->psFlash2xCSInfo, sizeof(FLASH2X_CS_INFO));
2172 if(Status)
2173 {
2174 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash2x cs info failed");
2175 break;
2176 }
2177 }
2178 else
2179 {
2180 if(IoBuffer.OutputLength < sizeof(FLASH_CS_INFO))
2181 {
2182 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0," Passed buffer size:0x%lX is insufficient for the CS structure.. Required size :0x%u ",IoBuffer.OutputLength, sizeof(FLASH_CS_INFO));
2183 Status = -EINVAL;
2184 break;
2185 }
2186 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)Adapter->psFlashCSInfo, sizeof(FLASH_CS_INFO));
2187 if(Status)
2188 {
2189 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copying Flash CS info failed");
2190 break;
2191 }
2192
2193 }
2194 }
2195 break ;
2196 case IOCTL_BCM_SELECT_DSD :
2197 {
2198 UINT SectOfset = 0;
2199 FLASH2X_SECTION_VAL eFlash2xSectionVal;
2200 eFlash2xSectionVal = NO_SECTION_VAL ;
2201 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, " IOCTL_BCM_SELECT_DSD Called");
2202
2203 if(IsFlash2x(Adapter) != TRUE)
2204 {
2205 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash Does not have 2.x map");
2206 return -EINVAL;
2207 }
2208
2209 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2210 if(Status)
2211 {
2212 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2213 return Status;
2214 }
2215 Status = copy_from_user((PCHAR)&eFlash2xSectionVal,(PCHAR)IoBuffer.InputBuffer, sizeof(INT));
2216 if(Status)
2217 {
2218 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of flash section val failed");
2219 return Status;
2220 }
2221
2222 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Read Section :%d", eFlash2xSectionVal);
2223 if((eFlash2xSectionVal != DSD0) &&
2224 (eFlash2xSectionVal != DSD1) &&
2225 (eFlash2xSectionVal != DSD2) )
2226 {
2227 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Passed section<%x> is not DSD section", eFlash2xSectionVal);
2228 return STATUS_FAILURE ;
2229 }
2230
2231 SectOfset= BcmGetSectionValStartOffset(Adapter,eFlash2xSectionVal);
2232 if(SectOfset == INVALID_OFFSET)
2233 {
2234 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Provided Section val <%d> does not exixt in Flash 2.x", eFlash2xSectionVal);
2235 return -EINVAL;
2236 }
2237
2238 Adapter->bAllDSDWriteAllow = TRUE ;
2239
2240 Adapter->ulFlashCalStart = SectOfset ;
2241 Adapter->eActiveDSD = eFlash2xSectionVal;
2242 }
2243 Status = STATUS_SUCCESS ;
2244 break;
2245
2246 case IOCTL_BCM_NVM_RAW_READ :
2247 {
2248
2249 NVM_READWRITE stNVMRead = {0};
2250 INT NOB ;
2251 INT BuffSize ;
2252 INT ReadOffset = 0;
2253 UINT ReadBytes = 0 ;
2254 PUCHAR pReadBuff = NULL ;
2255 PUCHAR OutPutBuff = NULL ;
2256
2257 if(Adapter->eNVMType != NVM_FLASH)
2258 {
2259 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"NVM TYPE is not Flash ");
2260 return -EINVAL ;
2261 }
2262
2263 /* Copy Ioctl Buffer structure */
2264 if(copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER)))
2265 {
2266 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "copy_from_user 1 failed\n");
2267 Status = -EFAULT;
2268 break;
2269 }
2270
2271 if(copy_from_user(&stNVMRead, (PUCHAR)IoBuffer.OutputBuffer,sizeof(NVM_READWRITE)))
2272 {
2273 Status = -EFAULT;
2274 break;
2275 }
2276
2277 NOB = stNVMRead.uiNumBytes;
2278 //In Raw-Read max Buff size : 64MB
2279
2280 if(NOB > DEFAULT_BUFF_SIZE)
2281 BuffSize = DEFAULT_BUFF_SIZE;
2282 else
2283 BuffSize = NOB ;
2284
2285 ReadOffset = stNVMRead.uiOffset ;
2286 OutPutBuff = (PUCHAR)(stNVMRead.pBuffer) ;
2287
2288
2289 pReadBuff = (PCHAR)kzalloc(BuffSize , GFP_KERNEL);
2290 if(pReadBuff == NULL)
2291 {
2292 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Memory allocation failed for Flash 2.x Read Structure");
2293 Status = -ENOMEM;
2294 break;
2295 }
2296 down(&Adapter->NVMRdmWrmLock);
2297
2298 if((Adapter->IdleMode == TRUE) ||
2299 (Adapter->bShutStatus ==TRUE) ||
2300 (Adapter->bPreparingForLowPowerMode ==TRUE))
2301 {
2302 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Device is in Idle/Shutdown Mode\n");
2303 bcm_kfree(pReadBuff);
2304 up(&Adapter->NVMRdmWrmLock);
2305 return -EACCES;
2306 }
2307
2308 Adapter->bFlashRawRead = TRUE ;
2309 while(NOB)
2310 {
2311 if(NOB > DEFAULT_BUFF_SIZE )
2312 ReadBytes = DEFAULT_BUFF_SIZE;
2313 else
2314 ReadBytes = NOB;
2315
2316 //Reading the data from Flash 2.x
2317 Status = BeceemNVMRead(Adapter,(PUINT)pReadBuff,ReadOffset,ReadBytes);
2318 if(Status)
2319 {
2320 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Flash 2x read err with Status :%d", Status);
2321 break;
2322 }
2323
2324 BCM_DEBUG_PRINT_BUFFER(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,pReadBuff, ReadBytes);
2325
2326 Status = copy_to_user(OutPutBuff, pReadBuff,ReadBytes);
2327 if(Status)
2328 {
2329 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"Copy to use failed with status :%d", Status);
2330 break;
2331 }
2332 NOB = NOB - ReadBytes;
2333 if(NOB)
2334 {
2335 ReadOffset = ReadOffset + ReadBytes ;
2336 OutPutBuff = OutPutBuff + ReadBytes ;
2337 }
2338
2339 }
2340 Adapter->bFlashRawRead = FALSE ;
2341 up(&Adapter->NVMRdmWrmLock);
2342 bcm_kfree(pReadBuff);
2343 break ;
2344 }
2345
2346 case IOCTL_BCM_CNTRLMSG_MASK:
2347 {
2348 ULONG RxCntrlMsgBitMask = 0 ;
2349
2350 /* Copy Ioctl Buffer structure */
2351 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2352 if(Status)
2353 {
2354 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of Ioctl buffer is failed from user space");
2355 break;
2356 }
2357
2358 Status = copy_from_user(&RxCntrlMsgBitMask, IoBuffer.InputBuffer, IoBuffer.InputLength);
2359 if(Status)
2360 {
2361 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"copy of control bit mask failed from user space");
2362 break;
2363 }
2364 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"\n Got user defined cntrl msg bit mask :%lx", RxCntrlMsgBitMask);
2365 pTarang->RxCntrlMsgBitMask = RxCntrlMsgBitMask ;
2366 }
2367 break;
2368 case IOCTL_BCM_GET_DEVICE_DRIVER_INFO:
2369 {
2370 DEVICE_DRIVER_INFO DevInfo;
2371
2372 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"Called IOCTL_BCM_GET_DEVICE_DRIVER_INFO\n");
2373
2374 memset(&DevInfo,0,sizeof(DEVICE_DRIVER_INFO));
2375
2376 DevInfo.MaxRDMBufferSize = BUFFER_4K;
2377 DevInfo.u32DSDStartOffset = EEPROM_CALPARAM_START;
2378 DevInfo.u32RxAlignmentCorrection = 0;
2379 DevInfo.u32NVMType = Adapter->eNVMType;
2380
2381
2382 if(Adapter->fw_download_done == TRUE)
2383 {
2384 DevInfo.u32DeviceStatus = DEV_NOT_IN_RESET;
2385 }
2386 else
2387 {
2388 DevInfo.u32DeviceStatus = DEV_IN_RESET;
2389 }
2390
2391 #ifndef BCM_SHM_INTERFACE
2392 DevInfo.u32InterfaceType = BCM_USB;
2393
2394 #else
2395 DevInfo.u32InterfaceType = BCM_SHM;
2396 #endif
2397 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2398 if(Status)
2399 {
2400 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2401 break;
2402 }
2403 if(IoBuffer.OutputLength < sizeof(DevInfo))
2404 {
2405 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"User Passed buffer length is less than actural buffer size");
2406 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"user passed buffer size :0x%lX, expected size :0x%x",IoBuffer.OutputLength, sizeof(DevInfo));
2407 Status = -EINVAL;
2408 break;
2409 }
2410 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)&DevInfo, sizeof(DevInfo));
2411 if(Status)
2412 {
2413 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying Dev info structure to user space buffer failed");
2414 break;
2415 }
2416 }
2417 break ;
2418
2419 case IOCTL_BCM_TIME_SINCE_NET_ENTRY:
2420 {
2421 ST_TIME_ELAPSED stTimeElapsedSinceNetEntry = {0};
2422 struct timeval tv = {0} ;
2423
2424 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL,"IOCTL_BCM_TIME_SINCE_NET_ENTRY called");
2425
2426 Status = copy_from_user((PCHAR)&IoBuffer, (PCHAR)arg, sizeof(IOCTL_BUFFER));
2427 if(Status)
2428 {
2429 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0, "Copy of IOCTL BUFFER failed");
2430 break;
2431 }
2432 if(IoBuffer.OutputLength < sizeof(ST_TIME_ELAPSED))
2433 {
2434 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"User Passed buffer length:0x%lx is less than expected buff size :0x%X",IoBuffer.OutputLength,sizeof(ST_TIME_ELAPSED));
2435 Status = -EINVAL;
2436 break;
2437 }
2438
2439 //stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = Adapter->liTimeSinceLastNetEntry;
2440 do_gettimeofday(&tv);
2441 stTimeElapsedSinceNetEntry.ul64TimeElapsedSinceNetEntry = tv.tv_sec - Adapter->liTimeSinceLastNetEntry;
2442
2443 Status = copy_to_user((PCHAR)IoBuffer.OutputBuffer, (PCHAR)&stTimeElapsedSinceNetEntry, sizeof(ST_TIME_ELAPSED));
2444 if(Status)
2445 {
2446 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_PRINTK, 0, 0,"copying ST_TIME_ELAPSED structure to user space buffer failed");
2447 break;
2448 }
2449
2450 }
2451 break;
2452
2453 default:
2454 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_PRINTK, 0, 0, "wrong input %x",cmd);
2455 BCM_DEBUG_PRINT (Adapter, DBG_TYPE_OTHERS, OSAL_DBG, DBG_LVL_ALL, "In default ioctl %d\n", cmd);
2456 Status = STATUS_FAILURE;
2457
2458 break;
2459 }
2460 return Status;
2461 }
2462
2463 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
2464 static INT bcm_char_unlocked_ioctl(struct file *filp,
2465 UINT cmd, ULONG arg)
2466 {
2467 return bcm_char_ioctl(NULL, filp, cmd, arg);
2468 }
2469 #endif
2470
2471 static struct file_operations bcm_fops = {
2472 .owner = THIS_MODULE,
2473 .open = bcm_char_open,
2474 .release = bcm_char_release,
2475 .read = bcm_char_read,
2476 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36)
2477 .unlocked_ioctl = bcm_char_unlocked_ioctl
2478 #else
2479 .ioctl = bcm_char_ioctl
2480 #endif
2481 };
2482
2483
2484 int register_control_device_interface(PMINI_ADAPTER Adapter)
2485 {
2486 if(Adapter->major>0)
2487 return Adapter->major;
2488 Adapter->major = register_chrdev(0, "tarang", &bcm_fops);
2489 if(Adapter->major < 0)
2490 {
2491 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "register_chrdev:Failed to registering WiMax control char device!");
2492 return Adapter->major;
2493 }
2494
2495 bcm_class = NULL;
2496 bcm_class = class_create (THIS_MODULE, "tarang");
2497 if(IS_ERR (bcm_class))
2498 {
2499 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Unable to create class\n");
2500 unregister_chrdev(Adapter->major, "tarang");
2501 Adapter->major = 0;
2502 return -ENODEV;
2503 }
2504 Adapter->pstCreatedClassDevice = device_create (bcm_class, NULL,
2505 MKDEV(Adapter->major, 0),
2506 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,26)
2507 NULL ,
2508 #endif
2509 "tarang");
2510
2511 if(IS_ERR(Adapter->pstCreatedClassDevice))
2512 {
2513 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "class device did not get created : %ld", PTR_ERR(Adapter->pstCreatedClassDevice) );
2514 }
2515 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "Got Major No: %d", Adapter->major);
2516 return 0;
2517 }
2518
2519 void unregister_control_device_interface(PMINI_ADAPTER Adapter)
2520 {
2521 if(Adapter->major > 0)
2522 {
2523 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying class device");
2524 device_destroy (bcm_class, MKDEV(Adapter->major, 0));
2525 }
2526 if(!IS_ERR(bcm_class))
2527 {
2528 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL, "destroying created class ");
2529 class_destroy (bcm_class);
2530 bcm_class = NULL;
2531 }
2532 if(Adapter->major > 0)
2533 {
2534 BCM_DEBUG_PRINT(Adapter,DBG_TYPE_INITEXIT, DRV_ENTRY, DBG_LVL_ALL,"unregistering character interface");
2535 unregister_chrdev(Adapter->major, "tarang");
2536 }
2537
2538 }
Tomato firmware and modifications.