dmaengine: fail device registration if channel registration fails
[linux-2.6.git] / drivers / dma / ioat.c
1 /*
2  * Intel I/OAT DMA Linux driver
3  * Copyright(c) 2007 - 2009 Intel Corporation.
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms and conditions of the GNU General Public License,
7  * version 2, as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc.,
16  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
17  *
18  * The full GNU General Public License is included in this distribution in
19  * the file called "COPYING".
20  *
21  */
22
23 /*
24  * This driver supports an Intel I/OAT DMA engine, which does asynchronous
25  * copy operations.
26  */
27
28 #include <linux/init.h>
29 #include <linux/module.h>
30 #include <linux/pci.h>
31 #include <linux/interrupt.h>
32 #include <linux/dca.h>
33 #include "ioatdma.h"
34 #include "ioatdma_registers.h"
35 #include "ioatdma_hw.h"
36
37 MODULE_VERSION(IOAT_DMA_VERSION);
38 MODULE_LICENSE("GPL");
39 MODULE_AUTHOR("Intel Corporation");
40
41 static struct pci_device_id ioat_pci_tbl[] = {
42         /* I/OAT v1 platforms */
43         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT) },
44         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_CNB)  },
45         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_SCNB) },
46         { PCI_DEVICE(PCI_VENDOR_ID_UNISYS, PCI_DEVICE_ID_UNISYS_DMA_DIRECTOR) },
47
48         /* I/OAT v2 platforms */
49         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_SNB) },
50
51         /* I/OAT v3 platforms */
52         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG0) },
53         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG1) },
54         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG2) },
55         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG3) },
56         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG4) },
57         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG5) },
58         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG6) },
59         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_IOAT_TBG7) },
60         { 0, }
61 };
62
63 struct ioat_device {
64         struct pci_dev          *pdev;
65         void __iomem            *iobase;
66         struct ioatdma_device   *dma;
67         struct dca_provider     *dca;
68 };
69
70 static int __devinit ioat_probe(struct pci_dev *pdev,
71                                 const struct pci_device_id *id);
72 static void __devexit ioat_remove(struct pci_dev *pdev);
73
74 static int ioat_dca_enabled = 1;
75 module_param(ioat_dca_enabled, int, 0644);
76 MODULE_PARM_DESC(ioat_dca_enabled, "control support of dca service (default: 1)");
77
78 static struct pci_driver ioat_pci_driver = {
79         .name           = "ioatdma",
80         .id_table       = ioat_pci_tbl,
81         .probe          = ioat_probe,
82         .remove         = __devexit_p(ioat_remove),
83 };
84
85 static int __devinit ioat_probe(struct pci_dev *pdev,
86                                 const struct pci_device_id *id)
87 {
88         void __iomem *iobase;
89         struct ioat_device *device;
90         unsigned long mmio_start, mmio_len;
91         int err;
92
93         err = pci_enable_device(pdev);
94         if (err)
95                 goto err_enable_device;
96
97         err = pci_request_regions(pdev, ioat_pci_driver.name);
98         if (err)
99                 goto err_request_regions;
100
101         err = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
102         if (err)
103                 err = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
104         if (err)
105                 goto err_set_dma_mask;
106
107         err = pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
108         if (err)
109                 err = pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK);
110         if (err)
111                 goto err_set_dma_mask;
112
113         mmio_start = pci_resource_start(pdev, 0);
114         mmio_len = pci_resource_len(pdev, 0);
115         iobase = ioremap(mmio_start, mmio_len);
116         if (!iobase) {
117                 err = -ENOMEM;
118                 goto err_ioremap;
119         }
120
121         device = kzalloc(sizeof(*device), GFP_KERNEL);
122         if (!device) {
123                 err = -ENOMEM;
124                 goto err_kzalloc;
125         }
126         device->pdev = pdev;
127         pci_set_drvdata(pdev, device);
128         device->iobase = iobase;
129
130         pci_set_master(pdev);
131
132         switch (readb(iobase + IOAT_VER_OFFSET)) {
133         case IOAT_VER_1_2:
134                 device->dma = ioat_dma_probe(pdev, iobase);
135                 if (device->dma && ioat_dca_enabled)
136                         device->dca = ioat_dca_init(pdev, iobase);
137                 break;
138         case IOAT_VER_2_0:
139                 device->dma = ioat_dma_probe(pdev, iobase);
140                 if (device->dma && ioat_dca_enabled)
141                         device->dca = ioat2_dca_init(pdev, iobase);
142                 break;
143         case IOAT_VER_3_0:
144                 device->dma = ioat_dma_probe(pdev, iobase);
145                 if (device->dma && ioat_dca_enabled)
146                         device->dca = ioat3_dca_init(pdev, iobase);
147                 break;
148         default:
149                 err = -ENODEV;
150                 break;
151         }
152         if (!device->dma)
153                 err = -ENODEV;
154
155         if (err)
156                 goto err_version;
157
158         return 0;
159
160 err_version:
161         kfree(device);
162 err_kzalloc:
163         iounmap(iobase);
164 err_ioremap:
165 err_set_dma_mask:
166         pci_release_regions(pdev);
167         pci_disable_device(pdev);
168 err_request_regions:
169 err_enable_device:
170         return err;
171 }
172
173 static void __devexit ioat_remove(struct pci_dev *pdev)
174 {
175         struct ioat_device *device = pci_get_drvdata(pdev);
176
177         dev_err(&pdev->dev, "Removing dma and dca services\n");
178         if (device->dca) {
179                 unregister_dca_provider(device->dca);
180                 free_dca_provider(device->dca);
181                 device->dca = NULL;
182         }
183
184         if (device->dma) {
185                 ioat_dma_remove(device->dma);
186                 device->dma = NULL;
187         }
188
189         kfree(device);
190 }
191
192 static int __init ioat_init_module(void)
193 {
194         return pci_register_driver(&ioat_pci_driver);
195 }
196 module_init(ioat_init_module);
197
198 static void __exit ioat_exit_module(void)
199 {
200         pci_unregister_driver(&ioat_pci_driver);
201 }
202 module_exit(ioat_exit_module);