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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
ieee1394_core.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：35k
源码类别：

Linux/Unix编程

开发平台：

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 <linux/proc_fs.h>
  22. #include <linux/tqueue.h>
  23. #include <asm/bitops.h>
  24. #include <asm/byteorder.h>
  25. #include <asm/semaphore.h>
  27. #include "ieee1394_types.h"
  28. #include "ieee1394.h"
  29. #include "hosts.h"
  30. #include "ieee1394_core.h"
  31. #include "highlevel.h"
  32. #include "ieee1394_transactions.h"
  33. #include "csr.h"
  34. #include "nodemgr.h"
  35. #include "ieee1394_hotplug.h"
  37. /*
  38.  * Disable the nodemgr detection and config rom reading functionality.
  39.  */
  40. MODULE_PARM(disable_nodemgr, "i");
  41. MODULE_PARM_DESC(disable_nodemgr, "Disable nodemgr functionality.");
  42. static int disable_nodemgr = 0;
  44. MODULE_PARM(disable_hotplug, "i");
  45. MODULE_PARM_DESC(disable_hotplug, "Disable hotplug for detected nodes.");
  46. static int disable_hotplug = 0;
  48. /* We are GPL, so treat us special */
  49. MODULE_LICENSE("GPL");
  51. static kmem_cache_t *hpsb_packet_cache;
  53. /* Some globals used */
  54. const char *hpsb_speedto_str[] = { "S100", "S200", "S400" };
  56. static void dump_packet(const char *text, quadlet_t *data, int size)
  57. {
  58.         int i;
  60.         size /= 4;
  61.         size = (size > 4 ? 4 : size);
  63.         printk(KERN_DEBUG "ieee1394: %s", text);
  64.         for (i = 0; i < size; i++) {
  65.                 printk(" %8.8x", data[i]);
  66.         }
  67.         printk("n");
  68. }
  70. static void process_complete_tasks(struct hpsb_packet *packet)
  71. {
  72. struct list_head *lh, *next;
  74. list_for_each_safe(lh, next, &packet->complete_tq) {
  75. struct tq_struct *tq = list_entry(lh, struct tq_struct, list);
  76. list_del(&tq->list);
  77. schedule_task(tq);
  78. }
  80. return;
  81. }
  83. /**
  84.  * hpsb_add_packet_complete_task - add a new task for when a packet completes
  85.  * @packet: the packet whose completion we want the task added to
  86.  * @tq: the tq_struct describing the task to add
  87.  */
  88. void hpsb_add_packet_complete_task(struct hpsb_packet *packet, struct tq_struct *tq)
  89. {
  90. list_add_tail(&tq->list, &packet->complete_tq);
  91. return;
  92. }
  94. /**
  95.  * alloc_hpsb_packet - allocate new packet structure
  96.  * @data_size: size of the data block to be allocated
  97.  *
  98.  * This function allocates, initializes and returns a new &struct hpsb_packet.
  99.  * It can be used in interrupt context.  A header block is always included, its
  100.  * size is big enough to contain all possible 1394 headers.  The data block is
  101.  * only allocated when @data_size is not zero.
  102.  *
  103.  * For packets for which responses will be received the @data_size has to be big
  104.  * enough to contain the response's data block since no further allocation
  105.  * occurs at response matching time.
  106.  *
  107.  * The packet's generation value will be set to the current generation number
  108.  * for ease of use.  Remember to overwrite it with your own recorded generation
  109.  * number if you can not be sure that your code will not race with a bus reset.
  110.  *
  111.  * Return value: A pointer to a &struct hpsb_packet or NULL on allocation
  112.  * failure.
  113.  */
  114. struct hpsb_packet *alloc_hpsb_packet(size_t data_size)
  115. {
  116.         struct hpsb_packet *packet = NULL;
  117.         void *data = NULL;
  118.         int kmflags = in_interrupt() ? GFP_ATOMIC : GFP_KERNEL;
  120.         packet = kmem_cache_alloc(hpsb_packet_cache, kmflags);
  121.         if (packet == NULL)
  122.                 return NULL;
  124.         memset(packet, 0, sizeof(struct hpsb_packet));
  125.         packet->header = packet->embedded_header;
  127.         if (data_size) {
  128.                 data = kmalloc(data_size + 8, kmflags);
  129.                 if (data == NULL) {
  130. kmem_cache_free(hpsb_packet_cache, packet);
  131.                         return NULL;
  132.                 }
  134.                 packet->data = data;
  135.                 packet->data_size = data_size;
  136.         }
  138.         INIT_LIST_HEAD(&packet->complete_tq);
  139.         INIT_LIST_HEAD(&packet->list);
  140.         sema_init(&packet->state_change, 0);
  141.         packet->state = hpsb_unused;
  142.         packet->generation = -1;
  143.         packet->data_be = 1;
  145.         return packet;
  146. }
  149. /**
  150.  * free_hpsb_packet - free packet and data associated with it
  151.  * @packet: packet to free (is NULL safe)
  152.  *
  153.  * This function will free packet->data, packet->header and finally the packet
  154.  * itself.
  155.  */
  156. void free_hpsb_packet(struct hpsb_packet *packet)
  157. {
  158.         if (!packet) return;
  160.         kfree(packet->data);
  161.         kmem_cache_free(hpsb_packet_cache, packet);
  162. }
  165. int hpsb_reset_bus(struct hpsb_host *host, int type)
  166. {
  167.         if (!host->in_bus_reset) {
  168.                 host->driver->devctl(host, RESET_BUS, type);
  169.                 return 0;
  170.         } else {
  171.                 return 1;
  172.         }
  173. }
  176. int hpsb_bus_reset(struct hpsb_host *host)
  177. {
  178.         if (host->in_bus_reset) {
  179.                 HPSB_NOTICE("%s called while bus reset already in progress",
  180.     __FUNCTION__);
  181.                 return 1;
  182.         }
  184.         abort_requests(host);
  185.         host->in_bus_reset = 1;
  186.         host->irm_id = -1;
  187. host->is_irm = 0;
  188.         host->busmgr_id = -1;
  189. host->is_busmgr = 0;
  190. host->is_cycmst = 0;
  191.         host->node_count = 0;
  192.         host->selfid_count = 0;
  194.         return 0;
  195. }
  198. /*
  199.  * Verify num_of_selfids SelfIDs and return number of nodes.  Return zero in
  200.  * case verification failed.
  201.  */
  202. static int check_selfids(struct hpsb_host *host)
  203. {
  204.         int nodeid = -1;
  205.         int rest_of_selfids = host->selfid_count;
  206.         struct selfid *sid = (struct selfid *)host->topology_map;
  207.         struct ext_selfid *esid;
  208.         int esid_seq = 23;
  210. host->nodes_active = 0;
  212.         while (rest_of_selfids--) {
  213.                 if (!sid->extended) {
  214.                         nodeid++;
  215.                         esid_seq = 0;
  216.                         
  217.                         if (sid->phy_id != nodeid) {
  218.                                 HPSB_INFO("SelfIDs failed monotony check with "
  219.                                           "%d", sid->phy_id);
  220.                                 return 0;
  221.                         }
  222.                         
  223. if (sid->link_active) {
  224. host->nodes_active++;
  225. if (sid->contender)
  226. host->irm_id = LOCAL_BUS | sid->phy_id;
  227. }
  228.                 } else {
  229.                         esid = (struct ext_selfid *)sid;
  231.                         if ((esid->phy_id != nodeid) 
  232.                             || (esid->seq_nr != esid_seq)) {
  233.                                 HPSB_INFO("SelfIDs failed monotony check with "
  234.                                           "%d/%d", esid->phy_id, esid->seq_nr);
  235.                                 return 0;
  236.                         }
  237.                         esid_seq++;
  238.                 }
  239.                 sid++;
  240.         }
  241.         
  242.         esid = (struct ext_selfid *)(sid - 1);
  243.         while (esid->extended) {
  244.                 if ((esid->porta == 0x2) || (esid->portb == 0x2)
  245.                     || (esid->portc == 0x2) || (esid->portd == 0x2)
  246.                     || (esid->porte == 0x2) || (esid->portf == 0x2)
  247.                     || (esid->portg == 0x2) || (esid->porth == 0x2)) {
  248.                                 HPSB_INFO("SelfIDs failed root check on "
  249.                                           "extended SelfID");
  250.                                 return 0;
  251.                 }
  252.                 esid--;
  253.         }
  255.         sid = (struct selfid *)esid;
  256.         if ((sid->port0 == 0x2) || (sid->port1 == 0x2) || (sid->port2 == 0x2)) {
  257.                         HPSB_INFO("SelfIDs failed root check");
  258.                         return 0;
  259.         }
  261. host->node_count = nodeid + 1;
  262.         return 1;
  263. }
  265. static void build_speed_map(struct hpsb_host *host, int nodecount)
  266. {
  267.         char speedcap[nodecount];
  268.         char cldcnt[nodecount];
  269.         u8 *map = host->speed_map;
  270.         struct selfid *sid;
  271.         struct ext_selfid *esid;
  272.         int i, j, n;
  274.         for (i = 0; i < (nodecount * 64); i += 64) {
  275.                 for (j = 0; j < nodecount; j++) {
  276.                         map[i+j] = SPEED_400;
  277.                 }
  278.         }
  280.         for (i = 0; i < nodecount; i++) {
  281.                 cldcnt[i] = 0;
  282.         }
  284.         /* find direct children count and speed */
  285.         for (sid = (struct selfid *)&host->topology_map[host->selfid_count-1],
  286.                      n = nodecount - 1;
  287.              (void *)sid >= (void *)host->topology_map; sid--) {
  288.                 if (sid->extended) {
  289.                         esid = (struct ext_selfid *)sid;
  291.                         if (esid->porta == 0x3) cldcnt[n]++;
  292.                         if (esid->portb == 0x3) cldcnt[n]++;
  293.                         if (esid->portc == 0x3) cldcnt[n]++;
  294.                         if (esid->portd == 0x3) cldcnt[n]++;
  295.                         if (esid->porte == 0x3) cldcnt[n]++;
  296.                         if (esid->portf == 0x3) cldcnt[n]++;
  297.                         if (esid->portg == 0x3) cldcnt[n]++;
  298.                         if (esid->porth == 0x3) cldcnt[n]++;
  299.                 } else {
  300.                         if (sid->port0 == 0x3) cldcnt[n]++;
  301.                         if (sid->port1 == 0x3) cldcnt[n]++;
  302.                         if (sid->port2 == 0x3) cldcnt[n]++;
  304.                         speedcap[n] = sid->speed;
  305.                         n--;
  306.                 }
  307.         }
  309.         /* set self mapping */
  310.         for (i = 0; i < nodecount; i++) {
  311.                 map[64*i + i] = speedcap[i];
  312.         }
  314.         /* fix up direct children count to total children count;
  315.          * also fix up speedcaps for sibling and parent communication */
  316.         for (i = 1; i < nodecount; i++) {
  317.                 for (j = cldcnt[i], n = i - 1; j > 0; j--) {
  318.                         cldcnt[i] += cldcnt[n];
  319.                         speedcap[n] = MIN(speedcap[n], speedcap[i]);
  320.                         n -= cldcnt[n] + 1;
  321.                 }
  322.         }
  324.         for (n = 0; n < nodecount; n++) {
  325.                 for (i = n - cldcnt[n]; i <= n; i++) {
  326.                         for (j = 0; j < (n - cldcnt[n]); j++) {
  327.                                 map[j*64 + i] = map[i*64 + j] =
  328.                                         MIN(map[i*64 + j], speedcap[n]);
  329.                         }
  330.                         for (j = n + 1; j < nodecount; j++) {
  331.                                 map[j*64 + i] = map[i*64 + j] =
  332.                                         MIN(map[i*64 + j], speedcap[n]);
  333.                         }
  334.                 }
  335.         }
  336. }
  339. void hpsb_selfid_received(struct hpsb_host *host, quadlet_t sid)
  340. {
  341.         if (host->in_bus_reset) {
  342. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  343.                 HPSB_INFO("Including SelfID 0x%x", sid);
  344. #endif
  345.                 host->topology_map[host->selfid_count++] = sid;
  346.         } else {
  347.                 HPSB_NOTICE("Spurious SelfID packet (0x%08x) received from bus %d",
  348.     sid, (host->node_id & BUS_MASK) >> 6);
  349.         }
  350. }
  352. void hpsb_selfid_complete(struct hpsb_host *host, int phyid, int isroot)
  353. {
  354. if (!host->in_bus_reset)
  355. HPSB_NOTICE("SelfID completion called outside of bus reset!");
  357.         host->node_id = LOCAL_BUS | phyid;
  358.         host->is_root = isroot;
  360.         if (!check_selfids(host)) {
  361.                 if (host->reset_retries++ < 20) {
  362.                         /* selfid stage did not complete without error */
  363.                         HPSB_NOTICE("Error in SelfID stage, resetting");
  364. host->in_bus_reset = 0;
  365.                         hpsb_reset_bus(host, LONG_RESET);
  366.                         return;
  367.                 } else {
  368.                         HPSB_NOTICE("Stopping out-of-control reset loop");
  369.                         HPSB_NOTICE("Warning - topology map and speed map will not be valid");
  370.                 }
  371.         } else {
  372.                 build_speed_map(host, host->node_count);
  373.         }
  375.         /* irm_id is kept up to date by check_selfids() */
  376.         if (host->irm_id == host->node_id) {
  377.                 host->is_irm = 1;
  378.                 host->is_busmgr = 1;
  379.                 host->busmgr_id = host->node_id;
  380.                 host->csr.bus_manager_id = host->node_id;
  381.         }
  383.         host->reset_retries = 0;
  384.         if (isroot) {
  385. host->driver->devctl(host, ACT_CYCLE_MASTER, 1);
  386. host->is_cycmst = 1;
  387. }
  388. atomic_inc(&host->generation);
  389. host->in_bus_reset = 0;
  390.         highlevel_host_reset(host);
  391. }
  394. void hpsb_packet_sent(struct hpsb_host *host, struct hpsb_packet *packet, 
  395.                       int ackcode)
  396. {
  397.         unsigned long flags;
  399.         packet->ack_code = ackcode;
  401.         if (packet->no_waiter) {
  402.                 /* must not have a tlabel allocated */
  403.                 free_hpsb_packet(packet);
  404.                 return;
  405.         }
  407.         if (ackcode != ACK_PENDING || !packet->expect_response) {
  408.                 packet->state = hpsb_complete;
  409.                 up(&packet->state_change);
  410.                 up(&packet->state_change);
  411.                 process_complete_tasks(packet);
  412.                 return;
  413.         }
  415.         packet->state = hpsb_pending;
  416.         packet->sendtime = jiffies;
  418.         spin_lock_irqsave(&host->pending_pkt_lock, flags);
  419.         list_add_tail(&packet->list, &host->pending_packets);
  420.         spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  422.         up(&packet->state_change);
  423.         schedule_task(&host->timeout_tq);
  424. }
  426. /**
  427.  * hpsb_send_packet - transmit a packet on the bus
  428.  * @packet: packet to send
  429.  *
  430.  * The packet is sent through the host specified in the packet->host field.
  431.  * Before sending, the packet's transmit speed is automatically determined using
  432.  * the local speed map when it is an async, non-broadcast packet.
  433.  *
  434.  * Possibilities for failure are that host is either not initialized, in bus
  435.  * reset, the packet's generation number doesn't match the current generation
  436.  * number or the host reports a transmit error.
  437.  *
  438.  * Return value: False (0) on failure, true (1) otherwise.
  439.  */
  440. int hpsb_send_packet(struct hpsb_packet *packet)
  441. {
  442.         struct hpsb_host *host = packet->host;
  444.         if (host->is_shutdown || host->in_bus_reset
  445.             || (packet->generation != get_hpsb_generation(host))) {
  446.                 return 0;
  447.         }
  449.         packet->state = hpsb_queued;
  451.         if (packet->type == hpsb_async && packet->node_id != ALL_NODES) {
  452.                 packet->speed_code =
  453.                         host->speed_map[(host->node_id & NODE_MASK) * 64
  454.                                        + (packet->node_id & NODE_MASK)];
  455.         }
  457. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  458.         switch (packet->speed_code) {
  459.         case 2:
  460.                 dump_packet("send packet 400:", packet->header,
  461.                             packet->header_size);
  462.                 break;
  463.         case 1:
  464.                 dump_packet("send packet 200:", packet->header,
  465.                             packet->header_size);
  466.                 break;
  467.         default:
  468.                 dump_packet("send packet 100:", packet->header,
  469.                             packet->header_size);
  470.         }
  471. #endif
  473.         return host->driver->transmit_packet(host, packet);
  474. }
  476. static void send_packet_nocare(struct hpsb_packet *packet)
  477. {
  478.         if (!hpsb_send_packet(packet)) {
  479.                 free_hpsb_packet(packet);
  480.         }
  481. }
  484. void handle_packet_response(struct hpsb_host *host, int tcode, quadlet_t *data,
  485.                             size_t size)
  486. {
  487.         struct hpsb_packet *packet = NULL;
  488.         struct list_head *lh;
  489.         int tcode_match = 0;
  490.         int tlabel;
  491.         unsigned long flags;
  493.         tlabel = (data[0] >> 10) & 0x3f;
  495.         spin_lock_irqsave(&host->pending_pkt_lock, flags);
  497.         list_for_each(lh, &host->pending_packets) {
  498.                 packet = list_entry(lh, struct hpsb_packet, list);
  499.                 if ((packet->tlabel == tlabel)
  500.                     && (packet->node_id == (data[1] >> 16))){
  501.                         break;
  502.                 }
  503.         }
  505.         if (lh == &host->pending_packets) {
  506.                 HPSB_DEBUG("unsolicited response packet received - np");
  507.                 dump_packet("contents:", data, 16);
  508.                 spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  509.                 return;
  510.         }
  512.         switch (packet->tcode) {
  513.         case TCODE_WRITEQ:
  514.         case TCODE_WRITEB:
  515.                 if (tcode == TCODE_WRITE_RESPONSE) tcode_match = 1;
  516.                 break;
  517.         case TCODE_READQ:
  518.                 if (tcode == TCODE_READQ_RESPONSE) tcode_match = 1;
  519.                 break;
  520.         case TCODE_READB:
  521.                 if (tcode == TCODE_READB_RESPONSE) tcode_match = 1;
  522.                 break;
  523.         case TCODE_LOCK_REQUEST:
  524.                 if (tcode == TCODE_LOCK_RESPONSE) tcode_match = 1;
  525.                 break;
  526.         }
  528.         if (!tcode_match || (packet->tlabel != tlabel)
  529.             || (packet->node_id != (data[1] >> 16))) {
  530.                 HPSB_INFO("unsolicited response packet received");
  531.                 dump_packet("contents:", data, 16);
  533.                 spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  534.                 return;
  535.         }
  537.         list_del(&packet->list);
  539.         spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  541.         /* FIXME - update size fields? */
  542.         switch (tcode) {
  543.         case TCODE_WRITE_RESPONSE:
  544.                 memcpy(packet->header, data, 12);
  545.                 break;
  546.         case TCODE_READQ_RESPONSE:
  547.                 memcpy(packet->header, data, 16);
  548.                 break;
  549.         case TCODE_READB_RESPONSE:
  550.                 memcpy(packet->header, data, 16);
  551.                 memcpy(packet->data, data + 4, size - 16);
  552.                 break;
  553.         case TCODE_LOCK_RESPONSE:
  554.                 memcpy(packet->header, data, 16);
  555.                 memcpy(packet->data, data + 4, (size - 16) > 8 ? 8 : size - 16);
  556.                 break;
  557.         }
  559.         packet->state = hpsb_complete;
  560.         up(&packet->state_change);
  561. process_complete_tasks(packet);
  562. }
  565. static struct hpsb_packet *create_reply_packet(struct hpsb_host *host,
  566.        quadlet_t *data, size_t dsize)
  567. {
  568.         struct hpsb_packet *p;
  570.         dsize += (dsize % 4 ? 4 - (dsize % 4) : 0);
  572.         p = alloc_hpsb_packet(dsize);
  573.         if (p == NULL) {
  574.                 /* FIXME - send data_error response */
  575.                 return NULL;
  576.         }
  578.         p->type = hpsb_async;
  579.         p->state = hpsb_unused;
  580.         p->host = host;
  581.         p->node_id = data[1] >> 16;
  582.         p->tlabel = (data[0] >> 10) & 0x3f;
  583.         p->no_waiter = 1;
  585. p->generation = get_hpsb_generation(host);
  587.         if (dsize % 4) {
  588.                 p->data[dsize / 4] = 0;
  589.         }
  591.         return p;
  592. }
  594. #define PREP_REPLY_PACKET(length) 
  595.                 packet = create_reply_packet(host, data, length); 
  596.                 if (packet == NULL) break
  598. static void handle_incoming_packet(struct hpsb_host *host, int tcode,
  599.    quadlet_t *data, size_t size, int write_acked)
  600. {
  601.         struct hpsb_packet *packet;
  602.         int length, rcode, extcode;
  603.         nodeid_t source = data[1] >> 16;
  604. nodeid_t dest = data[0] >> 16;
  605.         u64 addr;
  607.         /* big FIXME - no error checking is done for an out of bounds length */
  609.         switch (tcode) {
  610.         case TCODE_WRITEQ:
  611.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  612.                 rcode = highlevel_write(host, source, dest, data+3,
  613. addr, 4);
  615.                 if (!write_acked
  616.                     && ((data[0] >> 16) & NODE_MASK) != NODE_MASK) {
  617.                         /* not a broadcast write, reply */
  618.                         PREP_REPLY_PACKET(0);
  619.                         fill_async_write_resp(packet, rcode);
  620.                         send_packet_nocare(packet);
  621.                 }
  622.                 break;
  624.         case TCODE_WRITEB:
  625.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  626.                 rcode = highlevel_write(host, source, dest, data+4,
  627. addr, data[3]>>16);
  629.                 if (!write_acked
  630.                     && ((data[0] >> 16) & NODE_MASK) != NODE_MASK) {
  631.                         /* not a broadcast write, reply */
  632.                         PREP_REPLY_PACKET(0);
  633.                         fill_async_write_resp(packet, rcode);
  634.                         send_packet_nocare(packet);
  635.                 }
  636.                 break;
  638.         case TCODE_READQ:
  639.                 PREP_REPLY_PACKET(0);
  641.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  642.                 rcode = highlevel_read(host, source, data, addr, 4);
  643.                 fill_async_readquad_resp(packet, rcode, *data);
  644.                 send_packet_nocare(packet);
  645.                 break;
  647.         case TCODE_READB:
  648.                 length = data[3] >> 16;
  649.                 PREP_REPLY_PACKET(length);
  651.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  652.                 rcode = highlevel_read(host, source, packet->data, addr,
  653.                                        length);
  654.                 fill_async_readblock_resp(packet, rcode, length);
  655.                 send_packet_nocare(packet);
  656.                 break;
  658.         case TCODE_LOCK_REQUEST:
  659.                 length = data[3] >> 16;
  660.                 extcode = data[3] & 0xffff;
  661.                 addr = (((u64)(data[1] & 0xffff)) << 32) | data[2];
  663.                 PREP_REPLY_PACKET(8);
  665.                 if ((extcode == 0) || (extcode >= 7)) {
  666.                         /* let switch default handle error */
  667.                         length = 0;
  668.                 }
  670.                 switch (length) {
  671.                 case 4:
  672.                         rcode = highlevel_lock(host, source, packet->data, addr,
  673.                                                data[4], 0, extcode);
  674.                         fill_async_lock_resp(packet, rcode, extcode, 4);
  675.                         break;
  676.                 case 8:
  677.                         if ((extcode != EXTCODE_FETCH_ADD) 
  678.                             && (extcode != EXTCODE_LITTLE_ADD)) {
  679.                                 rcode = highlevel_lock(host, source,
  680.                                                        packet->data, addr,
  681.                                                        data[5], data[4], 
  682.                                                        extcode);
  683.                                 fill_async_lock_resp(packet, rcode, extcode, 4);
  684.                         } else {
  685.                                 rcode = highlevel_lock64(host, source,
  686.                                              (octlet_t *)packet->data, addr,
  687.                                              *(octlet_t *)(data + 4), 0ULL,
  688.                                              extcode);
  689.                                 fill_async_lock_resp(packet, rcode, extcode, 8);
  690.                         }
  691.                         break;
  692.                 case 16:
  693.                         rcode = highlevel_lock64(host, source,
  694.                                                  (octlet_t *)packet->data, addr,
  695.                                                  *(octlet_t *)(data + 6),
  696.                                                  *(octlet_t *)(data + 4), 
  697.                                                  extcode);
  698.                         fill_async_lock_resp(packet, rcode, extcode, 8);
  699.                         break;
  700.                 default:
  701.                         fill_async_lock_resp(packet, RCODE_TYPE_ERROR,
  702.                                              extcode, 0);
  703.                 }
  705.                 send_packet_nocare(packet);
  706.                 break;
  707.         }
  709. }
  710. #undef PREP_REPLY_PACKET
  713. void hpsb_packet_received(struct hpsb_host *host, quadlet_t *data, size_t size,
  714.                           int write_acked)
  715. {
  716.         int tcode;
  718.         if (host->in_bus_reset) {
  719.                 HPSB_INFO("received packet during reset; ignoring");
  720.                 return;
  721.         }
  723. #ifdef CONFIG_IEEE1394_VERBOSEDEBUG
  724.         dump_packet("received packet:", data, size);
  725. #endif
  727.         tcode = (data[0] >> 4) & 0xf;
  729.         switch (tcode) {
  730.         case TCODE_WRITE_RESPONSE:
  731.         case TCODE_READQ_RESPONSE:
  732.         case TCODE_READB_RESPONSE:
  733.         case TCODE_LOCK_RESPONSE:
  734.                 handle_packet_response(host, tcode, data, size);
  735.                 break;
  737.         case TCODE_WRITEQ:
  738.         case TCODE_WRITEB:
  739.         case TCODE_READQ:
  740.         case TCODE_READB:
  741.         case TCODE_LOCK_REQUEST:
  742.                 handle_incoming_packet(host, tcode, data, size, write_acked);
  743.                 break;
  746.         case TCODE_ISO_DATA:
  747.                 highlevel_iso_receive(host, data, size);
  748.                 break;
  750.         case TCODE_CYCLE_START:
  751.                 /* simply ignore this packet if it is passed on */
  752.                 break;
  754.         default:
  755.                 HPSB_NOTICE("received packet with bogus transaction code %d", 
  756.                             tcode);
  757.                 break;
  758.         }
  759. }
  762. void abort_requests(struct hpsb_host *host)
  763. {
  764.         unsigned long flags;
  765.         struct hpsb_packet *packet;
  766.         struct list_head *lh;
  767.         LIST_HEAD(llist);
  769.         host->driver->devctl(host, CANCEL_REQUESTS, 0);
  771.         spin_lock_irqsave(&host->pending_pkt_lock, flags);
  772.         list_splice(&host->pending_packets, &llist);
  773.         INIT_LIST_HEAD(&host->pending_packets);
  774.         spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  776.         list_for_each(lh, &llist) {
  777.                 packet = list_entry(lh, struct hpsb_packet, list);
  778.                 packet->state = hpsb_complete;
  779.                 packet->ack_code = ACKX_ABORTED;
  780.                 up(&packet->state_change);
  781. process_complete_tasks(packet);
  782.         }
  783. }
  785. void abort_timedouts(struct hpsb_host *host)
  786. {
  787.         unsigned long flags;
  788.         struct hpsb_packet *packet;
  789.         unsigned long expire;
  790.         struct list_head *lh, *next;
  791.         LIST_HEAD(expiredlist);
  793.         spin_lock_irqsave(&host->csr.lock, flags);
  794.         expire = (host->csr.split_timeout_hi * 8000 
  795.                   + (host->csr.split_timeout_lo >> 19))
  796.                 * HZ / 8000;
  797.         /* Avoid shortening of timeout due to rounding errors: */
  798.         expire++;
  799.         spin_unlock_irqrestore(&host->csr.lock, flags);
  802.         spin_lock_irqsave(&host->pending_pkt_lock, flags);
  804. for (lh = host->pending_packets.next; lh != &host->pending_packets; lh = next) {
  805.                 packet = list_entry(lh, struct hpsb_packet, list);
  806. next = lh->next;
  807.                 if (time_before(packet->sendtime + expire, jiffies)) {
  808.                         list_del(&packet->list);
  809.                         list_add(&packet->list, &expiredlist);
  810.                 }
  811.         }
  813.         if (!list_empty(&host->pending_packets))
  814. schedule_task(&host->timeout_tq);
  816.         spin_unlock_irqrestore(&host->pending_pkt_lock, flags);
  818.         list_for_each(lh, &expiredlist) {
  819.                 packet = list_entry(lh, struct hpsb_packet, list);
  820.                 packet->state = hpsb_complete;
  821.                 packet->ack_code = ACKX_TIMEOUT;
  822.                 up(&packet->state_change);
  823. process_complete_tasks(packet);
  824.         }
  825. }
  828. /*
  829.  * character device dispatching (see ieee1394_core.h)
  830.  * Dan Maas <dmaas@dcine.com>
  831.  */
  833. static struct {
  834. struct file_operations *file_ops;
  835. struct module *module;
  836. } ieee1394_chardevs[16];
  838. static rwlock_t ieee1394_chardevs_lock = RW_LOCK_UNLOCKED;
  840. static int ieee1394_dispatch_open(struct inode *inode, struct file *file);
  842. static struct file_operations ieee1394_chardev_ops = {
  843. .owner =THIS_MODULE,
  844. .open = ieee1394_dispatch_open,
  845. };
  847. devfs_handle_t ieee1394_devfs_handle;
  850. /* claim a block of minor numbers */
  851. int ieee1394_register_chardev(int blocknum,
  852.       struct module *module,
  853.       struct file_operations *file_ops)
  854. {
  855. int retval;
  857. if( (blocknum < 0) || (blocknum > 15) )
  858. return -EINVAL;
  860. write_lock(&ieee1394_chardevs_lock);
  862. if(ieee1394_chardevs[blocknum].file_ops == NULL) {
  863. /* grab the minor block */
  864. ieee1394_chardevs[blocknum].file_ops = file_ops;
  865. ieee1394_chardevs[blocknum].module = module;
  867. retval = 0;
  868. } else {
  869. /* block already taken */
  870. retval = -EBUSY;
  871. }
  873. write_unlock(&ieee1394_chardevs_lock);
  875. return retval;
  876. }
  878. /* release a block of minor numbers */
  879. void ieee1394_unregister_chardev(int blocknum)
  880. {
  881. if( (blocknum < 0) || (blocknum > 15) )
  882. return;
  884. write_lock(&ieee1394_chardevs_lock);
  886. if(ieee1394_chardevs[blocknum].file_ops) {
  887. ieee1394_chardevs[blocknum].file_ops = NULL;
  888. ieee1394_chardevs[blocknum].module = NULL;
  889. }
  891. write_unlock(&ieee1394_chardevs_lock);
  892. }
  894. /*
  895.   ieee1394_get_chardev() - look up and acquire a character device
  896.   driver that has previously registered using ieee1394_register_chardev()
  897.   
  898.   On success, returns 1 and sets module and file_ops to the driver.
  899.   The module will have an incremented reference count.
  900.    
  901.   On failure, returns 0.
  902.   The module will NOT have an incremented reference count.
  903. */
  905. static int ieee1394_get_chardev(int blocknum,
  906. struct module **module,
  907. struct file_operations **file_ops)
  908. {
  909. int ret = 0;
  910.        
  911. if( (blocknum < 0) || (blocknum > 15) )
  912. return ret;
  914. read_lock(&ieee1394_chardevs_lock);
  916. *module = ieee1394_chardevs[blocknum].module;
  917. *file_ops = ieee1394_chardevs[blocknum].file_ops;
  919. if(*file_ops == NULL)
  920. goto out;
  922. /* don't need try_inc_mod_count if the driver is non-modular */
  923. if(*module && (try_inc_mod_count(*module) == 0))
  924. goto out;
  926. /* success! */
  927. ret = 1;
  929. out:
  930. read_unlock(&ieee1394_chardevs_lock);
  931. return ret;
  932. }
  934. /* the point of entry for open() on any ieee1394 character device */
  935. static int ieee1394_dispatch_open(struct inode *inode, struct file *file)
  936. {
  937. struct file_operations *file_ops;
  938. struct module *module;
  939. int blocknum;
  940. int retval;
  942. /*
  943.   Maintaining correct module reference counts is tricky here!
  945.   The key thing to remember is that the VFS increments the
  946.   reference count of ieee1394 before it calls
  947.   ieee1394_dispatch_open().
  949.   If the open() succeeds, then we need to transfer this extra
  950.   reference to the task-specific driver module (e.g. raw1394).
  951.   The VFS will deref the driver module automatically when the
  952.   file is later released.
  954.   If the open() fails, then the VFS will drop the
  955.   reference count of whatever module file->f_op->owner points
  956.   to, immediately after this function returns.
  957. */
  959.         /* shift away lower four bits of the minor
  960.    to get the index of the ieee1394_driver
  961.    we want */
  963. blocknum = (minor(inode->i_rdev) >> 4) & 0xF;
  965. /* look up the driver */
  967. if(ieee1394_get_chardev(blocknum, &module, &file_ops) == 0)
  968. return -ENODEV;
  970. /* redirect all subsequent requests to the driver's
  971.    own file_operations */
  972. file->f_op = file_ops;
  974. /* at this point BOTH ieee1394 and the task-specific driver have
  975.    an extra reference */
  977. /* follow through with the open() */
  978. retval = file_ops->open(inode, file);
  980. if(retval == 0) {
  982. /* If the open() succeeded, then ieee1394 will be left
  983.    with an extra module reference, so we discard it here.
  985.    The task-specific driver still has the extra
  986.    reference given to it by ieee1394_get_chardev().
  987.    This extra reference prevents the module from
  988.    unloading while the file is open, and will be
  989.    dropped by the VFS when the file is released.
  990. */
  992. if(THIS_MODULE)
  993. __MOD_DEC_USE_COUNT((struct module*) THIS_MODULE);
  995. /* note that if ieee1394 is compiled into the kernel,
  996.    THIS_MODULE will be (void*) NULL, hence the if and
  997.    the cast are necessary */
  999. } else {
  1001. /* if the open() failed, then we need to drop the
  1002.    extra reference we gave to the task-specific
  1003.    driver */
  1005. if(module)
  1006. __MOD_DEC_USE_COUNT(module);
  1008. /* point the file's f_ops back to ieee1394. The VFS will then
  1009.    decrement ieee1394's reference count immediately after this
  1010.    function returns. */
  1012. file->f_op = &ieee1394_chardev_ops;
  1013. }
  1015. return retval;
  1016. }
  1018. struct proc_dir_entry *ieee1394_procfs_entry;
  1020. static int __init ieee1394_init(void)
  1021. {
  1022. hpsb_packet_cache = kmem_cache_create("hpsb_packet", sizeof(struct hpsb_packet),
  1023.       0, 0, NULL, NULL);
  1025. ieee1394_devfs_handle = devfs_mk_dir(NULL, "ieee1394", NULL);
  1027. if (register_chrdev(IEEE1394_MAJOR, "ieee1394", &ieee1394_chardev_ops)) {
  1028. HPSB_ERR("unable to register character device major %d!n", IEEE1394_MAJOR);
  1029. devfs_unregister(ieee1394_devfs_handle);
  1030. return -ENODEV;
  1031. }
  1033. #ifdef CONFIG_PROC_FS
  1034. /* Must be done before we start everything else, since the drivers
  1035.  * may use it.  */
  1036. ieee1394_procfs_entry = proc_mkdir( "ieee1394", proc_bus);
  1037. if (ieee1394_procfs_entry == NULL) {
  1038. HPSB_ERR("unable to create /proc/bus/ieee1394n");
  1039. unregister_chrdev(IEEE1394_MAJOR, "ieee1394");
  1040. devfs_unregister(ieee1394_devfs_handle);
  1041. return -ENOMEM;
  1042. }
  1043. ieee1394_procfs_entry->owner = THIS_MODULE;
  1044. #endif
  1046. init_hpsb_highlevel();
  1047. init_csr();
  1048. if (!disable_nodemgr)
  1049. init_ieee1394_nodemgr(disable_hotplug);
  1050. else
  1051. HPSB_INFO("nodemgr functionality disabled");
  1053. return 0;
  1054. }
  1056. static void __exit ieee1394_cleanup(void)
  1057. {
  1058. if (!disable_nodemgr)
  1059. cleanup_ieee1394_nodemgr();
  1061. cleanup_csr();
  1062. kmem_cache_destroy(hpsb_packet_cache);
  1064. unregister_chrdev(IEEE1394_MAJOR, "ieee1394");
  1066. /* it's ok to pass a NULL devfs_handle to devfs_unregister */
  1067. devfs_unregister(ieee1394_devfs_handle);
  1069. remove_proc_entry("ieee1394", proc_bus);
  1070. }
  1072. module_init(ieee1394_init);
  1073. module_exit(ieee1394_cleanup);
  1075. /* Exported symbols */
  1076. EXPORT_SYMBOL(hpsb_alloc_host);
  1077. EXPORT_SYMBOL(hpsb_add_host);
  1078. EXPORT_SYMBOL(hpsb_remove_host);
  1079. EXPORT_SYMBOL(hpsb_ref_host);
  1080. EXPORT_SYMBOL(hpsb_unref_host);
  1081. EXPORT_SYMBOL(hpsb_speedto_str);
  1082. EXPORT_SYMBOL(hpsb_add_packet_complete_task);
  1084. EXPORT_SYMBOL(alloc_hpsb_packet);
  1085. EXPORT_SYMBOL(free_hpsb_packet);
  1086. EXPORT_SYMBOL(hpsb_send_packet);
  1087. EXPORT_SYMBOL(hpsb_reset_bus);
  1088. EXPORT_SYMBOL(hpsb_bus_reset);
  1089. EXPORT_SYMBOL(hpsb_selfid_received);
  1090. EXPORT_SYMBOL(hpsb_selfid_complete);
  1091. EXPORT_SYMBOL(hpsb_packet_sent);
  1092. EXPORT_SYMBOL(hpsb_packet_received);
  1094. EXPORT_SYMBOL(get_tlabel);
  1095. EXPORT_SYMBOL(free_tlabel);
  1096. EXPORT_SYMBOL(fill_async_readquad);
  1097. EXPORT_SYMBOL(fill_async_readquad_resp);
  1098. EXPORT_SYMBOL(fill_async_readblock);
  1099. EXPORT_SYMBOL(fill_async_readblock_resp);
  1100. EXPORT_SYMBOL(fill_async_writequad);
  1101. EXPORT_SYMBOL(fill_async_writeblock);
  1102. EXPORT_SYMBOL(fill_async_write_resp);
  1103. EXPORT_SYMBOL(fill_async_lock);
  1104. EXPORT_SYMBOL(fill_async_lock_resp);
  1105. EXPORT_SYMBOL(fill_iso_packet);
  1106. EXPORT_SYMBOL(fill_phy_packet);
  1107. EXPORT_SYMBOL(hpsb_make_readqpacket);
  1108. EXPORT_SYMBOL(hpsb_make_readbpacket);
  1109. EXPORT_SYMBOL(hpsb_make_writeqpacket);
  1110. EXPORT_SYMBOL(hpsb_make_writebpacket);
  1111. EXPORT_SYMBOL(hpsb_make_lockpacket);
  1112. EXPORT_SYMBOL(hpsb_make_phypacket);
  1113. EXPORT_SYMBOL(hpsb_packet_success);
  1114. EXPORT_SYMBOL(hpsb_make_packet);
  1115. EXPORT_SYMBOL(hpsb_read);
  1116. EXPORT_SYMBOL(hpsb_write);
  1117. EXPORT_SYMBOL(hpsb_lock);
  1119. EXPORT_SYMBOL(hpsb_register_highlevel);
  1120. EXPORT_SYMBOL(hpsb_unregister_highlevel);
  1121. EXPORT_SYMBOL(hpsb_register_addrspace);
  1122. EXPORT_SYMBOL(hpsb_listen_channel);
  1123. EXPORT_SYMBOL(hpsb_unlisten_channel);
  1124. EXPORT_SYMBOL(highlevel_read);
  1125. EXPORT_SYMBOL(highlevel_write);
  1126. EXPORT_SYMBOL(highlevel_lock);
  1127. EXPORT_SYMBOL(highlevel_lock64);
  1128. EXPORT_SYMBOL(highlevel_add_host);
  1129. EXPORT_SYMBOL(highlevel_remove_host);
  1130. EXPORT_SYMBOL(highlevel_host_reset);
  1132. EXPORT_SYMBOL(hpsb_guid_get_entry);
  1133. EXPORT_SYMBOL(hpsb_nodeid_get_entry);
  1134. EXPORT_SYMBOL(hpsb_node_fill_packet);
  1135. EXPORT_SYMBOL(hpsb_node_read);
  1136. EXPORT_SYMBOL(hpsb_node_write);
  1137. EXPORT_SYMBOL(hpsb_node_lock);
  1138. EXPORT_SYMBOL(hpsb_register_protocol);
  1139. EXPORT_SYMBOL(hpsb_unregister_protocol);
  1140. EXPORT_SYMBOL(hpsb_release_unit_directory);
  1142. EXPORT_SYMBOL(ieee1394_register_chardev);
  1143. EXPORT_SYMBOL(ieee1394_unregister_chardev);
  1144. EXPORT_SYMBOL(ieee1394_devfs_handle);
  1146. EXPORT_SYMBOL(ieee1394_procfs_entry);