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

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

Linux/Unix编程

开发平台：

Unix_Linux

proc.c：源码内容
  1. /*
  2.  * $Id: proc.c,v 1.13 1998/05/12 07:36:07 mj Exp $
  3.  *
  4.  * Procfs interface for the PCI bus.
  5.  *
  6.  * Copyright (c) 1997--1999 Martin Mares <mj@ucw.cz>
  7.  */
  9. #include <linux/types.h>
  10. #include <linux/kernel.h>
  11. #include <linux/pci.h>
  12. #include <linux/proc_fs.h>
  13. #include <linux/init.h>
  14. #include <linux/seq_file.h>
  16. #include <asm/uaccess.h>
  17. #include <asm/byteorder.h>
  19. #define PCI_CFG_SPACE_SIZE 256
  21. static loff_t
  22. proc_bus_pci_lseek(struct file *file, loff_t off, int whence)
  23. {
  24. loff_t new;
  26. switch (whence) {
  27. case 0:
  28. new = off;
  29. break;
  30. case 1:
  31. new = file->f_pos + off;
  32. break;
  33. case 2:
  34. new = PCI_CFG_SPACE_SIZE + off;
  35. break;
  36. default:
  37. return -EINVAL;
  38. }
  39. if (new < 0 || new > PCI_CFG_SPACE_SIZE)
  40. return -EINVAL;
  41. return (file->f_pos = new);
  42. }
  44. static ssize_t
  45. proc_bus_pci_read(struct file *file, char *buf, size_t nbytes, loff_t *ppos)
  46. {
  47. const struct inode *ino = file->f_dentry->d_inode;
  48. const struct proc_dir_entry *dp = ino->u.generic_ip;
  49. struct pci_dev *dev = dp->data;
  50. unsigned int pos = *ppos;
  51. unsigned int cnt, size;
  53. /*
  54.  * Normal users can read only the standardized portion of the
  55.  * configuration space as several chips lock up when trying to read
  56.  * undefined locations (think of Intel PIIX4 as a typical example).
  57.  */
  59. if (capable(CAP_SYS_ADMIN))
  60. size = PCI_CFG_SPACE_SIZE;
  61. else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
  62. size = 128;
  63. else
  64. size = 64;
  66. if (pos >= size)
  67. return 0;
  68. if (nbytes >= size)
  69. nbytes = size;
  70. if (pos + nbytes > size)
  71. nbytes = size - pos;
  72. cnt = nbytes;
  74. if (!access_ok(VERIFY_WRITE, buf, cnt))
  75. return -EINVAL;
  77. if ((pos & 1) && cnt) {
  78. unsigned char val;
  79. pci_read_config_byte(dev, pos, &val);
  80. __put_user(val, buf);
  81. buf++;
  82. pos++;
  83. cnt--;
  84. }
  86. if ((pos & 3) && cnt > 2) {
  87. unsigned short val;
  88. pci_read_config_word(dev, pos, &val);
  89. __put_user(cpu_to_le16(val), (unsigned short *) buf);
  90. buf += 2;
  91. pos += 2;
  92. cnt -= 2;
  93. }
  95. while (cnt >= 4) {
  96. unsigned int val;
  97. pci_read_config_dword(dev, pos, &val);
  98. __put_user(cpu_to_le32(val), (unsigned int *) buf);
  99. buf += 4;
  100. pos += 4;
  101. cnt -= 4;
  102. }
  104. if (cnt >= 2) {
  105. unsigned short val;
  106. pci_read_config_word(dev, pos, &val);
  107. __put_user(cpu_to_le16(val), (unsigned short *) buf);
  108. buf += 2;
  109. pos += 2;
  110. cnt -= 2;
  111. }
  113. if (cnt) {
  114. unsigned char val;
  115. pci_read_config_byte(dev, pos, &val);
  116. __put_user(val, buf);
  117. buf++;
  118. pos++;
  119. cnt--;
  120. }
  122. *ppos = pos;
  123. return nbytes;
  124. }
  126. static ssize_t
  127. proc_bus_pci_write(struct file *file, const char *buf, size_t nbytes, loff_t *ppos)
  128. {
  129. const struct inode *ino = file->f_dentry->d_inode;
  130. const struct proc_dir_entry *dp = ino->u.generic_ip;
  131. struct pci_dev *dev = dp->data;
  132. int pos = *ppos;
  133. int cnt;
  135. if (pos >= PCI_CFG_SPACE_SIZE)
  136. return 0;
  137. if (nbytes >= PCI_CFG_SPACE_SIZE)
  138. nbytes = PCI_CFG_SPACE_SIZE;
  139. if (pos + nbytes > PCI_CFG_SPACE_SIZE)
  140. nbytes = PCI_CFG_SPACE_SIZE - pos;
  141. cnt = nbytes;
  143. if (!access_ok(VERIFY_READ, buf, cnt))
  144. return -EINVAL;
  146. if ((pos & 1) && cnt) {
  147. unsigned char val;
  148. __get_user(val, buf);
  149. pci_write_config_byte(dev, pos, val);
  150. buf++;
  151. pos++;
  152. cnt--;
  153. }
  155. if ((pos & 3) && cnt > 2) {
  156. unsigned short val;
  157. __get_user(val, (unsigned short *) buf);
  158. pci_write_config_word(dev, pos, le16_to_cpu(val));
  159. buf += 2;
  160. pos += 2;
  161. cnt -= 2;
  162. }
  164. while (cnt >= 4) {
  165. unsigned int val;
  166. __get_user(val, (unsigned int *) buf);
  167. pci_write_config_dword(dev, pos, le32_to_cpu(val));
  168. buf += 4;
  169. pos += 4;
  170. cnt -= 4;
  171. }
  173. if (cnt >= 2) {
  174. unsigned short val;
  175. __get_user(val, (unsigned short *) buf);
  176. pci_write_config_word(dev, pos, le16_to_cpu(val));
  177. buf += 2;
  178. pos += 2;
  179. cnt -= 2;
  180. }
  182. if (cnt) {
  183. unsigned char val;
  184. __get_user(val, buf);
  185. pci_write_config_byte(dev, pos, val);
  186. buf++;
  187. pos++;
  188. cnt--;
  189. }
  191. *ppos = pos;
  192. return nbytes;
  193. }
  195. struct pci_filp_private {
  196. enum pci_mmap_state mmap_state;
  197. int write_combine;
  198. };
  200. static int proc_bus_pci_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  201. {
  202. const struct proc_dir_entry *dp = inode->u.generic_ip;
  203. struct pci_dev *dev = dp->data;
  204. #ifdef HAVE_PCI_MMAP
  205. struct pci_filp_private *fpriv = file->private_data;
  206. #endif /* HAVE_PCI_MMAP */
  207. int ret = 0;
  209. switch (cmd) {
  210. case PCIIOC_CONTROLLER:
  211. ret = pci_controller_num(dev);
  212. break;
  214. #ifdef HAVE_PCI_MMAP
  215. case PCIIOC_MMAP_IS_IO:
  216. fpriv->mmap_state = pci_mmap_io;
  217. break;
  219. case PCIIOC_MMAP_IS_MEM:
  220. fpriv->mmap_state = pci_mmap_mem;
  221. break;
  223. case PCIIOC_WRITE_COMBINE:
  224. if (arg)
  225. fpriv->write_combine = 1;
  226. else
  227. fpriv->write_combine = 0;
  228. break;
  230. #endif /* HAVE_PCI_MMAP */
  232. default:
  233. ret = -EINVAL;
  234. break;
  235. };
  237. return ret;
  238. }
  240. #ifdef HAVE_PCI_MMAP
  241. static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)
  242. {
  243. struct inode *inode = file->f_dentry->d_inode;
  244. const struct proc_dir_entry *dp = inode->u.generic_ip;
  245. struct pci_dev *dev = dp->data;
  246. struct pci_filp_private *fpriv = file->private_data;
  247. int ret;
  249. if (!capable(CAP_SYS_RAWIO))
  250. return -EPERM;
  252. ret = pci_mmap_page_range(dev, vma,
  253.   fpriv->mmap_state,
  254.   fpriv->write_combine);
  255. if (ret < 0)
  256. return ret;
  258. return 0;
  259. }
  261. static int proc_bus_pci_open(struct inode *inode, struct file *file)
  262. {
  263. struct pci_filp_private *fpriv = kmalloc(sizeof(*fpriv), GFP_KERNEL);
  265. if (!fpriv)
  266. return -ENOMEM;
  268. fpriv->mmap_state = pci_mmap_io;
  269. fpriv->write_combine = 0;
  271. file->private_data = fpriv;
  273. return 0;
  274. }
  276. static int proc_bus_pci_release(struct inode *inode, struct file *file)
  277. {
  278. kfree(file->private_data);
  279. file->private_data = NULL;
  281. return 0;
  282. }
  283. #endif /* HAVE_PCI_MMAP */
  285. static struct file_operations proc_bus_pci_operations = {
  286. llseek: proc_bus_pci_lseek,
  287. read: proc_bus_pci_read,
  288. write: proc_bus_pci_write,
  289. ioctl: proc_bus_pci_ioctl,
  290. #ifdef HAVE_PCI_MMAP
  291. open: proc_bus_pci_open,
  292. release: proc_bus_pci_release,
  293. mmap: proc_bus_pci_mmap,
  294. #ifdef HAVE_ARCH_PCI_GET_UNMAPPED_AREA
  295. get_unmapped_area: get_pci_unmapped_area,
  296. #endif /* HAVE_ARCH_PCI_GET_UNMAPPED_AREA */
  297. #endif /* HAVE_PCI_MMAP */
  298. };
  300. #if BITS_PER_LONG == 32
  301. #define LONG_FORMAT "t%08lx"
  302. #else
  303. #define LONG_FORMAT "t%16lx"
  304. #endif
  306. /* iterator */
  307. static void *pci_seq_start(struct seq_file *m, loff_t *pos)
  308. {
  309. struct list_head *p = &pci_devices;
  310. loff_t n = *pos;
  312. /* XXX: surely we need some locking for traversing the list? */
  313. while (n--) {
  314. p = p->next;
  315. if (p == &pci_devices)
  316. return NULL;
  317. }
  318. return p;
  319. }
  320. static void *pci_seq_next(struct seq_file *m, void *v, loff_t *pos)
  321. {
  322. struct list_head *p = v;
  323. (*pos)++;
  324. return p->next != &pci_devices ? p->next : NULL;
  325. }
  326. static void pci_seq_stop(struct seq_file *m, void *v)
  327. {
  328. /* release whatever locks we need */
  329. }
  331. static int show_device(struct seq_file *m, void *v)
  332. {
  333. struct list_head *p = v;
  334. const struct pci_dev *dev;
  335. const struct pci_driver *drv;
  336. int i;
  338. if (p == &pci_devices)
  339. return 0;
  341. dev = pci_dev_g(p);
  342. drv = pci_dev_driver(dev);
  343. seq_printf(m, "%02x%02xt%04x%04xt%x",
  344. dev->bus->number,
  345. dev->devfn,
  346. dev->vendor,
  347. dev->device,
  348. dev->irq);
  349. /* Here should be 7 and not PCI_NUM_RESOURCES as we need to preserve compatibility */
  350. for(i=0; i<7; i++)
  351. seq_printf(m, LONG_FORMAT,
  352. dev->resource[i].start |
  353. (dev->resource[i].flags & PCI_REGION_FLAG_MASK));
  354. for(i=0; i<7; i++)
  355. seq_printf(m, LONG_FORMAT,
  356. dev->resource[i].start < dev->resource[i].end ?
  357. dev->resource[i].end - dev->resource[i].start + 1 : 0);
  358. seq_putc(m, 't');
  359. if (drv)
  360. seq_printf(m, "%s", drv->name);
  361. seq_putc(m, 'n');
  362. return 0;
  363. }
  365. static struct seq_operations proc_bus_pci_devices_op = {
  366. start: pci_seq_start,
  367. next: pci_seq_next,
  368. stop: pci_seq_stop,
  369. show: show_device
  370. };
  372. struct proc_dir_entry *proc_bus_pci_dir;
  374. int pci_proc_attach_device(struct pci_dev *dev)
  375. {
  376. struct pci_bus *bus = dev->bus;
  377. struct proc_dir_entry *de, *e;
  378. char name[16];
  380. if (!(de = bus->procdir)) {
  381. sprintf(name, "%02x", bus->number);
  382. de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
  383. if (!de)
  384. return -ENOMEM;
  385. }
  386. sprintf(name, "%02x.%x", PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
  387. e = dev->procent = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, de);
  388. if (!e)
  389. return -ENOMEM;
  390. e->proc_fops = &proc_bus_pci_operations;
  391. e->data = dev;
  392. e->size = PCI_CFG_SPACE_SIZE;
  393. return 0;
  394. }
  396. int pci_proc_detach_device(struct pci_dev *dev)
  397. {
  398. struct proc_dir_entry *e;
  400. if ((e = dev->procent)) {
  401. if (atomic_read(&e->count))
  402. return -EBUSY;
  403. remove_proc_entry(e->name, dev->bus->procdir);
  404. dev->procent = NULL;
  405. }
  406. return 0;
  407. }
  409. int pci_proc_attach_bus(struct pci_bus* bus)
  410. {
  411. struct proc_dir_entry *de = bus->procdir;
  413. if (!de) {
  414. char name[16];
  415. sprintf(name, "%02x", bus->number);
  416. de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
  417. if (!de)
  418. return -ENOMEM;
  419. }
  420. return 0;
  421. }
  423. int pci_proc_detach_bus(struct pci_bus* bus)
  424. {
  425. struct proc_dir_entry *de = bus->procdir;
  426. if (de)
  427. remove_proc_entry(de->name, proc_bus_pci_dir);
  428. return 0;
  429. }
  432. /*
  433.  *  Backward compatible /proc/pci interface.
  434.  */
  436. /*
  437.  * Convert some of the configuration space registers of the device at
  438.  * address (bus,devfn) into a string (possibly several lines each).
  439.  * The configuration string is stored starting at buf[len].  If the
  440.  * string would exceed the size of the buffer (SIZE), 0 is returned.
  441.  */
  442. static int show_dev_config(struct seq_file *m, void *v)
  443. {
  444. struct list_head *p = v;
  445. struct pci_dev *dev;
  446. struct pci_driver *drv;
  447. u32 class_rev;
  448. unsigned char latency, min_gnt, max_lat, *class;
  449. int reg;
  451. if (p == &pci_devices) {
  452. seq_puts(m, "PCI devices found:n");
  453. return 0;
  454. }
  456. dev = pci_dev_g(p);
  457. drv = pci_dev_driver(dev);
  459. pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
  460. pci_read_config_byte (dev, PCI_LATENCY_TIMER, &latency);
  461. pci_read_config_byte (dev, PCI_MIN_GNT, &min_gnt);
  462. pci_read_config_byte (dev, PCI_MAX_LAT, &max_lat);
  463. seq_printf(m, "  Bus %2d, device %3d, function %2d:n",
  464.        dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
  465. class = pci_class_name(class_rev >> 16);
  466. if (class)
  467. seq_printf(m, "    %s", class);
  468. else
  469. seq_printf(m, "    Class %04x", class_rev >> 16);
  470. seq_printf(m, ": %s (rev %d).n", dev->name, class_rev & 0xff);
  472. if (dev->irq)
  473. seq_printf(m, "      IRQ %d.n", dev->irq);
  475. if (latency || min_gnt || max_lat) {
  476. seq_printf(m, "      Master Capable.  ");
  477. if (latency)
  478. seq_printf(m, "Latency=%d.  ", latency);
  479. else
  480. seq_puts(m, "No bursts.  ");
  481. if (min_gnt)
  482. seq_printf(m, "Min Gnt=%d.", min_gnt);
  483. if (max_lat)
  484. seq_printf(m, "Max Lat=%d.", max_lat);
  485. seq_putc(m, 'n');
  486. }
  488. for (reg = 0; reg < 6; reg++) {
  489. struct resource *res = dev->resource + reg;
  490. unsigned long base, end, flags;
  492. base = res->start;
  493. end = res->end;
  494. flags = res->flags;
  495. if (!end)
  496. continue;
  498. if (flags & PCI_BASE_ADDRESS_SPACE_IO) {
  499. seq_printf(m, "      I/O at 0x%lx [0x%lx].n",
  500. base, end);
  501. } else {
  502. const char *pref, *type = "unknown";
  504. if (flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
  505. pref = "P";
  506. else
  507. pref = "Non-p";
  508. switch (flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
  509.       case PCI_BASE_ADDRESS_MEM_TYPE_32:
  510. type = "32 bit"; break;
  511.       case PCI_BASE_ADDRESS_MEM_TYPE_1M:
  512. type = "20 bit"; break;
  513.       case PCI_BASE_ADDRESS_MEM_TYPE_64:
  514. type = "64 bit"; break;
  515. }
  516. seq_printf(m, "      %srefetchable %s memory at "
  517.        "0x%lx [0x%lx].n", pref, type,
  518.        base,
  519.        end);
  520. }
  521. }
  522. return 0;
  523. }
  525. static struct seq_operations proc_pci_op = {
  526. start: pci_seq_start,
  527. next: pci_seq_next,
  528. stop: pci_seq_stop,
  529. show: show_dev_config
  530. };
  532. static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
  533. {
  534. return seq_open(file, &proc_bus_pci_devices_op);
  535. }
  536. static struct file_operations proc_bus_pci_dev_operations = {
  537. open: proc_bus_pci_dev_open,
  538. read: seq_read,
  539. llseek: seq_lseek,
  540. release: seq_release,
  541. };
  542. static int proc_pci_open(struct inode *inode, struct file *file)
  543. {
  544. return seq_open(file, &proc_pci_op);
  545. }
  546. static struct file_operations proc_pci_operations = {
  547. open: proc_pci_open,
  548. read: seq_read,
  549. llseek: seq_lseek,
  550. release: seq_release,
  551. };
  553. static int __init pci_proc_init(void)
  554. {
  555. if (pci_present()) {
  556. struct proc_dir_entry *entry;
  557. struct pci_dev *dev;
  558. proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
  559. entry = create_proc_entry("devices", 0, proc_bus_pci_dir);
  560. if (entry)
  561. entry->proc_fops = &proc_bus_pci_dev_operations;
  562. pci_for_each_dev(dev) {
  563. pci_proc_attach_device(dev);
  564. }
  565. entry = create_proc_entry("pci", 0, NULL);
  566. if (entry)
  567. entry->proc_fops = &proc_pci_operations;
  568. }
  569. return 0;
  570. }
  572. __initcall(pci_proc_init);