1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
/* dvb-usb-firmware.c is part of the DVB USB library.
*
* Copyright (C) 2004-6 Patrick Boettcher (patrick.boettcher@desy.de)
* see dvb-usb-init.c for copyright information.
*
* This file contains functions for downloading the firmware to Cypress FX 1
* and 2 based devices.
*
* FIXME: This part does actually not belong to dvb-usb, but to the
* usb-subsystem.
*/
#include "dvb_usb_common.h"
#include <linux/usb.h>
struct usb_cypress_controller {
int id;
/* name of the usb controller */
const char *name;
/* needs to be restarted, when the firmware has been downloaded. */
u16 cpu_cs_register;
};
static struct usb_cypress_controller cypress[] = {
{ .id = DEVICE_SPECIFIC, .name = "Device specific",
.cpu_cs_register = 0 },
{ .id = CYPRESS_AN2135, .name = "Cypress AN2135",
.cpu_cs_register = 0x7f92 },
{ .id = CYPRESS_AN2235, .name = "Cypress AN2235",
.cpu_cs_register = 0x7f92 },
{ .id = CYPRESS_FX2, .name = "Cypress FX2",
.cpu_cs_register = 0xe600 },
};
/*
* load a firmware packet to the device
*/
static int usb_cypress_writemem(struct usb_device *udev, u16 addr, u8 *data,
u8 len)
{
return usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
0xa0, USB_TYPE_VENDOR, addr, 0x00, data, len, 5000);
}
int usbv2_cypress_load_firmware(struct usb_device *udev,
const struct firmware *fw, int type)
{
struct hexline hx;
u8 reset;
int ret, pos = 0;
/* stop the CPU */
reset = 1;
ret = usb_cypress_writemem(udev, cypress[type].cpu_cs_register,
&reset, 1);
if (ret != 1)
err("could not stop the USB controller CPU.");
while ((ret = dvb_usbv2_get_hexline(fw, &hx, &pos)) > 0) {
deb_fw("writing to address 0x%04x (buffer: 0x%02x %02x)\n",
hx.addr, hx.len, hx.chk);
ret = usb_cypress_writemem(udev, hx.addr, hx.data, hx.len);
if (ret != hx.len) {
err("error while transferring firmware " \
"(transferred size: %d, block size: %d)",
ret, hx.len);
ret = -EINVAL;
break;
}
}
if (ret < 0) {
err("firmware download failed at %d with %d", pos, ret);
return ret;
}
if (ret == 0) {
/* restart the CPU */
reset = 0;
if (ret || usb_cypress_writemem(udev,
cypress[type].cpu_cs_register,
&reset, 1) != 1) {
err("could not restart the USB controller CPU.");
ret = -EINVAL;
}
} else
ret = -EIO;
return ret;
}
EXPORT_SYMBOL(usbv2_cypress_load_firmware);
int dvb_usb_download_firmware(struct dvb_usb_device *d)
{
int ret;
const struct firmware *fw = NULL;
const char *name;
ret = d->props.get_firmware_name(d, &name);
if (ret < 0)
return ret;
ret = request_firmware(&fw, name, &d->udev->dev);
if (ret != 0) {
err("did not find the firmware file. (%s) " \
"Please see linux/Documentation/dvb/ for more" \
" details on firmware-problems. (%d)",
name, ret);
return ret;
}
info("downloading firmware from file '%s'", name);
switch (d->props.usb_ctrl) {
case CYPRESS_AN2135:
case CYPRESS_AN2235:
case CYPRESS_FX2:
ret = usbv2_cypress_load_firmware(d->udev, fw,
d->props.usb_ctrl);
break;
case DEVICE_SPECIFIC:
if (d->props.download_firmware)
ret = d->props.download_firmware(d, fw);
else {
err("BUG: driver didn't specified a download_firmware" \
"-callback, although it claims to have a" \
" DEVICE_SPECIFIC one.");
ret = -EINVAL;
}
break;
default:
ret = -EINVAL;
break;
}
release_firmware(fw);
return ret;
}
int dvb_usbv2_get_hexline(const struct firmware *fw, struct hexline *hx,
int *pos)
{
u8 *b = (u8 *) &fw->data[*pos];
int data_offs = 4;
if (*pos >= fw->size)
return 0;
memset(hx, 0, sizeof(struct hexline));
hx->len = b[0];
if ((*pos + hx->len + 4) >= fw->size)
return -EINVAL;
hx->addr = b[1] | (b[2] << 8);
hx->type = b[3];
if (hx->type == 0x04) {
/* b[4] and b[5] are the Extended linear address record data
* field */
hx->addr |= (b[4] << 24) | (b[5] << 16);
/* hx->len -= 2;
data_offs += 2; */
}
memcpy(hx->data, &b[data_offs], hx->len);
hx->chk = b[hx->len + data_offs];
*pos += hx->len + 5;
return *pos;
}
EXPORT_SYMBOL(dvb_usbv2_get_hexline);
|
