Print this page 
9658 Update cxgbe to deal with newer flash modules
Reviewed by: Robert Mustacchi <rm@joyent.com>
Reviewed by: Toomas Soome <tsoome@me.com>
Approved by: Dan McDonald <danmcd@joyent.com>
Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/io/cxgbe/common/t4_hw.c
          +++ new/usr/src/uts/common/io/cxgbe/common/t4_hw.c
↓ open down ↓ 8868 lines elided ↑ open up ↑ 
8869 8869          return -EIO;
8870 8870  }
8871 8871  
8872 8872  struct flash_desc {
8873 8873          u32 vendor_and_model_id;
8874 8874          u32 size_mb;
8875 8875  };
8876 8876  
8877 8877  int t4_get_flash_params(struct adapter *adapter)
8878 8878  {
8879      -        /* Table for non-Numonix supported flash parts.  Numonix parts are left
8880      -         * to the preexisting well-tested code.  All flash parts have 64KB
8881      -         * sectors.
     8879 +        /*
     8880 +         * Table for non-standard supported Flash parts.  Note, all Flash
     8881 +         * parts must have 64KB sectors.
8882 8882           */
8883 8883          static struct flash_desc supported_flash[] = {
8884 8884                  { 0x00150201, 4 << 20 },        /* Spansion 4MB S25FL032P */
8885 8885          };
8886 8886  
8887 8887          int ret;
8888 8888          u32 flashid = 0;
8889 8889          unsigned int part, manufacturer;
8890      -        unsigned int density, size;
     8890 +        unsigned int density, size = 0;
8891 8891  
8892 8892  
8893 8893          /*
8894 8894           * Issue a Read ID Command to the Flash part.  We decode supported
8895 8895           * Flash parts and their sizes from this.  There's a newer Query
8896      -         * Command which can retrieve detailed geometry information but
8897      -         * many Flash parts don't support it.
     8896 +         * Command which can retrieve detailed geometry information but many
     8897 +         * Flash parts don't support it.
8898 8898           */
8899 8899          ret = sf1_write(adapter, 1, 1, 0, SF_RD_ID);
8900 8900          if (!ret)
8901 8901                  ret = sf1_read(adapter, 3, 0, 1, &flashid);
8902 8902          t4_write_reg(adapter, A_SF_OP, 0);      /* unlock SF */
8903 8903          if (ret < 0)
8904 8904                  return ret;
8905 8905  
     8906 +        /*
     8907 +         * Check to see if it's one of our non-standard supported Flash parts.
     8908 +         */
8906 8909          for (part = 0; part < ARRAY_SIZE(supported_flash); part++)
8907 8910                  if (supported_flash[part].vendor_and_model_id == flashid) {
8908 8911                          adapter->params.sf_size =
8909 8912                                  supported_flash[part].size_mb;
8910 8913                          adapter->params.sf_nsec =
8911 8914                                  adapter->params.sf_size / SF_SEC_SIZE;
8912 8915                          goto found;
8913 8916                  }
8914 8917  
     8918 +        /*
     8919 +         * Decode Flash part size.  The code below looks repetitive with
     8920 +         * common encodings, but that's not guaranteed in the JEDEC
     8921 +         * specification for the Read JEDEC ID command.  The only thing that
     8922 +         * we're guaranteed by the JEDEC specification is where the
     8923 +         * Manufacturer ID is in the returned result.  After that each
     8924 +         * Manufacturer ~could~ encode things completely differently.
     8925 +         * Note, all Flash parts must have 64KB sectors.
     8926 +         */
8915 8927          manufacturer = flashid & 0xff;
8916 8928          switch (manufacturer) {
8917 8929          case 0x20: { /* Micron/Numonix */
8918 8930                  /*
8919 8931                   * This Density -> Size decoding table is taken from Micron
8920 8932                   * Data Sheets.
8921 8933                   */
8922 8934                  density = (flashid >> 16) & 0xff;
8923 8935                  switch (density) {
8924 8936                  case 0x14: size = 1 << 20; break; /*   1MB */
8925 8937                  case 0x15: size = 1 << 21; break; /*   2MB */
8926 8938                  case 0x16: size = 1 << 22; break; /*   4MB */
8927 8939                  case 0x17: size = 1 << 23; break; /*   8MB */
8928 8940                  case 0x18: size = 1 << 24; break; /*  16MB */
8929 8941                  case 0x19: size = 1 << 25; break; /*  32MB */
8930 8942                  case 0x20: size = 1 << 26; break; /*  64MB */
8931 8943                  case 0x21: size = 1 << 27; break; /* 128MB */
8932 8944                  case 0x22: size = 1 << 28; break; /* 256MB */
     8945 +                }
     8946 +                break;
     8947 +        }
8933 8948  
8934      -                default:
8935      -                        CH_ERR(adapter, "Micron Flash Part has bad size, "
8936      -                               "ID = %#x, Density code = %#x\n",
8937      -                               flashid, density);
8938      -                        return -EINVAL;
     8949 +        case 0x9d: { /* ISSI -- Integrated Silicon Solution, Inc. */
     8950 +                /*
     8951 +                 * This Density -> Size decoding table is taken from ISSI
     8952 +                 * Data Sheets.
     8953 +                 */
     8954 +                density = (flashid >> 16) & 0xff;
     8955 +                switch (density) {
     8956 +                case 0x16: size = 1 << 25; break; /*  32MB */
     8957 +                case 0x17: size = 1 << 26; break; /*  64MB */
8939 8958                  }
     8959 +                break;
     8960 +        }
8940 8961  
8941      -                adapter->params.sf_size = size;
8942      -                adapter->params.sf_nsec = size / SF_SEC_SIZE;
     8962 +        case 0xc2: { /* Macronix */
     8963 +                /*
     8964 +                 * This Density -> Size decoding table is taken from Macronix
     8965 +                 * Data Sheets.
     8966 +                 */
     8967 +                density = (flashid >> 16) & 0xff;
     8968 +                switch (density) {
     8969 +                case 0x17: size = 1 << 23; break; /*   8MB */
     8970 +                case 0x18: size = 1 << 24; break; /*  16MB */
     8971 +                }
8943 8972                  break;
8944 8973          }
8945 8974  
8946      -        default:
8947      -                CH_ERR(adapter, "Unsupported Flash Part, ID = %#x\n", flashid);
8948      -                return -EINVAL;
     8975 +        case 0xef: { /* Winbond */
     8976 +                /*
     8977 +                 * This Density -> Size decoding table is taken from Winbond
     8978 +                 * Data Sheets.
     8979 +                 */
     8980 +                density = (flashid >> 16) & 0xff;
     8981 +                switch (density) {
     8982 +                case 0x17: size = 1 << 23; break; /*   8MB */
     8983 +                case 0x18: size = 1 << 24; break; /*  16MB */
     8984 +                }
     8985 +                break;
8949 8986          }
     8987 +        }
8950 8988  
     8989 +        /*
     8990 +         * If we didn't recognize the FLASH part, that's no real issue: the
     8991 +         * Hardware/Software contract says that Hardware will _*ALWAYS*_
     8992 +         * use a FLASH part which is at least 4MB in size and has 64KB
     8993 +         * sectors.  The unrecognized FLASH part is likely to be much larger
     8994 +         * than 4MB, but that's all we really need.
     8995 +         */
     8996 +        if (size == 0) {
     8997 +                CH_WARN(adapter, "Unknown Flash Part, ID = %#x, assuming 4MB\n", flashid);
     8998 +                size = 1 << 22;
     8999 +        }
     9000 +
     9001 +        /*
     9002 +         * Store decoded Flash size and fall through into vetting code.
     9003 +         */
     9004 +        adapter->params.sf_size = size;
     9005 +        adapter->params.sf_nsec = size / SF_SEC_SIZE;
     9006 +
8951 9007   found:
8952 9008          /*
8953 9009           * We should ~probably~ reject adapters with FLASHes which are too
8954 9010           * small but we have some legacy FPGAs with small FLASHes that we'd
8955 9011           * still like to use.  So instead we emit a scary message ...
8956 9012           */
8957 9013          if (adapter->params.sf_size < FLASH_MIN_SIZE)
8958 9014                  CH_WARN(adapter, "WARNING: Flash Part ID %#x, size %#x < %#x\n",
8959 9015                          flashid, adapter->params.sf_size, FLASH_MIN_SIZE);
8960 9016
↓ open down ↓ 2110 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX