proc.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487
  1. /*
  2. * $Id: proc.c,v 1.1.1.1 2007/06/12 07:27:09 eyryu Exp $
  3. *
  4. * Procfs interface for the PCI bus.
  5. *
  6. * Copyright (c) 1997--1999 Martin Mares <mj@ucw.cz>
  7. */
  8. #include <linux/init.h>
  9. #include <linux/pci.h>
  10. #include <linux/module.h>
  11. #include <linux/proc_fs.h>
  12. #include <linux/seq_file.h>
  13. #include <linux/smp_lock.h>
  14. #include <asm/uaccess.h>
  15. #include <asm/byteorder.h>
  16. #include "pci.h"
  17. static int proc_initialized; /* = 0 */
  18. static loff_t
  19. proc_bus_pci_lseek(struct file *file, loff_t off, int whence)
  20. {
  21. loff_t new = -1;
  22. struct inode *inode = file->f_path.dentry->d_inode;
  23. mutex_lock(&inode->i_mutex);
  24. switch (whence) {
  25. case 0:
  26. new = off;
  27. break;
  28. case 1:
  29. new = file->f_pos + off;
  30. break;
  31. case 2:
  32. new = inode->i_size + off;
  33. break;
  34. }
  35. if (new < 0 || new > inode->i_size)
  36. new = -EINVAL;
  37. else
  38. file->f_pos = new;
  39. mutex_unlock(&inode->i_mutex);
  40. return new;
  41. }
  42. static ssize_t
  43. proc_bus_pci_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
  44. {
  45. const struct inode *ino = file->f_path.dentry->d_inode;
  46. const struct proc_dir_entry *dp = PDE(ino);
  47. struct pci_dev *dev = dp->data;
  48. unsigned int pos = *ppos;
  49. unsigned int cnt, size;
  50. /*
  51. * Normal users can read only the standardized portion of the
  52. * configuration space as several chips lock up when trying to read
  53. * undefined locations (think of Intel PIIX4 as a typical example).
  54. */
  55. if (capable(CAP_SYS_ADMIN))
  56. size = dev->cfg_size;
  57. else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
  58. size = 128;
  59. else
  60. size = 64;
  61. if (pos >= size)
  62. return 0;
  63. if (nbytes >= size)
  64. nbytes = size;
  65. if (pos + nbytes > size)
  66. nbytes = size - pos;
  67. cnt = nbytes;
  68. if (!access_ok(VERIFY_WRITE, buf, cnt))
  69. return -EINVAL;
  70. if ((pos & 1) && cnt) {
  71. unsigned char val;
  72. pci_user_read_config_byte(dev, pos, &val);
  73. __put_user(val, buf);
  74. buf++;
  75. pos++;
  76. cnt--;
  77. }
  78. if ((pos & 3) && cnt > 2) {
  79. unsigned short val;
  80. pci_user_read_config_word(dev, pos, &val);
  81. __put_user(cpu_to_le16(val), (unsigned short __user *) buf);
  82. buf += 2;
  83. pos += 2;
  84. cnt -= 2;
  85. }
  86. while (cnt >= 4) {
  87. unsigned int val;
  88. pci_user_read_config_dword(dev, pos, &val);
  89. __put_user(cpu_to_le32(val), (unsigned int __user *) buf);
  90. buf += 4;
  91. pos += 4;
  92. cnt -= 4;
  93. }
  94. if (cnt >= 2) {
  95. unsigned short val;
  96. pci_user_read_config_word(dev, pos, &val);
  97. __put_user(cpu_to_le16(val), (unsigned short __user *) buf);
  98. buf += 2;
  99. pos += 2;
  100. cnt -= 2;
  101. }
  102. if (cnt) {
  103. unsigned char val;
  104. pci_user_read_config_byte(dev, pos, &val);
  105. __put_user(val, buf);
  106. buf++;
  107. pos++;
  108. cnt--;
  109. }
  110. *ppos = pos;
  111. return nbytes;
  112. }
  113. static ssize_t
  114. proc_bus_pci_write(struct file *file, const char __user *buf, size_t nbytes, loff_t *ppos)
  115. {
  116. const struct inode *ino = file->f_path.dentry->d_inode;
  117. const struct proc_dir_entry *dp = PDE(ino);
  118. struct pci_dev *dev = dp->data;
  119. int pos = *ppos;
  120. int size = dev->cfg_size;
  121. int cnt;
  122. if (pos >= size)
  123. return 0;
  124. if (nbytes >= size)
  125. nbytes = size;
  126. if (pos + nbytes > size)
  127. nbytes = size - pos;
  128. cnt = nbytes;
  129. if (!access_ok(VERIFY_READ, buf, cnt))
  130. return -EINVAL;
  131. if ((pos & 1) && cnt) {
  132. unsigned char val;
  133. __get_user(val, buf);
  134. pci_user_write_config_byte(dev, pos, val);
  135. buf++;
  136. pos++;
  137. cnt--;
  138. }
  139. if ((pos & 3) && cnt > 2) {
  140. unsigned short val;
  141. __get_user(val, (unsigned short __user *) buf);
  142. pci_user_write_config_word(dev, pos, le16_to_cpu(val));
  143. buf += 2;
  144. pos += 2;
  145. cnt -= 2;
  146. }
  147. while (cnt >= 4) {
  148. unsigned int val;
  149. __get_user(val, (unsigned int __user *) buf);
  150. pci_user_write_config_dword(dev, pos, le32_to_cpu(val));
  151. buf += 4;
  152. pos += 4;
  153. cnt -= 4;
  154. }
  155. if (cnt >= 2) {
  156. unsigned short val;
  157. __get_user(val, (unsigned short __user *) buf);
  158. pci_user_write_config_word(dev, pos, le16_to_cpu(val));
  159. buf += 2;
  160. pos += 2;
  161. cnt -= 2;
  162. }
  163. if (cnt) {
  164. unsigned char val;
  165. __get_user(val, buf);
  166. pci_user_write_config_byte(dev, pos, val);
  167. buf++;
  168. pos++;
  169. cnt--;
  170. }
  171. *ppos = pos;
  172. return nbytes;
  173. }
  174. struct pci_filp_private {
  175. enum pci_mmap_state mmap_state;
  176. int write_combine;
  177. };
  178. static int proc_bus_pci_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
  179. {
  180. const struct proc_dir_entry *dp = PDE(inode);
  181. struct pci_dev *dev = dp->data;
  182. #ifdef HAVE_PCI_MMAP
  183. struct pci_filp_private *fpriv = file->private_data;
  184. #endif /* HAVE_PCI_MMAP */
  185. int ret = 0;
  186. switch (cmd) {
  187. case PCIIOC_CONTROLLER:
  188. ret = pci_domain_nr(dev->bus);
  189. break;
  190. #ifdef HAVE_PCI_MMAP
  191. case PCIIOC_MMAP_IS_IO:
  192. fpriv->mmap_state = pci_mmap_io;
  193. break;
  194. case PCIIOC_MMAP_IS_MEM:
  195. fpriv->mmap_state = pci_mmap_mem;
  196. break;
  197. case PCIIOC_WRITE_COMBINE:
  198. if (arg)
  199. fpriv->write_combine = 1;
  200. else
  201. fpriv->write_combine = 0;
  202. break;
  203. #endif /* HAVE_PCI_MMAP */
  204. default:
  205. ret = -EINVAL;
  206. break;
  207. };
  208. return ret;
  209. }
  210. #ifdef HAVE_PCI_MMAP
  211. static int proc_bus_pci_mmap(struct file *file, struct vm_area_struct *vma)
  212. {
  213. struct inode *inode = file->f_path.dentry->d_inode;
  214. const struct proc_dir_entry *dp = PDE(inode);
  215. struct pci_dev *dev = dp->data;
  216. struct pci_filp_private *fpriv = file->private_data;
  217. int ret;
  218. if (!capable(CAP_SYS_RAWIO))
  219. return -EPERM;
  220. ret = pci_mmap_page_range(dev, vma,
  221. fpriv->mmap_state,
  222. fpriv->write_combine);
  223. if (ret < 0)
  224. return ret;
  225. return 0;
  226. }
  227. static int proc_bus_pci_open(struct inode *inode, struct file *file)
  228. {
  229. struct pci_filp_private *fpriv = kmalloc(sizeof(*fpriv), GFP_KERNEL);
  230. if (!fpriv)
  231. return -ENOMEM;
  232. fpriv->mmap_state = pci_mmap_io;
  233. fpriv->write_combine = 0;
  234. file->private_data = fpriv;
  235. return 0;
  236. }
  237. static int proc_bus_pci_release(struct inode *inode, struct file *file)
  238. {
  239. kfree(file->private_data);
  240. file->private_data = NULL;
  241. return 0;
  242. }
  243. #endif /* HAVE_PCI_MMAP */
  244. static const struct file_operations proc_bus_pci_operations = {
  245. .llseek = proc_bus_pci_lseek,
  246. .read = proc_bus_pci_read,
  247. .write = proc_bus_pci_write,
  248. .ioctl = proc_bus_pci_ioctl,
  249. #ifdef HAVE_PCI_MMAP
  250. .open = proc_bus_pci_open,
  251. .release = proc_bus_pci_release,
  252. .mmap = proc_bus_pci_mmap,
  253. #ifdef HAVE_ARCH_PCI_GET_UNMAPPED_AREA
  254. .get_unmapped_area = get_pci_unmapped_area,
  255. #endif /* HAVE_ARCH_PCI_GET_UNMAPPED_AREA */
  256. #endif /* HAVE_PCI_MMAP */
  257. };
  258. /* iterator */
  259. static void *pci_seq_start(struct seq_file *m, loff_t *pos)
  260. {
  261. struct pci_dev *dev = NULL;
  262. loff_t n = *pos;
  263. for_each_pci_dev(dev) {
  264. if (!n--)
  265. break;
  266. }
  267. return dev;
  268. }
  269. static void *pci_seq_next(struct seq_file *m, void *v, loff_t *pos)
  270. {
  271. struct pci_dev *dev = v;
  272. (*pos)++;
  273. dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev);
  274. return dev;
  275. }
  276. static void pci_seq_stop(struct seq_file *m, void *v)
  277. {
  278. if (v) {
  279. struct pci_dev *dev = v;
  280. pci_dev_put(dev);
  281. }
  282. }
  283. static int show_device(struct seq_file *m, void *v)
  284. {
  285. const struct pci_dev *dev = v;
  286. const struct pci_driver *drv;
  287. int i;
  288. if (dev == NULL)
  289. return 0;
  290. drv = pci_dev_driver(dev);
  291. seq_printf(m, "%02x%02x\t%04x%04x\t%x",
  292. dev->bus->number,
  293. dev->devfn,
  294. dev->vendor,
  295. dev->device,
  296. dev->irq);
  297. /* Here should be 7 and not PCI_NUM_RESOURCES as we need to preserve compatibility */
  298. for (i=0; i<7; i++) {
  299. resource_size_t start, end;
  300. pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
  301. seq_printf(m, "\t%16llx",
  302. (unsigned long long)(start |
  303. (dev->resource[i].flags & PCI_REGION_FLAG_MASK)));
  304. }
  305. for (i=0; i<7; i++) {
  306. resource_size_t start, end;
  307. pci_resource_to_user(dev, i, &dev->resource[i], &start, &end);
  308. seq_printf(m, "\t%16llx",
  309. dev->resource[i].start < dev->resource[i].end ?
  310. (unsigned long long)(end - start) + 1 : 0);
  311. }
  312. seq_putc(m, '\t');
  313. if (drv)
  314. seq_printf(m, "%s", drv->name);
  315. seq_putc(m, '\n');
  316. return 0;
  317. }
  318. static struct seq_operations proc_bus_pci_devices_op = {
  319. .start = pci_seq_start,
  320. .next = pci_seq_next,
  321. .stop = pci_seq_stop,
  322. .show = show_device
  323. };
  324. static struct proc_dir_entry *proc_bus_pci_dir;
  325. int pci_proc_attach_device(struct pci_dev *dev)
  326. {
  327. struct pci_bus *bus = dev->bus;
  328. struct proc_dir_entry *e;
  329. char name[16];
  330. if (!proc_initialized)
  331. return -EACCES;
  332. if (!bus->procdir) {
  333. if (pci_proc_domain(bus)) {
  334. sprintf(name, "%04x:%02x", pci_domain_nr(bus),
  335. bus->number);
  336. } else {
  337. sprintf(name, "%02x", bus->number);
  338. }
  339. bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
  340. if (!bus->procdir)
  341. return -ENOMEM;
  342. }
  343. sprintf(name, "%02x.%x", PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
  344. e = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, bus->procdir);
  345. if (!e)
  346. return -ENOMEM;
  347. e->proc_fops = &proc_bus_pci_operations;
  348. e->data = dev;
  349. e->size = dev->cfg_size;
  350. dev->procent = e;
  351. return 0;
  352. }
  353. int pci_proc_detach_device(struct pci_dev *dev)
  354. {
  355. struct proc_dir_entry *e;
  356. if ((e = dev->procent)) {
  357. if (atomic_read(&e->count))
  358. return -EBUSY;
  359. remove_proc_entry(e->name, dev->bus->procdir);
  360. dev->procent = NULL;
  361. }
  362. return 0;
  363. }
  364. #if 0
  365. int pci_proc_attach_bus(struct pci_bus* bus)
  366. {
  367. struct proc_dir_entry *de = bus->procdir;
  368. if (!proc_initialized)
  369. return -EACCES;
  370. if (!de) {
  371. char name[16];
  372. sprintf(name, "%02x", bus->number);
  373. de = bus->procdir = proc_mkdir(name, proc_bus_pci_dir);
  374. if (!de)
  375. return -ENOMEM;
  376. }
  377. return 0;
  378. }
  379. #endif /* 0 */
  380. int pci_proc_detach_bus(struct pci_bus* bus)
  381. {
  382. struct proc_dir_entry *de = bus->procdir;
  383. if (de)
  384. remove_proc_entry(de->name, proc_bus_pci_dir);
  385. return 0;
  386. }
  387. static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
  388. {
  389. return seq_open(file, &proc_bus_pci_devices_op);
  390. }
  391. static const struct file_operations proc_bus_pci_dev_operations = {
  392. .open = proc_bus_pci_dev_open,
  393. .read = seq_read,
  394. .llseek = seq_lseek,
  395. .release = seq_release,
  396. };
  397. static int __init pci_proc_init(void)
  398. {
  399. struct proc_dir_entry *entry;
  400. struct pci_dev *dev = NULL;
  401. proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
  402. entry = create_proc_entry("devices", 0, proc_bus_pci_dir);
  403. if (entry)
  404. entry->proc_fops = &proc_bus_pci_dev_operations;
  405. proc_initialized = 1;
  406. while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
  407. pci_proc_attach_device(dev);
  408. }
  409. return 0;
  410. }
  411. __initcall(pci_proc_init);
  412. #ifdef CONFIG_HOTPLUG
  413. EXPORT_SYMBOL(pci_proc_attach_device);
  414. EXPORT_SYMBOL(pci_proc_detach_bus);
  415. #endif