isci: Added support for C0 to SCU Driver
[linux-2.6.git] / drivers / scsi / isci / probe_roms.c
1 /*
2  * This file is provided under a dual BSD/GPLv2 license.  When using or
3  * redistributing this file, you may do so under either license.
4  *
5  * GPL LICENSE SUMMARY
6  *
7  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of version 2 of the GNU General Public License as
11  * published by the Free Software Foundation.
12  *
13  * This program is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21  * The full GNU General Public License is included in this distribution
22  * in the file called LICENSE.GPL.
23  */
24
25 /* probe_roms - scan for oem parameters */
26
27 #include <linux/kernel.h>
28 #include <linux/firmware.h>
29 #include <linux/uaccess.h>
30 #include <linux/efi.h>
31 #include <asm/probe_roms.h>
32
33 #include "isci.h"
34 #include "task.h"
35 #include "probe_roms.h"
36
37 static efi_char16_t isci_efivar_name[] =
38                         {'R', 's', 't', 'S', 'c', 'u', 'O'};
39
40 struct isci_orom *isci_request_oprom(struct pci_dev *pdev)
41 {
42         void __iomem *oprom = pci_map_biosrom(pdev);
43         struct isci_orom *rom = NULL;
44         size_t len, i;
45         int j;
46         char oem_sig[4];
47         struct isci_oem_hdr oem_hdr;
48         u8 *tmp, sum;
49
50         if (!oprom)
51                 return NULL;
52
53         len = pci_biosrom_size(pdev);
54         rom = devm_kzalloc(&pdev->dev, sizeof(*rom), GFP_KERNEL);
55         if (!rom) {
56                 dev_warn(&pdev->dev,
57                          "Unable to allocate memory for orom\n");
58                 return NULL;
59         }
60
61         for (i = 0; i < len && rom; i += ISCI_OEM_SIG_SIZE) {
62                 memcpy_fromio(oem_sig, oprom + i, ISCI_OEM_SIG_SIZE);
63
64                 /* we think we found the OEM table */
65                 if (memcmp(oem_sig, ISCI_OEM_SIG, ISCI_OEM_SIG_SIZE) == 0) {
66                         size_t copy_len;
67
68                         memcpy_fromio(&oem_hdr, oprom + i, sizeof(oem_hdr));
69
70                         copy_len = min(oem_hdr.len - sizeof(oem_hdr),
71                                        sizeof(*rom));
72
73                         memcpy_fromio(rom,
74                                       oprom + i + sizeof(oem_hdr),
75                                       copy_len);
76
77                         /* calculate checksum */
78                         tmp = (u8 *)&oem_hdr;
79                         for (j = 0, sum = 0; j < sizeof(oem_hdr); j++, tmp++)
80                                 sum += *tmp;
81
82                         tmp = (u8 *)rom;
83                         for (j = 0; j < sizeof(*rom); j++, tmp++)
84                                 sum += *tmp;
85
86                         if (sum != 0) {
87                                 dev_warn(&pdev->dev,
88                                          "OEM table checksum failed\n");
89                                 continue;
90                         }
91
92                         /* keep going if that's not the oem param table */
93                         if (memcmp(rom->hdr.signature,
94                                    ISCI_ROM_SIG,
95                                    ISCI_ROM_SIG_SIZE) != 0)
96                                 continue;
97
98                         dev_info(&pdev->dev,
99                                  "OEM parameter table found in OROM\n");
100                         break;
101                 }
102         }
103
104         if (i >= len) {
105                 dev_err(&pdev->dev, "oprom parse error\n");
106                 devm_kfree(&pdev->dev, rom);
107                 rom = NULL;
108         }
109         pci_unmap_biosrom(oprom);
110
111         return rom;
112 }
113
114 /**
115  * isci_parse_oem_parameters() - This method will take OEM parameters
116  *    from the module init parameters and copy them to oem_params. This will
117  *    only copy values that are not set to the module parameter default values
118  * @oem_parameters: This parameter specifies the controller default OEM
119  *    parameters. It is expected that this has been initialized to the default
120  *    parameters for the controller
121  *
122  *
123  */
124 enum sci_status isci_parse_oem_parameters(union scic_oem_parameters *oem_params,
125                                           struct isci_orom *orom, int scu_index)
126 {
127         /* check for valid inputs */
128         if (scu_index < 0 || scu_index > SCI_MAX_CONTROLLERS ||
129             scu_index > orom->hdr.num_elements || !oem_params)
130                 return -EINVAL;
131
132         oem_params->sds1 = orom->ctrl[scu_index];
133         return 0;
134 }
135
136 struct isci_orom *isci_request_firmware(struct pci_dev *pdev, const struct firmware *fw)
137 {
138         struct isci_orom *orom = NULL, *data;
139         int i, j;
140
141         if (request_firmware(&fw, ISCI_FW_NAME, &pdev->dev) != 0)
142                 return NULL;
143
144         if (fw->size < sizeof(*orom))
145                 goto out;
146
147         data = (struct isci_orom *)fw->data;
148
149         if (strncmp(ISCI_ROM_SIG, data->hdr.signature,
150                     strlen(ISCI_ROM_SIG)) != 0)
151                 goto out;
152
153         orom = devm_kzalloc(&pdev->dev, fw->size, GFP_KERNEL);
154         if (!orom)
155                 goto out;
156
157         memcpy(orom, fw->data, fw->size);
158
159         /*
160          * deprecated: override default amp_control for pre-preproduction
161          * silicon revisions
162          */
163         if (isci_si_rev <= ISCI_SI_REVB0)
164                 goto out;
165
166         for (i = 0; i < ARRAY_SIZE(orom->ctrl); i++)
167                 for (j = 0; j < ARRAY_SIZE(orom->ctrl[i].phys); j++) {
168                         orom->ctrl[i].phys[j].afe_tx_amp_control0 = 0xe7c03;
169                         orom->ctrl[i].phys[j].afe_tx_amp_control1 = 0xe7c03;
170                         orom->ctrl[i].phys[j].afe_tx_amp_control2 = 0xe7c03;
171                         orom->ctrl[i].phys[j].afe_tx_amp_control3 = 0xe7c03;
172                 }
173  out:
174         release_firmware(fw);
175
176         return orom;
177 }
178
179 static struct efi *get_efi(void)
180 {
181 #ifdef CONFIG_EFI
182         return &efi;
183 #else
184         return NULL;
185 #endif
186 }
187
188 struct isci_orom *isci_get_efi_var(struct pci_dev *pdev)
189 {
190         efi_status_t status;
191         struct isci_orom *rom;
192         struct isci_oem_hdr *oem_hdr;
193         u8 *tmp, sum;
194         int j;
195         ssize_t data_len;
196         u8 *efi_data;
197         u32 efi_attrib = 0;
198
199         data_len = 1024;
200         efi_data = devm_kzalloc(&pdev->dev, data_len, GFP_KERNEL);
201         if (!efi_data) {
202                 dev_warn(&pdev->dev,
203                          "Unable to allocate memory for EFI data\n");
204                 return NULL;
205         }
206
207         rom = (struct isci_orom *)(efi_data + sizeof(struct isci_oem_hdr));
208
209         if (get_efi())
210                 status = get_efi()->get_variable(isci_efivar_name,
211                                                  &ISCI_EFI_VENDOR_GUID,
212                                                  &efi_attrib,
213                                                  &data_len,
214                                                  efi_data);
215         else
216                 status = EFI_NOT_FOUND;
217
218         if (status != EFI_SUCCESS) {
219                 dev_warn(&pdev->dev,
220                          "Unable to obtain EFI var data for OEM parms\n");
221                 return NULL;
222         }
223
224         oem_hdr = (struct isci_oem_hdr *)efi_data;
225
226         if (memcmp(oem_hdr->sig, ISCI_OEM_SIG, ISCI_OEM_SIG_SIZE) != 0) {
227                 dev_warn(&pdev->dev,
228                          "Invalid OEM header signature\n");
229                 return NULL;
230         }
231
232         /* calculate checksum */
233         tmp = (u8 *)efi_data;
234         for (j = 0, sum = 0; j < (sizeof(*oem_hdr) + sizeof(*rom)); j++, tmp++)
235                 sum += *tmp;
236
237         if (sum != 0) {
238                 dev_warn(&pdev->dev,
239                          "OEM table checksum failed\n");
240                 return NULL;
241         }
242
243         if (memcmp(rom->hdr.signature,
244                    ISCI_ROM_SIG,
245                    ISCI_ROM_SIG_SIZE) != 0) {
246                 dev_warn(&pdev->dev,
247                          "Invalid OEM table signature\n");
248                 return NULL;
249         }
250
251         return rom;
252 }