~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/platforms/pseries/ibmebus.c

Version: ~ [ linux-5.2-rc5 ] ~ [ linux-5.1.12 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.53 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.128 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.182 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.182 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.68 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * IBM PowerPC IBM eBus Infrastructure Support.
  3  *
  4  * Copyright (c) 2005 IBM Corporation
  5  *  Joachim Fenkes <fenkes@de.ibm.com>
  6  *  Heiko J Schick <schickhj@de.ibm.com>
  7  *
  8  * All rights reserved.
  9  *
 10  * This source code is distributed under a dual license of GPL v2.0 and OpenIB
 11  * BSD.
 12  *
 13  * OpenIB BSD License
 14  *
 15  * Redistribution and use in source and binary forms, with or without
 16  * modification, are permitted provided that the following conditions are met:
 17  *
 18  * Redistributions of source code must retain the above copyright notice, this
 19  * list of conditions and the following disclaimer.
 20  *
 21  * Redistributions in binary form must reproduce the above copyright notice,
 22  * this list of conditions and the following disclaimer in the documentation
 23  * and/or other materials
 24  * provided with the distribution.
 25  *
 26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 27  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 29  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 30  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 33  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
 34  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 36  * POSSIBILITY OF SUCH DAMAGE.
 37  */
 38 
 39 #include <linux/init.h>
 40 #include <linux/export.h>
 41 #include <linux/console.h>
 42 #include <linux/kobject.h>
 43 #include <linux/dma-mapping.h>
 44 #include <linux/interrupt.h>
 45 #include <linux/of.h>
 46 #include <linux/slab.h>
 47 #include <linux/stat.h>
 48 #include <linux/of_platform.h>
 49 #include <asm/ibmebus.h>
 50 
 51 static struct device ibmebus_bus_device = { /* fake "parent" device */
 52         .init_name = "ibmebus",
 53 };
 54 
 55 struct bus_type ibmebus_bus_type;
 56 
 57 /* These devices will automatically be added to the bus during init */
 58 static const struct of_device_id ibmebus_matches[] __initconst = {
 59         { .compatible = "IBM,lhca" },
 60         { .compatible = "IBM,lhea" },
 61         {},
 62 };
 63 
 64 static void *ibmebus_alloc_coherent(struct device *dev,
 65                                     size_t size,
 66                                     dma_addr_t *dma_handle,
 67                                     gfp_t flag,
 68                                     unsigned long attrs)
 69 {
 70         void *mem;
 71 
 72         mem = kmalloc(size, flag);
 73         *dma_handle = (dma_addr_t)mem;
 74 
 75         return mem;
 76 }
 77 
 78 static void ibmebus_free_coherent(struct device *dev,
 79                                   size_t size, void *vaddr,
 80                                   dma_addr_t dma_handle,
 81                                   unsigned long attrs)
 82 {
 83         kfree(vaddr);
 84 }
 85 
 86 static dma_addr_t ibmebus_map_page(struct device *dev,
 87                                    struct page *page,
 88                                    unsigned long offset,
 89                                    size_t size,
 90                                    enum dma_data_direction direction,
 91                                    unsigned long attrs)
 92 {
 93         return (dma_addr_t)(page_address(page) + offset);
 94 }
 95 
 96 static void ibmebus_unmap_page(struct device *dev,
 97                                dma_addr_t dma_addr,
 98                                size_t size,
 99                                enum dma_data_direction direction,
100                                unsigned long attrs)
101 {
102         return;
103 }
104 
105 static int ibmebus_map_sg(struct device *dev,
106                           struct scatterlist *sgl,
107                           int nents, enum dma_data_direction direction,
108                           unsigned long attrs)
109 {
110         struct scatterlist *sg;
111         int i;
112 
113         for_each_sg(sgl, sg, nents, i) {
114                 sg->dma_address = (dma_addr_t) sg_virt(sg);
115                 sg->dma_length = sg->length;
116         }
117 
118         return nents;
119 }
120 
121 static void ibmebus_unmap_sg(struct device *dev,
122                              struct scatterlist *sg,
123                              int nents, enum dma_data_direction direction,
124                              unsigned long attrs)
125 {
126         return;
127 }
128 
129 static int ibmebus_dma_supported(struct device *dev, u64 mask)
130 {
131         return mask == DMA_BIT_MASK(64);
132 }
133 
134 static u64 ibmebus_dma_get_required_mask(struct device *dev)
135 {
136         return DMA_BIT_MASK(64);
137 }
138 
139 static const struct dma_map_ops ibmebus_dma_ops = {
140         .alloc              = ibmebus_alloc_coherent,
141         .free               = ibmebus_free_coherent,
142         .map_sg             = ibmebus_map_sg,
143         .unmap_sg           = ibmebus_unmap_sg,
144         .dma_supported      = ibmebus_dma_supported,
145         .get_required_mask  = ibmebus_dma_get_required_mask,
146         .map_page           = ibmebus_map_page,
147         .unmap_page         = ibmebus_unmap_page,
148 };
149 
150 static int ibmebus_match_path(struct device *dev, void *data)
151 {
152         struct device_node *dn = to_platform_device(dev)->dev.of_node;
153         return (dn->full_name &&
154                 (strcasecmp((char *)data, dn->full_name) == 0));
155 }
156 
157 static int ibmebus_match_node(struct device *dev, void *data)
158 {
159         return to_platform_device(dev)->dev.of_node == data;
160 }
161 
162 static int ibmebus_create_device(struct device_node *dn)
163 {
164         struct platform_device *dev;
165         int ret;
166 
167         dev = of_device_alloc(dn, NULL, &ibmebus_bus_device);
168         if (!dev)
169                 return -ENOMEM;
170 
171         dev->dev.bus = &ibmebus_bus_type;
172         dev->dev.dma_ops = &ibmebus_dma_ops;
173 
174         ret = of_device_add(dev);
175         if (ret)
176                 platform_device_put(dev);
177         return ret;
178 }
179 
180 static int ibmebus_create_devices(const struct of_device_id *matches)
181 {
182         struct device_node *root, *child;
183         struct device *dev;
184         int ret = 0;
185 
186         root = of_find_node_by_path("/");
187 
188         for_each_child_of_node(root, child) {
189                 if (!of_match_node(matches, child))
190                         continue;
191 
192                 dev = bus_find_device(&ibmebus_bus_type, NULL, child,
193                                       ibmebus_match_node);
194                 if (dev) {
195                         put_device(dev);
196                         continue;
197                 }
198 
199                 ret = ibmebus_create_device(child);
200                 if (ret) {
201                         printk(KERN_ERR "%s: failed to create device (%i)",
202                                __func__, ret);
203                         of_node_put(child);
204                         break;
205                 }
206         }
207 
208         of_node_put(root);
209         return ret;
210 }
211 
212 int ibmebus_register_driver(struct platform_driver *drv)
213 {
214         /* If the driver uses devices that ibmebus doesn't know, add them */
215         ibmebus_create_devices(drv->driver.of_match_table);
216 
217         drv->driver.bus = &ibmebus_bus_type;
218         return driver_register(&drv->driver);
219 }
220 EXPORT_SYMBOL(ibmebus_register_driver);
221 
222 void ibmebus_unregister_driver(struct platform_driver *drv)
223 {
224         driver_unregister(&drv->driver);
225 }
226 EXPORT_SYMBOL(ibmebus_unregister_driver);
227 
228 int ibmebus_request_irq(u32 ist, irq_handler_t handler,
229                         unsigned long irq_flags, const char *devname,
230                         void *dev_id)
231 {
232         unsigned int irq = irq_create_mapping(NULL, ist);
233 
234         if (!irq)
235                 return -EINVAL;
236 
237         return request_irq(irq, handler, irq_flags, devname, dev_id);
238 }
239 EXPORT_SYMBOL(ibmebus_request_irq);
240 
241 void ibmebus_free_irq(u32 ist, void *dev_id)
242 {
243         unsigned int irq = irq_find_mapping(NULL, ist);
244 
245         free_irq(irq, dev_id);
246         irq_dispose_mapping(irq);
247 }
248 EXPORT_SYMBOL(ibmebus_free_irq);
249 
250 static char *ibmebus_chomp(const char *in, size_t count)
251 {
252         char *out = kmalloc(count + 1, GFP_KERNEL);
253 
254         if (!out)
255                 return NULL;
256 
257         memcpy(out, in, count);
258         out[count] = '\0';
259         if (out[count - 1] == '\n')
260                 out[count - 1] = '\0';
261 
262         return out;
263 }
264 
265 static ssize_t ibmebus_store_probe(struct bus_type *bus,
266                                    const char *buf, size_t count)
267 {
268         struct device_node *dn = NULL;
269         struct device *dev;
270         char *path;
271         ssize_t rc = 0;
272 
273         path = ibmebus_chomp(buf, count);
274         if (!path)
275                 return -ENOMEM;
276 
277         dev = bus_find_device(&ibmebus_bus_type, NULL, path,
278                               ibmebus_match_path);
279         if (dev) {
280                 put_device(dev);
281                 printk(KERN_WARNING "%s: %s has already been probed\n",
282                        __func__, path);
283                 rc = -EEXIST;
284                 goto out;
285         }
286 
287         if ((dn = of_find_node_by_path(path))) {
288                 rc = ibmebus_create_device(dn);
289                 of_node_put(dn);
290         } else {
291                 printk(KERN_WARNING "%s: no such device node: %s\n",
292                        __func__, path);
293                 rc = -ENODEV;
294         }
295 
296 out:
297         kfree(path);
298         if (rc)
299                 return rc;
300         return count;
301 }
302 static BUS_ATTR(probe, S_IWUSR, NULL, ibmebus_store_probe);
303 
304 static ssize_t ibmebus_store_remove(struct bus_type *bus,
305                                     const char *buf, size_t count)
306 {
307         struct device *dev;
308         char *path;
309 
310         path = ibmebus_chomp(buf, count);
311         if (!path)
312                 return -ENOMEM;
313 
314         if ((dev = bus_find_device(&ibmebus_bus_type, NULL, path,
315                                    ibmebus_match_path))) {
316                 of_device_unregister(to_platform_device(dev));
317                 put_device(dev);
318 
319                 kfree(path);
320                 return count;
321         } else {
322                 printk(KERN_WARNING "%s: %s not on the bus\n",
323                        __func__, path);
324 
325                 kfree(path);
326                 return -ENODEV;
327         }
328 }
329 static BUS_ATTR(remove, S_IWUSR, NULL, ibmebus_store_remove);
330 
331 static struct attribute *ibmbus_bus_attrs[] = {
332         &bus_attr_probe.attr,
333         &bus_attr_remove.attr,
334         NULL,
335 };
336 ATTRIBUTE_GROUPS(ibmbus_bus);
337 
338 static int ibmebus_bus_bus_match(struct device *dev, struct device_driver *drv)
339 {
340         const struct of_device_id *matches = drv->of_match_table;
341 
342         if (!matches)
343                 return 0;
344 
345         return of_match_device(matches, dev) != NULL;
346 }
347 
348 static int ibmebus_bus_device_probe(struct device *dev)
349 {
350         int error = -ENODEV;
351         struct platform_driver *drv;
352         struct platform_device *of_dev;
353 
354         drv = to_platform_driver(dev->driver);
355         of_dev = to_platform_device(dev);
356 
357         if (!drv->probe)
358                 return error;
359 
360         of_dev_get(of_dev);
361 
362         if (of_driver_match_device(dev, dev->driver))
363                 error = drv->probe(of_dev);
364         if (error)
365                 of_dev_put(of_dev);
366 
367         return error;
368 }
369 
370 static int ibmebus_bus_device_remove(struct device *dev)
371 {
372         struct platform_device *of_dev = to_platform_device(dev);
373         struct platform_driver *drv = to_platform_driver(dev->driver);
374 
375         if (dev->driver && drv->remove)
376                 drv->remove(of_dev);
377         return 0;
378 }
379 
380 static void ibmebus_bus_device_shutdown(struct device *dev)
381 {
382         struct platform_device *of_dev = to_platform_device(dev);
383         struct platform_driver *drv = to_platform_driver(dev->driver);
384 
385         if (dev->driver && drv->shutdown)
386                 drv->shutdown(of_dev);
387 }
388 
389 /*
390  * ibmebus_bus_device_attrs
391  */
392 static ssize_t devspec_show(struct device *dev,
393                                 struct device_attribute *attr, char *buf)
394 {
395         struct platform_device *ofdev;
396 
397         ofdev = to_platform_device(dev);
398         return sprintf(buf, "%s\n", ofdev->dev.of_node->full_name);
399 }
400 
401 static ssize_t name_show(struct device *dev,
402                                 struct device_attribute *attr, char *buf)
403 {
404         struct platform_device *ofdev;
405 
406         ofdev = to_platform_device(dev);
407         return sprintf(buf, "%s\n", ofdev->dev.of_node->name);
408 }
409 
410 static ssize_t modalias_show(struct device *dev,
411                                 struct device_attribute *attr, char *buf)
412 {
413         ssize_t len = of_device_get_modalias(dev, buf, PAGE_SIZE - 2);
414         buf[len] = '\n';
415         buf[len+1] = 0;
416         return len+1;
417 }
418 
419 static struct device_attribute ibmebus_bus_device_attrs[] = {
420         __ATTR_RO(devspec),
421         __ATTR_RO(name),
422         __ATTR_RO(modalias),
423         __ATTR_NULL
424 };
425 
426 struct bus_type ibmebus_bus_type = {
427         .name      = "ibmebus",
428         .uevent    = of_device_uevent_modalias,
429         .bus_groups = ibmbus_bus_groups,
430         .match     = ibmebus_bus_bus_match,
431         .probe     = ibmebus_bus_device_probe,
432         .remove    = ibmebus_bus_device_remove,
433         .shutdown  = ibmebus_bus_device_shutdown,
434         .dev_attrs = ibmebus_bus_device_attrs,
435 };
436 EXPORT_SYMBOL(ibmebus_bus_type);
437 
438 static int __init ibmebus_bus_init(void)
439 {
440         int err;
441 
442         printk(KERN_INFO "IBM eBus Device Driver\n");
443 
444         err = bus_register(&ibmebus_bus_type);
445         if (err) {
446                 printk(KERN_ERR "%s: failed to register IBM eBus.\n",
447                        __func__);
448                 return err;
449         }
450 
451         err = device_register(&ibmebus_bus_device);
452         if (err) {
453                 printk(KERN_WARNING "%s: device_register returned %i\n",
454                        __func__, err);
455                 bus_unregister(&ibmebus_bus_type);
456 
457                 return err;
458         }
459 
460         err = ibmebus_create_devices(ibmebus_matches);
461         if (err) {
462                 device_unregister(&ibmebus_bus_device);
463                 bus_unregister(&ibmebus_bus_type);
464                 return err;
465         }
466 
467         return 0;
468 }
469 postcore_initcall(ibmebus_bus_init);
470 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp