nodemgr.c 52 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889
  1. /*
  2. * Node information (ConfigROM) collection and management.
  3. *
  4. * Copyright (C) 2000 Andreas E. Bombe
  5. * 2001-2003 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. */
  10. #include <linux/bitmap.h>
  11. #include <linux/kernel.h>
  12. #include <linux/list.h>
  13. #include <linux/slab.h>
  14. #include <linux/delay.h>
  15. #include <linux/kthread.h>
  16. #include <linux/module.h>
  17. #include <linux/moduleparam.h>
  18. #include <linux/mutex.h>
  19. #include <linux/freezer.h>
  20. #include <asm/atomic.h>
  21. #include "csr.h"
  22. #include "highlevel.h"
  23. #include "hosts.h"
  24. #include "ieee1394.h"
  25. #include "ieee1394_core.h"
  26. #include "ieee1394_hotplug.h"
  27. #include "ieee1394_types.h"
  28. #include "ieee1394_transactions.h"
  29. #include "nodemgr.h"
  30. static int ignore_drivers;
  31. module_param(ignore_drivers, int, S_IRUGO | S_IWUSR);
  32. MODULE_PARM_DESC(ignore_drivers, "Disable automatic probing for drivers.");
  33. struct nodemgr_csr_info {
  34. struct hpsb_host *host;
  35. nodeid_t nodeid;
  36. unsigned int generation;
  37. unsigned int speed_unverified:1;
  38. };
  39. /*
  40. * Correct the speed map entry. This is necessary
  41. * - for nodes with link speed < phy speed,
  42. * - for 1394b nodes with negotiated phy port speed < IEEE1394_SPEED_MAX.
  43. * A possible speed is determined by trial and error, using quadlet reads.
  44. */
  45. static int nodemgr_check_speed(struct nodemgr_csr_info *ci, u64 addr,
  46. quadlet_t *buffer)
  47. {
  48. quadlet_t q;
  49. u8 i, *speed, old_speed, good_speed;
  50. int error;
  51. speed = &(ci->host->speed[NODEID_TO_NODE(ci->nodeid)]);
  52. old_speed = *speed;
  53. good_speed = IEEE1394_SPEED_MAX + 1;
  54. /* Try every speed from S100 to old_speed.
  55. * If we did it the other way around, a too low speed could be caught
  56. * if the retry succeeded for some other reason, e.g. because the link
  57. * just finished its initialization. */
  58. for (i = IEEE1394_SPEED_100; i <= old_speed; i++) {
  59. *speed = i;
  60. error = hpsb_read(ci->host, ci->nodeid, ci->generation, addr,
  61. &q, sizeof(quadlet_t));
  62. if (error)
  63. break;
  64. *buffer = q;
  65. good_speed = i;
  66. }
  67. if (good_speed <= IEEE1394_SPEED_MAX) {
  68. HPSB_DEBUG("Speed probe of node " NODE_BUS_FMT " yields %s",
  69. NODE_BUS_ARGS(ci->host, ci->nodeid),
  70. hpsb_speedto_str[good_speed]);
  71. *speed = good_speed;
  72. ci->speed_unverified = 0;
  73. return 0;
  74. }
  75. *speed = old_speed;
  76. return error;
  77. }
  78. static int nodemgr_bus_read(struct csr1212_csr *csr, u64 addr, u16 length,
  79. void *buffer, void *__ci)
  80. {
  81. struct nodemgr_csr_info *ci = (struct nodemgr_csr_info*)__ci;
  82. int i, error;
  83. for (i = 1; ; i++) {
  84. error = hpsb_read(ci->host, ci->nodeid, ci->generation, addr,
  85. buffer, length);
  86. if (!error) {
  87. ci->speed_unverified = 0;
  88. break;
  89. }
  90. /* Give up after 3rd failure. */
  91. if (i == 3)
  92. break;
  93. /* The ieee1394_core guessed the node's speed capability from
  94. * the self ID. Check whether a lower speed works. */
  95. if (ci->speed_unverified && length == sizeof(quadlet_t)) {
  96. error = nodemgr_check_speed(ci, addr, buffer);
  97. if (!error)
  98. break;
  99. }
  100. if (msleep_interruptible(334))
  101. return -EINTR;
  102. }
  103. return error;
  104. }
  105. static int nodemgr_get_max_rom(quadlet_t *bus_info_data, void *__ci)
  106. {
  107. return (be32_to_cpu(bus_info_data[2]) >> 8) & 0x3;
  108. }
  109. static struct csr1212_bus_ops nodemgr_csr_ops = {
  110. .bus_read = nodemgr_bus_read,
  111. .get_max_rom = nodemgr_get_max_rom
  112. };
  113. /*
  114. * Basically what we do here is start off retrieving the bus_info block.
  115. * From there will fill in some info about the node, verify it is of IEEE
  116. * 1394 type, and that the crc checks out ok. After that we start off with
  117. * the root directory, and subdirectories. To do this, we retrieve the
  118. * quadlet header for a directory, find out the length, and retrieve the
  119. * complete directory entry (be it a leaf or a directory). We then process
  120. * it and add the info to our structure for that particular node.
  121. *
  122. * We verify CRC's along the way for each directory/block/leaf. The entire
  123. * node structure is generic, and simply stores the information in a way
  124. * that's easy to parse by the protocol interface.
  125. */
  126. /*
  127. * The nodemgr relies heavily on the Driver Model for device callbacks and
  128. * driver/device mappings. The old nodemgr used to handle all this itself,
  129. * but now we are much simpler because of the LDM.
  130. */
  131. static DEFINE_MUTEX(nodemgr_serialize);
  132. struct host_info {
  133. struct hpsb_host *host;
  134. struct list_head list;
  135. struct task_struct *thread;
  136. };
  137. static int nodemgr_bus_match(struct device * dev, struct device_driver * drv);
  138. static int nodemgr_uevent(struct class_device *cdev, char **envp, int num_envp,
  139. char *buffer, int buffer_size);
  140. static void nodemgr_resume_ne(struct node_entry *ne);
  141. static void nodemgr_remove_ne(struct node_entry *ne);
  142. static struct node_entry *find_entry_by_guid(u64 guid);
  143. struct bus_type ieee1394_bus_type = {
  144. .name = "ieee1394",
  145. .match = nodemgr_bus_match,
  146. };
  147. static void host_cls_release(struct class_device *class_dev)
  148. {
  149. put_device(&container_of((class_dev), struct hpsb_host, class_dev)->device);
  150. }
  151. struct class hpsb_host_class = {
  152. .name = "ieee1394_host",
  153. .release = host_cls_release,
  154. };
  155. static void ne_cls_release(struct class_device *class_dev)
  156. {
  157. put_device(&container_of((class_dev), struct node_entry, class_dev)->device);
  158. }
  159. static struct class nodemgr_ne_class = {
  160. .name = "ieee1394_node",
  161. .release = ne_cls_release,
  162. };
  163. static void ud_cls_release(struct class_device *class_dev)
  164. {
  165. put_device(&container_of((class_dev), struct unit_directory, class_dev)->device);
  166. }
  167. /* The name here is only so that unit directory hotplug works with old
  168. * style hotplug, which only ever did unit directories anyway. */
  169. static struct class nodemgr_ud_class = {
  170. .name = "ieee1394",
  171. .release = ud_cls_release,
  172. .uevent = nodemgr_uevent,
  173. };
  174. static struct hpsb_highlevel nodemgr_highlevel;
  175. static void nodemgr_release_ud(struct device *dev)
  176. {
  177. struct unit_directory *ud = container_of(dev, struct unit_directory, device);
  178. if (ud->vendor_name_kv)
  179. csr1212_release_keyval(ud->vendor_name_kv);
  180. if (ud->model_name_kv)
  181. csr1212_release_keyval(ud->model_name_kv);
  182. kfree(ud);
  183. }
  184. static void nodemgr_release_ne(struct device *dev)
  185. {
  186. struct node_entry *ne = container_of(dev, struct node_entry, device);
  187. if (ne->vendor_name_kv)
  188. csr1212_release_keyval(ne->vendor_name_kv);
  189. kfree(ne);
  190. }
  191. static void nodemgr_release_host(struct device *dev)
  192. {
  193. struct hpsb_host *host = container_of(dev, struct hpsb_host, device);
  194. csr1212_destroy_csr(host->csr.rom);
  195. kfree(host);
  196. }
  197. static int nodemgr_ud_platform_data;
  198. static struct device nodemgr_dev_template_ud = {
  199. .bus = &ieee1394_bus_type,
  200. .release = nodemgr_release_ud,
  201. .platform_data = &nodemgr_ud_platform_data,
  202. };
  203. static struct device nodemgr_dev_template_ne = {
  204. .bus = &ieee1394_bus_type,
  205. .release = nodemgr_release_ne,
  206. };
  207. /* This dummy driver prevents the host devices from being scanned. We have no
  208. * useful drivers for them yet, and there would be a deadlock possible if the
  209. * driver core scans the host device while the host's low-level driver (i.e.
  210. * the host's parent device) is being removed. */
  211. static struct device_driver nodemgr_mid_layer_driver = {
  212. .bus = &ieee1394_bus_type,
  213. .name = "nodemgr",
  214. .owner = THIS_MODULE,
  215. };
  216. struct device nodemgr_dev_template_host = {
  217. .bus = &ieee1394_bus_type,
  218. .release = nodemgr_release_host,
  219. };
  220. #define fw_attr(class, class_type, field, type, format_string) \
  221. static ssize_t fw_show_##class##_##field (struct device *dev, struct device_attribute *attr, char *buf)\
  222. { \
  223. class_type *class; \
  224. class = container_of(dev, class_type, device); \
  225. return sprintf(buf, format_string, (type)class->field); \
  226. } \
  227. static struct device_attribute dev_attr_##class##_##field = { \
  228. .attr = {.name = __stringify(field), .mode = S_IRUGO }, \
  229. .show = fw_show_##class##_##field, \
  230. };
  231. #define fw_attr_td(class, class_type, td_kv) \
  232. static ssize_t fw_show_##class##_##td_kv (struct device *dev, struct device_attribute *attr, char *buf)\
  233. { \
  234. int len; \
  235. class_type *class = container_of(dev, class_type, device); \
  236. len = (class->td_kv->value.leaf.len - 2) * sizeof(quadlet_t); \
  237. memcpy(buf, \
  238. CSR1212_TEXTUAL_DESCRIPTOR_LEAF_DATA(class->td_kv), \
  239. len); \
  240. while ((buf + len - 1) == '\0') \
  241. len--; \
  242. buf[len++] = '\n'; \
  243. buf[len] = '\0'; \
  244. return len; \
  245. } \
  246. static struct device_attribute dev_attr_##class##_##td_kv = { \
  247. .attr = {.name = __stringify(td_kv), .mode = S_IRUGO }, \
  248. .show = fw_show_##class##_##td_kv, \
  249. };
  250. #define fw_drv_attr(field, type, format_string) \
  251. static ssize_t fw_drv_show_##field (struct device_driver *drv, char *buf) \
  252. { \
  253. struct hpsb_protocol_driver *driver; \
  254. driver = container_of(drv, struct hpsb_protocol_driver, driver); \
  255. return sprintf(buf, format_string, (type)driver->field);\
  256. } \
  257. static struct driver_attribute driver_attr_drv_##field = { \
  258. .attr = {.name = __stringify(field), .mode = S_IRUGO }, \
  259. .show = fw_drv_show_##field, \
  260. };
  261. static ssize_t fw_show_ne_bus_options(struct device *dev, struct device_attribute *attr, char *buf)
  262. {
  263. struct node_entry *ne = container_of(dev, struct node_entry, device);
  264. return sprintf(buf, "IRMC(%d) CMC(%d) ISC(%d) BMC(%d) PMC(%d) GEN(%d) "
  265. "LSPD(%d) MAX_REC(%d) MAX_ROM(%d) CYC_CLK_ACC(%d)\n",
  266. ne->busopt.irmc,
  267. ne->busopt.cmc, ne->busopt.isc, ne->busopt.bmc,
  268. ne->busopt.pmc, ne->busopt.generation, ne->busopt.lnkspd,
  269. ne->busopt.max_rec,
  270. ne->busopt.max_rom,
  271. ne->busopt.cyc_clk_acc);
  272. }
  273. static DEVICE_ATTR(bus_options,S_IRUGO,fw_show_ne_bus_options,NULL);
  274. #ifdef HPSB_DEBUG_TLABELS
  275. static ssize_t fw_show_ne_tlabels_free(struct device *dev,
  276. struct device_attribute *attr, char *buf)
  277. {
  278. struct node_entry *ne = container_of(dev, struct node_entry, device);
  279. unsigned long flags;
  280. unsigned long *tp = ne->host->tl_pool[NODEID_TO_NODE(ne->nodeid)].map;
  281. int tf;
  282. spin_lock_irqsave(&hpsb_tlabel_lock, flags);
  283. tf = 64 - bitmap_weight(tp, 64);
  284. spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
  285. return sprintf(buf, "%d\n", tf);
  286. }
  287. static DEVICE_ATTR(tlabels_free,S_IRUGO,fw_show_ne_tlabels_free,NULL);
  288. static ssize_t fw_show_ne_tlabels_mask(struct device *dev,
  289. struct device_attribute *attr, char *buf)
  290. {
  291. struct node_entry *ne = container_of(dev, struct node_entry, device);
  292. unsigned long flags;
  293. unsigned long *tp = ne->host->tl_pool[NODEID_TO_NODE(ne->nodeid)].map;
  294. u64 tm;
  295. spin_lock_irqsave(&hpsb_tlabel_lock, flags);
  296. #if (BITS_PER_LONG <= 32)
  297. tm = ((u64)tp[0] << 32) + tp[1];
  298. #else
  299. tm = tp[0];
  300. #endif
  301. spin_unlock_irqrestore(&hpsb_tlabel_lock, flags);
  302. return sprintf(buf, "0x%016llx\n", (unsigned long long)tm);
  303. }
  304. static DEVICE_ATTR(tlabels_mask, S_IRUGO, fw_show_ne_tlabels_mask, NULL);
  305. #endif /* HPSB_DEBUG_TLABELS */
  306. static ssize_t fw_set_ignore_driver(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
  307. {
  308. struct unit_directory *ud = container_of(dev, struct unit_directory, device);
  309. int state = simple_strtoul(buf, NULL, 10);
  310. if (state == 1) {
  311. ud->ignore_driver = 1;
  312. device_release_driver(dev);
  313. } else if (state == 0)
  314. ud->ignore_driver = 0;
  315. return count;
  316. }
  317. static ssize_t fw_get_ignore_driver(struct device *dev, struct device_attribute *attr, char *buf)
  318. {
  319. struct unit_directory *ud = container_of(dev, struct unit_directory, device);
  320. return sprintf(buf, "%d\n", ud->ignore_driver);
  321. }
  322. static DEVICE_ATTR(ignore_driver, S_IWUSR | S_IRUGO, fw_get_ignore_driver, fw_set_ignore_driver);
  323. static ssize_t fw_set_destroy_node(struct bus_type *bus, const char *buf, size_t count)
  324. {
  325. struct node_entry *ne;
  326. u64 guid = (u64)simple_strtoull(buf, NULL, 16);
  327. ne = find_entry_by_guid(guid);
  328. if (ne == NULL || !ne->in_limbo)
  329. return -EINVAL;
  330. nodemgr_remove_ne(ne);
  331. return count;
  332. }
  333. static ssize_t fw_get_destroy_node(struct bus_type *bus, char *buf)
  334. {
  335. return sprintf(buf, "You can destroy in_limbo nodes by writing their GUID to this file\n");
  336. }
  337. static BUS_ATTR(destroy_node, S_IWUSR | S_IRUGO, fw_get_destroy_node, fw_set_destroy_node);
  338. static ssize_t fw_set_rescan(struct bus_type *bus, const char *buf,
  339. size_t count)
  340. {
  341. int error = 0;
  342. if (simple_strtoul(buf, NULL, 10) == 1)
  343. error = bus_rescan_devices(&ieee1394_bus_type);
  344. return error ? error : count;
  345. }
  346. static ssize_t fw_get_rescan(struct bus_type *bus, char *buf)
  347. {
  348. return sprintf(buf, "You can force a rescan of the bus for "
  349. "drivers by writing a 1 to this file\n");
  350. }
  351. static BUS_ATTR(rescan, S_IWUSR | S_IRUGO, fw_get_rescan, fw_set_rescan);
  352. static ssize_t fw_set_ignore_drivers(struct bus_type *bus, const char *buf, size_t count)
  353. {
  354. int state = simple_strtoul(buf, NULL, 10);
  355. if (state == 1)
  356. ignore_drivers = 1;
  357. else if (state == 0)
  358. ignore_drivers = 0;
  359. return count;
  360. }
  361. static ssize_t fw_get_ignore_drivers(struct bus_type *bus, char *buf)
  362. {
  363. return sprintf(buf, "%d\n", ignore_drivers);
  364. }
  365. static BUS_ATTR(ignore_drivers, S_IWUSR | S_IRUGO, fw_get_ignore_drivers, fw_set_ignore_drivers);
  366. struct bus_attribute *const fw_bus_attrs[] = {
  367. &bus_attr_destroy_node,
  368. &bus_attr_rescan,
  369. &bus_attr_ignore_drivers,
  370. NULL
  371. };
  372. fw_attr(ne, struct node_entry, capabilities, unsigned int, "0x%06x\n")
  373. fw_attr(ne, struct node_entry, nodeid, unsigned int, "0x%04x\n")
  374. fw_attr(ne, struct node_entry, vendor_id, unsigned int, "0x%06x\n")
  375. fw_attr_td(ne, struct node_entry, vendor_name_kv)
  376. fw_attr(ne, struct node_entry, guid, unsigned long long, "0x%016Lx\n")
  377. fw_attr(ne, struct node_entry, guid_vendor_id, unsigned int, "0x%06x\n")
  378. fw_attr(ne, struct node_entry, in_limbo, int, "%d\n");
  379. static struct device_attribute *const fw_ne_attrs[] = {
  380. &dev_attr_ne_guid,
  381. &dev_attr_ne_guid_vendor_id,
  382. &dev_attr_ne_capabilities,
  383. &dev_attr_ne_vendor_id,
  384. &dev_attr_ne_nodeid,
  385. &dev_attr_bus_options,
  386. #ifdef HPSB_DEBUG_TLABELS
  387. &dev_attr_tlabels_free,
  388. &dev_attr_tlabels_mask,
  389. #endif
  390. };
  391. fw_attr(ud, struct unit_directory, address, unsigned long long, "0x%016Lx\n")
  392. fw_attr(ud, struct unit_directory, length, int, "%d\n")
  393. /* These are all dependent on the value being provided */
  394. fw_attr(ud, struct unit_directory, vendor_id, unsigned int, "0x%06x\n")
  395. fw_attr(ud, struct unit_directory, model_id, unsigned int, "0x%06x\n")
  396. fw_attr(ud, struct unit_directory, specifier_id, unsigned int, "0x%06x\n")
  397. fw_attr(ud, struct unit_directory, version, unsigned int, "0x%06x\n")
  398. fw_attr_td(ud, struct unit_directory, vendor_name_kv)
  399. fw_attr_td(ud, struct unit_directory, model_name_kv)
  400. static struct device_attribute *const fw_ud_attrs[] = {
  401. &dev_attr_ud_address,
  402. &dev_attr_ud_length,
  403. &dev_attr_ignore_driver,
  404. };
  405. fw_attr(host, struct hpsb_host, node_count, int, "%d\n")
  406. fw_attr(host, struct hpsb_host, selfid_count, int, "%d\n")
  407. fw_attr(host, struct hpsb_host, nodes_active, int, "%d\n")
  408. fw_attr(host, struct hpsb_host, in_bus_reset, int, "%d\n")
  409. fw_attr(host, struct hpsb_host, is_root, int, "%d\n")
  410. fw_attr(host, struct hpsb_host, is_cycmst, int, "%d\n")
  411. fw_attr(host, struct hpsb_host, is_irm, int, "%d\n")
  412. fw_attr(host, struct hpsb_host, is_busmgr, int, "%d\n")
  413. static struct device_attribute *const fw_host_attrs[] = {
  414. &dev_attr_host_node_count,
  415. &dev_attr_host_selfid_count,
  416. &dev_attr_host_nodes_active,
  417. &dev_attr_host_in_bus_reset,
  418. &dev_attr_host_is_root,
  419. &dev_attr_host_is_cycmst,
  420. &dev_attr_host_is_irm,
  421. &dev_attr_host_is_busmgr,
  422. };
  423. static ssize_t fw_show_drv_device_ids(struct device_driver *drv, char *buf)
  424. {
  425. struct hpsb_protocol_driver *driver;
  426. struct ieee1394_device_id *id;
  427. int length = 0;
  428. char *scratch = buf;
  429. driver = container_of(drv, struct hpsb_protocol_driver, driver);
  430. for (id = driver->id_table; id->match_flags != 0; id++) {
  431. int need_coma = 0;
  432. if (id->match_flags & IEEE1394_MATCH_VENDOR_ID) {
  433. length += sprintf(scratch, "vendor_id=0x%06x", id->vendor_id);
  434. scratch = buf + length;
  435. need_coma++;
  436. }
  437. if (id->match_flags & IEEE1394_MATCH_MODEL_ID) {
  438. length += sprintf(scratch, "%smodel_id=0x%06x",
  439. need_coma++ ? "," : "",
  440. id->model_id);
  441. scratch = buf + length;
  442. }
  443. if (id->match_flags & IEEE1394_MATCH_SPECIFIER_ID) {
  444. length += sprintf(scratch, "%sspecifier_id=0x%06x",
  445. need_coma++ ? "," : "",
  446. id->specifier_id);
  447. scratch = buf + length;
  448. }
  449. if (id->match_flags & IEEE1394_MATCH_VERSION) {
  450. length += sprintf(scratch, "%sversion=0x%06x",
  451. need_coma++ ? "," : "",
  452. id->version);
  453. scratch = buf + length;
  454. }
  455. if (need_coma) {
  456. *scratch++ = '\n';
  457. length++;
  458. }
  459. }
  460. return length;
  461. }
  462. static DRIVER_ATTR(device_ids,S_IRUGO,fw_show_drv_device_ids,NULL);
  463. fw_drv_attr(name, const char *, "%s\n")
  464. static struct driver_attribute *const fw_drv_attrs[] = {
  465. &driver_attr_drv_name,
  466. &driver_attr_device_ids,
  467. };
  468. static void nodemgr_create_drv_files(struct hpsb_protocol_driver *driver)
  469. {
  470. struct device_driver *drv = &driver->driver;
  471. int i;
  472. for (i = 0; i < ARRAY_SIZE(fw_drv_attrs); i++)
  473. if (driver_create_file(drv, fw_drv_attrs[i]))
  474. goto fail;
  475. return;
  476. fail:
  477. HPSB_ERR("Failed to add sysfs attribute");
  478. }
  479. static void nodemgr_remove_drv_files(struct hpsb_protocol_driver *driver)
  480. {
  481. struct device_driver *drv = &driver->driver;
  482. int i;
  483. for (i = 0; i < ARRAY_SIZE(fw_drv_attrs); i++)
  484. driver_remove_file(drv, fw_drv_attrs[i]);
  485. }
  486. static void nodemgr_create_ne_dev_files(struct node_entry *ne)
  487. {
  488. struct device *dev = &ne->device;
  489. int i;
  490. for (i = 0; i < ARRAY_SIZE(fw_ne_attrs); i++)
  491. if (device_create_file(dev, fw_ne_attrs[i]))
  492. goto fail;
  493. return;
  494. fail:
  495. HPSB_ERR("Failed to add sysfs attribute");
  496. }
  497. static void nodemgr_create_host_dev_files(struct hpsb_host *host)
  498. {
  499. struct device *dev = &host->device;
  500. int i;
  501. for (i = 0; i < ARRAY_SIZE(fw_host_attrs); i++)
  502. if (device_create_file(dev, fw_host_attrs[i]))
  503. goto fail;
  504. return;
  505. fail:
  506. HPSB_ERR("Failed to add sysfs attribute");
  507. }
  508. static struct node_entry *find_entry_by_nodeid(struct hpsb_host *host,
  509. nodeid_t nodeid);
  510. static void nodemgr_update_host_dev_links(struct hpsb_host *host)
  511. {
  512. struct device *dev = &host->device;
  513. struct node_entry *ne;
  514. sysfs_remove_link(&dev->kobj, "irm_id");
  515. sysfs_remove_link(&dev->kobj, "busmgr_id");
  516. sysfs_remove_link(&dev->kobj, "host_id");
  517. if ((ne = find_entry_by_nodeid(host, host->irm_id)) &&
  518. sysfs_create_link(&dev->kobj, &ne->device.kobj, "irm_id"))
  519. goto fail;
  520. if ((ne = find_entry_by_nodeid(host, host->busmgr_id)) &&
  521. sysfs_create_link(&dev->kobj, &ne->device.kobj, "busmgr_id"))
  522. goto fail;
  523. if ((ne = find_entry_by_nodeid(host, host->node_id)) &&
  524. sysfs_create_link(&dev->kobj, &ne->device.kobj, "host_id"))
  525. goto fail;
  526. return;
  527. fail:
  528. HPSB_ERR("Failed to update sysfs attributes for host %d", host->id);
  529. }
  530. static void nodemgr_create_ud_dev_files(struct unit_directory *ud)
  531. {
  532. struct device *dev = &ud->device;
  533. int i;
  534. for (i = 0; i < ARRAY_SIZE(fw_ud_attrs); i++)
  535. if (device_create_file(dev, fw_ud_attrs[i]))
  536. goto fail;
  537. if (ud->flags & UNIT_DIRECTORY_SPECIFIER_ID)
  538. if (device_create_file(dev, &dev_attr_ud_specifier_id))
  539. goto fail;
  540. if (ud->flags & UNIT_DIRECTORY_VERSION)
  541. if (device_create_file(dev, &dev_attr_ud_version))
  542. goto fail;
  543. if (ud->flags & UNIT_DIRECTORY_VENDOR_ID) {
  544. if (device_create_file(dev, &dev_attr_ud_vendor_id))
  545. goto fail;
  546. if (ud->vendor_name_kv &&
  547. device_create_file(dev, &dev_attr_ud_vendor_name_kv))
  548. goto fail;
  549. }
  550. if (ud->flags & UNIT_DIRECTORY_MODEL_ID) {
  551. if (device_create_file(dev, &dev_attr_ud_model_id))
  552. goto fail;
  553. if (ud->model_name_kv &&
  554. device_create_file(dev, &dev_attr_ud_model_name_kv))
  555. goto fail;
  556. }
  557. return;
  558. fail:
  559. HPSB_ERR("Failed to add sysfs attribute");
  560. }
  561. static int nodemgr_bus_match(struct device * dev, struct device_driver * drv)
  562. {
  563. struct hpsb_protocol_driver *driver;
  564. struct unit_directory *ud;
  565. struct ieee1394_device_id *id;
  566. /* We only match unit directories */
  567. if (dev->platform_data != &nodemgr_ud_platform_data)
  568. return 0;
  569. ud = container_of(dev, struct unit_directory, device);
  570. if (ud->ne->in_limbo || ud->ignore_driver)
  571. return 0;
  572. /* We only match drivers of type hpsb_protocol_driver */
  573. if (drv == &nodemgr_mid_layer_driver)
  574. return 0;
  575. driver = container_of(drv, struct hpsb_protocol_driver, driver);
  576. for (id = driver->id_table; id->match_flags != 0; id++) {
  577. if ((id->match_flags & IEEE1394_MATCH_VENDOR_ID) &&
  578. id->vendor_id != ud->vendor_id)
  579. continue;
  580. if ((id->match_flags & IEEE1394_MATCH_MODEL_ID) &&
  581. id->model_id != ud->model_id)
  582. continue;
  583. if ((id->match_flags & IEEE1394_MATCH_SPECIFIER_ID) &&
  584. id->specifier_id != ud->specifier_id)
  585. continue;
  586. if ((id->match_flags & IEEE1394_MATCH_VERSION) &&
  587. id->version != ud->version)
  588. continue;
  589. return 1;
  590. }
  591. return 0;
  592. }
  593. static DEFINE_MUTEX(nodemgr_serialize_remove_uds);
  594. static void nodemgr_remove_uds(struct node_entry *ne)
  595. {
  596. struct class_device *cdev;
  597. struct unit_directory *tmp, *ud;
  598. /* Iteration over nodemgr_ud_class.children has to be protected by
  599. * nodemgr_ud_class.sem, but class_device_unregister() will eventually
  600. * take nodemgr_ud_class.sem too. Therefore pick out one ud at a time,
  601. * release the semaphore, and then unregister the ud. Since this code
  602. * may be called from other contexts besides the knodemgrds, protect the
  603. * gap after release of the semaphore by nodemgr_serialize_remove_uds.
  604. */
  605. mutex_lock(&nodemgr_serialize_remove_uds);
  606. for (;;) {
  607. ud = NULL;
  608. down(&nodemgr_ud_class.sem);
  609. list_for_each_entry(cdev, &nodemgr_ud_class.children, node) {
  610. tmp = container_of(cdev, struct unit_directory,
  611. class_dev);
  612. if (tmp->ne == ne) {
  613. ud = tmp;
  614. break;
  615. }
  616. }
  617. up(&nodemgr_ud_class.sem);
  618. if (ud == NULL)
  619. break;
  620. class_device_unregister(&ud->class_dev);
  621. device_unregister(&ud->device);
  622. }
  623. mutex_unlock(&nodemgr_serialize_remove_uds);
  624. }
  625. static void nodemgr_remove_ne(struct node_entry *ne)
  626. {
  627. struct device *dev;
  628. dev = get_device(&ne->device);
  629. if (!dev)
  630. return;
  631. HPSB_DEBUG("Node removed: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
  632. NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);
  633. nodemgr_remove_uds(ne);
  634. class_device_unregister(&ne->class_dev);
  635. device_unregister(dev);
  636. put_device(dev);
  637. }
  638. static int __nodemgr_remove_host_dev(struct device *dev, void *data)
  639. {
  640. nodemgr_remove_ne(container_of(dev, struct node_entry, device));
  641. return 0;
  642. }
  643. static void nodemgr_remove_host_dev(struct device *dev)
  644. {
  645. WARN_ON(device_for_each_child(dev, NULL, __nodemgr_remove_host_dev));
  646. sysfs_remove_link(&dev->kobj, "irm_id");
  647. sysfs_remove_link(&dev->kobj, "busmgr_id");
  648. sysfs_remove_link(&dev->kobj, "host_id");
  649. }
  650. static void nodemgr_update_bus_options(struct node_entry *ne)
  651. {
  652. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  653. static const u16 mr[] = { 4, 64, 1024, 0};
  654. #endif
  655. quadlet_t busoptions = be32_to_cpu(ne->csr->bus_info_data[2]);
  656. ne->busopt.irmc = (busoptions >> 31) & 1;
  657. ne->busopt.cmc = (busoptions >> 30) & 1;
  658. ne->busopt.isc = (busoptions >> 29) & 1;
  659. ne->busopt.bmc = (busoptions >> 28) & 1;
  660. ne->busopt.pmc = (busoptions >> 27) & 1;
  661. ne->busopt.cyc_clk_acc = (busoptions >> 16) & 0xff;
  662. ne->busopt.max_rec = 1 << (((busoptions >> 12) & 0xf) + 1);
  663. ne->busopt.max_rom = (busoptions >> 8) & 0x3;
  664. ne->busopt.generation = (busoptions >> 4) & 0xf;
  665. ne->busopt.lnkspd = busoptions & 0x7;
  666. HPSB_VERBOSE("NodeMgr: raw=0x%08x irmc=%d cmc=%d isc=%d bmc=%d pmc=%d "
  667. "cyc_clk_acc=%d max_rec=%d max_rom=%d gen=%d lspd=%d",
  668. busoptions, ne->busopt.irmc, ne->busopt.cmc,
  669. ne->busopt.isc, ne->busopt.bmc, ne->busopt.pmc,
  670. ne->busopt.cyc_clk_acc, ne->busopt.max_rec,
  671. mr[ne->busopt.max_rom],
  672. ne->busopt.generation, ne->busopt.lnkspd);
  673. }
  674. static struct node_entry *nodemgr_create_node(octlet_t guid, struct csr1212_csr *csr,
  675. struct host_info *hi, nodeid_t nodeid,
  676. unsigned int generation)
  677. {
  678. struct hpsb_host *host = hi->host;
  679. struct node_entry *ne;
  680. ne = kzalloc(sizeof(*ne), GFP_KERNEL);
  681. if (!ne)
  682. goto fail_alloc;
  683. ne->host = host;
  684. ne->nodeid = nodeid;
  685. ne->generation = generation;
  686. ne->needs_probe = 1;
  687. ne->guid = guid;
  688. ne->guid_vendor_id = (guid >> 40) & 0xffffff;
  689. ne->csr = csr;
  690. memcpy(&ne->device, &nodemgr_dev_template_ne,
  691. sizeof(ne->device));
  692. ne->device.parent = &host->device;
  693. snprintf(ne->device.bus_id, BUS_ID_SIZE, "%016Lx",
  694. (unsigned long long)(ne->guid));
  695. ne->class_dev.dev = &ne->device;
  696. ne->class_dev.class = &nodemgr_ne_class;
  697. snprintf(ne->class_dev.class_id, BUS_ID_SIZE, "%016Lx",
  698. (unsigned long long)(ne->guid));
  699. if (device_register(&ne->device))
  700. goto fail_devreg;
  701. if (class_device_register(&ne->class_dev))
  702. goto fail_classdevreg;
  703. get_device(&ne->device);
  704. nodemgr_create_ne_dev_files(ne);
  705. nodemgr_update_bus_options(ne);
  706. HPSB_DEBUG("%s added: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
  707. (host->node_id == nodeid) ? "Host" : "Node",
  708. NODE_BUS_ARGS(host, nodeid), (unsigned long long)guid);
  709. return ne;
  710. fail_classdevreg:
  711. device_unregister(&ne->device);
  712. fail_devreg:
  713. kfree(ne);
  714. fail_alloc:
  715. HPSB_ERR("Failed to create node ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
  716. NODE_BUS_ARGS(host, nodeid), (unsigned long long)guid);
  717. return NULL;
  718. }
  719. static struct node_entry *find_entry_by_guid(u64 guid)
  720. {
  721. struct class_device *cdev;
  722. struct node_entry *ne, *ret_ne = NULL;
  723. down(&nodemgr_ne_class.sem);
  724. list_for_each_entry(cdev, &nodemgr_ne_class.children, node) {
  725. ne = container_of(cdev, struct node_entry, class_dev);
  726. if (ne->guid == guid) {
  727. ret_ne = ne;
  728. break;
  729. }
  730. }
  731. up(&nodemgr_ne_class.sem);
  732. return ret_ne;
  733. }
  734. static struct node_entry *find_entry_by_nodeid(struct hpsb_host *host,
  735. nodeid_t nodeid)
  736. {
  737. struct class_device *cdev;
  738. struct node_entry *ne, *ret_ne = NULL;
  739. down(&nodemgr_ne_class.sem);
  740. list_for_each_entry(cdev, &nodemgr_ne_class.children, node) {
  741. ne = container_of(cdev, struct node_entry, class_dev);
  742. if (ne->host == host && ne->nodeid == nodeid) {
  743. ret_ne = ne;
  744. break;
  745. }
  746. }
  747. up(&nodemgr_ne_class.sem);
  748. return ret_ne;
  749. }
  750. static void nodemgr_register_device(struct node_entry *ne,
  751. struct unit_directory *ud, struct device *parent)
  752. {
  753. memcpy(&ud->device, &nodemgr_dev_template_ud,
  754. sizeof(ud->device));
  755. ud->device.parent = parent;
  756. snprintf(ud->device.bus_id, BUS_ID_SIZE, "%s-%u",
  757. ne->device.bus_id, ud->id);
  758. ud->class_dev.dev = &ud->device;
  759. ud->class_dev.class = &nodemgr_ud_class;
  760. snprintf(ud->class_dev.class_id, BUS_ID_SIZE, "%s-%u",
  761. ne->device.bus_id, ud->id);
  762. if (device_register(&ud->device))
  763. goto fail_devreg;
  764. if (class_device_register(&ud->class_dev))
  765. goto fail_classdevreg;
  766. get_device(&ud->device);
  767. nodemgr_create_ud_dev_files(ud);
  768. return;
  769. fail_classdevreg:
  770. device_unregister(&ud->device);
  771. fail_devreg:
  772. HPSB_ERR("Failed to create unit %s", ud->device.bus_id);
  773. }
  774. /* This implementation currently only scans the config rom and its
  775. * immediate unit directories looking for software_id and
  776. * software_version entries, in order to get driver autoloading working. */
  777. static struct unit_directory *nodemgr_process_unit_directory
  778. (struct host_info *hi, struct node_entry *ne, struct csr1212_keyval *ud_kv,
  779. unsigned int *id, struct unit_directory *parent)
  780. {
  781. struct unit_directory *ud;
  782. struct unit_directory *ud_child = NULL;
  783. struct csr1212_dentry *dentry;
  784. struct csr1212_keyval *kv;
  785. u8 last_key_id = 0;
  786. ud = kzalloc(sizeof(*ud), GFP_KERNEL);
  787. if (!ud)
  788. goto unit_directory_error;
  789. ud->ne = ne;
  790. ud->ignore_driver = ignore_drivers;
  791. ud->address = ud_kv->offset + CSR1212_REGISTER_SPACE_BASE;
  792. ud->ud_kv = ud_kv;
  793. ud->id = (*id)++;
  794. csr1212_for_each_dir_entry(ne->csr, kv, ud_kv, dentry) {
  795. switch (kv->key.id) {
  796. case CSR1212_KV_ID_VENDOR:
  797. if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) {
  798. ud->vendor_id = kv->value.immediate;
  799. ud->flags |= UNIT_DIRECTORY_VENDOR_ID;
  800. }
  801. break;
  802. case CSR1212_KV_ID_MODEL:
  803. ud->model_id = kv->value.immediate;
  804. ud->flags |= UNIT_DIRECTORY_MODEL_ID;
  805. break;
  806. case CSR1212_KV_ID_SPECIFIER_ID:
  807. ud->specifier_id = kv->value.immediate;
  808. ud->flags |= UNIT_DIRECTORY_SPECIFIER_ID;
  809. break;
  810. case CSR1212_KV_ID_VERSION:
  811. ud->version = kv->value.immediate;
  812. ud->flags |= UNIT_DIRECTORY_VERSION;
  813. break;
  814. case CSR1212_KV_ID_DESCRIPTOR:
  815. if (kv->key.type == CSR1212_KV_TYPE_LEAF &&
  816. CSR1212_DESCRIPTOR_LEAF_TYPE(kv) == 0 &&
  817. CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) == 0 &&
  818. CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH(kv) == 0 &&
  819. CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET(kv) == 0 &&
  820. CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE(kv) == 0) {
  821. switch (last_key_id) {
  822. case CSR1212_KV_ID_VENDOR:
  823. ud->vendor_name_kv = kv;
  824. csr1212_keep_keyval(kv);
  825. break;
  826. case CSR1212_KV_ID_MODEL:
  827. ud->model_name_kv = kv;
  828. csr1212_keep_keyval(kv);
  829. break;
  830. }
  831. } /* else if (kv->key.type == CSR1212_KV_TYPE_DIRECTORY) ... */
  832. break;
  833. case CSR1212_KV_ID_DEPENDENT_INFO:
  834. /* Logical Unit Number */
  835. if (kv->key.type == CSR1212_KV_TYPE_IMMEDIATE) {
  836. if (ud->flags & UNIT_DIRECTORY_HAS_LUN) {
  837. ud_child = kmemdup(ud, sizeof(*ud_child), GFP_KERNEL);
  838. if (!ud_child)
  839. goto unit_directory_error;
  840. nodemgr_register_device(ne, ud_child, &ne->device);
  841. ud_child = NULL;
  842. ud->id = (*id)++;
  843. }
  844. ud->lun = kv->value.immediate;
  845. ud->flags |= UNIT_DIRECTORY_HAS_LUN;
  846. /* Logical Unit Directory */
  847. } else if (kv->key.type == CSR1212_KV_TYPE_DIRECTORY) {
  848. /* This should really be done in SBP2 as this is
  849. * doing SBP2 specific parsing.
  850. */
  851. /* first register the parent unit */
  852. ud->flags |= UNIT_DIRECTORY_HAS_LUN_DIRECTORY;
  853. if (ud->device.bus != &ieee1394_bus_type)
  854. nodemgr_register_device(ne, ud, &ne->device);
  855. /* process the child unit */
  856. ud_child = nodemgr_process_unit_directory(hi, ne, kv, id, ud);
  857. if (ud_child == NULL)
  858. break;
  859. /* inherit unspecified values, the driver core picks it up */
  860. if ((ud->flags & UNIT_DIRECTORY_MODEL_ID) &&
  861. !(ud_child->flags & UNIT_DIRECTORY_MODEL_ID))
  862. {
  863. ud_child->flags |= UNIT_DIRECTORY_MODEL_ID;
  864. ud_child->model_id = ud->model_id;
  865. }
  866. if ((ud->flags & UNIT_DIRECTORY_SPECIFIER_ID) &&
  867. !(ud_child->flags & UNIT_DIRECTORY_SPECIFIER_ID))
  868. {
  869. ud_child->flags |= UNIT_DIRECTORY_SPECIFIER_ID;
  870. ud_child->specifier_id = ud->specifier_id;
  871. }
  872. if ((ud->flags & UNIT_DIRECTORY_VERSION) &&
  873. !(ud_child->flags & UNIT_DIRECTORY_VERSION))
  874. {
  875. ud_child->flags |= UNIT_DIRECTORY_VERSION;
  876. ud_child->version = ud->version;
  877. }
  878. /* register the child unit */
  879. ud_child->flags |= UNIT_DIRECTORY_LUN_DIRECTORY;
  880. nodemgr_register_device(ne, ud_child, &ud->device);
  881. }
  882. break;
  883. default:
  884. break;
  885. }
  886. last_key_id = kv->key.id;
  887. }
  888. /* do not process child units here and only if not already registered */
  889. if (!parent && ud->device.bus != &ieee1394_bus_type)
  890. nodemgr_register_device(ne, ud, &ne->device);
  891. return ud;
  892. unit_directory_error:
  893. kfree(ud);
  894. return NULL;
  895. }
  896. static void nodemgr_process_root_directory(struct host_info *hi, struct node_entry *ne)
  897. {
  898. unsigned int ud_id = 0;
  899. struct csr1212_dentry *dentry;
  900. struct csr1212_keyval *kv;
  901. u8 last_key_id = 0;
  902. ne->needs_probe = 0;
  903. csr1212_for_each_dir_entry(ne->csr, kv, ne->csr->root_kv, dentry) {
  904. switch (kv->key.id) {
  905. case CSR1212_KV_ID_VENDOR:
  906. ne->vendor_id = kv->value.immediate;
  907. break;
  908. case CSR1212_KV_ID_NODE_CAPABILITIES:
  909. ne->capabilities = kv->value.immediate;
  910. break;
  911. case CSR1212_KV_ID_UNIT:
  912. nodemgr_process_unit_directory(hi, ne, kv, &ud_id, NULL);
  913. break;
  914. case CSR1212_KV_ID_DESCRIPTOR:
  915. if (last_key_id == CSR1212_KV_ID_VENDOR) {
  916. if (kv->key.type == CSR1212_KV_TYPE_LEAF &&
  917. CSR1212_DESCRIPTOR_LEAF_TYPE(kv) == 0 &&
  918. CSR1212_DESCRIPTOR_LEAF_SPECIFIER_ID(kv) == 0 &&
  919. CSR1212_TEXTUAL_DESCRIPTOR_LEAF_WIDTH(kv) == 0 &&
  920. CSR1212_TEXTUAL_DESCRIPTOR_LEAF_CHAR_SET(kv) == 0 &&
  921. CSR1212_TEXTUAL_DESCRIPTOR_LEAF_LANGUAGE(kv) == 0) {
  922. ne->vendor_name_kv = kv;
  923. csr1212_keep_keyval(kv);
  924. }
  925. }
  926. break;
  927. }
  928. last_key_id = kv->key.id;
  929. }
  930. if (ne->vendor_name_kv) {
  931. int error = device_create_file(&ne->device,
  932. &dev_attr_ne_vendor_name_kv);
  933. if (error && error != -EEXIST)
  934. HPSB_ERR("Failed to add sysfs attribute");
  935. }
  936. }
  937. #ifdef CONFIG_HOTPLUG
  938. static int nodemgr_uevent(struct class_device *cdev, char **envp, int num_envp,
  939. char *buffer, int buffer_size)
  940. {
  941. struct unit_directory *ud;
  942. int i = 0;
  943. int length = 0;
  944. int retval = 0;
  945. /* ieee1394:venNmoNspNverN */
  946. char buf[8 + 1 + 3 + 8 + 2 + 8 + 2 + 8 + 3 + 8 + 1];
  947. if (!cdev)
  948. return -ENODEV;
  949. ud = container_of(cdev, struct unit_directory, class_dev);
  950. if (ud->ne->in_limbo || ud->ignore_driver)
  951. return -ENODEV;
  952. #define PUT_ENVP(fmt,val) \
  953. do { \
  954. retval = add_uevent_var(envp, num_envp, &i, \
  955. buffer, buffer_size, &length, \
  956. fmt, val); \
  957. if (retval) \
  958. return retval; \
  959. } while (0)
  960. PUT_ENVP("VENDOR_ID=%06x", ud->vendor_id);
  961. PUT_ENVP("MODEL_ID=%06x", ud->model_id);
  962. PUT_ENVP("GUID=%016Lx", (unsigned long long)ud->ne->guid);
  963. PUT_ENVP("SPECIFIER_ID=%06x", ud->specifier_id);
  964. PUT_ENVP("VERSION=%06x", ud->version);
  965. snprintf(buf, sizeof(buf), "ieee1394:ven%08Xmo%08Xsp%08Xver%08X",
  966. ud->vendor_id,
  967. ud->model_id,
  968. ud->specifier_id,
  969. ud->version);
  970. PUT_ENVP("MODALIAS=%s", buf);
  971. #undef PUT_ENVP
  972. envp[i] = NULL;
  973. return 0;
  974. }
  975. #else
  976. static int nodemgr_uevent(struct class_device *cdev, char **envp, int num_envp,
  977. char *buffer, int buffer_size)
  978. {
  979. return -ENODEV;
  980. }
  981. #endif /* CONFIG_HOTPLUG */
  982. int __hpsb_register_protocol(struct hpsb_protocol_driver *drv,
  983. struct module *owner)
  984. {
  985. int error;
  986. drv->driver.bus = &ieee1394_bus_type;
  987. drv->driver.owner = owner;
  988. drv->driver.name = drv->name;
  989. /* This will cause a probe for devices */
  990. error = driver_register(&drv->driver);
  991. if (!error)
  992. nodemgr_create_drv_files(drv);
  993. return error;
  994. }
  995. void hpsb_unregister_protocol(struct hpsb_protocol_driver *driver)
  996. {
  997. nodemgr_remove_drv_files(driver);
  998. /* This will subsequently disconnect all devices that our driver
  999. * is attached to. */
  1000. driver_unregister(&driver->driver);
  1001. }
  1002. /*
  1003. * This function updates nodes that were present on the bus before the
  1004. * reset and still are after the reset. The nodeid and the config rom
  1005. * may have changed, and the drivers managing this device must be
  1006. * informed that this device just went through a bus reset, to allow
  1007. * the to take whatever actions required.
  1008. */
  1009. static void nodemgr_update_node(struct node_entry *ne, struct csr1212_csr *csr,
  1010. struct host_info *hi, nodeid_t nodeid,
  1011. unsigned int generation)
  1012. {
  1013. if (ne->nodeid != nodeid) {
  1014. HPSB_DEBUG("Node changed: " NODE_BUS_FMT " -> " NODE_BUS_FMT,
  1015. NODE_BUS_ARGS(ne->host, ne->nodeid),
  1016. NODE_BUS_ARGS(ne->host, nodeid));
  1017. ne->nodeid = nodeid;
  1018. }
  1019. if (ne->busopt.generation != ((be32_to_cpu(csr->bus_info_data[2]) >> 4) & 0xf)) {
  1020. kfree(ne->csr->private);
  1021. csr1212_destroy_csr(ne->csr);
  1022. ne->csr = csr;
  1023. /* If the node's configrom generation has changed, we
  1024. * unregister all the unit directories. */
  1025. nodemgr_remove_uds(ne);
  1026. nodemgr_update_bus_options(ne);
  1027. /* Mark the node as new, so it gets re-probed */
  1028. ne->needs_probe = 1;
  1029. } else {
  1030. /* old cache is valid, so update its generation */
  1031. struct nodemgr_csr_info *ci = ne->csr->private;
  1032. ci->generation = generation;
  1033. /* free the partially filled now unneeded new cache */
  1034. kfree(csr->private);
  1035. csr1212_destroy_csr(csr);
  1036. }
  1037. if (ne->in_limbo)
  1038. nodemgr_resume_ne(ne);
  1039. /* Mark the node current */
  1040. ne->generation = generation;
  1041. }
  1042. static void nodemgr_node_scan_one(struct host_info *hi,
  1043. nodeid_t nodeid, int generation)
  1044. {
  1045. struct hpsb_host *host = hi->host;
  1046. struct node_entry *ne;
  1047. octlet_t guid;
  1048. struct csr1212_csr *csr;
  1049. struct nodemgr_csr_info *ci;
  1050. u8 *speed;
  1051. ci = kmalloc(sizeof(*ci), GFP_KERNEL);
  1052. if (!ci)
  1053. return;
  1054. ci->host = host;
  1055. ci->nodeid = nodeid;
  1056. ci->generation = generation;
  1057. /* Prepare for speed probe which occurs when reading the ROM */
  1058. speed = &(host->speed[NODEID_TO_NODE(nodeid)]);
  1059. if (*speed > host->csr.lnk_spd)
  1060. *speed = host->csr.lnk_spd;
  1061. ci->speed_unverified = *speed > IEEE1394_SPEED_100;
  1062. /* We need to detect when the ConfigROM's generation has changed,
  1063. * so we only update the node's info when it needs to be. */
  1064. csr = csr1212_create_csr(&nodemgr_csr_ops, 5 * sizeof(quadlet_t), ci);
  1065. if (!csr || csr1212_parse_csr(csr) != CSR1212_SUCCESS) {
  1066. HPSB_ERR("Error parsing configrom for node " NODE_BUS_FMT,
  1067. NODE_BUS_ARGS(host, nodeid));
  1068. if (csr)
  1069. csr1212_destroy_csr(csr);
  1070. kfree(ci);
  1071. return;
  1072. }
  1073. if (csr->bus_info_data[1] != IEEE1394_BUSID_MAGIC) {
  1074. /* This isn't a 1394 device, but we let it slide. There
  1075. * was a report of a device with broken firmware which
  1076. * reported '2394' instead of '1394', which is obviously a
  1077. * mistake. One would hope that a non-1394 device never
  1078. * gets connected to Firewire bus. If someone does, we
  1079. * shouldn't be held responsible, so we'll allow it with a
  1080. * warning. */
  1081. HPSB_WARN("Node " NODE_BUS_FMT " has invalid busID magic [0x%08x]",
  1082. NODE_BUS_ARGS(host, nodeid), csr->bus_info_data[1]);
  1083. }
  1084. guid = ((u64)be32_to_cpu(csr->bus_info_data[3]) << 32) | be32_to_cpu(csr->bus_info_data[4]);
  1085. ne = find_entry_by_guid(guid);
  1086. if (ne && ne->host != host && ne->in_limbo) {
  1087. /* Must have moved this device from one host to another */
  1088. nodemgr_remove_ne(ne);
  1089. ne = NULL;
  1090. }
  1091. if (!ne)
  1092. nodemgr_create_node(guid, csr, hi, nodeid, generation);
  1093. else
  1094. nodemgr_update_node(ne, csr, hi, nodeid, generation);
  1095. }
  1096. static void nodemgr_node_scan(struct host_info *hi, int generation)
  1097. {
  1098. int count;
  1099. struct hpsb_host *host = hi->host;
  1100. struct selfid *sid = (struct selfid *)host->topology_map;
  1101. nodeid_t nodeid = LOCAL_BUS;
  1102. /* Scan each node on the bus */
  1103. for (count = host->selfid_count; count; count--, sid++) {
  1104. if (sid->extended)
  1105. continue;
  1106. if (!sid->link_active) {
  1107. nodeid++;
  1108. continue;
  1109. }
  1110. nodemgr_node_scan_one(hi, nodeid++, generation);
  1111. }
  1112. }
  1113. static void nodemgr_suspend_ne(struct node_entry *ne)
  1114. {
  1115. struct class_device *cdev;
  1116. struct unit_directory *ud;
  1117. HPSB_DEBUG("Node suspended: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
  1118. NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);
  1119. ne->in_limbo = 1;
  1120. WARN_ON(device_create_file(&ne->device, &dev_attr_ne_in_limbo));
  1121. down(&nodemgr_ud_class.sem);
  1122. list_for_each_entry(cdev, &nodemgr_ud_class.children, node) {
  1123. ud = container_of(cdev, struct unit_directory, class_dev);
  1124. if (ud->ne != ne)
  1125. continue;
  1126. if (ud->device.driver &&
  1127. (!ud->device.driver->suspend ||
  1128. ud->device.driver->suspend(&ud->device, PMSG_SUSPEND)))
  1129. device_release_driver(&ud->device);
  1130. }
  1131. up(&nodemgr_ud_class.sem);
  1132. }
  1133. static void nodemgr_resume_ne(struct node_entry *ne)
  1134. {
  1135. struct class_device *cdev;
  1136. struct unit_directory *ud;
  1137. ne->in_limbo = 0;
  1138. device_remove_file(&ne->device, &dev_attr_ne_in_limbo);
  1139. down(&nodemgr_ud_class.sem);
  1140. list_for_each_entry(cdev, &nodemgr_ud_class.children, node) {
  1141. ud = container_of(cdev, struct unit_directory, class_dev);
  1142. if (ud->ne != ne)
  1143. continue;
  1144. if (ud->device.driver && ud->device.driver->resume)
  1145. ud->device.driver->resume(&ud->device);
  1146. }
  1147. up(&nodemgr_ud_class.sem);
  1148. HPSB_DEBUG("Node resumed: ID:BUS[" NODE_BUS_FMT "] GUID[%016Lx]",
  1149. NODE_BUS_ARGS(ne->host, ne->nodeid), (unsigned long long)ne->guid);
  1150. }
  1151. static void nodemgr_update_pdrv(struct node_entry *ne)
  1152. {
  1153. struct unit_directory *ud;
  1154. struct hpsb_protocol_driver *pdrv;
  1155. struct class_device *cdev;
  1156. down(&nodemgr_ud_class.sem);
  1157. list_for_each_entry(cdev, &nodemgr_ud_class.children, node) {
  1158. ud = container_of(cdev, struct unit_directory, class_dev);
  1159. if (ud->ne != ne)
  1160. continue;
  1161. if (ud->device.driver) {
  1162. pdrv = container_of(ud->device.driver,
  1163. struct hpsb_protocol_driver,
  1164. driver);
  1165. if (pdrv->update && pdrv->update(ud))
  1166. device_release_driver(&ud->device);
  1167. }
  1168. }
  1169. up(&nodemgr_ud_class.sem);
  1170. }
  1171. /* Write the BROADCAST_CHANNEL as per IEEE1394a 8.3.2.3.11 and 8.4.2.3. This
  1172. * seems like an optional service but in the end it is practically mandatory
  1173. * as a consequence of these clauses.
  1174. *
  1175. * Note that we cannot do a broadcast write to all nodes at once because some
  1176. * pre-1394a devices would hang. */
  1177. static void nodemgr_irm_write_bc(struct node_entry *ne, int generation)
  1178. {
  1179. const u64 bc_addr = (CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL);
  1180. quadlet_t bc_remote, bc_local;
  1181. int error;
  1182. if (!ne->host->is_irm || ne->generation != generation ||
  1183. ne->nodeid == ne->host->node_id)
  1184. return;
  1185. bc_local = cpu_to_be32(ne->host->csr.broadcast_channel);
  1186. /* Check if the register is implemented and 1394a compliant. */
  1187. error = hpsb_read(ne->host, ne->nodeid, generation, bc_addr, &bc_remote,
  1188. sizeof(bc_remote));
  1189. if (!error && bc_remote & cpu_to_be32(0x80000000) &&
  1190. bc_remote != bc_local)
  1191. hpsb_node_write(ne, bc_addr, &bc_local, sizeof(bc_local));
  1192. }
  1193. static void nodemgr_probe_ne(struct host_info *hi, struct node_entry *ne, int generation)
  1194. {
  1195. struct device *dev;
  1196. if (ne->host != hi->host || ne->in_limbo)
  1197. return;
  1198. dev = get_device(&ne->device);
  1199. if (!dev)
  1200. return;
  1201. nodemgr_irm_write_bc(ne, generation);
  1202. /* If "needs_probe", then this is either a new or changed node we
  1203. * rescan totally. If the generation matches for an existing node
  1204. * (one that existed prior to the bus reset) we send update calls
  1205. * down to the drivers. Otherwise, this is a dead node and we
  1206. * suspend it. */
  1207. if (ne->needs_probe)
  1208. nodemgr_process_root_directory(hi, ne);
  1209. else if (ne->generation == generation)
  1210. nodemgr_update_pdrv(ne);
  1211. else
  1212. nodemgr_suspend_ne(ne);
  1213. put_device(dev);
  1214. }
  1215. static void nodemgr_node_probe(struct host_info *hi, int generation)
  1216. {
  1217. struct hpsb_host *host = hi->host;
  1218. struct class_device *cdev;
  1219. struct node_entry *ne;
  1220. /* Do some processing of the nodes we've probed. This pulls them
  1221. * into the sysfs layer if needed, and can result in processing of
  1222. * unit-directories, or just updating the node and it's
  1223. * unit-directories.
  1224. *
  1225. * Run updates before probes. Usually, updates are time-critical
  1226. * while probes are time-consuming. (Well, those probes need some
  1227. * improvement...) */
  1228. down(&nodemgr_ne_class.sem);
  1229. list_for_each_entry(cdev, &nodemgr_ne_class.children, node) {
  1230. ne = container_of(cdev, struct node_entry, class_dev);
  1231. if (!ne->needs_probe)
  1232. nodemgr_probe_ne(hi, ne, generation);
  1233. }
  1234. list_for_each_entry(cdev, &nodemgr_ne_class.children, node) {
  1235. ne = container_of(cdev, struct node_entry, class_dev);
  1236. if (ne->needs_probe)
  1237. nodemgr_probe_ne(hi, ne, generation);
  1238. }
  1239. up(&nodemgr_ne_class.sem);
  1240. /* If we had a bus reset while we were scanning the bus, it is
  1241. * possible that we did not probe all nodes. In that case, we
  1242. * skip the clean up for now, since we could remove nodes that
  1243. * were still on the bus. Another bus scan is pending which will
  1244. * do the clean up eventually.
  1245. *
  1246. * Now let's tell the bus to rescan our devices. This may seem
  1247. * like overhead, but the driver-model core will only scan a
  1248. * device for a driver when either the device is added, or when a
  1249. * new driver is added. A bus reset is a good reason to rescan
  1250. * devices that were there before. For example, an sbp2 device
  1251. * may become available for login, if the host that held it was
  1252. * just removed. */
  1253. if (generation == get_hpsb_generation(host))
  1254. if (bus_rescan_devices(&ieee1394_bus_type))
  1255. HPSB_DEBUG("bus_rescan_devices had an error");
  1256. }
  1257. static int nodemgr_send_resume_packet(struct hpsb_host *host)
  1258. {
  1259. struct hpsb_packet *packet;
  1260. int error = -ENOMEM;
  1261. packet = hpsb_make_phypacket(host,
  1262. EXTPHYPACKET_TYPE_RESUME |
  1263. NODEID_TO_NODE(host->node_id) << PHYPACKET_PORT_SHIFT);
  1264. if (packet) {
  1265. packet->no_waiter = 1;
  1266. packet->generation = get_hpsb_generation(host);
  1267. error = hpsb_send_packet(packet);
  1268. }
  1269. if (error)
  1270. HPSB_WARN("fw-host%d: Failed to broadcast resume packet",
  1271. host->id);
  1272. return error;
  1273. }
  1274. /* Perform a few high-level IRM responsibilities. */
  1275. static int nodemgr_do_irm_duties(struct hpsb_host *host, int cycles)
  1276. {
  1277. quadlet_t bc;
  1278. /* if irm_id == -1 then there is no IRM on this bus */
  1279. if (!host->is_irm || host->irm_id == (nodeid_t)-1)
  1280. return 1;
  1281. /* We are a 1394a-2000 compliant IRM. Set the validity bit. */
  1282. host->csr.broadcast_channel |= 0x40000000;
  1283. /* If there is no bus manager then we should set the root node's
  1284. * force_root bit to promote bus stability per the 1394
  1285. * spec. (8.4.2.6) */
  1286. if (host->busmgr_id == 0xffff && host->node_count > 1)
  1287. {
  1288. u16 root_node = host->node_count - 1;
  1289. /* get cycle master capability flag from root node */
  1290. if (host->is_cycmst ||
  1291. (!hpsb_read(host, LOCAL_BUS | root_node, get_hpsb_generation(host),
  1292. (CSR_REGISTER_BASE + CSR_CONFIG_ROM + 2 * sizeof(quadlet_t)),
  1293. &bc, sizeof(quadlet_t)) &&
  1294. be32_to_cpu(bc) & 1 << CSR_CMC_SHIFT))
  1295. hpsb_send_phy_config(host, root_node, -1);
  1296. else {
  1297. HPSB_DEBUG("The root node is not cycle master capable; "
  1298. "selecting a new root node and resetting...");
  1299. if (cycles >= 5) {
  1300. /* Oh screw it! Just leave the bus as it is */
  1301. HPSB_DEBUG("Stopping reset loop for IRM sanity");
  1302. return 1;
  1303. }
  1304. hpsb_send_phy_config(host, NODEID_TO_NODE(host->node_id), -1);
  1305. hpsb_reset_bus(host, LONG_RESET_FORCE_ROOT);
  1306. return 0;
  1307. }
  1308. }
  1309. /* Some devices suspend their ports while being connected to an inactive
  1310. * host adapter, i.e. if connected before the low-level driver is
  1311. * loaded. They become visible either when physically unplugged and
  1312. * replugged, or when receiving a resume packet. Send one once. */
  1313. if (!host->resume_packet_sent && !nodemgr_send_resume_packet(host))
  1314. host->resume_packet_sent = 1;
  1315. return 1;
  1316. }
  1317. /* We need to ensure that if we are not the IRM, that the IRM node is capable of
  1318. * everything we can do, otherwise issue a bus reset and try to become the IRM
  1319. * ourselves. */
  1320. static int nodemgr_check_irm_capability(struct hpsb_host *host, int cycles)
  1321. {
  1322. quadlet_t bc;
  1323. int status;
  1324. if (hpsb_disable_irm || host->is_irm)
  1325. return 1;
  1326. status = hpsb_read(host, LOCAL_BUS | (host->irm_id),
  1327. get_hpsb_generation(host),
  1328. (CSR_REGISTER_BASE | CSR_BROADCAST_CHANNEL),
  1329. &bc, sizeof(quadlet_t));
  1330. if (status < 0 || !(be32_to_cpu(bc) & 0x80000000)) {
  1331. /* The current irm node does not have a valid BROADCAST_CHANNEL
  1332. * register and we do, so reset the bus with force_root set */
  1333. HPSB_DEBUG("Current remote IRM is not 1394a-2000 compliant, resetting...");
  1334. if (cycles >= 5) {
  1335. /* Oh screw it! Just leave the bus as it is */
  1336. HPSB_DEBUG("Stopping reset loop for IRM sanity");
  1337. return 1;
  1338. }
  1339. hpsb_send_phy_config(host, NODEID_TO_NODE(host->node_id), -1);
  1340. hpsb_reset_bus(host, LONG_RESET_FORCE_ROOT);
  1341. return 0;
  1342. }
  1343. return 1;
  1344. }
  1345. static int nodemgr_host_thread(void *__hi)
  1346. {
  1347. struct host_info *hi = (struct host_info *)__hi;
  1348. struct hpsb_host *host = hi->host;
  1349. unsigned int g, generation = 0;
  1350. int i, reset_cycles = 0;
  1351. /* Setup our device-model entries */
  1352. nodemgr_create_host_dev_files(host);
  1353. for (;;) {
  1354. /* Sleep until next bus reset */
  1355. set_current_state(TASK_INTERRUPTIBLE);
  1356. if (get_hpsb_generation(host) == generation &&
  1357. !kthread_should_stop())
  1358. schedule();
  1359. __set_current_state(TASK_RUNNING);
  1360. /* Thread may have been woken up to freeze or to exit */
  1361. if (try_to_freeze())
  1362. continue;
  1363. if (kthread_should_stop())
  1364. goto exit;
  1365. if (mutex_lock_interruptible(&nodemgr_serialize)) {
  1366. if (try_to_freeze())
  1367. continue;
  1368. goto exit;
  1369. }
  1370. /* Pause for 1/4 second in 1/16 second intervals,
  1371. * to make sure things settle down. */
  1372. g = get_hpsb_generation(host);
  1373. for (i = 0; i < 4 ; i++) {
  1374. if (msleep_interruptible(63) || kthread_should_stop())
  1375. goto unlock_exit;
  1376. /* Now get the generation in which the node ID's we collect
  1377. * are valid. During the bus scan we will use this generation
  1378. * for the read transactions, so that if another reset occurs
  1379. * during the scan the transactions will fail instead of
  1380. * returning bogus data. */
  1381. generation = get_hpsb_generation(host);
  1382. /* If we get a reset before we are done waiting, then
  1383. * start the waiting over again */
  1384. if (generation != g)
  1385. g = generation, i = 0;
  1386. }
  1387. if (!nodemgr_check_irm_capability(host, reset_cycles) ||
  1388. !nodemgr_do_irm_duties(host, reset_cycles)) {
  1389. reset_cycles++;
  1390. mutex_unlock(&nodemgr_serialize);
  1391. continue;
  1392. }
  1393. reset_cycles = 0;
  1394. /* Scan our nodes to get the bus options and create node
  1395. * entries. This does not do the sysfs stuff, since that
  1396. * would trigger uevents and such, which is a bad idea at
  1397. * this point. */
  1398. nodemgr_node_scan(hi, generation);
  1399. /* This actually does the full probe, with sysfs
  1400. * registration. */
  1401. nodemgr_node_probe(hi, generation);
  1402. /* Update some of our sysfs symlinks */
  1403. nodemgr_update_host_dev_links(host);
  1404. mutex_unlock(&nodemgr_serialize);
  1405. }
  1406. unlock_exit:
  1407. mutex_unlock(&nodemgr_serialize);
  1408. exit:
  1409. HPSB_VERBOSE("NodeMgr: Exiting thread");
  1410. return 0;
  1411. }
  1412. /**
  1413. * nodemgr_for_each_host - call a function for each IEEE 1394 host
  1414. * @data: an address to supply to the callback
  1415. * @cb: function to call for each host
  1416. *
  1417. * Iterate the hosts, calling a given function with supplied data for each host.
  1418. * If the callback fails on a host, i.e. if it returns a non-zero value, the
  1419. * iteration is stopped.
  1420. *
  1421. * Return value: 0 on success, non-zero on failure (same as returned by last run
  1422. * of the callback).
  1423. */
  1424. int nodemgr_for_each_host(void *data, int (*cb)(struct hpsb_host *, void *))
  1425. {
  1426. struct class_device *cdev;
  1427. struct hpsb_host *host;
  1428. int error = 0;
  1429. down(&hpsb_host_class.sem);
  1430. list_for_each_entry(cdev, &hpsb_host_class.children, node) {
  1431. host = container_of(cdev, struct hpsb_host, class_dev);
  1432. if ((error = cb(host, data)))
  1433. break;
  1434. }
  1435. up(&hpsb_host_class.sem);
  1436. return error;
  1437. }
  1438. /* The following two convenience functions use a struct node_entry
  1439. * for addressing a node on the bus. They are intended for use by any
  1440. * process context, not just the nodemgr thread, so we need to be a
  1441. * little careful when reading out the node ID and generation. The
  1442. * thing that can go wrong is that we get the node ID, then a bus
  1443. * reset occurs, and then we read the generation. The node ID is
  1444. * possibly invalid, but the generation is current, and we end up
  1445. * sending a packet to a the wrong node.
  1446. *
  1447. * The solution is to make sure we read the generation first, so that
  1448. * if a reset occurs in the process, we end up with a stale generation
  1449. * and the transactions will fail instead of silently using wrong node
  1450. * ID's.
  1451. */
  1452. /**
  1453. * hpsb_node_fill_packet - fill some destination information into a packet
  1454. * @ne: destination node
  1455. * @packet: packet to fill in
  1456. *
  1457. * This will fill in the given, pre-initialised hpsb_packet with the current
  1458. * information from the node entry (host, node ID, bus generation number).
  1459. */
  1460. void hpsb_node_fill_packet(struct node_entry *ne, struct hpsb_packet *packet)
  1461. {
  1462. packet->host = ne->host;
  1463. packet->generation = ne->generation;
  1464. barrier();
  1465. packet->node_id = ne->nodeid;
  1466. }
  1467. int hpsb_node_write(struct node_entry *ne, u64 addr,
  1468. quadlet_t *buffer, size_t length)
  1469. {
  1470. unsigned int generation = ne->generation;
  1471. barrier();
  1472. return hpsb_write(ne->host, ne->nodeid, generation,
  1473. addr, buffer, length);
  1474. }
  1475. static void nodemgr_add_host(struct hpsb_host *host)
  1476. {
  1477. struct host_info *hi;
  1478. hi = hpsb_create_hostinfo(&nodemgr_highlevel, host, sizeof(*hi));
  1479. if (!hi) {
  1480. HPSB_ERR("NodeMgr: out of memory in add host");
  1481. return;
  1482. }
  1483. hi->host = host;
  1484. hi->thread = kthread_run(nodemgr_host_thread, hi, "knodemgrd_%d",
  1485. host->id);
  1486. if (IS_ERR(hi->thread)) {
  1487. HPSB_ERR("NodeMgr: cannot start thread for host %d", host->id);
  1488. hpsb_destroy_hostinfo(&nodemgr_highlevel, host);
  1489. }
  1490. }
  1491. static void nodemgr_host_reset(struct hpsb_host *host)
  1492. {
  1493. struct host_info *hi = hpsb_get_hostinfo(&nodemgr_highlevel, host);
  1494. if (hi) {
  1495. HPSB_VERBOSE("NodeMgr: Processing reset for host %d", host->id);
  1496. wake_up_process(hi->thread);
  1497. }
  1498. }
  1499. static void nodemgr_remove_host(struct hpsb_host *host)
  1500. {
  1501. struct host_info *hi = hpsb_get_hostinfo(&nodemgr_highlevel, host);
  1502. if (hi) {
  1503. kthread_stop(hi->thread);
  1504. nodemgr_remove_host_dev(&host->device);
  1505. }
  1506. }
  1507. static struct hpsb_highlevel nodemgr_highlevel = {
  1508. .name = "Node manager",
  1509. .add_host = nodemgr_add_host,
  1510. .host_reset = nodemgr_host_reset,
  1511. .remove_host = nodemgr_remove_host,
  1512. };
  1513. int init_ieee1394_nodemgr(void)
  1514. {
  1515. int error;
  1516. error = class_register(&nodemgr_ne_class);
  1517. if (error)
  1518. goto fail_ne;
  1519. error = class_register(&nodemgr_ud_class);
  1520. if (error)
  1521. goto fail_ud;
  1522. error = driver_register(&nodemgr_mid_layer_driver);
  1523. if (error)
  1524. goto fail_ml;
  1525. /* This driver is not used if nodemgr is off (disable_nodemgr=1). */
  1526. nodemgr_dev_template_host.driver = &nodemgr_mid_layer_driver;
  1527. hpsb_register_highlevel(&nodemgr_highlevel);
  1528. return 0;
  1529. fail_ml:
  1530. class_unregister(&nodemgr_ud_class);
  1531. fail_ud:
  1532. class_unregister(&nodemgr_ne_class);
  1533. fail_ne:
  1534. return error;
  1535. }
  1536. void cleanup_ieee1394_nodemgr(void)
  1537. {
  1538. hpsb_unregister_highlevel(&nodemgr_highlevel);
  1539. driver_unregister(&nodemgr_mid_layer_driver);
  1540. class_unregister(&nodemgr_ud_class);
  1541. class_unregister(&nodemgr_ne_class);
  1542. }