2 * This file is part of linux driver the digital TV devices equipped with B2C2 FlexcopII(b)/III
4 * flexcop-usb.c - covers the USB part.
6 * see flexcop.c for copyright information.
9 #define FC_LOG_PREFIX "flexcop_usb"
10 #include "flexcop-usb.h"
11 #include "flexcop-common.h"
13 /* Version information */
14 #define DRIVER_VERSION "0.1"
15 #define DRIVER_NAME "Technisat/B2C2 FlexCop II/IIb/III Digital TV USB Driver"
16 #define DRIVER_AUTHOR "Patrick Boettcher <patrick.boettcher@desy.de>"
19 #ifdef CONFIG_DVB_B2C2_FLEXCOP_DEBUG
20 #define dprintk(level,args...) \
21 do { if ((debug & level)) { printk(args); } } while (0)
22 #define debug_dump(b,l,method) {\
24 for (i = 0; i < l; i++) method("%02x ", b[i]); \
30 #define dprintk(level,args...)
31 #define debug_dump(b,l,method)
32 #define DEBSTATUS " (debugging is not enabled)"
36 module_param(debug
, int, 0644);
37 MODULE_PARM_DESC(debug
, "set debugging level (1=info,ts=2,ctrl=4,i2c=8,v8mem=16 (or-able))." DEBSTATUS
);
40 #define deb_info(args...) dprintk(0x01,args)
41 #define deb_ts(args...) dprintk(0x02,args)
42 #define deb_ctrl(args...) dprintk(0x04,args)
43 #define deb_i2c(args...) dprintk(0x08,args)
44 #define deb_v8(args...) dprintk(0x10,args)
46 /* JLP 111700: we will include the 1 bit gap between the upper and lower 3 bits
47 * in the IBI address, to make the V8 code simpler.
48 * PCI ADDRESS FORMAT: 0x71C -> 0000 0111 0001 1100 (these are the six bits used)
49 * in general: 0000 0HHH 000L LL00
50 * IBI ADDRESS FORMAT: RHHH BLLL
52 * where R is the read(1)/write(0) bit, B is the busy bit
53 * and HHH and LLL are the two sets of three bits from the PCI address.
55 #define B2C2_FLEX_PCIOFFSET_TO_INTERNALADDR(usPCI) (u8) (((usPCI >> 2) & 0x07) + ((usPCI >> 4) & 0x70))
56 #define B2C2_FLEX_INTERNALADDR_TO_PCIOFFSET(ucAddr) (u16) (((ucAddr & 0x07) << 2) + ((ucAddr & 0x70) << 4))
60 * - forget about this VENDOR_BUFFER_SIZE, read and write register
61 * deal with DWORD or 4 bytes, that should be should from now on
62 * - from now on, we don't support anything older than firm 1.00
63 * I eliminated the write register as a 2 trip of writing hi word and lo word
64 * and force this to write only 4 bytes at a time.
65 * NOTE: this should work with all the firmware from 1.00 and newer
67 static int flexcop_usb_readwrite_dw(struct flexcop_device
*fc
, u16 wRegOffsPCI
, u32
*val
, u8 read
)
69 struct flexcop_usb
*fc_usb
= fc
->bus_specific
;
70 u8 request
= read
? B2C2_USB_READ_REG
: B2C2_USB_WRITE_REG
;
71 u8 request_type
= (read
? USB_DIR_IN
: USB_DIR_OUT
) | USB_TYPE_VENDOR
;
72 u8 wAddress
= B2C2_FLEX_PCIOFFSET_TO_INTERNALADDR(wRegOffsPCI
) | (read
? 0x80 : 0);
74 int len
= usb_control_msg(fc_usb
->udev
,
75 read
? B2C2_USB_CTRL_PIPE_IN
: B2C2_USB_CTRL_PIPE_OUT
,
77 request_type
, /* 0xc0 read or 0x40 write*/
82 B2C2_WAIT_FOR_OPERATION_RDW
* HZ
);
84 if (len
!= sizeof(u32
)) {
85 err("error while %s dword from %d (%d).",read
? "reading" : "writing",
86 wAddress
,wRegOffsPCI
);
93 * DKT 010817 - add support for V8 memory read/write and flash update
95 static int flexcop_usb_v8_memory_req(struct flexcop_usb
*fc_usb
,
96 flexcop_usb_request_t req
, u8 page
, u16 wAddress
,
97 u8
*pbBuffer
,u32 buflen
)
100 u8 request_type
= USB_TYPE_VENDOR
;
102 int nWaitTime
,pipe
,len
;
107 case B2C2_USB_READ_V8_MEM
:
108 nWaitTime
= B2C2_WAIT_FOR_OPERATION_V8READ
;
109 request_type
|= USB_DIR_IN
;
110 // dwRequestType = (u8) RTYPE_READ_V8_MEMORY;
111 pipe
= B2C2_USB_CTRL_PIPE_IN
;
113 case B2C2_USB_WRITE_V8_MEM
:
114 wIndex
|= pbBuffer
[0];
115 request_type
|= USB_DIR_OUT
;
116 nWaitTime
= B2C2_WAIT_FOR_OPERATION_V8WRITE
;
117 // dwRequestType = (u8) RTYPE_WRITE_V8_MEMORY;
118 pipe
= B2C2_USB_CTRL_PIPE_OUT
;
120 case B2C2_USB_FLASH_BLOCK
:
121 request_type
|= USB_DIR_OUT
;
122 nWaitTime
= B2C2_WAIT_FOR_OPERATION_V8FLASH
;
123 // dwRequestType = (u8) RTYPE_WRITE_V8_FLASH;
124 pipe
= B2C2_USB_CTRL_PIPE_OUT
;
127 deb_info("unsupported request for v8_mem_req %x.\n",req
);
130 deb_v8("v8mem: %02x %02x %04x %04x, len: %d\n",request_type
,req
,
131 wAddress
,wIndex
,buflen
);
133 len
= usb_control_msg(fc_usb
->udev
,pipe
,
142 debug_dump(pbBuffer
,len
,deb_v8
);
144 return len
== buflen
? 0 : -EIO
;
147 #define bytes_left_to_read_on_page(paddr,buflen) \
148 ((V8_MEMORY_PAGE_SIZE - (paddr & V8_MEMORY_PAGE_MASK)) > buflen \
149 ? buflen : (V8_MEMORY_PAGE_SIZE - (paddr & V8_MEMORY_PAGE_MASK)))
151 static int flexcop_usb_memory_req(struct flexcop_usb
*fc_usb
,flexcop_usb_request_t req
,
152 flexcop_usb_mem_page_t page_start
, u32 addr
, int extended
, u8
*buf
, u32 len
)
159 case B2C2_USB_READ_V8_MEM
: wMax
= USB_MEM_READ_MAX
; break;
160 case B2C2_USB_WRITE_V8_MEM
: wMax
= USB_MEM_WRITE_MAX
; break;
161 case B2C2_USB_FLASH_BLOCK
: wMax
= USB_FLASH_MAX
; break;
166 for (i
= 0; i
< len
;) {
167 pagechunk
= wMax
< bytes_left_to_read_on_page(addr
,len
) ? wMax
: bytes_left_to_read_on_page(addr
,len
);
168 deb_info("%x\n",(addr
& V8_MEMORY_PAGE_MASK
) | (V8_MEMORY_EXTENDED
*extended
));
169 if ((ret
= flexcop_usb_v8_memory_req(fc_usb
,req
,
170 page_start
+ (addr
/ V8_MEMORY_PAGE_SIZE
), /* actual page */
171 (addr
& V8_MEMORY_PAGE_MASK
) | (V8_MEMORY_EXTENDED
*extended
),
172 &buf
[i
],pagechunk
)) < 0)
181 static int flexcop_usb_get_mac_addr(struct flexcop_device
*fc
, int extended
)
183 return flexcop_usb_memory_req(fc
->bus_specific
,B2C2_USB_READ_V8_MEM
,V8_MEMORY_PAGE_FLASH
,0x1f010,1,fc
->mac_address
,6);
187 static int flexcop_usb_utility_req(struct flexcop_usb
*fc_usb
, int set
,
188 flexcop_usb_utility_function_t func
, u8 extra
, u16 wIndex
,
189 u16 buflen
, u8
*pvBuffer
)
192 u8 request_type
= (set
? USB_DIR_OUT
: USB_DIR_IN
) | USB_TYPE_VENDOR
;
193 // u8 dwRequestType = (u8) RTYPE_GENERIC,
195 pipe
= set
? B2C2_USB_CTRL_PIPE_OUT
: B2C2_USB_CTRL_PIPE_IN
,
198 wValue
= (func
<< 8) | extra
;
200 len
= usb_control_msg(fc_usb
->udev
,pipe
,
208 return len
== buflen
? 0 : -EIO
;
213 static int flexcop_usb_i2c_req(struct flexcop_usb
*fc_usb
,
214 flexcop_usb_request_t req
, flexcop_usb_i2c_function_t func
,
215 flexcop_i2c_port_t port
, u8 chipaddr
, u8 addr
, u8
*buf
, u8 buflen
)
218 int nWaitTime
,pipe
,len
;
220 u8 request_type
= USB_TYPE_VENDOR
;
223 case USB_FUNC_I2C_WRITE
:
224 case USB_FUNC_I2C_MULTIWRITE
:
225 case USB_FUNC_I2C_REPEATWRITE
:
226 /* DKT 020208 - add this to support special case of DiSEqC */
227 case USB_FUNC_I2C_CHECKWRITE
:
228 pipe
= B2C2_USB_CTRL_PIPE_OUT
;
230 // dwRequestType = (u8) RTYPE_GENERIC;
231 request_type
|= USB_DIR_OUT
;
233 case USB_FUNC_I2C_READ
:
234 case USB_FUNC_I2C_REPEATREAD
:
235 pipe
= B2C2_USB_CTRL_PIPE_IN
;
237 // dwRequestType = (u8) RTYPE_GENERIC;
238 request_type
|= USB_DIR_IN
;
241 deb_info("unsupported function for i2c_req %x\n",func
);
244 wValue
= (func
<< 8 ) | (port
<< 4);
245 wIndex
= (chipaddr
<< 8 ) | addr
;
247 deb_i2c("i2c %2d: %02x %02x %02x %02x %02x %02x\n",func
,request_type
,req
,
248 ((wValue
&& 0xff) << 8),wValue
>> 8,((wIndex
&& 0xff) << 8),wIndex
>> 8);
250 len
= usb_control_msg(fc_usb
->udev
,pipe
,
259 return len
== buflen
? 0 : -EREMOTEIO
;
262 /* actual bus specific access functions, make sure prototype are/will be equal to pci */
263 static flexcop_ibi_value
flexcop_usb_read_ibi_reg(struct flexcop_device
*fc
, flexcop_ibi_register reg
)
265 flexcop_ibi_value val
;
267 flexcop_usb_readwrite_dw(fc
,reg
, &val
.raw
, 1);
271 static int flexcop_usb_write_ibi_reg(struct flexcop_device
*fc
, flexcop_ibi_register reg
, flexcop_ibi_value val
)
273 return flexcop_usb_readwrite_dw(fc
,reg
, &val
.raw
, 0);
276 static int flexcop_usb_i2c_request(struct flexcop_device
*fc
, flexcop_access_op_t op
,
277 flexcop_i2c_port_t port
, u8 chipaddr
, u8 addr
, u8
*buf
, u16 len
)
280 return flexcop_usb_i2c_req(fc
->bus_specific
,B2C2_USB_I2C_REQUEST
,USB_FUNC_I2C_READ
,port
,chipaddr
,addr
,buf
,len
);
282 return flexcop_usb_i2c_req(fc
->bus_specific
,B2C2_USB_I2C_REQUEST
,USB_FUNC_I2C_WRITE
,port
,chipaddr
,addr
,buf
,len
);
285 static void flexcop_usb_urb_complete(struct urb
*urb
, struct pt_regs
*ptregs
)
287 struct flexcop_usb
*fc_usb
= urb
->context
;
290 if (urb
->actual_length
> 0)
291 deb_ts("urb completed, bufsize: %d actlen; %d\n",urb
->transfer_buffer_length
, urb
->actual_length
);
293 for (i
= 0; i
< urb
->number_of_packets
; i
++) {
294 if (urb
->iso_frame_desc
[i
].status
< 0) {
295 err("iso frame descriptor %d has an error: %d\n",i
,urb
->iso_frame_desc
[i
].status
);
297 if (urb
->iso_frame_desc
[i
].actual_length
> 0) {
298 deb_ts("passed %d bytes to the demux\n",urb
->iso_frame_desc
[i
].actual_length
);
300 flexcop_pass_dmx_data(fc_usb
->fc_dev
,
301 urb
->transfer_buffer
+ urb
->iso_frame_desc
[i
].offset
,
302 urb
->iso_frame_desc
[i
].actual_length
);
304 urb
->iso_frame_desc
[i
].status
= 0;
305 urb
->iso_frame_desc
[i
].actual_length
= 0;
308 usb_submit_urb(urb
,GFP_ATOMIC
);
311 static int flexcop_usb_stream_control(struct flexcop_device
*fc
, int onoff
)
313 /* submit/kill iso packets */
317 static void flexcop_usb_transfer_exit(struct flexcop_usb
*fc_usb
)
320 for (i
= 0; i
< B2C2_USB_NUM_ISO_URB
; i
++)
321 if (fc_usb
->iso_urb
[i
] != NULL
) {
322 deb_ts("unlinking/killing urb no. %d\n",i
);
323 usb_kill_urb(fc_usb
->iso_urb
[i
]);
324 usb_free_urb(fc_usb
->iso_urb
[i
]);
327 if (fc_usb
->iso_buffer
!= NULL
)
328 pci_free_consistent(NULL
,fc_usb
->buffer_size
, fc_usb
->iso_buffer
, fc_usb
->dma_addr
);
331 static int flexcop_usb_transfer_init(struct flexcop_usb
*fc_usb
)
333 u16 frame_size
= fc_usb
->uintf
->cur_altsetting
->endpoint
[0].desc
.wMaxPacketSize
;
334 int bufsize
= B2C2_USB_NUM_ISO_URB
* B2C2_USB_FRAMES_PER_ISO
* frame_size
,i
,j
,ret
;
335 int buffer_offset
= 0;
337 deb_ts("creating %d iso-urbs with %d frames each of %d bytes size = %d.\n",
338 B2C2_USB_NUM_ISO_URB
, B2C2_USB_FRAMES_PER_ISO
, frame_size
,bufsize
);
340 fc_usb
->iso_buffer
= pci_alloc_consistent(NULL
,bufsize
,&fc_usb
->dma_addr
);
341 if (fc_usb
->iso_buffer
== NULL
)
343 memset(fc_usb
->iso_buffer
, 0, bufsize
);
344 fc_usb
->buffer_size
= bufsize
;
346 /* creating iso urbs */
347 for (i
= 0; i
< B2C2_USB_NUM_ISO_URB
; i
++)
348 if (!(fc_usb
->iso_urb
[i
] = usb_alloc_urb(B2C2_USB_FRAMES_PER_ISO
,GFP_ATOMIC
))) {
352 /* initialising and submitting iso urbs */
353 for (i
= 0; i
< B2C2_USB_NUM_ISO_URB
; i
++) {
354 int frame_offset
= 0;
355 struct urb
*urb
= fc_usb
->iso_urb
[i
];
356 deb_ts("initializing and submitting urb no. %d (buf_offset: %d).\n",i
,buffer_offset
);
358 urb
->dev
= fc_usb
->udev
;
359 urb
->context
= fc_usb
;
360 urb
->complete
= flexcop_usb_urb_complete
;
361 urb
->pipe
= B2C2_USB_DATA_PIPE
;
362 urb
->transfer_flags
= URB_ISO_ASAP
;
364 urb
->number_of_packets
= B2C2_USB_FRAMES_PER_ISO
;
365 urb
->transfer_buffer_length
= frame_size
* B2C2_USB_FRAMES_PER_ISO
;
366 urb
->transfer_buffer
= fc_usb
->iso_buffer
+ buffer_offset
;
368 buffer_offset
+= frame_size
* B2C2_USB_FRAMES_PER_ISO
;
369 for (j
= 0; j
< B2C2_USB_FRAMES_PER_ISO
; j
++) {
370 deb_ts("urb no: %d, frame: %d, frame_offset: %d\n",i
,j
,frame_offset
);
371 urb
->iso_frame_desc
[j
].offset
= frame_offset
;
372 urb
->iso_frame_desc
[j
].length
= frame_size
;
373 frame_offset
+= frame_size
;
376 if ((ret
= usb_submit_urb(fc_usb
->iso_urb
[i
],GFP_ATOMIC
))) {
377 err("submitting urb %d failed with %d.",i
,ret
);
380 deb_ts("submitted urb no. %d.\n",i
);
385 flexcop_sram_set_dest(fc_usb
->fc_dev
,FC_SRAM_DEST_MEDIA
| FC_SRAM_DEST_NET
|
386 FC_SRAM_DEST_CAO
| FC_SRAM_DEST_CAI
, FC_SRAM_DEST_TARGET_WAN_USB
);
387 flexcop_wan_set_speed(fc_usb
->fc_dev
,FC_WAN_SPEED_8MBITS
);
388 flexcop_sram_ctrl(fc_usb
->fc_dev
,1,1,1);
393 flexcop_usb_transfer_exit(fc_usb
);
398 static int flexcop_usb_init(struct flexcop_usb
*fc_usb
)
400 /* use the alternate setting with the larges buffer */
401 usb_set_interface(fc_usb
->udev
,0,1);
402 switch (fc_usb
->udev
->speed
) {
404 err("cannot handle USB speed because it is to sLOW.");
408 info("running at FULL speed.");
411 info("running at HIGH speed.");
413 case USB_SPEED_UNKNOWN
: /* fall through */
415 err("cannot handle USB speed because it is unkown.");
418 usb_set_intfdata(fc_usb
->uintf
, fc_usb
);
422 static void flexcop_usb_exit(struct flexcop_usb
*fc_usb
)
424 usb_set_intfdata(fc_usb
->uintf
, NULL
);
427 static int flexcop_usb_probe(struct usb_interface
*intf
,
428 const struct usb_device_id
*id
)
430 struct usb_device
*udev
= interface_to_usbdev(intf
);
431 struct flexcop_usb
*fc_usb
= NULL
;
432 struct flexcop_device
*fc
= NULL
;
435 if ((fc
= flexcop_device_kmalloc(sizeof(struct flexcop_usb
))) == NULL
) {
436 err("out of memory\n");
440 /* general flexcop init */
441 fc_usb
= fc
->bus_specific
;
444 fc
->read_ibi_reg
= flexcop_usb_read_ibi_reg
;
445 fc
->write_ibi_reg
= flexcop_usb_write_ibi_reg
;
446 fc
->i2c_request
= flexcop_usb_i2c_request
;
447 fc
->get_mac_addr
= flexcop_usb_get_mac_addr
;
449 fc
->stream_control
= flexcop_usb_stream_control
;
451 fc
->pid_filtering
= 1;
452 fc
->bus_type
= FC_USB
;
454 fc
->dev
= &udev
->dev
;
456 /* bus specific part */
458 fc_usb
->uintf
= intf
;
459 if ((ret
= flexcop_usb_init(fc_usb
)) != 0)
463 if ((ret
= flexcop_device_initialize(fc
)) != 0)
467 if ((ret
= flexcop_usb_transfer_init(fc_usb
)) != 0)
470 info("%s successfully initialized and connected.",DRIVER_NAME
);
474 flexcop_device_exit(fc
);
476 flexcop_usb_exit(fc_usb
);
478 flexcop_device_kfree(fc
);
483 static void flexcop_usb_disconnect(struct usb_interface
*intf
)
485 struct flexcop_usb
*fc_usb
= usb_get_intfdata(intf
);
486 flexcop_usb_transfer_exit(fc_usb
);
487 flexcop_device_exit(fc_usb
->fc_dev
);
488 flexcop_usb_exit(fc_usb
);
489 flexcop_device_kfree(fc_usb
->fc_dev
);
490 info("%s successfully deinitialized and disconnected.",DRIVER_NAME
);
493 static struct usb_device_id flexcop_usb_table
[] = {
494 { USB_DEVICE(0x0af7, 0x0101) },
498 /* usb specific object needed to register this driver with the usb subsystem */
499 static struct usb_driver flexcop_usb_driver
= {
500 .owner
= THIS_MODULE
,
501 .name
= "Technisat/B2C2 FlexCop II/IIb/III USB",
502 .probe
= flexcop_usb_probe
,
503 .disconnect
= flexcop_usb_disconnect
,
504 .id_table
= flexcop_usb_table
,
508 static int __init
flexcop_usb_module_init(void)
511 if ((result
= usb_register(&flexcop_usb_driver
))) {
512 err("usb_register failed. (%d)",result
);
519 static void __exit
flexcop_usb_module_exit(void)
521 /* deregister this driver from the USB subsystem */
522 usb_deregister(&flexcop_usb_driver
);
525 module_init(flexcop_usb_module_init
);
526 module_exit(flexcop_usb_module_exit
);
528 MODULE_AUTHOR(DRIVER_AUTHOR
);
529 MODULE_DESCRIPTION(DRIVER_NAME
);
530 MODULE_LICENSE("GPL");