开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
nodemgr.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：25k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

nodemgr.c：源码内容
  1. /*
  2.  * Node information (ConfigROM) collection and management.
  3.  *
  4.  * Copyright (C) 2000 Andreas E. Bombe
  5.  *               2001 Ben Collins <bcollins@debian.net>
  6.  *
  7.  * This code is licensed under the GPL.  See the file COPYING in the root
  8.  * directory of the kernel sources for details.
  9.  */
  11. #include <linux/kernel.h>
  12. #include <linux/list.h>
  13. #include <linux/slab.h>
  14. #include <asm/byteorder.h>
  15. #include <asm/atomic.h>
  16. #include <linux/smp_lock.h>
  17. #include <linux/interrupt.h>
  18. #include <linux/kmod.h>
  20. #include "ieee1394_types.h"
  21. #include "ieee1394.h"
  22. #include "hosts.h"
  23. #include "ieee1394_transactions.h"
  24. #include "ieee1394_hotplug.h"
  25. #include "highlevel.h"
  26. #include "csr.h"
  27. #include "nodemgr.h"
  30. /* 
  31.  * Basically what we do here is start off retrieving the bus_info block.
  32.  * From there will fill in some info about the node, verify it is of IEEE
  33.  * 1394 type, and that the crc checks out ok. After that we start off with
  34.  * the root directory, and subdirectories. To do this, we retrieve the
  35.  * quadlet header for a directory, find out the length, and retrieve the
  36.  * complete directory entry (be it a leaf or a directory). We then process
  37.  * it and add the info to our structure for that particular node.
  38.  *
  39.  * We verify CRC's along the way for each directory/block/leaf. The
  40.  * entire node structure is generic, and simply stores the information in
  41.  * a way that's easy to parse by the protocol interface.
  42.  */
  44. static LIST_HEAD(node_list);
  45. static rwlock_t node_lock = RW_LOCK_UNLOCKED;
  47. static LIST_HEAD(driver_list);
  48. static rwlock_t driver_lock = RW_LOCK_UNLOCKED;
  50. /* The rwlock unit_directory_lock is always held when manipulating the
  51.  * global unit_directory_list, but this also protects access to the
  52.  * lists of unit directories stored in the protocol drivers.
  53.  */
  54. static LIST_HEAD(unit_directory_list);
  55. static rwlock_t unit_directory_lock = RW_LOCK_UNLOCKED;
  57. static LIST_HEAD(host_info_list);
  58. static spinlock_t host_info_lock = SPIN_LOCK_UNLOCKED;
  60. struct host_info {
  61. struct hpsb_host *host;
  62. struct tq_struct task;
  63. struct list_head list;
  64. };
  66. static void nodemgr_process_config_rom(struct node_entry *ne, 
  67.        quadlet_t busoptions);
  70. static struct node_entry *nodemgr_create_node(octlet_t guid, quadlet_t busoptions,
  71.       struct hpsb_host *host, nodeid_t nodeid)
  72. {
  73.         struct node_entry *ne;
  74.         unsigned long flags;
  76.         ne = kmalloc(sizeof(struct node_entry), SLAB_ATOMIC);
  77.         if (!ne) return NULL;
  79.         INIT_LIST_HEAD(&ne->list);
  80. INIT_LIST_HEAD(&ne->unit_directories);
  81.         ne->host = host;
  82.         ne->nodeid = nodeid;
  83.         ne->guid = guid;
  84. atomic_set(&ne->generation, get_hpsb_generation(ne->host));
  86.         write_lock_irqsave(&node_lock, flags);
  87.         list_add_tail(&ne->list, &node_list);
  88.         write_unlock_irqrestore(&node_lock, flags);
  90. nodemgr_process_config_rom (ne, busoptions);
  92. HPSB_DEBUG("%s added: node " NODE_BUS_FMT ", GUID %016Lx",
  93.    (host->node_id == nodeid) ? "Local host" : "Device",
  94.    NODE_BUS_ARGS(nodeid), (unsigned long long)guid);
  96.         return ne;
  97. }
  99. static struct node_entry *find_entry_by_guid(u64 guid)
  100. {
  101.         struct list_head *lh;
  102.         struct node_entry *ne;
  103.         
  104.         list_for_each(lh, &node_list) {
  105.                 ne = list_entry(lh, struct node_entry, list);
  106.                 if (ne->guid == guid) return ne;
  107.         }
  109.         return NULL;
  110. }
  112. static struct node_entry *find_entry_by_nodeid(nodeid_t nodeid)
  113. {
  114. struct list_head *lh;
  115. struct node_entry *ne;
  117. list_for_each(lh, &node_list) {
  118. ne = list_entry(lh, struct node_entry, list);
  119. if (ne->nodeid == nodeid) return ne;
  120. }
  122. return NULL;
  123. }
  125. int nodemgr_read_quadlet(struct node_entry *ne,
  126.  octlet_t address, quadlet_t *quad)
  127. {
  128. int i;
  129. int ret = 0;
  131. for (i = 0; i < 3; i++) {
  132. ret = hpsb_read(ne->host, ne->nodeid, address, quad, 4);
  133. if (ret != -EAGAIN)
  134. break;
  135. }
  136. *quad = be32_to_cpu(*quad);
  138. return ret;
  139. }
  141. #define CONFIG_ROM_VENDOR_ID 0x03
  142. #define CONFIG_ROM_MODEL_ID 0x17
  143. #define CONFIG_ROM_NODE_CAPABILITES 0x0C
  144. #define CONFIG_ROM_UNIT_DIRECTORY 0xd1
  145. #define CONFIG_ROM_SPECIFIER_ID 0x12 
  146. #define CONFIG_ROM_VERSION 0x13
  147. #define CONFIG_ROM_DESCRIPTOR_LEAF 0x81
  148. #define CONFIG_ROM_DESCRIPTOR_DIRECTORY 0xc1
  150. /* This implementation currently only scans the config rom and its
  151.  * immediate unit directories looking for software_id and
  152.  * software_version entries, in order to get driver autoloading working.
  153.  */
  155. static void nodemgr_process_unit_directory(struct node_entry *ne, 
  156.    octlet_t address)
  157. {
  158. struct unit_directory *ud;
  159. octlet_t a;
  160. quadlet_t quad;
  161. int length, i;
  163. if (!(ud = kmalloc (sizeof *ud, GFP_KERNEL)))
  164. goto unit_directory_error;
  166. memset (ud, 0, sizeof *ud);
  167. ud->ne = ne;
  168. ud->address = address;
  169. ud->arb_count = 0;
  171. if (nodemgr_read_quadlet(ne, address, &quad))
  172. goto unit_directory_error;
  173. length = quad >> 16;
  174. a = address + 4;
  176. for (i = 0; i < length; i++, a += 4) {
  177. int code;
  178. quadlet_t value;
  180. if (nodemgr_read_quadlet(ne, a, &quad))
  181. goto unit_directory_error;
  182. code = quad >> 24;
  183. value = quad & 0xffffff;
  185. switch (code) {
  186. case CONFIG_ROM_VENDOR_ID:
  187. ud->vendor_id = value;
  188. ud->flags |= UNIT_DIRECTORY_VENDOR_ID;
  189. break;
  191. case CONFIG_ROM_MODEL_ID:
  192. ud->model_id = value;
  193. ud->flags |= UNIT_DIRECTORY_MODEL_ID;
  194. break;
  196. case CONFIG_ROM_SPECIFIER_ID:
  197. ud->specifier_id = value;
  198. ud->flags |= UNIT_DIRECTORY_SPECIFIER_ID;
  199. break;
  201. case CONFIG_ROM_VERSION:
  202. ud->version = value;
  203. ud->flags |= UNIT_DIRECTORY_VERSION;
  204. break;
  206. case CONFIG_ROM_DESCRIPTOR_LEAF:
  207. case CONFIG_ROM_DESCRIPTOR_DIRECTORY:
  208. /* TODO: read strings... icons? */
  209. break;
  211. default:
  212. if (ud->arb_count < 16) {
  213. /* Place them in the arbitrary pairs */
  214. ud->arb_keys[ud->arb_count] = code;
  215. ud->arb_values[ud->arb_count] = value;
  216. ud->arb_count++;
  217. }
  218. }
  219. }
  221. list_add_tail(&ud->node_list, &ne->unit_directories);
  222. list_add_tail(&ud->driver_list, &unit_directory_list);
  224. return;
  226. unit_directory_error:
  227. if (ud != NULL)
  228. kfree(ud);
  229. }
  231. static void dump_directories (struct node_entry *ne)
  232. {
  233. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  234. struct list_head *l;
  236. HPSB_DEBUG("vendor_id=0x%06x, capabilities=0x%06x",
  237.    ne->vendor_id, ne->capabilities);
  238. list_for_each (l, &ne->unit_directories) {
  239. struct unit_directory *ud = list_entry (l, struct unit_directory, node_list);
  240. HPSB_DEBUG("unit directory:");
  241. if (ud->flags & UNIT_DIRECTORY_VENDOR_ID)
  242. HPSB_DEBUG("  vendor_id=0x%06x ", ud->vendor_id);
  243. if (ud->flags & UNIT_DIRECTORY_MODEL_ID)
  244. HPSB_DEBUG("  model_id=0x%06x ", ud->model_id);
  245. if (ud->flags & UNIT_DIRECTORY_SPECIFIER_ID)
  246. HPSB_DEBUG("  sw_specifier_id=0x%06x ", ud->specifier_id);
  247. if (ud->flags & UNIT_DIRECTORY_VERSION)
  248. HPSB_DEBUG("  sw_version=0x%06x ", ud->version);
  249. }
  250. #else
  251. return;
  252. #endif
  253. }
  255. static void nodemgr_process_root_directory(struct node_entry *ne)
  256. {
  257. octlet_t address;
  258. quadlet_t quad;
  259. int length, i;
  261. address = CSR_REGISTER_BASE + CSR_CONFIG_ROM;
  263. if (nodemgr_read_quadlet(ne, address, &quad))
  264. return;
  265. address += 4 + (quad >> 24) * 4;
  267. if (nodemgr_read_quadlet(ne, address, &quad))
  268. return;
  269. length = quad >> 16;
  270. address += 4;
  272. for (i = 0; i < length; i++, address += 4) {
  273. int code, value;
  275. if (nodemgr_read_quadlet(ne, address, &quad))
  276. return;
  277. code = quad >> 24;
  278. value = quad & 0xffffff;
  280. switch (code) {
  281. case CONFIG_ROM_VENDOR_ID:
  282. ne->vendor_id = value;
  283. break;
  285. case CONFIG_ROM_NODE_CAPABILITES:
  286. ne->capabilities = value;
  287. break;
  289. case CONFIG_ROM_UNIT_DIRECTORY:
  290. nodemgr_process_unit_directory(ne, address + value * 4);
  291. break;
  293. case CONFIG_ROM_DESCRIPTOR_LEAF:
  294. case CONFIG_ROM_DESCRIPTOR_DIRECTORY:
  295. /* TODO: read strings... icons? */
  296. break;
  297. }
  298. }
  300. dump_directories(ne);
  301. }
  303. #ifdef CONFIG_HOTPLUG
  305. static void nodemgr_call_policy(char *verb, struct unit_directory *ud)
  306. {
  307. char *argv [3], **envp, *buf, *scratch;
  308. int i = 0, value;
  310. if (!hotplug_path [0])
  311. return;
  312. if (!current->fs->root)
  313. return;
  314. if (!(envp = (char **) kmalloc(20 * sizeof (char *), GFP_KERNEL))) {
  315. HPSB_DEBUG ("ENOMEM");
  316. return;
  317. }
  318. if (!(buf = kmalloc(256, GFP_KERNEL))) {
  319. kfree(envp);
  320. HPSB_DEBUG("ENOMEM2");
  321. return;
  322. }
  324. /* only one standardized param to hotplug command: type */
  325. argv[0] = hotplug_path;
  326. argv[1] = "ieee1394";
  327. argv[2] = 0;
  329. /* minimal command environment */
  330. envp[i++] = "HOME=/";
  331. envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
  333. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  334. /* hint that policy agent should enter no-stdout debug mode */
  335. envp[i++] = "DEBUG=kernel";
  336. #endif
  337. /* extensible set of named bus-specific parameters,
  338.  * supporting multiple driver selection algorithms.
  339.  */
  340. scratch = buf;
  342. envp[i++] = scratch;
  343. scratch += sprintf(scratch, "ACTION=%s", verb) + 1;
  344. envp[i++] = scratch;
  345. scratch += sprintf(scratch, "VENDOR_ID=%06x", ud->ne->vendor_id) + 1;
  346. envp[i++] = scratch;
  347. scratch += sprintf(scratch, "GUID=%016Lx", (long long unsigned)ud->ne->guid) + 1;
  348. envp[i++] = scratch;
  349. scratch += sprintf(scratch, "SPECIFIER_ID=%06x", ud->specifier_id) + 1;
  350. envp[i++] = scratch;
  351. scratch += sprintf(scratch, "VERSION=%06x", ud->version) + 1;
  352. envp[i++] = 0;
  354. /* NOTE: user mode daemons can call the agents too */
  355. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  356. HPSB_DEBUG("NodeMgr: %s %s %016Lx", argv[0], verb, (long long unsigned)ud->ne->guid);
  357. #endif
  358. value = call_usermodehelper(argv[0], argv, envp);
  359. kfree(buf);
  360. kfree(envp);
  361. if (value != 0)
  362. HPSB_DEBUG("NodeMgr: hotplug policy returned %d", value);
  363. }
  365. #else
  367. static inline void
  368. nodemgr_call_policy(char *verb, struct unit_directory *ud)
  369. {
  370. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  371. HPSB_DEBUG("NodeMgr: nodemgr_call_policy(): hotplug not enabled");
  372. #endif
  373. return;
  374. } 
  376. #endif /* CONFIG_HOTPLUG */
  378. static void nodemgr_claim_unit_directory(struct unit_directory *ud,
  379.  struct hpsb_protocol_driver *driver)
  380. {
  381. ud->driver = driver;
  382. list_del(&ud->driver_list);
  383. list_add_tail(&ud->driver_list, &driver->unit_directories);
  384. }
  386. static void nodemgr_release_unit_directory(struct unit_directory *ud)
  387. {
  388. ud->driver = NULL;
  389. list_del(&ud->driver_list);
  390. list_add_tail(&ud->driver_list, &unit_directory_list);
  391. }
  393. void hpsb_release_unit_directory(struct unit_directory *ud)
  394. {
  395. unsigned long flags;
  397. write_lock_irqsave(&unit_directory_lock, flags);
  398. nodemgr_release_unit_directory(ud);
  399. write_unlock_irqrestore(&unit_directory_lock, flags);
  400. }
  402. static void nodemgr_free_unit_directories(struct node_entry *ne)
  403. {
  404. struct list_head *lh;
  405. struct unit_directory *ud;
  407. lh = ne->unit_directories.next;
  408. while (lh != &ne->unit_directories) {
  409. ud = list_entry(lh, struct unit_directory, node_list);
  410. lh = lh->next;
  411. if (ud->driver && ud->driver->disconnect)
  412. ud->driver->disconnect(ud);
  413. nodemgr_release_unit_directory(ud);
  414. nodemgr_call_policy("remove", ud);
  415. list_del(&ud->driver_list);
  416. kfree(ud);
  417. }
  418. }
  420. static struct ieee1394_device_id *
  421. nodemgr_match_driver(struct hpsb_protocol_driver *driver, 
  422.      struct unit_directory *ud)
  423. {
  424. struct ieee1394_device_id *id;
  426. for (id = driver->id_table; id->match_flags != 0; id++) {
  427. if ((id->match_flags & IEEE1394_MATCH_VENDOR_ID) &&
  428.     id->vendor_id != ud->vendor_id)
  429. continue;
  431. if ((id->match_flags & IEEE1394_MATCH_MODEL_ID) &&
  432.     id->model_id != ud->model_id)
  433. continue;
  435. if ((id->match_flags & IEEE1394_MATCH_SPECIFIER_ID) &&
  436.     id->specifier_id != ud->specifier_id)
  437. continue;
  439. if ((id->match_flags & IEEE1394_MATCH_VERSION) &&
  440.     id->version != ud->version)
  441. continue;
  443. return id;
  444. }
  446. return NULL;
  447. }
  449. static struct hpsb_protocol_driver *
  450. nodemgr_find_driver(struct unit_directory *ud)
  451. {
  452. struct list_head *l;
  453. struct hpsb_protocol_driver *match, *driver;
  454. struct ieee1394_device_id *device_id;
  456. match = NULL;
  457. list_for_each(l, &driver_list) {
  458. driver = list_entry(l, struct hpsb_protocol_driver, list);
  459. device_id = nodemgr_match_driver(driver, ud);
  461. if (device_id != NULL) {
  462. match = driver;
  463. break;
  464. }
  465. }
  467. return match;
  468. }
  470. static void nodemgr_bind_drivers (struct node_entry *ne)
  471. {
  472. struct list_head *lh;
  473. struct hpsb_protocol_driver *driver;
  474. struct unit_directory *ud;
  476. list_for_each(lh, &ne->unit_directories) {
  477. ud = list_entry(lh, struct unit_directory, node_list);
  478. driver = nodemgr_find_driver(ud);
  479. if (driver != NULL && driver->probe(ud) == 0)
  480. nodemgr_claim_unit_directory(ud, driver);
  481. nodemgr_call_policy("add", ud);
  482. }
  483. }
  485. int hpsb_register_protocol(struct hpsb_protocol_driver *driver)
  486. {
  487. struct unit_directory *ud;
  488. struct list_head *lh;
  489. unsigned long flags;
  491.         write_lock_irqsave(&driver_lock, flags);
  492. list_add_tail(&driver->list, &driver_list);
  493. write_unlock_irqrestore(&driver_lock, flags);
  495. write_lock_irqsave(&unit_directory_lock, flags);
  496. INIT_LIST_HEAD(&driver->unit_directories);
  497. lh = unit_directory_list.next;
  498. while (lh != &unit_directory_list) {
  499. ud = list_entry(lh, struct unit_directory, driver_list);
  500. lh = lh->next;
  501. if (nodemgr_match_driver(driver, ud) && driver->probe(ud) == 0)
  502. nodemgr_claim_unit_directory(ud, driver);
  503. }
  504. write_unlock_irqrestore(&unit_directory_lock, flags);
  506. /*
  507.  * Right now registration always succeeds, but maybe we should
  508.  * detect clashes in protocols handled by other drivers.
  509.  */
  511. return 0;
  512. }
  514. void hpsb_unregister_protocol(struct hpsb_protocol_driver *driver)
  515. {
  516. struct list_head *lh;
  517. struct unit_directory *ud;
  518. unsigned long flags;
  520.         write_lock_irqsave(&driver_lock, flags);
  521. list_del(&driver->list);
  522. write_unlock_irqrestore(&driver_lock, flags);
  524. write_lock_irqsave(&unit_directory_lock, flags);
  525. lh = driver->unit_directories.next;
  526. while (lh != &driver->unit_directories) {
  527. ud = list_entry(lh, struct unit_directory, driver_list);
  528. lh = lh->next;
  529. if (ud->driver && ud->driver->disconnect)
  530. ud->driver->disconnect(ud);
  531. nodemgr_release_unit_directory(ud);
  532. }
  533. write_unlock_irqrestore(&unit_directory_lock, flags);
  534. }
  536. static void nodemgr_process_config_rom(struct node_entry *ne, 
  537.        quadlet_t busoptions)
  538. {
  539. unsigned long flags;
  541. ne->busopt.irmc = (busoptions >> 31) & 1;
  542. ne->busopt.cmc = (busoptions >> 30) & 1;
  543. ne->busopt.isc = (busoptions >> 29) & 1;
  544. ne->busopt.bmc = (busoptions >> 28) & 1;
  545. ne->busopt.pmc = (busoptions >> 27) & 1;
  546. ne->busopt.cyc_clk_acc = (busoptions >> 16) & 0xff;
  547. ne->busopt.max_rec = 1 << (((busoptions >> 12) & 0xf) + 1);
  548. ne->busopt.generation = (busoptions >> 4) & 0xf;
  549. ne->busopt.lnkspd = busoptions & 0x7;
  551. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  552. HPSB_DEBUG("NodeMgr: raw=0x%08x irmc=%d cmc=%d isc=%d bmc=%d pmc=%d "
  553.    "cyc_clk_acc=%d max_rec=%d gen=%d lspd=%d",
  554.    busoptions, ne->busopt.irmc, ne->busopt.cmc,
  555.    ne->busopt.isc, ne->busopt.bmc, ne->busopt.pmc,
  556.    ne->busopt.cyc_clk_acc, ne->busopt.max_rec,
  557.    ne->busopt.generation, ne->busopt.lnkspd);
  558. #endif
  560. /*
  561.  * When the config rom changes we disconnect all drivers and
  562.  * free the cached unit directories and reread the whole
  563.  * thing.  If this was a new device, the call to
  564.  * nodemgr_disconnect_drivers is a no-op and all is well.
  565.  */
  566. write_lock_irqsave(&unit_directory_lock, flags);
  567. nodemgr_free_unit_directories(ne);
  568. nodemgr_process_root_directory(ne);
  569. nodemgr_bind_drivers(ne);
  570. write_unlock_irqrestore(&unit_directory_lock, flags);
  571. }
  573. /*
  574.  * This function updates nodes that were present on the bus before the
  575.  * reset and still are after the reset.  The nodeid and the config rom
  576.  * may have changed, and the drivers managing this device must be
  577.  * informed that this device just went through a bus reset, to allow
  578.  * the to take whatever actions required.
  579.  */
  580. static void nodemgr_update_node(struct node_entry *ne, quadlet_t busoptions,
  581.                                struct hpsb_host *host, nodeid_t nodeid)
  582. {
  583. struct list_head *lh;
  584. struct unit_directory *ud;
  586. if (ne->nodeid != nodeid) {
  587. HPSB_DEBUG("Node " NODE_BUS_FMT " changed to " NODE_BUS_FMT,
  588.    NODE_BUS_ARGS(ne->nodeid), NODE_BUS_ARGS(nodeid));
  589. ne->nodeid = nodeid;
  590. }
  592. if (ne->busopt.generation != ((busoptions >> 4) & 0xf))
  593. nodemgr_process_config_rom (ne, busoptions);
  595. /* Since that's done, we can declare this record current */
  596. atomic_set(&ne->generation, get_hpsb_generation(ne->host));
  598. list_for_each (lh, &ne->unit_directories) {
  599. ud = list_entry (lh, struct unit_directory, node_list);
  600. if (ud->driver != NULL && ud->driver->update != NULL)
  601. ud->driver->update(ud);
  602. }
  603. }
  605. static int read_businfo_block(struct hpsb_host *host, nodeid_t nodeid,
  606.       quadlet_t *buffer, int buffer_length)
  607. {
  608. octlet_t base = CSR_REGISTER_BASE + CSR_CONFIG_ROM;
  609. int retries = 3;
  610. int header_count;
  611. unsigned header_size;
  612. quadlet_t quad;
  614. retry_configrom:
  616. if (!retries--) {
  617. HPSB_ERR("Giving up on node " NODE_BUS_FMT
  618.  " for ConfigROM probe, too many errors",
  619.  NODE_BUS_ARGS(nodeid));
  620. return -1;
  621. }
  623. header_count = 0;
  624. header_size = 0;
  626. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  627. HPSB_INFO("Initiating ConfigROM request for node " NODE_BUS_FMT,
  628.   NODE_BUS_ARGS(nodeid));
  629. #endif
  631. /* Now, P1212 says that devices should support 64byte block
  632.  * reads, aligned on 64byte boundaries. That doesn't seem
  633.  * to work though, and we are forced to doing quadlet
  634.  * sized reads.  */
  636. if (hpsb_read(host, nodeid, base, &quad, 4)) {
  637. HPSB_ERR("ConfigROM quadlet transaction error for node " NODE_BUS_FMT,
  638.  NODE_BUS_ARGS(nodeid));
  639. goto retry_configrom;
  640. }
  641. buffer[header_count++] = be32_to_cpu(quad);
  643. header_size = buffer[0] >> 24;
  645. if (header_size < 4) {
  646. HPSB_INFO("Node " NODE_BUS_FMT " has non-standard ROM format (%d quads), "
  647.   "cannot parse", NODE_BUS_ARGS(nodeid), header_size);
  648. return -1;
  649. }
  651. while (header_count <= header_size && header_count < buffer_length) {
  652. if (hpsb_read(host, nodeid, base + (header_count<<2), &quad, 4)) {
  653. HPSB_ERR("ConfigROM quadlet transaction error for " NODE_BUS_FMT,
  654.  NODE_BUS_ARGS(nodeid));
  655. goto retry_configrom;
  656. }
  657. buffer[header_count++] = be32_to_cpu(quad);
  658. }
  660. return 0;
  661. }
  663. static void nodemgr_remove_node(struct node_entry *ne)
  664. {
  665. unsigned long flags;
  667. HPSB_DEBUG("Device removed: node " NODE_BUS_FMT ", GUID %016Lx",
  668.    NODE_BUS_ARGS(ne->nodeid), (unsigned long long)ne->guid);
  670. write_lock_irqsave(&unit_directory_lock, flags);
  671. nodemgr_free_unit_directories(ne);
  672. write_unlock_irqrestore(&unit_directory_lock, flags);
  673. list_del(&ne->list);
  674. kfree(ne);
  676. return;
  677. }
  679. /* Used to schedule each nodes config rom probe */
  680. struct node_probe_task {
  681. nodeid_t nodeid;
  682. struct hpsb_host *host;
  683. atomic_t *count;
  684. struct tq_struct task;
  685. };
  687. /* This is where we probe the nodes for their information and provided
  688.  * features.  */
  689. static void nodemgr_node_probe_one(void *__npt)
  690. {
  691. struct node_probe_task *npt = (struct node_probe_task *)__npt;
  692. struct node_entry *ne;
  693. quadlet_t buffer[5];
  694. octlet_t guid;
  696. /* We need to detect when the ConfigROM's generation has changed,
  697.  * so we only update the node's info when it needs to be.  */
  699. if (read_businfo_block (npt->host, npt->nodeid, buffer, sizeof(buffer) >> 2))
  700. goto probe_complete;
  702. if (buffer[1] != IEEE1394_BUSID_MAGIC) {
  703. /* This isn't a 1394 device */
  704. HPSB_ERR("Node " NODE_BUS_FMT " isn't an IEEE 1394 device",
  705.  NODE_BUS_ARGS(npt->nodeid));
  706. goto probe_complete;
  707. }
  709. guid = ((u64)buffer[3] << 32) | buffer[4];
  710. ne = hpsb_guid_get_entry(guid);
  712. if (!ne)
  713. nodemgr_create_node(guid, buffer[2], npt->host, npt->nodeid);
  714. else
  715. nodemgr_update_node(ne, buffer[2], npt->host, npt->nodeid);
  717. probe_complete:
  718. atomic_dec(npt->count);
  720. kfree(npt);
  722. return;
  723. }
  725. static void nodemgr_node_probe_cleanup(void *__npt)
  726. {
  727. struct node_probe_task *npt = (struct node_probe_task *)__npt;
  728. unsigned long flags;
  729. struct list_head *lh, *next;
  730. struct node_entry *ne;
  732. /* If things aren't done yet, reschedule ourselves. */
  733.         if (atomic_read(npt->count)) {
  734.                 schedule_task(&npt->task);
  735. return;
  736. }
  738. kfree(npt->count);
  740. /* Now check to see if we have any nodes that aren't referenced
  741.  * any longer.  */
  742. write_lock_irqsave(&node_lock, flags);
  743. for (lh = node_list.next; lh != &node_list; lh = next) {
  744. ne = list_entry(lh, struct node_entry, list);
  745. next = lh->next;
  747. /* Only checking this host */
  748. if (ne->host != npt->host)
  749. continue;
  751. /* If the generation didn't get updated, then either the
  752.  * node was removed, or it failed the above probe. Either
  753.  * way, we remove references to it, since they are
  754.  * invalid.  */
  755. if (!hpsb_node_entry_valid(ne))
  756. nodemgr_remove_node(ne);
  757. }
  758. write_unlock_irqrestore(&node_lock, flags);
  760. kfree(npt);
  762. return;
  763. }
  765. static void nodemgr_node_probe(void *__host)
  766. {
  767. struct hpsb_host *host = (struct hpsb_host *)__host;
  768. int nodecount = host->node_count;
  769. struct selfid *sid = (struct selfid *)host->topology_map;
  770. nodeid_t nodeid = LOCAL_BUS;
  771. struct node_probe_task *npt;
  772. atomic_t *count;
  774. count = kmalloc(sizeof (*count), GFP_KERNEL);
  776. if (count == NULL) {
  777. HPSB_ERR ("NodeMgr: out of memory in nodemgr_node_probe");
  778. return;
  779. }
  781. atomic_set(count, 0);
  783. for (; nodecount; nodecount--, nodeid++, sid++) {
  784. while (sid->extended)
  785. sid++;
  786. if (!sid->link_active || nodeid == host->node_id)
  787. continue;
  789. npt = kmalloc(sizeof (*npt), GFP_KERNEL);
  791. if (npt == NULL) {
  792. HPSB_ERR ("NodeMgr: out of memory in nodemgr_node_probe");
  793. break;
  794. }
  796. INIT_TQUEUE(&npt->task, nodemgr_node_probe_one, npt);
  797. npt->host = host;
  798. npt->nodeid = nodeid;
  799. npt->count = count;
  801. atomic_inc(count);
  803. schedule_task(&npt->task);
  804. }
  806. /* Now schedule a task to clean things up after the node probes
  807.  * are done.  */
  808. npt = kmalloc (sizeof (*npt), GFP_KERNEL);
  810. if (npt == NULL) {
  811. HPSB_ERR ("NodeMgr: out of memory in nodemgr_node_probe");
  812. return;
  813. }
  815. INIT_TQUEUE(&npt->task, nodemgr_node_probe_cleanup, npt);
  816. npt->host = host;
  817. npt->nodeid = 0;
  818. npt->count = count;
  820. schedule_task(&npt->task);
  822. return;
  823. }
  825. struct node_entry *hpsb_guid_get_entry(u64 guid)
  826. {
  827.         unsigned long flags;
  828.         struct node_entry *ne;
  830.         read_lock_irqsave(&node_lock, flags);
  831.         ne = find_entry_by_guid(guid);
  832.         read_unlock_irqrestore(&node_lock, flags);
  834.         return ne;
  835. }
  837. struct node_entry *hpsb_nodeid_get_entry(nodeid_t nodeid)
  838. {
  839. unsigned long flags;
  840. struct node_entry *ne;
  842. read_lock_irqsave(&node_lock, flags);
  843. ne = find_entry_by_nodeid(nodeid);
  844. read_unlock_irqrestore(&node_lock, flags);
  846. return ne;
  847. }
  849. struct hpsb_host *hpsb_get_host_by_ne(struct node_entry *ne)
  850. {
  851.         if (atomic_read(&ne->generation) != get_hpsb_generation(ne->host))
  852. return NULL;
  853.         if (ne->nodeid == ne->host->node_id) return ne->host;
  854.         return NULL;
  855. }
  857. int hpsb_guid_fill_packet(struct node_entry *ne, struct hpsb_packet *pkt)
  858. {
  859.         if (atomic_read(&ne->generation) != get_hpsb_generation(ne->host))
  860. return 0;
  862.         pkt->host = ne->host;
  863.         pkt->node_id = ne->nodeid;
  864.         pkt->generation = atomic_read(&ne->generation);
  865.         return 1;
  866. }
  868. static void nodemgr_add_host(struct hpsb_host *host)
  869. {
  870. struct host_info *hi = kmalloc (sizeof (struct host_info), GFP_KERNEL);
  871. unsigned long flags;
  873. if (!hi) {
  874. HPSB_ERR ("NodeMgr: out of memory in add host");
  875. return;
  876. }
  878. /* We simply initialize the struct here. We don't start the thread
  879.  * until the first bus reset.  */
  880. hi->host = host;
  881. INIT_LIST_HEAD(&hi->list);
  882. INIT_TQUEUE(&hi->task, nodemgr_node_probe, host);
  884. spin_lock_irqsave (&host_info_lock, flags);
  885. list_add_tail (&hi->list, &host_info_list);
  886. spin_unlock_irqrestore (&host_info_lock, flags);
  888. return;
  889. }
  891. static void nodemgr_host_reset(struct hpsb_host *host)
  892. {
  893. struct list_head *lh;
  894. struct host_info *hi = NULL;
  895. unsigned long flags;
  897. spin_lock_irqsave (&host_info_lock, flags);
  898. list_for_each(lh, &host_info_list) {
  899. struct host_info *myhi = list_entry(lh, struct host_info, list);
  900. if (myhi->host == host) {
  901. hi = myhi;
  902. break;
  903. }
  904. }
  906. if (hi == NULL) {
  907. HPSB_ERR ("NodeMgr: could not process reset of non-existent host");
  908. goto done_reset_host;
  909. }
  911. schedule_task(&hi->task);
  913. done_reset_host:
  914. spin_unlock_irqrestore (&host_info_lock, flags);
  916. return;
  917. }
  919. static void nodemgr_remove_host(struct hpsb_host *host)
  920. {
  921. struct list_head *lh, *next;
  922. struct node_entry *ne;
  923. unsigned long flags;
  925. /* Make sure we have no active scans */
  926. flush_scheduled_tasks();
  928. /* First remove all node entries for this host */
  929. write_lock_irqsave(&node_lock, flags);
  931. for (lh = node_list.next; lh != &node_list; lh = next) {
  932. ne = list_entry(lh, struct node_entry, list);
  933. next = lh->next;
  935. /* Only checking this host */
  936. if (ne->host != host)
  937. continue;
  939. nodemgr_remove_node(ne);
  940. }
  941. write_unlock_irqrestore(&node_lock, flags);
  943. spin_lock_irqsave (&host_info_lock, flags);
  944. list_for_each_safe(lh, next, &host_info_list) {
  945. struct host_info *hi = list_entry(lh, struct host_info, list);
  946. if (hi->host == host) {
  947. list_del(&hi->list);
  948. kfree (hi);
  949. break;
  950. }
  951. }
  953. if (lh == host_info_list.next)
  954. HPSB_ERR ("NodeMgr: could not remove non-existent host");
  956. spin_unlock_irqrestore (&host_info_lock, flags);
  958. return;
  959. }
  961. static struct hpsb_highlevel_ops nodemgr_ops = {
  962. add_host: nodemgr_add_host,
  963. host_reset: nodemgr_host_reset,
  964. remove_host: nodemgr_remove_host,
  965. };
  967. static struct hpsb_highlevel *hl;
  969. void init_ieee1394_nodemgr(void)
  970. {
  971.         hl = hpsb_register_highlevel("Node manager", &nodemgr_ops);
  972.         if (!hl) {
  973. HPSB_ERR("NodeMgr: out of memory during ieee1394 initialization");
  974.         }
  975. }
  977. void cleanup_ieee1394_nodemgr(void)
  978. {
  979.         hpsb_unregister_highlevel(hl);
  980. }