8859 if (whoami != 0xffffffff && whoami != X_CIM_PF_NOACCESS)
8860 return 0;
8861
8862 msleep(500);
8863 whoami = t4_read_reg(adapter, A_PL_WHOAMI);
8864 if (whoami != 0xffffffff && whoami != X_CIM_PF_NOACCESS)
8865 return 0;
8866
8867 CH_ERR(adapter, "Device didn't become ready for access, "
8868 "whoami = %#x\n", whoami);
8869 return -EIO;
8870 }
8871
8872 struct flash_desc {
8873 u32 vendor_and_model_id;
8874 u32 size_mb;
8875 };
8876
8877 int t4_get_flash_params(struct adapter *adapter)
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.
8882 */
8883 static struct flash_desc supported_flash[] = {
8884 { 0x00150201, 4 << 20 }, /* Spansion 4MB S25FL032P */
8885 };
8886
8887 int ret;
8888 u32 flashid = 0;
8889 unsigned int part, manufacturer;
8890 unsigned int density, size;
8891
8892
8893 /*
8894 * Issue a Read ID Command to the Flash part. We decode supported
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.
8898 */
8899 ret = sf1_write(adapter, 1, 1, 0, SF_RD_ID);
8900 if (!ret)
8901 ret = sf1_read(adapter, 3, 0, 1, &flashid);
8902 t4_write_reg(adapter, A_SF_OP, 0); /* unlock SF */
8903 if (ret < 0)
8904 return ret;
8905
8906 for (part = 0; part < ARRAY_SIZE(supported_flash); part++)
8907 if (supported_flash[part].vendor_and_model_id == flashid) {
8908 adapter->params.sf_size =
8909 supported_flash[part].size_mb;
8910 adapter->params.sf_nsec =
8911 adapter->params.sf_size / SF_SEC_SIZE;
8912 goto found;
8913 }
8914
8915 manufacturer = flashid & 0xff;
8916 switch (manufacturer) {
8917 case 0x20: { /* Micron/Numonix */
8918 /*
8919 * This Density -> Size decoding table is taken from Micron
8920 * Data Sheets.
8921 */
8922 density = (flashid >> 16) & 0xff;
8923 switch (density) {
8924 case 0x14: size = 1 << 20; break; /* 1MB */
8925 case 0x15: size = 1 << 21; break; /* 2MB */
8926 case 0x16: size = 1 << 22; break; /* 4MB */
8927 case 0x17: size = 1 << 23; break; /* 8MB */
8928 case 0x18: size = 1 << 24; break; /* 16MB */
8929 case 0x19: size = 1 << 25; break; /* 32MB */
8930 case 0x20: size = 1 << 26; break; /* 64MB */
8931 case 0x21: size = 1 << 27; break; /* 128MB */
8932 case 0x22: size = 1 << 28; break; /* 256MB */
8933
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;
8939 }
8940
8941 adapter->params.sf_size = size;
8942 adapter->params.sf_nsec = size / SF_SEC_SIZE;
8943 break;
8944 }
8945
8946 default:
8947 CH_ERR(adapter, "Unsupported Flash Part, ID = %#x\n", flashid);
8948 return -EINVAL;
8949 }
8950
8951 found:
8952 /*
8953 * We should ~probably~ reject adapters with FLASHes which are too
8954 * small but we have some legacy FPGAs with small FLASHes that we'd
8955 * still like to use. So instead we emit a scary message ...
8956 */
8957 if (adapter->params.sf_size < FLASH_MIN_SIZE)
8958 CH_WARN(adapter, "WARNING: Flash Part ID %#x, size %#x < %#x\n",
8959 flashid, adapter->params.sf_size, FLASH_MIN_SIZE);
8960
8961 return 0;
8962 }
8963
8964 static void set_pcie_completion_timeout(struct adapter *adapter,
8965 u8 range)
8966 {
8967 u16 val;
8968 u32 pcie_cap;
8969
8970 pcie_cap = t4_os_find_pci_capability(adapter, PCI_CAP_ID_EXP);
|
8859 if (whoami != 0xffffffff && whoami != X_CIM_PF_NOACCESS)
8860 return 0;
8861
8862 msleep(500);
8863 whoami = t4_read_reg(adapter, A_PL_WHOAMI);
8864 if (whoami != 0xffffffff && whoami != X_CIM_PF_NOACCESS)
8865 return 0;
8866
8867 CH_ERR(adapter, "Device didn't become ready for access, "
8868 "whoami = %#x\n", whoami);
8869 return -EIO;
8870 }
8871
8872 struct flash_desc {
8873 u32 vendor_and_model_id;
8874 u32 size_mb;
8875 };
8876
8877 int t4_get_flash_params(struct adapter *adapter)
8878 {
8879 /*
8880 * Table for non-standard supported Flash parts. Note, all Flash
8881 * parts must have 64KB sectors.
8882 */
8883 static struct flash_desc supported_flash[] = {
8884 { 0x00150201, 4 << 20 }, /* Spansion 4MB S25FL032P */
8885 };
8886
8887 int ret;
8888 u32 flashid = 0;
8889 unsigned int part, manufacturer;
8890 unsigned int density, size = 0;
8891
8892
8893 /*
8894 * Issue a Read ID Command to the Flash part. We decode supported
8895 * Flash parts and their sizes from this. There's a newer Query
8896 * Command which can retrieve detailed geometry information but many
8897 * Flash parts don't support it.
8898 */
8899 ret = sf1_write(adapter, 1, 1, 0, SF_RD_ID);
8900 if (!ret)
8901 ret = sf1_read(adapter, 3, 0, 1, &flashid);
8902 t4_write_reg(adapter, A_SF_OP, 0); /* unlock SF */
8903 if (ret < 0)
8904 return ret;
8905
8906 /*
8907 * Check to see if it's one of our non-standard supported Flash parts.
8908 */
8909 for (part = 0; part < ARRAY_SIZE(supported_flash); part++)
8910 if (supported_flash[part].vendor_and_model_id == flashid) {
8911 adapter->params.sf_size =
8912 supported_flash[part].size_mb;
8913 adapter->params.sf_nsec =
8914 adapter->params.sf_size / SF_SEC_SIZE;
8915 goto found;
8916 }
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 */
8927 manufacturer = flashid & 0xff;
8928 switch (manufacturer) {
8929 case 0x20: { /* Micron/Numonix */
8930 /*
8931 * This Density -> Size decoding table is taken from Micron
8932 * Data Sheets.
8933 */
8934 density = (flashid >> 16) & 0xff;
8935 switch (density) {
8936 case 0x14: size = 1 << 20; break; /* 1MB */
8937 case 0x15: size = 1 << 21; break; /* 2MB */
8938 case 0x16: size = 1 << 22; break; /* 4MB */
8939 case 0x17: size = 1 << 23; break; /* 8MB */
8940 case 0x18: size = 1 << 24; break; /* 16MB */
8941 case 0x19: size = 1 << 25; break; /* 32MB */
8942 case 0x20: size = 1 << 26; break; /* 64MB */
8943 case 0x21: size = 1 << 27; break; /* 128MB */
8944 case 0x22: size = 1 << 28; break; /* 256MB */
8945 }
8946 break;
8947 }
8948
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 */
8958 }
8959 break;
8960 }
8961
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 }
8972 break;
8973 }
8974
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;
8986 }
8987 }
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
9007 found:
9008 /*
9009 * We should ~probably~ reject adapters with FLASHes which are too
9010 * small but we have some legacy FPGAs with small FLASHes that we'd
9011 * still like to use. So instead we emit a scary message ...
9012 */
9013 if (adapter->params.sf_size < FLASH_MIN_SIZE)
9014 CH_WARN(adapter, "WARNING: Flash Part ID %#x, size %#x < %#x\n",
9015 flashid, adapter->params.sf_size, FLASH_MIN_SIZE);
9016
9017 return 0;
9018 }
9019
9020 static void set_pcie_completion_timeout(struct adapter *adapter,
9021 u8 range)
9022 {
9023 u16 val;
9024 u32 pcie_cap;
9025
9026 pcie_cap = t4_os_find_pci_capability(adapter, PCI_CAP_ID_EXP);
|