sound/usb/6fire/firmware.c

   1 /*
   2  * Linux driver for TerraTec DMX 6Fire USB
   3  *
   4  * Firmware loader
   5  *
   6  * Currently not working for all devices. To be able to use the device
   7  * in linux, it is also possible to let the windows driver upload the firmware.
   8  * For that, start the computer in windows and reboot.
   9  * As long as the device is connected to the power supply, no firmware reload
  10  * needs to be performed.
  11  *
  12  * Author:      Torsten Schenk <torsten.schenk@zoho.com>
  13  * Created:     Jan 01, 2011
  14  * Version:     0.3.0
  15  * Copyright:   (C) Torsten Schenk
  16  *
  17  * This program is free software; you can redistribute it and/or modify
  18  * it under the terms of the GNU General Public License as published by
  19  * the Free Software Foundation; either version 2 of the License, or
  20  * (at your option) any later version.
  21  */
  22
  23 #include <linux/firmware.h>
  24
  25 #include "firmware.h"
  26 #include "chip.h"
  27
  28 MODULE_FIRMWARE("6fire/dmx6firel2.ihx");
  29 MODULE_FIRMWARE("6fire/dmx6fireap.ihx");
  30 MODULE_FIRMWARE("6fire/dmx6firecf.bin");
  31
  32 enum {
  33         FPGA_BUFSIZE = 512, FPGA_EP = 2
  34 };
  35
  36 static const u8 BIT_REVERSE_TABLE[256] = {
  37         0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0, 0x10, 0x90, 0x50,
  38         0xd0, 0x30, 0xb0, 0x70, 0xf0, 0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8,
  39         0x68, 0xe8, 0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8, 0x04,
  40         0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4, 0x14, 0x94, 0x54, 0xd4,
  41         0x34, 0xb4, 0x74, 0xf4, 0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c,
  42         0xec, 0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc, 0x02, 0x82,
  43         0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2, 0x12, 0x92, 0x52, 0xd2, 0x32,
  44         0xb2, 0x72, 0xf2, 0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
  45         0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa, 0x06, 0x86, 0x46,
  46         0xc6, 0x26, 0xa6, 0x66, 0xe6, 0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6,
  47         0x76, 0xf6, 0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee, 0x1e,
  48         0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe, 0x01, 0x81, 0x41, 0xc1,
  49         0x21, 0xa1, 0x61, 0xe1, 0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71,
  50         0xf1, 0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9, 0x19, 0x99,
  51         0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9, 0x05, 0x85, 0x45, 0xc5, 0x25,
  52         0xa5, 0x65, 0xe5, 0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
  53         0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed, 0x1d, 0x9d, 0x5d,
  54         0xdd, 0x3d, 0xbd, 0x7d, 0xfd, 0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3,
  55         0x63, 0xe3, 0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3, 0x0b,
  56         0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb, 0x1b, 0x9b, 0x5b, 0xdb,
  57         0x3b, 0xbb, 0x7b, 0xfb, 0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67,
  58         0xe7, 0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7, 0x0f, 0x8f,
  59         0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef, 0x1f, 0x9f, 0x5f, 0xdf, 0x3f,
  60         0xbf, 0x7f, 0xff };
  61
  62 /*
  63  * wMaxPacketSize of pcm endpoints.
  64  * keep synced with rates_in_packet_size and rates_out_packet_size in pcm.c
  65  * fpp: frames per isopacket
  66  *
  67  * CAUTION: keep sizeof <= buffer[] in usb6fire_fw_init
  68  */
  69 static const u8 ep_w_max_packet_size[] = {
  70         0xe4, 0x00, 0xe4, 0x00, /* alt 1: 228 EP2 and EP6 (7 fpp) */
  71         0xa4, 0x01, 0xa4, 0x01, /* alt 2: 420 EP2 and EP6 (13 fpp)*/
  72         0x94, 0x01, 0x5c, 0x02  /* alt 3: 404 EP2 and 604 EP6 (25 fpp) */
  73 };
  74
  75 struct ihex_record {
  76         u16 address;
  77         u8 len;
  78         u8 data[256];
  79         char error; /* true if an error occurred parsing this record */
  80
  81         u8 max_len; /* maximum record length in whole ihex */
  82
  83         /* private */
  84         const char *txt_data;
  85         unsigned int txt_length;
  86         unsigned int txt_offset; /* current position in txt_data */
  87 };
  88
  89 static u8 usb6fire_fw_ihex_nibble(const u8 n)
  90 {
  91         if (n >= '0' && n <= '9')
  92                 return n - '0';
  93         else if (n >= 'A' && n <= 'F')
  94                 return n - ('A' - 10);
  95         else if (n >= 'a' && n <= 'f')
  96                 return n - ('a' - 10);
  97         return 0;
  98 }
  99
 100 static u8 usb6fire_fw_ihex_hex(const u8 *data, u8 *crc)
 101 {
 102         u8 val = (usb6fire_fw_ihex_nibble(data[0]) << 4) |
 103                         usb6fire_fw_ihex_nibble(data[1]);
 104         *crc += val;
 105         return val;
 106 }
 107
 108 /*
 109  * returns true if record is available, false otherwise.
 110  * iff an error occurred, false will be returned and record->error will be true.
 111  */
 112 static bool usb6fire_fw_ihex_next_record(struct ihex_record *record)
 113 {
 114         u8 crc = 0;
 115         u8 type;
 116         int i;
 117
 118         record->error = false;
 119
 120         /* find begin of record (marked by a colon) */
 121         while (record->txt_offset < record->txt_length
 122                         && record->txt_data[record->txt_offset] != ':')
 123                 record->txt_offset++;
 124         if (record->txt_offset == record->txt_length)
 125                 return false;
 126
 127         /* number of characters needed for len, addr and type entries */
 128         record->txt_offset++;
 129         if (record->txt_offset + 8 > record->txt_length) {
 130                 record->error = true;
 131                 return false;
 132         }
 133
 134         record->len = usb6fire_fw_ihex_hex(record->txt_data +
 135                         record->txt_offset, &crc);
 136         record->txt_offset += 2;
 137         record->address = usb6fire_fw_ihex_hex(record->txt_data +
 138                         record->txt_offset, &crc) << 8;
 139         record->txt_offset += 2;
 140         record->address |= usb6fire_fw_ihex_hex(record->txt_data +
 141                         record->txt_offset, &crc);
 142         record->txt_offset += 2;
 143         type = usb6fire_fw_ihex_hex(record->txt_data +
 144                         record->txt_offset, &crc);
 145         record->txt_offset += 2;
 146
 147         /* number of characters needed for data and crc entries */
 148         if (record->txt_offset + 2 * (record->len + 1) > record->txt_length) {
 149                 record->error = true;
 150                 return false;
 151         }
 152         for (i = 0; i < record->len; i++) {
 153                 record->data[i] = usb6fire_fw_ihex_hex(record->txt_data
 154                                 + record->txt_offset, &crc);
 155                 record->txt_offset += 2;
 156         }
 157         usb6fire_fw_ihex_hex(record->txt_data + record->txt_offset, &crc);
 158         if (crc) {
 159                 record->error = true;
 160                 return false;
 161         }
 162
 163         if (type == 1 || !record->len) /* eof */
 164                 return false;
 165         else if (type == 0)
 166                 return true;
 167         else {
 168                 record->error = true;
 169                 return false;
 170         }
 171 }
 172
 173 static int usb6fire_fw_ihex_init(const struct firmware *fw,
 174                 struct ihex_record *record)
 175 {
 176         record->txt_data = fw->data;
 177         record->txt_length = fw->size;
 178         record->txt_offset = 0;
 179         record->max_len = 0;
 180         /* read all records, if loop ends, record->error indicates,
 181          * whether ihex is valid. */
 182         while (usb6fire_fw_ihex_next_record(record))
 183                 record->max_len = max(record->len, record->max_len);
 184         if (record->error)
 185                 return -EINVAL;
 186         record->txt_offset = 0;
 187         return 0;
 188 }
 189
 190 static int usb6fire_fw_ezusb_write(struct usb_device *device,
 191                 int type, int value, char *data, int len)
 192 {
 193         int ret;
 194
 195         ret = usb_control_msg(device, usb_sndctrlpipe(device, 0), type,
 196                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 197                         value, 0, data, len, HZ);
 198         if (ret < 0)
 199                 return ret;
 200         else if (ret != len)
 201                 return -EIO;
 202         return 0;
 203 }
 204
 205 static int usb6fire_fw_ezusb_read(struct usb_device *device,
 206                 int type, int value, char *data, int len)
 207 {
 208         int ret = usb_control_msg(device, usb_rcvctrlpipe(device, 0), type,
 209                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, value,
 210                         0, data, len, HZ);
 211         if (ret < 0)
 212                 return ret;
 213         else if (ret != len)
 214                 return -EIO;
 215         return 0;
 216 }
 217
 218 static int usb6fire_fw_fpga_write(struct usb_device *device,
 219                 char *data, int len)
 220 {
 221         int actual_len;
 222         int ret;
 223
 224         ret = usb_bulk_msg(device, usb_sndbulkpipe(device, FPGA_EP), data, len,
 225                         &actual_len, HZ);
 226         if (ret < 0)
 227                 return ret;
 228         else if (actual_len != len)
 229                 return -EIO;
 230         return 0;
 231 }
 232
 233 static int usb6fire_fw_ezusb_upload(
 234                 struct usb_interface *intf, const char *fwname,
 235                 unsigned int postaddr, u8 *postdata, unsigned int postlen)
 236 {
 237         int ret;
 238         u8 data;
 239         struct usb_device *device = interface_to_usbdev(intf);
 240         const struct firmware *fw = 0;
 241         struct ihex_record *rec = kmalloc(sizeof(struct ihex_record),
 242                         GFP_KERNEL);
 243
 244         if (!rec)
 245                 return -ENOMEM;
 246
 247         ret = request_firmware(&fw, fwname, &device->dev);
 248         if (ret < 0) {
 249                 kfree(rec);
 250                 snd_printk(KERN_ERR PREFIX "error requesting ezusb "
 251                                 "firmware %s.\n", fwname);
 252                 return ret;
 253         }
 254         ret = usb6fire_fw_ihex_init(fw, rec);
 255         if (ret < 0) {
 256                 kfree(rec);
 257                 snd_printk(KERN_ERR PREFIX "error validating ezusb "
 258                                 "firmware %s.\n", fwname);
 259                 return ret;
 260         }
 261         /* upload firmware image */
 262         data = 0x01; /* stop ezusb cpu */
 263         ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1);
 264         if (ret < 0) {
 265                 kfree(rec);
 266                 release_firmware(fw);
 267                 snd_printk(KERN_ERR PREFIX "unable to upload ezusb "
 268                                 "firmware %s: begin message.\n", fwname);
 269                 return ret;
 270         }
 271
 272         while (usb6fire_fw_ihex_next_record(rec)) { /* write firmware */
 273                 ret = usb6fire_fw_ezusb_write(device, 0xa0, rec->address,
 274                                 rec->data, rec->len);
 275                 if (ret < 0) {
 276                         kfree(rec);
 277                         release_firmware(fw);
 278                         snd_printk(KERN_ERR PREFIX "unable to upload ezusb "
 279                                         "firmware %s: data urb.\n", fwname);
 280                         return ret;
 281                 }
 282         }
 283
 284         release_firmware(fw);
 285         kfree(rec);
 286         if (postdata) { /* write data after firmware has been uploaded */
 287                 ret = usb6fire_fw_ezusb_write(device, 0xa0, postaddr,
 288                                 postdata, postlen);
 289                 if (ret < 0) {
 290                         snd_printk(KERN_ERR PREFIX "unable to upload ezusb "
 291                                         "firmware %s: post urb.\n", fwname);
 292                         return ret;
 293                 }
 294         }
 295
 296         data = 0x00; /* resume ezusb cpu */
 297         ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1);
 298         if (ret < 0) {
 299                 release_firmware(fw);
 300                 snd_printk(KERN_ERR PREFIX "unable to upload ezusb "
 301                                 "firmware %s: end message.\n", fwname);
 302                 return ret;
 303         }
 304         return 0;
 305 }
 306
 307 static int usb6fire_fw_fpga_upload(
 308                 struct usb_interface *intf, const char *fwname)
 309 {
 310         int ret;
 311         int i;
 312         struct usb_device *device = interface_to_usbdev(intf);
 313         u8 *buffer = kmalloc(FPGA_BUFSIZE, GFP_KERNEL);
 314         const char *c;
 315         const char *end;
 316         const struct firmware *fw;
 317
 318         if (!buffer)
 319                 return -ENOMEM;
 320
 321         ret = request_firmware(&fw, fwname, &device->dev);
 322         if (ret < 0) {
 323                 snd_printk(KERN_ERR PREFIX "unable to get fpga firmware %s.\n",
 324                                 fwname);
 325                 kfree(buffer);
 326                 return -EIO;
 327         }
 328
 329         c = fw->data;
 330         end = fw->data + fw->size;
 331
 332         ret = usb6fire_fw_ezusb_write(device, 8, 0, NULL, 0);
 333         if (ret < 0) {
 334                 kfree(buffer);
 335                 release_firmware(fw);
 336                 snd_printk(KERN_ERR PREFIX "unable to upload fpga firmware: "
 337                                 "begin urb.\n");
 338                 return ret;
 339         }
 340
 341         while (c != end) {
 342                 for (i = 0; c != end && i < FPGA_BUFSIZE; i++, c++)
 343                         buffer[i] = BIT_REVERSE_TABLE[(u8) *c];
 344
 345                 ret = usb6fire_fw_fpga_write(device, buffer, i);
 346                 if (ret < 0) {
 347                         release_firmware(fw);
 348                         kfree(buffer);
 349                         snd_printk(KERN_ERR PREFIX "unable to upload fpga "
 350                                         "firmware: fw urb.\n");
 351                         return ret;
 352                 }
 353         }
 354         release_firmware(fw);
 355         kfree(buffer);
 356
 357         ret = usb6fire_fw_ezusb_write(device, 9, 0, NULL, 0);
 358         if (ret < 0) {
 359                 snd_printk(KERN_ERR PREFIX "unable to upload fpga firmware: "
 360                                 "end urb.\n");
 361                 return ret;
 362         }
 363         return 0;
 364 }
 365
 366 int usb6fire_fw_init(struct usb_interface *intf)
 367 {
 368         int i;
 369         int ret;
 370         struct usb_device *device = interface_to_usbdev(intf);
 371         /* buffer: 8 receiving bytes from device and
 372          * sizeof(EP_W_MAX_PACKET_SIZE) bytes for non-const copy */
 373         u8 buffer[12];
 374
 375         ret = usb6fire_fw_ezusb_read(device, 1, 0, buffer, 8);
 376         if (ret < 0) {
 377                 snd_printk(KERN_ERR PREFIX "unable to receive device "
 378                                 "firmware state.\n");
 379                 return ret;
 380         }
 381         if (buffer[0] != 0xeb || buffer[1] != 0xaa || buffer[2] != 0x55
 382                         || buffer[4] != 0x03 || buffer[5] != 0x01 || buffer[7]
 383                         != 0x00) {
 384                 snd_printk(KERN_ERR PREFIX "unknown device firmware state "
 385                                 "received from device: ");
 386                 for (i = 0; i < 8; i++)
 387                         snd_printk("%02x ", buffer[i]);
 388                 snd_printk("\n");
 389                 return -EIO;
 390         }
 391         /* do we need fpga loader ezusb firmware? */
 392         if (buffer[3] == 0x01 && buffer[6] == 0x19) {
 393                 ret = usb6fire_fw_ezusb_upload(intf,
 394                                 "6fire/dmx6firel2.ihx", 0, NULL, 0);
 395                 if (ret < 0)
 396                         return ret;
 397                 return FW_NOT_READY;
 398         }
 399         /* do we need fpga firmware and application ezusb firmware? */
 400         else if (buffer[3] == 0x02 && buffer[6] == 0x0b) {
 401                 ret = usb6fire_fw_fpga_upload(intf, "6fire/dmx6firecf.bin");
 402                 if (ret < 0)
 403                         return ret;
 404                 memcpy(buffer, ep_w_max_packet_size,
 405                                 sizeof(ep_w_max_packet_size));
 406                 ret = usb6fire_fw_ezusb_upload(intf, "6fire/dmx6fireap.ihx",
 407                                 0x0003, buffer, sizeof(ep_w_max_packet_size));
 408                 if (ret < 0)
 409                         return ret;
 410                 return FW_NOT_READY;
 411         }
 412         /* all fw loaded? */
 413         else if (buffer[3] == 0x03 && buffer[6] == 0x0b)
 414                 return 0;
 415         /* unknown data? */
 416         else {
 417                 snd_printk(KERN_ERR PREFIX "unknown device firmware state "
 418                                 "received from device: ");
 419                 for (i = 0; i < 8; i++)
 420                         snd_printk("%02x ", buffer[i]);
 421                 snd_printk("\n");
 422                 return -EIO;
 423         }
 424         return 0;
 425 }
 426