eth1394.c 48 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785
  1. /*
  2. * eth1394.c -- Ethernet driver for Linux IEEE-1394 Subsystem
  3. *
  4. * Copyright (C) 2001-2003 Ben Collins <bcollins@debian.org>
  5. * 2000 Bonin Franck <boninf@free.fr>
  6. * 2003 Steve Kinneberg <kinnebergsteve@acmsystems.com>
  7. *
  8. * Mainly based on work by Emanuel Pirker and Andreas E. Bombe
  9. *
  10. * This program is free software; you can redistribute it and/or modify
  11. * it under the terms of the GNU General Public License as published by
  12. * the Free Software Foundation; either version 2 of the License, or
  13. * (at your option) any later version.
  14. *
  15. * This program is distributed in the hope that it will be useful,
  16. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18. * GNU General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software Foundation,
  22. * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. */
  24. /* This driver intends to support RFC 2734, which describes a method for
  25. * transporting IPv4 datagrams over IEEE-1394 serial busses. This driver
  26. * will ultimately support that method, but currently falls short in
  27. * several areas.
  28. *
  29. * TODO:
  30. * RFC 2734 related:
  31. * - Add MCAP. Limited Multicast exists only to 224.0.0.1 and 224.0.0.2.
  32. *
  33. * Non-RFC 2734 related:
  34. * - Handle fragmented skb's coming from the networking layer.
  35. * - Move generic GASP reception to core 1394 code
  36. * - Convert kmalloc/kfree for link fragments to use kmem_cache_* instead
  37. * - Stability improvements
  38. * - Performance enhancements
  39. * - Consider garbage collecting old partial datagrams after X amount of time
  40. */
  41. #include <linux/module.h>
  42. #include <linux/sched.h>
  43. #include <linux/kernel.h>
  44. #include <linux/slab.h>
  45. #include <linux/errno.h>
  46. #include <linux/types.h>
  47. #include <linux/delay.h>
  48. #include <linux/init.h>
  49. #include <linux/netdevice.h>
  50. #include <linux/inetdevice.h>
  51. #include <linux/etherdevice.h>
  52. #include <linux/if_arp.h>
  53. #include <linux/if_ether.h>
  54. #include <linux/ip.h>
  55. #include <linux/in.h>
  56. #include <linux/tcp.h>
  57. #include <linux/skbuff.h>
  58. #include <linux/bitops.h>
  59. #include <linux/ethtool.h>
  60. #include <asm/uaccess.h>
  61. #include <asm/delay.h>
  62. #include <net/arp.h>
  63. #include "config_roms.h"
  64. #include "csr1212.h"
  65. #include "eth1394.h"
  66. #include "highlevel.h"
  67. #include "ieee1394.h"
  68. #include "ieee1394_core.h"
  69. #include "ieee1394_hotplug.h"
  70. #include "ieee1394_transactions.h"
  71. #include "ieee1394_types.h"
  72. #include "iso.h"
  73. #include "nodemgr.h"
  74. #define ETH1394_PRINT_G(level, fmt, args...) \
  75. printk(level "%s: " fmt, driver_name, ## args)
  76. #define ETH1394_PRINT(level, dev_name, fmt, args...) \
  77. printk(level "%s: %s: " fmt, driver_name, dev_name, ## args)
  78. #define DEBUG(fmt, args...) \
  79. printk(KERN_ERR "%s:%s[%d]: " fmt "\n", driver_name, __FUNCTION__, __LINE__, ## args)
  80. #define TRACE() printk(KERN_ERR "%s:%s[%d] ---- TRACE\n", driver_name, __FUNCTION__, __LINE__)
  81. struct fragment_info {
  82. struct list_head list;
  83. int offset;
  84. int len;
  85. };
  86. struct partial_datagram {
  87. struct list_head list;
  88. u16 dgl;
  89. u16 dg_size;
  90. u16 ether_type;
  91. struct sk_buff *skb;
  92. char *pbuf;
  93. struct list_head frag_info;
  94. };
  95. struct pdg_list {
  96. struct list_head list; /* partial datagram list per node */
  97. unsigned int sz; /* partial datagram list size per node */
  98. spinlock_t lock; /* partial datagram lock */
  99. };
  100. struct eth1394_host_info {
  101. struct hpsb_host *host;
  102. struct net_device *dev;
  103. };
  104. struct eth1394_node_ref {
  105. struct unit_directory *ud;
  106. struct list_head list;
  107. };
  108. struct eth1394_node_info {
  109. u16 maxpayload; /* Max payload */
  110. u8 sspd; /* Max speed */
  111. u64 fifo; /* FIFO address */
  112. struct pdg_list pdg; /* partial RX datagram lists */
  113. int dgl; /* Outgoing datagram label */
  114. };
  115. /* Our ieee1394 highlevel driver */
  116. #define ETH1394_DRIVER_NAME "eth1394"
  117. static const char driver_name[] = ETH1394_DRIVER_NAME;
  118. static kmem_cache_t *packet_task_cache;
  119. static struct hpsb_highlevel eth1394_highlevel;
  120. /* Use common.lf to determine header len */
  121. static const int hdr_type_len[] = {
  122. sizeof (struct eth1394_uf_hdr),
  123. sizeof (struct eth1394_ff_hdr),
  124. sizeof (struct eth1394_sf_hdr),
  125. sizeof (struct eth1394_sf_hdr)
  126. };
  127. /* Change this to IEEE1394_SPEED_S100 to make testing easier */
  128. #define ETH1394_SPEED_DEF IEEE1394_SPEED_MAX
  129. /* For now, this needs to be 1500, so that XP works with us */
  130. #define ETH1394_DATA_LEN ETH_DATA_LEN
  131. static const u16 eth1394_speedto_maxpayload[] = {
  132. /* S100, S200, S400, S800, S1600, S3200 */
  133. 512, 1024, 2048, 4096, 4096, 4096
  134. };
  135. MODULE_AUTHOR("Ben Collins (bcollins@debian.org)");
  136. MODULE_DESCRIPTION("IEEE 1394 IPv4 Driver (IPv4-over-1394 as per RFC 2734)");
  137. MODULE_LICENSE("GPL");
  138. /* The max_partial_datagrams parameter is the maximum number of fragmented
  139. * datagrams per node that eth1394 will keep in memory. Providing an upper
  140. * bound allows us to limit the amount of memory that partial datagrams
  141. * consume in the event that some partial datagrams are never completed.
  142. */
  143. static int max_partial_datagrams = 25;
  144. module_param(max_partial_datagrams, int, S_IRUGO | S_IWUSR);
  145. MODULE_PARM_DESC(max_partial_datagrams,
  146. "Maximum number of partially received fragmented datagrams "
  147. "(default = 25).");
  148. static int ether1394_header(struct sk_buff *skb, struct net_device *dev,
  149. unsigned short type, void *daddr, void *saddr,
  150. unsigned len);
  151. static int ether1394_rebuild_header(struct sk_buff *skb);
  152. static int ether1394_header_parse(struct sk_buff *skb, unsigned char *haddr);
  153. static int ether1394_header_cache(struct neighbour *neigh, struct hh_cache *hh);
  154. static void ether1394_header_cache_update(struct hh_cache *hh,
  155. struct net_device *dev,
  156. unsigned char * haddr);
  157. static int ether1394_mac_addr(struct net_device *dev, void *p);
  158. static void purge_partial_datagram(struct list_head *old);
  159. static int ether1394_tx(struct sk_buff *skb, struct net_device *dev);
  160. static void ether1394_iso(struct hpsb_iso *iso);
  161. static struct ethtool_ops ethtool_ops;
  162. static int ether1394_write(struct hpsb_host *host, int srcid, int destid,
  163. quadlet_t *data, u64 addr, size_t len, u16 flags);
  164. static void ether1394_add_host (struct hpsb_host *host);
  165. static void ether1394_remove_host (struct hpsb_host *host);
  166. static void ether1394_host_reset (struct hpsb_host *host);
  167. /* Function for incoming 1394 packets */
  168. static struct hpsb_address_ops addr_ops = {
  169. .write = ether1394_write,
  170. };
  171. /* Ieee1394 highlevel driver functions */
  172. static struct hpsb_highlevel eth1394_highlevel = {
  173. .name = driver_name,
  174. .add_host = ether1394_add_host,
  175. .remove_host = ether1394_remove_host,
  176. .host_reset = ether1394_host_reset,
  177. };
  178. /* This is called after an "ifup" */
  179. static int ether1394_open (struct net_device *dev)
  180. {
  181. struct eth1394_priv *priv = netdev_priv(dev);
  182. int ret = 0;
  183. /* Something bad happened, don't even try */
  184. if (priv->bc_state == ETHER1394_BC_ERROR) {
  185. /* we'll try again */
  186. priv->iso = hpsb_iso_recv_init(priv->host,
  187. ETHER1394_ISO_BUF_SIZE,
  188. ETHER1394_GASP_BUFFERS,
  189. priv->broadcast_channel,
  190. HPSB_ISO_DMA_PACKET_PER_BUFFER,
  191. 1, ether1394_iso);
  192. if (priv->iso == NULL) {
  193. ETH1394_PRINT(KERN_ERR, dev->name,
  194. "Could not allocate isochronous receive "
  195. "context for the broadcast channel\n");
  196. priv->bc_state = ETHER1394_BC_ERROR;
  197. ret = -EAGAIN;
  198. } else {
  199. if (hpsb_iso_recv_start(priv->iso, -1, (1 << 3), -1) < 0)
  200. priv->bc_state = ETHER1394_BC_STOPPED;
  201. else
  202. priv->bc_state = ETHER1394_BC_RUNNING;
  203. }
  204. }
  205. if (ret)
  206. return ret;
  207. netif_start_queue (dev);
  208. return 0;
  209. }
  210. /* This is called after an "ifdown" */
  211. static int ether1394_stop (struct net_device *dev)
  212. {
  213. netif_stop_queue (dev);
  214. return 0;
  215. }
  216. /* Return statistics to the caller */
  217. static struct net_device_stats *ether1394_stats (struct net_device *dev)
  218. {
  219. return &(((struct eth1394_priv *)netdev_priv(dev))->stats);
  220. }
  221. /* What to do if we timeout. I think a host reset is probably in order, so
  222. * that's what we do. Should we increment the stat counters too? */
  223. static void ether1394_tx_timeout (struct net_device *dev)
  224. {
  225. ETH1394_PRINT (KERN_ERR, dev->name, "Timeout, resetting host %s\n",
  226. ((struct eth1394_priv *)netdev_priv(dev))->host->driver->name);
  227. highlevel_host_reset (((struct eth1394_priv *)netdev_priv(dev))->host);
  228. netif_wake_queue (dev);
  229. }
  230. static int ether1394_change_mtu(struct net_device *dev, int new_mtu)
  231. {
  232. struct eth1394_priv *priv = netdev_priv(dev);
  233. if ((new_mtu < 68) ||
  234. (new_mtu > min(ETH1394_DATA_LEN,
  235. (int)((1 << (priv->host->csr.max_rec + 1)) -
  236. (sizeof(union eth1394_hdr) +
  237. ETHER1394_GASP_OVERHEAD)))))
  238. return -EINVAL;
  239. dev->mtu = new_mtu;
  240. return 0;
  241. }
  242. static void purge_partial_datagram(struct list_head *old)
  243. {
  244. struct partial_datagram *pd = list_entry(old, struct partial_datagram, list);
  245. struct list_head *lh, *n;
  246. list_for_each_safe(lh, n, &pd->frag_info) {
  247. struct fragment_info *fi = list_entry(lh, struct fragment_info, list);
  248. list_del(lh);
  249. kfree(fi);
  250. }
  251. list_del(old);
  252. kfree_skb(pd->skb);
  253. kfree(pd);
  254. }
  255. /******************************************
  256. * 1394 bus activity functions
  257. ******************************************/
  258. static struct eth1394_node_ref *eth1394_find_node(struct list_head *inl,
  259. struct unit_directory *ud)
  260. {
  261. struct eth1394_node_ref *node;
  262. list_for_each_entry(node, inl, list)
  263. if (node->ud == ud)
  264. return node;
  265. return NULL;
  266. }
  267. static struct eth1394_node_ref *eth1394_find_node_guid(struct list_head *inl,
  268. u64 guid)
  269. {
  270. struct eth1394_node_ref *node;
  271. list_for_each_entry(node, inl, list)
  272. if (node->ud->ne->guid == guid)
  273. return node;
  274. return NULL;
  275. }
  276. static struct eth1394_node_ref *eth1394_find_node_nodeid(struct list_head *inl,
  277. nodeid_t nodeid)
  278. {
  279. struct eth1394_node_ref *node;
  280. list_for_each_entry(node, inl, list) {
  281. if (node->ud->ne->nodeid == nodeid)
  282. return node;
  283. }
  284. return NULL;
  285. }
  286. static int eth1394_probe(struct device *dev)
  287. {
  288. struct unit_directory *ud;
  289. struct eth1394_host_info *hi;
  290. struct eth1394_priv *priv;
  291. struct eth1394_node_ref *new_node;
  292. struct eth1394_node_info *node_info;
  293. ud = container_of(dev, struct unit_directory, device);
  294. hi = hpsb_get_hostinfo(&eth1394_highlevel, ud->ne->host);
  295. if (!hi)
  296. return -ENOENT;
  297. new_node = kmalloc(sizeof(*new_node),
  298. in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
  299. if (!new_node)
  300. return -ENOMEM;
  301. node_info = kmalloc(sizeof(*node_info),
  302. in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
  303. if (!node_info) {
  304. kfree(new_node);
  305. return -ENOMEM;
  306. }
  307. spin_lock_init(&node_info->pdg.lock);
  308. INIT_LIST_HEAD(&node_info->pdg.list);
  309. node_info->pdg.sz = 0;
  310. node_info->fifo = CSR1212_INVALID_ADDR_SPACE;
  311. ud->device.driver_data = node_info;
  312. new_node->ud = ud;
  313. priv = netdev_priv(hi->dev);
  314. list_add_tail(&new_node->list, &priv->ip_node_list);
  315. return 0;
  316. }
  317. static int eth1394_remove(struct device *dev)
  318. {
  319. struct unit_directory *ud;
  320. struct eth1394_host_info *hi;
  321. struct eth1394_priv *priv;
  322. struct eth1394_node_ref *old_node;
  323. struct eth1394_node_info *node_info;
  324. struct list_head *lh, *n;
  325. unsigned long flags;
  326. ud = container_of(dev, struct unit_directory, device);
  327. hi = hpsb_get_hostinfo(&eth1394_highlevel, ud->ne->host);
  328. if (!hi)
  329. return -ENOENT;
  330. priv = netdev_priv(hi->dev);
  331. old_node = eth1394_find_node(&priv->ip_node_list, ud);
  332. if (old_node) {
  333. list_del(&old_node->list);
  334. kfree(old_node);
  335. node_info = (struct eth1394_node_info*)ud->device.driver_data;
  336. spin_lock_irqsave(&node_info->pdg.lock, flags);
  337. /* The partial datagram list should be empty, but we'll just
  338. * make sure anyway... */
  339. list_for_each_safe(lh, n, &node_info->pdg.list) {
  340. purge_partial_datagram(lh);
  341. }
  342. spin_unlock_irqrestore(&node_info->pdg.lock, flags);
  343. kfree(node_info);
  344. ud->device.driver_data = NULL;
  345. }
  346. return 0;
  347. }
  348. static int eth1394_update(struct unit_directory *ud)
  349. {
  350. struct eth1394_host_info *hi;
  351. struct eth1394_priv *priv;
  352. struct eth1394_node_ref *node;
  353. struct eth1394_node_info *node_info;
  354. hi = hpsb_get_hostinfo(&eth1394_highlevel, ud->ne->host);
  355. if (!hi)
  356. return -ENOENT;
  357. priv = netdev_priv(hi->dev);
  358. node = eth1394_find_node(&priv->ip_node_list, ud);
  359. if (!node) {
  360. node = kmalloc(sizeof(*node),
  361. in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
  362. if (!node)
  363. return -ENOMEM;
  364. node_info = kmalloc(sizeof(*node_info),
  365. in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
  366. if (!node_info) {
  367. kfree(node);
  368. return -ENOMEM;
  369. }
  370. spin_lock_init(&node_info->pdg.lock);
  371. INIT_LIST_HEAD(&node_info->pdg.list);
  372. node_info->pdg.sz = 0;
  373. ud->device.driver_data = node_info;
  374. node->ud = ud;
  375. priv = netdev_priv(hi->dev);
  376. list_add_tail(&node->list, &priv->ip_node_list);
  377. }
  378. return 0;
  379. }
  380. static struct ieee1394_device_id eth1394_id_table[] = {
  381. {
  382. .match_flags = (IEEE1394_MATCH_SPECIFIER_ID |
  383. IEEE1394_MATCH_VERSION),
  384. .specifier_id = ETHER1394_GASP_SPECIFIER_ID,
  385. .version = ETHER1394_GASP_VERSION,
  386. },
  387. {}
  388. };
  389. MODULE_DEVICE_TABLE(ieee1394, eth1394_id_table);
  390. static struct hpsb_protocol_driver eth1394_proto_driver = {
  391. .name = "IPv4 over 1394 Driver",
  392. .id_table = eth1394_id_table,
  393. .update = eth1394_update,
  394. .driver = {
  395. .name = ETH1394_DRIVER_NAME,
  396. .bus = &ieee1394_bus_type,
  397. .probe = eth1394_probe,
  398. .remove = eth1394_remove,
  399. },
  400. };
  401. static void ether1394_reset_priv (struct net_device *dev, int set_mtu)
  402. {
  403. unsigned long flags;
  404. int i;
  405. struct eth1394_priv *priv = netdev_priv(dev);
  406. struct hpsb_host *host = priv->host;
  407. u64 guid = *((u64*)&(host->csr.rom->bus_info_data[3]));
  408. u16 maxpayload = 1 << (host->csr.max_rec + 1);
  409. int max_speed = IEEE1394_SPEED_MAX;
  410. spin_lock_irqsave (&priv->lock, flags);
  411. memset(priv->ud_list, 0, sizeof(struct node_entry*) * ALL_NODES);
  412. priv->bc_maxpayload = 512;
  413. /* Determine speed limit */
  414. for (i = 0; i < host->node_count; i++)
  415. if (max_speed > host->speed[i])
  416. max_speed = host->speed[i];
  417. priv->bc_sspd = max_speed;
  418. /* We'll use our maxpayload as the default mtu */
  419. if (set_mtu) {
  420. dev->mtu = min(ETH1394_DATA_LEN,
  421. (int)(maxpayload -
  422. (sizeof(union eth1394_hdr) +
  423. ETHER1394_GASP_OVERHEAD)));
  424. /* Set our hardware address while we're at it */
  425. *(u64*)dev->dev_addr = guid;
  426. *(u64*)dev->broadcast = ~0x0ULL;
  427. }
  428. spin_unlock_irqrestore (&priv->lock, flags);
  429. }
  430. /* This function is called right before register_netdev */
  431. static void ether1394_init_dev (struct net_device *dev)
  432. {
  433. /* Our functions */
  434. dev->open = ether1394_open;
  435. dev->stop = ether1394_stop;
  436. dev->hard_start_xmit = ether1394_tx;
  437. dev->get_stats = ether1394_stats;
  438. dev->tx_timeout = ether1394_tx_timeout;
  439. dev->change_mtu = ether1394_change_mtu;
  440. dev->hard_header = ether1394_header;
  441. dev->rebuild_header = ether1394_rebuild_header;
  442. dev->hard_header_cache = ether1394_header_cache;
  443. dev->header_cache_update= ether1394_header_cache_update;
  444. dev->hard_header_parse = ether1394_header_parse;
  445. dev->set_mac_address = ether1394_mac_addr;
  446. SET_ETHTOOL_OPS(dev, &ethtool_ops);
  447. /* Some constants */
  448. dev->watchdog_timeo = ETHER1394_TIMEOUT;
  449. dev->flags = IFF_BROADCAST | IFF_MULTICAST;
  450. dev->features = NETIF_F_HIGHDMA;
  451. dev->addr_len = ETH1394_ALEN;
  452. dev->hard_header_len = ETH1394_HLEN;
  453. dev->type = ARPHRD_IEEE1394;
  454. ether1394_reset_priv (dev, 1);
  455. }
  456. /*
  457. * This function is called every time a card is found. It is generally called
  458. * when the module is installed. This is where we add all of our ethernet
  459. * devices. One for each host.
  460. */
  461. static void ether1394_add_host (struct hpsb_host *host)
  462. {
  463. struct eth1394_host_info *hi = NULL;
  464. struct net_device *dev = NULL;
  465. struct eth1394_priv *priv;
  466. u64 fifo_addr;
  467. if (!(host->config_roms & HPSB_CONFIG_ROM_ENTRY_IP1394))
  468. return;
  469. fifo_addr = hpsb_allocate_and_register_addrspace(
  470. &eth1394_highlevel, host, &addr_ops,
  471. ETHER1394_REGION_ADDR_LEN, ETHER1394_REGION_ADDR_LEN,
  472. CSR1212_INVALID_ADDR_SPACE, CSR1212_INVALID_ADDR_SPACE);
  473. if (fifo_addr == CSR1212_INVALID_ADDR_SPACE)
  474. goto out;
  475. /* We should really have our own alloc_hpsbdev() function in
  476. * net_init.c instead of calling the one for ethernet then hijacking
  477. * it for ourselves. That way we'd be a real networking device. */
  478. dev = alloc_etherdev(sizeof (struct eth1394_priv));
  479. if (dev == NULL) {
  480. ETH1394_PRINT_G (KERN_ERR, "Out of memory trying to allocate "
  481. "etherdevice for IEEE 1394 device %s-%d\n",
  482. host->driver->name, host->id);
  483. goto out;
  484. }
  485. SET_MODULE_OWNER(dev);
  486. SET_NETDEV_DEV(dev, &host->device);
  487. priv = netdev_priv(dev);
  488. INIT_LIST_HEAD(&priv->ip_node_list);
  489. spin_lock_init(&priv->lock);
  490. priv->host = host;
  491. priv->local_fifo = fifo_addr;
  492. hi = hpsb_create_hostinfo(&eth1394_highlevel, host, sizeof(*hi));
  493. if (hi == NULL) {
  494. ETH1394_PRINT_G (KERN_ERR, "Out of memory trying to create "
  495. "hostinfo for IEEE 1394 device %s-%d\n",
  496. host->driver->name, host->id);
  497. goto out;
  498. }
  499. ether1394_init_dev(dev);
  500. if (register_netdev (dev)) {
  501. ETH1394_PRINT (KERN_ERR, dev->name, "Error registering network driver\n");
  502. goto out;
  503. }
  504. ETH1394_PRINT (KERN_INFO, dev->name, "IEEE-1394 IPv4 over 1394 Ethernet (fw-host%d)\n",
  505. host->id);
  506. hi->host = host;
  507. hi->dev = dev;
  508. /* Ignore validity in hopes that it will be set in the future. It'll
  509. * be checked when the eth device is opened. */
  510. priv->broadcast_channel = host->csr.broadcast_channel & 0x3f;
  511. priv->iso = hpsb_iso_recv_init(host,
  512. ETHER1394_ISO_BUF_SIZE,
  513. ETHER1394_GASP_BUFFERS,
  514. priv->broadcast_channel,
  515. HPSB_ISO_DMA_PACKET_PER_BUFFER,
  516. 1, ether1394_iso);
  517. if (priv->iso == NULL) {
  518. ETH1394_PRINT(KERN_ERR, dev->name,
  519. "Could not allocate isochronous receive context "
  520. "for the broadcast channel\n");
  521. priv->bc_state = ETHER1394_BC_ERROR;
  522. } else {
  523. if (hpsb_iso_recv_start(priv->iso, -1, (1 << 3), -1) < 0)
  524. priv->bc_state = ETHER1394_BC_STOPPED;
  525. else
  526. priv->bc_state = ETHER1394_BC_RUNNING;
  527. }
  528. return;
  529. out:
  530. if (dev != NULL)
  531. free_netdev(dev);
  532. if (hi)
  533. hpsb_destroy_hostinfo(&eth1394_highlevel, host);
  534. return;
  535. }
  536. /* Remove a card from our list */
  537. static void ether1394_remove_host (struct hpsb_host *host)
  538. {
  539. struct eth1394_host_info *hi;
  540. hi = hpsb_get_hostinfo(&eth1394_highlevel, host);
  541. if (hi != NULL) {
  542. struct eth1394_priv *priv = netdev_priv(hi->dev);
  543. hpsb_unregister_addrspace(&eth1394_highlevel, host,
  544. priv->local_fifo);
  545. if (priv->iso != NULL)
  546. hpsb_iso_shutdown(priv->iso);
  547. if (hi->dev) {
  548. unregister_netdev (hi->dev);
  549. free_netdev(hi->dev);
  550. }
  551. }
  552. return;
  553. }
  554. /* A reset has just arisen */
  555. static void ether1394_host_reset (struct hpsb_host *host)
  556. {
  557. struct eth1394_host_info *hi;
  558. struct eth1394_priv *priv;
  559. struct net_device *dev;
  560. struct list_head *lh, *n;
  561. struct eth1394_node_ref *node;
  562. struct eth1394_node_info *node_info;
  563. unsigned long flags;
  564. hi = hpsb_get_hostinfo(&eth1394_highlevel, host);
  565. /* This can happen for hosts that we don't use */
  566. if (hi == NULL)
  567. return;
  568. dev = hi->dev;
  569. priv = (struct eth1394_priv *)netdev_priv(dev);
  570. /* Reset our private host data, but not our mtu */
  571. netif_stop_queue (dev);
  572. ether1394_reset_priv (dev, 0);
  573. list_for_each_entry(node, &priv->ip_node_list, list) {
  574. node_info = (struct eth1394_node_info*)node->ud->device.driver_data;
  575. spin_lock_irqsave(&node_info->pdg.lock, flags);
  576. list_for_each_safe(lh, n, &node_info->pdg.list) {
  577. purge_partial_datagram(lh);
  578. }
  579. INIT_LIST_HEAD(&(node_info->pdg.list));
  580. node_info->pdg.sz = 0;
  581. spin_unlock_irqrestore(&node_info->pdg.lock, flags);
  582. }
  583. netif_wake_queue (dev);
  584. }
  585. /******************************************
  586. * HW Header net device functions
  587. ******************************************/
  588. /* These functions have been adapted from net/ethernet/eth.c */
  589. /* Create a fake MAC header for an arbitrary protocol layer.
  590. * saddr=NULL means use device source address
  591. * daddr=NULL means leave destination address (eg unresolved arp). */
  592. static int ether1394_header(struct sk_buff *skb, struct net_device *dev,
  593. unsigned short type, void *daddr, void *saddr,
  594. unsigned len)
  595. {
  596. struct eth1394hdr *eth = (struct eth1394hdr *)skb_push(skb, ETH1394_HLEN);
  597. eth->h_proto = htons(type);
  598. if (dev->flags & (IFF_LOOPBACK|IFF_NOARP)) {
  599. memset(eth->h_dest, 0, dev->addr_len);
  600. return(dev->hard_header_len);
  601. }
  602. if (daddr) {
  603. memcpy(eth->h_dest,daddr,dev->addr_len);
  604. return dev->hard_header_len;
  605. }
  606. return -dev->hard_header_len;
  607. }
  608. /* Rebuild the faked MAC header. This is called after an ARP
  609. * (or in future other address resolution) has completed on this
  610. * sk_buff. We now let ARP fill in the other fields.
  611. *
  612. * This routine CANNOT use cached dst->neigh!
  613. * Really, it is used only when dst->neigh is wrong.
  614. */
  615. static int ether1394_rebuild_header(struct sk_buff *skb)
  616. {
  617. struct eth1394hdr *eth = (struct eth1394hdr *)skb->data;
  618. struct net_device *dev = skb->dev;
  619. switch (eth->h_proto) {
  620. #ifdef CONFIG_INET
  621. case __constant_htons(ETH_P_IP):
  622. return arp_find((unsigned char*)&eth->h_dest, skb);
  623. #endif
  624. default:
  625. ETH1394_PRINT(KERN_DEBUG, dev->name,
  626. "unable to resolve type %04x addresses.\n",
  627. ntohs(eth->h_proto));
  628. break;
  629. }
  630. return 0;
  631. }
  632. static int ether1394_header_parse(struct sk_buff *skb, unsigned char *haddr)
  633. {
  634. struct net_device *dev = skb->dev;
  635. memcpy(haddr, dev->dev_addr, ETH1394_ALEN);
  636. return ETH1394_ALEN;
  637. }
  638. static int ether1394_header_cache(struct neighbour *neigh, struct hh_cache *hh)
  639. {
  640. unsigned short type = hh->hh_type;
  641. struct eth1394hdr *eth = (struct eth1394hdr*)(((u8*)hh->hh_data) +
  642. (16 - ETH1394_HLEN));
  643. struct net_device *dev = neigh->dev;
  644. if (type == htons(ETH_P_802_3))
  645. return -1;
  646. eth->h_proto = type;
  647. memcpy(eth->h_dest, neigh->ha, dev->addr_len);
  648. hh->hh_len = ETH1394_HLEN;
  649. return 0;
  650. }
  651. /* Called by Address Resolution module to notify changes in address. */
  652. static void ether1394_header_cache_update(struct hh_cache *hh,
  653. struct net_device *dev,
  654. unsigned char * haddr)
  655. {
  656. memcpy(((u8*)hh->hh_data) + (16 - ETH1394_HLEN), haddr, dev->addr_len);
  657. }
  658. static int ether1394_mac_addr(struct net_device *dev, void *p)
  659. {
  660. if (netif_running(dev))
  661. return -EBUSY;
  662. /* Not going to allow setting the MAC address, we really need to use
  663. * the real one supplied by the hardware */
  664. return -EINVAL;
  665. }
  666. /******************************************
  667. * Datagram reception code
  668. ******************************************/
  669. /* Copied from net/ethernet/eth.c */
  670. static inline u16 ether1394_type_trans(struct sk_buff *skb,
  671. struct net_device *dev)
  672. {
  673. struct eth1394hdr *eth;
  674. unsigned char *rawp;
  675. skb->mac.raw = skb->data;
  676. skb_pull (skb, ETH1394_HLEN);
  677. eth = eth1394_hdr(skb);
  678. if (*eth->h_dest & 1) {
  679. if (memcmp(eth->h_dest, dev->broadcast, dev->addr_len)==0)
  680. skb->pkt_type = PACKET_BROADCAST;
  681. #if 0
  682. else
  683. skb->pkt_type = PACKET_MULTICAST;
  684. #endif
  685. } else {
  686. if (memcmp(eth->h_dest, dev->dev_addr, dev->addr_len))
  687. skb->pkt_type = PACKET_OTHERHOST;
  688. }
  689. if (ntohs (eth->h_proto) >= 1536)
  690. return eth->h_proto;
  691. rawp = skb->data;
  692. if (*(unsigned short *)rawp == 0xFFFF)
  693. return htons (ETH_P_802_3);
  694. return htons (ETH_P_802_2);
  695. }
  696. /* Parse an encapsulated IP1394 header into an ethernet frame packet.
  697. * We also perform ARP translation here, if need be. */
  698. static inline u16 ether1394_parse_encap(struct sk_buff *skb,
  699. struct net_device *dev,
  700. nodeid_t srcid, nodeid_t destid,
  701. u16 ether_type)
  702. {
  703. struct eth1394_priv *priv = netdev_priv(dev);
  704. u64 dest_hw;
  705. unsigned short ret = 0;
  706. /* Setup our hw addresses. We use these to build the
  707. * ethernet header. */
  708. if (destid == (LOCAL_BUS | ALL_NODES))
  709. dest_hw = ~0ULL; /* broadcast */
  710. else
  711. dest_hw = cpu_to_be64((((u64)priv->host->csr.guid_hi) << 32) |
  712. priv->host->csr.guid_lo);
  713. /* If this is an ARP packet, convert it. First, we want to make
  714. * use of some of the fields, since they tell us a little bit
  715. * about the sending machine. */
  716. if (ether_type == htons(ETH_P_ARP)) {
  717. struct eth1394_arp *arp1394 = (struct eth1394_arp*)skb->data;
  718. struct arphdr *arp = (struct arphdr *)skb->data;
  719. unsigned char *arp_ptr = (unsigned char *)(arp + 1);
  720. u64 fifo_addr = (u64)ntohs(arp1394->fifo_hi) << 32 |
  721. ntohl(arp1394->fifo_lo);
  722. u8 max_rec = min(priv->host->csr.max_rec,
  723. (u8)(arp1394->max_rec));
  724. int sspd = arp1394->sspd;
  725. u16 maxpayload;
  726. struct eth1394_node_ref *node;
  727. struct eth1394_node_info *node_info;
  728. /* Sanity check. MacOSX seems to be sending us 131 in this
  729. * field (atleast on my Panther G5). Not sure why. */
  730. if (sspd > 5 || sspd < 0)
  731. sspd = 0;
  732. maxpayload = min(eth1394_speedto_maxpayload[sspd], (u16)(1 << (max_rec + 1)));
  733. node = eth1394_find_node_guid(&priv->ip_node_list,
  734. be64_to_cpu(arp1394->s_uniq_id));
  735. if (!node) {
  736. return 0;
  737. }
  738. node_info = (struct eth1394_node_info*)node->ud->device.driver_data;
  739. /* Update our speed/payload/fifo_offset table */
  740. node_info->maxpayload = maxpayload;
  741. node_info->sspd = sspd;
  742. node_info->fifo = fifo_addr;
  743. /* Now that we're done with the 1394 specific stuff, we'll
  744. * need to alter some of the data. Believe it or not, all
  745. * that needs to be done is sender_IP_address needs to be
  746. * moved, the destination hardware address get stuffed
  747. * in and the hardware address length set to 8.
  748. *
  749. * IMPORTANT: The code below overwrites 1394 specific data
  750. * needed above so keep the munging of the data for the
  751. * higher level IP stack last. */
  752. arp->ar_hln = 8;
  753. arp_ptr += arp->ar_hln; /* skip over sender unique id */
  754. *(u32*)arp_ptr = arp1394->sip; /* move sender IP addr */
  755. arp_ptr += arp->ar_pln; /* skip over sender IP addr */
  756. if (arp->ar_op == htons(ARPOP_REQUEST))
  757. /* just set ARP req target unique ID to 0 */
  758. *((u64*)arp_ptr) = 0;
  759. else
  760. *((u64*)arp_ptr) = *((u64*)dev->dev_addr);
  761. }
  762. /* Now add the ethernet header. */
  763. if (dev->hard_header(skb, dev, ntohs(ether_type), &dest_hw, NULL,
  764. skb->len) >= 0)
  765. ret = ether1394_type_trans(skb, dev);
  766. return ret;
  767. }
  768. static inline int fragment_overlap(struct list_head *frag_list, int offset, int len)
  769. {
  770. struct fragment_info *fi;
  771. list_for_each_entry(fi, frag_list, list) {
  772. if ( ! ((offset > (fi->offset + fi->len - 1)) ||
  773. ((offset + len - 1) < fi->offset)))
  774. return 1;
  775. }
  776. return 0;
  777. }
  778. static inline struct list_head *find_partial_datagram(struct list_head *pdgl, int dgl)
  779. {
  780. struct partial_datagram *pd;
  781. list_for_each_entry(pd, pdgl, list) {
  782. if (pd->dgl == dgl)
  783. return &pd->list;
  784. }
  785. return NULL;
  786. }
  787. /* Assumes that new fragment does not overlap any existing fragments */
  788. static inline int new_fragment(struct list_head *frag_info, int offset, int len)
  789. {
  790. struct list_head *lh;
  791. struct fragment_info *fi, *fi2, *new;
  792. list_for_each(lh, frag_info) {
  793. fi = list_entry(lh, struct fragment_info, list);
  794. if ((fi->offset + fi->len) == offset) {
  795. /* The new fragment can be tacked on to the end */
  796. fi->len += len;
  797. /* Did the new fragment plug a hole? */
  798. fi2 = list_entry(lh->next, struct fragment_info, list);
  799. if ((fi->offset + fi->len) == fi2->offset) {
  800. /* glue fragments together */
  801. fi->len += fi2->len;
  802. list_del(lh->next);
  803. kfree(fi2);
  804. }
  805. return 0;
  806. } else if ((offset + len) == fi->offset) {
  807. /* The new fragment can be tacked on to the beginning */
  808. fi->offset = offset;
  809. fi->len += len;
  810. /* Did the new fragment plug a hole? */
  811. fi2 = list_entry(lh->prev, struct fragment_info, list);
  812. if ((fi2->offset + fi2->len) == fi->offset) {
  813. /* glue fragments together */
  814. fi2->len += fi->len;
  815. list_del(lh);
  816. kfree(fi);
  817. }
  818. return 0;
  819. } else if (offset > (fi->offset + fi->len)) {
  820. break;
  821. } else if ((offset + len) < fi->offset) {
  822. lh = lh->prev;
  823. break;
  824. }
  825. }
  826. new = kmalloc(sizeof(*new), GFP_ATOMIC);
  827. if (!new)
  828. return -ENOMEM;
  829. new->offset = offset;
  830. new->len = len;
  831. list_add(&new->list, lh);
  832. return 0;
  833. }
  834. static inline int new_partial_datagram(struct net_device *dev,
  835. struct list_head *pdgl, int dgl,
  836. int dg_size, char *frag_buf,
  837. int frag_off, int frag_len)
  838. {
  839. struct partial_datagram *new;
  840. new = kmalloc(sizeof(*new), GFP_ATOMIC);
  841. if (!new)
  842. return -ENOMEM;
  843. INIT_LIST_HEAD(&new->frag_info);
  844. if (new_fragment(&new->frag_info, frag_off, frag_len) < 0) {
  845. kfree(new);
  846. return -ENOMEM;
  847. }
  848. new->dgl = dgl;
  849. new->dg_size = dg_size;
  850. new->skb = dev_alloc_skb(dg_size + dev->hard_header_len + 15);
  851. if (!new->skb) {
  852. struct fragment_info *fi = list_entry(new->frag_info.next,
  853. struct fragment_info,
  854. list);
  855. kfree(fi);
  856. kfree(new);
  857. return -ENOMEM;
  858. }
  859. skb_reserve(new->skb, (dev->hard_header_len + 15) & ~15);
  860. new->pbuf = skb_put(new->skb, dg_size);
  861. memcpy(new->pbuf + frag_off, frag_buf, frag_len);
  862. list_add(&new->list, pdgl);
  863. return 0;
  864. }
  865. static inline int update_partial_datagram(struct list_head *pdgl, struct list_head *lh,
  866. char *frag_buf, int frag_off, int frag_len)
  867. {
  868. struct partial_datagram *pd = list_entry(lh, struct partial_datagram, list);
  869. if (new_fragment(&pd->frag_info, frag_off, frag_len) < 0) {
  870. return -ENOMEM;
  871. }
  872. memcpy(pd->pbuf + frag_off, frag_buf, frag_len);
  873. /* Move list entry to beginnig of list so that oldest partial
  874. * datagrams percolate to the end of the list */
  875. list_move(lh, pdgl);
  876. return 0;
  877. }
  878. static inline int is_datagram_complete(struct list_head *lh, int dg_size)
  879. {
  880. struct partial_datagram *pd = list_entry(lh, struct partial_datagram, list);
  881. struct fragment_info *fi = list_entry(pd->frag_info.next,
  882. struct fragment_info, list);
  883. return (fi->len == dg_size);
  884. }
  885. /* Packet reception. We convert the IP1394 encapsulation header to an
  886. * ethernet header, and fill it with some of our other fields. This is
  887. * an incoming packet from the 1394 bus. */
  888. static int ether1394_data_handler(struct net_device *dev, int srcid, int destid,
  889. char *buf, int len)
  890. {
  891. struct sk_buff *skb;
  892. unsigned long flags;
  893. struct eth1394_priv *priv = netdev_priv(dev);
  894. union eth1394_hdr *hdr = (union eth1394_hdr *)buf;
  895. u16 ether_type = 0; /* initialized to clear warning */
  896. int hdr_len;
  897. struct unit_directory *ud = priv->ud_list[NODEID_TO_NODE(srcid)];
  898. struct eth1394_node_info *node_info;
  899. if (!ud) {
  900. struct eth1394_node_ref *node;
  901. node = eth1394_find_node_nodeid(&priv->ip_node_list, srcid);
  902. if (!node) {
  903. HPSB_PRINT(KERN_ERR, "ether1394 rx: sender nodeid "
  904. "lookup failure: " NODE_BUS_FMT,
  905. NODE_BUS_ARGS(priv->host, srcid));
  906. priv->stats.rx_dropped++;
  907. return -1;
  908. }
  909. ud = node->ud;
  910. priv->ud_list[NODEID_TO_NODE(srcid)] = ud;
  911. }
  912. node_info = (struct eth1394_node_info*)ud->device.driver_data;
  913. /* First, did we receive a fragmented or unfragmented datagram? */
  914. hdr->words.word1 = ntohs(hdr->words.word1);
  915. hdr_len = hdr_type_len[hdr->common.lf];
  916. if (hdr->common.lf == ETH1394_HDR_LF_UF) {
  917. /* An unfragmented datagram has been received by the ieee1394
  918. * bus. Build an skbuff around it so we can pass it to the
  919. * high level network layer. */
  920. skb = dev_alloc_skb(len + dev->hard_header_len + 15);
  921. if (!skb) {
  922. HPSB_PRINT (KERN_ERR, "ether1394 rx: low on mem\n");
  923. priv->stats.rx_dropped++;
  924. return -1;
  925. }
  926. skb_reserve(skb, (dev->hard_header_len + 15) & ~15);
  927. memcpy(skb_put(skb, len - hdr_len), buf + hdr_len, len - hdr_len);
  928. ether_type = hdr->uf.ether_type;
  929. } else {
  930. /* A datagram fragment has been received, now the fun begins. */
  931. struct list_head *pdgl, *lh;
  932. struct partial_datagram *pd;
  933. int fg_off;
  934. int fg_len = len - hdr_len;
  935. int dg_size;
  936. int dgl;
  937. int retval;
  938. struct pdg_list *pdg = &(node_info->pdg);
  939. hdr->words.word3 = ntohs(hdr->words.word3);
  940. /* The 4th header word is reserved so no need to do ntohs() */
  941. if (hdr->common.lf == ETH1394_HDR_LF_FF) {
  942. ether_type = hdr->ff.ether_type;
  943. dgl = hdr->ff.dgl;
  944. dg_size = hdr->ff.dg_size + 1;
  945. fg_off = 0;
  946. } else {
  947. hdr->words.word2 = ntohs(hdr->words.word2);
  948. dgl = hdr->sf.dgl;
  949. dg_size = hdr->sf.dg_size + 1;
  950. fg_off = hdr->sf.fg_off;
  951. }
  952. spin_lock_irqsave(&pdg->lock, flags);
  953. pdgl = &(pdg->list);
  954. lh = find_partial_datagram(pdgl, dgl);
  955. if (lh == NULL) {
  956. while (pdg->sz >= max_partial_datagrams) {
  957. /* remove the oldest */
  958. purge_partial_datagram(pdgl->prev);
  959. pdg->sz--;
  960. }
  961. retval = new_partial_datagram(dev, pdgl, dgl, dg_size,
  962. buf + hdr_len, fg_off,
  963. fg_len);
  964. if (retval < 0) {
  965. spin_unlock_irqrestore(&pdg->lock, flags);
  966. goto bad_proto;
  967. }
  968. pdg->sz++;
  969. lh = find_partial_datagram(pdgl, dgl);
  970. } else {
  971. struct partial_datagram *pd;
  972. pd = list_entry(lh, struct partial_datagram, list);
  973. if (fragment_overlap(&pd->frag_info, fg_off, fg_len)) {
  974. /* Overlapping fragments, obliterate old
  975. * datagram and start new one. */
  976. purge_partial_datagram(lh);
  977. retval = new_partial_datagram(dev, pdgl, dgl,
  978. dg_size,
  979. buf + hdr_len,
  980. fg_off, fg_len);
  981. if (retval < 0) {
  982. pdg->sz--;
  983. spin_unlock_irqrestore(&pdg->lock, flags);
  984. goto bad_proto;
  985. }
  986. } else {
  987. retval = update_partial_datagram(pdgl, lh,
  988. buf + hdr_len,
  989. fg_off, fg_len);
  990. if (retval < 0) {
  991. /* Couldn't save off fragment anyway
  992. * so might as well obliterate the
  993. * datagram now. */
  994. purge_partial_datagram(lh);
  995. pdg->sz--;
  996. spin_unlock_irqrestore(&pdg->lock, flags);
  997. goto bad_proto;
  998. }
  999. } /* fragment overlap */
  1000. } /* new datagram or add to existing one */
  1001. pd = list_entry(lh, struct partial_datagram, list);
  1002. if (hdr->common.lf == ETH1394_HDR_LF_FF) {
  1003. pd->ether_type = ether_type;
  1004. }
  1005. if (is_datagram_complete(lh, dg_size)) {
  1006. ether_type = pd->ether_type;
  1007. pdg->sz--;
  1008. skb = skb_get(pd->skb);
  1009. purge_partial_datagram(lh);
  1010. spin_unlock_irqrestore(&pdg->lock, flags);
  1011. } else {
  1012. /* Datagram is not complete, we're done for the
  1013. * moment. */
  1014. spin_unlock_irqrestore(&pdg->lock, flags);
  1015. return 0;
  1016. }
  1017. } /* unframgented datagram or fragmented one */
  1018. /* Write metadata, and then pass to the receive level */
  1019. skb->dev = dev;
  1020. skb->ip_summed = CHECKSUM_UNNECESSARY; /* don't check it */
  1021. /* Parse the encapsulation header. This actually does the job of
  1022. * converting to an ethernet frame header, aswell as arp
  1023. * conversion if needed. ARP conversion is easier in this
  1024. * direction, since we are using ethernet as our backend. */
  1025. skb->protocol = ether1394_parse_encap(skb, dev, srcid, destid,
  1026. ether_type);
  1027. spin_lock_irqsave(&priv->lock, flags);
  1028. if (!skb->protocol) {
  1029. priv->stats.rx_errors++;
  1030. priv->stats.rx_dropped++;
  1031. dev_kfree_skb_any(skb);
  1032. goto bad_proto;
  1033. }
  1034. if (netif_rx(skb) == NET_RX_DROP) {
  1035. priv->stats.rx_errors++;
  1036. priv->stats.rx_dropped++;
  1037. goto bad_proto;
  1038. }
  1039. /* Statistics */
  1040. priv->stats.rx_packets++;
  1041. priv->stats.rx_bytes += skb->len;
  1042. bad_proto:
  1043. if (netif_queue_stopped(dev))
  1044. netif_wake_queue(dev);
  1045. spin_unlock_irqrestore(&priv->lock, flags);
  1046. dev->last_rx = jiffies;
  1047. return 0;
  1048. }
  1049. static int ether1394_write(struct hpsb_host *host, int srcid, int destid,
  1050. quadlet_t *data, u64 addr, size_t len, u16 flags)
  1051. {
  1052. struct eth1394_host_info *hi;
  1053. hi = hpsb_get_hostinfo(&eth1394_highlevel, host);
  1054. if (hi == NULL) {
  1055. ETH1394_PRINT_G(KERN_ERR, "Could not find net device for host %s\n",
  1056. host->driver->name);
  1057. return RCODE_ADDRESS_ERROR;
  1058. }
  1059. if (ether1394_data_handler(hi->dev, srcid, destid, (char*)data, len))
  1060. return RCODE_ADDRESS_ERROR;
  1061. else
  1062. return RCODE_COMPLETE;
  1063. }
  1064. static void ether1394_iso(struct hpsb_iso *iso)
  1065. {
  1066. quadlet_t *data;
  1067. char *buf;
  1068. struct eth1394_host_info *hi;
  1069. struct net_device *dev;
  1070. struct eth1394_priv *priv;
  1071. unsigned int len;
  1072. u32 specifier_id;
  1073. u16 source_id;
  1074. int i;
  1075. int nready;
  1076. hi = hpsb_get_hostinfo(&eth1394_highlevel, iso->host);
  1077. if (hi == NULL) {
  1078. ETH1394_PRINT_G(KERN_ERR, "Could not find net device for host %s\n",
  1079. iso->host->driver->name);
  1080. return;
  1081. }
  1082. dev = hi->dev;
  1083. nready = hpsb_iso_n_ready(iso);
  1084. for (i = 0; i < nready; i++) {
  1085. struct hpsb_iso_packet_info *info =
  1086. &iso->infos[(iso->first_packet + i) % iso->buf_packets];
  1087. data = (quadlet_t*) (iso->data_buf.kvirt + info->offset);
  1088. /* skip over GASP header */
  1089. buf = (char *)data + 8;
  1090. len = info->len - 8;
  1091. specifier_id = (((be32_to_cpu(data[0]) & 0xffff) << 8) |
  1092. ((be32_to_cpu(data[1]) & 0xff000000) >> 24));
  1093. source_id = be32_to_cpu(data[0]) >> 16;
  1094. priv = netdev_priv(dev);
  1095. if (info->channel != (iso->host->csr.broadcast_channel & 0x3f) ||
  1096. specifier_id != ETHER1394_GASP_SPECIFIER_ID) {
  1097. /* This packet is not for us */
  1098. continue;
  1099. }
  1100. ether1394_data_handler(dev, source_id, LOCAL_BUS | ALL_NODES,
  1101. buf, len);
  1102. }
  1103. hpsb_iso_recv_release_packets(iso, i);
  1104. dev->last_rx = jiffies;
  1105. }
  1106. /******************************************
  1107. * Datagram transmission code
  1108. ******************************************/
  1109. /* Convert a standard ARP packet to 1394 ARP. The first 8 bytes (the entire
  1110. * arphdr) is the same format as the ip1394 header, so they overlap. The rest
  1111. * needs to be munged a bit. The remainder of the arphdr is formatted based
  1112. * on hwaddr len and ipaddr len. We know what they'll be, so it's easy to
  1113. * judge.
  1114. *
  1115. * Now that the EUI is used for the hardware address all we need to do to make
  1116. * this work for 1394 is to insert 2 quadlets that contain max_rec size,
  1117. * speed, and unicast FIFO address information between the sender_unique_id
  1118. * and the IP addresses.
  1119. */
  1120. static inline void ether1394_arp_to_1394arp(struct sk_buff *skb,
  1121. struct net_device *dev)
  1122. {
  1123. struct eth1394_priv *priv = netdev_priv(dev);
  1124. struct arphdr *arp = (struct arphdr *)skb->data;
  1125. unsigned char *arp_ptr = (unsigned char *)(arp + 1);
  1126. struct eth1394_arp *arp1394 = (struct eth1394_arp *)skb->data;
  1127. /* Believe it or not, all that need to happen is sender IP get moved
  1128. * and set hw_addr_len, max_rec, sspd, fifo_hi and fifo_lo. */
  1129. arp1394->hw_addr_len = 16;
  1130. arp1394->sip = *(u32*)(arp_ptr + ETH1394_ALEN);
  1131. arp1394->max_rec = priv->host->csr.max_rec;
  1132. arp1394->sspd = priv->host->csr.lnk_spd;
  1133. arp1394->fifo_hi = htons (priv->local_fifo >> 32);
  1134. arp1394->fifo_lo = htonl (priv->local_fifo & ~0x0);
  1135. return;
  1136. }
  1137. /* We need to encapsulate the standard header with our own. We use the
  1138. * ethernet header's proto for our own. */
  1139. static inline unsigned int ether1394_encapsulate_prep(unsigned int max_payload,
  1140. __be16 proto,
  1141. union eth1394_hdr *hdr,
  1142. u16 dg_size, u16 dgl)
  1143. {
  1144. unsigned int adj_max_payload = max_payload - hdr_type_len[ETH1394_HDR_LF_UF];
  1145. /* Does it all fit in one packet? */
  1146. if (dg_size <= adj_max_payload) {
  1147. hdr->uf.lf = ETH1394_HDR_LF_UF;
  1148. hdr->uf.ether_type = proto;
  1149. } else {
  1150. hdr->ff.lf = ETH1394_HDR_LF_FF;
  1151. hdr->ff.ether_type = proto;
  1152. hdr->ff.dg_size = dg_size - 1;
  1153. hdr->ff.dgl = dgl;
  1154. adj_max_payload = max_payload - hdr_type_len[ETH1394_HDR_LF_FF];
  1155. }
  1156. return((dg_size + (adj_max_payload - 1)) / adj_max_payload);
  1157. }
  1158. static inline unsigned int ether1394_encapsulate(struct sk_buff *skb,
  1159. unsigned int max_payload,
  1160. union eth1394_hdr *hdr)
  1161. {
  1162. union eth1394_hdr *bufhdr;
  1163. int ftype = hdr->common.lf;
  1164. int hdrsz = hdr_type_len[ftype];
  1165. unsigned int adj_max_payload = max_payload - hdrsz;
  1166. switch(ftype) {
  1167. case ETH1394_HDR_LF_UF:
  1168. bufhdr = (union eth1394_hdr *)skb_push(skb, hdrsz);
  1169. bufhdr->words.word1 = htons(hdr->words.word1);
  1170. bufhdr->words.word2 = hdr->words.word2;
  1171. break;
  1172. case ETH1394_HDR_LF_FF:
  1173. bufhdr = (union eth1394_hdr *)skb_push(skb, hdrsz);
  1174. bufhdr->words.word1 = htons(hdr->words.word1);
  1175. bufhdr->words.word2 = hdr->words.word2;
  1176. bufhdr->words.word3 = htons(hdr->words.word3);
  1177. bufhdr->words.word4 = 0;
  1178. /* Set frag type here for future interior fragments */
  1179. hdr->common.lf = ETH1394_HDR_LF_IF;
  1180. hdr->sf.fg_off = 0;
  1181. break;
  1182. default:
  1183. hdr->sf.fg_off += adj_max_payload;
  1184. bufhdr = (union eth1394_hdr *)skb_pull(skb, adj_max_payload);
  1185. if (max_payload >= skb->len)
  1186. hdr->common.lf = ETH1394_HDR_LF_LF;
  1187. bufhdr->words.word1 = htons(hdr->words.word1);
  1188. bufhdr->words.word2 = htons(hdr->words.word2);
  1189. bufhdr->words.word3 = htons(hdr->words.word3);
  1190. bufhdr->words.word4 = 0;
  1191. }
  1192. return min(max_payload, skb->len);
  1193. }
  1194. static inline struct hpsb_packet *ether1394_alloc_common_packet(struct hpsb_host *host)
  1195. {
  1196. struct hpsb_packet *p;
  1197. p = hpsb_alloc_packet(0);
  1198. if (p) {
  1199. p->host = host;
  1200. p->generation = get_hpsb_generation(host);
  1201. p->type = hpsb_async;
  1202. }
  1203. return p;
  1204. }
  1205. static inline int ether1394_prep_write_packet(struct hpsb_packet *p,
  1206. struct hpsb_host *host,
  1207. nodeid_t node, u64 addr,
  1208. void * data, int tx_len)
  1209. {
  1210. p->node_id = node;
  1211. p->data = NULL;
  1212. p->tcode = TCODE_WRITEB;
  1213. p->header[1] = (host->node_id << 16) | (addr >> 32);
  1214. p->header[2] = addr & 0xffffffff;
  1215. p->header_size = 16;
  1216. p->expect_response = 1;
  1217. if (hpsb_get_tlabel(p)) {
  1218. ETH1394_PRINT_G(KERN_ERR, "No more tlabels left while sending "
  1219. "to node " NODE_BUS_FMT "\n", NODE_BUS_ARGS(host, node));
  1220. return -1;
  1221. }
  1222. p->header[0] = (p->node_id << 16) | (p->tlabel << 10)
  1223. | (1 << 8) | (TCODE_WRITEB << 4);
  1224. p->header[3] = tx_len << 16;
  1225. p->data_size = (tx_len + 3) & ~3;
  1226. p->data = (quadlet_t*)data;
  1227. return 0;
  1228. }
  1229. static inline void ether1394_prep_gasp_packet(struct hpsb_packet *p,
  1230. struct eth1394_priv *priv,
  1231. struct sk_buff *skb, int length)
  1232. {
  1233. p->header_size = 4;
  1234. p->tcode = TCODE_STREAM_DATA;
  1235. p->header[0] = (length << 16) | (3 << 14)
  1236. | ((priv->broadcast_channel) << 8)
  1237. | (TCODE_STREAM_DATA << 4);
  1238. p->data_size = length;
  1239. p->data = ((quadlet_t*)skb->data) - 2;
  1240. p->data[0] = cpu_to_be32((priv->host->node_id << 16) |
  1241. ETHER1394_GASP_SPECIFIER_ID_HI);
  1242. p->data[1] = cpu_to_be32((ETHER1394_GASP_SPECIFIER_ID_LO << 24) |
  1243. ETHER1394_GASP_VERSION);
  1244. /* Setting the node id to ALL_NODES (not LOCAL_BUS | ALL_NODES)
  1245. * prevents hpsb_send_packet() from setting the speed to an arbitrary
  1246. * value based on packet->node_id if packet->node_id is not set. */
  1247. p->node_id = ALL_NODES;
  1248. p->speed_code = priv->bc_sspd;
  1249. }
  1250. static inline void ether1394_free_packet(struct hpsb_packet *packet)
  1251. {
  1252. if (packet->tcode != TCODE_STREAM_DATA)
  1253. hpsb_free_tlabel(packet);
  1254. hpsb_free_packet(packet);
  1255. }
  1256. static void ether1394_complete_cb(void *__ptask);
  1257. static int ether1394_send_packet(struct packet_task *ptask, unsigned int tx_len)
  1258. {
  1259. struct eth1394_priv *priv = ptask->priv;
  1260. struct hpsb_packet *packet = NULL;
  1261. packet = ether1394_alloc_common_packet(priv->host);
  1262. if (!packet)
  1263. return -1;
  1264. if (ptask->tx_type == ETH1394_GASP) {
  1265. int length = tx_len + (2 * sizeof(quadlet_t));
  1266. ether1394_prep_gasp_packet(packet, priv, ptask->skb, length);
  1267. } else if (ether1394_prep_write_packet(packet, priv->host,
  1268. ptask->dest_node,
  1269. ptask->addr, ptask->skb->data,
  1270. tx_len)) {
  1271. hpsb_free_packet(packet);
  1272. return -1;
  1273. }
  1274. ptask->packet = packet;
  1275. hpsb_set_packet_complete_task(ptask->packet, ether1394_complete_cb,
  1276. ptask);
  1277. if (hpsb_send_packet(packet) < 0) {
  1278. ether1394_free_packet(packet);
  1279. return -1;
  1280. }
  1281. return 0;
  1282. }
  1283. /* Task function to be run when a datagram transmission is completed */
  1284. static inline void ether1394_dg_complete(struct packet_task *ptask, int fail)
  1285. {
  1286. struct sk_buff *skb = ptask->skb;
  1287. struct net_device *dev = skb->dev;
  1288. struct eth1394_priv *priv = netdev_priv(dev);
  1289. unsigned long flags;
  1290. /* Statistics */
  1291. spin_lock_irqsave(&priv->lock, flags);
  1292. if (fail) {
  1293. priv->stats.tx_dropped++;
  1294. priv->stats.tx_errors++;
  1295. } else {
  1296. priv->stats.tx_bytes += skb->len;
  1297. priv->stats.tx_packets++;
  1298. }
  1299. spin_unlock_irqrestore(&priv->lock, flags);
  1300. dev_kfree_skb_any(skb);
  1301. kmem_cache_free(packet_task_cache, ptask);
  1302. }
  1303. /* Callback for when a packet has been sent and the status of that packet is
  1304. * known */
  1305. static void ether1394_complete_cb(void *__ptask)
  1306. {
  1307. struct packet_task *ptask = (struct packet_task *)__ptask;
  1308. struct hpsb_packet *packet = ptask->packet;
  1309. int fail = 0;
  1310. if (packet->tcode != TCODE_STREAM_DATA)
  1311. fail = hpsb_packet_success(packet);
  1312. ether1394_free_packet(packet);
  1313. ptask->outstanding_pkts--;
  1314. if (ptask->outstanding_pkts > 0 && !fail) {
  1315. int tx_len;
  1316. /* Add the encapsulation header to the fragment */
  1317. tx_len = ether1394_encapsulate(ptask->skb, ptask->max_payload,
  1318. &ptask->hdr);
  1319. if (ether1394_send_packet(ptask, tx_len))
  1320. ether1394_dg_complete(ptask, 1);
  1321. } else {
  1322. ether1394_dg_complete(ptask, fail);
  1323. }
  1324. }
  1325. /* Transmit a packet (called by kernel) */
  1326. static int ether1394_tx (struct sk_buff *skb, struct net_device *dev)
  1327. {
  1328. gfp_t kmflags = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;
  1329. struct eth1394hdr *eth;
  1330. struct eth1394_priv *priv = netdev_priv(dev);
  1331. __be16 proto;
  1332. unsigned long flags;
  1333. nodeid_t dest_node;
  1334. eth1394_tx_type tx_type;
  1335. int ret = 0;
  1336. unsigned int tx_len;
  1337. unsigned int max_payload;
  1338. u16 dg_size;
  1339. u16 dgl;
  1340. struct packet_task *ptask;
  1341. struct eth1394_node_ref *node;
  1342. struct eth1394_node_info *node_info = NULL;
  1343. ptask = kmem_cache_alloc(packet_task_cache, kmflags);
  1344. if (ptask == NULL) {
  1345. ret = -ENOMEM;
  1346. goto fail;
  1347. }
  1348. /* XXX Ignore this for now. Noticed that when MacOSX is the IRM,
  1349. * it does not set our validity bit. We need to compensate for
  1350. * that somewhere else, but not in eth1394. */
  1351. #if 0
  1352. if ((priv->host->csr.broadcast_channel & 0xc0000000) != 0xc0000000) {
  1353. ret = -EAGAIN;
  1354. goto fail;
  1355. }
  1356. #endif
  1357. if ((skb = skb_share_check (skb, kmflags)) == NULL) {
  1358. ret = -ENOMEM;
  1359. goto fail;
  1360. }
  1361. /* Get rid of the fake eth1394 header, but save a pointer */
  1362. eth = (struct eth1394hdr*)skb->data;
  1363. skb_pull(skb, ETH1394_HLEN);
  1364. proto = eth->h_proto;
  1365. dg_size = skb->len;
  1366. /* Set the transmission type for the packet. ARP packets and IP
  1367. * broadcast packets are sent via GASP. */
  1368. if (memcmp(eth->h_dest, dev->broadcast, ETH1394_ALEN) == 0 ||
  1369. proto == htons(ETH_P_ARP) ||
  1370. (proto == htons(ETH_P_IP) &&
  1371. IN_MULTICAST(ntohl(skb->nh.iph->daddr)))) {
  1372. tx_type = ETH1394_GASP;
  1373. dest_node = LOCAL_BUS | ALL_NODES;
  1374. max_payload = priv->bc_maxpayload - ETHER1394_GASP_OVERHEAD;
  1375. BUG_ON(max_payload < (512 - ETHER1394_GASP_OVERHEAD));
  1376. dgl = priv->bc_dgl;
  1377. if (max_payload < dg_size + hdr_type_len[ETH1394_HDR_LF_UF])
  1378. priv->bc_dgl++;
  1379. } else {
  1380. node = eth1394_find_node_guid(&priv->ip_node_list,
  1381. be64_to_cpu(*(u64*)eth->h_dest));
  1382. if (!node) {
  1383. ret = -EAGAIN;
  1384. goto fail;
  1385. }
  1386. node_info = (struct eth1394_node_info*)node->ud->device.driver_data;
  1387. if (node_info->fifo == CSR1212_INVALID_ADDR_SPACE) {
  1388. ret = -EAGAIN;
  1389. goto fail;
  1390. }
  1391. dest_node = node->ud->ne->nodeid;
  1392. max_payload = node_info->maxpayload;
  1393. BUG_ON(max_payload < (512 - ETHER1394_GASP_OVERHEAD));
  1394. dgl = node_info->dgl;
  1395. if (max_payload < dg_size + hdr_type_len[ETH1394_HDR_LF_UF])
  1396. node_info->dgl++;
  1397. tx_type = ETH1394_WRREQ;
  1398. }
  1399. /* If this is an ARP packet, convert it */
  1400. if (proto == htons(ETH_P_ARP))
  1401. ether1394_arp_to_1394arp (skb, dev);
  1402. ptask->hdr.words.word1 = 0;
  1403. ptask->hdr.words.word2 = 0;
  1404. ptask->hdr.words.word3 = 0;
  1405. ptask->hdr.words.word4 = 0;
  1406. ptask->skb = skb;
  1407. ptask->priv = priv;
  1408. ptask->tx_type = tx_type;
  1409. if (tx_type != ETH1394_GASP) {
  1410. u64 addr;
  1411. spin_lock_irqsave(&priv->lock, flags);
  1412. addr = node_info->fifo;
  1413. spin_unlock_irqrestore(&priv->lock, flags);
  1414. ptask->addr = addr;
  1415. ptask->dest_node = dest_node;
  1416. }
  1417. ptask->tx_type = tx_type;
  1418. ptask->max_payload = max_payload;
  1419. ptask->outstanding_pkts = ether1394_encapsulate_prep(max_payload, proto,
  1420. &ptask->hdr, dg_size,
  1421. dgl);
  1422. /* Add the encapsulation header to the fragment */
  1423. tx_len = ether1394_encapsulate(skb, max_payload, &ptask->hdr);
  1424. dev->trans_start = jiffies;
  1425. if (ether1394_send_packet(ptask, tx_len))
  1426. goto fail;
  1427. netif_wake_queue(dev);
  1428. return 0;
  1429. fail:
  1430. if (ptask)
  1431. kmem_cache_free(packet_task_cache, ptask);
  1432. if (skb != NULL)
  1433. dev_kfree_skb(skb);
  1434. spin_lock_irqsave (&priv->lock, flags);
  1435. priv->stats.tx_dropped++;
  1436. priv->stats.tx_errors++;
  1437. spin_unlock_irqrestore (&priv->lock, flags);
  1438. if (netif_queue_stopped(dev))
  1439. netif_wake_queue(dev);
  1440. return 0; /* returning non-zero causes serious problems */
  1441. }
  1442. static void ether1394_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
  1443. {
  1444. strcpy (info->driver, driver_name);
  1445. /* FIXME XXX provide sane businfo */
  1446. strcpy (info->bus_info, "ieee1394");
  1447. }
  1448. static struct ethtool_ops ethtool_ops = {
  1449. .get_drvinfo = ether1394_get_drvinfo
  1450. };
  1451. static int __init ether1394_init_module (void)
  1452. {
  1453. packet_task_cache = kmem_cache_create("packet_task", sizeof(struct packet_task),
  1454. 0, 0, NULL, NULL);
  1455. /* Register ourselves as a highlevel driver */
  1456. hpsb_register_highlevel(&eth1394_highlevel);
  1457. return hpsb_register_protocol(&eth1394_proto_driver);
  1458. }
  1459. static void __exit ether1394_exit_module (void)
  1460. {
  1461. hpsb_unregister_protocol(&eth1394_proto_driver);
  1462. hpsb_unregister_highlevel(&eth1394_highlevel);
  1463. kmem_cache_destroy(packet_task_cache);
  1464. }
  1465. module_init(ether1394_init_module);
  1466. module_exit(ether1394_exit_module);