drivers/pci/syscall.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *      pci_syscall.c
   4  *
   5  * For architectures where we want to allow direct access
   6  * to the PCI config stuff - it would probably be preferable
   7  * on PCs too, but there people just do it by hand with the
   8  * magic northbridge registers..
   9  */
  10
  11 #include <linux/errno.h>
  12 #include <linux/pci.h>
  13 #include <linux/syscalls.h>
  14 #include <linux/uaccess.h>
  15 #include "pci.h"
  16
  17 SYSCALL_DEFINE5(pciconfig_read, unsigned long, bus, unsigned long, dfn,
  18                 unsigned long, off, unsigned long, len, void __user *, buf)
  19 {
  20         struct pci_dev *dev;
  21         u8 byte;
  22         u16 word;
  23         u32 dword;
  24         long err;
  25         int cfg_ret;
  26
  27         err = -EPERM;
  28         dev = NULL;
  29         if (!capable(CAP_SYS_ADMIN))
  30                 goto error;
  31
  32         err = -ENODEV;
  33         dev = pci_get_bus_and_slot(bus, dfn);
  34         if (!dev)
  35                 goto error;
  36
  37         switch (len) {
  38         case 1:
  39                 cfg_ret = pci_user_read_config_byte(dev, off, &byte);
  40                 break;
  41         case 2:
  42                 cfg_ret = pci_user_read_config_word(dev, off, &word);
  43                 break;
  44         case 4:
  45                 cfg_ret = pci_user_read_config_dword(dev, off, &dword);
  46                 break;
  47         default:
  48                 err = -EINVAL;
  49                 goto error;
  50         }
  51
  52         err = -EIO;
  53         if (cfg_ret)
  54                 goto error;
  55
  56         switch (len) {
  57         case 1:
  58                 err = put_user(byte, (unsigned char __user *)buf);
  59                 break;
  60         case 2:
  61                 err = put_user(word, (unsigned short __user *)buf);
  62                 break;
  63         case 4:
  64                 err = put_user(dword, (unsigned int __user *)buf);
  65                 break;
  66         }
  67         pci_dev_put(dev);
  68         return err;
  69
  70 error:
  71         /* ??? XFree86 doesn't even check the return value.  They
  72            just look for 0xffffffff in the output, since that's what
  73            they get instead of a machine check on x86.  */
  74         switch (len) {
  75         case 1:
  76                 put_user(-1, (unsigned char __user *)buf);
  77                 break;
  78         case 2:
  79                 put_user(-1, (unsigned short __user *)buf);
  80                 break;
  81         case 4:
  82                 put_user(-1, (unsigned int __user *)buf);
  83                 break;
  84         }
  85         pci_dev_put(dev);
  86         return err;
  87 }
  88
  89 SYSCALL_DEFINE5(pciconfig_write, unsigned long, bus, unsigned long, dfn,
  90                 unsigned long, off, unsigned long, len, void __user *, buf)
  91 {
  92         struct pci_dev *dev;
  93         u8 byte;
  94         u16 word;
  95         u32 dword;
  96         int err = 0;
  97
  98         if (!capable(CAP_SYS_ADMIN))
  99                 return -EPERM;
 100
 101         dev = pci_get_bus_and_slot(bus, dfn);
 102         if (!dev)
 103                 return -ENODEV;
 104
 105         switch (len) {
 106         case 1:
 107                 err = get_user(byte, (u8 __user *)buf);
 108                 if (err)
 109                         break;
 110                 err = pci_user_write_config_byte(dev, off, byte);
 111                 if (err)
 112                         err = -EIO;
 113                 break;
 114
 115         case 2:
 116                 err = get_user(word, (u16 __user *)buf);
 117                 if (err)
 118                         break;
 119                 err = pci_user_write_config_word(dev, off, word);
 120                 if (err)
 121                         err = -EIO;
 122                 break;
 123
 124         case 4:
 125                 err = get_user(dword, (u32 __user *)buf);
 126                 if (err)
 127                         break;
 128                 err = pci_user_write_config_dword(dev, off, dword);
 129                 if (err)
 130                         err = -EIO;
 131                 break;
 132
 133         default:
 134                 err = -EINVAL;
 135                 break;
 136         }
 137         pci_dev_put(dev);
 138         return err;
 139 }