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