This source file includes following definitions.
- c_can_pci_read_reg_aligned_to_16bit
- c_can_pci_write_reg_aligned_to_16bit
- c_can_pci_read_reg_aligned_to_32bit
- c_can_pci_write_reg_aligned_to_32bit
- c_can_pci_read_reg_32bit
- c_can_pci_write_reg_32bit
- c_can_pci_read_reg32
- c_can_pci_write_reg32
- c_can_pci_reset_pch
- c_can_pci_probe
- c_can_pci_remove
1
2
3
4
5
6
7
8
9
10
11
12
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/netdevice.h>
16 #include <linux/pci.h>
17
18 #include <linux/can/dev.h>
19
20 #include "c_can.h"
21
22 #define PCI_DEVICE_ID_PCH_CAN 0x8818
23 #define PCH_PCI_SOFT_RESET 0x01fc
24
25 enum c_can_pci_reg_align {
26 C_CAN_REG_ALIGN_16,
27 C_CAN_REG_ALIGN_32,
28 C_CAN_REG_32,
29 };
30
31 struct c_can_pci_data {
32
33 enum c_can_dev_id type;
34
35 enum c_can_pci_reg_align reg_align;
36
37 unsigned int freq;
38
39 int bar;
40
41 void (*init)(const struct c_can_priv *priv, bool enable);
42 };
43
44
45
46
47
48
49
50 static u16 c_can_pci_read_reg_aligned_to_16bit(const struct c_can_priv *priv,
51 enum reg index)
52 {
53 return readw(priv->base + priv->regs[index]);
54 }
55
56 static void c_can_pci_write_reg_aligned_to_16bit(const struct c_can_priv *priv,
57 enum reg index, u16 val)
58 {
59 writew(val, priv->base + priv->regs[index]);
60 }
61
62 static u16 c_can_pci_read_reg_aligned_to_32bit(const struct c_can_priv *priv,
63 enum reg index)
64 {
65 return readw(priv->base + 2 * priv->regs[index]);
66 }
67
68 static void c_can_pci_write_reg_aligned_to_32bit(const struct c_can_priv *priv,
69 enum reg index, u16 val)
70 {
71 writew(val, priv->base + 2 * priv->regs[index]);
72 }
73
74 static u16 c_can_pci_read_reg_32bit(const struct c_can_priv *priv,
75 enum reg index)
76 {
77 return (u16)ioread32(priv->base + 2 * priv->regs[index]);
78 }
79
80 static void c_can_pci_write_reg_32bit(const struct c_can_priv *priv,
81 enum reg index, u16 val)
82 {
83 iowrite32((u32)val, priv->base + 2 * priv->regs[index]);
84 }
85
86 static u32 c_can_pci_read_reg32(const struct c_can_priv *priv, enum reg index)
87 {
88 u32 val;
89
90 val = priv->read_reg(priv, index);
91 val |= ((u32) priv->read_reg(priv, index + 1)) << 16;
92
93 return val;
94 }
95
96 static void c_can_pci_write_reg32(const struct c_can_priv *priv, enum reg index,
97 u32 val)
98 {
99 priv->write_reg(priv, index + 1, val >> 16);
100 priv->write_reg(priv, index, val);
101 }
102
103 static void c_can_pci_reset_pch(const struct c_can_priv *priv, bool enable)
104 {
105 if (enable) {
106 u32 __iomem *addr = priv->base + PCH_PCI_SOFT_RESET;
107
108
109 iowrite32(1, addr);
110 iowrite32(0, addr);
111 }
112 }
113
114 static int c_can_pci_probe(struct pci_dev *pdev,
115 const struct pci_device_id *ent)
116 {
117 struct c_can_pci_data *c_can_pci_data = (void *)ent->driver_data;
118 struct c_can_priv *priv;
119 struct net_device *dev;
120 void __iomem *addr;
121 int ret;
122
123 ret = pci_enable_device(pdev);
124 if (ret) {
125 dev_err(&pdev->dev, "pci_enable_device FAILED\n");
126 goto out;
127 }
128
129 ret = pci_request_regions(pdev, KBUILD_MODNAME);
130 if (ret) {
131 dev_err(&pdev->dev, "pci_request_regions FAILED\n");
132 goto out_disable_device;
133 }
134
135 ret = pci_enable_msi(pdev);
136 if (!ret) {
137 dev_info(&pdev->dev, "MSI enabled\n");
138 pci_set_master(pdev);
139 }
140
141 addr = pci_iomap(pdev, c_can_pci_data->bar,
142 pci_resource_len(pdev, c_can_pci_data->bar));
143 if (!addr) {
144 dev_err(&pdev->dev,
145 "device has no PCI memory resources, "
146 "failing adapter\n");
147 ret = -ENOMEM;
148 goto out_release_regions;
149 }
150
151
152 dev = alloc_c_can_dev();
153 if (!dev) {
154 ret = -ENOMEM;
155 goto out_iounmap;
156 }
157
158 priv = netdev_priv(dev);
159 pci_set_drvdata(pdev, dev);
160 SET_NETDEV_DEV(dev, &pdev->dev);
161
162 dev->irq = pdev->irq;
163 priv->base = addr;
164 priv->device = &pdev->dev;
165
166 if (!c_can_pci_data->freq) {
167 dev_err(&pdev->dev, "no clock frequency defined\n");
168 ret = -ENODEV;
169 goto out_free_c_can;
170 } else {
171 priv->can.clock.freq = c_can_pci_data->freq;
172 }
173
174
175 switch (c_can_pci_data->type) {
176 case BOSCH_C_CAN:
177 priv->regs = reg_map_c_can;
178 break;
179 case BOSCH_D_CAN:
180 priv->regs = reg_map_d_can;
181 break;
182 default:
183 ret = -EINVAL;
184 goto out_free_c_can;
185 }
186
187 priv->type = c_can_pci_data->type;
188
189
190 switch (c_can_pci_data->reg_align) {
191 case C_CAN_REG_ALIGN_32:
192 priv->read_reg = c_can_pci_read_reg_aligned_to_32bit;
193 priv->write_reg = c_can_pci_write_reg_aligned_to_32bit;
194 break;
195 case C_CAN_REG_ALIGN_16:
196 priv->read_reg = c_can_pci_read_reg_aligned_to_16bit;
197 priv->write_reg = c_can_pci_write_reg_aligned_to_16bit;
198 break;
199 case C_CAN_REG_32:
200 priv->read_reg = c_can_pci_read_reg_32bit;
201 priv->write_reg = c_can_pci_write_reg_32bit;
202 break;
203 default:
204 ret = -EINVAL;
205 goto out_free_c_can;
206 }
207 priv->read_reg32 = c_can_pci_read_reg32;
208 priv->write_reg32 = c_can_pci_write_reg32;
209
210 priv->raminit = c_can_pci_data->init;
211
212 ret = register_c_can_dev(dev);
213 if (ret) {
214 dev_err(&pdev->dev, "registering %s failed (err=%d)\n",
215 KBUILD_MODNAME, ret);
216 goto out_free_c_can;
217 }
218
219 dev_dbg(&pdev->dev, "%s device registered (regs=%p, irq=%d)\n",
220 KBUILD_MODNAME, priv->regs, dev->irq);
221
222 return 0;
223
224 out_free_c_can:
225 free_c_can_dev(dev);
226 out_iounmap:
227 pci_iounmap(pdev, addr);
228 out_release_regions:
229 pci_disable_msi(pdev);
230 pci_clear_master(pdev);
231 pci_release_regions(pdev);
232 out_disable_device:
233 pci_disable_device(pdev);
234 out:
235 return ret;
236 }
237
238 static void c_can_pci_remove(struct pci_dev *pdev)
239 {
240 struct net_device *dev = pci_get_drvdata(pdev);
241 struct c_can_priv *priv = netdev_priv(dev);
242
243 unregister_c_can_dev(dev);
244
245 free_c_can_dev(dev);
246
247 pci_iounmap(pdev, priv->base);
248 pci_disable_msi(pdev);
249 pci_clear_master(pdev);
250 pci_release_regions(pdev);
251 pci_disable_device(pdev);
252 }
253
254 static const struct c_can_pci_data c_can_sta2x11= {
255 .type = BOSCH_C_CAN,
256 .reg_align = C_CAN_REG_ALIGN_32,
257 .freq = 52000000,
258 .bar = 0,
259 };
260
261 static const struct c_can_pci_data c_can_pch = {
262 .type = BOSCH_C_CAN,
263 .reg_align = C_CAN_REG_32,
264 .freq = 50000000,
265 .init = c_can_pci_reset_pch,
266 .bar = 1,
267 };
268
269 #define C_CAN_ID(_vend, _dev, _driverdata) { \
270 PCI_DEVICE(_vend, _dev), \
271 .driver_data = (unsigned long)&_driverdata, \
272 }
273
274 static const struct pci_device_id c_can_pci_tbl[] = {
275 C_CAN_ID(PCI_VENDOR_ID_STMICRO, PCI_DEVICE_ID_STMICRO_CAN,
276 c_can_sta2x11),
277 C_CAN_ID(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_PCH_CAN,
278 c_can_pch),
279 {},
280 };
281 static struct pci_driver c_can_pci_driver = {
282 .name = KBUILD_MODNAME,
283 .id_table = c_can_pci_tbl,
284 .probe = c_can_pci_probe,
285 .remove = c_can_pci_remove,
286 };
287
288 module_pci_driver(c_can_pci_driver);
289
290 MODULE_AUTHOR("Federico Vaga <federico.vaga@gmail.com>");
291 MODULE_LICENSE("GPL v2");
292 MODULE_DESCRIPTION("PCI CAN bus driver for Bosch C_CAN/D_CAN controller");
293 MODULE_DEVICE_TABLE(pci, c_can_pci_tbl);