Hello all,

I have written the basics of a PCI driver. Currently all the driver does is register the device. It assigns the IRQ and I/O and memeory space. Below is the code.


#include <linux/pci.h> /* PCI specific functions */
#include <linux/kernel.h> /* printk() */

#define PCI_VENDOR_ID_OXFORD 0x1415
#define PCI_DEVICE_ID_OXFORD_FUN0 0x9501 /* Device ID for PCI Function 0 UARTs */
#define PCI_DEVICE_ID_OXFORD_FUN1 0x9511 /* Device ID for PCI Function 1 8-bit bus */
#define PCI_MAJOR_NUM 61 /* Major Number */



static int dev_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
int ret;
u16 venid;
u32 devid;

ret = pci_enable_device(dev); /*Enables the device and assigns the interrupt line*/
if (ret < 0) return ret;
pci_read_config_word(dev, 0x00, &venid); /*Reads the first 16 bits from configuration space*/
printk("Vendor ID= %#0.4x ",venid); /*Outputs the frist 16 bits of the config space (Vendor ID) in hex*/
pci_read_config_dword(dev, 0x00, &devid); /*Reads the first 32 bits from configuration space*/
devid = devid >> 16; /*Shifts the 32bits to the right 16*/
printk("Device ID= %#0.4x\n",devid); /*Outputs the shifted bits (or the last 16 bits of the config space (Device ID)*/


ret = pci_request_regions(dev, "MyPCIDevice");
if (ret < 0)
{
pci_disable_device(dev);
return ret;
}

return 0;
}



static void dev_remove(struct pci_dev *dev)
{

pci_release_regions(dev);
pci_disable_device(dev);

}

/* Table of device ID's the drive is interested in */
static struct pci_device_id ids[] = {
{ PCI_DEVICE(PCI_VENDOR_ID_OXFORD, PCI_DEVICE_ID_OXFORD_FUN0) },
{ PCI_DEVICE(PCI_VENDOR_ID_OXFORD, PCI_DEVICE_ID_OXFORD_FUN1) },
{ 0, }//end of list
};


static struct pci_driver pci_driver = {
.name = "MyPCIDevice",
.id_table = ids,
.probe = dev_probe,
.remove = dev_remove,
};

static int __init pci_init(void)
{
printk("Inserting Module\n");
return pci_register_driver(&pci_driver);
}

static void __exit pci_exit(void)
{
printk("Removing Module\n");
pci_unregister_driver(&pci_driver);
}


module_init(pci_init);
module_exit(pci_exit);

MODULE_AUTHOR("ADDITECH");
MODULE_DESCRIPTION("PCI Oxford Board Driver");
MODULE_LICENSE("Dual BSD/GPL");
MODULE_DEVICE_TABLE(pci, ids);




My question is how do I access this information outside of the probe function. I could assign the IRQ number to a global variable. I obviously don't like this approach so I was hoping there is another way. My issue is I don't understand what "dev" is in the probe function or how to access it outside of that function. Any help would be awesome.

You probably don't need to probe a PCI device; that is more for old ISA things. Look into pci_find_device().

To access the information outside, you could (for instance) printk it to the log file, or you could set up an entry in /proc or /sys for it. Look into create_proc_entry().

I usually will use a global variable for a global piece of information, such as the IRQ number. In fact, if my hardware permits interrupts to be disabled, then I will design my driver to enable/disable interrupts. In this case, I use the IRQ number value itself to determine whether interrupts are enabled; NULL if disabled, and containing a value if enabled. Using a global for this is not a problem; the IRQ is associated with the specific hardware and won't change.

For multiple instances of the hardware, replace the IRQ number with a pointer to a hardware configuration structure, then build a linked list to provide an instance of the structure for each piece of hardware that is present.