drivers/scsi/isci/firmware/create_fw.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <sys/types.h>
   5 #include <sys/stat.h>
   6 #include <fcntl.h>
   7 #include <string.h>
   8 #include <errno.h>
   9
  10 char blob_name[] = "isci_firmware.bin";
  11 char id[] = "#SCU MAGIC#";
  12 unsigned char version = 1;
  13 unsigned char sub_version = 0;
  14
  15
  16 /*
  17  * For all defined arrays:
  18  * elements 0-3 are for SCU0, ports 0-3
  19  * elements 4-7 are for SCU1, ports 0-3
  20  *
  21  * valid configurations for one SCU are:
  22  *  P0  P1  P2  P3
  23  * ----------------
  24  * 0xF,0x0,0x0,0x0 # 1 x4 port
  25  * 0x3,0x0,0x4,0x8 # Phys 0 and 1 are a x2 port, phy 2 and phy 3 are each x1
  26  *                 # ports
  27  * 0x1,0x2,0xC,0x0 # Phys 0 and 1 are each x1 ports, phy 2 and phy 3 are a x2
  28  *                 # port
  29  * 0x3,0x0,0xC,0x0 # Phys 0 and 1 are a x2 port, phy 2 and phy 3 are a x2 port
  30  * 0x1,0x2,0x4,0x8 # Each phy is a x1 port (this is the default configuration)
  31  *
  32  * if there is a port/phy on which you do not wish to override the default
  33  * values, use the value assigned to UNINIT_PARAM (255).
  34  */
  35 unsigned int phy_mask[] = { 1, 2, 4, 8, 1, 2, 4, 8 };
  36
  37
  38 /* denotes SAS generation. i.e. 3: SAS Gen 3 6G */
  39 unsigned int phy_gen[] = { 3, 3, 3, 3, 3, 3, 3, 3 };
  40
  41 /*
  42  * if there is a port/phy on which you do not wish to override the default
  43  * values, use the value "0000000000000000". SAS address of zero's is
  44  * considered invalid and will not be used.
  45  */
  46 unsigned long long sas_addr[] = { 0x5FCFFFFFF0000000ULL,
  47                                   0x5FCFFFFFF1000000ULL,
  48                                   0x5FCFFFFFF2000000ULL,
  49                                   0x5FCFFFFFF3000000ULL,
  50                                   0x5FCFFFFFF4000000ULL,
  51                                   0x5FCFFFFFF5000000ULL,
  52                                   0x5FCFFFFFF6000000ULL,
  53                                   0x5FCFFFFFF7000000ULL };
  54
  55 int write_blob(void)
  56 {
  57         FILE *fd;
  58         int err;
  59
  60         fd = fopen(blob_name, "w+");
  61         if (!fd) {
  62                 perror("Open file for write failed");
  63                 return -EIO;
  64         }
  65
  66         /* write id */
  67         err = fwrite((void *)id, sizeof(char), strlen(id)+1, fd);
  68         if (err == 0) {
  69                 perror("write id failed");
  70                 return err;
  71         }
  72
  73         /* write version */
  74         err = fwrite((void *)&version, sizeof(version), 1, fd);
  75         if (err == 0) {
  76                 perror("write version failed");
  77                 return err;
  78         }
  79
  80         /* write sub version */
  81         err = fwrite((void *)&sub_version, sizeof(sub_version), 1, fd);
  82         if (err == 0) {
  83                 perror("write subversion failed");
  84                 return err;
  85         }
  86
  87         /* write phy mask header */
  88         err = fputc(0x1, fd);
  89         if (err == EOF) {
  90                 perror("write phy mask header failed");
  91                 return -EIO;
  92         }
  93
  94         /* write size */
  95         err = fputc(8, fd);
  96         if (err == EOF) {
  97                 perror("write phy mask size failed");
  98                 return -EIO;
  99         }
 100
 101         /* write phy masks */
 102         err = fwrite((void *)phy_mask, 1, sizeof(phy_mask), fd);
 103         if (err == 0) {
 104                 perror("write phy_mask failed");
 105                 return err;
 106         }
 107
 108         /* write phy gen header */
 109         err = fputc(0x2, fd);
 110         if (err == EOF) {
 111                 perror("write phy gen header failed");
 112                 return -EIO;
 113         }
 114
 115         /* write size */
 116         err = fputc(8, fd);
 117         if (err == EOF) {
 118                 perror("write phy gen size failed");
 119                 return -EIO;
 120         }
 121
 122         /* write phy_gen */
 123         err = fwrite((void *)phy_gen,
 124                      1,
 125                      sizeof(phy_gen),
 126                      fd);
 127         if (err == 0) {
 128                 perror("write phy_gen failed");
 129                 return err;
 130         }
 131
 132         /* write phy gen header */
 133         err = fputc(0x3, fd);
 134         if (err == EOF) {
 135                 perror("write sas addr header failed");
 136                 return -EIO;
 137         }
 138
 139         /* write size */
 140         err = fputc(8, fd);
 141         if (err == EOF) {
 142                 perror("write sas addr size failed");
 143                 return -EIO;
 144         }
 145
 146         /* write sas_addr */
 147         err = fwrite((void *)sas_addr,
 148                      1,
 149                      sizeof(sas_addr),
 150                      fd);
 151         if (err == 0) {
 152                 perror("write sas_addr failed");
 153                 return err;
 154         }
 155
 156         /* write end header */
 157         err = fputc(0xff, fd);
 158         if (err == EOF) {
 159                 perror("write end header failed");
 160                 return -EIO;
 161         }
 162
 163         fclose(fd);
 164
 165         return 0;
 166 }
 167
 168 int main(void)
 169 {
 170         int err;
 171
 172         err = write_blob();
 173         if (err < 0)
 174                 return err;
 175
 176         return 0;
 177 }