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/console.h> 41#include <linux/kobject.h> 42#include <linux/dma-mapping.h> 43#include <linux/interrupt.h> 44#include <asm/ibmebus.h> 45#include <asm/abs_addr.h> 46 47static struct device ibmebus_bus_device = { /* fake "parent" device */ 48 .bus_id = "ibmebus", 49}; 50 51struct bus_type ibmebus_bus_type; 52 53static void *ibmebus_alloc_coherent(struct device *dev, 54 size_t size, 55 dma_addr_t *dma_handle, 56 gfp_t flag) 57{ 58 void *mem; 59 60 mem = kmalloc(size, flag); 61 *dma_handle = (dma_addr_t)mem; 62 63 return mem; 64} 65 66static void ibmebus_free_coherent(struct device *dev, 67 size_t size, void *vaddr, 68 dma_addr_t dma_handle) 69{ 70 kfree(vaddr); 71} 72 73static dma_addr_t ibmebus_map_single(struct device *dev, 74 void *ptr, 75 size_t size, 76 enum dma_data_direction direction) 77{ 78 return (dma_addr_t)(ptr); 79} 80 81static void ibmebus_unmap_single(struct device *dev, 82 dma_addr_t dma_addr, 83 size_t size, 84 enum dma_data_direction direction) 85{ 86 return; 87} 88 89static int ibmebus_map_sg(struct device *dev, 90 struct scatterlist *sg, 91 int nents, enum dma_data_direction direction) 92{ 93 int i; 94 95 for (i = 0; i < nents; i++) { 96 sg[i].dma_address = (dma_addr_t)page_address(sg[i].page) 97 + sg[i].offset; 98 sg[i].dma_length = sg[i].length; 99 } 100 101 return nents; 102} 103 104static void ibmebus_unmap_sg(struct device *dev, 105 struct scatterlist *sg, 106 int nents, enum dma_data_direction direction) 107{ 108 return; 109} 110 111static int ibmebus_dma_supported(struct device *dev, u64 mask) 112{ 113 return 1; 114} 115 116static struct dma_mapping_ops ibmebus_dma_ops = { 117 .alloc_coherent = ibmebus_alloc_coherent, 118 .free_coherent = ibmebus_free_coherent, 119 .map_single = ibmebus_map_single, 120 .unmap_single = ibmebus_unmap_single, 121 .map_sg = ibmebus_map_sg, 122 .unmap_sg = ibmebus_unmap_sg, 123 .dma_supported = ibmebus_dma_supported, 124}; 125 126static int ibmebus_bus_probe(struct device *dev) 127{ 128 struct ibmebus_dev *ibmebusdev = to_ibmebus_dev(dev); 129 struct ibmebus_driver *ibmebusdrv = to_ibmebus_driver(dev->driver); 130 const struct of_device_id *id; 131 int error = -ENODEV; 132 133 if (!ibmebusdrv->probe) 134 return error; 135 136 id = of_match_device(ibmebusdrv->id_table, &ibmebusdev->ofdev); 137 if (id) { 138 error = ibmebusdrv->probe(ibmebusdev, id); 139 } 140 141 return error; 142} 143 144static int ibmebus_bus_remove(struct device *dev) 145{ 146 struct ibmebus_dev *ibmebusdev = to_ibmebus_dev(dev); 147 struct ibmebus_driver *ibmebusdrv = to_ibmebus_driver(dev->driver); 148 149 if (ibmebusdrv->remove) { 150 return ibmebusdrv->remove(ibmebusdev); 151 } 152 153 return 0; 154} 155 156static void __devinit ibmebus_dev_release(struct device *dev) 157{ 158 of_node_put(to_ibmebus_dev(dev)->ofdev.node); 159 kfree(to_ibmebus_dev(dev)); 160} 161 162static int __devinit ibmebus_register_device_common( 163 struct ibmebus_dev *dev, const char *name) 164{ 165 int err = 0; 166 167 dev->ofdev.dev.parent = &ibmebus_bus_device; 168 dev->ofdev.dev.bus = &ibmebus_bus_type; 169 dev->ofdev.dev.release = ibmebus_dev_release; 170 171 dev->ofdev.dev.archdata.of_node = dev->ofdev.node; 172 dev->ofdev.dev.archdata.dma_ops = &ibmebus_dma_ops; 173 dev->ofdev.dev.archdata.numa_node = of_node_to_nid(dev->ofdev.node); 174 175 /* An ibmebusdev is based on a of_device. We have to change the 176 * bus type to use our own DMA mapping operations. 177 */ 178 if ((err = of_device_register(&dev->ofdev)) != 0) { 179 printk(KERN_ERR "%s: failed to register device (%d).\n", 180 __FUNCTION__, err); 181 return -ENODEV; 182 } 183 184 return 0; 185} 186 187static struct ibmebus_dev* __devinit ibmebus_register_device_node( 188 struct device_node *dn) 189{ 190 struct ibmebus_dev *dev; 191 const char *loc_code; 192 int length; 193 194 loc_code = of_get_property(dn, "ibm,loc-code", NULL); 195 if (!loc_code) { 196 printk(KERN_WARNING "%s: node %s missing 'ibm,loc-code'\n", 197 __FUNCTION__, dn->name ? dn->name : "<unknown>"); 198 return ERR_PTR(-EINVAL); 199 } 200 201 if (strlen(loc_code) == 0) { 202 printk(KERN_WARNING "%s: 'ibm,loc-code' is invalid\n", 203 __FUNCTION__); 204 return ERR_PTR(-EINVAL); 205 } 206 207 dev = kzalloc(sizeof(struct ibmebus_dev), GFP_KERNEL); 208 if (!dev) { 209 return ERR_PTR(-ENOMEM); 210 } 211 212 dev->ofdev.node = of_node_get(dn); 213 214 length = strlen(loc_code); 215 memcpy(dev->ofdev.dev.bus_id, loc_code 216 + (length - min(length, BUS_ID_SIZE - 1)), 217 min(length, BUS_ID_SIZE - 1)); 218 219 /* Register with generic device framework. */ 220 if (ibmebus_register_device_common(dev, dn->name) != 0) { 221 kfree(dev); 222 return ERR_PTR(-ENODEV); 223 } 224 225 return dev; 226} 227 228static void ibmebus_probe_of_nodes(char* name) 229{ 230 struct device_node *dn = NULL; 231 232 while ((dn = of_find_node_by_name(dn, name))) { 233 if (IS_ERR(ibmebus_register_device_node(dn))) { 234 of_node_put(dn); 235 return; 236 } 237 } 238 239 of_node_put(dn); 240 241 return; 242} 243 244static void ibmebus_add_devices_by_id(struct of_device_id *idt) 245{ 246 while (strlen(idt->name) > 0) { 247 ibmebus_probe_of_nodes(idt->name); 248 idt++; 249 } 250 251 return; 252} 253 254static int ibmebus_match_name(struct device *dev, void *data) 255{ 256 const struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev); 257 const char *name; 258 259 name = of_get_property(ebus_dev->ofdev.node, "name", NULL); 260 261 if (name && (strcmp(data, name) == 0)) 262 return 1; 263 264 return 0; 265} 266 267static int ibmebus_unregister_device(struct device *dev) 268{ 269 of_device_unregister(to_of_device(dev)); 270 271 return 0; 272} 273 274static void ibmebus_remove_devices_by_id(struct of_device_id *idt) 275{ 276 struct device *dev; 277 278 while (strlen(idt->name) > 0) { 279 while ((dev = bus_find_device(&ibmebus_bus_type, NULL, 280 (void*)idt->name, 281 ibmebus_match_name))) { 282 ibmebus_unregister_device(dev); 283 } 284 idt++; 285 } 286 287 return; 288} 289 290int ibmebus_register_driver(struct ibmebus_driver *drv) 291{ 292 int err = 0; 293 294 drv->driver.name = drv->name; 295 drv->driver.bus = &ibmebus_bus_type; 296 drv->driver.probe = ibmebus_bus_probe; 297 drv->driver.remove = ibmebus_bus_remove; 298 299 if ((err = driver_register(&drv->driver) != 0)) 300 return err; 301 302 /* remove all supported devices first, in case someone 303 * probed them manually before registering the driver */ 304 ibmebus_remove_devices_by_id(drv->id_table); 305 ibmebus_add_devices_by_id(drv->id_table); 306 307 return 0; 308} 309EXPORT_SYMBOL(ibmebus_register_driver); 310 311void ibmebus_unregister_driver(struct ibmebus_driver *drv) 312{ 313 driver_unregister(&drv->driver); 314 ibmebus_remove_devices_by_id(drv->id_table); 315} 316EXPORT_SYMBOL(ibmebus_unregister_driver); 317 318int ibmebus_request_irq(struct ibmebus_dev *dev, 319 u32 ist, 320 irq_handler_t handler, 321 unsigned long irq_flags, const char * devname, 322 void *dev_id) 323{ 324 unsigned int irq = irq_create_mapping(NULL, ist); 325 326 if (irq == NO_IRQ) 327 return -EINVAL; 328 329 return request_irq(irq, handler, 330 irq_flags, devname, dev_id); 331} 332EXPORT_SYMBOL(ibmebus_request_irq); 333 334void ibmebus_free_irq(struct ibmebus_dev *dev, u32 ist, void *dev_id) 335{ 336 unsigned int irq = irq_find_mapping(NULL, ist); 337 338 free_irq(irq, dev_id); 339} 340EXPORT_SYMBOL(ibmebus_free_irq); 341 342static int ibmebus_bus_match(struct device *dev, struct device_driver *drv) 343{ 344 const struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev); 345 struct ibmebus_driver *ebus_drv = to_ibmebus_driver(drv); 346 const struct of_device_id *ids = ebus_drv->id_table; 347 const struct of_device_id *found_id; 348 349 if (!ids) 350 return 0; 351 352 found_id = of_match_device(ids, &ebus_dev->ofdev); 353 if (found_id) 354 return 1; 355 356 return 0; 357} 358 359static ssize_t name_show(struct device *dev, 360 struct device_attribute *attr, char *buf) 361{ 362 struct ibmebus_dev *ebus_dev = to_ibmebus_dev(dev); 363 const char *name = of_get_property(ebus_dev->ofdev.node, "name", NULL); 364 return sprintf(buf, "%s\n", name); 365} 366 367static struct device_attribute ibmebus_dev_attrs[] = { 368 __ATTR_RO(name), 369 __ATTR_NULL 370}; 371 372static int ibmebus_match_path(struct device *dev, void *data) 373{ 374 int rc; 375 struct device_node *dn = 376 of_node_get(to_ibmebus_dev(dev)->ofdev.node); 377 378 rc = (dn->full_name && (strcasecmp((char*)data, dn->full_name) == 0)); 379 380 of_node_put(dn); 381 return rc; 382} 383 384static char *ibmebus_chomp(const char *in, size_t count) 385{ 386 char *out = (char*)kmalloc(count + 1, GFP_KERNEL); 387 if (!out) 388 return NULL; 389 390 memcpy(out, in, count); 391 out[count] = '\0'; 392 if (out[count - 1] == '\n') 393 out[count - 1] = '\0'; 394 395 return out; 396} 397 398static ssize_t ibmebus_store_probe(struct bus_type *bus, 399 const char *buf, size_t count) 400{ 401 struct device_node *dn = NULL; 402 struct ibmebus_dev *dev; 403 char *path; 404 ssize_t rc; 405 406 path = ibmebus_chomp(buf, count); 407 if (!path) 408 return -ENOMEM; 409 410 if (bus_find_device(&ibmebus_bus_type, NULL, path, 411 ibmebus_match_path)) { 412 printk(KERN_WARNING "%s: %s has already been probed\n", 413 __FUNCTION__, path); 414 rc = -EINVAL; 415 goto out; 416 } 417 418 if ((dn = of_find_node_by_path(path))) { 419 dev = ibmebus_register_device_node(dn); 420 of_node_put(dn); 421 rc = IS_ERR(dev) ? PTR_ERR(dev) : count; 422 } else { 423 printk(KERN_WARNING "%s: no such device node: %s\n", 424 __FUNCTION__, path); 425 rc = -ENODEV; 426 } 427 428out: 429 kfree(path); 430 return rc; 431} 432 433static ssize_t ibmebus_store_remove(struct bus_type *bus, 434 const char *buf, size_t count) 435{ 436 struct device *dev; 437 char *path; 438 439 path = ibmebus_chomp(buf, count); 440 if (!path) 441 return -ENOMEM; 442 443 if ((dev = bus_find_device(&ibmebus_bus_type, NULL, path, 444 ibmebus_match_path))) { 445 ibmebus_unregister_device(dev); 446 447 kfree(path); 448 return count; 449 } else { 450 printk(KERN_WARNING "%s: %s not on the bus\n", 451 __FUNCTION__, path); 452 453 kfree(path); 454 return -ENODEV; 455 } 456} 457 458static struct bus_attribute ibmebus_bus_attrs[] = { 459 __ATTR(probe, S_IWUSR, NULL, ibmebus_store_probe), 460 __ATTR(remove, S_IWUSR, NULL, ibmebus_store_remove), 461 __ATTR_NULL 462}; 463 464struct bus_type ibmebus_bus_type = { 465 .name = "ibmebus", 466 .match = ibmebus_bus_match, 467 .dev_attrs = ibmebus_dev_attrs, 468 .bus_attrs = ibmebus_bus_attrs 469}; 470EXPORT_SYMBOL(ibmebus_bus_type); 471 472static int __init ibmebus_bus_init(void) 473{ 474 int err; 475 476 printk(KERN_INFO "IBM eBus Device Driver\n"); 477 478 err = bus_register(&ibmebus_bus_type); 479 if (err) { 480 printk(KERN_ERR ":%s: failed to register IBM eBus.\n", 481 __FUNCTION__); 482 return err; 483 } 484 485 err = device_register(&ibmebus_bus_device); 486 if (err) { 487 printk(KERN_WARNING "%s: device_register returned %i\n", 488 __FUNCTION__, err); 489 bus_unregister(&ibmebus_bus_type); 490 491 return err; 492 } 493 494 return 0; 495} 496__initcall(ibmebus_bus_init); 497