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

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

Linux/Unix编程

开发平台：

Unix_Linux

pci_auto.c：源码内容
  1. /*
  2.  * PCI autoconfiguration library
  3.  *
  4.  * Author: Matt Porter <mporter@mvista.com>
  5.  *
  6.  * Copyright 2000, 2001 MontaVista Software Inc.
  7.  * Copyright 2001 Bradley D. LaRonde <brad@ltc.com>
  8.  *
  9.  * This program is free software; you can redistribute  it and/or modify it
  10.  * under  the terms of  the GNU General  Public License as published by the
  11.  * Free Software Foundation;  either version 2 of the  License, or (at your
  12.  * option) any later version.
  13.  */
  15. /*
  16.  * Modified for MIPS by Jun Sun, jsun@mvista.com
  17.  *
  18.  * . Simplify the interface between pci_auto and the rest: a single function.
  19.  * . Assign resources from low address to upper address.
  20.  * . change most int to u32.
  21.  *
  22.  * Further modified to include it as mips generic code, ppopov@mvista.com.
  23.  *
  24.  * 2001-10-26  Bradley D. LaRonde <brad@ltc.com>
  25.  * - Add a top_bus argument to the "early config" functions so that
  26.  *   they can set a fake parent bus pointer to convince the underlying
  27.  *   pci ops to use type 1 configuration for sub busses.
  28.  * - Set bridge base and limit registers correctly.
  29.  * - Align io and memory base properly before and after bridge setup.
  30.  * - Don't fall through to pci_setup_bars for bridge.
  31.  * - Reformat the debug output to look more like lspci's output.
  32.  */
  34. #include <linux/kernel.h>
  35. #include <linux/init.h>
  36. #include <linux/types.h>
  37. #include <linux/pci.h>
  39. #include <asm/pci_channel.h>
  41. #define DEBUG
  42. #ifdef  DEBUG
  43. #define DBG(x...) printk(x)
  44. #else
  45. #define DBG(x...)
  46. #endif
  48. /*
  49.  * These functions are used early on before PCI scanning is done
  50.  * and all of the pci_dev and pci_bus structures have been created.
  51.  */
  52. static struct pci_dev *fake_pci_dev(struct pci_channel *hose,
  53. int top_bus, int busnr, int devfn)
  54. {
  55. static struct pci_dev dev;
  56. static struct pci_bus bus;
  58. dev.bus = &bus;
  59. dev.sysdata = hose;
  60. dev.devfn = devfn;
  61. bus.number = busnr;
  62. bus.ops = hose->pci_ops;
  64. if(busnr != top_bus)
  65. /* Fake a parent bus structure. */
  66. bus.parent = &bus;
  67. else
  68. bus.parent = NULL;
  70. return &dev;
  71. }
  73. #define EARLY_PCI_OP(rw, size, type)
  74. int early_##rw##_config_##size(struct pci_channel *hose,
  75. int top_bus, int bus, int devfn, int offset, type value)
  76. {
  77. return pci_##rw##_config_##size(
  78. fake_pci_dev(hose, top_bus, bus, devfn),
  79. offset, value);
  80. }
  82. EARLY_PCI_OP(read, byte, u8 *)
  83. EARLY_PCI_OP(read, word, u16 *)
  84. EARLY_PCI_OP(read, dword, u32 *)
  85. EARLY_PCI_OP(write, byte, u8)
  86. EARLY_PCI_OP(write, word, u16)
  87. EARLY_PCI_OP(write, dword, u32)
  89. static struct resource *io_resource_inuse;
  90. static struct resource *mem_resource_inuse;
  92. static u32 pciauto_lower_iospc;
  93. static u32 pciauto_upper_iospc;
  95. static u32 pciauto_lower_memspc;
  96. static u32 pciauto_upper_memspc;
  98. void __init
  99. pciauto_setup_bars(struct pci_channel *hose,
  100.    int top_bus,
  101.    int current_bus,
  102.    int pci_devfn)
  103. {
  104. u32 bar_response, bar_size, bar_value;
  105. u32 bar, addr_mask, bar_nr = 0;
  106. u32 * upper_limit;
  107. u32 * lower_limit;
  108. int found_mem64 = 0;
  110. for (bar = PCI_BASE_ADDRESS_0; bar <= PCI_BASE_ADDRESS_5; bar+=4) {
  111. /* Tickle the BAR and get the response */
  112. early_write_config_dword(hose, top_bus,
  113.  current_bus,
  114.  pci_devfn,
  115.  bar,
  116.  0xffffffff);
  117. early_read_config_dword(hose, top_bus,
  118. current_bus,
  119. pci_devfn,
  120. bar,
  121. &bar_response);
  123. /* If BAR is not implemented go to the next BAR */
  124. if (!bar_response)
  125. continue;
  127. /*
  128.  * Workaround for a BAR that doesn't use its upper word,
  129.  * like the ALi 1535D+ PCI DC-97 Controller Modem (M5457).
  130.  * bdl <brad@ltc.com>
  131.  */
  132. if (!(bar_response & 0xffff0000))
  133. bar_response |= 0xffff0000;
  135. retry:
  136. /* Check the BAR type and set our address mask */
  137. if (bar_response & PCI_BASE_ADDRESS_SPACE) {
  138. addr_mask = PCI_BASE_ADDRESS_IO_MASK;
  139. upper_limit = &pciauto_upper_iospc;
  140. lower_limit = &pciauto_lower_iospc;
  141. DBG("        I/O");
  142. } else {
  143. if ((bar_response & PCI_BASE_ADDRESS_MEM_TYPE_MASK) ==
  144.     PCI_BASE_ADDRESS_MEM_TYPE_64)
  145. found_mem64 = 1;
  147. addr_mask = PCI_BASE_ADDRESS_MEM_MASK;
  148. upper_limit = &pciauto_upper_memspc;
  149. lower_limit = &pciauto_lower_memspc;
  150. DBG("        Mem");
  151. }
  154. /* Calculate requested size */
  155. bar_size = ~(bar_response & addr_mask) + 1;
  157. /* Allocate a base address */
  158. bar_value = ((*lower_limit - 1) & ~(bar_size - 1)) + bar_size;
  160. if ((bar_value + bar_size) > *upper_limit) {
  161. if (bar_response & PCI_BASE_ADDRESS_SPACE) {
  162. if (io_resource_inuse->child) {
  163. io_resource_inuse =
  164. io_resource_inuse->child;
  165. pciauto_lower_iospc =
  166. io_resource_inuse->start;
  167. pciauto_upper_iospc =
  168. io_resource_inuse->end + 1;
  169. goto retry;
  170. }
  172. } else {
  173. if (mem_resource_inuse->child) {
  174. mem_resource_inuse =
  175. mem_resource_inuse->child;
  176. pciauto_lower_memspc =
  177. mem_resource_inuse->start;
  178. pciauto_upper_memspc =
  179. mem_resource_inuse->end + 1;
  180. goto retry;
  181. }
  182. }
  183. DBG(" unavailable -- skippingn");
  184. continue;
  185. }
  187. /* Write it out and update our limit */
  188. early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
  189.  bar, bar_value);
  191. *lower_limit = bar_value + bar_size;
  193. /*
  194.  * If we are a 64-bit decoder then increment to the
  195.  * upper 32 bits of the bar and force it to locate
  196.  * in the lower 4GB of memory.
  197.  */
  198. if (found_mem64) {
  199. bar += 4;
  200. early_write_config_dword(hose, top_bus,
  201.  current_bus,
  202.  pci_devfn,
  203.  bar,
  204.  0x00000000);
  205. }
  207. DBG(" at 0x%.8x [size=0x%x]n", bar_value, bar_size);
  209. bar_nr++;
  210. }
  212. }
  214. void __init
  215. pciauto_prescan_setup_bridge(struct pci_channel *hose,
  216.      int top_bus,
  217.      int current_bus,
  218.      int pci_devfn,
  219.      int sub_bus)
  220. {
  221. /* Configure bus number registers */
  222. early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
  223.                         PCI_PRIMARY_BUS, current_bus);
  224. early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
  225. PCI_SECONDARY_BUS, sub_bus + 1);
  226. early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
  227. PCI_SUBORDINATE_BUS, 0xff);
  229. /* Align memory and I/O to 1MB and 4KB boundaries. */
  230. pciauto_lower_memspc = (pciauto_lower_memspc + (0x100000 - 1))
  231. & ~(0x100000 - 1);
  232. pciauto_lower_iospc = (pciauto_lower_iospc + (0x1000 - 1))
  233. & ~(0x1000 - 1);
  235. /* Set base (lower limit) of address range behind bridge. */
  236. early_write_config_word(hose, top_bus, current_bus, pci_devfn,
  237. PCI_MEMORY_BASE, pciauto_lower_memspc >> 16);
  238. early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
  239. PCI_IO_BASE, (pciauto_lower_iospc & 0x0000f000) >> 8);
  240. early_write_config_word(hose, top_bus, current_bus, pci_devfn,
  241. PCI_IO_BASE_UPPER16, pciauto_lower_iospc >> 16);
  243. /* We don't support prefetchable memory for now, so disable */
  244. early_write_config_word(hose, top_bus, current_bus, pci_devfn,
  245. PCI_PREF_MEMORY_BASE, 0);
  246. early_write_config_word(hose, top_bus, current_bus, pci_devfn,
  247. PCI_PREF_MEMORY_LIMIT, 0);
  248. }
  250. void __init
  251. pciauto_postscan_setup_bridge(struct pci_channel *hose,
  252.       int top_bus,
  253.       int current_bus,
  254.       int pci_devfn,
  255.       int sub_bus)
  256. {
  257. u32 temp;
  259. /* Configure bus number registers */
  260. early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
  261. PCI_SUBORDINATE_BUS, sub_bus);
  263. /* Set upper limit of address range behind bridge. */
  264. early_write_config_word(hose, top_bus, current_bus, pci_devfn,
  265. PCI_MEMORY_LIMIT, pciauto_lower_memspc >> 16);
  266. early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
  267. PCI_IO_LIMIT, (pciauto_lower_iospc & 0x0000f000) >> 8);
  268. early_write_config_word(hose, top_bus, current_bus, pci_devfn,
  269. PCI_IO_LIMIT_UPPER16, pciauto_lower_iospc >> 16);
  271. /* Align memory and I/O to 1MB and 4KB boundaries. */
  272. pciauto_lower_memspc = (pciauto_lower_memspc + (0x100000 - 1))
  273. & ~(0x100000 - 1);
  274. pciauto_lower_iospc = (pciauto_lower_iospc + (0x1000 - 1))
  275. & ~(0x1000 - 1);
  277. /* Enable memory and I/O accesses, enable bus master */
  278. early_read_config_dword(hose, top_bus, current_bus, pci_devfn,
  279. PCI_COMMAND, &temp);
  280. early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
  281. PCI_COMMAND, temp | PCI_COMMAND_IO | PCI_COMMAND_MEMORY
  282. | PCI_COMMAND_MASTER);
  283. }
  285. #define      PCIAUTO_IDE_MODE_MASK           0x05
  287. int __init
  288. pciauto_bus_scan(struct pci_channel *hose, int top_bus, int current_bus)
  289. {
  290. int sub_bus;
  291. u32 pci_devfn, pci_class, cmdstat, found_multi=0;
  292. unsigned short vid, did;
  293. unsigned char header_type;
  294. int devfn_start = 0;
  295. int devfn_stop = 0xff;
  297. sub_bus = current_bus;
  299. if (hose->first_devfn)
  300. devfn_start = hose->first_devfn;
  301. if (hose->last_devfn)
  302. devfn_stop = hose->last_devfn;
  304. for (pci_devfn=devfn_start; pci_devfn<devfn_stop; pci_devfn++) {
  306. if (PCI_FUNC(pci_devfn) && !found_multi)
  307. continue;
  309. early_read_config_word(hose, top_bus, current_bus, pci_devfn,
  310.        PCI_VENDOR_ID, &vid);
  312. if (vid == 0xffff) continue;
  314. early_read_config_byte(hose, top_bus, current_bus, pci_devfn,
  315.        PCI_HEADER_TYPE, &header_type);
  317. if (!PCI_FUNC(pci_devfn))
  318. found_multi = header_type & 0x80;
  320. early_read_config_word(hose, top_bus, current_bus, pci_devfn,
  321.        PCI_DEVICE_ID, &did);
  323. early_read_config_dword(hose, top_bus, current_bus, pci_devfn,
  324. PCI_CLASS_REVISION, &pci_class);
  326. DBG("%.2x:%.2x.%x Class %.4x: %.4x:%.4x",
  327. current_bus, PCI_SLOT(pci_devfn), PCI_FUNC(pci_devfn),
  328. pci_class >> 16, vid, did);
  329. if (pci_class & 0xff)
  330. DBG(" (rev %.2x)", pci_class & 0xff);
  331. DBG("n");
  333. if ((pci_class >> 16) == PCI_CLASS_BRIDGE_PCI) {
  334. DBG("        Bridge: primary=%.2x, secondary=%.2xn",
  335. current_bus, sub_bus + 1);
  336. pciauto_prescan_setup_bridge(hose, top_bus, current_bus,
  337.      pci_devfn, sub_bus);
  338. DBG("Scanning sub bus %.2x, I/O 0x%.8x, Mem 0x%.8xn",
  339. sub_bus + 1,
  340. pciauto_lower_iospc, pciauto_lower_memspc);
  341. sub_bus = pciauto_bus_scan(hose, top_bus, sub_bus+1);
  342. DBG("Back to bus %.2xn", current_bus);
  343. pciauto_postscan_setup_bridge(hose, top_bus, current_bus,
  344.       pci_devfn, sub_bus);
  345. continue;
  346. } else if ((pci_class >> 16) == PCI_CLASS_STORAGE_IDE) {
  348. unsigned char prg_iface;
  350. early_read_config_byte(hose, top_bus, current_bus,
  351. pci_devfn, PCI_CLASS_PROG, &prg_iface);
  352. if (!(prg_iface & PCIAUTO_IDE_MODE_MASK)) {
  353. DBG("Skipping legacy mode IDE controllern");
  354. continue;
  355. }
  356. }
  358.   /*
  359.  * Found a peripheral, enable some standard
  360.  * settings
  361.  */
  362. early_read_config_dword(hose, top_bus, current_bus, pci_devfn,
  363. PCI_COMMAND, &cmdstat);
  364. early_write_config_dword(hose, top_bus, current_bus, pci_devfn,
  365.  PCI_COMMAND, cmdstat | PCI_COMMAND_IO |
  366.  PCI_COMMAND_MEMORY |
  367.  PCI_COMMAND_MASTER);
  368. early_write_config_byte(hose, top_bus, current_bus, pci_devfn,
  369. PCI_LATENCY_TIMER, 0x80);
  371. /* Allocate PCI I/O and/or memory space */
  372. pciauto_setup_bars(hose, top_bus, current_bus, pci_devfn);
  373. }
  374. return sub_bus;
  375. }
  377. int __init
  378. pciauto_assign_resources(int busno, struct pci_channel *hose)
  379. {
  380. /* setup resource limits */
  381. io_resource_inuse = hose->io_resource;
  382. mem_resource_inuse = hose->mem_resource;
  384. pciauto_lower_iospc = io_resource_inuse->start;
  385. pciauto_upper_iospc = io_resource_inuse->end + 1;
  386. pciauto_lower_memspc = mem_resource_inuse->start;
  387. pciauto_upper_memspc = mem_resource_inuse->end + 1;
  388. DBG("Autoconfig PCI channel 0x%pn", hose);
  389. DBG("Scanning bus %.2x, I/O 0x%.8x:0x%.8x, Mem 0x%.8x:0x%.8xn",
  390. busno, pciauto_lower_iospc, pciauto_upper_iospc,
  391. pciauto_lower_memspc, pciauto_upper_memspc);
  393. return pciauto_bus_scan(hose, busno, busno);
  394. }