1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Compaq Hot Plug Controller Driver
4  *
5  * Copyright (C) 1995,2001 Compaq Computer Corporation
6  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
7  * Copyright (C) 2001 IBM Corp.
8  *
9  * All rights reserved.
10  *
11  * Send feedback to <greg@kroah.com>
12  *
13  */
14 
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/types.h>
18 #include <linux/proc_fs.h>
19 #include <linux/slab.h>
20 #include <linux/workqueue.h>
21 #include <linux/pci.h>
22 #include <linux/pci_hotplug.h>
23 #include <linux/uaccess.h>
24 #include "cpqphp.h"
25 #include "cpqphp_nvram.h"
26 
27 
28 #define ROM_INT15_PHY_ADDR		0x0FF859
29 #define READ_EV				0xD8A4
30 #define WRITE_EV			0xD8A5
31 
32 struct register_foo {
33 	union {
34 		unsigned long lword;		/* eax */
35 		unsigned short word;		/* ax */
36 
37 		struct {
38 			unsigned char low;	/* al */
39 			unsigned char high;	/* ah */
40 		} byte;
41 	} data;
42 
43 	unsigned char opcode;	/* see below */
44 	unsigned long length;	/* if the reg. is a pointer, how much data */
45 } __attribute__ ((packed));
46 
47 struct all_reg {
48 	struct register_foo eax_reg;
49 	struct register_foo ebx_reg;
50 	struct register_foo ecx_reg;
51 	struct register_foo edx_reg;
52 	struct register_foo edi_reg;
53 	struct register_foo esi_reg;
54 	struct register_foo eflags_reg;
55 } __attribute__ ((packed));
56 
57 
58 struct ev_hrt_header {
59 	u8 Version;
60 	u8 num_of_ctrl;
61 	u8 next;
62 };
63 
64 struct ev_hrt_ctrl {
65 	u8 bus;
66 	u8 device;
67 	u8 function;
68 	u8 mem_avail;
69 	u8 p_mem_avail;
70 	u8 io_avail;
71 	u8 bus_avail;
72 	u8 next;
73 };
74 
75 
76 static u8 evbuffer_init;
77 static u8 evbuffer_length;
78 static u8 evbuffer[1024];
79 
80 static void __iomem *compaq_int15_entry_point;
81 
82 /* lock for ordering int15_bios_call() */
83 static DEFINE_SPINLOCK(int15_lock);
84 
85 
86 /* This is a series of function that deals with
87  * setting & getting the hotplug resource table in some environment variable.
88  */
89 
90 /*
91  * We really shouldn't be doing this unless there is a _very_ good reason to!!!
92  * greg k-h
93  */
94 
95 
96 static u32 add_byte(u32 **p_buffer, u8 value, u32 *used, u32 *avail)
97 {
98 	u8 **tByte;
99 
100 	if ((*used + 1) > *avail)
101 		return(1);
102 
103 	*((u8 *)*p_buffer) = value;
104 	tByte = (u8 **)p_buffer;
105 	(*tByte)++;
106 	*used += 1;
107 	return(0);
108 }
109 
110 
111 static u32 add_dword(u32 **p_buffer, u32 value, u32 *used, u32 *avail)
112 {
113 	if ((*used + 4) > *avail)
114 		return(1);
115 
116 	**p_buffer = value;
117 	(*p_buffer)++;
118 	*used += 4;
119 	return(0);
120 }
121 
122 
123 /*
124  * check_for_compaq_ROM
125  *
126  * this routine verifies that the ROM OEM string is 'COMPAQ'
127  *
128  * returns 0 for non-Compaq ROM, 1 for Compaq ROM
129  */
130 static int check_for_compaq_ROM(void __iomem *rom_start)
131 {
132 	u8 temp1, temp2, temp3, temp4, temp5, temp6;
133 	int result = 0;
134 
135 	temp1 = readb(rom_start + 0xffea + 0);
136 	temp2 = readb(rom_start + 0xffea + 1);
137 	temp3 = readb(rom_start + 0xffea + 2);
138 	temp4 = readb(rom_start + 0xffea + 3);
139 	temp5 = readb(rom_start + 0xffea + 4);
140 	temp6 = readb(rom_start + 0xffea + 5);
141 	if ((temp1 == 'C') &&
142 	    (temp2 == 'O') &&
143 	    (temp3 == 'M') &&
144 	    (temp4 == 'P') &&
145 	    (temp5 == 'A') &&
146 	    (temp6 == 'Q')) {
147 		result = 1;
148 	}
149 	dbg("%s - returned %d\n", __func__, result);
150 	return result;
151 }
152 
153 
154 static u32 access_EV(u16 operation, u8 *ev_name, u8 *buffer, u32 *buf_size)
155 {
156 	unsigned long flags;
157 	int op = operation;
158 	int ret_val;
159 
160 	if (!compaq_int15_entry_point)
161 		return -ENODEV;
162 
163 	spin_lock_irqsave(&int15_lock, flags);
164 	__asm__ (
165 		"xorl   %%ebx,%%ebx\n" \
166 		"xorl    %%edx,%%edx\n" \
167 		"pushf\n" \
168 		"push %%cs\n" \
169 		"cli\n" \
170 		"call *%6\n"
171 		: "=c" (*buf_size), "=a" (ret_val)
172 		: "a" (op), "c" (*buf_size), "S" (ev_name),
173 		"D" (buffer), "m" (compaq_int15_entry_point)
174 		: "%ebx", "%edx");
175 	spin_unlock_irqrestore(&int15_lock, flags);
176 
177 	return((ret_val & 0xFF00) >> 8);
178 }
179 
180 
181 /*
182  * load_HRT
183  *
184  * Read the hot plug Resource Table from NVRAM
185  */
186 static int load_HRT(void __iomem *rom_start)
187 {
188 	u32 available;
189 	u32 temp_dword;
190 	u8 temp_byte = 0xFF;
191 	u32 rc;
192 
193 	if (!check_for_compaq_ROM(rom_start))
194 		return -ENODEV;
195 
196 	available = 1024;
197 
198 	/* Now load the EV */
199 	temp_dword = available;
200 
201 	rc = access_EV(READ_EV, "CQTHPS", evbuffer, &temp_dword);
202 
203 	evbuffer_length = temp_dword;
204 
205 	/* We're maintaining the resource lists so write FF to invalidate old
206 	 * info
207 	 */
208 	temp_dword = 1;
209 
210 	rc = access_EV(WRITE_EV, "CQTHPS", &temp_byte, &temp_dword);
211 
212 	return rc;
213 }
214 
215 
216 /*
217  * store_HRT
218  *
219  * Save the hot plug Resource Table in NVRAM
220  */
221 static u32 store_HRT(void __iomem *rom_start)
222 {
223 	u32 *buffer;
224 	u32 *pFill;
225 	u32 usedbytes;
226 	u32 available;
227 	u32 temp_dword;
228 	u32 rc;
229 	u8 loop;
230 	u8 numCtrl = 0;
231 	struct controller *ctrl;
232 	struct pci_resource *resNode;
233 	struct ev_hrt_header *p_EV_header;
234 	struct ev_hrt_ctrl *p_ev_ctrl;
235 
236 	available = 1024;
237 
238 	if (!check_for_compaq_ROM(rom_start))
239 		return(1);
240 
241 	buffer = (u32 *) evbuffer;
242 
243 	if (!buffer)
244 		return(1);
245 
246 	pFill = buffer;
247 	usedbytes = 0;
248 
249 	p_EV_header = (struct ev_hrt_header *) pFill;
250 
251 	ctrl = cpqhp_ctrl_list;
252 
253 	/* The revision of this structure */
254 	rc = add_byte(&pFill, 1 + ctrl->push_flag, &usedbytes, &available);
255 	if (rc)
256 		return(rc);
257 
258 	/* The number of controllers */
259 	rc = add_byte(&pFill, 1, &usedbytes, &available);
260 	if (rc)
261 		return(rc);
262 
263 	while (ctrl) {
264 		p_ev_ctrl = (struct ev_hrt_ctrl *) pFill;
265 
266 		numCtrl++;
267 
268 		/* The bus number */
269 		rc = add_byte(&pFill, ctrl->bus, &usedbytes, &available);
270 		if (rc)
271 			return(rc);
272 
273 		/* The device Number */
274 		rc = add_byte(&pFill, PCI_SLOT(ctrl->pci_dev->devfn), &usedbytes, &available);
275 		if (rc)
276 			return(rc);
277 
278 		/* The function Number */
279 		rc = add_byte(&pFill, PCI_FUNC(ctrl->pci_dev->devfn), &usedbytes, &available);
280 		if (rc)
281 			return(rc);
282 
283 		/* Skip the number of available entries */
284 		rc = add_dword(&pFill, 0, &usedbytes, &available);
285 		if (rc)
286 			return(rc);
287 
288 		/* Figure out memory Available */
289 
290 		resNode = ctrl->mem_head;
291 
292 		loop = 0;
293 
294 		while (resNode) {
295 			loop++;
296 
297 			/* base */
298 			rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
299 			if (rc)
300 				return(rc);
301 
302 			/* length */
303 			rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
304 			if (rc)
305 				return(rc);
306 
307 			resNode = resNode->next;
308 		}
309 
310 		/* Fill in the number of entries */
311 		p_ev_ctrl->mem_avail = loop;
312 
313 		/* Figure out prefetchable memory Available */
314 
315 		resNode = ctrl->p_mem_head;
316 
317 		loop = 0;
318 
319 		while (resNode) {
320 			loop++;
321 
322 			/* base */
323 			rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
324 			if (rc)
325 				return(rc);
326 
327 			/* length */
328 			rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
329 			if (rc)
330 				return(rc);
331 
332 			resNode = resNode->next;
333 		}
334 
335 		/* Fill in the number of entries */
336 		p_ev_ctrl->p_mem_avail = loop;
337 
338 		/* Figure out IO Available */
339 
340 		resNode = ctrl->io_head;
341 
342 		loop = 0;
343 
344 		while (resNode) {
345 			loop++;
346 
347 			/* base */
348 			rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
349 			if (rc)
350 				return(rc);
351 
352 			/* length */
353 			rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
354 			if (rc)
355 				return(rc);
356 
357 			resNode = resNode->next;
358 		}
359 
360 		/* Fill in the number of entries */
361 		p_ev_ctrl->io_avail = loop;
362 
363 		/* Figure out bus Available */
364 
365 		resNode = ctrl->bus_head;
366 
367 		loop = 0;
368 
369 		while (resNode) {
370 			loop++;
371 
372 			/* base */
373 			rc = add_dword(&pFill, resNode->base, &usedbytes, &available);
374 			if (rc)
375 				return(rc);
376 
377 			/* length */
378 			rc = add_dword(&pFill, resNode->length, &usedbytes, &available);
379 			if (rc)
380 				return(rc);
381 
382 			resNode = resNode->next;
383 		}
384 
385 		/* Fill in the number of entries */
386 		p_ev_ctrl->bus_avail = loop;
387 
388 		ctrl = ctrl->next;
389 	}
390 
391 	p_EV_header->num_of_ctrl = numCtrl;
392 
393 	/* Now store the EV */
394 
395 	temp_dword = usedbytes;
396 
397 	rc = access_EV(WRITE_EV, "CQTHPS", (u8 *) buffer, &temp_dword);
398 
399 	dbg("usedbytes = 0x%x, length = 0x%x\n", usedbytes, temp_dword);
400 
401 	evbuffer_length = temp_dword;
402 
403 	if (rc) {
404 		err(msg_unable_to_save);
405 		return(1);
406 	}
407 
408 	return(0);
409 }
410 
411 
412 void compaq_nvram_init(void __iomem *rom_start)
413 {
414 	if (rom_start)
415 		compaq_int15_entry_point = (rom_start + ROM_INT15_PHY_ADDR - ROM_PHY_ADDR);
416 
417 	dbg("int15 entry  = %p\n", compaq_int15_entry_point);
418 }
419 
420 
421 int compaq_nvram_load(void __iomem *rom_start, struct controller *ctrl)
422 {
423 	u8 bus, device, function;
424 	u8 nummem, numpmem, numio, numbus;
425 	u32 rc;
426 	u8 *p_byte;
427 	struct pci_resource *mem_node;
428 	struct pci_resource *p_mem_node;
429 	struct pci_resource *io_node;
430 	struct pci_resource *bus_node;
431 	struct ev_hrt_ctrl *p_ev_ctrl;
432 	struct ev_hrt_header *p_EV_header;
433 
434 	if (!evbuffer_init) {
435 		/* Read the resource list information in from NVRAM */
436 		if (load_HRT(rom_start))
437 			memset(evbuffer, 0, 1024);
438 
439 		evbuffer_init = 1;
440 	}
441 
442 	/* If we saved information in NVRAM, use it now */
443 	p_EV_header = (struct ev_hrt_header *) evbuffer;
444 
445 	/* The following code is for systems where version 1.0 of this
446 	 * driver has been loaded, but doesn't support the hardware.
447 	 * In that case, the driver would incorrectly store something
448 	 * in NVRAM.
449 	 */
450 	if ((p_EV_header->Version == 2) ||
451 	    ((p_EV_header->Version == 1) && !ctrl->push_flag)) {
452 		p_byte = &(p_EV_header->next);
453 
454 		p_ev_ctrl = (struct ev_hrt_ctrl *) &(p_EV_header->next);
455 
456 		p_byte += 3;
457 
458 		if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
459 			return 2;
460 
461 		bus = p_ev_ctrl->bus;
462 		device = p_ev_ctrl->device;
463 		function = p_ev_ctrl->function;
464 
465 		while ((bus != ctrl->bus) ||
466 		       (device != PCI_SLOT(ctrl->pci_dev->devfn)) ||
467 		       (function != PCI_FUNC(ctrl->pci_dev->devfn))) {
468 			nummem = p_ev_ctrl->mem_avail;
469 			numpmem = p_ev_ctrl->p_mem_avail;
470 			numio = p_ev_ctrl->io_avail;
471 			numbus = p_ev_ctrl->bus_avail;
472 
473 			p_byte += 4;
474 
475 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
476 				return 2;
477 
478 			/* Skip forward to the next entry */
479 			p_byte += (nummem + numpmem + numio + numbus) * 8;
480 
481 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
482 				return 2;
483 
484 			p_ev_ctrl = (struct ev_hrt_ctrl *) p_byte;
485 
486 			p_byte += 3;
487 
488 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
489 				return 2;
490 
491 			bus = p_ev_ctrl->bus;
492 			device = p_ev_ctrl->device;
493 			function = p_ev_ctrl->function;
494 		}
495 
496 		nummem = p_ev_ctrl->mem_avail;
497 		numpmem = p_ev_ctrl->p_mem_avail;
498 		numio = p_ev_ctrl->io_avail;
499 		numbus = p_ev_ctrl->bus_avail;
500 
501 		p_byte += 4;
502 
503 		if (p_byte > ((u8 *)p_EV_header + evbuffer_length))
504 			return 2;
505 
506 		while (nummem--) {
507 			mem_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
508 
509 			if (!mem_node)
510 				break;
511 
512 			mem_node->base = *(u32 *)p_byte;
513 			dbg("mem base = %8.8x\n", mem_node->base);
514 			p_byte += 4;
515 
516 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
517 				kfree(mem_node);
518 				return 2;
519 			}
520 
521 			mem_node->length = *(u32 *)p_byte;
522 			dbg("mem length = %8.8x\n", mem_node->length);
523 			p_byte += 4;
524 
525 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
526 				kfree(mem_node);
527 				return 2;
528 			}
529 
530 			mem_node->next = ctrl->mem_head;
531 			ctrl->mem_head = mem_node;
532 		}
533 
534 		while (numpmem--) {
535 			p_mem_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
536 
537 			if (!p_mem_node)
538 				break;
539 
540 			p_mem_node->base = *(u32 *)p_byte;
541 			dbg("pre-mem base = %8.8x\n", p_mem_node->base);
542 			p_byte += 4;
543 
544 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
545 				kfree(p_mem_node);
546 				return 2;
547 			}
548 
549 			p_mem_node->length = *(u32 *)p_byte;
550 			dbg("pre-mem length = %8.8x\n", p_mem_node->length);
551 			p_byte += 4;
552 
553 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
554 				kfree(p_mem_node);
555 				return 2;
556 			}
557 
558 			p_mem_node->next = ctrl->p_mem_head;
559 			ctrl->p_mem_head = p_mem_node;
560 		}
561 
562 		while (numio--) {
563 			io_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
564 
565 			if (!io_node)
566 				break;
567 
568 			io_node->base = *(u32 *)p_byte;
569 			dbg("io base = %8.8x\n", io_node->base);
570 			p_byte += 4;
571 
572 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
573 				kfree(io_node);
574 				return 2;
575 			}
576 
577 			io_node->length = *(u32 *)p_byte;
578 			dbg("io length = %8.8x\n", io_node->length);
579 			p_byte += 4;
580 
581 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
582 				kfree(io_node);
583 				return 2;
584 			}
585 
586 			io_node->next = ctrl->io_head;
587 			ctrl->io_head = io_node;
588 		}
589 
590 		while (numbus--) {
591 			bus_node = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
592 
593 			if (!bus_node)
594 				break;
595 
596 			bus_node->base = *(u32 *)p_byte;
597 			p_byte += 4;
598 
599 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
600 				kfree(bus_node);
601 				return 2;
602 			}
603 
604 			bus_node->length = *(u32 *)p_byte;
605 			p_byte += 4;
606 
607 			if (p_byte > ((u8 *)p_EV_header + evbuffer_length)) {
608 				kfree(bus_node);
609 				return 2;
610 			}
611 
612 			bus_node->next = ctrl->bus_head;
613 			ctrl->bus_head = bus_node;
614 		}
615 
616 		/* If all of the following fail, we don't have any resources for
617 		 * hot plug add
618 		 */
619 		rc = 1;
620 		rc &= cpqhp_resource_sort_and_combine(&(ctrl->mem_head));
621 		rc &= cpqhp_resource_sort_and_combine(&(ctrl->p_mem_head));
622 		rc &= cpqhp_resource_sort_and_combine(&(ctrl->io_head));
623 		rc &= cpqhp_resource_sort_and_combine(&(ctrl->bus_head));
624 
625 		if (rc)
626 			return(rc);
627 	} else {
628 		if ((evbuffer[0] != 0) && (!ctrl->push_flag))
629 			return 1;
630 	}
631 
632 	return 0;
633 }
634 
635 
636 int compaq_nvram_store(void __iomem *rom_start)
637 {
638 	int rc = 1;
639 
640 	if (rom_start == NULL)
641 		return -ENODEV;
642 
643 	if (evbuffer_init) {
644 		rc = store_HRT(rom_start);
645 		if (rc)
646 			err(msg_unable_to_save);
647 	}
648 	return rc;
649 }
650 
651