]>
Commit | Line | Data |
---|---|---|
a17a75e2 MW |
1 | /* |
2 | * VME Bridge Framework | |
3 | * | |
66bd8db5 MW |
4 | * Author: Martyn Welch <martyn.welch@ge.com> |
5 | * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc. | |
a17a75e2 MW |
6 | * |
7 | * Based on work by Tom Armistead and Ajit Prem | |
8 | * Copyright 2004 Motorola Inc. | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify it | |
11 | * under the terms of the GNU General Public License as published by the | |
12 | * Free Software Foundation; either version 2 of the License, or (at your | |
13 | * option) any later version. | |
14 | */ | |
15 | ||
050c3d52 PG |
16 | #include <linux/init.h> |
17 | #include <linux/export.h> | |
a17a75e2 MW |
18 | #include <linux/mm.h> |
19 | #include <linux/types.h> | |
20 | #include <linux/kernel.h> | |
21 | #include <linux/errno.h> | |
22 | #include <linux/pci.h> | |
23 | #include <linux/poll.h> | |
24 | #include <linux/highmem.h> | |
25 | #include <linux/interrupt.h> | |
26 | #include <linux/pagemap.h> | |
27 | #include <linux/device.h> | |
28 | #include <linux/dma-mapping.h> | |
29 | #include <linux/syscalls.h> | |
400822fe | 30 | #include <linux/mutex.h> |
a17a75e2 | 31 | #include <linux/spinlock.h> |
5a0e3ad6 | 32 | #include <linux/slab.h> |
db3b9e99 | 33 | #include <linux/vme.h> |
a17a75e2 | 34 | |
a17a75e2 MW |
35 | #include "vme_bridge.h" |
36 | ||
733e3ef0 | 37 | /* Bitmask and list of registered buses both protected by common mutex */ |
a17a75e2 | 38 | static unsigned int vme_bus_numbers; |
733e3ef0 MV |
39 | static LIST_HEAD(vme_bus_list); |
40 | static DEFINE_MUTEX(vme_buses_lock); | |
a17a75e2 | 41 | |
ead1f3e3 | 42 | static int __init vme_init(void); |
a17a75e2 | 43 | |
8f966dc4 | 44 | static struct vme_dev *dev_to_vme_dev(struct device *dev) |
a17a75e2 | 45 | { |
8f966dc4 | 46 | return container_of(dev, struct vme_dev, dev); |
a17a75e2 MW |
47 | } |
48 | ||
49 | /* | |
50 | * Find the bridge that the resource is associated with. | |
51 | */ | |
52 | static struct vme_bridge *find_bridge(struct vme_resource *resource) | |
53 | { | |
54 | /* Get list to search */ | |
55 | switch (resource->type) { | |
56 | case VME_MASTER: | |
57 | return list_entry(resource->entry, struct vme_master_resource, | |
58 | list)->parent; | |
59 | break; | |
60 | case VME_SLAVE: | |
61 | return list_entry(resource->entry, struct vme_slave_resource, | |
62 | list)->parent; | |
63 | break; | |
64 | case VME_DMA: | |
65 | return list_entry(resource->entry, struct vme_dma_resource, | |
66 | list)->parent; | |
67 | break; | |
42fb5031 MW |
68 | case VME_LM: |
69 | return list_entry(resource->entry, struct vme_lm_resource, | |
70 | list)->parent; | |
71 | break; | |
a17a75e2 MW |
72 | default: |
73 | printk(KERN_ERR "Unknown resource type\n"); | |
74 | return NULL; | |
75 | break; | |
76 | } | |
77 | } | |
78 | ||
b5bc980a MW |
79 | /** |
80 | * vme_free_consistent - Allocate contiguous memory. | |
81 | * @resource: Pointer to VME resource. | |
82 | * @size: Size of allocation required. | |
83 | * @dma: Pointer to variable to store physical address of allocation. | |
84 | * | |
a17a75e2 MW |
85 | * Allocate a contiguous block of memory for use by the driver. This is used to |
86 | * create the buffers for the slave windows. | |
b5bc980a MW |
87 | * |
88 | * Return: Virtual address of allocation on success, NULL on failure. | |
a17a75e2 | 89 | */ |
ead1f3e3 | 90 | void *vme_alloc_consistent(struct vme_resource *resource, size_t size, |
a17a75e2 MW |
91 | dma_addr_t *dma) |
92 | { | |
93 | struct vme_bridge *bridge; | |
a17a75e2 | 94 | |
ead1f3e3 MW |
95 | if (resource == NULL) { |
96 | printk(KERN_ERR "No resource\n"); | |
a17a75e2 MW |
97 | return NULL; |
98 | } | |
99 | ||
100 | bridge = find_bridge(resource); | |
ead1f3e3 MW |
101 | if (bridge == NULL) { |
102 | printk(KERN_ERR "Can't find bridge\n"); | |
a17a75e2 MW |
103 | return NULL; |
104 | } | |
105 | ||
a17a75e2 | 106 | if (bridge->parent == NULL) { |
25958ce3 | 107 | printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name); |
7f58f025 MV |
108 | return NULL; |
109 | } | |
110 | ||
111 | if (bridge->alloc_consistent == NULL) { | |
25958ce3 GKH |
112 | printk(KERN_ERR "alloc_consistent not supported by bridge %s\n", |
113 | bridge->name); | |
a17a75e2 MW |
114 | return NULL; |
115 | } | |
a17a75e2 | 116 | |
7f58f025 | 117 | return bridge->alloc_consistent(bridge->parent, size, dma); |
a17a75e2 MW |
118 | } |
119 | EXPORT_SYMBOL(vme_alloc_consistent); | |
120 | ||
b5bc980a MW |
121 | /** |
122 | * vme_free_consistent - Free previously allocated memory. | |
123 | * @resource: Pointer to VME resource. | |
124 | * @size: Size of allocation to free. | |
125 | * @vaddr: Virtual address of allocation. | |
126 | * @dma: Physical address of allocation. | |
127 | * | |
128 | * Free previously allocated block of contiguous memory. | |
a17a75e2 MW |
129 | */ |
130 | void vme_free_consistent(struct vme_resource *resource, size_t size, | |
131 | void *vaddr, dma_addr_t dma) | |
132 | { | |
133 | struct vme_bridge *bridge; | |
a17a75e2 | 134 | |
ead1f3e3 MW |
135 | if (resource == NULL) { |
136 | printk(KERN_ERR "No resource\n"); | |
a17a75e2 MW |
137 | return; |
138 | } | |
139 | ||
140 | bridge = find_bridge(resource); | |
ead1f3e3 MW |
141 | if (bridge == NULL) { |
142 | printk(KERN_ERR "Can't find bridge\n"); | |
a17a75e2 MW |
143 | return; |
144 | } | |
145 | ||
7f58f025 | 146 | if (bridge->parent == NULL) { |
25958ce3 | 147 | printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name); |
7f58f025 MV |
148 | return; |
149 | } | |
150 | ||
151 | if (bridge->free_consistent == NULL) { | |
25958ce3 GKH |
152 | printk(KERN_ERR "free_consistent not supported by bridge %s\n", |
153 | bridge->name); | |
7f58f025 MV |
154 | return; |
155 | } | |
a17a75e2 | 156 | |
7f58f025 | 157 | bridge->free_consistent(bridge->parent, size, vaddr, dma); |
a17a75e2 MW |
158 | } |
159 | EXPORT_SYMBOL(vme_free_consistent); | |
160 | ||
b5bc980a MW |
161 | /** |
162 | * vme_get_size - Helper function returning size of a VME window | |
163 | * @resource: Pointer to VME slave or master resource. | |
164 | * | |
165 | * Determine the size of the VME window provided. This is a helper | |
166 | * function, wrappering the call to vme_master_get or vme_slave_get | |
167 | * depending on the type of window resource handed to it. | |
168 | * | |
169 | * Return: Size of the window on success, zero on failure. | |
170 | */ | |
a17a75e2 MW |
171 | size_t vme_get_size(struct vme_resource *resource) |
172 | { | |
173 | int enabled, retval; | |
174 | unsigned long long base, size; | |
175 | dma_addr_t buf_base; | |
6af04b06 | 176 | u32 aspace, cycle, dwidth; |
a17a75e2 MW |
177 | |
178 | switch (resource->type) { | |
179 | case VME_MASTER: | |
180 | retval = vme_master_get(resource, &enabled, &base, &size, | |
181 | &aspace, &cycle, &dwidth); | |
6ad37567 MW |
182 | if (retval) |
183 | return 0; | |
a17a75e2 MW |
184 | |
185 | return size; | |
186 | break; | |
187 | case VME_SLAVE: | |
188 | retval = vme_slave_get(resource, &enabled, &base, &size, | |
189 | &buf_base, &aspace, &cycle); | |
6ad37567 MW |
190 | if (retval) |
191 | return 0; | |
a17a75e2 MW |
192 | |
193 | return size; | |
194 | break; | |
195 | case VME_DMA: | |
196 | return 0; | |
197 | break; | |
198 | default: | |
199 | printk(KERN_ERR "Unknown resource type\n"); | |
200 | return 0; | |
201 | break; | |
202 | } | |
203 | } | |
204 | EXPORT_SYMBOL(vme_get_size); | |
205 | ||
ef73f886 DK |
206 | int vme_check_window(u32 aspace, unsigned long long vme_base, |
207 | unsigned long long size) | |
a17a75e2 MW |
208 | { |
209 | int retval = 0; | |
210 | ||
211 | switch (aspace) { | |
212 | case VME_A16: | |
213 | if (((vme_base + size) > VME_A16_MAX) || | |
214 | (vme_base > VME_A16_MAX)) | |
215 | retval = -EFAULT; | |
216 | break; | |
217 | case VME_A24: | |
218 | if (((vme_base + size) > VME_A24_MAX) || | |
219 | (vme_base > VME_A24_MAX)) | |
220 | retval = -EFAULT; | |
221 | break; | |
222 | case VME_A32: | |
223 | if (((vme_base + size) > VME_A32_MAX) || | |
224 | (vme_base > VME_A32_MAX)) | |
225 | retval = -EFAULT; | |
226 | break; | |
227 | case VME_A64: | |
e7fd80cb DK |
228 | if ((size != 0) && (vme_base > U64_MAX + 1 - size)) |
229 | retval = -EFAULT; | |
a17a75e2 MW |
230 | break; |
231 | case VME_CRCSR: | |
232 | if (((vme_base + size) > VME_CRCSR_MAX) || | |
233 | (vme_base > VME_CRCSR_MAX)) | |
234 | retval = -EFAULT; | |
235 | break; | |
236 | case VME_USER1: | |
237 | case VME_USER2: | |
238 | case VME_USER3: | |
239 | case VME_USER4: | |
240 | /* User Defined */ | |
241 | break; | |
242 | default: | |
ead1f3e3 | 243 | printk(KERN_ERR "Invalid address space\n"); |
a17a75e2 MW |
244 | retval = -EINVAL; |
245 | break; | |
246 | } | |
247 | ||
248 | return retval; | |
249 | } | |
ef73f886 | 250 | EXPORT_SYMBOL(vme_check_window); |
a17a75e2 | 251 | |
472f16f3 DK |
252 | static u32 vme_get_aspace(int am) |
253 | { | |
254 | switch (am) { | |
255 | case 0x29: | |
256 | case 0x2D: | |
257 | return VME_A16; | |
258 | case 0x38: | |
259 | case 0x39: | |
260 | case 0x3A: | |
261 | case 0x3B: | |
262 | case 0x3C: | |
263 | case 0x3D: | |
264 | case 0x3E: | |
265 | case 0x3F: | |
266 | return VME_A24; | |
267 | case 0x8: | |
268 | case 0x9: | |
269 | case 0xA: | |
270 | case 0xB: | |
271 | case 0xC: | |
272 | case 0xD: | |
273 | case 0xE: | |
274 | case 0xF: | |
275 | return VME_A32; | |
276 | case 0x0: | |
277 | case 0x1: | |
278 | case 0x3: | |
279 | return VME_A64; | |
280 | } | |
281 | ||
282 | return 0; | |
283 | } | |
284 | ||
b5bc980a MW |
285 | /** |
286 | * vme_slave_request - Request a VME slave window resource. | |
287 | * @vdev: Pointer to VME device struct vme_dev assigned to driver instance. | |
288 | * @address: Required VME address space. | |
289 | * @cycle: Required VME data transfer cycle type. | |
290 | * | |
291 | * Request use of a VME window resource capable of being set for the requested | |
292 | * address space and data transfer cycle. | |
293 | * | |
294 | * Return: Pointer to VME resource on success, NULL on failure. | |
a17a75e2 | 295 | */ |
6af04b06 MW |
296 | struct vme_resource *vme_slave_request(struct vme_dev *vdev, u32 address, |
297 | u32 cycle) | |
a17a75e2 MW |
298 | { |
299 | struct vme_bridge *bridge; | |
300 | struct list_head *slave_pos = NULL; | |
301 | struct vme_slave_resource *allocated_image = NULL; | |
302 | struct vme_slave_resource *slave_image = NULL; | |
303 | struct vme_resource *resource = NULL; | |
304 | ||
8f966dc4 | 305 | bridge = vdev->bridge; |
a17a75e2 MW |
306 | if (bridge == NULL) { |
307 | printk(KERN_ERR "Can't find VME bus\n"); | |
308 | goto err_bus; | |
309 | } | |
310 | ||
311 | /* Loop through slave resources */ | |
886953e9 | 312 | list_for_each(slave_pos, &bridge->slave_resources) { |
a17a75e2 MW |
313 | slave_image = list_entry(slave_pos, |
314 | struct vme_slave_resource, list); | |
315 | ||
316 | if (slave_image == NULL) { | |
ead1f3e3 | 317 | printk(KERN_ERR "Registered NULL Slave resource\n"); |
a17a75e2 MW |
318 | continue; |
319 | } | |
320 | ||
321 | /* Find an unlocked and compatible image */ | |
886953e9 | 322 | mutex_lock(&slave_image->mtx); |
ead1f3e3 | 323 | if (((slave_image->address_attr & address) == address) && |
a17a75e2 MW |
324 | ((slave_image->cycle_attr & cycle) == cycle) && |
325 | (slave_image->locked == 0)) { | |
326 | ||
327 | slave_image->locked = 1; | |
886953e9 | 328 | mutex_unlock(&slave_image->mtx); |
a17a75e2 MW |
329 | allocated_image = slave_image; |
330 | break; | |
331 | } | |
886953e9 | 332 | mutex_unlock(&slave_image->mtx); |
a17a75e2 MW |
333 | } |
334 | ||
335 | /* No free image */ | |
336 | if (allocated_image == NULL) | |
337 | goto err_image; | |
338 | ||
1ff0a19c | 339 | resource = kmalloc(sizeof(*resource), GFP_KERNEL); |
94eefcc1 | 340 | if (!resource) |
a17a75e2 | 341 | goto err_alloc; |
94eefcc1 | 342 | |
a17a75e2 | 343 | resource->type = VME_SLAVE; |
886953e9 | 344 | resource->entry = &allocated_image->list; |
a17a75e2 MW |
345 | |
346 | return resource; | |
347 | ||
348 | err_alloc: | |
349 | /* Unlock image */ | |
886953e9 | 350 | mutex_lock(&slave_image->mtx); |
a17a75e2 | 351 | slave_image->locked = 0; |
886953e9 | 352 | mutex_unlock(&slave_image->mtx); |
a17a75e2 MW |
353 | err_image: |
354 | err_bus: | |
355 | return NULL; | |
356 | } | |
357 | EXPORT_SYMBOL(vme_slave_request); | |
358 | ||
b5bc980a MW |
359 | /** |
360 | * vme_slave_set - Set VME slave window configuration. | |
361 | * @resource: Pointer to VME slave resource. | |
362 | * @enabled: State to which the window should be configured. | |
363 | * @vme_base: Base address for the window. | |
364 | * @size: Size of the VME window. | |
365 | * @buf_base: Based address of buffer used to provide VME slave window storage. | |
366 | * @aspace: VME address space for the VME window. | |
367 | * @cycle: VME data transfer cycle type for the VME window. | |
368 | * | |
369 | * Set configuration for provided VME slave window. | |
370 | * | |
371 | * Return: Zero on success, -EINVAL if operation is not supported on this | |
372 | * device, if an invalid resource has been provided or invalid | |
373 | * attributes are provided. Hardware specific errors may also be | |
374 | * returned. | |
375 | */ | |
ead1f3e3 | 376 | int vme_slave_set(struct vme_resource *resource, int enabled, |
a17a75e2 | 377 | unsigned long long vme_base, unsigned long long size, |
6af04b06 | 378 | dma_addr_t buf_base, u32 aspace, u32 cycle) |
a17a75e2 MW |
379 | { |
380 | struct vme_bridge *bridge = find_bridge(resource); | |
381 | struct vme_slave_resource *image; | |
382 | int retval; | |
383 | ||
384 | if (resource->type != VME_SLAVE) { | |
ead1f3e3 | 385 | printk(KERN_ERR "Not a slave resource\n"); |
a17a75e2 MW |
386 | return -EINVAL; |
387 | } | |
388 | ||
389 | image = list_entry(resource->entry, struct vme_slave_resource, list); | |
390 | ||
391 | if (bridge->slave_set == NULL) { | |
ead1f3e3 | 392 | printk(KERN_ERR "Function not supported\n"); |
a17a75e2 MW |
393 | return -ENOSYS; |
394 | } | |
395 | ||
ead1f3e3 | 396 | if (!(((image->address_attr & aspace) == aspace) && |
a17a75e2 | 397 | ((image->cycle_attr & cycle) == cycle))) { |
ead1f3e3 | 398 | printk(KERN_ERR "Invalid attributes\n"); |
a17a75e2 MW |
399 | return -EINVAL; |
400 | } | |
401 | ||
402 | retval = vme_check_window(aspace, vme_base, size); | |
ead1f3e3 | 403 | if (retval) |
a17a75e2 MW |
404 | return retval; |
405 | ||
406 | return bridge->slave_set(image, enabled, vme_base, size, buf_base, | |
407 | aspace, cycle); | |
408 | } | |
409 | EXPORT_SYMBOL(vme_slave_set); | |
410 | ||
b5bc980a MW |
411 | /** |
412 | * vme_slave_get - Retrieve VME slave window configuration. | |
413 | * @resource: Pointer to VME slave resource. | |
414 | * @enabled: Pointer to variable for storing state. | |
415 | * @vme_base: Pointer to variable for storing window base address. | |
416 | * @size: Pointer to variable for storing window size. | |
417 | * @buf_base: Pointer to variable for storing slave buffer base address. | |
418 | * @aspace: Pointer to variable for storing VME address space. | |
419 | * @cycle: Pointer to variable for storing VME data transfer cycle type. | |
420 | * | |
421 | * Return configuration for provided VME slave window. | |
422 | * | |
423 | * Return: Zero on success, -EINVAL if operation is not supported on this | |
424 | * device or if an invalid resource has been provided. | |
425 | */ | |
ead1f3e3 | 426 | int vme_slave_get(struct vme_resource *resource, int *enabled, |
a17a75e2 | 427 | unsigned long long *vme_base, unsigned long long *size, |
6af04b06 | 428 | dma_addr_t *buf_base, u32 *aspace, u32 *cycle) |
a17a75e2 MW |
429 | { |
430 | struct vme_bridge *bridge = find_bridge(resource); | |
431 | struct vme_slave_resource *image; | |
432 | ||
433 | if (resource->type != VME_SLAVE) { | |
ead1f3e3 | 434 | printk(KERN_ERR "Not a slave resource\n"); |
a17a75e2 MW |
435 | return -EINVAL; |
436 | } | |
437 | ||
438 | image = list_entry(resource->entry, struct vme_slave_resource, list); | |
439 | ||
51a569f7 | 440 | if (bridge->slave_get == NULL) { |
ead1f3e3 | 441 | printk(KERN_ERR "vme_slave_get not supported\n"); |
a17a75e2 MW |
442 | return -EINVAL; |
443 | } | |
444 | ||
445 | return bridge->slave_get(image, enabled, vme_base, size, buf_base, | |
446 | aspace, cycle); | |
447 | } | |
448 | EXPORT_SYMBOL(vme_slave_get); | |
449 | ||
b5bc980a MW |
450 | /** |
451 | * vme_slave_free - Free VME slave window | |
452 | * @resource: Pointer to VME slave resource. | |
453 | * | |
454 | * Free the provided slave resource so that it may be reallocated. | |
455 | */ | |
a17a75e2 MW |
456 | void vme_slave_free(struct vme_resource *resource) |
457 | { | |
458 | struct vme_slave_resource *slave_image; | |
459 | ||
460 | if (resource->type != VME_SLAVE) { | |
ead1f3e3 | 461 | printk(KERN_ERR "Not a slave resource\n"); |
a17a75e2 MW |
462 | return; |
463 | } | |
464 | ||
465 | slave_image = list_entry(resource->entry, struct vme_slave_resource, | |
466 | list); | |
467 | if (slave_image == NULL) { | |
ead1f3e3 | 468 | printk(KERN_ERR "Can't find slave resource\n"); |
a17a75e2 MW |
469 | return; |
470 | } | |
471 | ||
472 | /* Unlock image */ | |
886953e9 | 473 | mutex_lock(&slave_image->mtx); |
a17a75e2 MW |
474 | if (slave_image->locked == 0) |
475 | printk(KERN_ERR "Image is already free\n"); | |
476 | ||
477 | slave_image->locked = 0; | |
886953e9 | 478 | mutex_unlock(&slave_image->mtx); |
a17a75e2 MW |
479 | |
480 | /* Free up resource memory */ | |
481 | kfree(resource); | |
482 | } | |
483 | EXPORT_SYMBOL(vme_slave_free); | |
484 | ||
b5bc980a MW |
485 | /** |
486 | * vme_master_request - Request a VME master window resource. | |
487 | * @vdev: Pointer to VME device struct vme_dev assigned to driver instance. | |
488 | * @address: Required VME address space. | |
489 | * @cycle: Required VME data transfer cycle type. | |
490 | * @dwidth: Required VME data transfer width. | |
491 | * | |
492 | * Request use of a VME window resource capable of being set for the requested | |
493 | * address space, data transfer cycle and width. | |
494 | * | |
495 | * Return: Pointer to VME resource on success, NULL on failure. | |
a17a75e2 | 496 | */ |
6af04b06 MW |
497 | struct vme_resource *vme_master_request(struct vme_dev *vdev, u32 address, |
498 | u32 cycle, u32 dwidth) | |
a17a75e2 MW |
499 | { |
500 | struct vme_bridge *bridge; | |
501 | struct list_head *master_pos = NULL; | |
502 | struct vme_master_resource *allocated_image = NULL; | |
503 | struct vme_master_resource *master_image = NULL; | |
504 | struct vme_resource *resource = NULL; | |
505 | ||
8f966dc4 | 506 | bridge = vdev->bridge; |
a17a75e2 MW |
507 | if (bridge == NULL) { |
508 | printk(KERN_ERR "Can't find VME bus\n"); | |
509 | goto err_bus; | |
510 | } | |
511 | ||
512 | /* Loop through master resources */ | |
886953e9 | 513 | list_for_each(master_pos, &bridge->master_resources) { |
a17a75e2 MW |
514 | master_image = list_entry(master_pos, |
515 | struct vme_master_resource, list); | |
516 | ||
517 | if (master_image == NULL) { | |
518 | printk(KERN_WARNING "Registered NULL master resource\n"); | |
519 | continue; | |
520 | } | |
521 | ||
522 | /* Find an unlocked and compatible image */ | |
886953e9 | 523 | spin_lock(&master_image->lock); |
ead1f3e3 | 524 | if (((master_image->address_attr & address) == address) && |
a17a75e2 MW |
525 | ((master_image->cycle_attr & cycle) == cycle) && |
526 | ((master_image->width_attr & dwidth) == dwidth) && | |
527 | (master_image->locked == 0)) { | |
528 | ||
529 | master_image->locked = 1; | |
886953e9 | 530 | spin_unlock(&master_image->lock); |
a17a75e2 MW |
531 | allocated_image = master_image; |
532 | break; | |
533 | } | |
886953e9 | 534 | spin_unlock(&master_image->lock); |
a17a75e2 MW |
535 | } |
536 | ||
537 | /* Check to see if we found a resource */ | |
538 | if (allocated_image == NULL) { | |
539 | printk(KERN_ERR "Can't find a suitable resource\n"); | |
540 | goto err_image; | |
541 | } | |
542 | ||
1ff0a19c | 543 | resource = kmalloc(sizeof(*resource), GFP_KERNEL); |
94eefcc1 | 544 | if (!resource) |
a17a75e2 | 545 | goto err_alloc; |
94eefcc1 | 546 | |
a17a75e2 | 547 | resource->type = VME_MASTER; |
886953e9 | 548 | resource->entry = &allocated_image->list; |
a17a75e2 MW |
549 | |
550 | return resource; | |
551 | ||
a17a75e2 MW |
552 | err_alloc: |
553 | /* Unlock image */ | |
886953e9 | 554 | spin_lock(&master_image->lock); |
a17a75e2 | 555 | master_image->locked = 0; |
886953e9 | 556 | spin_unlock(&master_image->lock); |
a17a75e2 MW |
557 | err_image: |
558 | err_bus: | |
559 | return NULL; | |
560 | } | |
561 | EXPORT_SYMBOL(vme_master_request); | |
562 | ||
b5bc980a MW |
563 | /** |
564 | * vme_master_set - Set VME master window configuration. | |
565 | * @resource: Pointer to VME master resource. | |
566 | * @enabled: State to which the window should be configured. | |
567 | * @vme_base: Base address for the window. | |
568 | * @size: Size of the VME window. | |
569 | * @aspace: VME address space for the VME window. | |
570 | * @cycle: VME data transfer cycle type for the VME window. | |
571 | * @dwidth: VME data transfer width for the VME window. | |
572 | * | |
573 | * Set configuration for provided VME master window. | |
574 | * | |
575 | * Return: Zero on success, -EINVAL if operation is not supported on this | |
576 | * device, if an invalid resource has been provided or invalid | |
577 | * attributes are provided. Hardware specific errors may also be | |
578 | * returned. | |
579 | */ | |
ead1f3e3 | 580 | int vme_master_set(struct vme_resource *resource, int enabled, |
6af04b06 MW |
581 | unsigned long long vme_base, unsigned long long size, u32 aspace, |
582 | u32 cycle, u32 dwidth) | |
a17a75e2 MW |
583 | { |
584 | struct vme_bridge *bridge = find_bridge(resource); | |
585 | struct vme_master_resource *image; | |
586 | int retval; | |
587 | ||
588 | if (resource->type != VME_MASTER) { | |
ead1f3e3 | 589 | printk(KERN_ERR "Not a master resource\n"); |
a17a75e2 MW |
590 | return -EINVAL; |
591 | } | |
592 | ||
593 | image = list_entry(resource->entry, struct vme_master_resource, list); | |
594 | ||
595 | if (bridge->master_set == NULL) { | |
ead1f3e3 | 596 | printk(KERN_WARNING "vme_master_set not supported\n"); |
a17a75e2 MW |
597 | return -EINVAL; |
598 | } | |
599 | ||
ead1f3e3 | 600 | if (!(((image->address_attr & aspace) == aspace) && |
a17a75e2 MW |
601 | ((image->cycle_attr & cycle) == cycle) && |
602 | ((image->width_attr & dwidth) == dwidth))) { | |
ead1f3e3 | 603 | printk(KERN_WARNING "Invalid attributes\n"); |
a17a75e2 MW |
604 | return -EINVAL; |
605 | } | |
606 | ||
607 | retval = vme_check_window(aspace, vme_base, size); | |
ead1f3e3 | 608 | if (retval) |
a17a75e2 MW |
609 | return retval; |
610 | ||
611 | return bridge->master_set(image, enabled, vme_base, size, aspace, | |
612 | cycle, dwidth); | |
613 | } | |
614 | EXPORT_SYMBOL(vme_master_set); | |
615 | ||
b5bc980a MW |
616 | /** |
617 | * vme_master_get - Retrieve VME master window configuration. | |
618 | * @resource: Pointer to VME master resource. | |
619 | * @enabled: Pointer to variable for storing state. | |
620 | * @vme_base: Pointer to variable for storing window base address. | |
621 | * @size: Pointer to variable for storing window size. | |
622 | * @aspace: Pointer to variable for storing VME address space. | |
623 | * @cycle: Pointer to variable for storing VME data transfer cycle type. | |
624 | * @dwidth: Pointer to variable for storing VME data transfer width. | |
625 | * | |
626 | * Return configuration for provided VME master window. | |
627 | * | |
628 | * Return: Zero on success, -EINVAL if operation is not supported on this | |
629 | * device or if an invalid resource has been provided. | |
630 | */ | |
ead1f3e3 | 631 | int vme_master_get(struct vme_resource *resource, int *enabled, |
6af04b06 MW |
632 | unsigned long long *vme_base, unsigned long long *size, u32 *aspace, |
633 | u32 *cycle, u32 *dwidth) | |
a17a75e2 MW |
634 | { |
635 | struct vme_bridge *bridge = find_bridge(resource); | |
636 | struct vme_master_resource *image; | |
637 | ||
638 | if (resource->type != VME_MASTER) { | |
ead1f3e3 | 639 | printk(KERN_ERR "Not a master resource\n"); |
a17a75e2 MW |
640 | return -EINVAL; |
641 | } | |
642 | ||
643 | image = list_entry(resource->entry, struct vme_master_resource, list); | |
644 | ||
51a569f7 | 645 | if (bridge->master_get == NULL) { |
c1038307 | 646 | printk(KERN_WARNING "%s not supported\n", __func__); |
a17a75e2 MW |
647 | return -EINVAL; |
648 | } | |
649 | ||
650 | return bridge->master_get(image, enabled, vme_base, size, aspace, | |
651 | cycle, dwidth); | |
652 | } | |
653 | EXPORT_SYMBOL(vme_master_get); | |
654 | ||
b5bc980a MW |
655 | /** |
656 | * vme_master_write - Read data from VME space into a buffer. | |
657 | * @resource: Pointer to VME master resource. | |
658 | * @buf: Pointer to buffer where data should be transferred. | |
659 | * @count: Number of bytes to transfer. | |
660 | * @offset: Offset into VME master window at which to start transfer. | |
661 | * | |
662 | * Perform read of count bytes of data from location on VME bus which maps into | |
663 | * the VME master window at offset to buf. | |
664 | * | |
665 | * Return: Number of bytes read, -EINVAL if resource is not a VME master | |
666 | * resource or read operation is not supported. -EFAULT returned if | |
667 | * invalid offset is provided. Hardware specific errors may also be | |
668 | * returned. | |
a17a75e2 | 669 | */ |
ead1f3e3 | 670 | ssize_t vme_master_read(struct vme_resource *resource, void *buf, size_t count, |
a17a75e2 MW |
671 | loff_t offset) |
672 | { | |
673 | struct vme_bridge *bridge = find_bridge(resource); | |
674 | struct vme_master_resource *image; | |
675 | size_t length; | |
676 | ||
677 | if (bridge->master_read == NULL) { | |
ead1f3e3 | 678 | printk(KERN_WARNING "Reading from resource not supported\n"); |
a17a75e2 MW |
679 | return -EINVAL; |
680 | } | |
681 | ||
682 | if (resource->type != VME_MASTER) { | |
ead1f3e3 | 683 | printk(KERN_ERR "Not a master resource\n"); |
a17a75e2 MW |
684 | return -EINVAL; |
685 | } | |
686 | ||
687 | image = list_entry(resource->entry, struct vme_master_resource, list); | |
688 | ||
689 | length = vme_get_size(resource); | |
690 | ||
691 | if (offset > length) { | |
ead1f3e3 | 692 | printk(KERN_WARNING "Invalid Offset\n"); |
a17a75e2 MW |
693 | return -EFAULT; |
694 | } | |
695 | ||
696 | if ((offset + count) > length) | |
697 | count = length - offset; | |
698 | ||
699 | return bridge->master_read(image, buf, count, offset); | |
700 | ||
701 | } | |
702 | EXPORT_SYMBOL(vme_master_read); | |
703 | ||
b5bc980a MW |
704 | /** |
705 | * vme_master_write - Write data out to VME space from a buffer. | |
706 | * @resource: Pointer to VME master resource. | |
707 | * @buf: Pointer to buffer holding data to transfer. | |
708 | * @count: Number of bytes to transfer. | |
709 | * @offset: Offset into VME master window at which to start transfer. | |
710 | * | |
711 | * Perform write of count bytes of data from buf to location on VME bus which | |
712 | * maps into the VME master window at offset. | |
713 | * | |
714 | * Return: Number of bytes written, -EINVAL if resource is not a VME master | |
715 | * resource or write operation is not supported. -EFAULT returned if | |
716 | * invalid offset is provided. Hardware specific errors may also be | |
717 | * returned. | |
a17a75e2 | 718 | */ |
ead1f3e3 | 719 | ssize_t vme_master_write(struct vme_resource *resource, void *buf, |
a17a75e2 MW |
720 | size_t count, loff_t offset) |
721 | { | |
722 | struct vme_bridge *bridge = find_bridge(resource); | |
723 | struct vme_master_resource *image; | |
724 | size_t length; | |
725 | ||
726 | if (bridge->master_write == NULL) { | |
ead1f3e3 | 727 | printk(KERN_WARNING "Writing to resource not supported\n"); |
a17a75e2 MW |
728 | return -EINVAL; |
729 | } | |
730 | ||
731 | if (resource->type != VME_MASTER) { | |
ead1f3e3 | 732 | printk(KERN_ERR "Not a master resource\n"); |
a17a75e2 MW |
733 | return -EINVAL; |
734 | } | |
735 | ||
736 | image = list_entry(resource->entry, struct vme_master_resource, list); | |
737 | ||
738 | length = vme_get_size(resource); | |
739 | ||
740 | if (offset > length) { | |
ead1f3e3 | 741 | printk(KERN_WARNING "Invalid Offset\n"); |
a17a75e2 MW |
742 | return -EFAULT; |
743 | } | |
744 | ||
745 | if ((offset + count) > length) | |
746 | count = length - offset; | |
747 | ||
748 | return bridge->master_write(image, buf, count, offset); | |
749 | } | |
750 | EXPORT_SYMBOL(vme_master_write); | |
751 | ||
b5bc980a MW |
752 | /** |
753 | * vme_master_rmw - Perform read-modify-write cycle. | |
754 | * @resource: Pointer to VME master resource. | |
755 | * @mask: Bits to be compared and swapped in operation. | |
756 | * @compare: Bits to be compared with data read from offset. | |
757 | * @swap: Bits to be swapped in data read from offset. | |
758 | * @offset: Offset into VME master window at which to perform operation. | |
759 | * | |
760 | * Perform read-modify-write cycle on provided location: | |
761 | * - Location on VME bus is read. | |
762 | * - Bits selected by mask are compared with compare. | |
763 | * - Where a selected bit matches that in compare and are selected in swap, | |
764 | * the bit is swapped. | |
765 | * - Result written back to location on VME bus. | |
766 | * | |
767 | * Return: Bytes written on success, -EINVAL if resource is not a VME master | |
768 | * resource or RMW operation is not supported. Hardware specific | |
769 | * errors may also be returned. | |
a17a75e2 | 770 | */ |
ead1f3e3 | 771 | unsigned int vme_master_rmw(struct vme_resource *resource, unsigned int mask, |
a17a75e2 MW |
772 | unsigned int compare, unsigned int swap, loff_t offset) |
773 | { | |
774 | struct vme_bridge *bridge = find_bridge(resource); | |
775 | struct vme_master_resource *image; | |
776 | ||
777 | if (bridge->master_rmw == NULL) { | |
ead1f3e3 | 778 | printk(KERN_WARNING "Writing to resource not supported\n"); |
a17a75e2 MW |
779 | return -EINVAL; |
780 | } | |
781 | ||
782 | if (resource->type != VME_MASTER) { | |
ead1f3e3 | 783 | printk(KERN_ERR "Not a master resource\n"); |
a17a75e2 MW |
784 | return -EINVAL; |
785 | } | |
786 | ||
787 | image = list_entry(resource->entry, struct vme_master_resource, list); | |
788 | ||
789 | return bridge->master_rmw(image, mask, compare, swap, offset); | |
790 | } | |
791 | EXPORT_SYMBOL(vme_master_rmw); | |
792 | ||
b5bc980a MW |
793 | /** |
794 | * vme_master_mmap - Mmap region of VME master window. | |
795 | * @resource: Pointer to VME master resource. | |
796 | * @vma: Pointer to definition of user mapping. | |
797 | * | |
798 | * Memory map a region of the VME master window into user space. | |
799 | * | |
800 | * Return: Zero on success, -EINVAL if resource is not a VME master | |
801 | * resource or -EFAULT if map exceeds window size. Other generic mmap | |
802 | * errors may also be returned. | |
803 | */ | |
c74a804f DK |
804 | int vme_master_mmap(struct vme_resource *resource, struct vm_area_struct *vma) |
805 | { | |
806 | struct vme_master_resource *image; | |
807 | phys_addr_t phys_addr; | |
808 | unsigned long vma_size; | |
809 | ||
810 | if (resource->type != VME_MASTER) { | |
811 | pr_err("Not a master resource\n"); | |
812 | return -EINVAL; | |
813 | } | |
814 | ||
815 | image = list_entry(resource->entry, struct vme_master_resource, list); | |
816 | phys_addr = image->bus_resource.start + (vma->vm_pgoff << PAGE_SHIFT); | |
817 | vma_size = vma->vm_end - vma->vm_start; | |
818 | ||
819 | if (phys_addr + vma_size > image->bus_resource.end + 1) { | |
820 | pr_err("Map size cannot exceed the window size\n"); | |
821 | return -EFAULT; | |
822 | } | |
823 | ||
824 | vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); | |
825 | ||
826 | return vm_iomap_memory(vma, phys_addr, vma->vm_end - vma->vm_start); | |
827 | } | |
828 | EXPORT_SYMBOL(vme_master_mmap); | |
829 | ||
b5bc980a MW |
830 | /** |
831 | * vme_master_free - Free VME master window | |
832 | * @resource: Pointer to VME master resource. | |
833 | * | |
834 | * Free the provided master resource so that it may be reallocated. | |
835 | */ | |
a17a75e2 MW |
836 | void vme_master_free(struct vme_resource *resource) |
837 | { | |
838 | struct vme_master_resource *master_image; | |
839 | ||
840 | if (resource->type != VME_MASTER) { | |
ead1f3e3 | 841 | printk(KERN_ERR "Not a master resource\n"); |
a17a75e2 MW |
842 | return; |
843 | } | |
844 | ||
845 | master_image = list_entry(resource->entry, struct vme_master_resource, | |
846 | list); | |
847 | if (master_image == NULL) { | |
ead1f3e3 | 848 | printk(KERN_ERR "Can't find master resource\n"); |
a17a75e2 MW |
849 | return; |
850 | } | |
851 | ||
852 | /* Unlock image */ | |
886953e9 | 853 | spin_lock(&master_image->lock); |
a17a75e2 MW |
854 | if (master_image->locked == 0) |
855 | printk(KERN_ERR "Image is already free\n"); | |
856 | ||
857 | master_image->locked = 0; | |
886953e9 | 858 | spin_unlock(&master_image->lock); |
a17a75e2 MW |
859 | |
860 | /* Free up resource memory */ | |
861 | kfree(resource); | |
862 | } | |
863 | EXPORT_SYMBOL(vme_master_free); | |
864 | ||
b5bc980a MW |
865 | /** |
866 | * vme_dma_request - Request a DMA controller. | |
867 | * @vdev: Pointer to VME device struct vme_dev assigned to driver instance. | |
868 | * @route: Required src/destination combination. | |
869 | * | |
870 | * Request a VME DMA controller with capability to perform transfers bewteen | |
871 | * requested source/destination combination. | |
872 | * | |
873 | * Return: Pointer to VME DMA resource on success, NULL on failure. | |
a17a75e2 | 874 | */ |
6af04b06 | 875 | struct vme_resource *vme_dma_request(struct vme_dev *vdev, u32 route) |
a17a75e2 MW |
876 | { |
877 | struct vme_bridge *bridge; | |
878 | struct list_head *dma_pos = NULL; | |
879 | struct vme_dma_resource *allocated_ctrlr = NULL; | |
880 | struct vme_dma_resource *dma_ctrlr = NULL; | |
881 | struct vme_resource *resource = NULL; | |
882 | ||
883 | /* XXX Not checking resource attributes */ | |
884 | printk(KERN_ERR "No VME resource Attribute tests done\n"); | |
885 | ||
8f966dc4 | 886 | bridge = vdev->bridge; |
a17a75e2 MW |
887 | if (bridge == NULL) { |
888 | printk(KERN_ERR "Can't find VME bus\n"); | |
889 | goto err_bus; | |
890 | } | |
891 | ||
892 | /* Loop through DMA resources */ | |
886953e9 | 893 | list_for_each(dma_pos, &bridge->dma_resources) { |
a17a75e2 MW |
894 | dma_ctrlr = list_entry(dma_pos, |
895 | struct vme_dma_resource, list); | |
896 | ||
897 | if (dma_ctrlr == NULL) { | |
ead1f3e3 | 898 | printk(KERN_ERR "Registered NULL DMA resource\n"); |
a17a75e2 MW |
899 | continue; |
900 | } | |
901 | ||
4f723df4 | 902 | /* Find an unlocked and compatible controller */ |
886953e9 | 903 | mutex_lock(&dma_ctrlr->mtx); |
4f723df4 MW |
904 | if (((dma_ctrlr->route_attr & route) == route) && |
905 | (dma_ctrlr->locked == 0)) { | |
906 | ||
a17a75e2 | 907 | dma_ctrlr->locked = 1; |
886953e9 | 908 | mutex_unlock(&dma_ctrlr->mtx); |
a17a75e2 MW |
909 | allocated_ctrlr = dma_ctrlr; |
910 | break; | |
911 | } | |
886953e9 | 912 | mutex_unlock(&dma_ctrlr->mtx); |
a17a75e2 MW |
913 | } |
914 | ||
915 | /* Check to see if we found a resource */ | |
916 | if (allocated_ctrlr == NULL) | |
917 | goto err_ctrlr; | |
918 | ||
1ff0a19c | 919 | resource = kmalloc(sizeof(*resource), GFP_KERNEL); |
94eefcc1 | 920 | if (!resource) |
a17a75e2 | 921 | goto err_alloc; |
94eefcc1 | 922 | |
a17a75e2 | 923 | resource->type = VME_DMA; |
886953e9 | 924 | resource->entry = &allocated_ctrlr->list; |
a17a75e2 MW |
925 | |
926 | return resource; | |
927 | ||
928 | err_alloc: | |
929 | /* Unlock image */ | |
886953e9 | 930 | mutex_lock(&dma_ctrlr->mtx); |
a17a75e2 | 931 | dma_ctrlr->locked = 0; |
886953e9 | 932 | mutex_unlock(&dma_ctrlr->mtx); |
a17a75e2 MW |
933 | err_ctrlr: |
934 | err_bus: | |
935 | return NULL; | |
936 | } | |
58e50798 | 937 | EXPORT_SYMBOL(vme_dma_request); |
a17a75e2 | 938 | |
b5bc980a MW |
939 | /** |
940 | * vme_new_dma_list - Create new VME DMA list. | |
941 | * @resource: Pointer to VME DMA resource. | |
942 | * | |
943 | * Create a new VME DMA list. It is the responsibility of the user to free | |
944 | * the list once it is no longer required with vme_dma_list_free(). | |
945 | * | |
946 | * Return: Pointer to new VME DMA list, NULL on allocation failure or invalid | |
947 | * VME DMA resource. | |
a17a75e2 MW |
948 | */ |
949 | struct vme_dma_list *vme_new_dma_list(struct vme_resource *resource) | |
950 | { | |
951 | struct vme_dma_resource *ctrlr; | |
952 | struct vme_dma_list *dma_list; | |
953 | ||
954 | if (resource->type != VME_DMA) { | |
ead1f3e3 | 955 | printk(KERN_ERR "Not a DMA resource\n"); |
a17a75e2 MW |
956 | return NULL; |
957 | } | |
958 | ||
959 | ctrlr = list_entry(resource->entry, struct vme_dma_resource, list); | |
960 | ||
1ff0a19c | 961 | dma_list = kmalloc(sizeof(*dma_list), GFP_KERNEL); |
94eefcc1 | 962 | if (!dma_list) |
a17a75e2 | 963 | return NULL; |
94eefcc1 | 964 | |
886953e9 | 965 | INIT_LIST_HEAD(&dma_list->entries); |
a17a75e2 | 966 | dma_list->parent = ctrlr; |
886953e9 | 967 | mutex_init(&dma_list->mtx); |
a17a75e2 MW |
968 | |
969 | return dma_list; | |
970 | } | |
971 | EXPORT_SYMBOL(vme_new_dma_list); | |
972 | ||
b5bc980a MW |
973 | /** |
974 | * vme_dma_pattern_attribute - Create "Pattern" type VME DMA list attribute. | |
975 | * @pattern: Value to use used as pattern | |
976 | * @type: Type of pattern to be written. | |
977 | * | |
978 | * Create VME DMA list attribute for pattern generation. It is the | |
979 | * responsibility of the user to free used attributes using | |
980 | * vme_dma_free_attribute(). | |
981 | * | |
982 | * Return: Pointer to VME DMA attribute, NULL on failure. | |
a17a75e2 | 983 | */ |
6af04b06 | 984 | struct vme_dma_attr *vme_dma_pattern_attribute(u32 pattern, u32 type) |
a17a75e2 MW |
985 | { |
986 | struct vme_dma_attr *attributes; | |
987 | struct vme_dma_pattern *pattern_attr; | |
988 | ||
1ff0a19c | 989 | attributes = kmalloc(sizeof(*attributes), GFP_KERNEL); |
94eefcc1 | 990 | if (!attributes) |
a17a75e2 | 991 | goto err_attr; |
a17a75e2 | 992 | |
1ff0a19c | 993 | pattern_attr = kmalloc(sizeof(*pattern_attr), GFP_KERNEL); |
94eefcc1 | 994 | if (!pattern_attr) |
a17a75e2 | 995 | goto err_pat; |
a17a75e2 MW |
996 | |
997 | attributes->type = VME_DMA_PATTERN; | |
998 | attributes->private = (void *)pattern_attr; | |
999 | ||
1000 | pattern_attr->pattern = pattern; | |
1001 | pattern_attr->type = type; | |
1002 | ||
1003 | return attributes; | |
1004 | ||
a17a75e2 MW |
1005 | err_pat: |
1006 | kfree(attributes); | |
1007 | err_attr: | |
1008 | return NULL; | |
1009 | } | |
1010 | EXPORT_SYMBOL(vme_dma_pattern_attribute); | |
1011 | ||
b5bc980a MW |
1012 | /** |
1013 | * vme_dma_pci_attribute - Create "PCI" type VME DMA list attribute. | |
1014 | * @address: PCI base address for DMA transfer. | |
1015 | * | |
1016 | * Create VME DMA list attribute pointing to a location on PCI for DMA | |
1017 | * transfers. It is the responsibility of the user to free used attributes | |
1018 | * using vme_dma_free_attribute(). | |
1019 | * | |
1020 | * Return: Pointer to VME DMA attribute, NULL on failure. | |
a17a75e2 MW |
1021 | */ |
1022 | struct vme_dma_attr *vme_dma_pci_attribute(dma_addr_t address) | |
1023 | { | |
1024 | struct vme_dma_attr *attributes; | |
1025 | struct vme_dma_pci *pci_attr; | |
1026 | ||
1027 | /* XXX Run some sanity checks here */ | |
1028 | ||
1ff0a19c | 1029 | attributes = kmalloc(sizeof(*attributes), GFP_KERNEL); |
94eefcc1 | 1030 | if (!attributes) |
a17a75e2 | 1031 | goto err_attr; |
a17a75e2 | 1032 | |
1ff0a19c | 1033 | pci_attr = kmalloc(sizeof(*pci_attr), GFP_KERNEL); |
94eefcc1 | 1034 | if (!pci_attr) |
a17a75e2 | 1035 | goto err_pci; |
a17a75e2 MW |
1036 | |
1037 | attributes->type = VME_DMA_PCI; | |
1038 | attributes->private = (void *)pci_attr; | |
1039 | ||
1040 | pci_attr->address = address; | |
1041 | ||
1042 | return attributes; | |
1043 | ||
a17a75e2 MW |
1044 | err_pci: |
1045 | kfree(attributes); | |
1046 | err_attr: | |
1047 | return NULL; | |
1048 | } | |
1049 | EXPORT_SYMBOL(vme_dma_pci_attribute); | |
1050 | ||
b5bc980a MW |
1051 | /** |
1052 | * vme_dma_vme_attribute - Create "VME" type VME DMA list attribute. | |
1053 | * @address: VME base address for DMA transfer. | |
1054 | * @aspace: VME address space to use for DMA transfer. | |
1055 | * @cycle: VME bus cycle to use for DMA transfer. | |
1056 | * @dwidth: VME data width to use for DMA transfer. | |
1057 | * | |
1058 | * Create VME DMA list attribute pointing to a location on the VME bus for DMA | |
1059 | * transfers. It is the responsibility of the user to free used attributes | |
1060 | * using vme_dma_free_attribute(). | |
1061 | * | |
1062 | * Return: Pointer to VME DMA attribute, NULL on failure. | |
a17a75e2 MW |
1063 | */ |
1064 | struct vme_dma_attr *vme_dma_vme_attribute(unsigned long long address, | |
6af04b06 | 1065 | u32 aspace, u32 cycle, u32 dwidth) |
a17a75e2 MW |
1066 | { |
1067 | struct vme_dma_attr *attributes; | |
1068 | struct vme_dma_vme *vme_attr; | |
1069 | ||
1ff0a19c | 1070 | attributes = kmalloc(sizeof(*attributes), GFP_KERNEL); |
94eefcc1 | 1071 | if (!attributes) |
a17a75e2 | 1072 | goto err_attr; |
a17a75e2 | 1073 | |
1ff0a19c | 1074 | vme_attr = kmalloc(sizeof(*vme_attr), GFP_KERNEL); |
94eefcc1 | 1075 | if (!vme_attr) |
a17a75e2 | 1076 | goto err_vme; |
a17a75e2 MW |
1077 | |
1078 | attributes->type = VME_DMA_VME; | |
1079 | attributes->private = (void *)vme_attr; | |
1080 | ||
1081 | vme_attr->address = address; | |
1082 | vme_attr->aspace = aspace; | |
1083 | vme_attr->cycle = cycle; | |
1084 | vme_attr->dwidth = dwidth; | |
1085 | ||
1086 | return attributes; | |
1087 | ||
a17a75e2 MW |
1088 | err_vme: |
1089 | kfree(attributes); | |
1090 | err_attr: | |
1091 | return NULL; | |
1092 | } | |
1093 | EXPORT_SYMBOL(vme_dma_vme_attribute); | |
1094 | ||
b5bc980a MW |
1095 | /** |
1096 | * vme_dma_free_attribute - Free DMA list attribute. | |
1097 | * @attributes: Pointer to DMA list attribute. | |
1098 | * | |
1099 | * Free VME DMA list attribute. VME DMA list attributes can be safely freed | |
1100 | * once vme_dma_list_add() has returned. | |
a17a75e2 MW |
1101 | */ |
1102 | void vme_dma_free_attribute(struct vme_dma_attr *attributes) | |
1103 | { | |
1104 | kfree(attributes->private); | |
1105 | kfree(attributes); | |
1106 | } | |
1107 | EXPORT_SYMBOL(vme_dma_free_attribute); | |
1108 | ||
b5bc980a MW |
1109 | /** |
1110 | * vme_dma_list_add - Add enty to a VME DMA list. | |
1111 | * @list: Pointer to VME list. | |
1112 | * @src: Pointer to DMA list attribute to use as source. | |
1113 | * @dest: Pointer to DMA list attribute to use as destination. | |
1114 | * @count: Number of bytes to transfer. | |
1115 | * | |
1116 | * Add an entry to the provided VME DMA list. Entry requires pointers to source | |
1117 | * and destination DMA attributes and a count. | |
1118 | * | |
1119 | * Please note, the attributes supported as source and destinations for | |
1120 | * transfers are hardware dependent. | |
1121 | * | |
1122 | * Return: Zero on success, -EINVAL if operation is not supported on this | |
1123 | * device or if the link list has already been submitted for execution. | |
1124 | * Hardware specific errors also possible. | |
1125 | */ | |
a17a75e2 MW |
1126 | int vme_dma_list_add(struct vme_dma_list *list, struct vme_dma_attr *src, |
1127 | struct vme_dma_attr *dest, size_t count) | |
1128 | { | |
1129 | struct vme_bridge *bridge = list->parent->parent; | |
1130 | int retval; | |
1131 | ||
1132 | if (bridge->dma_list_add == NULL) { | |
ead1f3e3 | 1133 | printk(KERN_WARNING "Link List DMA generation not supported\n"); |
a17a75e2 MW |
1134 | return -EINVAL; |
1135 | } | |
1136 | ||
886953e9 | 1137 | if (!mutex_trylock(&list->mtx)) { |
ead1f3e3 | 1138 | printk(KERN_ERR "Link List already submitted\n"); |
a17a75e2 MW |
1139 | return -EINVAL; |
1140 | } | |
1141 | ||
1142 | retval = bridge->dma_list_add(list, src, dest, count); | |
1143 | ||
886953e9 | 1144 | mutex_unlock(&list->mtx); |
a17a75e2 MW |
1145 | |
1146 | return retval; | |
1147 | } | |
1148 | EXPORT_SYMBOL(vme_dma_list_add); | |
1149 | ||
b5bc980a MW |
1150 | /** |
1151 | * vme_dma_list_exec - Queue a VME DMA list for execution. | |
1152 | * @list: Pointer to VME list. | |
1153 | * | |
1154 | * Queue the provided VME DMA list for execution. The call will return once the | |
1155 | * list has been executed. | |
1156 | * | |
1157 | * Return: Zero on success, -EINVAL if operation is not supported on this | |
1158 | * device. Hardware specific errors also possible. | |
1159 | */ | |
a17a75e2 MW |
1160 | int vme_dma_list_exec(struct vme_dma_list *list) |
1161 | { | |
1162 | struct vme_bridge *bridge = list->parent->parent; | |
1163 | int retval; | |
1164 | ||
1165 | if (bridge->dma_list_exec == NULL) { | |
ead1f3e3 | 1166 | printk(KERN_ERR "Link List DMA execution not supported\n"); |
a17a75e2 MW |
1167 | return -EINVAL; |
1168 | } | |
1169 | ||
886953e9 | 1170 | mutex_lock(&list->mtx); |
a17a75e2 MW |
1171 | |
1172 | retval = bridge->dma_list_exec(list); | |
1173 | ||
886953e9 | 1174 | mutex_unlock(&list->mtx); |
a17a75e2 MW |
1175 | |
1176 | return retval; | |
1177 | } | |
1178 | EXPORT_SYMBOL(vme_dma_list_exec); | |
1179 | ||
b5bc980a MW |
1180 | /** |
1181 | * vme_dma_list_free - Free a VME DMA list. | |
1182 | * @list: Pointer to VME list. | |
1183 | * | |
1184 | * Free the provided DMA list and all its entries. | |
1185 | * | |
1186 | * Return: Zero on success, -EINVAL on invalid VME resource, -EBUSY if resource | |
1187 | * is still in use. Hardware specific errors also possible. | |
1188 | */ | |
a17a75e2 MW |
1189 | int vme_dma_list_free(struct vme_dma_list *list) |
1190 | { | |
1191 | struct vme_bridge *bridge = list->parent->parent; | |
1192 | int retval; | |
1193 | ||
1194 | if (bridge->dma_list_empty == NULL) { | |
ead1f3e3 | 1195 | printk(KERN_WARNING "Emptying of Link Lists not supported\n"); |
a17a75e2 MW |
1196 | return -EINVAL; |
1197 | } | |
1198 | ||
886953e9 | 1199 | if (!mutex_trylock(&list->mtx)) { |
ead1f3e3 | 1200 | printk(KERN_ERR "Link List in use\n"); |
a17a75e2 MW |
1201 | return -EINVAL; |
1202 | } | |
1203 | ||
1204 | /* | |
f56c3d4f AS |
1205 | * Empty out all of the entries from the DMA list. We need to go to the |
1206 | * low level driver as DMA entries are driver specific. | |
a17a75e2 MW |
1207 | */ |
1208 | retval = bridge->dma_list_empty(list); | |
1209 | if (retval) { | |
ead1f3e3 | 1210 | printk(KERN_ERR "Unable to empty link-list entries\n"); |
886953e9 | 1211 | mutex_unlock(&list->mtx); |
a17a75e2 MW |
1212 | return retval; |
1213 | } | |
886953e9 | 1214 | mutex_unlock(&list->mtx); |
a17a75e2 MW |
1215 | kfree(list); |
1216 | ||
1217 | return retval; | |
1218 | } | |
1219 | EXPORT_SYMBOL(vme_dma_list_free); | |
1220 | ||
b5bc980a MW |
1221 | /** |
1222 | * vme_dma_free - Free a VME DMA resource. | |
1223 | * @resource: Pointer to VME DMA resource. | |
1224 | * | |
1225 | * Free the provided DMA resource so that it may be reallocated. | |
1226 | * | |
1227 | * Return: Zero on success, -EINVAL on invalid VME resource, -EBUSY if resource | |
1228 | * is still active. | |
1229 | */ | |
a17a75e2 MW |
1230 | int vme_dma_free(struct vme_resource *resource) |
1231 | { | |
1232 | struct vme_dma_resource *ctrlr; | |
1233 | ||
1234 | if (resource->type != VME_DMA) { | |
ead1f3e3 | 1235 | printk(KERN_ERR "Not a DMA resource\n"); |
a17a75e2 MW |
1236 | return -EINVAL; |
1237 | } | |
1238 | ||
1239 | ctrlr = list_entry(resource->entry, struct vme_dma_resource, list); | |
1240 | ||
886953e9 | 1241 | if (!mutex_trylock(&ctrlr->mtx)) { |
ead1f3e3 | 1242 | printk(KERN_ERR "Resource busy, can't free\n"); |
a17a75e2 MW |
1243 | return -EBUSY; |
1244 | } | |
1245 | ||
886953e9 | 1246 | if (!(list_empty(&ctrlr->pending) && list_empty(&ctrlr->running))) { |
ead1f3e3 | 1247 | printk(KERN_WARNING "Resource still processing transfers\n"); |
886953e9 | 1248 | mutex_unlock(&ctrlr->mtx); |
a17a75e2 MW |
1249 | return -EBUSY; |
1250 | } | |
1251 | ||
1252 | ctrlr->locked = 0; | |
1253 | ||
886953e9 | 1254 | mutex_unlock(&ctrlr->mtx); |
a17a75e2 | 1255 | |
fd5c2561 MW |
1256 | kfree(resource); |
1257 | ||
a17a75e2 MW |
1258 | return 0; |
1259 | } | |
1260 | EXPORT_SYMBOL(vme_dma_free); | |
1261 | ||
e2c6393f | 1262 | void vme_bus_error_handler(struct vme_bridge *bridge, |
472f16f3 | 1263 | unsigned long long address, int am) |
e2c6393f | 1264 | { |
0b049662 DK |
1265 | struct list_head *handler_pos = NULL; |
1266 | struct vme_error_handler *handler; | |
448535a3 | 1267 | int handler_triggered = 0; |
0b049662 DK |
1268 | u32 aspace = vme_get_aspace(am); |
1269 | ||
1270 | list_for_each(handler_pos, &bridge->vme_error_handlers) { | |
1271 | handler = list_entry(handler_pos, struct vme_error_handler, | |
1272 | list); | |
1273 | if ((aspace == handler->aspace) && | |
1274 | (address >= handler->start) && | |
1275 | (address < handler->end)) { | |
1276 | if (!handler->num_errors) | |
1277 | handler->first_error = address; | |
1278 | if (handler->num_errors != UINT_MAX) | |
1279 | handler->num_errors++; | |
448535a3 | 1280 | handler_triggered = 1; |
0b049662 | 1281 | } |
e2c6393f | 1282 | } |
448535a3 DK |
1283 | |
1284 | if (!handler_triggered) | |
1285 | dev_err(bridge->parent, | |
1286 | "Unhandled VME access error at address 0x%llx\n", | |
1287 | address); | |
e2c6393f DK |
1288 | } |
1289 | EXPORT_SYMBOL(vme_bus_error_handler); | |
1290 | ||
0b049662 DK |
1291 | struct vme_error_handler *vme_register_error_handler( |
1292 | struct vme_bridge *bridge, u32 aspace, | |
1293 | unsigned long long address, size_t len) | |
e2c6393f | 1294 | { |
0b049662 | 1295 | struct vme_error_handler *handler; |
e2c6393f | 1296 | |
0b049662 DK |
1297 | handler = kmalloc(sizeof(*handler), GFP_KERNEL); |
1298 | if (!handler) | |
1299 | return NULL; | |
e2c6393f | 1300 | |
0b049662 DK |
1301 | handler->aspace = aspace; |
1302 | handler->start = address; | |
1303 | handler->end = address + len; | |
1304 | handler->num_errors = 0; | |
1305 | handler->first_error = 0; | |
1306 | list_add_tail(&handler->list, &bridge->vme_error_handlers); | |
e2c6393f | 1307 | |
0b049662 | 1308 | return handler; |
e2c6393f | 1309 | } |
0b049662 | 1310 | EXPORT_SYMBOL(vme_register_error_handler); |
e2c6393f | 1311 | |
0b049662 | 1312 | void vme_unregister_error_handler(struct vme_error_handler *handler) |
e2c6393f | 1313 | { |
0b049662 DK |
1314 | list_del(&handler->list); |
1315 | kfree(handler); | |
e2c6393f | 1316 | } |
0b049662 | 1317 | EXPORT_SYMBOL(vme_unregister_error_handler); |
e2c6393f | 1318 | |
c813f592 MW |
1319 | void vme_irq_handler(struct vme_bridge *bridge, int level, int statid) |
1320 | { | |
1321 | void (*call)(int, int, void *); | |
1322 | void *priv_data; | |
1323 | ||
1324 | call = bridge->irq[level - 1].callback[statid].func; | |
1325 | priv_data = bridge->irq[level - 1].callback[statid].priv_data; | |
1326 | ||
1327 | if (call != NULL) | |
1328 | call(level, statid, priv_data); | |
1329 | else | |
f56c3d4f | 1330 | printk(KERN_WARNING "Spurious VME interrupt, level:%x, vector:%x\n", |
25958ce3 | 1331 | level, statid); |
c813f592 MW |
1332 | } |
1333 | EXPORT_SYMBOL(vme_irq_handler); | |
1334 | ||
b5bc980a MW |
1335 | /** |
1336 | * vme_irq_request - Request a specific VME interrupt. | |
1337 | * @vdev: Pointer to VME device struct vme_dev assigned to driver instance. | |
1338 | * @level: Interrupt priority being requested. | |
1339 | * @statid: Interrupt vector being requested. | |
1340 | * @callback: Pointer to callback function called when VME interrupt/vector | |
1341 | * received. | |
1342 | * @priv_data: Generic pointer that will be passed to the callback function. | |
1343 | * | |
1344 | * Request callback to be attached as a handler for VME interrupts with provided | |
1345 | * level and statid. | |
1346 | * | |
1347 | * Return: Zero on success, -EINVAL on invalid vme device, level or if the | |
1348 | * function is not supported, -EBUSY if the level/statid combination is | |
1349 | * already in use. Hardware specific errors also possible. | |
1350 | */ | |
8f966dc4 | 1351 | int vme_irq_request(struct vme_dev *vdev, int level, int statid, |
29848ac9 | 1352 | void (*callback)(int, int, void *), |
a17a75e2 MW |
1353 | void *priv_data) |
1354 | { | |
1355 | struct vme_bridge *bridge; | |
1356 | ||
8f966dc4 | 1357 | bridge = vdev->bridge; |
a17a75e2 MW |
1358 | if (bridge == NULL) { |
1359 | printk(KERN_ERR "Can't find VME bus\n"); | |
1360 | return -EINVAL; | |
1361 | } | |
1362 | ||
ead1f3e3 | 1363 | if ((level < 1) || (level > 7)) { |
c813f592 | 1364 | printk(KERN_ERR "Invalid interrupt level\n"); |
a17a75e2 MW |
1365 | return -EINVAL; |
1366 | } | |
1367 | ||
c813f592 MW |
1368 | if (bridge->irq_set == NULL) { |
1369 | printk(KERN_ERR "Configuring interrupts not supported\n"); | |
a17a75e2 MW |
1370 | return -EINVAL; |
1371 | } | |
1372 | ||
886953e9 | 1373 | mutex_lock(&bridge->irq_mtx); |
c813f592 MW |
1374 | |
1375 | if (bridge->irq[level - 1].callback[statid].func) { | |
886953e9 | 1376 | mutex_unlock(&bridge->irq_mtx); |
c813f592 MW |
1377 | printk(KERN_WARNING "VME Interrupt already taken\n"); |
1378 | return -EBUSY; | |
1379 | } | |
1380 | ||
1381 | bridge->irq[level - 1].count++; | |
1382 | bridge->irq[level - 1].callback[statid].priv_data = priv_data; | |
1383 | bridge->irq[level - 1].callback[statid].func = callback; | |
1384 | ||
1385 | /* Enable IRQ level */ | |
29848ac9 | 1386 | bridge->irq_set(bridge, level, 1, 1); |
c813f592 | 1387 | |
886953e9 | 1388 | mutex_unlock(&bridge->irq_mtx); |
c813f592 MW |
1389 | |
1390 | return 0; | |
a17a75e2 | 1391 | } |
c813f592 | 1392 | EXPORT_SYMBOL(vme_irq_request); |
a17a75e2 | 1393 | |
b5bc980a MW |
1394 | /** |
1395 | * vme_irq_free - Free a VME interrupt. | |
1396 | * @vdev: Pointer to VME device struct vme_dev assigned to driver instance. | |
1397 | * @level: Interrupt priority of interrupt being freed. | |
1398 | * @statid: Interrupt vector of interrupt being freed. | |
1399 | * | |
1400 | * Remove previously attached callback from VME interrupt priority/vector. | |
1401 | */ | |
8f966dc4 | 1402 | void vme_irq_free(struct vme_dev *vdev, int level, int statid) |
a17a75e2 MW |
1403 | { |
1404 | struct vme_bridge *bridge; | |
1405 | ||
8f966dc4 | 1406 | bridge = vdev->bridge; |
a17a75e2 MW |
1407 | if (bridge == NULL) { |
1408 | printk(KERN_ERR "Can't find VME bus\n"); | |
1409 | return; | |
1410 | } | |
1411 | ||
ead1f3e3 | 1412 | if ((level < 1) || (level > 7)) { |
c813f592 | 1413 | printk(KERN_ERR "Invalid interrupt level\n"); |
a17a75e2 MW |
1414 | return; |
1415 | } | |
1416 | ||
c813f592 MW |
1417 | if (bridge->irq_set == NULL) { |
1418 | printk(KERN_ERR "Configuring interrupts not supported\n"); | |
a17a75e2 MW |
1419 | return; |
1420 | } | |
1421 | ||
886953e9 | 1422 | mutex_lock(&bridge->irq_mtx); |
c813f592 MW |
1423 | |
1424 | bridge->irq[level - 1].count--; | |
1425 | ||
1426 | /* Disable IRQ level if no more interrupts attached at this level*/ | |
1427 | if (bridge->irq[level - 1].count == 0) | |
29848ac9 | 1428 | bridge->irq_set(bridge, level, 0, 1); |
c813f592 MW |
1429 | |
1430 | bridge->irq[level - 1].callback[statid].func = NULL; | |
1431 | bridge->irq[level - 1].callback[statid].priv_data = NULL; | |
1432 | ||
886953e9 | 1433 | mutex_unlock(&bridge->irq_mtx); |
a17a75e2 | 1434 | } |
c813f592 | 1435 | EXPORT_SYMBOL(vme_irq_free); |
a17a75e2 | 1436 | |
b5bc980a MW |
1437 | /** |
1438 | * vme_irq_generate - Generate VME interrupt. | |
1439 | * @vdev: Pointer to VME device struct vme_dev assigned to driver instance. | |
1440 | * @level: Interrupt priority at which to assert the interrupt. | |
1441 | * @statid: Interrupt vector to associate with the interrupt. | |
1442 | * | |
1443 | * Generate a VME interrupt of the provided level and with the provided | |
1444 | * statid. | |
1445 | * | |
1446 | * Return: Zero on success, -EINVAL on invalid vme device, level or if the | |
1447 | * function is not supported. Hardware specific errors also possible. | |
1448 | */ | |
8f966dc4 | 1449 | int vme_irq_generate(struct vme_dev *vdev, int level, int statid) |
a17a75e2 MW |
1450 | { |
1451 | struct vme_bridge *bridge; | |
1452 | ||
8f966dc4 | 1453 | bridge = vdev->bridge; |
a17a75e2 MW |
1454 | if (bridge == NULL) { |
1455 | printk(KERN_ERR "Can't find VME bus\n"); | |
1456 | return -EINVAL; | |
1457 | } | |
1458 | ||
ead1f3e3 | 1459 | if ((level < 1) || (level > 7)) { |
a17a75e2 MW |
1460 | printk(KERN_WARNING "Invalid interrupt level\n"); |
1461 | return -EINVAL; | |
1462 | } | |
1463 | ||
c813f592 | 1464 | if (bridge->irq_generate == NULL) { |
ead1f3e3 | 1465 | printk(KERN_WARNING "Interrupt generation not supported\n"); |
a17a75e2 MW |
1466 | return -EINVAL; |
1467 | } | |
1468 | ||
29848ac9 | 1469 | return bridge->irq_generate(bridge, level, statid); |
a17a75e2 | 1470 | } |
c813f592 | 1471 | EXPORT_SYMBOL(vme_irq_generate); |
a17a75e2 | 1472 | |
b5bc980a MW |
1473 | /** |
1474 | * vme_lm_request - Request a VME location monitor | |
1475 | * @vdev: Pointer to VME device struct vme_dev assigned to driver instance. | |
1476 | * | |
1477 | * Allocate a location monitor resource to the driver. A location monitor | |
1478 | * allows the driver to monitor accesses to a contiguous number of | |
1479 | * addresses on the VME bus. | |
1480 | * | |
1481 | * Return: Pointer to a VME resource on success or NULL on failure. | |
42fb5031 | 1482 | */ |
8f966dc4 | 1483 | struct vme_resource *vme_lm_request(struct vme_dev *vdev) |
a17a75e2 MW |
1484 | { |
1485 | struct vme_bridge *bridge; | |
42fb5031 MW |
1486 | struct list_head *lm_pos = NULL; |
1487 | struct vme_lm_resource *allocated_lm = NULL; | |
1488 | struct vme_lm_resource *lm = NULL; | |
1489 | struct vme_resource *resource = NULL; | |
a17a75e2 | 1490 | |
8f966dc4 | 1491 | bridge = vdev->bridge; |
a17a75e2 MW |
1492 | if (bridge == NULL) { |
1493 | printk(KERN_ERR "Can't find VME bus\n"); | |
42fb5031 MW |
1494 | goto err_bus; |
1495 | } | |
1496 | ||
b5bc980a | 1497 | /* Loop through LM resources */ |
886953e9 | 1498 | list_for_each(lm_pos, &bridge->lm_resources) { |
42fb5031 MW |
1499 | lm = list_entry(lm_pos, |
1500 | struct vme_lm_resource, list); | |
1501 | ||
1502 | if (lm == NULL) { | |
25958ce3 | 1503 | printk(KERN_ERR "Registered NULL Location Monitor resource\n"); |
42fb5031 MW |
1504 | continue; |
1505 | } | |
1506 | ||
1507 | /* Find an unlocked controller */ | |
886953e9 | 1508 | mutex_lock(&lm->mtx); |
42fb5031 MW |
1509 | if (lm->locked == 0) { |
1510 | lm->locked = 1; | |
886953e9 | 1511 | mutex_unlock(&lm->mtx); |
42fb5031 MW |
1512 | allocated_lm = lm; |
1513 | break; | |
1514 | } | |
886953e9 | 1515 | mutex_unlock(&lm->mtx); |
42fb5031 MW |
1516 | } |
1517 | ||
1518 | /* Check to see if we found a resource */ | |
1519 | if (allocated_lm == NULL) | |
1520 | goto err_lm; | |
1521 | ||
1ff0a19c | 1522 | resource = kmalloc(sizeof(*resource), GFP_KERNEL); |
94eefcc1 | 1523 | if (!resource) |
42fb5031 | 1524 | goto err_alloc; |
94eefcc1 | 1525 | |
42fb5031 | 1526 | resource->type = VME_LM; |
886953e9 | 1527 | resource->entry = &allocated_lm->list; |
42fb5031 MW |
1528 | |
1529 | return resource; | |
1530 | ||
1531 | err_alloc: | |
1532 | /* Unlock image */ | |
886953e9 | 1533 | mutex_lock(&lm->mtx); |
42fb5031 | 1534 | lm->locked = 0; |
886953e9 | 1535 | mutex_unlock(&lm->mtx); |
42fb5031 MW |
1536 | err_lm: |
1537 | err_bus: | |
1538 | return NULL; | |
1539 | } | |
1540 | EXPORT_SYMBOL(vme_lm_request); | |
1541 | ||
b5bc980a MW |
1542 | /** |
1543 | * vme_lm_count - Determine number of VME Addresses monitored | |
1544 | * @resource: Pointer to VME location monitor resource. | |
1545 | * | |
1546 | * The number of contiguous addresses monitored is hardware dependent. | |
1547 | * Return the number of contiguous addresses monitored by the | |
1548 | * location monitor. | |
1549 | * | |
1550 | * Return: Count of addresses monitored or -EINVAL when provided with an | |
1551 | * invalid location monitor resource. | |
1552 | */ | |
42fb5031 MW |
1553 | int vme_lm_count(struct vme_resource *resource) |
1554 | { | |
1555 | struct vme_lm_resource *lm; | |
1556 | ||
1557 | if (resource->type != VME_LM) { | |
1558 | printk(KERN_ERR "Not a Location Monitor resource\n"); | |
1559 | return -EINVAL; | |
1560 | } | |
1561 | ||
1562 | lm = list_entry(resource->entry, struct vme_lm_resource, list); | |
1563 | ||
1564 | return lm->monitors; | |
1565 | } | |
1566 | EXPORT_SYMBOL(vme_lm_count); | |
1567 | ||
b5bc980a MW |
1568 | /** |
1569 | * vme_lm_set - Configure location monitor | |
1570 | * @resource: Pointer to VME location monitor resource. | |
1571 | * @lm_base: Base address to monitor. | |
1572 | * @aspace: VME address space to monitor. | |
1573 | * @cycle: VME bus cycle type to monitor. | |
1574 | * | |
1575 | * Set the base address, address space and cycle type of accesses to be | |
1576 | * monitored by the location monitor. | |
1577 | * | |
1578 | * Return: Zero on success, -EINVAL when provided with an invalid location | |
1579 | * monitor resource or function is not supported. Hardware specific | |
1580 | * errors may also be returned. | |
1581 | */ | |
42fb5031 | 1582 | int vme_lm_set(struct vme_resource *resource, unsigned long long lm_base, |
6af04b06 | 1583 | u32 aspace, u32 cycle) |
42fb5031 MW |
1584 | { |
1585 | struct vme_bridge *bridge = find_bridge(resource); | |
1586 | struct vme_lm_resource *lm; | |
1587 | ||
1588 | if (resource->type != VME_LM) { | |
1589 | printk(KERN_ERR "Not a Location Monitor resource\n"); | |
a17a75e2 MW |
1590 | return -EINVAL; |
1591 | } | |
1592 | ||
42fb5031 MW |
1593 | lm = list_entry(resource->entry, struct vme_lm_resource, list); |
1594 | ||
a17a75e2 | 1595 | if (bridge->lm_set == NULL) { |
42fb5031 | 1596 | printk(KERN_ERR "vme_lm_set not supported\n"); |
a17a75e2 MW |
1597 | return -EINVAL; |
1598 | } | |
1599 | ||
8be9226c | 1600 | return bridge->lm_set(lm, lm_base, aspace, cycle); |
a17a75e2 MW |
1601 | } |
1602 | EXPORT_SYMBOL(vme_lm_set); | |
1603 | ||
b5bc980a MW |
1604 | /** |
1605 | * vme_lm_get - Retrieve location monitor settings | |
1606 | * @resource: Pointer to VME location monitor resource. | |
1607 | * @lm_base: Pointer used to output the base address monitored. | |
1608 | * @aspace: Pointer used to output the address space monitored. | |
1609 | * @cycle: Pointer used to output the VME bus cycle type monitored. | |
1610 | * | |
1611 | * Retrieve the base address, address space and cycle type of accesses to | |
1612 | * be monitored by the location monitor. | |
1613 | * | |
1614 | * Return: Zero on success, -EINVAL when provided with an invalid location | |
1615 | * monitor resource or function is not supported. Hardware specific | |
1616 | * errors may also be returned. | |
1617 | */ | |
42fb5031 | 1618 | int vme_lm_get(struct vme_resource *resource, unsigned long long *lm_base, |
6af04b06 | 1619 | u32 *aspace, u32 *cycle) |
a17a75e2 | 1620 | { |
42fb5031 MW |
1621 | struct vme_bridge *bridge = find_bridge(resource); |
1622 | struct vme_lm_resource *lm; | |
a17a75e2 | 1623 | |
42fb5031 MW |
1624 | if (resource->type != VME_LM) { |
1625 | printk(KERN_ERR "Not a Location Monitor resource\n"); | |
a17a75e2 MW |
1626 | return -EINVAL; |
1627 | } | |
1628 | ||
42fb5031 MW |
1629 | lm = list_entry(resource->entry, struct vme_lm_resource, list); |
1630 | ||
a17a75e2 | 1631 | if (bridge->lm_get == NULL) { |
42fb5031 | 1632 | printk(KERN_ERR "vme_lm_get not supported\n"); |
a17a75e2 MW |
1633 | return -EINVAL; |
1634 | } | |
1635 | ||
42fb5031 | 1636 | return bridge->lm_get(lm, lm_base, aspace, cycle); |
a17a75e2 MW |
1637 | } |
1638 | EXPORT_SYMBOL(vme_lm_get); | |
1639 | ||
b5bc980a MW |
1640 | /** |
1641 | * vme_lm_attach - Provide callback for location monitor address | |
1642 | * @resource: Pointer to VME location monitor resource. | |
1643 | * @monitor: Offset to which callback should be attached. | |
1644 | * @callback: Pointer to callback function called when triggered. | |
1645 | * @data: Generic pointer that will be passed to the callback function. | |
1646 | * | |
1647 | * Attach a callback to the specificed offset into the location monitors | |
1648 | * monitored addresses. A generic pointer is provided to allow data to be | |
1649 | * passed to the callback when called. | |
1650 | * | |
1651 | * Return: Zero on success, -EINVAL when provided with an invalid location | |
1652 | * monitor resource or function is not supported. Hardware specific | |
1653 | * errors may also be returned. | |
1654 | */ | |
42fb5031 | 1655 | int vme_lm_attach(struct vme_resource *resource, int monitor, |
fa54b326 | 1656 | void (*callback)(void *), void *data) |
a17a75e2 | 1657 | { |
42fb5031 MW |
1658 | struct vme_bridge *bridge = find_bridge(resource); |
1659 | struct vme_lm_resource *lm; | |
a17a75e2 | 1660 | |
42fb5031 MW |
1661 | if (resource->type != VME_LM) { |
1662 | printk(KERN_ERR "Not a Location Monitor resource\n"); | |
a17a75e2 MW |
1663 | return -EINVAL; |
1664 | } | |
1665 | ||
42fb5031 MW |
1666 | lm = list_entry(resource->entry, struct vme_lm_resource, list); |
1667 | ||
a17a75e2 | 1668 | if (bridge->lm_attach == NULL) { |
42fb5031 | 1669 | printk(KERN_ERR "vme_lm_attach not supported\n"); |
a17a75e2 MW |
1670 | return -EINVAL; |
1671 | } | |
1672 | ||
fa54b326 | 1673 | return bridge->lm_attach(lm, monitor, callback, data); |
a17a75e2 MW |
1674 | } |
1675 | EXPORT_SYMBOL(vme_lm_attach); | |
1676 | ||
b5bc980a MW |
1677 | /** |
1678 | * vme_lm_detach - Remove callback for location monitor address | |
1679 | * @resource: Pointer to VME location monitor resource. | |
1680 | * @monitor: Offset to which callback should be removed. | |
1681 | * | |
1682 | * Remove the callback associated with the specificed offset into the | |
1683 | * location monitors monitored addresses. | |
1684 | * | |
1685 | * Return: Zero on success, -EINVAL when provided with an invalid location | |
1686 | * monitor resource or function is not supported. Hardware specific | |
1687 | * errors may also be returned. | |
1688 | */ | |
42fb5031 | 1689 | int vme_lm_detach(struct vme_resource *resource, int monitor) |
a17a75e2 | 1690 | { |
42fb5031 MW |
1691 | struct vme_bridge *bridge = find_bridge(resource); |
1692 | struct vme_lm_resource *lm; | |
a17a75e2 | 1693 | |
42fb5031 MW |
1694 | if (resource->type != VME_LM) { |
1695 | printk(KERN_ERR "Not a Location Monitor resource\n"); | |
a17a75e2 MW |
1696 | return -EINVAL; |
1697 | } | |
1698 | ||
42fb5031 MW |
1699 | lm = list_entry(resource->entry, struct vme_lm_resource, list); |
1700 | ||
a17a75e2 | 1701 | if (bridge->lm_detach == NULL) { |
42fb5031 | 1702 | printk(KERN_ERR "vme_lm_detach not supported\n"); |
a17a75e2 MW |
1703 | return -EINVAL; |
1704 | } | |
1705 | ||
42fb5031 | 1706 | return bridge->lm_detach(lm, monitor); |
a17a75e2 MW |
1707 | } |
1708 | EXPORT_SYMBOL(vme_lm_detach); | |
1709 | ||
b5bc980a MW |
1710 | /** |
1711 | * vme_lm_free - Free allocated VME location monitor | |
1712 | * @resource: Pointer to VME location monitor resource. | |
1713 | * | |
1714 | * Free allocation of a VME location monitor. | |
1715 | * | |
1716 | * WARNING: This function currently expects that any callbacks that have | |
1717 | * been attached to the location monitor have been removed. | |
1718 | * | |
1719 | * Return: Zero on success, -EINVAL when provided with an invalid location | |
1720 | * monitor resource. | |
1721 | */ | |
42fb5031 MW |
1722 | void vme_lm_free(struct vme_resource *resource) |
1723 | { | |
1724 | struct vme_lm_resource *lm; | |
1725 | ||
1726 | if (resource->type != VME_LM) { | |
1727 | printk(KERN_ERR "Not a Location Monitor resource\n"); | |
1728 | return; | |
1729 | } | |
1730 | ||
1731 | lm = list_entry(resource->entry, struct vme_lm_resource, list); | |
1732 | ||
886953e9 | 1733 | mutex_lock(&lm->mtx); |
42fb5031 | 1734 | |
8be9226c MW |
1735 | /* XXX |
1736 | * Check to see that there aren't any callbacks still attached, if | |
1737 | * there are we should probably be detaching them! | |
1738 | */ | |
42fb5031 MW |
1739 | |
1740 | lm->locked = 0; | |
1741 | ||
886953e9 | 1742 | mutex_unlock(&lm->mtx); |
8be9226c MW |
1743 | |
1744 | kfree(resource); | |
42fb5031 MW |
1745 | } |
1746 | EXPORT_SYMBOL(vme_lm_free); | |
1747 | ||
b5bc980a MW |
1748 | /** |
1749 | * vme_slot_num - Retrieve slot ID | |
1750 | * @vdev: Pointer to VME device struct vme_dev assigned to driver instance. | |
1751 | * | |
1752 | * Retrieve the slot ID associated with the provided VME device. | |
1753 | * | |
1754 | * Return: The slot ID on success, -EINVAL if VME bridge cannot be determined | |
1755 | * or the function is not supported. Hardware specific errors may also | |
1756 | * be returned. | |
1757 | */ | |
d7729f0f | 1758 | int vme_slot_num(struct vme_dev *vdev) |
a17a75e2 MW |
1759 | { |
1760 | struct vme_bridge *bridge; | |
1761 | ||
8f966dc4 | 1762 | bridge = vdev->bridge; |
a17a75e2 MW |
1763 | if (bridge == NULL) { |
1764 | printk(KERN_ERR "Can't find VME bus\n"); | |
1765 | return -EINVAL; | |
1766 | } | |
1767 | ||
1768 | if (bridge->slot_get == NULL) { | |
d7729f0f | 1769 | printk(KERN_WARNING "vme_slot_num not supported\n"); |
a17a75e2 MW |
1770 | return -EINVAL; |
1771 | } | |
1772 | ||
29848ac9 | 1773 | return bridge->slot_get(bridge); |
a17a75e2 | 1774 | } |
d7729f0f | 1775 | EXPORT_SYMBOL(vme_slot_num); |
a17a75e2 | 1776 | |
b5bc980a MW |
1777 | /** |
1778 | * vme_bus_num - Retrieve bus number | |
1779 | * @vdev: Pointer to VME device struct vme_dev assigned to driver instance. | |
1780 | * | |
1781 | * Retrieve the bus enumeration associated with the provided VME device. | |
1782 | * | |
1783 | * Return: The bus number on success, -EINVAL if VME bridge cannot be | |
1784 | * determined. | |
1785 | */ | |
978f47d6 MW |
1786 | int vme_bus_num(struct vme_dev *vdev) |
1787 | { | |
1788 | struct vme_bridge *bridge; | |
1789 | ||
1790 | bridge = vdev->bridge; | |
1791 | if (bridge == NULL) { | |
1792 | pr_err("Can't find VME bus\n"); | |
1793 | return -EINVAL; | |
1794 | } | |
1795 | ||
1796 | return bridge->num; | |
1797 | } | |
1798 | EXPORT_SYMBOL(vme_bus_num); | |
a17a75e2 MW |
1799 | |
1800 | /* - Bridge Registration --------------------------------------------------- */ | |
1801 | ||
5b93c2a2 MV |
1802 | static void vme_dev_release(struct device *dev) |
1803 | { | |
1804 | kfree(dev_to_vme_dev(dev)); | |
1805 | } | |
1806 | ||
326071b3 AS |
1807 | /* Common bridge initialization */ |
1808 | struct vme_bridge *vme_init_bridge(struct vme_bridge *bridge) | |
1809 | { | |
1810 | INIT_LIST_HEAD(&bridge->vme_error_handlers); | |
1811 | INIT_LIST_HEAD(&bridge->master_resources); | |
1812 | INIT_LIST_HEAD(&bridge->slave_resources); | |
1813 | INIT_LIST_HEAD(&bridge->dma_resources); | |
1814 | INIT_LIST_HEAD(&bridge->lm_resources); | |
1815 | mutex_init(&bridge->irq_mtx); | |
1816 | ||
1817 | return bridge; | |
1818 | } | |
1819 | EXPORT_SYMBOL(vme_init_bridge); | |
1820 | ||
5b93c2a2 | 1821 | int vme_register_bridge(struct vme_bridge *bridge) |
a17a75e2 MW |
1822 | { |
1823 | int i; | |
733e3ef0 | 1824 | int ret = -1; |
a17a75e2 | 1825 | |
733e3ef0 | 1826 | mutex_lock(&vme_buses_lock); |
a17a75e2 | 1827 | for (i = 0; i < sizeof(vme_bus_numbers) * 8; i++) { |
733e3ef0 MV |
1828 | if ((vme_bus_numbers & (1 << i)) == 0) { |
1829 | vme_bus_numbers |= (1 << i); | |
1830 | bridge->num = i; | |
5d6abf37 | 1831 | INIT_LIST_HEAD(&bridge->devices); |
733e3ef0 MV |
1832 | list_add_tail(&bridge->bus_list, &vme_bus_list); |
1833 | ret = 0; | |
a17a75e2 MW |
1834 | break; |
1835 | } | |
1836 | } | |
733e3ef0 | 1837 | mutex_unlock(&vme_buses_lock); |
a17a75e2 | 1838 | |
733e3ef0 | 1839 | return ret; |
a17a75e2 | 1840 | } |
5b93c2a2 | 1841 | EXPORT_SYMBOL(vme_register_bridge); |
a17a75e2 | 1842 | |
5b93c2a2 | 1843 | void vme_unregister_bridge(struct vme_bridge *bridge) |
a17a75e2 | 1844 | { |
5d6abf37 MV |
1845 | struct vme_dev *vdev; |
1846 | struct vme_dev *tmp; | |
1847 | ||
733e3ef0 MV |
1848 | mutex_lock(&vme_buses_lock); |
1849 | vme_bus_numbers &= ~(1 << bridge->num); | |
5d6abf37 MV |
1850 | list_for_each_entry_safe(vdev, tmp, &bridge->devices, bridge_list) { |
1851 | list_del(&vdev->drv_list); | |
1852 | list_del(&vdev->bridge_list); | |
1853 | device_unregister(&vdev->dev); | |
1854 | } | |
733e3ef0 MV |
1855 | list_del(&bridge->bus_list); |
1856 | mutex_unlock(&vme_buses_lock); | |
a17a75e2 | 1857 | } |
5d6abf37 | 1858 | EXPORT_SYMBOL(vme_unregister_bridge); |
a17a75e2 | 1859 | |
5d6abf37 MV |
1860 | /* - Driver Registration --------------------------------------------------- */ |
1861 | ||
1862 | static int __vme_register_driver_bus(struct vme_driver *drv, | |
1863 | struct vme_bridge *bridge, unsigned int ndevs) | |
1864 | { | |
1865 | int err; | |
1866 | unsigned int i; | |
1867 | struct vme_dev *vdev; | |
1868 | struct vme_dev *tmp; | |
1869 | ||
1870 | for (i = 0; i < ndevs; i++) { | |
1ff0a19c | 1871 | vdev = kzalloc(sizeof(*vdev), GFP_KERNEL); |
5d6abf37 MV |
1872 | if (!vdev) { |
1873 | err = -ENOMEM; | |
f6c39d4f MV |
1874 | goto err_devalloc; |
1875 | } | |
a916a391 | 1876 | vdev->num = i; |
8f966dc4 | 1877 | vdev->bridge = bridge; |
5d6abf37 MV |
1878 | vdev->dev.platform_data = drv; |
1879 | vdev->dev.release = vme_dev_release; | |
8f966dc4 MV |
1880 | vdev->dev.parent = bridge->parent; |
1881 | vdev->dev.bus = &vme_bus_type; | |
a916a391 MV |
1882 | dev_set_name(&vdev->dev, "%s.%u-%u", drv->name, bridge->num, |
1883 | vdev->num); | |
a17a75e2 | 1884 | |
5d6abf37 MV |
1885 | err = device_register(&vdev->dev); |
1886 | if (err) | |
a17a75e2 | 1887 | goto err_reg; |
a17a75e2 | 1888 | |
5d6abf37 MV |
1889 | if (vdev->dev.platform_data) { |
1890 | list_add_tail(&vdev->drv_list, &drv->devices); | |
1891 | list_add_tail(&vdev->bridge_list, &bridge->devices); | |
1892 | } else | |
1893 | device_unregister(&vdev->dev); | |
1894 | } | |
1895 | return 0; | |
a17a75e2 | 1896 | |
a17a75e2 | 1897 | err_reg: |
def1820d | 1898 | put_device(&vdev->dev); |
8f966dc4 | 1899 | kfree(vdev); |
f6c39d4f | 1900 | err_devalloc: |
5d6abf37 MV |
1901 | list_for_each_entry_safe(vdev, tmp, &drv->devices, drv_list) { |
1902 | list_del(&vdev->drv_list); | |
1903 | list_del(&vdev->bridge_list); | |
8f966dc4 | 1904 | device_unregister(&vdev->dev); |
a17a75e2 | 1905 | } |
5d6abf37 | 1906 | return err; |
a17a75e2 | 1907 | } |
a17a75e2 | 1908 | |
5d6abf37 | 1909 | static int __vme_register_driver(struct vme_driver *drv, unsigned int ndevs) |
a17a75e2 | 1910 | { |
5d6abf37 MV |
1911 | struct vme_bridge *bridge; |
1912 | int err = 0; | |
a17a75e2 | 1913 | |
5d6abf37 MV |
1914 | mutex_lock(&vme_buses_lock); |
1915 | list_for_each_entry(bridge, &vme_bus_list, bus_list) { | |
1916 | /* | |
1917 | * This cannot cause trouble as we already have vme_buses_lock | |
1918 | * and if the bridge is removed, it will have to go through | |
1919 | * vme_unregister_bridge() to do it (which calls remove() on | |
1920 | * the bridge which in turn tries to acquire vme_buses_lock and | |
c26f6112 | 1921 | * will have to wait). |
5d6abf37 MV |
1922 | */ |
1923 | err = __vme_register_driver_bus(drv, bridge, ndevs); | |
1924 | if (err) | |
1925 | break; | |
a17a75e2 | 1926 | } |
5d6abf37 MV |
1927 | mutex_unlock(&vme_buses_lock); |
1928 | return err; | |
a17a75e2 | 1929 | } |
a17a75e2 | 1930 | |
b5bc980a MW |
1931 | /** |
1932 | * vme_register_driver - Register a VME driver | |
1933 | * @drv: Pointer to VME driver structure to register. | |
1934 | * @ndevs: Maximum number of devices to allow to be enumerated. | |
1935 | * | |
1936 | * Register a VME device driver with the VME subsystem. | |
1937 | * | |
1938 | * Return: Zero on success, error value on registration failure. | |
1939 | */ | |
5d6abf37 | 1940 | int vme_register_driver(struct vme_driver *drv, unsigned int ndevs) |
a17a75e2 | 1941 | { |
5d6abf37 MV |
1942 | int err; |
1943 | ||
a17a75e2 MW |
1944 | drv->driver.name = drv->name; |
1945 | drv->driver.bus = &vme_bus_type; | |
5d6abf37 MV |
1946 | INIT_LIST_HEAD(&drv->devices); |
1947 | ||
1948 | err = driver_register(&drv->driver); | |
1949 | if (err) | |
1950 | return err; | |
a17a75e2 | 1951 | |
5d6abf37 MV |
1952 | err = __vme_register_driver(drv, ndevs); |
1953 | if (err) | |
1954 | driver_unregister(&drv->driver); | |
1955 | ||
1956 | return err; | |
a17a75e2 MW |
1957 | } |
1958 | EXPORT_SYMBOL(vme_register_driver); | |
1959 | ||
b5bc980a MW |
1960 | /** |
1961 | * vme_unregister_driver - Unregister a VME driver | |
1962 | * @drv: Pointer to VME driver structure to unregister. | |
1963 | * | |
1964 | * Unregister a VME device driver from the VME subsystem. | |
1965 | */ | |
ead1f3e3 | 1966 | void vme_unregister_driver(struct vme_driver *drv) |
a17a75e2 | 1967 | { |
5d6abf37 MV |
1968 | struct vme_dev *dev, *dev_tmp; |
1969 | ||
1970 | mutex_lock(&vme_buses_lock); | |
1971 | list_for_each_entry_safe(dev, dev_tmp, &drv->devices, drv_list) { | |
1972 | list_del(&dev->drv_list); | |
1973 | list_del(&dev->bridge_list); | |
1974 | device_unregister(&dev->dev); | |
1975 | } | |
1976 | mutex_unlock(&vme_buses_lock); | |
1977 | ||
a17a75e2 MW |
1978 | driver_unregister(&drv->driver); |
1979 | } | |
1980 | EXPORT_SYMBOL(vme_unregister_driver); | |
1981 | ||
1982 | /* - Bus Registration ------------------------------------------------------ */ | |
1983 | ||
a17a75e2 MW |
1984 | static int vme_bus_match(struct device *dev, struct device_driver *drv) |
1985 | { | |
5d6abf37 | 1986 | struct vme_driver *vme_drv; |
a17a75e2 | 1987 | |
5d6abf37 | 1988 | vme_drv = container_of(drv, struct vme_driver, driver); |
a17a75e2 | 1989 | |
5d6abf37 MV |
1990 | if (dev->platform_data == vme_drv) { |
1991 | struct vme_dev *vdev = dev_to_vme_dev(dev); | |
a17a75e2 | 1992 | |
5d6abf37 MV |
1993 | if (vme_drv->match && vme_drv->match(vdev)) |
1994 | return 1; | |
a37b0dad | 1995 | |
5d6abf37 | 1996 | dev->platform_data = NULL; |
a17a75e2 | 1997 | } |
a17a75e2 MW |
1998 | return 0; |
1999 | } | |
2000 | ||
2001 | static int vme_bus_probe(struct device *dev) | |
2002 | { | |
a17a75e2 | 2003 | int retval = -ENODEV; |
5d6abf37 MV |
2004 | struct vme_driver *driver; |
2005 | struct vme_dev *vdev = dev_to_vme_dev(dev); | |
a17a75e2 | 2006 | |
5d6abf37 | 2007 | driver = dev->platform_data; |
a17a75e2 | 2008 | |
ead1f3e3 | 2009 | if (driver->probe != NULL) |
8f966dc4 | 2010 | retval = driver->probe(vdev); |
a17a75e2 MW |
2011 | |
2012 | return retval; | |
2013 | } | |
2014 | ||
9797484b SB |
2015 | static int vme_bus_remove(struct device *dev) |
2016 | { | |
2017 | int retval = -ENODEV; | |
2018 | struct vme_driver *driver; | |
2019 | struct vme_dev *vdev = dev_to_vme_dev(dev); | |
2020 | ||
2021 | driver = dev->platform_data; | |
2022 | ||
2023 | if (driver->remove != NULL) | |
2024 | retval = driver->remove(vdev); | |
2025 | ||
2026 | return retval; | |
2027 | } | |
2028 | ||
a17a75e2 MW |
2029 | struct bus_type vme_bus_type = { |
2030 | .name = "vme", | |
2031 | .match = vme_bus_match, | |
2032 | .probe = vme_bus_probe, | |
9797484b | 2033 | .remove = vme_bus_remove, |
a17a75e2 MW |
2034 | }; |
2035 | EXPORT_SYMBOL(vme_bus_type); | |
2036 | ||
ead1f3e3 | 2037 | static int __init vme_init(void) |
a17a75e2 MW |
2038 | { |
2039 | return bus_register(&vme_bus_type); | |
2040 | } | |
c326cc02 | 2041 | subsys_initcall(vme_init); |