?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Copied sources from OpenWRT project
[hides-driver.git] / src / it951x-core.c
blobd3541cfa741c99a9c9600aa8a55f771ae083be31
1 /**
2 * Copyright (c) 2016 ITE Corporation. All rights reserved.
3 *
4 * Module Name:
5 * IT951x Core
6 *
7 * Abstract:
8 * The core of IT951x serial driver.
9 */
10
11 #include "it951x-core.h"
12 #include "iocontrol.h"
13
14 static DEFINE_MUTEX(it951x_urb_kill);
15 static DEFINE_MUTEX(it951x_rb_mutex);
16 static Byte tx_usb_handles[TX_MAX_USB_HANDLE_NUM] = {0};
17
18 #define to_afa_dev(d) container_of(d, struct it951x_dev, kref)
19
20 static struct usb_driver it951x_driver;
21
22 struct usb_device_id it951x_usb_id_table[] = {
23 { USB_DEVICE(0x048D,0x9517) },
24 { 0}, /* Terminating entry */
25 };
26 MODULE_DEVICE_TABLE(usb, it951x_usb_id_table);
27
28 /* AirHD */
29 Dword Tx_RMRingBuffer(struct it951x_urb_context *context, Dword dwDataFrameSize)
30 {
31 struct it951x_dev *dev = context->dev;
32 //Dword dwBuffLen = 0;
33 unsigned long flags = 0;
34
35 #if RB_DEBUG
36 deb_data("Enter %s", __func__);
37 deb_data("Tx_RMRingBuffer: dev->TxCurrBuffPointAddr %lu", dev->TxCurrBuffPointAddr);
38 #endif
39 spin_lock_irqsave(&dev->TxRBKeyLock, flags);
40 //dev->TxCurrBuffPointAddr = (dev->TxCurrBuffPointAddr + dwDataFrameSize) % (dev->dwTxWriteTolBufferSize);// add by EE 0110
41 //dev->dwTxRemaingBufferSize += dwDataFrameSize;// add by EE 0110
42 dev->TxCurrBuffPointAddr = (dev->TxCurrBuffPointAddr + URB_BUFSIZE_TX) % (dev->dwTxWriteTolBufferSize);// add by EE 0110
43 dev->dwTxRemaingBufferSize += URB_BUFSIZE_TX;// add by EE 0110
44 dev->tx_urb_counter++;
45 spin_unlock_irqrestore(&dev->TxRBKeyLock, flags);
46
47 dev->tx_urbstatus[context->index] = 0;
48 return 0;
49 }
50
51 /* AirHD for low bitrate */
52 Dword Tx_RMRingBuffer_low_brate(struct it951x_urb_context *context, Dword dwDataFrameSize)
53 {
54 struct it951x_dev *dev = context->dev;
55 //Dword dwBuffLen = 0;
56 unsigned long flags = 0;
57
58 #if RB_DEBUG
59 deb_data("Enter %s", __func__);
60 deb_data("Tx_RMRingBuffer_low_brate: dev->TxCurrBuffPointAddr %lu", dev->TxCurrBuffPointAddr_low_brate);
61 #endif
62 spin_lock_irqsave(&dev->TxRBKeyLock_low_brate, flags);
63 dev->TxCurrBuffPointAddr_low_brate = (dev->TxCurrBuffPointAddr_low_brate + URB_BUFSIZE_TX_LOW_BRATE) % (dev->dwTxWriteTolBufferSize_low_brate);
64 dev->dwTxRemaingBufferSize_low_brate += URB_BUFSIZE_TX_LOW_BRATE;
65 dev->tx_urb_counter_low_brate++;
66 spin_unlock_irqrestore(&dev->TxRBKeyLock_low_brate, flags);
67
68 dev->tx_urbstatus_low_brate[context->index] = 0;
69 return 0;
70 }
71
72 /* AirHD for cmd */
73 #if RETURN_CHANNEL
74 Dword Tx_RMRingBuffer_cmd(struct it951x_urb_context *context, Dword dwDataFrameSize)
75 {
76 struct it951x_dev *dev = context->dev;
77 //deb_data("enter %s", __func__);
78 //deb_data("RMRingBuffer: (*dev->pWriteCurrBuffPointAddr) %d", (*dev->pWriteCurrBuffPointAddr));
79 unsigned long flags;
80
81 spin_lock_irqsave(&dev->TxRBKeyLock_cmd, flags);
82 //spin_lock_irqsave(&Write_RingBuffer_Lock, flags);
83 *dev->pTxCurrBuffPointAddr_cmd =
84 (*dev->pTxCurrBuffPointAddr_cmd + dwDataFrameSize) % dev->dwTxWriteTolBufferSize_cmd;
85
86 dev->dwTxRemaingBufferSize_cmd += dwDataFrameSize;
87 dev->tx_urbstatus_cmd[context->index] = 0;
88 spin_unlock_irqrestore(&dev->TxRBKeyLock_cmd, flags);
89
90 return 0;
91 }
92 #endif
93
94 static void
95 tx_free_urbs(struct it951x_dev *dev)
96 {
97 int i;
98 //deb_data("Enter %s Function\n",__FUNCTION__);
99
100 for (i = 0; i < URB_COUNT_TX; i++) {
101 usb_free_urb(dev->tx_urbs[i]);
102 dev->tx_urbs[i] = NULL;
103 }
104 for(i = 0; i < URB_COUNT_TX_LOW_BRATE; i++){
105 usb_free_urb(dev->tx_urbs_low_brate[i]);
106 dev->tx_urbs_low_brate[i] = NULL;
107 }
108 #if RETURN_CHANNEL
109 for(i = 0; i < URB_COUNT_TX_CMD; i++){
110 usb_free_urb(dev->tx_urbs_cmd[i]);
111 dev->tx_urbs_cmd[i] = NULL;
112 }
113 #endif
114 deb_data("%s() end\n", __func__);
115 }
116
117 static int tx_stop_urb_transfer(struct it951x_dev *dev)
118 {
119 deb_data("%s()\n", __func__);
120
121 if (!dev->tx_urb_streaming && !dev->tx_urb_streaming_low_brate) {
122 deb_data("%s: iso xfer already stop!\n", __func__);
123 return 0;
124 }
125
126 dev->tx_urb_streaming = 0;
127 dev->tx_urb_streaming_low_brate = 0;
128
129
130 /*DM368 usb bus error when using kill urb */
131
132 return 0;
133 }
134 #if RETURN_CHANNEL
135 static int tx_stop_urb_transfer_cmd(struct it951x_dev *dev)
136 {
137 deb_data("%s()\n", __func__);
138
139 if (!dev->tx_urb_streaming_cmd) {
140 deb_data("%s: iso xfer already stop!\n", __func__);
141 return 0;
142 }
143
144 dev->tx_urb_streaming_cmd = 0;
145
146 /*DM368 usb bus error when using kill urb */
147 deb_data("%s() end\n", __func__);
148
149 return 0;
150 }
151 #endif
152 DWORD fabs_self(DWORD a, DWORD b)
153 {
154 DWORD c = 0;
155
156 c = a - b;
157 if(c >= 0) return c;
158 else return c * -1;
159 }
160
161 /**
162 * Tx_RingBuffer - Eagle the core of write Ring-Buffer.
163 * Description:
164 * Successful submissions return 0(Error_NO_ERROR) and submited buffer length.
165 * Otherwise this routine returns a negative error number.
166 */
167 DWORD Tx_RingBuffer(
168 struct it951x_dev *dev,
169 Byte* pBuffer,
170 Dword* pBufferLength)
171 {
172 Dword dwBuffLen = 0;
173 Dword dwCpBuffLen = *pBufferLength;
174 Dword dwCurrBuffAddr = dev->TxCurrBuffPointAddr;
175 Dword dwWriteBuffAddr = dev->TxWriteBuffPointAddr;
176 Dword remainingSize = dev->dwTxRemaingBufferSize;
177 int ret = -ENOMEM;
178
179 #if RB_DEBUG
180 deb_data("RemaingBufferSize: {%lu}\n", dev->dwTxRemaingBufferSize);
181 deb_data("Tx_RingBuffer-CPLen %lu, dwCurrBuffAddr %lu, dwWriteBuffAddr %lu\n", dwCpBuffLen, dwCurrBuffAddr, dwWriteBuffAddr);
182 #endif
183 /* RingBuffer full */
184 if ((remainingSize) == 0) {
185 *pBufferLength = 0;
186 #if RB_DEBUG
187 deb_data("dwTxRemaingBufferSize = 0\n");
188 #endif
189 return Error_BUFFER_INSUFFICIENT;
190 }
191
192 if ((remainingSize) < dwCpBuffLen) {
193 *pBufferLength = 0;
194 #if RB_DEBUG
195 deb_data("dwTxRemaingBufferSize < dwCpBuffLen\n");
196 #endif
197 return Error_BUFFER_INSUFFICIENT;
198 }
199
200 if (*pBufferLength == 0) {
201 if (dev->tx_urb_streaming == 1) {
202 //add by EE 0110
203 /* allow submit urb */
204 if(dwWriteBuffAddr % URB_BUFSIZE_TX == 0){
205 return Error_NO_ERROR;
206 }
207 dwBuffLen = dwWriteBuffAddr - (dev->tx_urb_index * URB_BUFSIZE_TX);
208 if (dwBuffLen < 0) {
209 deb_data("\n\n\n%s(add by EE): dwBuffLen < 0, dwBuffLen = %lu\n\n\n", __func__, dwBuffLen);
210 return Error_BUFFER_INSUFFICIENT;
211 }
212 dev->tx_urbs[dev->tx_urb_index]->transfer_buffer_length = dwBuffLen;
213 ret = usb_submit_urb(dev->tx_urbs[dev->tx_urb_index], GFP_ATOMIC);
214 if (ret != 0) {
215 tx_stop_urb_transfer(dev);
216 deb_data("%s(add by EE): failed urb submission, err = %d\n", __func__, ret);
217 return ret;
218 }
219
220 dev->TxWriteBuffPointAddr = (dev->TxWriteBuffPointAddr + (URB_BUFSIZE_TX - dwBuffLen)) % (dev->dwTxWriteTolBufferSize);
221 dev->dwTxRemaingBufferSize -= (URB_BUFSIZE_TX - dwBuffLen);
222
223 dev->tx_urbstatus[dev->tx_urb_index] = 1;
224 dev->tx_urb_index = (dev->tx_urb_index + 1) % URB_COUNT_TX;
225 dev->tx_urb_counter--;
226 }
227
228 return Error_NO_ERROR;
229 }
230
231 /* memory must enough because checking at first in this function */
232 if (dwWriteBuffAddr >= dwCurrBuffAddr) {
233 /* To_kernel_urb not run a cycle or both run a cycle */
234 dwBuffLen = dev->dwTxWriteTolBufferSize - dwWriteBuffAddr;
235 if (dwBuffLen >= dwCpBuffLen) {
236 copy_from_user(dev->pTxRingBuffer + dwWriteBuffAddr, pBuffer, dwCpBuffLen);
237 }
238 else {
239 copy_from_user(dev->pTxRingBuffer + dwWriteBuffAddr, pBuffer, dwBuffLen);
240 copy_from_user(dev->pTxRingBuffer, pBuffer + dwBuffLen, dwCpBuffLen - dwBuffLen);
241 }
242 }
243 else {
244 /* To_kernel_urb run a cycle and Return_urb not */
245 copy_from_user(dev->pTxRingBuffer + dwWriteBuffAddr, pBuffer, dwCpBuffLen);
246 }
247
248 dev->TxWriteBuffPointAddr = (dev->TxWriteBuffPointAddr + dwCpBuffLen) % (dev->dwTxWriteTolBufferSize);
249 dev->dwTxRemaingBufferSize -= dwCpBuffLen;
250 dwWriteBuffAddr = dev->TxWriteBuffPointAddr;
251
252 if (dev->tx_urb_streaming == 1) {
253 /* allow submit urb */
254 while (((dwWriteBuffAddr - (dev->tx_urb_index * URB_BUFSIZE_TX)) >= URB_BUFSIZE_TX ||
255 (dwWriteBuffAddr < (dev->tx_urb_index * URB_BUFSIZE_TX))) && dev->tx_urb_counter > 0) {
256 /* while urb full and not submit */
257 dev->tx_urbs[dev->tx_urb_index]->transfer_buffer_length = URB_BUFSIZE_TX; //add by EE 0110
258 ret = usb_submit_urb(dev->tx_urbs[dev->tx_urb_index], GFP_ATOMIC);
259 if (ret != 0) {
260 tx_stop_urb_transfer(dev);
261 #if RB_DEBUG
262 deb_data("%s: failed urb submission, err = %d\n", __func__, ret);
263 #endif
264 return ret;
265 }
266
267 dev->tx_urbstatus[dev->tx_urb_index] = 1;
268 dev->tx_urb_index = (dev->tx_urb_index + 1) % URB_COUNT_TX;
269 dev->tx_urb_counter--;
270 }
271 }
272
273 return Error_NO_ERROR;
274 }
275
276 /* AirHD low bitrate */
277 DWORD Tx_RingBuffer_low_brate(
278 struct it951x_dev *dev,
279 Byte* pBuffer,
280 Dword* pBufferLength)
281 {
282 Dword dwBuffLen = 0;
283 Dword dwCpBuffLen = *pBufferLength;
284 Dword dwCurrBuffAddr = dev->TxCurrBuffPointAddr_low_brate;
285 Dword dwWriteBuffAddr = dev->TxWriteBuffPointAddr_low_brate;
286 Dword remainingSize = dev->dwTxRemaingBufferSize_low_brate;
287 int ret = -ENOMEM;
288
289 #if RB_DEBUG
290 deb_data("RemaingBufferSize_low_brate: {%lu}\n", dev->dwTxRemaingBufferSize_low_brate);
291 deb_data("Tx_RingBuffer_low_brate-CPLen %lu, dwCurrBuffAddr_low_brate %lu, dwWriteBuffAddr_low_brate %lu\n",
292 dwCpBuffLen, dwCurrBuffAddr, dwWriteBuffAddr);
293 #endif
294 /* RingBuffer full */
295 if ((remainingSize) == 0) {
296 *pBufferLength = 0;
297 #if RB_DEBUG
298 deb_data("dwTxRemaingBufferSize_low_brate = 0\n");
299 #endif
300 return Error_BUFFER_INSUFFICIENT;
301 }
302
303 if ((remainingSize) < dwCpBuffLen) {
304 *pBufferLength = 0;
305 #if RB_DEBUG
306 deb_data("dwTxRemaingBufferSize_low_brate < dwCpBuffLen\n");
307 #endif
308 return Error_BUFFER_INSUFFICIENT;
309 }
310
311 if (*pBufferLength == 0) {
312 if (dev->tx_urb_streaming_low_brate == 1) {
313 dwBuffLen = dwWriteBuffAddr - (dev->tx_urb_index_low_brate * URB_BUFSIZE_TX_LOW_BRATE);
314 if (dwBuffLen > 0) {
315 dev->tx_urbs_low_brate[dev->tx_urb_index_low_brate]->transfer_buffer_length = dwBuffLen;
316 ret = usb_submit_urb(dev->tx_urbs_low_brate[dev->tx_urb_index_low_brate], GFP_ATOMIC);
317 if (ret != 0) {
318 tx_stop_urb_transfer(dev);
319 deb_data("%s: failed urb submission immediately _low_brate, err = %d\n", __func__, ret);
320 return ret;
321 }
322
323 dev->tx_urbstatus_low_brate[dev->tx_urb_index_low_brate] = 1;
324 dev->tx_urb_index_low_brate = (dev->tx_urb_index_low_brate + 1) % URB_COUNT_TX_LOW_BRATE;
325 dev->tx_urb_counter_low_brate--;
326
327 dev->TxWriteBuffPointAddr_low_brate = dev->tx_urb_index_low_brate * URB_BUFSIZE_TX_LOW_BRATE;
328 dev->dwTxRemaingBufferSize_low_brate -= (URB_BUFSIZE_TX_LOW_BRATE - dwBuffLen);
329 }
330 }
331
332 return Error_NO_ERROR;
333 }
334
335
336 /* memory must enough because checking at first in this function */
337 if (dwWriteBuffAddr >= dwCurrBuffAddr) {
338 /* To_kernel_urb not run a cycle or both run a cycle */
339 dwBuffLen = dev->dwTxWriteTolBufferSize_low_brate - dwWriteBuffAddr;
340 if (dwBuffLen >= dwCpBuffLen) {
341 copy_from_user(dev->pTxRingBuffer_low_brate + dwWriteBuffAddr, pBuffer, dwCpBuffLen);
342 }
343 else {
344 copy_from_user(dev->pTxRingBuffer_low_brate + dwWriteBuffAddr, pBuffer, dwBuffLen);
345 copy_from_user(dev->pTxRingBuffer_low_brate, pBuffer + dwBuffLen, dwCpBuffLen - dwBuffLen);
346 }
347 }
348 else {
349 copy_from_user(dev->pTxRingBuffer_low_brate + dwWriteBuffAddr, pBuffer, dwCpBuffLen);
350 }
351
352 dev->TxWriteBuffPointAddr_low_brate = (dev->TxWriteBuffPointAddr_low_brate + dwCpBuffLen) % (dev->dwTxWriteTolBufferSize_low_brate);
353 dev->dwTxRemaingBufferSize_low_brate -= dwCpBuffLen;
354 dwWriteBuffAddr = dev->TxWriteBuffPointAddr_low_brate;
355
356 if (dev->tx_urb_streaming_low_brate == 1) {
357 /* allow submit urb */
358 while (((dwWriteBuffAddr - (dev->tx_urb_index_low_brate * URB_BUFSIZE_TX_LOW_BRATE)) >= URB_BUFSIZE_TX_LOW_BRATE ||
359 (dwWriteBuffAddr < (dev->tx_urb_index_low_brate * URB_BUFSIZE_TX_LOW_BRATE))) && dev->tx_urb_counter_low_brate > 0) {
360 /* while urb full and not submit */
361 dev->tx_urbs_low_brate[dev->tx_urb_index_low_brate]->transfer_buffer_length = URB_BUFSIZE_TX_LOW_BRATE; //add by EE 0110
362 ret = usb_submit_urb(dev->tx_urbs_low_brate[dev->tx_urb_index_low_brate], GFP_ATOMIC);
363 if (ret != 0) {
364 tx_stop_urb_transfer(dev);
365 #if RB_DEBUG
366 deb_data("%s: failed urb submission _low_brate, err = %d\n", __func__, ret);
367 #endif
368 return ret;
369 }
370
371 dev->tx_urbstatus_low_brate[dev->tx_urb_index_low_brate] = 1;
372 dev->tx_urb_index_low_brate = (dev->tx_urb_index_low_brate + 1) % URB_COUNT_TX_LOW_BRATE;
373 dev->tx_urb_counter_low_brate--;
374 }
375 }
376
377 return Error_NO_ERROR;
378 }
379
380 /* AirHD_CMD */
381 #if RETURN_CHANNEL
382 DWORD Tx_RingBuffer_cmd(
383 struct it951x_dev *dev,
384 Byte* pBuffer,
385 Dword* pBufferLength)
386 {
387 unsigned long flags = 0;
388 DWORD dwBuffLen = 0;
389 DWORD dwCpBuffLen = *pBufferLength;
390 DWORD dwCurrBuffAddr = (*dev->pTxCurrBuffPointAddr_cmd);
391 DWORD dwWriteBuffAddr = (*dev->pTxWriteBuffPointAddr_cmd);
392 Dword error = Error_NO_ERROR;
393 bool RingBufferOverWrite = false;
394
395
396 spin_lock_irqsave(&dev->TxRBKeyLock_cmd, flags);
397
398 if (*pBufferLength == 0)
399 {
400 error = Error_BUFFER_INSUFFICIENT;
401 goto exit;
402 }
403
404 if((dev->dwTxRemaingBufferSize_cmd == 0) || (dev->dwTxRemaingBufferSize_cmd < dwCpBuffLen))
405 {
406 *pBufferLength = 0;
407 error = Error_NO_ERROR;
408 goto exit;
409 }
410
411 if(dwWriteBuffAddr >= dwCurrBuffAddr)
412 {
413 dwBuffLen = dev->dwTxWriteTolBufferSize_cmd - dwWriteBuffAddr;
414 if(dwBuffLen < dwCpBuffLen)
415 {
416 copy_from_user(dev->pWriteFrameBuffer_cmd+dwWriteBuffAddr, pBuffer, dwBuffLen);
417 copy_from_user(dev->pWriteFrameBuffer_cmd, pBuffer+dwBuffLen, dwCpBuffLen-dwBuffLen);
418 RingBufferOverWrite = true;
419 }
420 else
421 copy_from_user(dev->pWriteFrameBuffer_cmd+dwWriteBuffAddr, pBuffer, dwCpBuffLen);
422 }
423 else
424 copy_from_user(dev->pWriteFrameBuffer_cmd+dwWriteBuffAddr, pBuffer, dwCpBuffLen);
425
426
427 *dev->pTxWriteBuffPointAddr_cmd = (*dev->pTxWriteBuffPointAddr_cmd+dwCpBuffLen) % dev->dwTxWriteTolBufferSize_cmd;
428 dev->dwTxRemaingBufferSize_cmd -= *pBufferLength;
429
430
431 if((*dev->pTxWriteBuffPointAddr_cmd) < (dev->tx_urb_index_cmd*URB_BUFSIZE_TX_CMD))
432 {
433 while(1)
434 {
435 if(!dev->tx_urbstatus_cmd[dev->tx_urb_index_cmd])
436 {
437 error = usb_submit_urb(dev->tx_urbs_cmd[dev->tx_urb_index_cmd], GFP_ATOMIC);
438 if (error != 0) {
439 tx_stop_urb_transfer_cmd(dev);
440 deb_data("%s: failed urb submission, err = %lu\n", __func__, error);
441 goto exit;
442 }//else deb_data("usb_submit_urb cmd ok \n");
443
444 dev->tx_urbstatus_cmd[dev->tx_urb_index_cmd] = 1;
445 }
446
447 dev->tx_urb_index_cmd++;
448 if(dev->tx_urb_index_cmd == URB_COUNT_TX_CMD)
449 {
450 dev->tx_urb_index_cmd = 0;
451 break;
452 }
453 }
454 }
455
456 while(((*dev->pTxWriteBuffPointAddr_cmd - (dev->tx_urb_index_cmd*URB_BUFSIZE_TX_CMD)) >= URB_BUFSIZE_TX_CMD)
457 || (RingBufferOverWrite == true))
458 {
459 if(!dev->tx_urbstatus_cmd[dev->tx_urb_index_cmd])
460 {
461 error = usb_submit_urb(dev->tx_urbs_cmd[dev->tx_urb_index_cmd], GFP_ATOMIC);
462 if (error != 0) {
463 tx_stop_urb_transfer_cmd(dev);
464 deb_data("%s: failed urb submission, err = %lu\n", __func__, error);
465 goto exit;
466 }//else deb_data("usb_submit_urb cmd ok \n");
467
468 dev->tx_urbstatus_cmd[dev->tx_urb_index_cmd] = 1;
469 }
470
471 dev->tx_urb_index_cmd++;
472 if(dev->tx_urb_index_cmd == URB_COUNT_TX_CMD)
473 {
474 dev->tx_urb_index_cmd = 0;
475 RingBufferOverWrite = false;
476 }
477 }
478
479 exit:
480
481 spin_unlock_irqrestore(&dev->TxRBKeyLock_cmd, flags);
482
483 return error;
484
485 }
486 #endif
487
488 /******************************************************************/
489
490 static void tx_urb_completion(struct urb *purb, struct pt_regs *ppt_regs)
491 {
492 struct it951x_urb_context *context = purb->context;
493 int ptype = usb_pipetype(purb->pipe);
494
495 #if RB_DEBUG
496 deb_data("Enter %s", __func__);
497
498 deb_data("urb id: %d. '%s' urb completed. status: %d, length: %d/%d, pack_num: %d, errors: %d\n",
499 context->index,
500 ptype == PIPE_ISOCHRONOUS ? "isoc" : "bulk",
501 purb->status,purb->actual_length,purb->transfer_buffer_length,
502 purb->number_of_packets,purb->error_count);
503 #endif
504 //context->dev->tx_urbstatus[context->index] = 0;
505 switch (purb->status) {
506 case 0: /* success */
507 case -ETIMEDOUT: /* NAK */
508 break;
509 case -ECONNRESET: /* kill */
510 case -ENOENT:
511 //context->dev->urb_use_count++;
512 deb_data("TX ENOENT-urb completition error %d.\n", purb->status);
513 case -ESHUTDOWN:
514 return;
515 default: /* error */
516 deb_data("TX urb completition error %d.\n", purb->status);
517 break;
518 }
519
520 if (!context->dev) return;
521
522 //if (context->dev->tx_urb_streaming == 0) return;
523
524 if (ptype != PIPE_BULK) {
525 deb_data("TX %s() Unsupported URB type %d\n", __func__, ptype);
526 return;
527 }
528
529 //ptr = (u8 *)purb->transfer_buffer;
530 /* Feed the transport payload into the kernel demux */
531 //dvb_dmx_swfilter_packets(&dev->dvb.demux,
532 // purb->transfer_buffer, purb->actual_length / 188);
533 //if (purb->actual_length > 0)
534
535 Tx_RMRingBuffer(context, URB_BUFSIZE_TX);
536
537 return;
538 }
539
540 static void tx_urb_completion_low_brate(struct urb *purb, struct pt_regs *ppt_regs)
541 {
542 struct it951x_urb_context *context = purb->context;
543 int ptype = usb_pipetype(purb->pipe);
544
545 #if RB_DEBUG
546 deb_data("Enter %s", __func__);
547
548 deb_data("_low_brate urb id: %d. '%s' urb completed. status: %d, length: %d/%d, pack_num: %d, errors: %d\n",
549 context->index,
550 ptype == PIPE_ISOCHRONOUS ? "isoc" : "bulk",
551 purb->status,purb->actual_length,purb->transfer_buffer_length,
552 purb->number_of_packets,purb->error_count);
553 #endif
554 //context->dev->tx_urbstatus[context->index] = 0;
555 switch (purb->status) {
556 case 0: /* success */
557 case -ETIMEDOUT: /* NAK */
558 break;
559 case -ECONNRESET: /* kill */
560 case -ENOENT:
561 //context->dev->urb_use_count++;
562 deb_data("TX_low_brate ENOENT-urb completition error %d.\n", purb->status);
563 case -ESHUTDOWN:
564 return;
565 default: /* error */
566 deb_data("TX_low_brate urb completition error %d.\n", purb->status);
567 break;
568 }
569
570 if (!context->dev) return;
571
572 //if (context->dev->tx_urb_streaming_low_brate == 0) return;
573
574 if (ptype != PIPE_BULK) {
575 deb_data("TX_low_brate %s() Unsupported URB type %d\n", __func__, ptype);
576 return;
577 }
578
579 //ptr = (u8 *)purb->transfer_buffer;
580 /* Feed the transport payload into the kernel demux */
581 //dvb_dmx_swfilter_packets(&dev->dvb.demux,
582 // purb->transfer_buffer, purb->actual_length / 188);
583 //if (purb->actual_length > 0)
584
585 Tx_RMRingBuffer_low_brate(context, URB_BUFSIZE_TX_LOW_BRATE);
586
587 return;
588 }
589 #if RETURN_CHANNEL
590 static void tx_urb_completion_cmd(struct urb *purb, struct pt_regs *ppt_regs)
591 {
592 struct it951x_urb_context *context = purb->context;
593 int ptype = usb_pipetype(purb->pipe);
594 //deb_data("enter %s", __func__);
595
596 //deb_data("'%s' urb completed. status: %d, length: %d/%d, pack_num: %d, errors: %d\n",
597 // ptype == PIPE_ISOCHRONOUS ? "isoc" : "bulk",
598 // purb->status,purb->actual_length,purb->transfer_buffer_length,
599 // purb->number_of_packets,purb->error_count);
600
601 //context->dev->tx_urbstatus_cmd[context->index] = 0;
602 switch (purb->status) {
603 case 0: /* success */
604 case -ETIMEDOUT: /* NAK */
605 break;
606 case -ECONNRESET: /* kill */
607 case -ENOENT:
608 //context->dev->urb_use_count_cmd++;
609 deb_data("TX ENOENT-urb completition error %d.\n", purb->status);
610 case -ESHUTDOWN:
611 return;
612 default: /* error */
613 deb_data("TX urb completition error %d.\n", purb->status);
614 break;
615 }
616
617 if (!context->dev) return;
618
619 if (context->dev->tx_urb_streaming_cmd == 0) return;
620
621 if (ptype != PIPE_BULK) {
622 deb_data("TX %s() Unsupported URB type %d\n", __func__, ptype);
623 return;
624 }
625
626 //ptr = (u8 *)purb->transfer_buffer;
627 /* Feed the transport payload into the kernel demux */
628 //dvb_dmx_swfilter_packets(&dev->dvb.demux,
629 // purb->transfer_buffer, purb->actual_length / 188);
630 //if (purb->actual_length > 0)
631
632 Tx_RMRingBuffer_cmd(context, URB_BUFSIZE_TX_CMD);
633
634 return;
635 }
636 #endif
637
638 /* AirHD */
639 static int tx_start_urb_transfer(struct it951x_dev *dev)
640 {
641
642 //int i;
643 int ret = -ENOMEM;
644
645 deb_data("%s()\n", __func__);
646 if (dev->tx_urb_streaming || dev->tx_urb_streaming_low_brate) {
647 deb_data("%s: iso xfer already running!\n", __func__);
648 return 0;
649 }
650
651 /* Write ring buffer */
652 dev->TxCurrBuffPointAddr = 0;
653 dev->TxWriteBuffPointAddr = 0;
654 dev->dwTxRemaingBufferSize = dev->dwTxWriteTolBufferSize;
655 dev->tx_urb_index = 0;
656 dev->tx_urb_streaming = 1;
657 dev->tx_urb_counter = URB_COUNT_TX;
658
659 /* Write ring buffer low brate */
660 dev->TxCurrBuffPointAddr_low_brate = 0;
661 dev->TxWriteBuffPointAddr_low_brate = 0;
662 dev->dwTxRemaingBufferSize_low_brate = dev->dwTxWriteTolBufferSize_low_brate;
663 dev->tx_urb_index_low_brate = 0;
664 dev->tx_urb_streaming_low_brate = 1;
665 dev->tx_urb_counter_low_brate = URB_COUNT_TX_LOW_BRATE;
666
667 ret = 0;
668
669 //deb_data("%s() end\n", __func__);
670
671 return ret;
672 }
673
674 /* AirHD_CMD */
675 #if RETURN_CHANNEL
676 static int tx_start_urb_transfer_cmd(struct it951x_dev *dev)
677 {
678 int ret = -ENOMEM;
679
680 deb_data("%s()\n", __func__);
681
682 if (dev->tx_urb_streaming_cmd) {
683 deb_data("%s: iso xfer already running!\n", __func__);
684 return 0;
685 }
686
687 *(dev->pTxCurrBuffPointAddr_cmd) = 0;
688 *(dev->pTxWriteBuffPointAddr_cmd) = 0;
689 dev->dwTxRemaingBufferSize_cmd = dev->dwTxWriteTolBufferSize_cmd;
690 dev->tx_urb_index_cmd = 0;
691 dev->tx_urb_streaming_cmd = 1;
692 ret = 0;
693
694 deb_data("%s() end\n", __func__);
695 return ret;
696 }
697 #endif
698
699 static int it951x_usb_open(struct inode *inode, struct file *file)
700 {
701 struct it951x_dev *dev;
702 struct usb_interface *interface;
703 int subminor, mainsubminor;
704 int retval = 0;
705 int error;
706
707 deb_data("it951x_usb_rx_open function\n");
708 mainsubminor = iminor(inode);
709 subminor = iminor(inode);
710 interface = usb_find_interface(&it951x_driver, subminor);
711
712 try:
713 while (!interface) {
714 subminor++;
715 interface = usb_find_interface(&it951x_driver, subminor);
716 if (subminor >= mainsubminor + USB_it91xx_MINOR_RANGE)
717 break;
718 }
719
720 if (!interface) {
721 deb_data("%s - error, can't find device for minor %d",
722 __FUNCTION__, subminor);
723 retval = -ENODEV;
724 goto exit;
725 }
726
727 dev = usb_get_intfdata(interface);
728 if (!dev) {
729 deb_data("usb_get_intfdata fail!\n");
730 retval = -ENODEV;
731 goto exit;
732 }
733
734 if (subminor != dev->tx_chip_minor) {
735 interface = NULL;
736 goto try;
737 }
738 deb_data("open RX subminor: %d\n", subminor);
739 atomic_add(1, &dev->g_AP_use_rx);
740
741 if( atomic_read(&dev->g_AP_use_rx) == 1) { // Prevent multi-open the same minor of APs.
742
743 #if DEVICE_POWER_CTRL
744 if(atomic_read(&dev->rx_pw_on) == 0) {
745 if(atomic_read(&dev->tx_pw_on) == 0) {
746 error = DL_ApPwCtrl(&dev, 0, 1);
747 error = DL_ApPwCtrl(&dev->DC, 1, 1);
748 atomic_set(&dev->tx_pw_on, 1);
749 atomic_set(&dev->rx_pw_on, 1);
750 } else {
751 error = DL_ApPwCtrl(&dev->DC, 1, 1);
752 atomic_set(&dev->rx_pw_on, 1);
753 }
754 }
755 #endif
756 }
757 /* increment our usage count for the device */
758 //kref_get(&dev->kref);
759
760 /* save our object in the file's private structure */
761 dev->file = file;
762 file->private_data = dev;
763
764 exit:
765 return retval;
766 }
767
768 static int it951x_usb_tx_open(struct inode *inode, struct file *file)
769 {
770 struct it951x_dev *dev;
771 struct usb_interface *interface;
772 int mainsubminor, subminor;
773 int retval = 0;
774 int error;
775
776 deb_data("it951x_usb_tx_open function\n");
777
778 mainsubminor = iminor(inode);
779 subminor = iminor(inode);
780 interface = usb_find_interface(&it951x_driver, subminor);
781
782 try:
783 while (!interface) {
784 subminor++;
785 interface = usb_find_interface(&it951x_driver, subminor);
786 if (subminor >= mainsubminor + USB_it951x_MINOR_RANGE)
787 break;
788 }
789
790 if (!interface) {
791 deb_data("%s - error, can't find device for minor %d",
792 __FUNCTION__, subminor);
793 retval = -ENODEV;
794 goto exit;
795 }
796 dev = usb_get_intfdata(interface);
797
798 if (!dev) {
799 deb_data("usb_get_intfdata fail!\n");
800 retval = -ENODEV;
801 goto exit;
802 }
803
804 if (subminor != dev->tx_chip_minor) {
805 interface = NULL;
806 goto try;
807 }
808 deb_data("open TX subminor: %d\n", subminor);
809 atomic_add(1, &dev->g_AP_use_tx);
810
811 /*
812 * Allocate buffer just for first user,
813 * in order to prevent multi-open the same minor of APs.
814 */
815 if( atomic_read(&dev->g_AP_use_tx) == 1) {
816 #if DEVICE_POWER_CTRL
817 if(atomic_read(&dev->tx_pw_on) == 0) {
818 error = DL_ApPwCtrl(&dev->DC, 0, 1);
819 atomic_set(&dev->tx_pw_on, 1);
820 }
821 #endif
822 }
823
824 /* save our object in the file's private structure */
825 dev->tx_file = file;
826 file->private_data = dev;
827
828 /* init API IQ table for default */
829
830 exit:
831 return retval;
832 }
833
834 static int it951x_usb_release(struct inode *inode, struct file *file)
835 {
836 struct it951x_dev *dev;
837 int error, i;
838 //int order;
839
840 dev = (struct it951x_dev *)file->private_data;
841 if (dev == NULL) {
842 deb_data("dev is NULL\n");
843 return -ENODEV;
844 }
845
846 if(atomic_read(&dev->g_AP_use_rx) == 1) { // Prevent multi-open the same minor of APs.
847
848 dev = (struct it951x_dev *)file->private_data;
849 if (dev == NULL)
850 return -ENODEV;
851
852 /* decrement the count on our device */
853 //kref_put(&dev->kref, afa_delete);
854
855 /* if rx urb doesn't call back, kill it. */
856 for (i = 0; i < URB_COUNT_RX; i++) {
857 }
858 #if DEVICE_POWER_CTRL
859 if(atomic_read(&dev->rx_pw_on) == 1) {
860 if(atomic_read(&dev->g_AP_use_tx) == 0) { // normal.
861 error = DL_ApPwCtrl(&dev->DC, 1, 0);
862 error = DL_ApPwCtrl(&dev->DC, 0, 0);
863 atomic_set(&dev->rx_pw_on, 0);
864 atomic_set(&dev->tx_pw_on, 0);
865 } else { // if tx in used. just off rx.
866 error = DL_ApPwCtrl(&dev->DC, 1, 0);
867 atomic_set(&dev->rx_pw_on, 0);
868 }
869 }
870 #endif
871 }
872 atomic_sub(1, &dev->g_AP_use_rx);
873 return 0;
874 }
875
876 static int it951x_usb_tx_release(struct inode *inode, struct file *file)
877 {
878 struct it951x_dev *dev;
879 int error;
880
881 //deb_data("it951x_usb_release function\n");
882 dev = (struct it951x_dev *)file->private_data;
883 if (dev == NULL) {
884 deb_data("dev is NULL\n");
885 return -ENODEV;
886 }
887
888 if( atomic_read(&dev->g_AP_use_tx) == 1) {
889
890 tx_stop_urb_transfer(dev);
891 #if RETURN_CHANNEL
892 tx_stop_urb_transfer_cmd(dev);
893 #endif
894 /* decrement the count on our device */
895 //kref_put(&dev->kref, afa_delete);
896
897 #if DEVICE_POWER_CTRL
898 if(atomic_read(&dev->tx_pw_on) == 1) {
899 if(atomic_read(&dev->g_AP_use_rx) == 0) { // RX not used, suspend tx.
900 error = DL_ApPwCtrl(&dev->DC, 0, 0);
901 atomic_set(&dev->tx_pw_on, 0);
902 } else {
903 deb_data("RX lock TX_PowerSaving\n");
904 }
905 }
906 #endif
907
908 }
909 atomic_sub(1, &dev->g_AP_use_tx);
910
911 return 0;
912 }
913
914 int SetLowBitRateTransfer(struct it951x_dev *dev, void *parg)
915 {
916 DWORD dwError = Error_NO_ERROR;
917 Dword *pdwBufferLength = 0;
918 unsigned long flags = 0;
919
920 PTxSetLowBitRateTransferRequest pRequest = (PTxSetLowBitRateTransferRequest) parg;
921 pdwBufferLength = (Dword*) pRequest->pdwBufferLength;
922
923 spin_lock_irqsave(&dev->TxRBKeyLock_low_brate, flags);
924 dwError = Tx_RingBuffer_low_brate(dev, (Byte*) pRequest->pBufferAddr, pdwBufferLength);
925 spin_unlock_irqrestore(&dev->TxRBKeyLock_low_brate, flags);
926
927 pRequest->error = dwError;
928 return 0;
929 }
930
931 #if PACKECT_SHIFT
932 int Thread_buffer_reset(void *DEV)
933 {
934 struct it951x_dev *dev = (struct it951x_dev *) DEV;
935
936 deb_data("- Create %s Thread -\n", __func__);
937
938 init_waitqueue_head(&dev->reset_wait);
939
940 while(!kthread_should_stop()){
941 wait_event_interruptible(dev->reset_wait, (dev->buffer_shift == 1) || (dev->DC.modulator.dev_disconnect == true));
942
943 if(dev->DC.modulator.dev_disconnect == 1)
944 break;
945
946 DL_ResetBuffer((void*) &dev->DC);
947 dev->buffer_shift = 0;
948 }
949
950 deb_data("\t %s thread kill\n", __func__);
951
952 return 0;
953 }
954 #endif
955
956 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,35)
957 static int it951x_usb_ioctl(struct inode *inode, struct file *file,
958 unsigned int cmd, unsigned long parg)
959 {
960 struct it951x_dev *dev;
961
962 dev = (struct it951x_dev *)file->private_data;
963 if (dev == NULL) {
964 deb_data("dev is NULL\n");
965 return -ENODEV;
966 }
967
968 /*
969 * extract the type and number bitfields, and don't decode
970 * wrong cmds: return ENOTTY (inappropriate ioctl) before access_ok()
971 */
972
973 //if (_IOC_TYPE(cmd) != AFA_IOC_MAGIC) return -ENOTTY;
974 //if (_IOC_NR(cmd) > AFA_IOC_MAXNR) return -ENOTTY;
975
976 switch (cmd)
977 {
978 }
979 return DL_DemodIOCTLFun((void *)&dev->DC.demodulator, (DWORD)cmd, parg);
980 }
981 #endif
982
983 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)
984 long it951x_usb_unlocked_ioctl(
985 struct file *file,
986 unsigned int cmd,
987 unsigned long parg)
988 {
989 struct it951x_dev *dev;
990 dev = (struct it951x_dev *)file->private_data;
991 if (dev == NULL) {
992 deb_data("dev is NULL\n");
993 return -ENODEV;
994 }
995
996 /*
997 * extract the type and number bitfields, and don't decode
998 * wrong cmds: return ENOTTY (inappropriate ioctl) before access_ok()
999 */
1000
1001 //if (_IOC_TYPE(cmd) != AFA_IOC_MAGIC) return -ENOTTY;
1002 //if (_IOC_NR(cmd) > AFA_IOC_MAXNR) return -ENOTTY;
1003
1004 switch (cmd)
1005 {
1006 }
1007 return DL_DemodIOCTLFun((void *)&dev->DC.demodulator, (DWORD)cmd, parg);
1008 }
1009 #endif
1010
1011 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,35)
1012 static int it951x_usb_tx_ioctl(struct inode *inode, struct file *file,
1013 unsigned int cmd, unsigned long parg)
1014 {
1015 struct it951x_dev *dev;
1016 PDEVICE_CONTEXT handle;
1017 SystemConfig syscfg;
1018 PTxCmdRequest pTxCmdRequest;
1019 TxSetDeviceTypeRequest pTxSetDeviceTypeRequest;
1020 TxGetDeviceTypeRequest pTxGetDeviceTypeRequest;
1021 PTxSetIQTableRequest pSetIQTableRequest;
1022 PTxSetDCTableRequest pSetDCTableRequest;
1023
1024 Byte *pIQtableUser, *pIQtableKernel;
1025 DCtable *pDCtableUser;
1026 DCtable *pOFStableUser;
1027 Word tableGroups, tableVersion;
1028 //Byte temp;
1029 int i, j;
1030 Dword error = Error_NO_ERROR;
1031
1032 dev = (struct it951x_dev *)file->private_data;
1033 if (dev == NULL) {
1034 deb_data("dev is NULL\n");
1035 return -ENODEV;
1036 }
1037 handle = &dev->DC;
1038
1039 /*
1040 * extract the type and number bitfields, and don't decode
1041 * wrong cmds: return ENOTTY (inappropriate ioctl) before access_ok()
1042 */
1043 //if (_IOC_TYPE(cmd) != AFA_IOC_MAGIC) return -ENOTTY;
1044 //if (_IOC_NR(cmd) > AFA_IOC_MAXNR) return -ENOTTY;
1045
1046 switch (cmd)
1047 {
1048 case IOCTL_ITE_MOD_STARTTRANSFER:
1049 tx_start_urb_transfer(dev);
1050 return 0;
1051
1052 case IOCTL_ITE_MOD_STOPTRANSFER:
1053 tx_stop_urb_transfer(dev);
1054 return 0;
1055
1056 case IOCTL_ITE_MOD_STARTTRANSFER_CMD:
1057 #if RETURN_CHANNEL
1058 tx_start_urb_transfer_cmd(dev);
1059 #endif
1060 return 0;
1061
1062 case IOCTL_ITE_MOD_STOPTRANSFER_CMD:
1063 #if RETURN_CHANNEL
1064 tx_stop_urb_transfer_cmd(dev);
1065 #endif
1066 return 0;
1067
1068 case IOCTL_ITE_MOD_WRITE_CMD:
1069 #if RETURN_CHANNEL
1070 pTxCmdRequest = (PTxCmdRequest) parg;
1071 Tx_RingBuffer_cmd(dev, (Byte*) pTxCmdRequest->cmdAddr, (Dword*) &pTxCmdRequest->len);
1072 #endif
1073 return 0;
1074
1075 case IOCTL_ITE_MOD_WRITE_LOWBITRATEDATA:
1076 SetLowBitRateTransfer(dev, (void*)parg);
1077 return 0;
1078
1079 case IOCTL_ITE_MOD_GETDEVICETYPE:
1080
1081 if (copy_from_user((void *)&pTxGetDeviceTypeRequest, (void *)parg, sizeof(TxGetDeviceTypeRequest)))
1082 return -EFAULT;
1083
1084 if(handle->isUsingDefaultDeviceType == true){ // is Using Default devicetype. return default type and return error message.
1085 pTxGetDeviceTypeRequest.DeviceType = handle->deviceType;
1086 pTxGetDeviceTypeRequest.error = ModulatorError_INVALID_DEV_TYPE;
1087 } else { // no using default. return current device type.
1088 pTxGetDeviceTypeRequest.DeviceType = handle->deviceType;
1089 pTxGetDeviceTypeRequest.error = Error_NO_ERROR;
1090 }
1091
1092 if (copy_to_user((void *)parg, (void *)&pTxGetDeviceTypeRequest, sizeof(TxGetDeviceTypeRequest)))
1093 return -EFAULT;
1094 return 0;
1095
1096 case IOCTL_ITE_MOD_SETDEVICETYPE:
1097 if (copy_from_user((void *)&pTxSetDeviceTypeRequest, (void *)parg, sizeof(TxGetDeviceTypeRequest)))
1098 return -EFAULT;
1099
1100 pTxSetDeviceTypeRequest.error = IT9510User_getDeviceTypeSetting((IT9510INFO*) &(handle->modulator), pTxSetDeviceTypeRequest.DeviceType, &syscfg);
1101 if(pTxSetDeviceTypeRequest.error != Error_NO_ERROR)
1102 deb_data("IT9510User_getDeviceTypeSetting fail\n\t- DeviceType id: %d\n", pTxSetDeviceTypeRequest.DeviceType);
1103 else
1104 deb_data("IT9510User_getDeviceTypeSetting ok\n\t- DeviceType id: %d\n", pTxSetDeviceTypeRequest.DeviceType);
1105
1106 handle->isUsingDefaultDeviceType = false; // Set for no default device type.
1107 handle->deviceType = pTxSetDeviceTypeRequest.DeviceType;
1108 handle->modulator.systemConfig = syscfg;
1109
1110 pTxSetDeviceTypeRequest.error = IT9510User_setSystemConfig((IT9510INFO*) &(handle->modulator), syscfg);
1111 if(pTxSetDeviceTypeRequest.error != Error_NO_ERROR)
1112 deb_data("IT9510User_setSystemConfig fail\n");
1113 else
1114 deb_data("IT9510User_setSystemConfig ok\n");
1115
1116 /* re-init GPIO setting for new device type */
1117 pTxSetDeviceTypeRequest.error = IT9510User_Initialization((IT9510INFO*) &(handle->modulator));
1118 if(pTxSetDeviceTypeRequest.error != Error_NO_ERROR)
1119 deb_data("IT9510User_Initialization fail\n");
1120 else
1121 deb_data("IT9510User_Initialization ok\n");
1122
1123 if (copy_to_user((void *)parg, (void *)&pTxSetDeviceTypeRequest, sizeof(TxGetDeviceTypeRequest)))
1124 return -EFAULT;
1125 return 0;
1126
1127 case IOCTL_ITE_MOD_SETIQTABLE:
1128 pSetIQTableRequest = (PTxSetIQTableRequest) parg;
1129 pIQtableUser = (Byte*) pSetIQTableRequest->pIQtableAddr;
1130
1131 if(pIQtableUser != NULL) {
1132 tableGroups = (Word) (pIQtableUser[14]<<8 | pIQtableUser[15]);
1133 tableVersion = (Dword) (pIQtableUser[10]<< 16 | pIQtableUser[11]<< 8 | pIQtableUser[12]);
1134 if( (tableGroups*8+16) != pSetIQTableRequest->IQtableSize) {
1135 deb_data("[SETIQTable] Error: File size and table groups is different.\n");
1136 pSetIQTableRequest->error = ModulatorError_INVALID_DATA_LENGTH;
1137 return 0;
1138 }
1139
1140 pIQtableKernel = (Byte*) __get_free_pages(GFP_KERNEL, get_order(tableGroups*8+16));
1141 if (copy_from_user(pIQtableKernel, pIQtableUser, (tableGroups*8+16))) {
1142 return -EFAULT;
1143 }
1144 if(dev->DC.calibrationInfo.tableGroups != tableGroups) { // Reallocate table.
1145 deb_data("[SETIQTable] Reallocate IQ Table.\n");
1146 if(dev->DC.calibrationInfo.ptrIQtableEx) {
1147 free_pages((unsigned long) dev->DC.calibrationInfo.ptrIQtableEx, get_order(dev->DC.calibrationInfo.tableGroups) * sizeof(IQtable));
1148 dev->DC.calibrationInfo.ptrIQtableEx = NULL;
1149 }
1150 dev->DC.calibrationInfo.tableGroups = tableGroups;
1151 dev->DC.calibrationInfo.ptrIQtableEx = (IQtable*)__get_free_pages(GFP_KERNEL, get_order(tableGroups) * sizeof(IQtable));
1152 }
1153 dev->DC.calibrationInfo.tableVersion = tableVersion;
1154 j = 16;
1155 for(i = 0; i < dev->DC.calibrationInfo.tableGroups; i++) {
1156 dev->DC.calibrationInfo.ptrIQtableEx[i].frequency = (pIQtableKernel[j+0] + pIQtableKernel[j+1]*256
1157 + pIQtableKernel[j+2]*256*256 + pIQtableKernel[j+3]*256*256*256);
1158 dev->DC.calibrationInfo.ptrIQtableEx[i].dAmp = (short)(pIQtableKernel[j+4] + pIQtableKernel[j+5]*256);
1159 dev->DC.calibrationInfo.ptrIQtableEx[i].dPhi = (short)(pIQtableKernel[j+6] + pIQtableKernel[j+7]*256);
1160 j += 8;
1161 }
1162 #if 0
1163 for(i = 0; i < dev->DC.calibrationInfo.tableGroups; i++) {
1164 deb_data("[SETIQTable] frequency[%d] = %d\n",i, dev->DC.calibrationInfo.ptrIQtableEx[i].frequency);
1165 deb_data("[SETIQTable] dAmp[%d] = %d\n",i, dev->DC.calibrationInfo.ptrIQtableEx[i].dAmp);
1166 deb_data("[SETIQTable] dPhi[%d] = %d\n",i, dev->DC.calibrationInfo.ptrIQtableEx[i].dPhi);
1167 }
1168 #endif
1169 pSetIQTableRequest->error = IT9510_setIQtable ((IT9510INFO*) &(dev->DC.modulator), dev->DC.calibrationInfo);
1170 deb_data("[SETIQTable] Set IQtable group length is %d\n", dev->DC.calibrationInfo.tableGroups);
1171
1172 if(pIQtableKernel != NULL) {
1173 free_pages((unsigned long) pIQtableKernel, get_order(tableGroups*8+16));
1174 pIQtableKernel = NULL;
1175 }
1176 } else {
1177 if(dev->DC.calibrationInfo.ptrIQtableEx) {
1178 free_pages((unsigned long) dev->DC.calibrationInfo.ptrIQtableEx, get_order(dev->DC.calibrationInfo.tableGroups) * sizeof(IQtable));
1179 dev->DC.calibrationInfo.ptrIQtableEx = NULL;
1180 }
1181 pSetIQTableRequest->error = IT9510_setIQtable ((IT9510INFO*) &(dev->DC.modulator), dev->DC.calibrationInfo);
1182 deb_data("[SETIQTable] Table NULL. Set default table.\n");
1183 }
1184
1185 return 0;
1186 case IOCTL_ITE_MOD_SETDCTABLE:
1187 pSetDCTableRequest = (PTxSetDCTableRequest) parg;
1188 pDCtableUser = (DCtable*) pSetDCTableRequest->pDCtableAddr;
1189 pOFStableUser = (DCtable*) pSetDCTableRequest->pOFStableAddr;
1190 tableGroups = pSetDCTableRequest->tableGroups;
1191 /* If table group is difference, reallocate table */
1192 if(dev->DC.dcInfo.tableGroups != tableGroups) {
1193 deb_data("[SETDCTable] Reallocate DC & OFS Table.\n");
1194 if(dev->DC.dcInfo.ptrDCtable) { // realloc DC table
1195 free_pages((unsigned long) dev->DC.dcInfo.ptrDCtable, get_order(dev->DC.dcInfo.tableGroups)*sizeof(DCtable));
1196 dev->DC.dcInfo.ptrDCtable = NULL;
1197 dev->DC.dcInfo.ptrDCtable = (DCtable*)__get_free_pages(GFP_KERNEL, get_order(tableGroups)*sizeof(DCtable));
1198 }
1199 if(dev->DC.dcInfo.ptrOFStable) { // realloc OFS table
1200 free_pages((unsigned long) dev->DC.dcInfo.ptrOFStable, get_order(dev->DC.dcInfo.tableGroups)*sizeof(DCtable));
1201 dev->DC.dcInfo.ptrOFStable = NULL;
1202 dev->DC.dcInfo.ptrOFStable = (DCtable*)__get_free_pages(GFP_KERNEL, get_order(tableGroups)*sizeof(DCtable));
1203 }
1204 }
1205
1206 dev->DC.dcInfo.tableGroups = tableGroups;
1207 copy_from_user(dev->DC.dcInfo.ptrDCtable, pDCtableUser, tableGroups * sizeof(DCtable));
1208 copy_from_user(dev->DC.dcInfo.ptrOFStable, pOFStableUser, tableGroups * sizeof(DCtable));
1209
1210 pSetDCTableRequest->error = IT9510_setDCtable ((IT9510INFO*) &(dev->DC.modulator), dev->DC.dcInfo);
1211 return 0;
1212 }
1213 return DL_DemodIOCTLFun((void *)&dev->DC.modulator, (DWORD)cmd, parg);
1214 }
1215 #endif
1216
1217 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)
1218 long it951x_usb_tx_unlocked_ioctl(
1219 struct file *file,
1220 unsigned int cmd,
1221 unsigned long parg)
1222 {
1223 struct it951x_dev *dev;
1224 PDEVICE_CONTEXT handle;
1225 SystemConfig syscfg;
1226 PTxCmdRequest pTxCmdRequest;
1227 TxSetDeviceTypeRequest pTxSetDeviceTypeRequest;
1228 TxGetDeviceTypeRequest pTxGetDeviceTypeRequest;
1229 PTxSetIQTableRequest pSetIQTableRequest;
1230 PTxSetDCTableRequest pSetDCTableRequest;
1231 Byte *pIQtableUser, *pIQtableKernel;
1232 DCtable *pDCtableUser;
1233 DCtable *pOFStableUser;
1234 Word tableGroups, tableVersion;
1235 //Byte temp;
1236 int i, j;
1237
1238 //deb_data("it951x_usb_tx_ioctl function\n");
1239
1240 dev = (struct it951x_dev *)file->private_data;
1241 if (dev == NULL) {
1242 deb_data("dev is NULL\n");
1243 return -ENODEV;
1244 }
1245
1246 handle = &dev->DC;
1247 /*
1248 * extract the type and number bitfields, and don't decode
1249 * wrong cmds: return ENOTTY (inappropriate ioctl) before access_ok()
1250 */
1251 //if (_IOC_TYPE(cmd) != AFA_IOC_MAGIC) return -ENOTTY;
1252 //if (_IOC_NR(cmd) > AFA_IOC_MAXNR) return -ENOTTY;
1253
1254 switch (cmd)
1255 {
1256 case IOCTL_ITE_MOD_STARTTRANSFER:
1257 tx_start_urb_transfer(dev);
1258 return 0;
1259
1260 case IOCTL_ITE_MOD_STOPTRANSFER:
1261 tx_stop_urb_transfer(dev);
1262 return 0;
1263
1264 case IOCTL_ITE_MOD_STARTTRANSFER_CMD:
1265 #if RETURN_CHANNEL
1266 tx_start_urb_transfer_cmd(dev);
1267 #endif
1268 return 0;
1269
1270 case IOCTL_ITE_MOD_STOPTRANSFER_CMD:
1271 #if RETURN_CHANNEL
1272 tx_stop_urb_transfer_cmd(dev);
1273 #endif
1274 return 0;
1275
1276 case IOCTL_ITE_MOD_WRITE_CMD:
1277 #if RETURN_CHANNEL
1278 pTxCmdRequest = (PTxCmdRequest) parg;
1279 Tx_RingBuffer_cmd(dev, (Byte*) pTxCmdRequest->cmdAddr, (Dword*) &pTxCmdRequest->len);
1280 #endif
1281 return 0;
1282
1283 case IOCTL_ITE_MOD_WRITE_LOWBITRATEDATA:
1284 SetLowBitRateTransfer(dev, (void*)parg);
1285 return 0;
1286
1287 case IOCTL_ITE_MOD_GETDEVICETYPE:
1288
1289 if (copy_from_user((void *)&pTxGetDeviceTypeRequest, (void *)parg, sizeof(TxGetDeviceTypeRequest)))
1290 return -EFAULT;
1291
1292 if(handle->isUsingDefaultDeviceType == true){ // is Using Default devicetype. return default type and return error message.
1293 pTxGetDeviceTypeRequest.DeviceType = handle->deviceType;
1294 pTxGetDeviceTypeRequest.error = ModulatorError_INVALID_DEV_TYPE;
1295 } else { // no using default. return current device type.
1296 pTxGetDeviceTypeRequest.DeviceType = handle->deviceType;
1297 pTxGetDeviceTypeRequest.error = Error_NO_ERROR;
1298 }
1299
1300 if (copy_to_user((void *)parg, (void *)&pTxGetDeviceTypeRequest, sizeof(TxGetDeviceTypeRequest)))
1301 return -EFAULT;
1302 return 0;
1303
1304 case IOCTL_ITE_MOD_SETDEVICETYPE:
1305 if (copy_from_user((void *)&pTxSetDeviceTypeRequest, (void *)parg, sizeof(TxGetDeviceTypeRequest)))
1306 return -EFAULT;
1307
1308 pTxSetDeviceTypeRequest.error = IT9510User_getDeviceTypeSetting((IT9510INFO*) &(handle->modulator), pTxSetDeviceTypeRequest.DeviceType, &syscfg);
1309 if(pTxSetDeviceTypeRequest.error != Error_NO_ERROR)
1310 deb_data("IT9510User_getDeviceTypeSetting fail\n\t- DeviceType id: %d\n", pTxSetDeviceTypeRequest.DeviceType);
1311 else
1312 deb_data("IT9510User_getDeviceTypeSetting ok\n\t- DeviceType id: %d\n", pTxSetDeviceTypeRequest.DeviceType);
1313
1314 handle->isUsingDefaultDeviceType = false; // Set for no default device type.
1315 handle->deviceType = pTxSetDeviceTypeRequest.DeviceType;
1316 handle->modulator.systemConfig = syscfg;
1317
1318 pTxSetDeviceTypeRequest.error = IT9510User_setSystemConfig((IT9510INFO*) &(handle->modulator), syscfg);
1319 if(pTxSetDeviceTypeRequest.error != Error_NO_ERROR)
1320 deb_data("IT9510User_setSystemConfig fail\n");
1321 else
1322 deb_data("IT9510User_setSystemConfig ok\n");
1323
1324 /* re-init GPIO setting for new device type */
1325 pTxSetDeviceTypeRequest.error = IT9510User_Initialization((IT9510INFO*) &(handle->modulator));
1326 if(pTxSetDeviceTypeRequest.error != Error_NO_ERROR)
1327 deb_data("IT9510User_Initialization fail\n");
1328 else
1329 deb_data("IT9510User_Initialization ok\n");
1330
1331 if (copy_to_user((void *)parg, (void *)&pTxSetDeviceTypeRequest, sizeof(TxGetDeviceTypeRequest)))
1332 return -EFAULT;
1333 return 0;
1334
1335 case IOCTL_ITE_MOD_SETIQTABLE:
1336 pSetIQTableRequest = (PTxSetIQTableRequest) parg;
1337 pIQtableUser = (Byte*) pSetIQTableRequest->pIQtableAddr;
1338
1339 if(pIQtableUser != NULL) {
1340 tableGroups = (Word) (pIQtableUser[14]<<8 | pIQtableUser[15]);
1341 tableVersion = (Dword) (pIQtableUser[10]<< 16 | pIQtableUser[11]<< 8 | pIQtableUser[12]);
1342 if( (tableGroups*8+16) != pSetIQTableRequest->IQtableSize) {
1343 deb_data("[SETIQTable] Error: File size and table groups is different.\n");
1344 pSetIQTableRequest->error = ModulatorError_INVALID_DATA_LENGTH;
1345 return 0;
1346 }
1347
1348 pIQtableKernel = (Byte*) __get_free_pages(GFP_KERNEL, get_order(tableGroups*8+16));
1349 if (copy_from_user(pIQtableKernel, pIQtableUser, (tableGroups*8+16))) {
1350 return -EFAULT;
1351 }
1352 if(dev->DC.calibrationInfo.tableGroups != tableGroups) { // Reallocate table.
1353 deb_data("[SETIQTable] Reallocate IQ Table.\n");
1354 if(dev->DC.calibrationInfo.ptrIQtableEx) {
1355 free_pages((unsigned long) dev->DC.calibrationInfo.ptrIQtableEx, get_order(dev->DC.calibrationInfo.tableGroups) * sizeof(IQtable));
1356 dev->DC.calibrationInfo.ptrIQtableEx = NULL;
1357 }
1358 dev->DC.calibrationInfo.tableGroups = tableGroups;
1359 dev->DC.calibrationInfo.ptrIQtableEx = (IQtable*)__get_free_pages(GFP_KERNEL, get_order(tableGroups) * sizeof(IQtable));
1360 }
1361 dev->DC.calibrationInfo.tableVersion = tableVersion;
1362 j = 16;
1363 for(i = 0; i < dev->DC.calibrationInfo.tableGroups; i++) {
1364 dev->DC.calibrationInfo.ptrIQtableEx[i].frequency = (pIQtableKernel[j+0] + pIQtableKernel[j+1]*256
1365 + pIQtableKernel[j+2]*256*256 + pIQtableKernel[j+3]*256*256*256);
1366 dev->DC.calibrationInfo.ptrIQtableEx[i].dAmp = (short)(pIQtableKernel[j+4] + pIQtableKernel[j+5]*256);
1367 dev->DC.calibrationInfo.ptrIQtableEx[i].dPhi = (short)(pIQtableKernel[j+6] + pIQtableKernel[j+7]*256);
1368 j += 8;
1369 }
1370 #if 0
1371 for(i = 0; i < dev->DC.calibrationInfo.tableGroups; i++) {
1372 deb_data("[SETIQTable] frequency[%d] = %d\n",i, dev->DC.calibrationInfo.ptrIQtableEx[i].frequency);
1373 deb_data("[SETIQTable] dAmp[%d] = %d\n",i, dev->DC.calibrationInfo.ptrIQtableEx[i].dAmp);
1374 deb_data("[SETIQTable] dPhi[%d] = %d\n",i, dev->DC.calibrationInfo.ptrIQtableEx[i].dPhi);
1375 }
1376 #endif
1377 pSetIQTableRequest->error = IT9510_setIQtable ((IT9510INFO*) &(dev->DC.modulator), dev->DC.calibrationInfo);
1378 deb_data("[SETIQTable] Set IQtable group length is %d\n", dev->DC.calibrationInfo.tableGroups);
1379
1380 if(pIQtableKernel != NULL) {
1381 free_pages((unsigned long) pIQtableKernel, get_order(tableGroups*8+16));
1382 pIQtableKernel = NULL;
1383 }
1384 } else {
1385 if(dev->DC.calibrationInfo.ptrIQtableEx) {
1386 free_pages((unsigned long) dev->DC.calibrationInfo.ptrIQtableEx, get_order(dev->DC.calibrationInfo.tableGroups) * sizeof(IQtable));
1387 dev->DC.calibrationInfo.ptrIQtableEx = NULL;
1388 }
1389 pSetIQTableRequest->error = IT9510_setIQtable ((IT9510INFO*) &(dev->DC.modulator), dev->DC.calibrationInfo);
1390 deb_data("[SETIQTable] Table NULL. Set default table.\n");
1391 }
1392
1393 return 0;
1394 case IOCTL_ITE_MOD_SETDCTABLE:
1395 pSetDCTableRequest = (PTxSetDCTableRequest) parg;
1396 pDCtableUser = (DCtable*) pSetDCTableRequest->pDCtableAddr;
1397 pOFStableUser = (DCtable*) pSetDCTableRequest->pOFStableAddr;
1398 tableGroups = pSetDCTableRequest->tableGroups;
1399 /* If table group is difference, reallocate table */
1400 if(dev->DC.dcInfo.tableGroups != tableGroups) {
1401 deb_data("[SETDCTable] Reallocate DC & OFS Table.\n");
1402 if(dev->DC.dcInfo.ptrDCtable) { // realloc DC table
1403 free_pages((unsigned long) dev->DC.dcInfo.ptrDCtable, get_order(dev->DC.dcInfo.tableGroups)*sizeof(DCtable));
1404 dev->DC.dcInfo.ptrDCtable = NULL;
1405 dev->DC.dcInfo.ptrDCtable = (DCtable*)__get_free_pages(GFP_KERNEL, get_order(tableGroups)*sizeof(DCtable));
1406 }
1407 if(dev->DC.dcInfo.ptrOFStable) { // realloc OFS table
1408 free_pages((unsigned long) dev->DC.dcInfo.ptrOFStable, get_order(dev->DC.dcInfo.tableGroups)*sizeof(DCtable));
1409 dev->DC.dcInfo.ptrOFStable = NULL;
1410 dev->DC.dcInfo.ptrOFStable = (DCtable*)__get_free_pages(GFP_KERNEL, get_order(tableGroups)*sizeof(DCtable));
1411 }
1412 }
1413
1414 dev->DC.dcInfo.tableGroups = tableGroups;
1415 if (copy_from_user(dev->DC.dcInfo.ptrDCtable, pDCtableUser, tableGroups * sizeof(DCtable))) {
1416 return -EFAULT;
1417 }
1418 if (copy_from_user(dev->DC.dcInfo.ptrOFStable, pOFStableUser, tableGroups * sizeof(DCtable))) {
1419 return -EFAULT;
1420 }
1421
1422 pSetDCTableRequest->error = IT9510_setDCtable ((IT9510INFO*) &(dev->DC.modulator), dev->DC.dcInfo);
1423 return 0;
1424 }
1425 return DL_DemodIOCTLFun((void *)&dev->DC.modulator, (DWORD)cmd, parg);
1426 }
1427 #endif
1428
1429
1430 static ssize_t it951x_tx_write(
1431 struct file *file,
1432 const char __user *user_buffer,
1433 size_t count,
1434 loff_t *ppos)
1435 {
1436 struct it951x_dev *dev;
1437
1438 Dword Len = count;
1439 DWORD dwError = Error_NO_ERROR;
1440 unsigned long flags = 0;
1441
1442 /*AirHD RingBuffer*/
1443 dev = (struct it951x_dev *)file->private_data;
1444 if (dev == NULL)
1445 return -ENODEV;
1446
1447 if(!dev->DC.modulator.dev_disconnect)
1448 {
1449 spin_lock_irqsave(&dev->TxRBKeyLock, flags);
1450 dwError = Tx_RingBuffer(dev, (Byte*)user_buffer, &Len);
1451 spin_unlock_irqrestore(&dev->TxRBKeyLock, flags);
1452 }
1453 return dwError;
1454
1455
1456 /*AirHD Bulk Msg*/
1457 }
1458
1459
1460 static struct file_operations it951x_usb_rx_fops ={
1461 .owner = THIS_MODULE,
1462 .open = it951x_usb_open,
1463 //.write = it951x_write,
1464 .release = it951x_usb_release,
1465 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)
1466 .unlocked_ioctl = it951x_usb_unlocked_ioctl,
1467 #else
1468 .ioctl = it951x_usb_ioctl,
1469 #endif
1470
1471 };
1472
1473 static struct file_operations it951x_usb_tx_fops ={
1474 .owner = THIS_MODULE,
1475 .open = it951x_usb_tx_open,
1476 //.read = it951x_read,
1477 .write = it951x_tx_write, /*AirHD*/
1478 .release = it951x_usb_tx_release,
1479 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,35)
1480 .unlocked_ioctl = it951x_usb_tx_unlocked_ioctl,
1481 #else
1482 .ioctl = it951x_usb_tx_ioctl,
1483 #endif
1484
1485 };
1486
1487 /*
1488 * usb class driver info in order to get a minor number from the usb core,
1489 * and to have the device registered with devfs and the driver core
1490 */
1491 #if IT9133Rx
1492 static struct usb_class_driver it951x_class = {
1493 .fops = &it951x_usb_rx_fops,
1494 .minor_base = USB_it91xx_MINOR_BASE
1495 };
1496 #else
1497 static struct usb_class_driver it951x_class = {
1498 .fops = &it951x_usb_rx_fops,
1499 .minor_base = USB_it91xx_MINOR_BASE
1500 };
1501 #endif
1502
1503 static struct usb_class_driver it951x_class_tx = {
1504 .fops = &it951x_usb_tx_fops,
1505 .minor_base = USB_it951x_MINOR_BASE
1506 };
1507
1508 static short usb_handle_set(Byte* usb_handles, Byte handle_size)
1509 {
1510 Byte i;
1511
1512 for(i=0; i<handle_size; i++) {
1513 if(!usb_handles[i]) {
1514 usb_handles[i] = true;
1515 return i;
1516 }
1517 }
1518 deb_data("ERROR usb_handle_set\n");
1519 return -EBADF;
1520 }
1521
1522 static short usb_handle_unset(Byte* usb_handles, Byte handle_unset_num)
1523 {
1524 if(usb_handles[handle_unset_num]) {
1525 usb_handles[handle_unset_num] = false;
1526 return 0;
1527 }
1528 deb_data("ERROR usb_handle_unset\n");
1529 return -EBADF;
1530 }
1531
1532 // Register a USB device node end
1533 static int it951x_probe(struct usb_interface *intf, const struct usb_device_id *id)
1534 {
1535 struct it951x_dev *dev = NULL;
1536 struct urb *purb;
1537 int retval = -ENOMEM;
1538 int i, order, error;
1539 ChannelModulation temp;
1540
1541 #if RETURN_CHANNEL
1542 int order_cmd;
1543 #endif
1544 /* allocate memory for our device state and intialize it */
1545 dev = kzalloc(sizeof(struct it951x_dev), GFP_KERNEL);
1546 dev->g_AP_use = 0;
1547 atomic_set(&dev->g_AP_use_tx, 0);
1548 atomic_set(&dev->g_AP_use_rx, 0);
1549 dev->DC.Tx_init_success = 0;
1550 dev->DC.Rx_init_success = 0;
1551
1552 dev->DC.pControlBuffer_WriteReg = kzalloc(200, GFP_KERNEL);
1553 dev->DC.pControlBuffer_ReadReg = kzalloc(200, GFP_KERNEL);
1554
1555 if (dev == NULL) {
1556 deb_data("Out of memory\n");
1557 return retval;
1558 }
1559
1560 dev->usbdev = interface_to_usbdev(intf);
1561
1562 /* Malloc IQ_TB */
1563 dev->DC.calibrationInfo.tableVersion = 0;
1564 dev->DC.calibrationInfo.tableGroups = IQ_TABLE_NROW;
1565 dev->DC.calibrationInfo.ptrIQtableEx = (IQtable*)__get_free_pages(GFP_KERNEL, get_order(IQ_TABLE_NROW) * sizeof(IQtable));
1566
1567 /* Malloc DC TB */
1568 dev->DC.dcInfo.tableGroups = 7;
1569 dev->DC.dcInfo.ptrDCtable = (DCtable*) __get_free_pages(GFP_KERNEL, get_order(dev->DC.dcInfo.tableGroups)*sizeof(DCtable));
1570 dev->DC.dcInfo.ptrOFStable = (DCtable*) __get_free_pages(GFP_KERNEL, get_order(dev->DC.dcInfo.tableGroups)*sizeof(DCtable));
1571
1572 /* we can register the device now, as it is ready */
1573 usb_set_intfdata(intf, dev);
1574 deb_data("*** it951x usb device pluged in ***\n");
1575 retval = Device_init(interface_to_usbdev(intf), &dev->DC, true);
1576 if (retval) {
1577 deb_data("Device_init Fail: 0x%08x\n", retval);
1578 return retval;
1579 }
1580
1581 /* Register Rx */
1582 if(dev->DC.Rx_init_success) {
1583 /* Register Rx handle name */
1584 if(it951x_class.name == NULL)
1585 it951x_class.name = kzalloc(sizeof(char)*MAX_USB_HANDLE_NAME_SIZE, GFP_KERNEL);
1586
1587 /* Register the device to usb core */
1588 retval = usb_register_dev(intf, &it951x_class);
1589 if (retval) {
1590 deb_data("Not able to get a minor for this device.");
1591 usb_set_intfdata(intf, NULL);
1592 //goto error;
1593 return -ENOTTY;
1594 }
1595 dev->rx_chip_minor = intf->minor;
1596 deb_data("rx minor %d \n", dev->rx_chip_minor);
1597 }
1598
1599 if(dev->DC.Tx_init_success) {
1600 /* Register Tx handle name */
1601 if(it951x_class_tx.name == NULL)
1602 it951x_class_tx.name = kzalloc(sizeof(char)*MAX_USB_HANDLE_NAME_SIZE, GFP_KERNEL);
1603 dev->tx_handle_num = usb_handle_set(tx_usb_handles, TX_MAX_USB_HANDLE_NUM);
1604 if(dev->tx_handle_num >= 0)
1605 snprintf(it951x_class_tx.name, MAX_USB_HANDLE_NAME_SIZE, "usb-it951x%d", dev->tx_handle_num);
1606 else
1607 return -EBADF;
1608
1609 /* Register Tx */
1610 intf->minor = -1;
1611 retval = usb_register_dev(intf, &it951x_class_tx);
1612 if (retval) {
1613 deb_data("Not able to get a minor for this device.");
1614 usb_set_intfdata(intf, NULL);
1615 //goto error;
1616 return -ENOTTY;
1617 }
1618 dev->tx_chip_minor = intf->minor;
1619 deb_data("tx minor %d \n", dev->tx_chip_minor);
1620 }
1621
1622 /* Allocate Tx Write Ring buffer */
1623 dev->dwTxWriteTolBufferSize = URB_BUFSIZE_TX * URB_COUNT_TX;
1624 order = get_order(dev->dwTxWriteTolBufferSize);
1625 dev->pTxRingBuffer = (Byte*)__get_free_pages(GFP_KERNEL, order);
1626 if (dev->pTxRingBuffer) {
1627 dev->TxCurrBuffPointAddr = 0;
1628 dev->TxWriteBuffPointAddr = 0;
1629 dev->dwTxRemaingBufferSize = dev->dwTxWriteTolBufferSize;
1630 dev->tx_urb_index = 0;
1631 }
1632
1633 /* Allocate Write low bitrate Ring buffer */
1634 dev->dwTxWriteTolBufferSize_low_brate = URB_BUFSIZE_TX_LOW_BRATE * URB_COUNT_TX_LOW_BRATE;
1635 order = get_order(dev->dwTxWriteTolBufferSize_low_brate);
1636 dev->pTxRingBuffer_low_brate = (Byte*)__get_free_pages(GFP_KERNEL, order);
1637 if (dev->pTxRingBuffer_low_brate) {
1638 dev->TxCurrBuffPointAddr_low_brate = 0;
1639 dev->TxWriteBuffPointAddr_low_brate = 0;
1640 dev->dwTxRemaingBufferSize_low_brate = dev->dwTxWriteTolBufferSize_low_brate;
1641 dev->tx_urb_index_low_brate = 0;
1642 }
1643 #if RETURN_CHANNEL
1644 /* Allocate Write cmd Ring buffer */
1645 dev->dwTxWriteTolBufferSize_cmd = URB_BUFSIZE_TX_CMD * URB_COUNT_TX_CMD;
1646 order_cmd = get_order(dev->dwTxWriteTolBufferSize_cmd + 8);
1647 dev->pTxRingBuffer_cmd = (Byte*)__get_free_pages(GFP_KERNEL, order_cmd);
1648 if (dev->pTxRingBuffer_cmd) {
1649 dev->pWriteFrameBuffer_cmd = dev->pTxRingBuffer_cmd + 8;
1650 dev->pTxCurrBuffPointAddr_cmd = (Dword*)dev->pTxRingBuffer_cmd;
1651 dev->pTxWriteBuffPointAddr_cmd = (Dword*)(dev->pTxRingBuffer_cmd + 4);
1652 dev->dwTxRemaingBufferSize_cmd = dev->dwTxWriteTolBufferSize_cmd;
1653 dev->tx_urb_index_cmd = 0;
1654 //dev->urb_use_count_cmd = URB_COUNT_TX_CMD;
1655 }
1656 #endif
1657 for (i = 0; i < URB_COUNT_TX; i++) {
1658 dev->tx_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
1659 if (!dev->tx_urbs[i])
1660 retval = -ENOMEM;
1661
1662 purb = dev->tx_urbs[i];
1663 purb->transfer_buffer = dev->pTxRingBuffer + (URB_BUFSIZE_TX*i);
1664 if (!purb->transfer_buffer) {
1665 usb_free_urb(purb);
1666 dev->tx_urbs[i] = NULL;
1667 deb_data("tx_urbs transfer_buffer alloc fail!\n");
1668 goto exit;
1669 }
1670
1671 dev->tx_urb_context[i].index = i;
1672 dev->tx_urb_context[i].dev = dev;
1673 dev->tx_urbstatus[i] = 0;
1674
1675 purb->status = -EINPROGRESS;
1676 usb_fill_bulk_urb(purb,
1677 dev->usbdev,
1678 usb_sndbulkpipe(dev->usbdev, 0x06),
1679 purb->transfer_buffer,
1680 URB_BUFSIZE_TX,
1681 (usb_complete_t)tx_urb_completion,
1682 &dev->tx_urb_context[i]);
1683
1684 purb->transfer_flags = 0;
1685 }
1686
1687 for (i = 0; i < URB_COUNT_TX_LOW_BRATE; i++) {
1688 dev->tx_urbs_low_brate[i] = usb_alloc_urb(0, GFP_KERNEL);
1689 if (!dev->tx_urbs_low_brate[i])
1690 retval = -ENOMEM;
1691
1692 purb = dev->tx_urbs_low_brate[i];
1693 purb->transfer_buffer = dev->pTxRingBuffer_low_brate + (URB_BUFSIZE_TX_LOW_BRATE*i);
1694 if (!purb->transfer_buffer) {
1695 usb_free_urb(purb);
1696 dev->tx_urbs_low_brate[i] = NULL;
1697 deb_data("tx_urbs_low_brate transfer_buffer alloc fail!\n");
1698 goto exit;
1699 }
1700
1701 dev->tx_urb_context_low_brate[i].index = i;
1702 dev->tx_urb_context_low_brate[i].dev = dev;
1703 dev->tx_urbstatus_low_brate[i] = 0;
1704 purb->status = -EINPROGRESS;
1705 usb_fill_bulk_urb(purb,
1706 dev->usbdev,
1707 usb_sndbulkpipe(dev->usbdev, 0x06),
1708 purb->transfer_buffer,
1709 URB_BUFSIZE_TX_LOW_BRATE,
1710 (usb_complete_t)tx_urb_completion_low_brate,
1711 &dev->tx_urb_context_low_brate[i]);
1712 purb->transfer_flags = 0;
1713 }
1714 #if RETURN_CHANNEL
1715 for (i = 0; i < URB_COUNT_TX_CMD; i++) {
1716 dev->tx_urbs_cmd[i] = usb_alloc_urb(0, GFP_KERNEL);
1717 if (!dev->tx_urbs_cmd[i])
1718 retval = -ENOMEM;
1719
1720 purb = dev->tx_urbs_cmd[i];
1721
1722 purb->transfer_buffer = dev->pWriteFrameBuffer_cmd + (URB_BUFSIZE_TX_CMD*i);
1723 if (!purb->transfer_buffer) {
1724 usb_free_urb(purb);
1725 dev->tx_urbs_cmd[i] = NULL;
1726 goto exit;
1727 }
1728
1729 dev->tx_urb_context_cmd[i].index = i;
1730 dev->tx_urb_context_cmd[i].dev = dev;
1731 dev->tx_urbstatus_cmd[i] = 0;
1732
1733 purb->status = -EINPROGRESS;
1734 usb_fill_bulk_urb(purb,
1735 dev->usbdev,
1736 usb_sndbulkpipe(dev->usbdev, 0x06),
1737 purb->transfer_buffer,
1738 URB_BUFSIZE_TX_CMD,
1739 (usb_complete_t)tx_urb_completion_cmd,
1740 &dev->tx_urb_context_cmd[i]);
1741
1742 purb->transfer_flags = 0;
1743 }
1744 #endif
1745
1746 /* Rx Ring buffer alloc & chip init */
1747 spin_lock_init(&dev->RxRBKeylock);
1748 dev->rx_urb_streaming = 0;
1749 dev->dwRxReadRemaingBufferSize = 0;
1750 dev->dwRxTolBufferSize = URB_BUFSIZE_RX * URB_COUNT_RX;
1751 dev->rx_urb_index = 0;
1752 dev->rx_first_urb_reset = 0;
1753
1754 atomic_set(&dev->rx_urb_counter, URB_COUNT_RX);
1755
1756 #if PACKECT_SHIFT
1757 /* Init reset buffer thread */
1758 dev->buffer_shift = 0;
1759 dev->reset_thread = kthread_create(&Thread_buffer_reset, (void *)dev, "Reset_Buffer_Thread");
1760 if(!dev->reset_thread || IS_ERR(dev->reset_thread)){
1761 deb_data("\t Error: Reset_Buffer_Thread fail\n");
1762 retval = PTR_ERR(dev->reset_thread);
1763 dev->reset_thread = NULL;
1764 goto exit;
1765 }
1766 wake_up_process(dev->reset_thread);
1767 #endif
1768
1769 /* device connect success */
1770 dev->DC.modulator.dev_disconnect = false;
1771
1772 /* fixed issue for enhance K DC calibration value in orion board */
1773 temp.constellation = Constellation_64QAM; // 64QAM
1774 temp.highCodeRate = CodeRate_7_OVER_8; // 7/8
1775 temp.interval = Interval_1_OVER_32; // 1/32
1776 temp.transmissionMode = TransmissionMode_8K; // 8K
1777 error = IT9510_setTXChannelModulation((IT9510INFO*) &(dev->DC.modulator), &temp);
1778 if(error == 0 )
1779 printk("Default IT9510_setTXChannelModulation: success\n");
1780 else
1781 printk("Default IT9510_setTXChannelModulation: fail\n");
1782
1783 exit:
1784 #if (DEVICE_POWER_CTRL)
1785 atomic_set(&dev->tx_pw_on, 0);
1786 atomic_set(&dev->rx_pw_on, 0);
1787 DL_ApPwCtrl(&dev->DC, 1, 0);
1788 DL_ApPwCtrl(&dev->DC, 0, 0);
1789 #endif
1790 deb_data("USB ITEtech device now attached to USBSkel-%d \n", intf->minor);
1791
1792 return retval;
1793 }
1794
1795 static int it951x_suspend(struct usb_interface *intf, pm_message_t state)
1796 {
1797 struct it951x_dev *dev;
1798
1799 dev = usb_get_intfdata(intf);
1800 if (!dev)
1801 deb_data("dev = NULL");
1802 //deb_data("Enter %s Function\n", __FUNCTION__);
1803
1804 #ifdef EEEPC
1805 error = DL_Reboot();
1806 #else
1807 if (dev->DevicePower) {
1808 // PN!!! error = DL_CheckTunerInited(&dev->DC, 0, &dev->TunerInited0);
1809 // PN!!! error = DL_CheckTunerInited(&dev->DC, 1, &dev->TunerInited1);
1810
1811 // PN!!! error = DL_ApCtrl(&dev->DC, 0, 0);
1812 // PN!!! error = DL_ApCtrl(&dev->DC, 1, 0);
1813 // PN!!! if (error) {
1814 // PN!!! deb_data("DL_ApCtrl error : 0x%x\n", error);
1815 // PN!!! }
1816 // PN!!!
1817 dev->DeviceReboot = true;
1818 }
1819 #endif
1820
1821 return 0;
1822 }
1823
1824 static int it951x_resume(struct usb_interface *intf)
1825 {
1826 int retval = -ENOMEM;
1827 int error;
1828 struct it951x_dev *dev;
1829
1830 //deb_data("Enter %s Function\n",__FUNCTION__);
1831 dev = usb_get_intfdata(intf);
1832 if (!dev)
1833 deb_data("dev = NULL");
1834
1835
1836 #ifdef EEEPC
1837 #else
1838 if (dev->DeviceReboot == True) {
1839 retval = Device_init(interface_to_usbdev(intf),&dev->DC, false);
1840 if(retval)
1841 deb_data("Device_init Fail: 0x%08x\n", retval);
1842
1843 if (dev->TunerInited0)
1844 error = 0; // PN!!! DL_ApCtrl(&dev->DC, 0, 1);
1845 if (dev->TunerInited1)
1846 error = 0; // PN!!! DL_ApCtrl(&dev->DC, 1, 1);
1847 }
1848 #endif
1849
1850 return 0;
1851 }
1852
1853 static void it951x_disconnect(struct usb_interface *intf)
1854 {
1855 struct it951x_dev *dev;
1856 int minor = intf->minor;
1857 int order;
1858
1859 deb_data("%s()\n", __func__);
1860 /* prevent afa_open() from racing afa_disconnect() */
1861 //lock_kernel();
1862
1863 dev = usb_get_intfdata(intf);
1864 if (!dev) {
1865 deb_data("dev = NULL");
1866 }
1867
1868 /* disable this flag to prevent Usb read/write Bus failure */
1869 dev->DC.modulator.dev_disconnect = true;
1870
1871 /*DM368 usb bus error when using kill urb */
1872
1873 /* Release RBRingBuffer and urbs */
1874 tx_free_urbs(dev);
1875 if (dev->pTxRingBuffer) {
1876 order = get_order(dev->dwTxWriteTolBufferSize);
1877 free_pages((long unsigned int)dev->pTxRingBuffer, order);
1878 }
1879 #if RETURN_CHANNEL
1880 if (dev->pTxRingBuffer_cmd) {
1881 order = get_order(dev->dwTxWriteTolBufferSize_cmd + 8);
1882 free_pages((long unsigned int)dev->pTxRingBuffer_cmd, order);
1883 }
1884 #endif
1885 if (dev->pTxRingBuffer_low_brate) {
1886 order = get_order(dev->dwTxWriteTolBufferSize_low_brate);
1887 free_pages((long unsigned int)dev->pTxRingBuffer_low_brate, order);
1888 }
1889
1890
1891 #if PACKECT_SHIFT
1892 #endif
1893 /*DM368 usb bus error when using kill urb */
1894 usb_set_intfdata(intf, NULL);
1895
1896 /* give back our minor */
1897 /* Rx de-register */
1898 if(dev->DC.Rx_init_success) {
1899 intf->minor = dev->rx_chip_minor;
1900 usb_deregister_dev(intf, &it951x_class);
1901 }
1902
1903 /* Tx de-register */
1904 if(dev->DC.Tx_init_success) {
1905 intf->minor = dev->tx_chip_minor;
1906 usb_deregister_dev(intf, &it951x_class_tx);
1907 usb_handle_unset(tx_usb_handles, dev->tx_handle_num);
1908 }
1909 /* Free IQ_TB */
1910 if(dev->DC.calibrationInfo.ptrIQtableEx) {
1911 free_pages((unsigned long) dev->DC.calibrationInfo.ptrIQtableEx, get_order(dev->DC.calibrationInfo.tableGroups) * sizeof(IQtable));
1912 dev->DC.calibrationInfo.ptrIQtableEx = NULL;
1913 }
1914 if(dev->DC.dcInfo.ptrDCtable) {
1915 free_pages((unsigned long) dev->DC.dcInfo.ptrDCtable, get_order(dev->DC.dcInfo.tableGroups)*sizeof(DCtable));
1916 dev->DC.dcInfo.ptrDCtable = NULL;
1917 }
1918 if(dev->DC.dcInfo.ptrOFStable) {
1919 free_pages((unsigned long) dev->DC.dcInfo.ptrOFStable, get_order(dev->DC.dcInfo.tableGroups)*sizeof(DCtable));
1920 dev->DC.dcInfo.ptrOFStable = NULL;
1921 }
1922 //unlock_kernel();
1923
1924 /* decrement our usage count */
1925 // kref_put(&dev->kref, afa_delete);
1926
1927 if (dev){
1928 if(dev->file) dev->file->private_data = NULL;
1929 if(dev->tx_file) dev->tx_file->private_data = NULL;
1930 if(dev->DC.pControlBuffer_WriteReg) { /* Malloc Usb2_writeControlBus Write Buffer */
1931 kfree(dev->DC.pControlBuffer_WriteReg);
1932 dev->DC.pControlBuffer_WriteReg = NULL;
1933 }
1934 if(dev->DC.pControlBuffer_ReadReg) { /* Malloc Usb2_writeControlBus Read Buffer */
1935 kfree(dev->DC.pControlBuffer_ReadReg);
1936 dev->DC.pControlBuffer_ReadReg = NULL;
1937 }
1938 kfree(dev);
1939 }
1940
1941 deb_data("USB ITEtech #%d now disconnected", minor);
1942 }
1943
1944
1945 static struct usb_driver it951x_driver = {
1946 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,15)
1947 .owner = THIS_MODULE,
1948 #endif
1949 .name = "usb-it951x",
1950 .probe = it951x_probe,
1951 .disconnect = it951x_disconnect,//dvb_usb_device_exit,
1952 .id_table = it951x_usb_id_table,
1953 .suspend = it951x_suspend,
1954 .resume = it951x_resume,
1955 };
1956
1957 static int __init it951x_module_init(void)
1958 {
1959 int result;
1960
1961 //info("%s",__FUNCTION__);
1962 //deb_data("usb_it951x Module is loaded \n");
1963
1964 if ((result = usb_register(&it951x_driver))) {
1965 pr_err("usb_register failed. Error number %d",result);
1966 return result;
1967 }
1968
1969 return 0;
1970 }
1971
1972 static void __exit it951x_module_exit(void)
1973 {
1974 deb_data("usb_it951x Module is unloaded!\n");
1975 usb_deregister(&it951x_driver);
1976 }
1977
1978 module_init (it951x_module_init);
1979 module_exit (it951x_module_exit);
1980
1981 MODULE_AUTHOR("Jason Dong <jason.dong@ite.com.tw>");
1982 MODULE_DESCRIPTION("DTV Native Driver for Device Based on ITEtech it951x");
1983 MODULE_VERSION(DRIVER_RELEASE_VERSION);
1984 MODULE_LICENSE("GPL");
Hides DVB modulator driver for CoreELEC