lkml.org 
[lkml]   [2005]   [Sep]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: PCI driver
    Rolf Eike Beer wrote:

    >That is true, but you should not call pci_get_device() in this function at
    >all.
    >
    >
    >
    I reworked the whole thing over .. but i am feeling that something's a
    bit wrong somewhere ..

    The log i get on a load - unload ..

    [ 102.261264] mantis_pci_probe: Got a device
    [ 102.262852] mantis_pci_probe: We got an IRQ
    [ 102.264392] mantis_pci_probe: We finally enabled the device
    [ 102.266020] Mantis Rev 1, irq: 23, latency: 32
    [ 102.266118] memory: 0xefeff000, mmio: f9218000
    [ 102.269162] Trying to free free IRQ23
    [ 110.297341] mantis_pci_remove: Removing -->Mantis irq: 23,
    latency: 32
    [ 110.297344] memory: 0xefeff000, mmio: 0xf9218000
    [ 110.301326] Trying to free free IRQ23
    [ 110.303445] Trying to free nonexistent resource <efeff000-efefffff>


    #include <asm/io.h>
    #include <asm/pgtable.h>
    #include <asm/page.h>
    #include <linux/interrupt.h>
    #include <linux/kmod.h>
    #include <linux/vmalloc.h>
    #include <linux/init.h>
    #include <linux/sched.h>
    #include <linux/device.h>
    #include "mantis_common.h"
    #include "mantis_dma.h"
    #include "mantis_i2c.h"
    #include "mantis_eeprom.h"

    #define DRIVER_NAME "Mantis"

    static struct pci_device_id mantis_pci_table[] = {
    { PCI_DEVICE(PCI_VENDOR_ID_MANTIS, PCI_DEVICE_ID_MANTIS_R11) },
    { 0 },
    };

    MODULE_DEVICE_TABLE(pci, mantis_pci_table);

    static irqreturn_t mantis_pci_irq(int irq, void *dev_id, struct pt_regs
    *regs)
    {
    struct mantis_pci *mantis;

    dprintk(verbose, MANTIS_DEBUG, 1, "Mantis PCI IRQ");
    mantis = (struct mantis_pci *) dev_id;
    if (mantis == NULL)
    dprintk(verbose, MANTIS_DEBUG, 1, "Aeio, mantis ISR");

    /* Events
    * (1) PCMCIA insert
    * (2) PCMCIA extract
    * (3) I2C complete
    */

    return IRQ_HANDLED;
    }

    static int mantis_i2c_setup(struct mantis_pci *mantis)
    {
    u32 config = 0;

    // mmwrite(0x80, MANTIS_DMA_CTL); // MCU i2c read
    config = mmread(MANTIS_DMA_CTL);
    dprintk(verbose, MANTIS_DEBUG, 1, "Mantis Ctl reg=0x%04x", config);

    return 0;
    }

    static int mantis_reg_dump(struct mantis_pci *mantis)
    {
    u32 ctlreg, intstat, intmask, i2cdata;

    ctlreg = mmread(MANTIS_DMA_CTL);
    intstat = mmread(MANTIS_INT_STAT);
    intmask = mmread(MANTIS_INT_MASK);
    i2cdata = mmread(MANTIS_I2C_DATA);
    dprintk(verbose, MANTIS_DEBUG, 1, "CTL_REG=0x%04x, INT_STAT=0x%04x, \
    INT_MASK=0x%04x, I2C_DATA=0x%04x", ctlreg, intstat, \
    intmask, i2cdata);

    return 0;
    }

    static int __devinit mantis_pci_probe(struct pci_dev *pdev,
    const struct pci_device_id *mantis_pci_table)
    {
    u8 revision, latency;
    // u8 data[2];
    struct mantis_pci *mantis;
    mantis = (struct mantis_pci *)
    kmalloc(sizeof (struct mantis_pci), GFP_KERNEL);
    if (mantis == NULL) {
    dprintk(verbose, MANTIS_ERROR, 1, "Out of memory");
    return -ENOMEM;
    }
    dprintk(verbose, MANTIS_ERROR, 1, "Got a device");
    mantis->mantis_addr = pci_resource_start(pdev, 0);
    if (!request_mem_region(pci_resource_start(pdev, 0),
    pci_resource_len(pdev, 0), DRIVER_NAME)) {
    dprintk(verbose, MANTIS_ERROR, 1, "Request mem region failed");
    goto err0;
    }
    if ((mantis->mantis_mmio =
    ioremap(mantis->mantis_addr, 0x1000)) == NULL) {
    dprintk(verbose, MANTIS_ERROR, 1, "IO remap failed");
    goto err1;
    }
    if (request_irq(pdev->irq, mantis_pci_irq, SA_SHIRQ |
    SA_INTERRUPT, DRIVER_NAME, mantis) < 0) {
    dprintk(verbose, MANTIS_ERROR, 1, "Mantis IRQ reg failed");
    goto err2;
    }
    dprintk(verbose, MANTIS_DEBUG, 1, "We got an IRQ");
    if (pci_enable_device(pdev)) {
    dprintk(verbose, MANTIS_ERROR, 1, "Mantis PCI enable failed");
    goto err3;
    }
    dprintk(verbose, MANTIS_DEBUG, 1, "We finally enabled the device");
    pci_set_master(pdev);
    pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &latency);
    pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
    mantis->latency = latency;
    mantis->revision = revision;
    if (!latency) {
    pci_write_config_byte(pdev, PCI_LATENCY_TIMER, 32);
    }
    pci_set_drvdata(pdev, mantis);
    dprintk(verbose, MANTIS_ERROR, 0, "Mantis Rev %d, ", mantis->revision);
    dprintk(verbose, MANTIS_ERROR, 0, "irq: %d, latency: %d\n \
    memory: 0x%04x, mmio: %p\n", pdev->irq, mantis->latency, \
    mantis->mantis_addr, mantis->mantis_mmio);
    err3:
    free_irq(pdev->irq, pdev);
    err2:
    if (mantis->mantis_mmio)
    iounmap(mantis->mantis_mmio);
    err1:
    release_mem_region(pci_resource_start(pdev, 0),
    pci_resource_len(pdev, 0));
    err0:
    kfree(mantis);

    return 0;
    }

    static void __devexit mantis_pci_remove(struct pci_dev *pdev)
    {
    struct mantis_pci *mantis = pci_get_drvdata(pdev);
    if (mantis == NULL) {
    dprintk(verbose, MANTIS_ERROR, 1, "Aeio, MAntis NULL ptr");
    return;
    }
    dprintk(verbose, MANTIS_ERROR, 1, "Removing -->Mantis irq: %d, \
    latency: %d\n memory: 0x%04x, mmio: 0x%p",
    pdev->irq, mantis->latency, mantis->mantis_addr,
    mantis->mantis_mmio);

    free_irq(pdev->irq, pdev);

    release_mem_region(pci_resource_start(pdev, 0),
    pci_resource_len(pdev, 0));
    pci_set_drvdata(pdev, NULL);
    pci_disable_device(pdev);
    kfree(mantis);
    }

    static struct pci_driver mantis_pci_driver = {
    .name = "Mantis PCI combo driver",
    .id_table = mantis_pci_table,
    .probe = mantis_pci_probe,
    .remove = mantis_pci_remove,
    };

    static int __devinit mantis_pci_init(void)
    {
    return pci_register_driver(&mantis_pci_driver);
    }

    static void __devexit mantis_pci_exit(void)
    {
    pci_unregister_driver(&mantis_pci_driver);
    }

    module_init(mantis_pci_init);
    module_exit(mantis_pci_exit);

    MODULE_DESCRIPTION("Mantis PCI DTV bridge driver");
    MODULE_AUTHOR("Manu Abraham");
    MODULE_LICENSE("GPL");



    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2005-09-15 11:06    [W:0.031 / U:0.060 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site