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

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

嵌入式Linux

开发平台：

Unix_Linux

ieee1394_core.c：源码内容
  1. /*
  2.  * IEEE 1394 for Linux
  3.  *
  4.  * Core support: hpsb_packet management, packet handling and forwarding to
  5.  *               highlevel or lowlevel code
  6.  *
  7.  * Copyright (C) 1999, 2000 Andreas E. Bombe
  8.  *
  9.  * This code is licensed under the GPL.  See the file COPYING in the root
  10.  * directory of the kernel sources for details.
  11.  */
  13. #include <linux/config.h>
  14. #include <linux/kernel.h>
  15. #include <linux/list.h>
  16. #include <linux/string.h>
  17. #include <linux/init.h>
  18. #include <linux/slab.h>
  19. #include <linux/interrupt.h>
  20. #include <linux/module.h>
  21. #include <asm/bitops.h>
  22. #include <asm/byteorder.h>
  23. #include <asm/semaphore.h>
  25. #include "ieee1394_types.h"
  26. #include "ieee1394.h"
  27. #include "hosts.h"
  28. #include "ieee1394_core.h"
  29. #include "highlevel.h"
  30. #include "ieee1394_transactions.h"
  31. #include "csr.h"
  32. #include "nodemgr.h"
  33. #include "ieee1394_hotplug.h"
  35. /*
  36.  * Disable the nodemgr detection and config rom reading functionality.
  37.  */
  38. MODULE_PARM(disable_nodemgr, "i");
  39. MODULE_PARM_DESC(disable_nodemgr, "Disable nodemgr functionality.");
  40. static int disable_nodemgr = 0;
  42. /* We are GPL, so treat us special */
  43. MODULE_LICENSE("GPL");
  45. static kmem_cache_t *hpsb_packet_cache;
  47. /* Some globals used */
  48. const char *hpsb_speedto_str[] = { "S100", "S200", "S400" };
  50. static void dump_packet(const char *text, quadlet_t *data, int size)
  51. {
  52.         int i;
  54.         size /= 4;
  55.         size = (size > 4 ? 4 : size);
  57.         printk(KERN_DEBUG "ieee1394: %s", text);
  58.         for (i = 0; i < size; i++) {
  59.                 printk(" %8.8x", data[i]);
  60.         }
  61.         printk("n");
  62. }
  65. /**
  66.  * alloc_hpsb_packet - allocate new packet structure
  67.  * @data_size: size of the data block to be allocated
  68.  *
  69.  * This function allocates, initializes and returns a new &struct hpsb_packet.
  70.  * It can be used in interrupt context.  A header block is always included, its
  71.  * size is big enough to contain all possible 1394 headers.  The data block is
  72.  * only allocated when @data_size is not zero.
  73.  *
  74.  * For packets for which responses will be received the @data_size has to be big
  75.  * enough to contain the response's data block since no further allocation
  76.  * occurs at response matching time.
  77.  *
  78.  * The packet's generation value will be set to the current generation number
  79.  * for ease of use.  Remember to overwrite it with your own recorded generation
  80.  * number if you can not be sure that your code will not race with a bus reset.
  81.  *
  82.  * Return value: A pointer to a &struct hpsb_packet or NULL on allocation
  83.  * failure.
  84.  */
  85. struct hpsb_packet *alloc_hpsb_packet(size_t data_size)
  86. {
  87.         struct hpsb_packet *packet = NULL;
  88.         void *data = NULL;
  89.         int kmflags = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;
  91.         packet = kmem_cache_alloc(hpsb_packet_cache, kmflags);
  92.         if (packet == NULL)
  93.                 return NULL;
  95.         memset(packet, 0, sizeof(struct hpsb_packet));
  96.         packet->header = packet->embedded_header;
  98.         if (data_size) {
  99.                 data = kmalloc(data_size + 8, kmflags);
  100.                 if (data == NULL) {
  101. kmem_cache_free(hpsb_packet_cache, packet);
  102.                         return NULL;
  103.                 }
  105.                 packet->data = data;
  106.                 packet->data_size = data_size;
  107.         }
  109.         INIT_TQ_HEAD(packet->complete_tq);
  110.         INIT_LIST_HEAD(&packet->list);
  111.         sema_init(&packet->state_change, 0);
  112.         packet->state = hpsb_unused;
  113.         packet->generation = -1;
  114.         packet->data_be = 1;
  116.         return packet;
  117. }
  120. /**
  121.  * free_hpsb_packet - free packet and data associated with it
  122.  * @packet: packet to free (is NULL safe)
  123.  *
  124.  * This function will free packet->data, packet->header and finally the packet
  125.  * itself.
  126.  */
  127. void free_hpsb_packet(struct hpsb_packet *packet)
  128. {
  129.         if (!packet) return;
  131.         kfree(packet->data);
  132.         kmem_cache_free(hpsb_packet_cache, packet);
  133. }
  136. int hpsb_reset_bus(struct hpsb_host *host, int type)
  137. {
  138.         if (!host->initialized) {
  139.                 return 1;
  140.         }
  142.         if (!host->in_bus_reset) {
  143.                 host->template->devctl(host, RESET_BUS, type);
  144.                 return 0;
  145.         } else {
  146.                 return 1;
  147.         }
  148. }
  151. int hpsb_bus_reset(struct hpsb_host *host)
  152. {
  153.         if (host->in_bus_reset) {
  154.                 HPSB_NOTICE(__FUNCTION__ 
  155.                             " called while bus reset already in progress");
  156.                 return 1;
  157.         }
  159.         abort_requests(host);
  160.         host->in_bus_reset = 1;
  161.         host->irm_id = -1;
  162.         host->busmgr_id = -1;
  163.         host->node_count = 0;
  164.         host->selfid_count = 0;
  166.         return 0;
  167. }
  170. /*
  171.  * Verify num_of_selfids SelfIDs and return number of nodes.  Return zero in
  172.  * case verification failed.
  173.  */
  174. static int check_selfids(struct hpsb_host *host, unsigned int num_of_selfids)
  175. {
  176.         int nodeid = -1;
  177.         int rest_of_selfids = num_of_selfids;
  178.         struct selfid *sid = (struct selfid *)host->topology_map;
  179.         struct ext_selfid *esid;
  180.         int esid_seq = 23;
  182.         while (rest_of_selfids--) {
  183.                 if (!sid->extended) {
  184.                         nodeid++;
  185.                         esid_seq = 0;
  186.                         
  187.                         if (sid->phy_id != nodeid) {
  188.                                 HPSB_INFO("SelfIDs failed monotony check with "
  189.                                           "%d", sid->phy_id);
  190.                                 return 0;
  191.                         }
  192.                         
  193.                         if (sid->contender && sid->link_active) {
  194.                                 host->irm_id = LOCAL_BUS | sid->phy_id;
  195.                         }
  196.                 } else {
  197.                         esid = (struct ext_selfid *)sid;
  199.                         if ((esid->phy_id != nodeid) 
  200.                             || (esid->seq_nr != esid_seq)) {
  201.                                 HPSB_INFO("SelfIDs failed monotony check with "
  202.                                           "%d/%d", esid->phy_id, esid->seq_nr);
  203.                                 return 0;
  204.                         }
  205.                         esid_seq++;
  206.                 }
  207.                 sid++;
  208.         }
  209.         
  210.         esid = (struct ext_selfid *)(sid - 1);
  211.         while (esid->extended) {
  212.                 if ((esid->porta == 0x2) || (esid->portb == 0x2)
  213.                     || (esid->portc == 0x2) || (esid->portd == 0x2)
  214.                     || (esid->porte == 0x2) || (esid->portf == 0x2)
  215.                     || (esid->portg == 0x2) || (esid->porth == 0x2)) {
  216.                                 HPSB_INFO("SelfIDs failed root check on "
  217.                                           "extended SelfID");
  218.                                 return 0;
  219.                 }
  220.                 esid--;
  221.         }
  223.         sid = (struct selfid *)esid;
  224.         if ((sid->port0 == 0x2) || (sid->port1 == 0x2) || (sid->port2 == 0x2)) {
  225.                         HPSB_INFO("SelfIDs failed root check");
  226.                         return 0;
  227.         }
  229.         return nodeid + 1;
  230. }
  232. static void build_speed_map(struct hpsb_host *host, int nodecount)
  233. {
  234.         char speedcap[nodecount];
  235.         char cldcnt[nodecount];
  236.         u8 *map = host->speed_map;
  237.         struct selfid *sid;
  238.         struct ext_selfid *esid;
  239.         int i, j, n;
  241.         for (i = 0; i < (nodecount * 64); i += 64) {
  242.                 for (j = 0; j < nodecount; j++) {
  243.                         map[i+j] = SPEED_400;
  244.                 }
  245.         }
  247.         for (i = 0; i < nodecount; i++) {
  248.                 cldcnt[i] = 0;
  249.         }
  251.         /* find direct children count and speed */
  252.         for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1],
  253.                      n = nodecount - 1;
  254.              (void *)sid >= (void *)host->topology_map; sid--) {
  255.                 if (sid->extended) {
  256.                         esid = (struct ext_selfid *)sid;
  258.                         if (esid->porta == 0x3) cldcnt[n]++;
  259.                         if (esid->portb == 0x3) cldcnt[n]++;
  260.                         if (esid->portc == 0x3) cldcnt[n]++;
  261.                         if (esid->portd == 0x3) cldcnt[n]++;
  262.                         if (esid->porte == 0x3) cldcnt[n]++;
  263.                         if (esid->portf == 0x3) cldcnt[n]++;
  264.                         if (esid->portg == 0x3) cldcnt[n]++;
  265.                         if (esid->porth == 0x3) cldcnt[n]++;
  266.                 } else {
  267.                         if (sid->port0 == 0x3) cldcnt[n]++;
  268.                         if (sid->port1 == 0x3) cldcnt[n]++;
  269.                         if (sid->port2 == 0x3) cldcnt[n]++;
  271.                         speedcap[n] = sid->speed;
  272.                         n--;
  273.                 }
  274.         }
  276.         /* set self mapping */
  277.         for (i = 0; i < nodecount; i++) {
  278.                 map[64*i + i] = speedcap[i];
  279.         }
  281.         /* fix up direct children count to total children count;
  282.          * also fix up speedcaps for sibling and parent communication */
  283.         for (i = 1; i < nodecount; i++) {
  284.                 for (j = cldcnt[i], n = i - 1; j > 0; j--) {
  285.                         cldcnt[i] += cldcnt[n];
  286.                         speedcap[n] = MIN(speedcap[n], speedcap[i]);
  287.                         n -= cldcnt[n] + 1;
  288.                 }
  289.         }
  291.         for (n = 0; n < nodecount; n++) {
  292.                 for (i = n - cldcnt[n]; i <= n; i++) {
  293.                         for (j = 0; j < (n - cldcnt[n]); j++) {
  294.                                 map[j*64 + i] = map[i*64 + j] =
  295.                                         MIN(map[i*64 + j], speedcap[n]);
  296.                         }
  297.                         for (j = n + 1; j < nodecount; j++) {
  298.                                 map[j*64 + i] = map[i*64 + j] =
  299.                                         MIN(map[i*64 + j], speedcap[n]);
  300.                         }
  301.                 }
  302.         }
  303. }
  306. void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid)
  307. {
  308.         if (host->in_bus_reset) {
  309. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  310.                 HPSB_INFO("Including SelfID 0x%x", sid);
  311. #endif
  312.                 host->topology_map[host->selfid_count++] = sid;
  313.         } else {
  314.                 HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d",
  315.     sid, (host->node_id & BUS_MASK) >> 6);
  316.         }
  317. }
  319. void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot)
  320. {
  321.         host->node_id = LOCAL_BUS | phyid;
  322.         host->in_bus_reset = 0;
  323.         host->is_root = isroot;
  325.         host->node_count = check_selfids(host, host->selfid_count);
  326.         if (!host->node_count) {
  327.                 if (host->reset_retries++ < 20) {
  328.                         /* selfid stage did not complete without error */
  329.                         HPSB_NOTICE("Error in SelfID stage, resetting");
  330.                         hpsb_reset_bus(host, LONG_RESET);
  331.                         return;
  332.                 } else {
  333.                         HPSB_NOTICE("Stopping out-of-control reset loop");
  334.                         HPSB_NOTICE("Warning - topology map and speed map will not be valid");
  335.                 }
  336.         } else {
  337.                 build_speed_map(host, host->node_count);
  338.         }
  340.         /* irm_id is kept up to date by check_selfids() */
  341.         if (host->irm_id == host->node_id) {
  342.                 host->is_irm = 1;
  343.                 host->is_busmgr = 1;
  344.                 host->busmgr_id = host->node_id;
  345.                 host->csr.bus_manager_id = host->node_id;
  346.         }
  348.         host->reset_retries = 0;
  349.         atomic_inc(&host->generation);
  350.         if (isroot) host->template->devctl(host, ACT_CYCLE_MASTER, 1);
  351.         highlevel_host_reset(host);
  352. }
  355. void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, 
  356.                       int ackcode)
  357. {
  358.         unsigned long flags;
  360.         packet->ack_code = ackcode;
  362.         if (packet->no_waiter) {
  363.                 /* must not have a tlabel allocated */
  364.                 free_hpsb_packet(packet);
  365.                 return;
  366.         }
  368.         if (ackcode != ACK_PENDING || !packet->expect_response) {
  369.                 packet->state = hpsb_complete;
  370.                 up(&packet->state_change);
  371.                 up(&packet->state_change);
  372.                 run_task_queue(&packet->complete_tq);
  373.                 return;
  374.         }
  376.         packet->state = hpsb_pending;
  377.         packet->sendtime = jiffies;
  379.         spin_lock_irqsave(&host->pending_pkt_lock, flags);
  380.         list_add_tail(&packet->list, &host->pending_packets);
  381.         spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  383.         up(&packet->state_change);
  384.         queue_task(&host->timeout_tq, &tq_timer);
  385. }
  387. /**
  388.  * hpsb_send_packet - transmit a packet on the bus
  389.  * @packet: packet to send
  390.  *
  391.  * The packet is sent through the host specified in the packet->host field.
  392.  * Before sending, the packet's transmit speed is automatically determined using
  393.  * the local speed map when it is an async, non-broadcast packet.
  394.  *
  395.  * Possibilities for failure are that host is either not initialized, in bus
  396.  * reset, the packet's generation number doesn't match the current generation
  397.  * number or the host reports a transmit error.
  398.  *
  399.  * Return value: False (0) on failure, true (1) otherwise.
  400.  */
  401. int hpsb_send_packet(struct hpsb_packet *packet)
  402. {
  403.         struct hpsb_host *host = packet->host;
  405.         if (!host->initialized || host->in_bus_reset 
  406.             || (packet->generation != get_hpsb_generation(host))) {
  407.                 return 0;
  408.         }
  410.         packet->state = hpsb_queued;
  412.         if (packet->type == hpsb_async && packet->node_id != ALL_NODES) {
  413.                 packet->speed_code =
  414.                         host->speed_map[(host->node_id & NODE_MASK) * 64
  415.                                        + (packet->node_id & NODE_MASK)];
  416.         }
  418. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  419.         switch (packet->speed_code) {
  420.         case 2:
  421.                 dump_packet("send packet 400:", packet->header,
  422.                             packet->header_size);
  423.                 break;
  424.         case 1:
  425.                 dump_packet("send packet 200:", packet->header,
  426.                             packet->header_size);
  427.                 break;
  428.         default:
  429.                 dump_packet("send packet 100:", packet->header,
  430.                             packet->header_size);
  431.         }
  432. #endif
  434.         return host->template->transmit_packet(host, packet);
  435. }
  437. static void send_packet_nocare(struct hpsb_packet *packet)
  438. {
  439.         if (!hpsb_send_packet(packet)) {
  440.                 free_hpsb_packet(packet);
  441.         }
  442. }
  445. void handle_packet_response(struct hpsb_host *host, int tcode, quadlet_t *data,
  446.                             size_t size)
  447. {
  448.         struct hpsb_packet *packet = NULL;
  449.         struct list_head *lh;
  450.         int tcode_match = 0;
  451.         int tlabel;
  452.         unsigned long flags;
  454.         tlabel = (data[0] >> 10) & 0x3f;
  456.         spin_lock_irqsave(&host->pending_pkt_lock, flags);
  458.         list_for_each(lh, &host->pending_packets) {
  459.                 packet = list_entry(lh, struct hpsb_packet, list);
  460.                 if ((packet->tlabel == tlabel)
  461.                     && (packet->node_id == (data[1] >> 16))){
  462.                         break;
  463.                 }
  464.         }
  466.         if (lh == &host->pending_packets) {
  467.                 HPSB_DEBUG("unsolicited response packet received - np");
  468.                 dump_packet("contents:", data, 16);
  469.                 spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  470.                 return;
  471.         }
  473.         switch (packet->tcode) {
  474.         case TCODE_WRITEQ:
  475.         case TCODE_WRITEB:
  476.                 if (tcode == TCODE_WRITE_RESPONSE) tcode_match = 1;
  477.                 break;
  478.         case TCODE_READQ:
  479.                 if (tcode == TCODE_READQ_RESPONSE) tcode_match = 1;
  480.                 break;
  481.         case TCODE_READB:
  482.                 if (tcode == TCODE_READB_RESPONSE) tcode_match = 1;
  483.                 break;
  484.         case TCODE_LOCK_REQUEST:
  485.                 if (tcode == TCODE_LOCK_RESPONSE) tcode_match = 1;
  486.                 break;
  487.         }
  489.         if (!tcode_match || (packet->tlabel != tlabel)
  490.             || (packet->node_id != (data[1] >> 16))) {
  491.                 HPSB_INFO("unsolicited response packet received");
  492.                 dump_packet("contents:", data, 16);
  494.                 spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  495.                 return;
  496.         }
  498.         list_del(&packet->list);
  500.         spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  502.         /* FIXME - update size fields? */
  503.         switch (tcode) {
  504.         case TCODE_WRITE_RESPONSE:
  505.                 memcpy(packet->header, data, 12);
  506.                 break;
  507.         case TCODE_READQ_RESPONSE:
  508.                 memcpy(packet->header, data, 16);
  509.                 break;
  510.         case TCODE_READB_RESPONSE:
  511.                 memcpy(packet->header, data, 16);
  512.                 memcpy(packet->data, data + 4, size - 16);
  513.                 break;
  514.         case TCODE_LOCK_RESPONSE:
  515.                 memcpy(packet->header, data, 16);
  516.                 memcpy(packet->data, data + 4, (size - 16) > 8 ? 8 : size - 16);
  517.                 break;
  518.         }
  520.         packet->state = hpsb_complete;
  521.         up(&packet->state_change);
  522.         run_task_queue(&packet->complete_tq);
  523. }
  526. static struct hpsb_packet *create_reply_packet(struct hpsb_host *host,
  527.        quadlet_t *data, size_t dsize)
  528. {
  529.         struct hpsb_packet *p;
  531.         dsize += (dsize % 4 ? 4 - (dsize % 4) : 0);
  533.         p = alloc_hpsb_packet(dsize);
  534.         if (p == NULL) {
  535.                 /* FIXME - send data_error response */
  536.                 return NULL;
  537.         }
  539.         p->type = hpsb_async;
  540.         p->state = hpsb_unused;
  541.         p->host = host;
  542.         p->node_id = data[1] >> 16;
  543.         p->tlabel = (data[0] >> 10) & 0x3f;
  544.         p->no_waiter = 1;
  546. p->generation = get_hpsb_generation(host);
  548.         if (dsize % 4) {
  549.                 p->data[dsize / 4] = 0;
  550.         }
  552.         return p;
  553. }
  555. #define PREP_REPLY_PACKET(length) 
  556.                 packet = create_reply_packet(host, data, length); 
  557.                 if (packet == NULL) break
  559. static void handle_incoming_packet(struct hpsb_host *host, int tcode,
  560.    quadlet_t *data, size_t size, int write_acked)
  561. {
  562.         struct hpsb_packet *packet;
  563.         int length, rcode, extcode;
  564.         nodeid_t source = data[1] >> 16;
  565. nodeid_t dest = data[0] >> 16;
  566.         u64 addr;
  568.         /* big FIXME - no error checking is done for an out of bounds length */
  570.         switch (tcode) {
  571.         case TCODE_WRITEQ:
  572.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  573.                 rcode = highlevel_write(host, source, dest, data+3,
  574. addr, 4);
  576.                 if (!write_acked
  577.                     && ((data[0] >> 16) & NODE_MASK) != NODE_MASK) {
  578.                         /* not a broadcast write, reply */
  579.                         PREP_REPLY_PACKET(0);
  580.                         fill_async_write_resp(packet, rcode);
  581.                         send_packet_nocare(packet);
  582.                 }
  583.                 break;
  585.         case TCODE_WRITEB:
  586.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  587.                 rcode = highlevel_write(host, source, dest, data+4,
  588. addr, data[3]>>16);
  590.                 if (!write_acked
  591.                     && ((data[0] >> 16) & NODE_MASK) != NODE_MASK) {
  592.                         /* not a broadcast write, reply */
  593.                         PREP_REPLY_PACKET(0);
  594.                         fill_async_write_resp(packet, rcode);
  595.                         send_packet_nocare(packet);
  596.                 }
  597.                 break;
  599.         case TCODE_READQ:
  600.                 PREP_REPLY_PACKET(0);
  602.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  603.                 rcode = highlevel_read(host, source, data, addr, 4);
  604.                 fill_async_readquad_resp(packet, rcode, *data);
  605.                 send_packet_nocare(packet);
  606.                 break;
  608.         case TCODE_READB:
  609.                 length = data[3] >> 16;
  610.                 PREP_REPLY_PACKET(length);
  612.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  613.                 rcode = highlevel_read(host, source, packet->data, addr,
  614.                                        length);
  615.                 fill_async_readblock_resp(packet, rcode, length);
  616.                 send_packet_nocare(packet);
  617.                 break;
  619.         case TCODE_LOCK_REQUEST:
  620.                 length = data[3] >> 16;
  621.                 extcode = data[3] & 0xffff;
  622.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  624.                 PREP_REPLY_PACKET(8);
  626.                 if ((extcode == 0) || (extcode >= 7)) {
  627.                         /* let switch default handle error */
  628.                         length = 0;
  629.                 }
  631.                 switch (length) {
  632.                 case 4:
  633.                         rcode = highlevel_lock(host, source, packet->data, addr,
  634.                                                data[4], 0, extcode);
  635.                         fill_async_lock_resp(packet, rcode, extcode, 4);
  636.                         break;
  637.                 case 8:
  638.                         if ((extcode != EXTCODE_FETCH_ADD) 
  639.                             && (extcode != EXTCODE_LITTLE_ADD)) {
  640.                                 rcode = highlevel_lock(host, source,
  641.                                                        packet->data, addr,
  642.                                                        data[5], data[4], 
  643.                                                        extcode);
  644.                                 fill_async_lock_resp(packet, rcode, extcode, 4);
  645.                         } else {
  646.                                 rcode = highlevel_lock64(host, source,
  647.                                              (octlet_t *)packet->data, addr,
  648.                                              *(octlet_t *)(data + 4), 0ULL,
  649.                                              extcode);
  650.                                 fill_async_lock_resp(packet, rcode, extcode, 8);
  651.                         }
  652.                         break;
  653.                 case 16:
  654.                         rcode = highlevel_lock64(host, source,
  655.                                                  (octlet_t *)packet->data, addr,
  656.                                                  *(octlet_t *)(data + 6),
  657.                                                  *(octlet_t *)(data + 4), 
  658.                                                  extcode);
  659.                         fill_async_lock_resp(packet, rcode, extcode, 8);
  660.                         break;
  661.                 default:
  662.                         fill_async_lock_resp(packet, RCODE_TYPE_ERROR,
  663.                                              extcode, 0);
  664.                 }
  666.                 send_packet_nocare(packet);
  667.                 break;
  668.         }
  670. }
  671. #undef PREP_REPLY_PACKET
  674. void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
  675.                           int write_acked)
  676. {
  677.         int tcode;
  679.         if (host->in_bus_reset) {
  680.                 HPSB_INFO("received packet during reset; ignoring");
  681.                 return;
  682.         }
  684. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  685.         dump_packet("received packet:", data, size);
  686. #endif
  688.         tcode = (data[0] >> 4) & 0xf;
  690.         switch (tcode) {
  691.         case TCODE_WRITE_RESPONSE:
  692.         case TCODE_READQ_RESPONSE:
  693.         case TCODE_READB_RESPONSE:
  694.         case TCODE_LOCK_RESPONSE:
  695.                 handle_packet_response(host, tcode, data, size);
  696.                 break;
  698.         case TCODE_WRITEQ:
  699.         case TCODE_WRITEB:
  700.         case TCODE_READQ:
  701.         case TCODE_READB:
  702.         case TCODE_LOCK_REQUEST:
  703.                 handle_incoming_packet(host, tcode, data, size, write_acked);
  704.                 break;
  707.         case TCODE_ISO_DATA:
  708.                 highlevel_iso_receive(host, data, size);
  709.                 break;
  711.         case TCODE_CYCLE_START:
  712.                 /* simply ignore this packet if it is passed on */
  713.                 break;
  715.         default:
  716.                 HPSB_NOTICE("received packet with bogus transaction code %d", 
  717.                             tcode);
  718.                 break;
  719.         }
  720. }
  723. void abort_requests(struct hpsb_host *host)
  724. {
  725.         unsigned long flags;
  726.         struct hpsb_packet *packet;
  727.         struct list_head *lh;
  728.         LIST_HEAD(llist);
  730.         host->template->devctl(host, CANCEL_REQUESTS, 0);
  732.         spin_lock_irqsave(&host->pending_pkt_lock, flags);
  733.         list_splice(&host->pending_packets, &llist);
  734.         INIT_LIST_HEAD(&host->pending_packets);
  735.         spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  737.         list_for_each(lh, &llist) {
  738.                 packet = list_entry(lh, struct hpsb_packet, list);
  739.                 packet->state = hpsb_complete;
  740.                 packet->ack_code = ACKX_ABORTED;
  741.                 up(&packet->state_change);
  742.                 run_task_queue(&packet->complete_tq);
  743.         }
  744. }
  746. void abort_timedouts(struct hpsb_host *host)
  747. {
  748.         unsigned long flags;
  749.         struct hpsb_packet *packet;
  750.         unsigned long expire;
  751.         struct list_head *lh, *next;
  752.         LIST_HEAD(expiredlist);
  754.         spin_lock_irqsave(&host->csr.lock, flags);
  755.         expire = (host->csr.split_timeout_hi * 8000 
  756.                   + (host->csr.split_timeout_lo >> 19))
  757.                 * HZ / 8000;
  758.         /* Avoid shortening of timeout due to rounding errors: */
  759.         expire++;
  760.         spin_unlock_irqrestore(&host->csr.lock, flags);
  763.         spin_lock_irqsave(&host->pending_pkt_lock, flags);
  765. for (lh = host->pending_packets.next; lh != &host->pending_packets; lh = next) {
  766.                 packet = list_entry(lh, struct hpsb_packet, list);
  767. next = lh->next;
  768.                 if (time_before(packet->sendtime + expire, jiffies)) {
  769.                         list_del(&packet->list);
  770.                         list_add(&packet->list, &expiredlist);
  771.                 }
  772.         }
  774.         if (!list_empty(&host->pending_packets)) {
  775.                 queue_task(&host->timeout_tq, &tq_timer);
  776.         }
  777.         spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  779.         list_for_each(lh, &expiredlist) {
  780.                 packet = list_entry(lh, struct hpsb_packet, list);
  781.                 packet->state = hpsb_complete;
  782.                 packet->ack_code = ACKX_TIMEOUT;
  783.                 up(&packet->state_change);
  784.                 run_task_queue(&packet->complete_tq);
  785.         }
  786. }
  789. static int __init ieee1394_init(void)
  790. {
  791. hpsb_packet_cache = kmem_cache_create("hpsb_packet", sizeof(struct hpsb_packet),
  792.       0, 0, NULL, NULL);
  793. init_hpsb_highlevel();
  794. init_csr();
  795. if (!disable_nodemgr)
  796. init_ieee1394_nodemgr();
  797. else
  798. HPSB_INFO("nodemgr functionality disabled");
  800. return 0;
  801. }
  803. static void __exit ieee1394_cleanup(void)
  804. {
  805. if (!disable_nodemgr)
  806. cleanup_ieee1394_nodemgr();
  808. cleanup_csr();
  809. kmem_cache_destroy(hpsb_packet_cache);
  810. }
  812. module_init(ieee1394_init);
  813. module_exit(ieee1394_cleanup);
  815. /* Exported symbols */
  816. EXPORT_SYMBOL(hpsb_register_lowlevel);
  817. EXPORT_SYMBOL(hpsb_unregister_lowlevel);
  818. EXPORT_SYMBOL(hpsb_get_host);
  819. EXPORT_SYMBOL(hpsb_inc_host_usage);
  820. EXPORT_SYMBOL(hpsb_dec_host_usage);
  821. EXPORT_SYMBOL(hpsb_speedto_str);
  823. EXPORT_SYMBOL(alloc_hpsb_packet);
  824. EXPORT_SYMBOL(free_hpsb_packet);
  825. EXPORT_SYMBOL(hpsb_send_packet);
  826. EXPORT_SYMBOL(hpsb_reset_bus);
  827. EXPORT_SYMBOL(hpsb_bus_reset);
  828. EXPORT_SYMBOL(hpsb_selfid_received);
  829. EXPORT_SYMBOL(hpsb_selfid_complete);
  830. EXPORT_SYMBOL(hpsb_packet_sent);
  831. EXPORT_SYMBOL(hpsb_packet_received);
  833. EXPORT_SYMBOL(get_tlabel);
  834. EXPORT_SYMBOL(free_tlabel);
  835. EXPORT_SYMBOL(fill_async_readquad);
  836. EXPORT_SYMBOL(fill_async_readquad_resp);
  837. EXPORT_SYMBOL(fill_async_readblock);
  838. EXPORT_SYMBOL(fill_async_readblock_resp);
  839. EXPORT_SYMBOL(fill_async_writequad);
  840. EXPORT_SYMBOL(fill_async_writeblock);
  841. EXPORT_SYMBOL(fill_async_write_resp);
  842. EXPORT_SYMBOL(fill_async_lock);
  843. EXPORT_SYMBOL(fill_async_lock_resp);
  844. EXPORT_SYMBOL(fill_iso_packet);
  845. EXPORT_SYMBOL(fill_phy_packet);
  846. EXPORT_SYMBOL(hpsb_make_readqpacket);
  847. EXPORT_SYMBOL(hpsb_make_readbpacket);
  848. EXPORT_SYMBOL(hpsb_make_writeqpacket);
  849. EXPORT_SYMBOL(hpsb_make_writebpacket);
  850. EXPORT_SYMBOL(hpsb_make_lockpacket);
  851. EXPORT_SYMBOL(hpsb_make_phypacket);
  852. EXPORT_SYMBOL(hpsb_packet_success);
  853. EXPORT_SYMBOL(hpsb_make_packet);
  854. EXPORT_SYMBOL(hpsb_read);
  855. EXPORT_SYMBOL(hpsb_write);
  856. EXPORT_SYMBOL(hpsb_lock);
  858. EXPORT_SYMBOL(hpsb_register_highlevel);
  859. EXPORT_SYMBOL(hpsb_unregister_highlevel);
  860. EXPORT_SYMBOL(hpsb_register_addrspace);
  861. EXPORT_SYMBOL(hpsb_listen_channel);
  862. EXPORT_SYMBOL(hpsb_unlisten_channel);
  863. EXPORT_SYMBOL(highlevel_read);
  864. EXPORT_SYMBOL(highlevel_write);
  865. EXPORT_SYMBOL(highlevel_lock);
  866. EXPORT_SYMBOL(highlevel_lock64);
  867. EXPORT_SYMBOL(highlevel_add_host);
  868. EXPORT_SYMBOL(highlevel_remove_host);
  869. EXPORT_SYMBOL(highlevel_host_reset);
  870. EXPORT_SYMBOL(highlevel_add_one_host);
  872. EXPORT_SYMBOL(hpsb_guid_get_entry);
  873. EXPORT_SYMBOL(hpsb_nodeid_get_entry);
  874. EXPORT_SYMBOL(hpsb_get_host_by_ne);
  875. EXPORT_SYMBOL(hpsb_guid_fill_packet);
  876. EXPORT_SYMBOL(hpsb_register_protocol);
  877. EXPORT_SYMBOL(hpsb_unregister_protocol);
  878. EXPORT_SYMBOL(hpsb_release_unit_directory);