ibmebus.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757
  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. #include <linux/init.h>
  39. #include <linux/export.h>
  40. #include <linux/console.h>
  41. #include <linux/kobject.h>
  42. #include <linux/dma-mapping.h>
  43. #include <linux/interrupt.h>
  44. #include <linux/of.h>
  45. #include <linux/slab.h>
  46. #include <linux/stat.h>
  47. #include <linux/of_platform.h>
  48. #include <asm/ibmebus.h>
  49. static struct device ibmebus_bus_device = { /* fake "parent" device */
  50. .init_name = "ibmebus",
  51. };
  52. struct bus_type ibmebus_bus_type;
  53. /* These devices will automatically be added to the bus during init */
  54. static struct of_device_id __initdata ibmebus_matches[] = {
  55. { .compatible = "IBM,lhca" },
  56. { .compatible = "IBM,lhea" },
  57. {},
  58. };
  59. static void *ibmebus_alloc_coherent(struct device *dev,
  60. size_t size,
  61. dma_addr_t *dma_handle,
  62. gfp_t flag,
  63. struct dma_attrs *attrs)
  64. {
  65. void *mem;
  66. mem = kmalloc(size, flag);
  67. *dma_handle = (dma_addr_t)mem;
  68. return mem;
  69. }
  70. static void ibmebus_free_coherent(struct device *dev,
  71. size_t size, void *vaddr,
  72. dma_addr_t dma_handle,
  73. struct dma_attrs *attrs)
  74. {
  75. kfree(vaddr);
  76. }
  77. static dma_addr_t ibmebus_map_page(struct device *dev,
  78. struct page *page,
  79. unsigned long offset,
  80. size_t size,
  81. enum dma_data_direction direction,
  82. struct dma_attrs *attrs)
  83. {
  84. return (dma_addr_t)(page_address(page) + offset);
  85. }
  86. static void ibmebus_unmap_page(struct device *dev,
  87. dma_addr_t dma_addr,
  88. size_t size,
  89. enum dma_data_direction direction,
  90. struct dma_attrs *attrs)
  91. {
  92. return;
  93. }
  94. static int ibmebus_map_sg(struct device *dev,
  95. struct scatterlist *sgl,
  96. int nents, enum dma_data_direction direction,
  97. struct dma_attrs *attrs)
  98. {
  99. struct scatterlist *sg;
  100. int i;
  101. for_each_sg(sgl, sg, nents, i) {
  102. sg->dma_address = (dma_addr_t) sg_virt(sg);
  103. sg->dma_length = sg->length;
  104. }
  105. return nents;
  106. }
  107. static void ibmebus_unmap_sg(struct device *dev,
  108. struct scatterlist *sg,
  109. int nents, enum dma_data_direction direction,
  110. struct dma_attrs *attrs)
  111. {
  112. return;
  113. }
  114. static int ibmebus_dma_supported(struct device *dev, u64 mask)
  115. {
  116. return mask == DMA_BIT_MASK(64);
  117. }
  118. static u64 ibmebus_dma_get_required_mask(struct device *dev)
  119. {
  120. return DMA_BIT_MASK(64);
  121. }
  122. static struct dma_map_ops ibmebus_dma_ops = {
  123. .alloc = ibmebus_alloc_coherent,
  124. .free = ibmebus_free_coherent,
  125. .map_sg = ibmebus_map_sg,
  126. .unmap_sg = ibmebus_unmap_sg,
  127. .dma_supported = ibmebus_dma_supported,
  128. .get_required_mask = ibmebus_dma_get_required_mask,
  129. .map_page = ibmebus_map_page,
  130. .unmap_page = ibmebus_unmap_page,
  131. };
  132. static int ibmebus_match_path(struct device *dev, void *data)
  133. {
  134. struct device_node *dn = to_platform_device(dev)->dev.of_node;
  135. return (dn->full_name &&
  136. (strcasecmp((char *)data, dn->full_name) == 0));
  137. }
  138. static int ibmebus_match_node(struct device *dev, void *data)
  139. {
  140. return to_platform_device(dev)->dev.of_node == data;
  141. }
  142. static int ibmebus_create_device(struct device_node *dn)
  143. {
  144. struct platform_device *dev;
  145. int ret;
  146. dev = of_device_alloc(dn, NULL, &ibmebus_bus_device);
  147. if (!dev)
  148. return -ENOMEM;
  149. dev->dev.bus = &ibmebus_bus_type;
  150. dev->dev.archdata.dma_ops = &ibmebus_dma_ops;
  151. ret = of_device_add(dev);
  152. if (ret)
  153. platform_device_put(dev);
  154. return ret;
  155. }
  156. static int ibmebus_create_devices(const struct of_device_id *matches)
  157. {
  158. struct device_node *root, *child;
  159. int ret = 0;
  160. root = of_find_node_by_path("/");
  161. for_each_child_of_node(root, child) {
  162. if (!of_match_node(matches, child))
  163. continue;
  164. if (bus_find_device(&ibmebus_bus_type, NULL, child,
  165. ibmebus_match_node))
  166. continue;
  167. ret = ibmebus_create_device(child);
  168. if (ret) {
  169. printk(KERN_ERR "%s: failed to create device (%i)",
  170. __func__, ret);
  171. of_node_put(child);
  172. break;
  173. }
  174. }
  175. of_node_put(root);
  176. return ret;
  177. }
  178. int ibmebus_register_driver(struct platform_driver *drv)
  179. {
  180. /* If the driver uses devices that ibmebus doesn't know, add them */
  181. ibmebus_create_devices(drv->driver.of_match_table);
  182. drv->driver.bus = &ibmebus_bus_type;
  183. return driver_register(&drv->driver);
  184. }
  185. EXPORT_SYMBOL(ibmebus_register_driver);
  186. void ibmebus_unregister_driver(struct platform_driver *drv)
  187. {
  188. driver_unregister(&drv->driver);
  189. }
  190. EXPORT_SYMBOL(ibmebus_unregister_driver);
  191. int ibmebus_request_irq(u32 ist, irq_handler_t handler,
  192. unsigned long irq_flags, const char *devname,
  193. void *dev_id)
  194. {
  195. unsigned int irq = irq_create_mapping(NULL, ist);
  196. if (irq == NO_IRQ)
  197. return -EINVAL;
  198. return request_irq(irq, handler, irq_flags, devname, dev_id);
  199. }
  200. EXPORT_SYMBOL(ibmebus_request_irq);
  201. void ibmebus_free_irq(u32 ist, void *dev_id)
  202. {
  203. unsigned int irq = irq_find_mapping(NULL, ist);
  204. free_irq(irq, dev_id);
  205. irq_dispose_mapping(irq);
  206. }
  207. EXPORT_SYMBOL(ibmebus_free_irq);
  208. static char *ibmebus_chomp(const char *in, size_t count)
  209. {
  210. char *out = kmalloc(count + 1, GFP_KERNEL);
  211. if (!out)
  212. return NULL;
  213. memcpy(out, in, count);
  214. out[count] = '\0';
  215. if (out[count - 1] == '\n')
  216. out[count - 1] = '\0';
  217. return out;
  218. }
  219. static ssize_t ibmebus_store_probe(struct bus_type *bus,
  220. const char *buf, size_t count)
  221. {
  222. struct device_node *dn = NULL;
  223. char *path;
  224. ssize_t rc = 0;
  225. path = ibmebus_chomp(buf, count);
  226. if (!path)
  227. return -ENOMEM;
  228. if (bus_find_device(&ibmebus_bus_type, NULL, path,
  229. ibmebus_match_path)) {
  230. printk(KERN_WARNING "%s: %s has already been probed\n",
  231. __func__, path);
  232. rc = -EEXIST;
  233. goto out;
  234. }
  235. if ((dn = of_find_node_by_path(path))) {
  236. rc = ibmebus_create_device(dn);
  237. of_node_put(dn);
  238. } else {
  239. printk(KERN_WARNING "%s: no such device node: %s\n",
  240. __func__, path);
  241. rc = -ENODEV;
  242. }
  243. out:
  244. kfree(path);
  245. if (rc)
  246. return rc;
  247. return count;
  248. }
  249. static ssize_t ibmebus_store_remove(struct bus_type *bus,
  250. const char *buf, size_t count)
  251. {
  252. struct device *dev;
  253. char *path;
  254. path = ibmebus_chomp(buf, count);
  255. if (!path)
  256. return -ENOMEM;
  257. if ((dev = bus_find_device(&ibmebus_bus_type, NULL, path,
  258. ibmebus_match_path))) {
  259. of_device_unregister(to_platform_device(dev));
  260. kfree(path);
  261. return count;
  262. } else {
  263. printk(KERN_WARNING "%s: %s not on the bus\n",
  264. __func__, path);
  265. kfree(path);
  266. return -ENODEV;
  267. }
  268. }
  269. static struct bus_attribute ibmebus_bus_attrs[] = {
  270. __ATTR(probe, S_IWUSR, NULL, ibmebus_store_probe),
  271. __ATTR(remove, S_IWUSR, NULL, ibmebus_store_remove),
  272. __ATTR_NULL
  273. };
  274. static int ibmebus_bus_bus_match(struct device *dev, struct device_driver *drv)
  275. {
  276. const struct of_device_id *matches = drv->of_match_table;
  277. if (!matches)
  278. return 0;
  279. return of_match_device(matches, dev) != NULL;
  280. }
  281. static int ibmebus_bus_device_probe(struct device *dev)
  282. {
  283. int error = -ENODEV;
  284. struct platform_driver *drv;
  285. struct platform_device *of_dev;
  286. drv = to_platform_driver(dev->driver);
  287. of_dev = to_platform_device(dev);
  288. if (!drv->probe)
  289. return error;
  290. of_dev_get(of_dev);
  291. if (of_driver_match_device(dev, dev->driver))
  292. error = drv->probe(of_dev);
  293. if (error)
  294. of_dev_put(of_dev);
  295. return error;
  296. }
  297. static int ibmebus_bus_device_remove(struct device *dev)
  298. {
  299. struct platform_device *of_dev = to_platform_device(dev);
  300. struct platform_driver *drv = to_platform_driver(dev->driver);
  301. if (dev->driver && drv->remove)
  302. drv->remove(of_dev);
  303. return 0;
  304. }
  305. static void ibmebus_bus_device_shutdown(struct device *dev)
  306. {
  307. struct platform_device *of_dev = to_platform_device(dev);
  308. struct platform_driver *drv = to_platform_driver(dev->driver);
  309. if (dev->driver && drv->shutdown)
  310. drv->shutdown(of_dev);
  311. }
  312. /*
  313. * ibmebus_bus_device_attrs
  314. */
  315. static ssize_t devspec_show(struct device *dev,
  316. struct device_attribute *attr, char *buf)
  317. {
  318. struct platform_device *ofdev;
  319. ofdev = to_platform_device(dev);
  320. return sprintf(buf, "%s\n", ofdev->dev.of_node->full_name);
  321. }
  322. static ssize_t name_show(struct device *dev,
  323. struct device_attribute *attr, char *buf)
  324. {
  325. struct platform_device *ofdev;
  326. ofdev = to_platform_device(dev);
  327. return sprintf(buf, "%s\n", ofdev->dev.of_node->name);
  328. }
  329. static ssize_t modalias_show(struct device *dev,
  330. struct device_attribute *attr, char *buf)
  331. {
  332. ssize_t len = of_device_get_modalias(dev, buf, PAGE_SIZE - 2);
  333. buf[len] = '\n';
  334. buf[len+1] = 0;
  335. return len+1;
  336. }
  337. struct device_attribute ibmebus_bus_device_attrs[] = {
  338. __ATTR_RO(devspec),
  339. __ATTR_RO(name),
  340. __ATTR_RO(modalias),
  341. __ATTR_NULL
  342. };
  343. #ifdef CONFIG_PM_SLEEP
  344. static int ibmebus_bus_legacy_suspend(struct device *dev, pm_message_t mesg)
  345. {
  346. struct platform_device *of_dev = to_platform_device(dev);
  347. struct platform_driver *drv = to_platform_driver(dev->driver);
  348. int ret = 0;
  349. if (dev->driver && drv->suspend)
  350. ret = drv->suspend(of_dev, mesg);
  351. return ret;
  352. }
  353. static int ibmebus_bus_legacy_resume(struct device *dev)
  354. {
  355. struct platform_device *of_dev = to_platform_device(dev);
  356. struct platform_driver *drv = to_platform_driver(dev->driver);
  357. int ret = 0;
  358. if (dev->driver && drv->resume)
  359. ret = drv->resume(of_dev);
  360. return ret;
  361. }
  362. static int ibmebus_bus_pm_prepare(struct device *dev)
  363. {
  364. struct device_driver *drv = dev->driver;
  365. int ret = 0;
  366. if (drv && drv->pm && drv->pm->prepare)
  367. ret = drv->pm->prepare(dev);
  368. return ret;
  369. }
  370. static void ibmebus_bus_pm_complete(struct device *dev)
  371. {
  372. struct device_driver *drv = dev->driver;
  373. if (drv && drv->pm && drv->pm->complete)
  374. drv->pm->complete(dev);
  375. }
  376. #ifdef CONFIG_SUSPEND
  377. static int ibmebus_bus_pm_suspend(struct device *dev)
  378. {
  379. struct device_driver *drv = dev->driver;
  380. int ret = 0;
  381. if (!drv)
  382. return 0;
  383. if (drv->pm) {
  384. if (drv->pm->suspend)
  385. ret = drv->pm->suspend(dev);
  386. } else {
  387. ret = ibmebus_bus_legacy_suspend(dev, PMSG_SUSPEND);
  388. }
  389. return ret;
  390. }
  391. static int ibmebus_bus_pm_suspend_noirq(struct device *dev)
  392. {
  393. struct device_driver *drv = dev->driver;
  394. int ret = 0;
  395. if (!drv)
  396. return 0;
  397. if (drv->pm) {
  398. if (drv->pm->suspend_noirq)
  399. ret = drv->pm->suspend_noirq(dev);
  400. }
  401. return ret;
  402. }
  403. static int ibmebus_bus_pm_resume(struct device *dev)
  404. {
  405. struct device_driver *drv = dev->driver;
  406. int ret = 0;
  407. if (!drv)
  408. return 0;
  409. if (drv->pm) {
  410. if (drv->pm->resume)
  411. ret = drv->pm->resume(dev);
  412. } else {
  413. ret = ibmebus_bus_legacy_resume(dev);
  414. }
  415. return ret;
  416. }
  417. static int ibmebus_bus_pm_resume_noirq(struct device *dev)
  418. {
  419. struct device_driver *drv = dev->driver;
  420. int ret = 0;
  421. if (!drv)
  422. return 0;
  423. if (drv->pm) {
  424. if (drv->pm->resume_noirq)
  425. ret = drv->pm->resume_noirq(dev);
  426. }
  427. return ret;
  428. }
  429. #else /* !CONFIG_SUSPEND */
  430. #define ibmebus_bus_pm_suspend NULL
  431. #define ibmebus_bus_pm_resume NULL
  432. #define ibmebus_bus_pm_suspend_noirq NULL
  433. #define ibmebus_bus_pm_resume_noirq NULL
  434. #endif /* !CONFIG_SUSPEND */
  435. #ifdef CONFIG_HIBERNATE_CALLBACKS
  436. static int ibmebus_bus_pm_freeze(struct device *dev)
  437. {
  438. struct device_driver *drv = dev->driver;
  439. int ret = 0;
  440. if (!drv)
  441. return 0;
  442. if (drv->pm) {
  443. if (drv->pm->freeze)
  444. ret = drv->pm->freeze(dev);
  445. } else {
  446. ret = ibmebus_bus_legacy_suspend(dev, PMSG_FREEZE);
  447. }
  448. return ret;
  449. }
  450. static int ibmebus_bus_pm_freeze_noirq(struct device *dev)
  451. {
  452. struct device_driver *drv = dev->driver;
  453. int ret = 0;
  454. if (!drv)
  455. return 0;
  456. if (drv->pm) {
  457. if (drv->pm->freeze_noirq)
  458. ret = drv->pm->freeze_noirq(dev);
  459. }
  460. return ret;
  461. }
  462. static int ibmebus_bus_pm_thaw(struct device *dev)
  463. {
  464. struct device_driver *drv = dev->driver;
  465. int ret = 0;
  466. if (!drv)
  467. return 0;
  468. if (drv->pm) {
  469. if (drv->pm->thaw)
  470. ret = drv->pm->thaw(dev);
  471. } else {
  472. ret = ibmebus_bus_legacy_resume(dev);
  473. }
  474. return ret;
  475. }
  476. static int ibmebus_bus_pm_thaw_noirq(struct device *dev)
  477. {
  478. struct device_driver *drv = dev->driver;
  479. int ret = 0;
  480. if (!drv)
  481. return 0;
  482. if (drv->pm) {
  483. if (drv->pm->thaw_noirq)
  484. ret = drv->pm->thaw_noirq(dev);
  485. }
  486. return ret;
  487. }
  488. static int ibmebus_bus_pm_poweroff(struct device *dev)
  489. {
  490. struct device_driver *drv = dev->driver;
  491. int ret = 0;
  492. if (!drv)
  493. return 0;
  494. if (drv->pm) {
  495. if (drv->pm->poweroff)
  496. ret = drv->pm->poweroff(dev);
  497. } else {
  498. ret = ibmebus_bus_legacy_suspend(dev, PMSG_HIBERNATE);
  499. }
  500. return ret;
  501. }
  502. static int ibmebus_bus_pm_poweroff_noirq(struct device *dev)
  503. {
  504. struct device_driver *drv = dev->driver;
  505. int ret = 0;
  506. if (!drv)
  507. return 0;
  508. if (drv->pm) {
  509. if (drv->pm->poweroff_noirq)
  510. ret = drv->pm->poweroff_noirq(dev);
  511. }
  512. return ret;
  513. }
  514. static int ibmebus_bus_pm_restore(struct device *dev)
  515. {
  516. struct device_driver *drv = dev->driver;
  517. int ret = 0;
  518. if (!drv)
  519. return 0;
  520. if (drv->pm) {
  521. if (drv->pm->restore)
  522. ret = drv->pm->restore(dev);
  523. } else {
  524. ret = ibmebus_bus_legacy_resume(dev);
  525. }
  526. return ret;
  527. }
  528. static int ibmebus_bus_pm_restore_noirq(struct device *dev)
  529. {
  530. struct device_driver *drv = dev->driver;
  531. int ret = 0;
  532. if (!drv)
  533. return 0;
  534. if (drv->pm) {
  535. if (drv->pm->restore_noirq)
  536. ret = drv->pm->restore_noirq(dev);
  537. }
  538. return ret;
  539. }
  540. #else /* !CONFIG_HIBERNATE_CALLBACKS */
  541. #define ibmebus_bus_pm_freeze NULL
  542. #define ibmebus_bus_pm_thaw NULL
  543. #define ibmebus_bus_pm_poweroff NULL
  544. #define ibmebus_bus_pm_restore NULL
  545. #define ibmebus_bus_pm_freeze_noirq NULL
  546. #define ibmebus_bus_pm_thaw_noirq NULL
  547. #define ibmebus_bus_pm_poweroff_noirq NULL
  548. #define ibmebus_bus_pm_restore_noirq NULL
  549. #endif /* !CONFIG_HIBERNATE_CALLBACKS */
  550. static struct dev_pm_ops ibmebus_bus_dev_pm_ops = {
  551. .prepare = ibmebus_bus_pm_prepare,
  552. .complete = ibmebus_bus_pm_complete,
  553. .suspend = ibmebus_bus_pm_suspend,
  554. .resume = ibmebus_bus_pm_resume,
  555. .freeze = ibmebus_bus_pm_freeze,
  556. .thaw = ibmebus_bus_pm_thaw,
  557. .poweroff = ibmebus_bus_pm_poweroff,
  558. .restore = ibmebus_bus_pm_restore,
  559. .suspend_noirq = ibmebus_bus_pm_suspend_noirq,
  560. .resume_noirq = ibmebus_bus_pm_resume_noirq,
  561. .freeze_noirq = ibmebus_bus_pm_freeze_noirq,
  562. .thaw_noirq = ibmebus_bus_pm_thaw_noirq,
  563. .poweroff_noirq = ibmebus_bus_pm_poweroff_noirq,
  564. .restore_noirq = ibmebus_bus_pm_restore_noirq,
  565. };
  566. #define IBMEBUS_BUS_PM_OPS_PTR (&ibmebus_bus_dev_pm_ops)
  567. #else /* !CONFIG_PM_SLEEP */
  568. #define IBMEBUS_BUS_PM_OPS_PTR NULL
  569. #endif /* !CONFIG_PM_SLEEP */
  570. struct bus_type ibmebus_bus_type = {
  571. .name = "ibmebus",
  572. .uevent = of_device_uevent_modalias,
  573. .bus_attrs = ibmebus_bus_attrs,
  574. .match = ibmebus_bus_bus_match,
  575. .probe = ibmebus_bus_device_probe,
  576. .remove = ibmebus_bus_device_remove,
  577. .shutdown = ibmebus_bus_device_shutdown,
  578. .dev_attrs = ibmebus_bus_device_attrs,
  579. .pm = IBMEBUS_BUS_PM_OPS_PTR,
  580. };
  581. EXPORT_SYMBOL(ibmebus_bus_type);
  582. static int __init ibmebus_bus_init(void)
  583. {
  584. int err;
  585. printk(KERN_INFO "IBM eBus Device Driver\n");
  586. err = bus_register(&ibmebus_bus_type);
  587. if (err) {
  588. printk(KERN_ERR "%s: failed to register IBM eBus.\n",
  589. __func__);
  590. return err;
  591. }
  592. err = device_register(&ibmebus_bus_device);
  593. if (err) {
  594. printk(KERN_WARNING "%s: device_register returned %i\n",
  595. __func__, err);
  596. bus_unregister(&ibmebus_bus_type);
  597. return err;
  598. }
  599. err = ibmebus_create_devices(ibmebus_matches);
  600. if (err) {
  601. device_unregister(&ibmebus_bus_device);
  602. bus_unregister(&ibmebus_bus_type);
  603. return err;
  604. }
  605. return 0;
  606. }
  607. postcore_initcall(ibmebus_bus_init);