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

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

Linux/Unix编程

开发平台：

Unix_Linux

pciba.c：源码内容
  1. /*
  2.  * arch/ia64/sn/io/pciba.c
  3.  *
  4.  * IRIX PCIBA-inspired user mode PCI interface
  5.  *
  6.  * requires: devfs
  7.  *
  8.  * device nodes show up in /dev/pci/BB/SS.F (where BB is the bus the
  9.  * device is on, SS is the slot the device is in, and F is the
  10.  * device's function on a multi-function card).
  11.  *
  12.  * when compiled into the kernel, it will only be initialized by the
  13.  * sgi sn1 specific initialization code.  in this case, device nodes
  14.  * are under /dev/hw/..../
  15.  *
  16.  * This file is subject to the terms and conditions of the GNU General
  17.  * Public License.  See the file "COPYING" in the main directory of
  18.  * this archive for more details.
  19.  *
  20.  * Copyright (C) 2001-2002 Silicon Graphics, Inc.  All rights reserved.
  21.  *
  22.  * 03262001 - Initial version by Chad Talbott
  23.  */
  26. /* jesse's beefs:
  28.    register_pci_device should be documented
  29.    
  30.    grossness with do_swap should be documented
  31.    
  32.    big, gross union'ized node_data should be replaced with independent
  33.    structures
  35.    replace global list of nodes with global lists of resources.  could
  36.    use object oriented approach of allocating and cleaning up
  37.    resources.
  38.    
  39. */
  42. #include <linux/config.h>
  43. #ifndef CONFIG_DEVFS_FS
  44. #  error PCIBA requires devfs
  45. #endif
  47. #include <linux/module.h>
  48. #include <linux/devfs_fs_kernel.h>
  49. #include <linux/pci.h>
  50. #include <linux/list.h>
  52. #include <linux/mm.h>
  53. #include <linux/slab.h>
  54. #include <linux/vmalloc.h>
  55. #include <linux/mman.h>
  56. #include <linux/init.h>
  57. #include <linux/raw.h>
  58. #include <linux/capability.h>
  60. #include <asm/uaccess.h>
  61. #include <asm/io.h>
  62. #include <asm/pgalloc.h>
  63. #include <asm/page.h>
  65. #include <asm/sn/pci/pciba.h>
  68. MODULE_DESCRIPTION("User mode PCI interface");
  69. MODULE_AUTHOR("Chad Talbott");
  72. #undef DEBUG_PCIBA
  73. /* #define DEBUG_PCIBA */
  75. #undef TRACE_PCIBA
  76. /* #define TRACE_PCIBA */
  78. #if defined(DEBUG_PCIBA)
  79. #  define DPRINTF(x...) printk(KERN_DEBUG x)
  80. #else
  81. #  define DPRINTF(x...)
  82. #endif
  84. #if defined(TRACE_PCIBA)
  85. #  if defined(__GNUC__)
  86. #    define TRACE() printk(KERN_DEBUG "%s:%d:%sn", 
  87.        __FILE__, __LINE__, __FUNCTION__)
  88. #  else
  89. #    define TRACE() printk(KERN_DEBUG "%s:%dn", __LINE__, __FILE__)
  90. #  endif
  91. #else
  92. #  define TRACE()
  93. #endif
  96. typedef enum { failure, success } status;
  97. typedef enum { false, true } boolean;
  100. /* major data structures:
  102.    struct node_data -
  103.    
  104.     one for each file registered with devfs.  contains everything
  105.     that any file's fops would need to know about.
  107.    struct dma_allocation -
  109.     a single DMA allocation.  only the 'dma' nodes care about
  110.     these.  they are there primarily to allow the driver to look
  111.     up the kernel virtual address of dma buffers allocated by
  112.     pci_alloc_consistent, as the application is only given the
  113.     physical address (to program the device's dma, presumably) and
  114.     cannot supply the kernel virtual address when freeing the
  115.     buffer.
  117. it's also useful to maintain a list of buffers allocated
  118. through a specific node to allow some sanity checking by this
  119. driver.  this prevents (for example) a broken application from
  120. freeing buffers that it didn't allocate, or buffers allocated
  121. on another node.
  122.    
  123.    global_node_list -
  125.     a list of all nodes allocated.  this allows the driver to free
  126.     all the memory it has 'kmalloc'd in case of an error, or on
  127.     module removal.
  129.    global_dma_list -
  131.         a list of all dma buffers allocated by this driver.  this
  132. allows the driver to 'pci_free_consistent' all buffers on
  133. module removal or error.
  135. */
  138. struct node_data {
  139. /* flat list of all the device nodes.  makes it easy to free
  140.    them all when we're unregistered */
  141. struct list_head global_node_list;
  142. devfs_handle_t devfs_handle;
  144. void (* cleanup)(struct node_data *);
  146. union {
  147. struct {
  148. struct pci_dev * dev;
  149. struct list_head dma_allocs;
  150. boolean mmapped;
  151. } dma;
  152. struct {
  153. struct pci_dev * dev;
  154. u32 saved_rom_base_reg;
  155. boolean mmapped;
  156. } rom;
  157. struct {
  158. struct resource * res;
  159. } base;
  160. struct {
  161. struct pci_dev * dev;
  162. } config;
  163. } u;
  164. };
  166. struct dma_allocation {
  167. struct list_head list;
  169. dma_addr_t handle;
  170. void * va;
  171. size_t size;
  172. };
  175. static LIST_HEAD(global_node_list);
  176. static LIST_HEAD(global_dma_list);
  179. /* module entry points */
  180. int __init pciba_init(void);
  181. void __exit pciba_exit(void);
  183. static status __init register_with_devfs(void);
  184. static void __exit unregister_with_devfs(void);
  186. static status __init register_pci_device(devfs_handle_t device_dir_handle,
  187.  struct pci_dev * dev);
  189. /* file operations */
  190. static int generic_open(struct inode * inode, struct file * file);
  191. static int rom_mmap(struct file * file, struct vm_area_struct * vma);
  192. static int rom_release(struct inode * inode, struct file * file);
  193. static int base_mmap(struct file * file, struct vm_area_struct * vma);
  194. static int config_ioctl(struct inode * inode, struct file * file, 
  195. unsigned int cmd, 
  196. unsigned long arg);
  197. static int dma_ioctl(struct inode * inode, struct file * file, 
  198.      unsigned int cmd, 
  199.      unsigned long arg);
  200. static int dma_mmap(struct file * file, struct vm_area_struct * vma);
  202. /* support routines */
  203. static int mmap_pci_address(struct vm_area_struct * vma, unsigned long pci_va);
  204. static int mmap_kernel_address(struct vm_area_struct * vma, void * kernel_va);
  206. #ifdef DEBUG_PCIBA
  207. static void dump_nodes(struct list_head * nodes);
  208. static void dump_allocations(struct list_head * dalp);
  209. #endif
  211. /* file operations for each type of node */
  212. static struct file_operations rom_fops = {
  213. owner: THIS_MODULE,
  214. mmap: rom_mmap,
  215. open: generic_open,
  216. release: rom_release
  217. };
  218.  
  220. static struct file_operations base_fops = {
  221. owner: THIS_MODULE,
  222. mmap: base_mmap,
  223. open: generic_open
  224. };
  227. static struct file_operations config_fops = {
  228. owner: THIS_MODULE,
  229. ioctl: config_ioctl,
  230. open: generic_open
  231. };
  233. static struct file_operations dma_fops = {
  234. owner: THIS_MODULE,
  235. ioctl: dma_ioctl,
  236. mmap: dma_mmap,
  237. open: generic_open
  238. };
  241. module_init(pciba_init);
  242. module_exit(pciba_exit);
  245. int __init
  246. pciba_init(void)
  247. {
  248. TRACE();
  250. if (register_with_devfs() == failure)
  251. return 1; /* failure */
  253. printk("PCIBA (a user mode PCI interface) initialized.n");
  255. return 0; /* success */
  256. }
  259. void __exit
  260. pciba_exit(void)
  261. {
  262. TRACE();
  264. /* FIXME: should also free all that memory that we allocated
  265.            ;) */
  266. unregister_with_devfs();
  267. }
  270. # if 0
  271. static void __exit
  272. free_nodes(void)
  273. {
  274. struct node_data * nd;
  276. TRACE();
  278. list_for_each(nd, &node_list) {
  279. kfree(list_entry(nd, struct nd, node_list));
  280. }
  281. }
  282. #endif
  285. static devfs_handle_t pciba_devfs_handle;
  288. #if !defined(CONFIG_IA64_SGI_SN1)
  290. static status __init
  291. register_with_devfs(void)
  292. {
  293. struct pci_dev * dev;
  294. devfs_handle_t device_dir_handle;
  295. char devfs_path[40];
  297. TRACE();
  299. pciba_devfs_handle = devfs_mk_dir(NULL, "pci", NULL);
  300. if (pciba_devfs_handle == NULL)
  301. return failure;
  303. /* FIXME: don't forget /dev/pci/mem & /dev/pci/io */
  305. pci_for_each_dev(dev) {
  306. sprintf(devfs_path, "%02x/%02x.%x",
  307. dev->bus->number,
  308. PCI_SLOT(dev->devfn),
  309. PCI_FUNC(dev->devfn));
  310.     
  311. device_dir_handle =
  312. devfs_mk_dir(pciba_devfs_handle, devfs_path, NULL);
  313. if (device_dir_handle == NULL)
  314. return failure;
  316. if (register_pci_device(device_dir_handle, dev) == failure) {
  317. devfs_unregister(pciba_devfs_handle);
  318. return failure;
  319. }
  320. }
  322. return success;
  323. }
  325. #else
  327. extern devfs_handle_t
  328. devfn_to_vertex(unsigned char busnum, unsigned int devfn);
  330. static status __init
  331. register_with_devfs(void)
  332. {
  333. struct pci_dev * dev;
  334. devfs_handle_t device_dir_handle;
  336. TRACE();
  338. /* FIXME: don't forget /dev/.../pci/mem & /dev/.../pci/io */
  340. pci_for_each_dev(dev) {
  341. device_dir_handle = devfn_to_vertex(dev->bus->number,
  342.     dev->devfn);
  343. if (device_dir_handle == NULL)
  344. return failure;
  346. if (register_pci_device(device_dir_handle, dev) == failure) {
  347. devfs_unregister(pciba_devfs_handle);
  348. return failure;
  349. }
  350. }
  352. return success;
  353. }
  355. #endif /* CONFIG_IA64_SGI_SN1 */
  358. static void __exit
  359. unregister_with_devfs(void)
  360. {
  361. struct list_head * lhp;
  362. struct node_data * nd;
  364. TRACE();
  366. list_for_each(lhp, &global_node_list) {
  367. nd = list_entry(lhp, struct node_data, global_node_list);
  368. devfs_unregister(nd->devfs_handle);
  369. }
  371. }
  374. struct node_data * new_node(void)
  375. {
  376. struct node_data * node;
  378. TRACE();
  380. node = kmalloc(sizeof(struct node_data), GFP_KERNEL);
  381. if (node == NULL)
  382. return NULL;
  383. list_add(&node->global_node_list, &global_node_list);
  384. return node;
  385. }
  388. void dma_cleanup(struct node_data * dma_node)
  389. {
  390. TRACE();
  392. /* FIXME: should free these allocations */
  393. #ifdef DEBUG_PCIBA
  394. dump_allocations(&dma_node->u.dma.dma_allocs);
  395. #endif
  396. devfs_unregister(dma_node->devfs_handle);
  397. }
  400. void init_dma_node(struct node_data * node,
  401.    struct pci_dev * dev, devfs_handle_t dh)
  402. {
  403. TRACE();
  405. node->devfs_handle = dh;
  406. node->u.dma.dev = dev;
  407. node->cleanup = dma_cleanup;
  408. INIT_LIST_HEAD(&node->u.dma.dma_allocs);
  409. }
  412. void rom_cleanup(struct node_data * rom_node)
  413. {
  414. TRACE();
  416. if (rom_node->u.rom.mmapped)
  417. pci_write_config_dword(rom_node->u.rom.dev,
  418.        PCI_ROM_ADDRESS,
  419.        rom_node->u.rom.saved_rom_base_reg);
  420. devfs_unregister(rom_node->devfs_handle);
  421. }
  424. void init_rom_node(struct node_data * node,
  425.    struct pci_dev * dev, devfs_handle_t dh)
  426. {
  427. TRACE();
  429. node->devfs_handle = dh;
  430. node->u.rom.dev = dev;
  431. node->cleanup = rom_cleanup;
  432. node->u.rom.mmapped = false;
  433. }
  436. static status __init
  437. register_pci_device(devfs_handle_t device_dir_handle, struct pci_dev * dev)
  438. {
  439. struct node_data * nd;
  440. char devfs_path[20];
  441. devfs_handle_t node_devfs_handle;
  442. int ri;
  444. TRACE();
  447. /* register nodes for all the device's base address registers */
  448. for (ri = 0; ri < PCI_ROM_RESOURCE; ri++) {
  449. if (pci_resource_len(dev, ri) != 0) {
  450. sprintf(devfs_path, "base/%d", ri);
  451. if (devfs_register(device_dir_handle, devfs_path,
  452.    DEVFS_FL_NONE,
  453.    0, 0,
  454.    S_IFREG | S_IRUSR | S_IWUSR,
  455.    &base_fops, 
  456.    &dev->resource[ri]) == NULL)
  457. return failure;
  458. }
  459. }
  461. /* register a node corresponding to the first MEM resource on
  462.            the device */
  463. for (ri = 0; ri < PCI_ROM_RESOURCE; ri++) {
  464. if (dev->resource[ri].flags & IORESOURCE_MEM &&
  465.     pci_resource_len(dev, ri) != 0) {
  466. if (devfs_register(device_dir_handle, "mem",
  467.    DEVFS_FL_NONE, 0, 0,
  468.    S_IFREG | S_IRUSR | S_IWUSR,
  469.    &base_fops, 
  470.    &dev->resource[ri]) == NULL)
  471. return failure;
  472. break;
  473. }
  474. }
  476. /* also register a node corresponding to the first IO resource
  477.            on the device */
  478. for (ri = 0; ri < PCI_ROM_RESOURCE; ri++) {
  479. if (dev->resource[ri].flags & IORESOURCE_IO &&
  480.     pci_resource_len(dev, ri) != 0) {
  481. if (devfs_register(device_dir_handle, "io",
  482.    DEVFS_FL_NONE, 0, 0,
  483.    S_IFREG | S_IRUSR | S_IWUSR,
  484.    &base_fops, 
  485.    &dev->resource[ri]) == NULL)
  486. return failure;
  487. break;
  488. }
  489. }
  491. /* register a node corresponding to the device's ROM resource,
  492.            if present */
  493. if (pci_resource_len(dev, PCI_ROM_RESOURCE) != 0) {
  494. nd = new_node();
  495. if (nd == NULL)
  496. return failure;
  497. node_devfs_handle = devfs_register(device_dir_handle, "rom",
  498.    DEVFS_FL_NONE, 0, 0,
  499.    S_IFREG | S_IRUSR,
  500.    &rom_fops, nd);
  501. if (node_devfs_handle == NULL)
  502. return failure;
  503. init_rom_node(nd, dev, node_devfs_handle);
  504. }
  506. /* register a node that allows ioctl's to read and write to
  507.            the device's config space */
  508. if (devfs_register(device_dir_handle, "config", DEVFS_FL_NONE,
  509.    0, 0, S_IFREG | S_IRUSR | S_IWUSR,
  510.    &config_fops, dev) == NULL)
  511. return failure;
  514. /* finally, register a node that allows ioctl's to allocate
  515.            and free DMA buffers, as well as memory map those
  516.            buffers. */
  517. nd = new_node();
  518. if (nd == NULL)
  519. return failure;
  520. node_devfs_handle =
  521. devfs_register(device_dir_handle, "dma", DEVFS_FL_NONE,
  522.        0, 0, S_IFREG | S_IRUSR | S_IWUSR,
  523.        &dma_fops, nd);
  524. if (node_devfs_handle == NULL)
  525. return failure;
  526. init_dma_node(nd, dev, node_devfs_handle);
  528. #ifdef DEBUG_PCIBA
  529. dump_nodes(&global_node_list);
  530. #endif
  532. return success;
  533. }
  536. static int
  537. generic_open(struct inode * inode, struct file * file)
  538. {
  539. TRACE();
  541. /* FIXME: should check that they're not trying to open the ROM
  542.            writable */
  544. return 0; /* success */
  545. }
  548. static int
  549. rom_mmap(struct file * file, struct vm_area_struct * vma)
  550. {
  551. unsigned long pci_pa;
  552. struct node_data * nd;
  554. TRACE();
  556. nd = (struct node_data * )file->private_data;
  558. pci_pa = pci_resource_start(nd->u.rom.dev, PCI_ROM_RESOURCE);
  560. if (!nd->u.rom.mmapped) {
  561. nd->u.rom.mmapped = true;
  562. DPRINTF("Enabling ROM address decoder.n");
  563. DPRINTF(
  564. "rom_mmap: FIXME: some cards do not allow both ROM and memory addresses ton"
  565. "rom_mmap: FIXME: be enabled simultaneously, as they share a decoder.n");
  566. pci_read_config_dword(nd->u.rom.dev, PCI_ROM_ADDRESS,
  567.       &nd->u.rom.saved_rom_base_reg);
  568. DPRINTF("ROM base address contains %xn",
  569. nd->u.rom.saved_rom_base_reg);
  570. pci_write_config_dword(nd->u.rom.dev, PCI_ROM_ADDRESS,
  571.        nd->u.rom.saved_rom_base_reg |
  572.        PCI_ROM_ADDRESS_ENABLE);
  573. }
  575. return mmap_pci_address(vma, pci_pa);
  576. }
  579. static int
  580. rom_release(struct inode * inode, struct file * file)
  581. {
  582. struct node_data * nd;
  584. TRACE();
  586. nd = (struct node_data * )file->private_data;
  588. if (nd->u.rom.mmapped) {
  589. nd->u.rom.mmapped = false;
  590. DPRINTF("Disabling ROM address decoder.n");
  591. pci_write_config_dword(nd->u.rom.dev, PCI_ROM_ADDRESS,
  592.        nd->u.rom.saved_rom_base_reg);
  593. }
  594. return 0; /* indicate success */
  595. }
  598. static int
  599. base_mmap(struct file * file, struct vm_area_struct * vma)
  600. {
  601. struct resource * resource;
  603. TRACE();
  605. resource = (struct resource *)file->private_data;
  607. return mmap_pci_address(vma, resource->start);
  608. }
  611. static int
  612. config_ioctl(struct inode * inode, struct file * file, 
  613.      unsigned int cmd, 
  614.      unsigned long arg)
  615. {
  616. struct pci_dev * dev;
  618. union cfg_data {
  619. uint8_t byte;
  620. uint16_t word;
  621. uint32_t dword;
  622. } read_data, write_data;
  624. int dir, size, offset;
  626. TRACE();
  628. DPRINTF("cmd = %x (DIR = %x, TYPE = %x, NR = %x, SIZE = %x)n", 
  629. cmd, 
  630. _IOC_DIR(cmd), _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd));
  631. DPRINTF("arg = %lxn", arg);
  633. dev = (struct pci_dev *)file->private_data;
  635. /* PCIIOCCFG{RD,WR}: read and/or write PCI configuration
  636.    space. If both, the read happens first (this becomes a swap
  637.    operation, atomic with respect to other updates through
  638.    this path).  */
  640. dir = _IOC_DIR(cmd);
  642. #define do_swap(suffix, type)  
  643. do {
  644. if (dir & _IOC_READ) {
  645. pci_read_config_##suffix(dev, _IOC_NR(cmd), 
  646.  &read_data.suffix);
  647. }
  648. if (dir & _IOC_WRITE) {
  649. get_user(write_data.suffix, (type)arg);
  650. pci_write_config_##suffix(dev, _IOC_NR(cmd), 
  651.   write_data.suffix);
  652. }
  653. if (dir & _IOC_READ) {
  654. put_user(read_data.suffix, (type)arg);
  655. }
  656. } while (0)
  658. size = _IOC_SIZE(cmd);
  659. offset = _IOC_NR(cmd);
  661. DPRINTF("sanity checkn");
  662. if (((size > 0) || (size <= 4)) &&
  663.     ((offset + size) <= 256) &&
  664.     (dir & (_IOC_READ | _IOC_WRITE))) {
  666. switch (size)
  667. {
  668. case 1:
  669. do_swap(byte, uint8_t *);
  670. break;
  671. case 2:
  672. do_swap(word, uint16_t *);
  673. break;
  674. case 4:
  675. do_swap(dword, uint32_t *);
  676. break;
  677. default:
  678. DPRINTF("invalid ioctln");
  679. return -EINVAL;
  680. }
  681. } else
  682. return -EINVAL;
  684. return 0;
  685. }
  688. #ifdef DEBUG_PCIBA
  689. static void
  690. dump_allocations(struct list_head * dalp)
  691. {
  692. struct dma_allocation * dap;
  693. struct list_head * p;
  695. printk("{n");
  696. list_for_each(p, dalp) {
  697. dap = list_entry(p, struct dma_allocation, 
  698.  list);
  699. printk("  handle = %lx, va = %pn",
  700.        dap->handle, dap->va);
  701. }
  702. printk("}n");
  703. }
  705. static void
  706. dump_nodes(struct list_head * nodes)
  707. {
  708. struct node_data * ndp;
  709. struct list_head * p;
  711. printk("{n");
  712. list_for_each(p, nodes) {
  713. ndp = list_entry(p, struct node_data, 
  714.  global_node_list);
  715. printk("  %pn", (void *)ndp);
  716. }
  717. printk("}n");
  718. }
  721. #if 0
  722. #define NEW(ptr) (ptr = kmalloc(sizeof (*(ptr)), GFP_KERNEL))
  724. static void
  725. test_list(void)
  726. {
  727. u64 i;
  728. LIST_HEAD(the_list);
  730. for (i = 0; i < 5; i++) {
  731. struct dma_allocation * new_alloc;
  732. NEW(new_alloc);
  733. new_alloc->va = (void *)i;
  734. new_alloc->handle = 5*i;
  735. printk("%d - the_list->next = %lxn", i, the_list.next);
  736. list_add(&new_alloc->list, &the_list);
  737. }
  738. dump_allocations(&the_list);
  739. }
  740. #endif
  741. #endif
  744. static LIST_HEAD(dma_buffer_list);
  747. static int
  748. dma_ioctl(struct inode * inode, struct file * file, 
  749.   unsigned int cmd, 
  750.   unsigned long arg)
  751. {
  752. struct node_data * nd;
  753. uint64_t argv;
  754. int result;
  755. struct dma_allocation * dma_alloc;
  756. struct list_head * iterp;
  758. TRACE();
  760. DPRINTF("cmd = %xn", cmd);
  761. DPRINTF("arg = %lxn", arg);
  763. nd = (struct node_data *)file->private_data;
  765. #ifdef DEBUG_PCIBA
  766. DPRINTF("at dma_ioctl entryn");
  767. dump_allocations(&nd->u.dma.dma_allocs);
  768. #endif
  770. switch (cmd) {
  771. case PCIIOCDMAALLOC:
  772. /* PCIIOCDMAALLOC: allocate a chunk of physical memory
  773.    and set it up for DMA. Return the PCI address that
  774.    gets to it.  */
  775. DPRINTF("case PCIIOCDMAALLOC (%lx)n", PCIIOCDMAALLOC);
  777. if ( (result = get_user(argv, (uint64_t *)arg)) )
  778. return result;
  779. DPRINTF("argv (size of buffer) = %lxn", argv);
  781. dma_alloc = (struct dma_allocation *)
  782. kmalloc(sizeof(struct dma_allocation), GFP_KERNEL);
  783. if (dma_alloc == NULL)
  784. return -ENOMEM;
  786. dma_alloc->size = (size_t)argv;
  787. dma_alloc->va = pci_alloc_consistent(nd->u.dma.dev,
  788.      dma_alloc->size,
  789.      &dma_alloc->handle);
  790. DPRINTF("dma_alloc->va = %p, dma_alloc->handle = %lxn",
  791. dma_alloc->va, dma_alloc->handle);
  792. if (dma_alloc->va == NULL) {
  793. kfree(dma_alloc);
  794. return -ENOMEM;
  795. }
  797. list_add(&dma_alloc->list, &nd->u.dma.dma_allocs);
  798. if ( (result = put_user((uint64_t)dma_alloc->handle, 
  799.       (uint64_t *)arg)) ) {
  800. DPRINTF("put_user failedn");
  801. pci_free_consistent(nd->u.dma.dev, (size_t)argv,
  802.     dma_alloc->va, dma_alloc->handle);
  803. kfree(dma_alloc);
  804. return result;
  805. }
  807. #ifdef DEBUG_PCIBA
  808. DPRINTF("after insertionn");
  809. dump_allocations(&nd->u.dma.dma_allocs);
  810. #endif
  811. break;
  813. case PCIIOCDMAFREE:
  814. DPRINTF("case PCIIOCDMAFREE (%lx)n", PCIIOCDMAFREE);
  816. if ( (result = get_user(argv, (uint64_t *)arg)) ) {
  817. DPRINTF("get_user failedn");
  818. return result;
  819. }
  821. DPRINTF("argv (physical address of DMA buffer) = %lxn", argv);
  822. list_for_each(iterp, &nd->u.dma.dma_allocs) {
  823. struct dma_allocation * da =
  824. list_entry(iterp, struct dma_allocation, list);
  825. if (da->handle == argv) {
  826. pci_free_consistent(nd->u.dma.dev, da->size,
  827.     da->va, da->handle);
  828. list_del(&da->list);
  829. kfree(da);
  830. #ifdef DEBUG_PCIBA
  831. DPRINTF("after deletionn");
  832. dump_allocations(&nd->u.dma.dma_allocs);
  833. #endif
  834. return 0; /* success */
  835. }
  836. }
  837. /* previously allocated dma buffer wasn't found */
  838. DPRINTF("attempt to free invalid dma handlen");
  839. return -EINVAL;
  841. default:
  842. DPRINTF("undefined ioctln");
  843. return -EINVAL;
  844. }
  846. DPRINTF("successn");
  847. return 0;
  848. }
  851. static int
  852. dma_mmap(struct file * file, struct vm_area_struct * vma)
  853. {
  854. struct node_data * nd;
  855. struct list_head * iterp;
  856. int result;
  858. TRACE();
  860. nd = (struct node_data *)file->private_data;
  862. DPRINTF("vma->vm_start is %lxn", vma->vm_start);
  863. DPRINTF("vma->vm_end is %lxn", vma->vm_end);
  864. DPRINTF("offset = %lxn", vma->vm_pgoff);
  866. /* get kernel virtual address for the dma buffer (necessary
  867.  * for the mmap). */
  868. list_for_each(iterp, &nd->u.dma.dma_allocs) {
  869. struct dma_allocation * da =
  870. list_entry(iterp, struct dma_allocation, list);
  871. /* why does mmap shift its offset argument? */
  872. if (da->handle == vma->vm_pgoff << PAGE_SHIFT) {
  873. DPRINTF("found dma handlen");
  874. if ( (result = mmap_kernel_address(vma,
  875.    da->va)) ) {
  876. return result; /* failure */
  877. } else {
  878. /* it seems like at least one of these
  879.    should show up in user land....
  880.    I'm missing something */
  881. *(char *)da->va = 0xaa;
  882. strncpy(da->va, "        Toastie!", da->size);
  883. if (put_user(0x18badbeeful,
  884.      (u64 *)vma->vm_start))
  885. DPRINTF("put_user failed?!n");
  886. return 0; /* success */
  887. }
  889. }
  890. }
  891. DPRINTF("attempt to mmap an invalid dma handlen");
  892. return -EINVAL;
  893. }
  896. static int
  897. mmap_pci_address(struct vm_area_struct * vma, unsigned long pci_va)
  898. {
  899. unsigned long pci_pa;
  901. TRACE();
  903. DPRINTF("vma->vm_start is %lxn", vma->vm_start);
  904. DPRINTF("vma->vm_end is %lxn", vma->vm_end);
  906. /* the size of the vma doesn't necessarily correspond to the
  907.            size specified in the mmap call.  So we can't really do any
  908.            kind of sanity check here.  This is a dangerous driver, and
  909.            it's very easy for a user process to kill the machine.  */
  911. DPRINTF("PCI base at virtual address %lxn", pci_va);
  912. /* the __pa macro is intended for region 7 on IA64, so it
  913.    doesn't work for region 6 */
  914.    /* pci_pa = __pa(pci_va); */
  915. /* should be replaced by __tpa or equivalent (preferably a
  916.    generic equivalent) */
  917. pci_pa = pci_va & ~0xe000000000000000ul;
  918. DPRINTF("PCI base at physical address %lxn", pci_pa);
  920. /* there are various arch-specific versions of this function
  921.            defined in linux/drivers/char/mem.c, but it would be nice
  922.            if all architectures put it in pgtable.h.  it's defined
  923.            there for ia64.... */
  924. vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
  926. vma->vm_flags |= VM_NONCACHED | VM_RESERVED | VM_IO;
  928. return io_remap_page_range(vma->vm_start, pci_pa, 
  929.    vma->vm_end-vma->vm_start,
  930.    vma->vm_page_prot);
  931. }
  934. static int
  935. mmap_kernel_address(struct vm_area_struct * vma, void * kernel_va)
  936. {
  937. unsigned long kernel_pa;
  939. TRACE();
  941. DPRINTF("vma->vm_start is %lxn", vma->vm_start);
  942. DPRINTF("vma->vm_end is %lxn", vma->vm_end);
  944. /* the size of the vma doesn't necessarily correspond to the
  945.            size specified in the mmap call.  So we can't really do any
  946.            kind of sanity check here.  This is a dangerous driver, and
  947.            it's very easy for a user process to kill the machine.  */
  949. DPRINTF("mapping virtual address %pn", kernel_va);
  950. kernel_pa = __pa(kernel_va);
  951. DPRINTF("mapping physical address %lxn", kernel_pa);
  953. vma->vm_flags |= VM_NONCACHED | VM_RESERVED | VM_IO;
  955. return remap_page_range(vma->vm_start, kernel_pa, 
  956. vma->vm_end-vma->vm_start,
  957. vma->vm_page_prot);
  958. }