1 /*
2  * Copyright 2014 Red Hat Inc.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice shall be included in
12  * all copies or substantial portions of the Software.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20  * OTHER DEALINGS IN THE SOFTWARE.
21  *
22  * Authors: Ben Skeggs <bskeggs@redhat.com>
23  */
24 #include "priv.h"
25 
26 #include <core/option.h>
27 #include <subdev/bios.h>
28 #include <subdev/bios/image.h>
29 
30 struct shadow {
31 	u32 skip;
32 	const struct nvbios_source *func;
33 	void *data;
34 	u32 size;
35 	int score;
36 };
37 
38 static bool
39 shadow_fetch(struct nvkm_bios *bios, struct shadow *mthd, u32 upto)
40 {
41 	const u32 limit = (upto + 3) & ~3;
42 	const u32 start = bios->size;
43 	void *data = mthd->data;
44 	if (nvbios_extend(bios, limit) > 0) {
45 		u32 read = mthd->func->read(data, start, limit - start, bios);
46 		bios->size = start + read;
47 	}
48 	return bios->size >= upto;
49 }
50 
51 static int
52 shadow_image(struct nvkm_bios *bios, int idx, u32 offset, struct shadow *mthd)
53 {
54 	struct nvkm_subdev *subdev = &bios->subdev;
55 	struct nvbios_image image;
56 	int score = 1;
57 
58 	if (mthd->func->no_pcir) {
59 		image.base = 0;
60 		image.type = 0;
61 		image.size = mthd->func->size(mthd->data);
62 		image.last = 1;
63 	} else {
64 		if (!shadow_fetch(bios, mthd, offset + 0x1000)) {
65 			nvkm_debug(subdev, "%08x: header fetch failed\n",
66 				   offset);
67 			return 0;
68 		}
69 
70 		if (!nvbios_image(bios, idx, &image)) {
71 			nvkm_debug(subdev, "image %d invalid\n", idx);
72 			return 0;
73 		}
74 	}
75 	nvkm_debug(subdev, "%08x: type %02x, %d bytes\n",
76 		   image.base, image.type, image.size);
77 
78 	if (!shadow_fetch(bios, mthd, image.base + image.size)) {
79 		nvkm_debug(subdev, "%08x: fetch failed\n", image.base);
80 		return 0;
81 	}
82 
83 	switch (image.type) {
84 	case 0x00:
85 		if (!mthd->func->ignore_checksum &&
86 		    nvbios_checksum(&bios->data[image.base], image.size)) {
87 			nvkm_debug(subdev, "%08x: checksum failed\n",
88 				   image.base);
89 			if (!mthd->func->require_checksum) {
90 				if (mthd->func->rw)
91 					score += 1;
92 				score += 1;
93 			} else
94 				return 0;
95 		} else {
96 			score += 3;
97 		}
98 		break;
99 	default:
100 		score += 3;
101 		break;
102 	}
103 
104 	if (!image.last)
105 		score += shadow_image(bios, idx + 1, offset + image.size, mthd);
106 	return score;
107 }
108 
109 static int
110 shadow_method(struct nvkm_bios *bios, struct shadow *mthd, const char *name)
111 {
112 	const struct nvbios_source *func = mthd->func;
113 	struct nvkm_subdev *subdev = &bios->subdev;
114 	if (func->name) {
115 		nvkm_debug(subdev, "trying %s...\n", name ? name : func->name);
116 		if (func->init) {
117 			mthd->data = func->init(bios, name);
118 			if (IS_ERR(mthd->data)) {
119 				mthd->data = NULL;
120 				return 0;
121 			}
122 		}
123 		mthd->score = shadow_image(bios, 0, 0, mthd);
124 		if (func->fini)
125 			func->fini(mthd->data);
126 		nvkm_debug(subdev, "scored %d\n", mthd->score);
127 		mthd->data = bios->data;
128 		mthd->size = bios->size;
129 		bios->data  = NULL;
130 		bios->size  = 0;
131 	}
132 	return mthd->score;
133 }
134 
135 static u32
136 shadow_fw_read(void *data, u32 offset, u32 length, struct nvkm_bios *bios)
137 {
138 	const struct firmware *fw = data;
139 	if (offset + length <= fw->size) {
140 		memcpy(bios->data + offset, fw->data + offset, length);
141 		return length;
142 	}
143 	return 0;
144 }
145 
146 static void *
147 shadow_fw_init(struct nvkm_bios *bios, const char *name)
148 {
149 	struct device *dev = bios->subdev.device->dev;
150 	const struct firmware *fw;
151 	int ret = request_firmware(&fw, name, dev);
152 	if (ret)
153 		return ERR_PTR(-ENOENT);
154 	return (void *)fw;
155 }
156 
157 static void
158 shadow_fw_release(void *fw)
159 {
160 	release_firmware(fw);
161 }
162 
163 static const struct nvbios_source
164 shadow_fw = {
165 	.name = "firmware",
166 	.init = shadow_fw_init,
167 	.fini = shadow_fw_release,
168 	.read = shadow_fw_read,
169 	.rw = false,
170 };
171 
172 int
173 nvbios_shadow(struct nvkm_bios *bios)
174 {
175 	struct nvkm_subdev *subdev = &bios->subdev;
176 	struct nvkm_device *device = subdev->device;
177 	struct shadow mthds[] = {
178 		{ 0, &nvbios_of },
179 		{ 0, &nvbios_ramin },
180 		{ 0, &nvbios_prom },
181 		{ 0, &nvbios_acpi_fast },
182 		{ 4, &nvbios_acpi_slow },
183 		{ 1, &nvbios_pcirom },
184 		{ 1, &nvbios_platform },
185 		{}
186 	}, *mthd, *best = NULL;
187 	const char *optarg;
188 	char *source;
189 	int optlen;
190 
191 	/* handle user-specified bios source */
192 	optarg = nvkm_stropt(device->cfgopt, "NvBios", &optlen);
193 	source = optarg ? kstrndup(optarg, optlen, GFP_KERNEL) : NULL;
194 	if (source) {
195 		/* try to match one of the built-in methods */
196 		for (mthd = mthds; mthd->func; mthd++) {
197 			if (mthd->func->name &&
198 			    !strcasecmp(source, mthd->func->name)) {
199 				best = mthd;
200 				if (shadow_method(bios, mthd, NULL))
201 					break;
202 			}
203 		}
204 
205 		/* otherwise, attempt to load as firmware */
206 		if (!best && (best = mthd)) {
207 			mthd->func = &shadow_fw;
208 			shadow_method(bios, mthd, source);
209 			mthd->func = NULL;
210 		}
211 
212 		if (!best->score) {
213 			nvkm_error(subdev, "%s invalid\n", source);
214 			kfree(source);
215 			source = NULL;
216 		}
217 	}
218 
219 	/* scan all potential bios sources, looking for best image */
220 	if (!best || !best->score) {
221 		for (mthd = mthds, best = mthd; mthd->func; mthd++) {
222 			if (!mthd->skip || best->score < mthd->skip) {
223 				if (shadow_method(bios, mthd, NULL)) {
224 					if (mthd->score > best->score)
225 						best = mthd;
226 				}
227 			}
228 		}
229 	}
230 
231 	/* cleanup the ones we didn't use */
232 	for (mthd = mthds; mthd->func; mthd++) {
233 		if (mthd != best)
234 			kfree(mthd->data);
235 	}
236 
237 	if (!best->score) {
238 		nvkm_error(subdev, "unable to locate usable image\n");
239 		return -EINVAL;
240 	}
241 
242 	nvkm_debug(subdev, "using image from %s\n", best->func ?
243 		   best->func->name : source);
244 	bios->data = best->data;
245 	bios->size = best->size;
246 	kfree(source);
247 	return 0;
248 }
249