1 /*
2 * Copyright (C) 2008 Sensoray Company Inc.
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License (Version 2) as
6 * published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
16 */
17
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/usb.h>
22 #include <dvb-usb.h>
23
24 #define S2250_LOADER_FIRMWARE "s2250_loader.fw"
25 #define S2250_FIRMWARE "s2250.fw"
26
27 typedef struct device_extension_s {
28 struct kref kref;
29 int minor;
30 struct usb_device *usbdev;
31 } device_extension_t, *pdevice_extension_t;
32
33 #define USB_s2250loader_MAJOR 240
34 #define USB_s2250loader_MINOR_BASE 0
35 #define MAX_DEVICES 256
36
37 static pdevice_extension_t s2250_dev_table[MAX_DEVICES];
38 static DEFINE_MUTEX(s2250_dev_table_mutex);
39
40 #define to_s2250loader_dev_common(d) container_of(d, device_extension_t, kref)
s2250loader_delete(struct kref * kref)41 static void s2250loader_delete(struct kref *kref)
42 {
43 pdevice_extension_t s = to_s2250loader_dev_common(kref);
44 s2250_dev_table[s->minor] = NULL;
45 kfree(s);
46 }
47
s2250loader_probe(struct usb_interface * interface,const struct usb_device_id * id)48 static int s2250loader_probe(struct usb_interface *interface,
49 const struct usb_device_id *id)
50 {
51 struct usb_device *usbdev;
52 int minor, ret;
53 pdevice_extension_t s = NULL;
54 const struct firmware *fw;
55
56 usbdev = usb_get_dev(interface_to_usbdev(interface));
57 if (!usbdev) {
58 printk(KERN_ERR "Enter s2250loader_probe failed\n");
59 return -1;
60 }
61 printk(KERN_INFO "Enter s2250loader_probe 2.6 kernel\n");
62 printk(KERN_INFO "vendor id 0x%x, device id 0x%x devnum:%d\n",
63 usbdev->descriptor.idVendor, usbdev->descriptor.idProduct,
64 usbdev->devnum);
65
66 if (usbdev->descriptor.bNumConfigurations != 1) {
67 printk(KERN_ERR "can't handle multiple config\n");
68 return -1;
69 }
70 mutex_lock(&s2250_dev_table_mutex);
71
72 for (minor = 0; minor < MAX_DEVICES; minor++) {
73 if (s2250_dev_table[minor] == NULL)
74 break;
75 }
76
77 if (minor < 0 || minor >= MAX_DEVICES) {
78 printk(KERN_ERR "Invalid minor: %d\n", minor);
79 goto failed;
80 }
81
82 /* Allocate dev data structure */
83 s = kmalloc(sizeof(device_extension_t), GFP_KERNEL);
84 if (s == NULL) {
85 printk(KERN_ERR "Out of memory\n");
86 goto failed;
87 }
88 s2250_dev_table[minor] = s;
89
90 printk(KERN_INFO "s2250loader_probe: Device %d on Bus %d Minor %d\n",
91 usbdev->devnum, usbdev->bus->busnum, minor);
92
93 memset(s, 0, sizeof(device_extension_t));
94 s->usbdev = usbdev;
95 printk(KERN_INFO "loading 2250 loader\n");
96
97 kref_init(&(s->kref));
98
99 mutex_unlock(&s2250_dev_table_mutex);
100
101 if (request_firmware(&fw, S2250_LOADER_FIRMWARE, &usbdev->dev)) {
102 printk(KERN_ERR
103 "s2250: unable to load firmware from file \"%s\"\n",
104 S2250_LOADER_FIRMWARE);
105 goto failed2;
106 }
107 ret = usb_cypress_load_firmware(usbdev, fw, CYPRESS_FX2);
108 release_firmware(fw);
109 if (0 != ret) {
110 printk(KERN_ERR "loader download failed\n");
111 goto failed2;
112 }
113
114 if (request_firmware(&fw, S2250_FIRMWARE, &usbdev->dev)) {
115 printk(KERN_ERR
116 "s2250: unable to load firmware from file \"%s\"\n",
117 S2250_FIRMWARE);
118 goto failed2;
119 }
120 ret = usb_cypress_load_firmware(usbdev, fw, CYPRESS_FX2);
121 release_firmware(fw);
122 if (0 != ret) {
123 printk(KERN_ERR "firmware_s2250 download failed\n");
124 goto failed2;
125 }
126
127 usb_set_intfdata(interface, s);
128 return 0;
129
130 failed:
131 mutex_unlock(&s2250_dev_table_mutex);
132 failed2:
133 if (s)
134 kref_put(&(s->kref), s2250loader_delete);
135
136 printk(KERN_ERR "probe failed\n");
137 return -1;
138 }
139
s2250loader_disconnect(struct usb_interface * interface)140 static void s2250loader_disconnect(struct usb_interface *interface)
141 {
142 pdevice_extension_t s;
143 printk(KERN_INFO "s2250: disconnect\n");
144 s = usb_get_intfdata(interface);
145 usb_set_intfdata(interface, NULL);
146 kref_put(&(s->kref), s2250loader_delete);
147 }
148
149 static const struct usb_device_id s2250loader_ids[] = {
150 {USB_DEVICE(0x1943, 0xa250)},
151 {} /* Terminating entry */
152 };
153
154 MODULE_DEVICE_TABLE(usb, s2250loader_ids);
155
156 static struct usb_driver s2250loader_driver = {
157 .name = "s2250-loader",
158 .probe = s2250loader_probe,
159 .disconnect = s2250loader_disconnect,
160 .id_table = s2250loader_ids,
161 };
162
s2250loader_init(void)163 static int __init s2250loader_init(void)
164 {
165 int r;
166 unsigned i = 0;
167
168 for (i = 0; i < MAX_DEVICES; i++)
169 s2250_dev_table[i] = NULL;
170
171 r = usb_register(&s2250loader_driver);
172 if (r) {
173 printk(KERN_ERR "usb_register failed. Error number %d\n", r);
174 return -1;
175 }
176
177 printk(KERN_INFO "s2250loader_init: driver registered\n");
178 return 0;
179 }
180 module_init(s2250loader_init);
181
s2250loader_cleanup(void)182 static void __exit s2250loader_cleanup(void)
183 {
184 printk(KERN_INFO "s2250loader_cleanup\n");
185 usb_deregister(&s2250loader_driver);
186 }
187 module_exit(s2250loader_cleanup);
188
189 MODULE_AUTHOR("");
190 MODULE_DESCRIPTION("firmware loader for Sensoray 2250/2251");
191 MODULE_LICENSE("GPL v2");
192