drivers/pci/proc.c

Name: Public Git Hosting - davej-history.git/blob - drivers/pci/proc.c
Rating: 4.4 (9770 reviews)
 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@suse.cz>
 7  */
 8
 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
 15 #include <asm/uaccess.h>
 16 #include <asm/byteorder.h>
 17
 18 #define PCI_CFG_SPACE_SIZE 256
 19
 20 static loff_t
 21 proc_bus_pci_lseek(struct file *file, loff_t off,int whence)
 22 {
 23  loff_t new;
 24
 25 switch(whence) {
 26 case0:
 27 new= off;
 28 break;
 29 case1:
 30 new= file->f_pos + off;
 31 break;
 32 case2:
 33 new= PCI_CFG_SPACE_SIZE + off;
 34 break;
 35 default:
 36 return-EINVAL;
 37 }
 38 if(new<0||new> PCI_CFG_SPACE_SIZE)
 39 return-EINVAL;
 40 return(file->f_pos =new);
 41 }
 42
 43 static ssize_t
 44 proc_bus_pci_read(struct file *file,char*buf,size_t nbytes, loff_t *ppos)
 45 {
 46 const struct inode *ino = file->f_dentry->d_inode;
 47 const struct proc_dir_entry *dp = ino->u.generic_ip;
 48 struct pci_dev *dev = dp->data;
 49 unsigned int pos = *ppos;
 50 unsigned int cnt, size;
 51
 52 /*
 53  * Normal users can read only the standardized portion of the
 54  * configuration space as several chips lock up when trying to read
 55  * undefined locations (think of Intel PIIX4 as a typical example).
 56  */
 57
 58 if(capable(CAP_SYS_ADMIN))
 59  size = PCI_CFG_SPACE_SIZE;
 60 else if(dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
 61  size =128;
 62 else
 63  size =64;
 64
 65 if(pos >= size)
 66 return0;
 67 if(nbytes >= size)
 68  nbytes = size;
 69 if(pos + nbytes > size)
 70  nbytes = size - pos;
 71  cnt = nbytes;
 72
 73 if(!access_ok(VERIFY_WRITE, buf, cnt))
 74 return-EINVAL;
 75
 76 if((pos &1) && cnt) {
 77 unsigned char val;
 78 pci_read_config_byte(dev, pos, &val);
 79 __put_user(val, buf);
 80  buf++;
 81  pos++;
 82  cnt--;
 83 }
 84
 85 if((pos &3) && cnt >2) {
 86 unsigned short val;
 87 pci_read_config_word(dev, pos, &val);
 88 __put_user(cpu_to_le16(val), (unsigned short*) buf);
 89  buf +=2;
 90  pos +=2;
 91  cnt -=2;
 92 }
 93
 94 while(cnt >=4) {
 95 unsigned int val;
 96 pci_read_config_dword(dev, pos, &val);
 97 __put_user(cpu_to_le32(val), (unsigned int*) buf);
 98  buf +=4;
 99  pos +=4;
 100  cnt -=4;
 101 }
 102
 103 if(cnt >=2) {
 104 unsigned short val;
 105 pci_read_config_word(dev, pos, &val);
 106 __put_user(cpu_to_le16(val), (unsigned short*) buf);
 107  buf +=2;
 108  pos +=2;
 109  cnt -=2;
 110 }
 111
 112 if(cnt) {
 113 unsigned char val;
 114 pci_read_config_byte(dev, pos, &val);
 115 __put_user(val, buf);
 116  buf++;
 117  pos++;
 118  cnt--;
 119 }
 120
 121 *ppos = pos;
 122 return nbytes;
 123 }
 124
 125 static ssize_t
 126 proc_bus_pci_write(struct file *file,const char*buf,size_t nbytes, loff_t *ppos)
 127 {
 128 const struct inode *ino = file->f_dentry->d_inode;
 129 const struct proc_dir_entry *dp = ino->u.generic_ip;
 130 struct pci_dev *dev = dp->data;
 131 int pos = *ppos;
 132 int cnt;
 133
 134 if(pos >= PCI_CFG_SPACE_SIZE)
 135 return0;
 136 if(nbytes >= PCI_CFG_SPACE_SIZE)
 137  nbytes = PCI_CFG_SPACE_SIZE;
 138 if(pos + nbytes > PCI_CFG_SPACE_SIZE)
 139  nbytes = PCI_CFG_SPACE_SIZE - pos;
 140  cnt = nbytes;
 141
 142 if(!access_ok(VERIFY_READ, buf, cnt))
 143 return-EINVAL;
 144
 145 if((pos &1) && cnt) {
 146 unsigned char val;
 147 __get_user(val, buf);
 148 pci_write_config_byte(dev, pos, val);
 149  buf++;
 150  pos++;
 151  cnt--;
 152 }
 153
 154 if((pos &3) && cnt >2) {
 155 unsigned short val;
 156 __get_user(val, (unsigned short*) buf);
 157 pci_write_config_word(dev, pos,le16_to_cpu(val));
 158  buf +=2;
 159  pos +=2;
 160  cnt -=2;
 161 }
 162
 163 while(cnt >=4) {
 164 unsigned int val;
 165 __get_user(val, (unsigned int*) buf);
 166 pci_write_config_dword(dev, pos,le32_to_cpu(val));
 167  buf +=4;
 168  pos +=4;
 169  cnt -=4;
 170 }
 171
 172 if(cnt >=2) {
 173 unsigned short val;
 174 __get_user(val, (unsigned short*) buf);
 175 pci_write_config_word(dev, pos,le16_to_cpu(val));
 176  buf +=2;
 177  pos +=2;
 178  cnt -=2;
 179 }
 180
 181 if(cnt) {
 182 unsigned char val;
 183 __get_user(val, buf);
 184 pci_write_config_byte(dev, pos, val);
 185  buf++;
 186  pos++;
 187  cnt--;
 188 }
 189
 190 *ppos = pos;
 191 return nbytes;
 192 }
 193
 194 static struct file_operations proc_bus_pci_operations = {
 195  llseek: proc_bus_pci_lseek,
 196  read: proc_bus_pci_read,
 197  write: proc_bus_pci_write,
 198 };
 199
 200 #if BITS_PER_LONG == 32
 201 #define LONG_FORMAT"\t%08lx"
 202 #else
 203 #define LONG_FORMAT"\t%16lx"
 204 #endif
 205
 206 static int
 207 get_pci_dev_info(char*buf,char**start, off_t pos,int count)
 208 {
 209 const struct pci_dev *dev;
 210  off_t at =0;
 211 int len, i, cnt;
 212
 213  cnt =0;
 214 pci_for_each_dev(dev) {
 215 const struct pci_driver *drv =pci_dev_driver(dev);
 216  len =sprintf(buf,"%02x%02x\t%04x%04x\t%x",
 217  dev->bus->number,
 218  dev->devfn,
 219  dev->vendor,
 220  dev->device,
 221  dev->irq);
 222 /* Here should be 7 and not PCI_NUM_RESOURCES as we need to preserve compatibility */
 223 for(i=0; i<7; i++)
 224  len +=sprintf(buf+len, LONG_FORMAT,
 225  dev->resource[i].start | (dev->resource[i].flags & PCI_REGION_FLAG_MASK));
 226 for(i=0; i<7; i++)
 227  len +=sprintf(buf+len, LONG_FORMAT, dev->resource[i].start < dev->resource[i].end ?
 228  dev->resource[i].end - dev->resource[i].start +1:0);
 229  buf[len++] ='\t';
 230 if(drv)
 231  len +=sprintf(buf+len,"%s", drv->name);
 232  buf[len++] ='\n';
 233  at += len;
 234 if(at >= pos) {
 235 if(!*start) {
 236 *start = buf + (pos - (at - len));
 237  cnt = at - pos;
 238 }else
 239  cnt += len;
 240  buf += len;
 241 if(cnt >= count)
 242 /*
 243  * proc_file_read() gives us 1KB of slack so it's OK if the
 244  * above printfs write a little beyond the buffer end (we
 245  * never write more than 1KB beyond the buffer end).
 246  */
 247 break;
 248 }
 249 }
 250 return(count > cnt) ? cnt : count;
 251 }
 252
 253 static struct proc_dir_entry *proc_bus_pci_dir;
 254
 255 intpci_proc_attach_device(struct pci_dev *dev)
 256 {
 257 struct pci_bus *bus = dev->bus;
 258 struct proc_dir_entry *de, *e;
 259 char name[16];
 260
 261 if(!(de = bus->procdir)) {
 262 sprintf(name,"%02x", bus->number);
 263  de = bus->procdir =proc_mkdir(name, proc_bus_pci_dir);
 264 if(!de)
 265 return-ENOMEM;
 266 }
 267 sprintf(name,"%02x.%x",PCI_SLOT(dev->devfn),PCI_FUNC(dev->devfn));
 268  e = dev->procent =create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, de);
 269 if(!e)
 270 return-ENOMEM;
 271  e->proc_fops = &proc_bus_pci_operations;
 272  e->data = dev;
 273  e->size = PCI_CFG_SPACE_SIZE;
 274 return0;
 275 }
 276
 277 intpci_proc_detach_device(struct pci_dev *dev)
 278 {
 279 struct proc_dir_entry *e;
 280
 281 if((e = dev->procent)) {
 282 if(e->count)
 283 return-EBUSY;
 284 remove_proc_entry(e->name, dev->bus->procdir);
 285  dev->procent = NULL;
 286 }
 287 return0;
 288 }
 289
 290
 291 /*
 292  * Backward compatible /proc/pci interface.
 293  */
 294
 295 /*
 296  * Convert some of the configuration space registers of the device at
 297  * address (bus,devfn) into a string (possibly several lines each).
 298  * The configuration string is stored starting at buf[len]. If the
 299  * string would exceed the size of the buffer (SIZE), 0 is returned.
 300  */
 301 static intsprint_dev_config(struct pci_dev *dev,char*buf,int size)
 302 {
 303  u32 class_rev;
 304 unsigned char latency, min_gnt, max_lat, *class;
 305 int reg, len =0;
 306
 307 pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_rev);
 308 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &latency);
 309 pci_read_config_byte(dev, PCI_MIN_GNT, &min_gnt);
 310 pci_read_config_byte(dev, PCI_MAX_LAT, &max_lat);
 311 if(len +160> size)
 312 return-1;
 313  len +=sprintf(buf + len," Bus %2d, device %3d, function %2d:\n",
 314  dev->bus->number,PCI_SLOT(dev->devfn),PCI_FUNC(dev->devfn));
 315 class=pci_class_name(class_rev >>16);
 316 if(class)
 317  len +=sprintf(buf+len," %s",class);
 318 else
 319  len +=sprintf(buf+len," Class %04x", class_rev >>16);
 320  len +=sprintf(buf+len,": %s (rev %d).\n", dev->name, class_rev &0xff);
 321
 322 if(dev->irq) {
 323 if(len +40> size)
 324 return-1;
 325  len +=sprintf(buf + len," IRQ %d.\n", dev->irq);
 326 }
 327
 328 if(latency || min_gnt || max_lat) {
 329 if(len +80> size)
 330 return-1;
 331  len +=sprintf(buf + len," Master Capable. ");
 332 if(latency)
 333  len +=sprintf(buf + len,"Latency=%d. ", latency);
 334 else
 335  len +=sprintf(buf + len,"No bursts. ");
 336 if(min_gnt)
 337  len +=sprintf(buf + len,"Min Gnt=%d.", min_gnt);
 338 if(max_lat)
 339  len +=sprintf(buf + len,"Max Lat=%d.", max_lat);
 340  len +=sprintf(buf + len,"\n");
 341 }
 342
 343 for(reg =0; reg <6; reg++) {
 344 struct resource *res = dev->resource + reg;
 345 unsigned long base, end, flags;
 346
 347 if(len +40> size)
 348 return-1;
 349  base = res->start;
 350  end = res->end;
 351  flags = res->flags;
 352 if(!end)
 353 continue;
 354
 355 if(flags & PCI_BASE_ADDRESS_SPACE_IO) {
 356  len +=sprintf(buf + len,
 357 " I/O at 0x%lx [0x%lx].\n",
 358  base, end);
 359 }else{
 360 const char*pref, *type ="unknown";
 361
 362 if(flags & PCI_BASE_ADDRESS_MEM_PREFETCH)
 363  pref ="P";
 364 else
 365  pref ="Non-p";
 366 switch(flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
 367 case PCI_BASE_ADDRESS_MEM_TYPE_32:
 368  type ="32 bit";break;
 369 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
 370  type ="20 bit";break;
 371 case PCI_BASE_ADDRESS_MEM_TYPE_64:
 372  type ="64 bit";break;
 373 }
 374  len +=sprintf(buf + len,
 375 " %srefetchable %s memory at "
 376 "0x%lx [0x%lx].\n", pref, type,
 377  base,
 378  end);
 379 }
 380 }
 381
 382 return len;
 383 }
 384
 385 /*
 386  * Return list of PCI devices as a character string for /proc/pci.
 387  * BUF is a buffer that is PAGE_SIZE bytes long.
 388  */
 389 static intpci_read_proc(char*buf,char**start, off_t off,
 390 int count,int*eof,void*data)
 391 {
 392 int nprinted, len, begin =0;
 393 struct pci_dev *dev;
 394
 395  len =sprintf(buf,"PCI devices found:\n");
 396
 397 *eof =1;
 398 pci_for_each_dev(dev) {
 399  nprinted =sprint_dev_config(dev, buf + len, PAGE_SIZE - len);
 400 if(nprinted <0) {
 401 *eof =0;
 402 break;
 403 }
 404  len += nprinted;
 405 if(len+begin < off) {
 406  begin += len;
 407  len =0;
 408 }
 409 if(len+begin >= off+count)
 410 break;
 411 }
 412  off -= begin;
 413 *start = buf + off;
 414  len -= off;
 415 if(len>count)
 416  len = count;
 417 if(len<0)
 418  len =0;
 419 return len;
 420 }
 421
 422 static int __init pci_proc_init(void)
 423 {
 424 if(pci_present()) {
 425 struct pci_dev *dev;
 426  proc_bus_pci_dir =proc_mkdir("pci", proc_bus);
 427 create_proc_info_entry("devices",0, proc_bus_pci_dir,
 428  get_pci_dev_info);
 429 pci_for_each_dev(dev) {
 430 pci_proc_attach_device(dev);
 431 }
 432 create_proc_read_entry("pci",0, NULL, pci_read_proc, NULL);
 433 }
 434 return0;
 435 }
 436
 437 __initcall(pci_proc_init);