开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
acpiphp_res.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：16k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

acpiphp_res.c：源码内容
  1. /*
  2.  * ACPI PCI HotPlug Utility functions
  3.  *
  4.  * Copyright (c) 1995,2001 Compaq Computer Corporation
  5.  * Copyright (c) 2001 Greg Kroah-Hartman (greg@kroah.com)
  6.  * Copyright (c) 2001 IBM Corp.
  7.  * Copyright (c) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com)
  8.  * Copyright (c) 2002 Takayoshi Kochi (t-kouchi@cq.jp.nec.com)
  9.  * Copyright (c) 2002 NEC Corporation
  10.  *
  11.  * All rights reserved.
  12.  *
  13.  * This program is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 2 of the License, or (at
  16.  * your option) any later version.
  17.  *
  18.  * This program is distributed in the hope that it will be useful, but
  19.  * WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  21.  * NON INFRINGEMENT.  See the GNU General Public License for more
  22.  * details.
  23.  *
  24.  * You should have received a copy of the GNU General Public License
  25.  * along with this program; if not, write to the Free Software
  26.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  27.  *
  28.  * Send feedback to <gregkh@us.ibm.com>,<h-aono@ap.jp.nec.com>
  29.  *
  30.  */
  32. #include <linux/config.h>
  33. #include <linux/module.h>
  35. #include <linux/kernel.h>
  36. #include <linux/types.h>
  37. #include <linux/proc_fs.h>
  38. #include <linux/sysctl.h>
  39. #include <linux/pci.h>
  40. #include <linux/smp.h>
  41. #include <linux/smp_lock.h>
  42. #include <linux/init.h>
  44. #include <linux/string.h>
  45. #include <linux/mm.h>
  46. #include <linux/errno.h>
  47. #include <linux/ioport.h>
  48. #include <linux/slab.h>
  49. #include <linux/interrupt.h>
  50. #include <linux/timer.h>
  52. #include <linux/ioctl.h>
  53. #include <linux/fcntl.h>
  55. #include <linux/list.h>
  57. #include "pci_hotplug.h"
  58. #include "acpiphp.h"
  60. #define MY_NAME "acpiphp_res"
  62. /* local variables */
  63. static int debug = 0;
  65. /*
  66.  * sort_by_size - sort nodes by their length, smallest first
  67.  */
  68. static int sort_by_size(struct pci_resource **head)
  69. {
  70. struct pci_resource *current_res;
  71. struct pci_resource *next_res;
  72. int out_of_order = 1;
  74. if (!(*head))
  75. return 1;
  77. if (!((*head)->next))
  78. return 0;
  80. while (out_of_order) {
  81. out_of_order = 0;
  83. /* Special case for swapping list head */
  84. if (((*head)->next) &&
  85.     ((*head)->length > (*head)->next->length)) {
  86. out_of_order++;
  87. current_res = *head;
  88. *head = (*head)->next;
  89. current_res->next = (*head)->next;
  90. (*head)->next = current_res;
  91. }
  93. current_res = *head;
  95. while (current_res->next && current_res->next->next) {
  96. if (current_res->next->length > current_res->next->next->length) {
  97. out_of_order++;
  98. next_res = current_res->next;
  99. current_res->next = current_res->next->next;
  100. current_res = current_res->next;
  101. next_res->next = current_res->next;
  102. current_res->next = next_res;
  103. } else
  104. current_res = current_res->next;
  105. }
  106. }  /* End of out_of_order loop */
  108. return 0;
  109. }
  112. /*
  113.  * sort_by_max_size - sort nodes by their length, largest first
  114.  */
  115. static int sort_by_max_size(struct pci_resource **head)
  116. {
  117. struct pci_resource *current_res;
  118. struct pci_resource *next_res;
  119. int out_of_order = 1;
  121. if (!(*head))
  122. return 1;
  124. if (!((*head)->next))
  125. return 0;
  127. while (out_of_order) {
  128. out_of_order = 0;
  130. /* Special case for swapping list head */
  131. if (((*head)->next) &&
  132.     ((*head)->length < (*head)->next->length)) {
  133. out_of_order++;
  134. current_res = *head;
  135. *head = (*head)->next;
  136. current_res->next = (*head)->next;
  137. (*head)->next = current_res;
  138. }
  140. current_res = *head;
  142. while (current_res->next && current_res->next->next) {
  143. if (current_res->next->length < current_res->next->next->length) {
  144. out_of_order++;
  145. next_res = current_res->next;
  146. current_res->next = current_res->next->next;
  147. current_res = current_res->next;
  148. next_res->next = current_res->next;
  149. current_res->next = next_res;
  150. } else
  151. current_res = current_res->next;
  152. }
  153. }  /* End of out_of_order loop */
  155. return 0;
  156. }
  158. /**
  159.  * get_io_resource - get resource for I/O ports
  160.  *
  161.  * this function sorts the resource list by size and then
  162.  * returns the first node of "size" length that is not in the
  163.  * ISA aliasing window.  If it finds a node larger than "size"
  164.  * it will split it up.
  165.  *
  166.  * size must be a power of two.
  167.  *
  168.  * difference from get_resource is handling of ISA aliasing space.
  169.  *
  170.  */
  171. struct pci_resource *acpiphp_get_io_resource (struct pci_resource **head, u32 size)
  172. {
  173. struct pci_resource *prevnode;
  174. struct pci_resource *node;
  175. struct pci_resource *split_node;
  176. u64 temp_qword;
  178. if (!(*head))
  179. return NULL;
  181. if (acpiphp_resource_sort_and_combine(head))
  182. return NULL;
  184. if (sort_by_size(head))
  185. return NULL;
  187. for (node = *head; node; node = node->next) {
  188. if (node->length < size)
  189. continue;
  191. if (node->base & (size - 1)) {
  192. /* this one isn't base aligned properly
  193.    so we'll make a new entry and split it up */
  194. temp_qword = (node->base | (size-1)) + 1;
  196. /* Short circuit if adjusted size is too small */
  197. if ((node->length - (temp_qword - node->base)) < size)
  198. continue;
  200. split_node = acpiphp_make_resource(node->base, temp_qword - node->base);
  202. if (!split_node)
  203. return NULL;
  205. node->base = temp_qword;
  206. node->length -= split_node->length;
  208. /* Put it in the list */
  209. split_node->next = node->next;
  210. node->next = split_node;
  211. } /* End of non-aligned base */
  213. /* Don't need to check if too small since we already did */
  214. if (node->length > size) {
  215. /* this one is longer than we need
  216.    so we'll make a new entry and split it up */
  217. split_node = acpiphp_make_resource(node->base + size, node->length - size);
  219. if (!split_node)
  220. return NULL;
  222. node->length = size;
  224. /* Put it in the list */
  225. split_node->next = node->next;
  226. node->next = split_node;
  227. }  /* End of too big on top end */
  229. /* For IO make sure it's not in the ISA aliasing space */
  230. if (node->base & 0x300L)
  231. continue;
  233. /* If we got here, then it is the right size
  234.    Now take it out of the list */
  235. if (*head == node) {
  236. *head = node->next;
  237. } else {
  238. prevnode = *head;
  239. while (prevnode->next != node)
  240. prevnode = prevnode->next;
  242. prevnode->next = node->next;
  243. }
  244. node->next = NULL;
  245. /* Stop looping */
  246. break;
  247. }
  249. return node;
  250. }
  253. /**
  254.  * get_max_resource - get the largest resource
  255.  *
  256.  * Gets the largest node that is at least "size" big from the
  257.  * list pointed to by head.  It aligns the node on top and bottom
  258.  * to "size" alignment before returning it.
  259.  */
  260. struct pci_resource *acpiphp_get_max_resource (struct pci_resource **head, u32 size)
  261. {
  262. struct pci_resource *max;
  263. struct pci_resource *temp;
  264. struct pci_resource *split_node;
  265. u64 temp_qword;
  267. if (!(*head))
  268. return NULL;
  270. if (acpiphp_resource_sort_and_combine(head))
  271. return NULL;
  273. if (sort_by_max_size(head))
  274. return NULL;
  276. for (max = *head;max; max = max->next) {
  278. /* If not big enough we could probably just bail, 
  279.    instead we'll continue to the next. */
  280. if (max->length < size)
  281. continue;
  283. if (max->base & (size - 1)) {
  284. /* this one isn't base aligned properly
  285.    so we'll make a new entry and split it up */
  286. temp_qword = (max->base | (size-1)) + 1;
  288. /* Short circuit if adjusted size is too small */
  289. if ((max->length - (temp_qword - max->base)) < size)
  290. continue;
  292. split_node = acpiphp_make_resource(max->base, temp_qword - max->base);
  294. if (!split_node)
  295. return NULL;
  297. max->base = temp_qword;
  298. max->length -= split_node->length;
  300. /* Put it next in the list */
  301. split_node->next = max->next;
  302. max->next = split_node;
  303. }
  305. if ((max->base + max->length) & (size - 1)) {
  306. /* this one isn't end aligned properly at the top
  307.    so we'll make a new entry and split it up */
  308. temp_qword = ((max->base + max->length) & ~(size - 1));
  310. split_node = acpiphp_make_resource(temp_qword,
  311.    max->length + max->base - temp_qword);
  313. if (!split_node)
  314. return NULL;
  316. max->length -= split_node->length;
  318. /* Put it in the list */
  319. split_node->next = max->next;
  320. max->next = split_node;
  321. }
  323. /* Make sure it didn't shrink too much when we aligned it */
  324. if (max->length < size)
  325. continue;
  327. /* Now take it out of the list */
  328. temp = (struct pci_resource*) *head;
  329. if (temp == max) {
  330. *head = max->next;
  331. } else {
  332. while (temp && temp->next != max) {
  333. temp = temp->next;
  334. }
  336. temp->next = max->next;
  337. }
  339. max->next = NULL;
  340. return max;
  341. }
  343. /* If we get here, we couldn't find one */
  344. return NULL;
  345. }
  348. /**
  349.  * get_resource - get resource (mem, pfmem)
  350.  *
  351.  * this function sorts the resource list by size and then
  352.  * returns the first node of "size" length.  If it finds a node
  353.  * larger than "size" it will split it up.
  354.  *
  355.  * size must be a power of two.
  356.  *
  357.  */
  358. struct pci_resource *acpiphp_get_resource (struct pci_resource **head, u32 size)
  359. {
  360. struct pci_resource *prevnode;
  361. struct pci_resource *node;
  362. struct pci_resource *split_node;
  363. u64 temp_qword;
  365. if (!(*head))
  366. return NULL;
  368. if (acpiphp_resource_sort_and_combine(head))
  369. return NULL;
  371. if (sort_by_size(head))
  372. return NULL;
  374. for (node = *head; node; node = node->next) {
  375. dbg("%s: req_size =%x node=%p, base=%x, length=%x",
  376.     __FUNCTION__, size, node, (u32)node->base, node->length);
  377. if (node->length < size)
  378. continue;
  380. if (node->base & (size - 1)) {
  381. dbg("%s: not aligned", __FUNCTION__);
  382. /* this one isn't base aligned properly
  383.    so we'll make a new entry and split it up */
  384. temp_qword = (node->base | (size-1)) + 1;
  386. /* Short circuit if adjusted size is too small */
  387. if ((node->length - (temp_qword - node->base)) < size)
  388. continue;
  390. split_node = acpiphp_make_resource(node->base, temp_qword - node->base);
  392. if (!split_node)
  393. return NULL;
  395. node->base = temp_qword;
  396. node->length -= split_node->length;
  398. /* Put it in the list */
  399. split_node->next = node->next;
  400. node->next = split_node;
  401. } /* End of non-aligned base */
  403. /* Don't need to check if too small since we already did */
  404. if (node->length > size) {
  405. dbg("%s: too big", __FUNCTION__);
  406. /* this one is longer than we need
  407.    so we'll make a new entry and split it up */
  408. split_node = acpiphp_make_resource(node->base + size, node->length - size);
  410. if (!split_node)
  411. return NULL;
  413. node->length = size;
  415. /* Put it in the list */
  416. split_node->next = node->next;
  417. node->next = split_node;
  418. }  /* End of too big on top end */
  420. dbg("%s: got one!!!", __FUNCTION__);
  421. /* If we got here, then it is the right size
  422.    Now take it out of the list */
  423. if (*head == node) {
  424. *head = node->next;
  425. } else {
  426. prevnode = *head;
  427. while (prevnode->next != node)
  428. prevnode = prevnode->next;
  430. prevnode->next = node->next;
  431. }
  432. node->next = NULL;
  433. /* Stop looping */
  434. break;
  435. }
  436. return node;
  437. }
  439. /**
  440.  * get_resource_with_base - get resource with specific base address
  441.  *
  442.  * this function 
  443.  * returns the first node of "size" length located at specified base address.
  444.  * If it finds a node larger than "size" it will split it up.
  445.  *
  446.  * size must be a power of two.
  447.  *
  448.  */
  449. struct pci_resource *acpiphp_get_resource_with_base (struct pci_resource **head, u64 base, u32 size)
  450. {
  451. struct pci_resource *prevnode;
  452. struct pci_resource *node;
  453. struct pci_resource *split_node;
  454. u64 temp_qword;
  456. if (!(*head))
  457. return NULL;
  459. if (acpiphp_resource_sort_and_combine(head))
  460. return NULL;
  462. for (node = *head; node; node = node->next) {
  463. dbg(": 1st req_base=%x req_size =%x node=%p, base=%x, length=%x",
  464.     (u32)base, size, node, (u32)node->base, node->length);
  465. if (node->base > base)
  466. continue;
  468. if ((node->base + node->length) < (base + size))
  469. continue;
  471. if (node->base < base) {
  472. dbg(": split 1");
  473. /* this one isn't base aligned properly
  474.    so we'll make a new entry and split it up */
  475. temp_qword = base;
  477. /* Short circuit if adjusted size is too small */
  478. if ((node->length - (temp_qword - node->base)) < size)
  479. continue;
  481. split_node = acpiphp_make_resource(node->base, temp_qword - node->base);
  483. if (!split_node)
  484. return NULL;
  486. node->base = temp_qword;
  487. node->length -= split_node->length;
  489. /* Put it in the list */
  490. split_node->next = node->next;
  491. node->next = split_node;
  492. }
  494. dbg(": 2nd req_base=%x req_size =%x node=%p, base=%x, length=%x",
  495.     (u32)base, size, node, (u32)node->base, node->length);
  497. /* Don't need to check if too small since we already did */
  498. if (node->length > size) {
  499. dbg(": split 2");
  500. /* this one is longer than we need
  501.    so we'll make a new entry and split it up */
  502. split_node = acpiphp_make_resource(node->base + size, node->length - size);
  504. if (!split_node)
  505. return NULL;
  507. node->length = size;
  509. /* Put it in the list */
  510. split_node->next = node->next;
  511. node->next = split_node;
  512. }  /* End of too big on top end */
  514. dbg(": got one!!!");
  515. /* If we got here, then it is the right size
  516.    Now take it out of the list */
  517. if (*head == node) {
  518. *head = node->next;
  519. } else {
  520. prevnode = *head;
  521. while (prevnode->next != node)
  522. prevnode = prevnode->next;
  524. prevnode->next = node->next;
  525. }
  526. node->next = NULL;
  527. /* Stop looping */
  528. break;
  529. }
  530. return node;
  531. }
  534. /**
  535.  * acpiphp_resource_sort_and_combine
  536.  *
  537.  * Sorts all of the nodes in the list in ascending order by
  538.  * their base addresses.  Also does garbage collection by
  539.  * combining adjacent nodes.
  540.  *
  541.  * returns 0 if success
  542.  */
  543. int acpiphp_resource_sort_and_combine (struct pci_resource **head)
  544. {
  545. struct pci_resource *node1;
  546. struct pci_resource *node2;
  547. int out_of_order = 1;
  549. if (!(*head))
  550. return 1;
  552. dbg("*head->next = %p",(*head)->next);
  554. if (!(*head)->next)
  555. return 0; /* only one item on the list, already sorted! */
  557. dbg("*head->base = 0x%x",(u32)(*head)->base);
  558. dbg("*head->next->base = 0x%x", (u32)(*head)->next->base);
  559. while (out_of_order) {
  560. out_of_order = 0;
  562. /* Special case for swapping list head */
  563. if (((*head)->next) &&
  564.     ((*head)->base > (*head)->next->base)) {
  565. node1 = *head;
  566. (*head) = (*head)->next;
  567. node1->next = (*head)->next;
  568. (*head)->next = node1;
  569. out_of_order++;
  570. }
  572. node1 = (*head);
  574. while (node1->next && node1->next->next) {
  575. if (node1->next->base > node1->next->next->base) {
  576. out_of_order++;
  577. node2 = node1->next;
  578. node1->next = node1->next->next;
  579. node1 = node1->next;
  580. node2->next = node1->next;
  581. node1->next = node2;
  582. } else
  583. node1 = node1->next;
  584. }
  585. }  /* End of out_of_order loop */
  587. node1 = *head;
  589. while (node1 && node1->next) {
  590. if ((node1->base + node1->length) == node1->next->base) {
  591. /* Combine */
  592. dbg("8..");
  593. node1->length += node1->next->length;
  594. node2 = node1->next;
  595. node1->next = node1->next->next;
  596. kfree(node2);
  597. } else
  598. node1 = node1->next;
  599. }
  601. return 0;
  602. }
  605. /**
  606.  * acpiphp_make_resource - make resource structure
  607.  * @base: base address of a resource
  608.  * @length: length of a resource
  609.  */
  610. struct pci_resource *acpiphp_make_resource (u64 base, u32 length)
  611. {
  612. struct pci_resource *res;
  614. res = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
  615. if (res) {
  616. memset(res, 0, sizeof(struct pci_resource));
  617. res->base = base;
  618. res->length = length;
  619. }
  621. return res;
  622. }
  625. /**
  626.  * acpiphp_move_resource - move linked resources from one to another
  627.  * @from: head of linked resource list
  628.  * @to: head of linked resource list
  629.  */
  630. void acpiphp_move_resource (struct pci_resource **from, struct pci_resource **to)
  631. {
  632. struct pci_resource *tmp;
  634. while (*from) {
  635. tmp = (*from)->next;
  636. (*from)->next = *to;
  637. *to = *from;
  638. *from = tmp;
  639. }
  641. /* *from = NULL is guaranteed */
  642. }
  645. /**
  646.  * acpiphp_free_resource - free all linked resources
  647.  * @res: head of linked resource list
  648.  */
  649. void acpiphp_free_resource (struct pci_resource **res)
  650. {
  651. struct pci_resource *tmp;
  653. while (*res) {
  654. tmp = (*res)->next;
  655. kfree(*res);
  656. *res = tmp;
  657. }
  659. /* *res = NULL is guaranteed */
  660. }
  663. /* debug support functions;  will go away sometime :) */
  664. static void dump_resource(struct pci_resource *head)
  665. {
  666. struct pci_resource *p;
  667. int cnt;
  669. p = head;
  670. cnt = 0;
  672. while (p) {
  673. info("[%02d] %08x - %08x",
  674.      cnt++, (u32)p->base, (u32)p->base + p->length - 1);
  675. p = p->next;
  676. }
  677. }
  679. void acpiphp_dump_resource(struct acpiphp_bridge *bridge)
  680. {
  681. info("I/O resource:");
  682. dump_resource(bridge->io_head);
  683. info("MEM resource:");
  684. dump_resource(bridge->mem_head);
  685. info("PMEM resource:");
  686. dump_resource(bridge->p_mem_head);
  687. info("BUS resource:");
  688. dump_resource(bridge->bus_head);
  689. }
  691. void acpiphp_dump_func_resource(struct acpiphp_func *func)
  692. {
  693. info("I/O resource:");
  694. dump_resource(func->io_head);
  695. info("MEM resource:");
  696. dump_resource(func->mem_head);
  697. info("PMEM resource:");
  698. dump_resource(func->p_mem_head);
  699. info("BUS resource:");
  700. dump_resource(func->bus_head);
  701. }
  703. /*
  704. EXPORT_SYMBOL(acpiphp_get_io_resource);
  705. EXPORT_SYMBOL(acpiphp_get_max_resource);
  706. EXPORT_SYMBOL(acpiphp_get_resource);
  707. EXPORT_SYMBOL(acpiphp_resource_sort_and_combine);
  708. */