sound/usb/6fire/firmware.c

   1 /*
   2  * Linux driver for TerraTec DMX 6Fire USB
   3  *
   4  * Firmware loader
   5  *
   6  * Author:      Torsten Schenk <torsten.schenk@zoho.com>
   7  * Created:     Jan 01, 2011
   8  * Copyright:   (C) Torsten Schenk
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  */
  15
  16 #include <linux/firmware.h>
  17 #include <linux/module.h>
  18 #include <linux/bitrev.h>
  19 #include <linux/kernel.h>
  20
  21 #include "firmware.h"
  22 #include "chip.h"
  23
  24 /*(DEBLOBBED)*/
  25
  26 enum {
  27         FPGA_BUFSIZE = 512, FPGA_EP = 2
  28 };
  29
  30 /*
  31  * wMaxPacketSize of pcm endpoints.
  32  * keep synced with rates_in_packet_size and rates_out_packet_size in pcm.c
  33  * fpp: frames per isopacket
  34  *
  35  * CAUTION: keep sizeof <= buffer[] in usb6fire_fw_init
  36  */
  37 static const u8 ep_w_max_packet_size[] = {
  38         0xe4, 0x00, 0xe4, 0x00, /* alt 1: 228 EP2 and EP6 (7 fpp) */
  39         0xa4, 0x01, 0xa4, 0x01, /* alt 2: 420 EP2 and EP6 (13 fpp)*/
  40         0x94, 0x01, 0x5c, 0x02  /* alt 3: 404 EP2 and 604 EP6 (25 fpp) */
  41 };
  42
  43 static const u8 known_fw_versions[][2] = {
  44         { 0x03, 0x01 }
  45 };
  46
  47 struct ihex_record {
  48         u16 address;
  49         u8 len;
  50         u8 data[256];
  51         char error; /* true if an error occurred parsing this record */
  52
  53         u8 max_len; /* maximum record length in whole ihex */
  54
  55         /* private */
  56         const char *txt_data;
  57         unsigned int txt_length;
  58         unsigned int txt_offset; /* current position in txt_data */
  59 };
  60
  61 static u8 usb6fire_fw_ihex_hex(const u8 *data, u8 *crc)
  62 {
  63         u8 val = 0;
  64         int hval;
  65
  66         hval = hex_to_bin(data[0]);
  67         if (hval >= 0)
  68                 val |= (hval << 4);
  69
  70         hval = hex_to_bin(data[1]);
  71         if (hval >= 0)
  72                 val |= hval;
  73
  74         *crc += val;
  75         return val;
  76 }
  77
  78 /*
  79  * returns true if record is available, false otherwise.
  80  * iff an error occurred, false will be returned and record->error will be true.
  81  */
  82 static bool usb6fire_fw_ihex_next_record(struct ihex_record *record)
  83 {
  84         u8 crc = 0;
  85         u8 type;
  86         int i;
  87
  88         record->error = false;
  89
  90         /* find begin of record (marked by a colon) */
  91         while (record->txt_offset < record->txt_length
  92                         && record->txt_data[record->txt_offset] != ':')
  93                 record->txt_offset++;
  94         if (record->txt_offset == record->txt_length)
  95                 return false;
  96
  97         /* number of characters needed for len, addr and type entries */
  98         record->txt_offset++;
  99         if (record->txt_offset + 8 > record->txt_length) {
 100                 record->error = true;
 101                 return false;
 102         }
 103
 104         record->len = usb6fire_fw_ihex_hex(record->txt_data +
 105                         record->txt_offset, &crc);
 106         record->txt_offset += 2;
 107         record->address = usb6fire_fw_ihex_hex(record->txt_data +
 108                         record->txt_offset, &crc) << 8;
 109         record->txt_offset += 2;
 110         record->address |= usb6fire_fw_ihex_hex(record->txt_data +
 111                         record->txt_offset, &crc);
 112         record->txt_offset += 2;
 113         type = usb6fire_fw_ihex_hex(record->txt_data +
 114                         record->txt_offset, &crc);
 115         record->txt_offset += 2;
 116
 117         /* number of characters needed for data and crc entries */
 118         if (record->txt_offset + 2 * (record->len + 1) > record->txt_length) {
 119                 record->error = true;
 120                 return false;
 121         }
 122         for (i = 0; i < record->len; i++) {
 123                 record->data[i] = usb6fire_fw_ihex_hex(record->txt_data
 124                                 + record->txt_offset, &crc);
 125                 record->txt_offset += 2;
 126         }
 127         usb6fire_fw_ihex_hex(record->txt_data + record->txt_offset, &crc);
 128         if (crc) {
 129                 record->error = true;
 130                 return false;
 131         }
 132
 133         if (type == 1 || !record->len) /* eof */
 134                 return false;
 135         else if (type == 0)
 136                 return true;
 137         else {
 138                 record->error = true;
 139                 return false;
 140         }
 141 }
 142
 143 static int usb6fire_fw_ihex_init(const struct firmware *fw,
 144                 struct ihex_record *record)
 145 {
 146         record->txt_data = fw->data;
 147         record->txt_length = fw->size;
 148         record->txt_offset = 0;
 149         record->max_len = 0;
 150         /* read all records, if loop ends, record->error indicates,
 151          * whether ihex is valid. */
 152         while (usb6fire_fw_ihex_next_record(record))
 153                 record->max_len = max(record->len, record->max_len);
 154         if (record->error)
 155                 return -EINVAL;
 156         record->txt_offset = 0;
 157         return 0;
 158 }
 159
 160 static int usb6fire_fw_ezusb_write(struct usb_device *device,
 161                 int type, int value, char *data, int len)
 162 {
 163         int ret;
 164
 165         ret = usb_control_msg(device, usb_sndctrlpipe(device, 0), type,
 166                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 167                         value, 0, data, len, HZ);
 168         if (ret < 0)
 169                 return ret;
 170         else if (ret != len)
 171                 return -EIO;
 172         return 0;
 173 }
 174
 175 static int usb6fire_fw_ezusb_read(struct usb_device *device,
 176                 int type, int value, char *data, int len)
 177 {
 178         int ret = usb_control_msg(device, usb_rcvctrlpipe(device, 0), type,
 179                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, value,
 180                         0, data, len, HZ);
 181         if (ret < 0)
 182                 return ret;
 183         else if (ret != len)
 184                 return -EIO;
 185         return 0;
 186 }
 187
 188 static int usb6fire_fw_fpga_write(struct usb_device *device,
 189                 char *data, int len)
 190 {
 191         int actual_len;
 192         int ret;
 193
 194         ret = usb_bulk_msg(device, usb_sndbulkpipe(device, FPGA_EP), data, len,
 195                         &actual_len, HZ);
 196         if (ret < 0)
 197                 return ret;
 198         else if (actual_len != len)
 199                 return -EIO;
 200         return 0;
 201 }
 202
 203 static int usb6fire_fw_ezusb_upload(
 204                 struct usb_interface *intf, const char *fwname,
 205                 unsigned int postaddr, u8 *postdata, unsigned int postlen)
 206 {
 207         int ret;
 208         u8 data;
 209         struct usb_device *device = interface_to_usbdev(intf);
 210         const struct firmware *fw = NULL;
 211         struct ihex_record *rec = kmalloc(sizeof(struct ihex_record),
 212                         GFP_KERNEL);
 213
 214         if (!rec)
 215                 return -ENOMEM;
 216
 217         ret = reject_firmware(&fw, fwname, &device->dev);
 218         if (ret < 0) {
 219                 kfree(rec);
 220                 dev_err(&intf->dev,
 221                         "error requesting ezusb firmware %s.\n", fwname);
 222                 return ret;
 223         }
 224         ret = usb6fire_fw_ihex_init(fw, rec);
 225         if (ret < 0) {
 226                 kfree(rec);
 227                 release_firmware(fw);
 228                 dev_err(&intf->dev,
 229                         "error validating ezusb firmware %s.\n", fwname);
 230                 return ret;
 231         }
 232         /* upload firmware image */
 233         data = 0x01; /* stop ezusb cpu */
 234         ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1);
 235         if (ret < 0) {
 236                 kfree(rec);
 237                 release_firmware(fw);
 238                 dev_err(&intf->dev,
 239                         "unable to upload ezusb firmware %s: begin message.\n",
 240                         fwname);
 241                 return ret;
 242         }
 243
 244         while (usb6fire_fw_ihex_next_record(rec)) { /* write firmware */
 245                 ret = usb6fire_fw_ezusb_write(device, 0xa0, rec->address,
 246                                 rec->data, rec->len);
 247                 if (ret < 0) {
 248                         kfree(rec);
 249                         release_firmware(fw);
 250                         dev_err(&intf->dev,
 251                                 "unable to upload ezusb firmware %s: data urb.\n",
 252                                 fwname);
 253                         return ret;
 254                 }
 255         }
 256
 257         release_firmware(fw);
 258         kfree(rec);
 259         if (postdata) { /* write data after firmware has been uploaded */
 260                 ret = usb6fire_fw_ezusb_write(device, 0xa0, postaddr,
 261                                 postdata, postlen);
 262                 if (ret < 0) {
 263                         dev_err(&intf->dev,
 264                                 "unable to upload ezusb firmware %s: post urb.\n",
 265                                 fwname);
 266                         return ret;
 267                 }
 268         }
 269
 270         data = 0x00; /* resume ezusb cpu */
 271         ret = usb6fire_fw_ezusb_write(device, 0xa0, 0xe600, &data, 1);
 272         if (ret < 0) {
 273                 dev_err(&intf->dev,
 274                         "unable to upload ezusb firmware %s: end message.\n",
 275                         fwname);
 276                 return ret;
 277         }
 278         return 0;
 279 }
 280
 281 static int usb6fire_fw_fpga_upload(
 282                 struct usb_interface *intf, const char *fwname)
 283 {
 284         int ret;
 285         int i;
 286         struct usb_device *device = interface_to_usbdev(intf);
 287         u8 *buffer = kmalloc(FPGA_BUFSIZE, GFP_KERNEL);
 288         const char *c;
 289         const char *end;
 290         const struct firmware *fw;
 291
 292         if (!buffer)
 293                 return -ENOMEM;
 294
 295         ret = reject_firmware(&fw, fwname, &device->dev);
 296         if (ret < 0) {
 297                 dev_err(&intf->dev, "unable to get fpga firmware %s.\n",
 298                                 fwname);
 299                 kfree(buffer);
 300                 return -EIO;
 301         }
 302
 303         c = fw->data;
 304         end = fw->data + fw->size;
 305
 306         ret = usb6fire_fw_ezusb_write(device, 8, 0, NULL, 0);
 307         if (ret < 0) {
 308                 kfree(buffer);
 309                 release_firmware(fw);
 310                 dev_err(&intf->dev,
 311                         "unable to upload fpga firmware: begin urb.\n");
 312                 return ret;
 313         }
 314
 315         while (c != end) {
 316                 for (i = 0; c != end && i < FPGA_BUFSIZE; i++, c++)
 317                         buffer[i] = bitrev8((u8)*c);
 318
 319                 ret = usb6fire_fw_fpga_write(device, buffer, i);
 320                 if (ret < 0) {
 321                         release_firmware(fw);
 322                         kfree(buffer);
 323                         dev_err(&intf->dev,
 324                                 "unable to upload fpga firmware: fw urb.\n");
 325                         return ret;
 326                 }
 327         }
 328         release_firmware(fw);
 329         kfree(buffer);
 330
 331         ret = usb6fire_fw_ezusb_write(device, 9, 0, NULL, 0);
 332         if (ret < 0) {
 333                 dev_err(&intf->dev,
 334                         "unable to upload fpga firmware: end urb.\n");
 335                 return ret;
 336         }
 337         return 0;
 338 }
 339
 340 /* check, if the firmware version the devices has currently loaded
 341  * is known by this driver. 'version' needs to have 4 bytes version
 342  * info data. */
 343 static int usb6fire_fw_check(struct usb_interface *intf, const u8 *version)
 344 {
 345         int i;
 346
 347         for (i = 0; i < ARRAY_SIZE(known_fw_versions); i++)
 348                 if (!memcmp(version, known_fw_versions + i, 2))
 349                         return 0;
 350
 351         dev_err(&intf->dev, "invalid fimware version in device: %4ph. "
 352                         "please reconnect to power. if this failure "
 353                         "still happens, check your firmware installation.",
 354                         version);
 355         return -EINVAL;
 356 }
 357
 358 int usb6fire_fw_init(struct usb_interface *intf)
 359 {
 360         int i;
 361         int ret;
 362         struct usb_device *device = interface_to_usbdev(intf);
 363         /* buffer: 8 receiving bytes from device and
 364          * sizeof(EP_W_MAX_PACKET_SIZE) bytes for non-const copy */
 365         u8 buffer[12];
 366
 367         ret = usb6fire_fw_ezusb_read(device, 1, 0, buffer, 8);
 368         if (ret < 0) {
 369                 dev_err(&intf->dev,
 370                         "unable to receive device firmware state.\n");
 371                 return ret;
 372         }
 373         if (buffer[0] != 0xeb || buffer[1] != 0xaa || buffer[2] != 0x55) {
 374                 dev_err(&intf->dev,
 375                         "unknown device firmware state received from device:");
 376                 for (i = 0; i < 8; i++)
 377                         printk(KERN_CONT "%02x ", buffer[i]);
 378                 printk(KERN_CONT "\n");
 379                 return -EIO;
 380         }
 381         /* do we need fpga loader ezusb firmware? */
 382         if (buffer[3] == 0x01) {
 383                 ret = usb6fire_fw_ezusb_upload(intf,
 384                                 "/*(DEBLOBBED)*/", 0, NULL, 0);
 385                 if (ret < 0)
 386                         return ret;
 387                 return FW_NOT_READY;
 388         }
 389         /* do we need fpga firmware and application ezusb firmware? */
 390         else if (buffer[3] == 0x02) {
 391                 ret = usb6fire_fw_check(intf, buffer + 4);
 392                 if (ret < 0)
 393                         return ret;
 394                 ret = usb6fire_fw_fpga_upload(intf, "/*(DEBLOBBED)*/");
 395                 if (ret < 0)
 396                         return ret;
 397                 memcpy(buffer, ep_w_max_packet_size,
 398                                 sizeof(ep_w_max_packet_size));
 399                 ret = usb6fire_fw_ezusb_upload(intf, "/*(DEBLOBBED)*/",
 400                                 0x0003, buffer, sizeof(ep_w_max_packet_size));
 401                 if (ret < 0)
 402                         return ret;
 403                 return FW_NOT_READY;
 404         }
 405         /* all fw loaded? */
 406         else if (buffer[3] == 0x03)
 407                 return usb6fire_fw_check(intf, buffer + 4);
 408         /* unknown data? */
 409         else {
 410                 dev_err(&intf->dev,
 411                         "unknown device firmware state received from device: ");
 412                 for (i = 0; i < 8; i++)
 413                         printk(KERN_CONT "%02x ", buffer[i]);
 414                 printk(KERN_CONT "\n");
 415                 return -EIO;
 416         }
 417         return 0;
 418 }
 419