d9b6a0355443c8457b16e3e660f7a0edb7324d25
[linux-2.6.git] / drivers / usb / misc / emi26.c
1 /* 
2  * Emagic EMI 2|6 usb audio interface firmware loader.
3  * Copyright (C) 2002
4  *      Tapio Laxström (tapio.laxstrom@iptime.fi)
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License, as published by
8  * the Free Software Foundation, version 2.
9  * 
10  * emi26.c,v 1.13 2002/03/08 13:10:26 tapio Exp
11  */
12 #include <linux/kernel.h>
13 #include <linux/errno.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/usb.h>
18 #include <linux/delay.h>
19 #include <linux/firmware.h>
20 #include <linux/ihex.h>
21
22 #define EMI26_VENDOR_ID                 0x086a  /* Emagic Soft-und Hardware GmBH */
23 #define EMI26_PRODUCT_ID                0x0100  /* EMI 2|6 without firmware */
24 #define EMI26B_PRODUCT_ID               0x0102  /* EMI 2|6 without firmware */
25
26 #define ANCHOR_LOAD_INTERNAL    0xA0    /* Vendor specific request code for Anchor Upload/Download (This one is implemented in the core) */
27 #define ANCHOR_LOAD_EXTERNAL    0xA3    /* This command is not implemented in the core. Requires firmware */
28 #define ANCHOR_LOAD_FPGA        0xA5    /* This command is not implemented in the core. Requires firmware. Emagic extension */
29 #define MAX_INTERNAL_ADDRESS    0x1B3F  /* This is the highest internal RAM address for the AN2131Q */
30 #define CPUCS_REG               0x7F92  /* EZ-USB Control and Status Register.  Bit 0 controls 8051 reset */ 
31 #define INTERNAL_RAM(address)   (address <= MAX_INTERNAL_ADDRESS)
32
33 static int emi26_writememory( struct usb_device *dev, int address,
34                               const unsigned char *data, int length,
35                               __u8 bRequest);
36 static int emi26_set_reset(struct usb_device *dev, unsigned char reset_bit);
37 static int emi26_load_firmware (struct usb_device *dev);
38 static int emi26_probe(struct usb_interface *intf, const struct usb_device_id *id);
39 static void emi26_disconnect(struct usb_interface *intf);
40 static int __init emi26_init (void);
41 static void __exit emi26_exit (void);
42
43
44 /* thanks to drivers/usb/serial/keyspan_pda.c code */
45 static int emi26_writememory (struct usb_device *dev, int address,
46                               const unsigned char *data, int length,
47                               __u8 request)
48 {
49         int result;
50         unsigned char *buffer =  kmemdup(data, length, GFP_KERNEL);
51
52         if (!buffer) {
53                 dev_err(&dev->dev, "kmalloc(%d) failed.\n", length);
54                 return -ENOMEM;
55         }
56         /* Note: usb_control_msg returns negative value on error or length of the
57          *               data that was written! */
58         result = usb_control_msg (dev, usb_sndctrlpipe(dev, 0), request, 0x40, address, 0, buffer, length, 300);
59         kfree (buffer);
60         return result;
61 }
62
63 /* thanks to drivers/usb/serial/keyspan_pda.c code */
64 static int emi26_set_reset (struct usb_device *dev, unsigned char reset_bit)
65 {
66         int response;
67         dev_info(&dev->dev, "%s - %d\n", __func__, reset_bit);
68         /* printk(KERN_DEBUG "%s - %d", __func__, reset_bit); */
69         response = emi26_writememory (dev, CPUCS_REG, &reset_bit, 1, 0xa0);
70         if (response < 0) {
71                 dev_err(&dev->dev, "set_reset (%d) failed\n", reset_bit);
72         }
73         return response;
74 }
75
76 #define FW_LOAD_SIZE            1023
77
78 static int emi26_load_firmware (struct usb_device *dev)
79 {
80         const struct firmware *loader_fw = NULL;
81         const struct firmware *bitstream_fw = NULL;
82         const struct firmware *firmware_fw = NULL;
83         const struct ihex_binrec *rec;
84         int err;
85         int i;
86         __u32 addr;     /* Address to write */
87         __u8 *buf;
88
89         buf = kmalloc(FW_LOAD_SIZE, GFP_KERNEL);
90         if (!buf) {
91                 dev_err(&dev->dev, "%s - error loading firmware: error = %d\n",
92                         __func__, -ENOMEM);
93                 err = -ENOMEM;
94                 goto wraperr;
95         }
96
97         err = request_ihex_firmware(&loader_fw, "emi26/loader.fw", &dev->dev);
98         if (err)
99                 goto nofw;
100
101         err = request_ihex_firmware(&bitstream_fw, "emi26/bitstream.fw",
102                                     &dev->dev);
103         if (err)
104                 goto nofw;
105
106         err = request_ihex_firmware(&firmware_fw, "emi26/firmware.fw",
107                                     &dev->dev);
108         if (err) {
109         nofw:
110                 dev_err(&dev->dev, "%s - request_firmware() failed\n",
111                         __func__);
112                 goto wraperr;
113         }
114
115         /* Assert reset (stop the CPU in the EMI) */
116         err = emi26_set_reset(dev,1);
117         if (err < 0) {
118                 dev_err(&dev->dev,"%s - error loading firmware: error = %d\n",
119                         __func__, err);
120                 goto wraperr;
121         }
122
123         rec = (const struct ihex_binrec *)loader_fw->data;
124         /* 1. We need to put the loader for the FPGA into the EZ-USB */
125         while (rec) {
126                 err = emi26_writememory(dev, be32_to_cpu(rec->addr),
127                                         rec->data, be16_to_cpu(rec->len),
128                                         ANCHOR_LOAD_INTERNAL);
129                 if (err < 0) {
130                         err("%s - error loading firmware: error = %d", __func__, err);
131                         goto wraperr;
132                 }
133                 rec = ihex_next_binrec(rec);
134         }
135
136         /* De-assert reset (let the CPU run) */
137         err = emi26_set_reset(dev,0);
138         if (err < 0) {
139                 err("%s - error loading firmware: error = %d", __func__, err);
140                 goto wraperr;
141         }
142         msleep(250);    /* let device settle */
143
144         /* 2. We upload the FPGA firmware into the EMI
145          * Note: collect up to 1023 (yes!) bytes and send them with
146          * a single request. This is _much_ faster! */
147         rec = (const struct ihex_binrec *)bitstream_fw->data;
148         do {
149                 i = 0;
150                 addr = be32_to_cpu(rec->addr);
151
152                 /* intel hex records are terminated with type 0 element */
153                 while (rec && (i + be16_to_cpu(rec->len) < FW_LOAD_SIZE)) {
154                         memcpy(buf + i, rec->data, be16_to_cpu(rec->len));
155                         i += be16_to_cpu(rec->len);
156                         rec = ihex_next_binrec(rec);
157                 }
158                 err = emi26_writememory(dev, addr, buf, i, ANCHOR_LOAD_FPGA);
159                 if (err < 0) {
160                         err("%s - error loading firmware: error = %d", __func__, err);
161                         goto wraperr;
162                 }
163         } while (rec);
164
165         /* Assert reset (stop the CPU in the EMI) */
166         err = emi26_set_reset(dev,1);
167         if (err < 0) {
168                 err("%s - error loading firmware: error = %d", __func__, err);
169                 goto wraperr;
170         }
171
172         /* 3. We need to put the loader for the firmware into the EZ-USB (again...) */
173         for (rec = (const struct ihex_binrec *)loader_fw->data;
174              rec; rec = ihex_next_binrec(rec)) {
175                 err = emi26_writememory(dev, be32_to_cpu(rec->addr),
176                                         rec->data, be16_to_cpu(rec->len),
177                                         ANCHOR_LOAD_INTERNAL);
178                 if (err < 0) {
179                         err("%s - error loading firmware: error = %d", __func__, err);
180                         goto wraperr;
181                 }
182         }
183         msleep(250);    /* let device settle */
184
185         /* De-assert reset (let the CPU run) */
186         err = emi26_set_reset(dev,0);
187         if (err < 0) {
188                 err("%s - error loading firmware: error = %d", __func__, err);
189                 goto wraperr;
190         }
191
192         /* 4. We put the part of the firmware that lies in the external RAM into the EZ-USB */
193
194         for (rec = (const struct ihex_binrec *)firmware_fw->data;
195              rec; rec = ihex_next_binrec(rec)) {
196                 if (!INTERNAL_RAM(be32_to_cpu(rec->addr))) {
197                         err = emi26_writememory(dev, be32_to_cpu(rec->addr),
198                                                 rec->data, be16_to_cpu(rec->len),
199                                                 ANCHOR_LOAD_EXTERNAL);
200                         if (err < 0) {
201                                 err("%s - error loading firmware: error = %d", __func__, err);
202                                 goto wraperr;
203                         }
204                 }
205         }
206         
207         /* Assert reset (stop the CPU in the EMI) */
208         err = emi26_set_reset(dev,1);
209         if (err < 0) {
210                 err("%s - error loading firmware: error = %d", __func__, err);
211                 goto wraperr;
212         }
213
214         for (rec = (const struct ihex_binrec *)firmware_fw->data;
215              rec; rec = ihex_next_binrec(rec)) {
216                 if (INTERNAL_RAM(be32_to_cpu(rec->addr))) {
217                         err = emi26_writememory(dev, be32_to_cpu(rec->addr),
218                                                 rec->data, be16_to_cpu(rec->len),
219                                                 ANCHOR_LOAD_INTERNAL);
220                         if (err < 0) {
221                                 err("%s - error loading firmware: error = %d", __func__, err);
222                                 goto wraperr;
223                         }
224                 }
225         }
226
227         /* De-assert reset (let the CPU run) */
228         err = emi26_set_reset(dev,0);
229         if (err < 0) {
230                 err("%s - error loading firmware: error = %d", __func__, err);
231                 goto wraperr;
232         }
233         msleep(250);    /* let device settle */
234
235         /* return 1 to fail the driver inialization
236          * and give real driver change to load */
237         err = 1;
238
239 wraperr:
240         release_firmware(loader_fw);
241         release_firmware(bitstream_fw);
242         release_firmware(firmware_fw);
243
244         kfree(buf);
245         return err;
246 }
247
248 static const struct usb_device_id id_table[] = {
249         { USB_DEVICE(EMI26_VENDOR_ID, EMI26_PRODUCT_ID) },
250         { USB_DEVICE(EMI26_VENDOR_ID, EMI26B_PRODUCT_ID) },
251         { }                                             /* Terminating entry */
252 };
253
254 MODULE_DEVICE_TABLE (usb, id_table);
255
256 static int emi26_probe(struct usb_interface *intf, const struct usb_device_id *id)
257 {
258         struct usb_device *dev = interface_to_usbdev(intf);
259
260         dev_info(&intf->dev, "%s start\n", __func__);
261
262         emi26_load_firmware(dev);
263
264         /* do not return the driver context, let real audio driver do that */
265         return -EIO;
266 }
267
268 static void emi26_disconnect(struct usb_interface *intf)
269 {
270 }
271
272 static struct usb_driver emi26_driver = {
273         .name           = "emi26 - firmware loader",
274         .probe          = emi26_probe,
275         .disconnect     = emi26_disconnect,
276         .id_table       = id_table,
277 };
278
279 module_usb_driver(emi26_driver);
280
281 MODULE_AUTHOR("Tapio Laxström");
282 MODULE_DESCRIPTION("Emagic EMI 2|6 firmware loader.");
283 MODULE_LICENSE("GPL");
284
285 MODULE_FIRMWARE("emi26/loader.fw");
286 MODULE_FIRMWARE("emi26/bitstream.fw");
287 MODULE_FIRMWARE("emi26/firmware.fw");
288 /* vi:ai:syntax=c:sw=8:ts=8:tw=80
289  */