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