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

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

Linux/Unix编程

开发平台：

Unix_Linux

raw1394.c：源码内容
  1. /*
  2.  * IEEE 1394 for Linux
  3.  *
  4.  * Raw interface to the bus
  5.  *
  6.  * Copyright (C) 1999, 2000 Andreas E. Bombe
  7.  *
  8.  * This code is licensed under the GPL.  See the file COPYING in the root
  9.  * directory of the kernel sources for details.
  10.  */
  12. #include <linux/kernel.h>
  13. #include <linux/list.h>
  14. #include <linux/string.h>
  15. #include <linux/slab.h>
  16. #include <linux/fs.h>
  17. #include <linux/poll.h>
  18. #include <linux/module.h>
  19. #include <linux/init.h>
  20. #include <linux/version.h>
  21. #include <linux/smp_lock.h>
  22. #include <asm/uaccess.h>
  23. #include <asm/atomic.h>
  24. #include <linux/devfs_fs_kernel.h>
  26. #include "ieee1394.h"
  27. #include "ieee1394_types.h"
  28. #include "ieee1394_core.h"
  29. #include "hosts.h"
  30. #include "highlevel.h"
  31. #include "ieee1394_transactions.h"
  32. #include "raw1394.h"
  35. #if BITS_PER_LONG == 64
  36. #define int2ptr(x) ((void *)x)
  37. #define ptr2int(x) ((u64)x)
  38. #else
  39. #define int2ptr(x) ((void *)(u32)x)
  40. #define ptr2int(x) ((u64)(u32)x)
  41. #endif
  44. static devfs_handle_t devfs_handle;
  46. static LIST_HEAD(host_info_list);
  47. static int host_count;
  48. static spinlock_t host_info_lock = SPIN_LOCK_UNLOCKED;
  49. static atomic_t internal_generation = ATOMIC_INIT(0);
  51. static struct hpsb_highlevel *hl_handle;
  53. static atomic_t iso_buffer_size;
  54. static const int iso_buffer_max = 4 * 1024 * 1024; /* 4 MB */
  56. static void queue_complete_cb(struct pending_request *req);
  58. static struct pending_request *__alloc_pending_request(int flags)
  59. {
  60.         struct pending_request *req;
  62.         req = (struct pending_request *)kmalloc(sizeof(struct pending_request),
  63.                                                 flags);
  64.         if (req != NULL) {
  65.                 memset(req, 0, sizeof(struct pending_request));
  66.                 INIT_LIST_HEAD(&req->list);
  67. INIT_TQUEUE(&req->tq, (void(*)(void*))queue_complete_cb, NULL);
  68.         }
  70.         return req;
  71. }
  73. static inline struct pending_request *alloc_pending_request(void)
  74. {
  75.         return __alloc_pending_request(SLAB_KERNEL);
  76. }
  78. static void free_pending_request(struct pending_request *req)
  79. {
  80.         if (req->ibs) {
  81.                 if (atomic_dec_and_test(&req->ibs->refcount)) {
  82.                         atomic_sub(req->ibs->data_size, &iso_buffer_size);
  83.                         kfree(req->ibs);
  84.                 }
  85.         } else if (req->free_data) {
  86.                 kfree(req->data);
  87.         }
  88.         free_hpsb_packet(req->packet);
  89.         kfree(req);
  90. }
  92. static void queue_complete_req(struct pending_request *req)
  93. {
  94.         unsigned long flags;
  95.         struct file_info *fi = req->file_info;
  97.         spin_lock_irqsave(&fi->reqlists_lock, flags);
  98.         list_del(&req->list);
  99.         list_add_tail(&req->list, &fi->req_complete);
  100.         spin_unlock_irqrestore(&fi->reqlists_lock, flags);
  102.         up(&fi->complete_sem);
  103.         wake_up_interruptible(&fi->poll_wait_complete);
  104. }
  106. static void queue_complete_cb(struct pending_request *req)
  107. {
  108.         struct hpsb_packet *packet = req->packet;
  109.         int rcode = (packet->header[1] >> 12) & 0xf;
  111.         switch (packet->ack_code) {
  112.         case ACKX_NONE:
  113.         case ACKX_SEND_ERROR:
  114.                 req->req.error = RAW1394_ERROR_SEND_ERROR;
  115.                 break;
  116.         case ACKX_ABORTED:
  117.                 req->req.error = RAW1394_ERROR_ABORTED;
  118.                 break;
  119.         case ACKX_TIMEOUT:
  120.                 req->req.error = RAW1394_ERROR_TIMEOUT;
  121.                 break;
  122.         default:
  123.                 req->req.error = (packet->ack_code << 16) | rcode;
  124.                 break;
  125.         }
  127.         if (!((packet->ack_code == ACK_PENDING) && (rcode == RCODE_COMPLETE))) {
  128.                 req->req.length = 0;
  129.         }
  131.         free_tlabel(packet->host, packet->node_id, packet->tlabel);
  133.         queue_complete_req(req);
  134. }
  137. static void add_host(struct hpsb_host *host)
  138. {
  139.         struct host_info *hi;
  141.         hi = (struct host_info *)kmalloc(sizeof(struct host_info), SLAB_KERNEL);
  142.         if (hi != NULL) {
  143.                 INIT_LIST_HEAD(&hi->list);
  144.                 hi->host = host;
  145.                 INIT_LIST_HEAD(&hi->file_info_list);
  147.                 spin_lock_irq(&host_info_lock);
  148.                 list_add_tail(&hi->list, &host_info_list);
  149.                 host_count++;
  150.                 spin_unlock_irq(&host_info_lock);
  151.         }
  153.         atomic_inc(&internal_generation);
  154. }
  157. static struct host_info *find_host_info(struct hpsb_host *host)
  158. {
  159.         struct list_head *lh;
  160.         struct host_info *hi;
  162.         list_for_each(lh, &host_info_list) {
  163.                 hi = list_entry(lh, struct host_info, list);
  164.                 if (hi->host == host) {
  165.                         return hi;
  166.                 }
  167.         }
  169.         return NULL;
  170. }
  172. static void remove_host(struct hpsb_host *host)
  173. {
  174.         struct host_info *hi;
  176.         spin_lock_irq(&host_info_lock);
  177.         hi = find_host_info(host);
  179.         if (hi != NULL) {
  180.                 list_del(&hi->list);
  181.                 host_count--;
  182.         }
  183.         spin_unlock_irq(&host_info_lock);
  185.         if (hi == NULL) {
  186.                 printk(KERN_ERR "raw1394: attempt to remove unknown host "
  187.                        "0x%pn", host);
  188.                 return;
  189.         }
  191.         kfree(hi);
  193.         atomic_inc(&internal_generation);
  194. }
  196. static void host_reset(struct hpsb_host *host)
  197. {
  198.         unsigned long flags;
  199.         struct list_head *lh;
  200.         struct host_info *hi;
  201.         struct file_info *fi;
  202.         struct pending_request *req;
  204.         spin_lock_irqsave(&host_info_lock, flags);
  205.         hi = find_host_info(host);
  207.         if (hi != NULL) {
  208.                 list_for_each(lh, &hi->file_info_list) {
  209.                         fi = list_entry(lh, struct file_info, list);
  210.                         req = __alloc_pending_request(SLAB_ATOMIC);
  212.                         if (req != NULL) {
  213.                                 req->file_info = fi;
  214.                                 req->req.type = RAW1394_REQ_BUS_RESET;
  215.                                 req->req.generation = get_hpsb_generation(host);
  216.                                 req->req.misc = (host->node_id << 16)
  217.                                         | host->node_count;
  218.                                 if (fi->protocol_version > 3) {
  219.                                         req->req.misc |= ((host->irm_id
  220.                                                            & NODE_MASK) << 8);
  221.                                 }
  223.                                 queue_complete_req(req);
  224.                         }
  225.                 }
  226.         }
  227.         spin_unlock_irqrestore(&host_info_lock, flags);
  228. }
  230. static void iso_receive(struct hpsb_host *host, int channel, quadlet_t *data,
  231.                         unsigned int length)
  232. {
  233.         unsigned long flags;
  234.         struct list_head *lh;
  235.         struct host_info *hi;
  236.         struct file_info *fi;
  237.         struct pending_request *req;
  238.         struct iso_block_store *ibs = NULL;
  239.         LIST_HEAD(reqs);
  241.         if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
  242.                 HPSB_INFO("dropped iso packet");
  243.                 return;
  244.         }
  246.         spin_lock_irqsave(&host_info_lock, flags);
  247.         hi = find_host_info(host);
  249.         if (hi != NULL) {
  250. list_for_each(lh, &hi->file_info_list) {
  251.                         fi = list_entry(lh, struct file_info, list);
  253.                         if (!(fi->listen_channels & (1ULL << channel))) {
  254.                                 continue;
  255.                         }
  257.                         req = __alloc_pending_request(SLAB_ATOMIC);
  258.                         if (!req) break;
  260.                         if (!ibs) {
  261.                                 ibs = kmalloc(sizeof(struct iso_block_store)
  262.                                               + length, SLAB_ATOMIC);
  263.                                 if (!ibs) {
  264.                                         kfree(req);
  265.                                         break;
  266.                                 }
  268.                                 atomic_add(length, &iso_buffer_size);
  269.                                 atomic_set(&ibs->refcount, 0);
  270.                                 ibs->data_size = length;
  271.                                 memcpy(ibs->data, data, length);
  272.                         }
  274.                         atomic_inc(&ibs->refcount);
  276.                         req->file_info = fi;
  277.                         req->ibs = ibs;
  278.                         req->data = ibs->data;
  279.                         req->req.type = RAW1394_REQ_ISO_RECEIVE;
  280.                         req->req.generation = get_hpsb_generation(host);
  281.                         req->req.misc = 0;
  282.                         req->req.recvb = ptr2int(fi->iso_buffer);
  283.                         req->req.length = MIN(length, fi->iso_buffer_length);
  284.                         
  285.                         list_add_tail(&req->list, &reqs);
  286.                 }
  287.         }
  288.         spin_unlock_irqrestore(&host_info_lock, flags);
  290.         lh = reqs.next;
  291.         while (lh != &reqs) {
  292.                 req = list_entry(lh, struct pending_request, list);
  293.                 lh = lh->next;
  295.                 queue_complete_req(req);
  296.         }
  297. }
  299. static void fcp_request(struct hpsb_host *host, int nodeid, int direction,
  300.                         int cts, u8 *data, unsigned int length)
  301. {
  302.         unsigned long flags;
  303.         struct list_head *lh;
  304.         struct host_info *hi;
  305.         struct file_info *fi;
  306.         struct pending_request *req;
  307.         struct iso_block_store *ibs = NULL;
  308.         LIST_HEAD(reqs);
  310.         if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
  311.                 HPSB_INFO("dropped fcp request");
  312.                 return;
  313.         }
  315.         spin_lock_irqsave(&host_info_lock, flags);
  316.         hi = find_host_info(host);
  318.         if (hi != NULL) {
  319. list_for_each(lh, &hi->file_info_list) {
  320.                         fi = list_entry(lh, struct file_info, list);
  322.                         if (!fi->fcp_buffer) {
  323.                                 continue;
  324.                         }
  326.                         req = __alloc_pending_request(SLAB_ATOMIC);
  327.                         if (!req) break;
  329.                         if (!ibs) {
  330.                                 ibs = kmalloc(sizeof(struct iso_block_store)
  331.                                               + length, SLAB_ATOMIC);
  332.                                 if (!ibs) {
  333.                                         kfree(req);
  334.                                         break;
  335.                                 }
  337.                                 atomic_add(length, &iso_buffer_size);
  338.                                 atomic_set(&ibs->refcount, 0);
  339.                                 ibs->data_size = length;
  340.                                 memcpy(ibs->data, data, length);
  341.                         }
  343.                         atomic_inc(&ibs->refcount);
  345.                         req->file_info = fi;
  346.                         req->ibs = ibs;
  347.                         req->data = ibs->data;
  348.                         req->req.type = RAW1394_REQ_FCP_REQUEST;
  349.                         req->req.generation = get_hpsb_generation(host);
  350.                         req->req.misc = nodeid | (direction << 16);
  351.                         req->req.recvb = ptr2int(fi->fcp_buffer);
  352.                         req->req.length = length;
  353.                         
  354.                         list_add_tail(&req->list, &reqs);
  355.                 }
  356.         }
  357.         spin_unlock_irqrestore(&host_info_lock, flags);
  359.         lh = reqs.next;
  360.         while (lh != &reqs) {
  361.                 req = list_entry(lh, struct pending_request, list);
  362.                 lh = lh->next;
  364.                 queue_complete_req(req);
  365.         }
  366. }
  369. static ssize_t raw1394_read(struct file *file, char *buffer, size_t count,
  370.                     loff_t *offset_is_ignored)
  371. {
  372.         struct file_info *fi = (struct file_info *)file->private_data;
  373.         struct list_head *lh;
  374.         struct pending_request *req;
  376.         if (count != sizeof(struct raw1394_request)) {
  377.                 return -EINVAL;
  378.         }
  380.         if (!access_ok(VERIFY_WRITE, buffer, count)) {
  381.                 return -EFAULT;
  382.         }
  384.         if (file->f_flags & O_NONBLOCK) {
  385.                 if (down_trylock(&fi->complete_sem)) {
  386.                         return -EAGAIN;
  387.                 }
  388.         } else {
  389.                 if (down_interruptible(&fi->complete_sem)) {
  390.                         return -ERESTARTSYS;
  391.                 }
  392.         }
  394.         spin_lock_irq(&fi->reqlists_lock);
  395.         lh = fi->req_complete.next;
  396.         list_del(lh);
  397.         spin_unlock_irq(&fi->reqlists_lock);
  399.         req = list_entry(lh, struct pending_request, list);
  401.         if (req->req.length) {
  402.                 if (copy_to_user(int2ptr(req->req.recvb), req->data,
  403.                                  req->req.length)) {
  404.                         req->req.error = RAW1394_ERROR_MEMFAULT;
  405.                 }
  406.         }
  407.         __copy_to_user(buffer, &req->req, sizeof(req->req));
  409.         free_pending_request(req);
  410.         return sizeof(struct raw1394_request);
  411. }
  414. static int state_opened(struct file_info *fi, struct pending_request *req)
  415. {
  416.         if (req->req.type == RAW1394_REQ_INITIALIZE) {
  417.                 switch (req->req.misc) {
  418.                 case RAW1394_KERNELAPI_VERSION:
  419.                 case 3:
  420.                         fi->state = initialized;
  421.                         fi->protocol_version = req->req.misc;
  422.                         req->req.error = RAW1394_ERROR_NONE;
  423.                         req->req.generation = atomic_read(&internal_generation);
  424.                         break;
  426.                 default:
  427.                         req->req.error = RAW1394_ERROR_COMPAT;
  428.                         req->req.misc = RAW1394_KERNELAPI_VERSION;
  429.                 }
  430.         } else {
  431.                 req->req.error = RAW1394_ERROR_STATE_ORDER;
  432.         }
  434.         req->req.length = 0;
  435.         queue_complete_req(req);
  436.         return sizeof(struct raw1394_request);
  437. }
  439. static int state_initialized(struct file_info *fi, struct pending_request *req)
  440. {
  441.         struct list_head *lh;
  442.         struct host_info *hi;
  443.         struct raw1394_khost_list *khl;
  445.         if (req->req.generation != atomic_read(&internal_generation)) {
  446.                 req->req.error = RAW1394_ERROR_GENERATION;
  447.                 req->req.generation = atomic_read(&internal_generation);
  448.                 req->req.length = 0;
  449.                 queue_complete_req(req);
  450.                 return sizeof(struct raw1394_request);
  451.         }
  453.         switch (req->req.type) {
  454.         case RAW1394_REQ_LIST_CARDS:
  455.                 spin_lock_irq(&host_info_lock);
  456.                 khl = kmalloc(sizeof(struct raw1394_khost_list) * host_count,
  457.                               SLAB_ATOMIC);
  459.                 if (khl != NULL) {
  460.                         req->req.misc = host_count;
  461.                         req->data = (quadlet_t *)khl;
  462.                         
  463.                         list_for_each(lh, &host_info_list) {
  464.                                 hi = list_entry(lh, struct host_info, list);
  466.                                 khl->nodes = hi->host->node_count;
  467.                                 strcpy(khl->name, hi->host->driver->name);
  469.                                 khl++;
  470.                         }
  471.                 }
  472.                 spin_unlock_irq(&host_info_lock);
  474.                 if (khl != NULL) {
  475.                         req->req.error = RAW1394_ERROR_NONE;
  476.                         req->req.length = MIN(req->req.length,
  477.                                               sizeof(struct raw1394_khost_list)
  478.                                               * req->req.misc);
  479.                         req->free_data = 1;
  480.                 } else {
  481.                         return -ENOMEM;
  482.                 }
  483.                 break;
  485.         case RAW1394_REQ_SET_CARD:
  486.                 lh = NULL;
  488.                 spin_lock_irq(&host_info_lock);
  489.                 if (req->req.misc < host_count) {
  490.                         lh = host_info_list.next;
  491.                         while (req->req.misc--) {
  492.                                 lh = lh->next;
  493.                         }
  494.                         hi = list_entry(lh, struct host_info, list);
  495.                         hpsb_ref_host(hi->host);
  496.                         list_add_tail(&fi->list, &hi->file_info_list);
  497.                         fi->host = hi->host;
  498.                         fi->state = connected;
  499.                 }
  500.                 spin_unlock_irq(&host_info_lock);
  502.                 if (lh != NULL) {
  503.                         req->req.error = RAW1394_ERROR_NONE;
  504.                         req->req.generation = get_hpsb_generation(fi->host);
  505.                         req->req.misc = (fi->host->node_id << 16) 
  506.                                 | fi->host->node_count;
  507.                         if (fi->protocol_version > 3) {
  508.                                 req->req.misc |=
  509.                                         (fi->host->irm_id & NODE_MASK) << 8;
  510.                         }
  511.                 } else {
  512.                         req->req.error = RAW1394_ERROR_INVALID_ARG;
  513.                 }
  515.                 req->req.length = 0;
  516.                 break;
  518.         default:
  519.                 req->req.error = RAW1394_ERROR_STATE_ORDER;
  520.                 req->req.length = 0;
  521.                 break;
  522.         }
  524.         queue_complete_req(req);
  525.         return sizeof(struct raw1394_request);
  526. }
  528. static void handle_iso_listen(struct file_info *fi, struct pending_request *req)
  529. {
  530.         int channel = req->req.misc;
  532.         spin_lock(&host_info_lock);
  533.         if ((channel > 63) || (channel < -64)) {
  534.                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  535.         } else if (channel >= 0) {
  536.                 /* allocate channel req.misc */
  537.                 if (fi->listen_channels & (1ULL << channel)) {
  538.                         req->req.error = RAW1394_ERROR_ALREADY;
  539.                 } else {
  540.                         fi->listen_channels |= 1ULL << channel;
  541.                         hpsb_listen_channel(hl_handle, fi->host, channel);
  542.                         fi->iso_buffer = int2ptr(req->req.recvb);
  543.                         fi->iso_buffer_length = req->req.length;
  544.                 }
  545.         } else {
  546.                 /* deallocate channel (one's complement neg) req.misc */
  547.                 channel = ~channel;
  549.                 if (fi->listen_channels & (1ULL << channel)) {
  550.                         hpsb_unlisten_channel(hl_handle, fi->host, channel);
  551.                         fi->listen_channels &= ~(1ULL << channel);
  552.                 } else {
  553.                         req->req.error = RAW1394_ERROR_INVALID_ARG;
  554.                 }
  555.         }
  557.         req->req.length = 0;
  558.         queue_complete_req(req);
  559.         spin_unlock(&host_info_lock);
  560. }
  562. static void handle_fcp_listen(struct file_info *fi, struct pending_request *req)
  563. {
  564.         if (req->req.misc) {
  565.                 if (fi->fcp_buffer) {
  566.                         req->req.error = RAW1394_ERROR_ALREADY;
  567.                 } else {
  568.                         fi->fcp_buffer = (u8 *)int2ptr(req->req.recvb);
  569.                 }
  570.         } else {
  571.                 if (!fi->fcp_buffer) {
  572.                         req->req.error = RAW1394_ERROR_ALREADY;
  573.                 } else {
  574.                         fi->fcp_buffer = NULL;
  575.                 }
  576.         }
  578.         req->req.length = 0;
  579.         queue_complete_req(req);
  580. }
  582. static int handle_local_request(struct file_info *fi,
  583.                                 struct pending_request *req, int node)
  584. {
  585.         u64 addr = req->req.address & 0xffffffffffffULL;
  587.         req->data = kmalloc(req->req.length, SLAB_KERNEL);
  588.         if (!req->data) return -ENOMEM;
  589.         req->free_data = 1;
  591.         switch (req->req.type) {
  592.         case RAW1394_REQ_ASYNC_READ:
  593.                 req->req.error = highlevel_read(fi->host, node, req->data, addr,
  594.                                                 req->req.length);
  595.                 break;
  597.         case RAW1394_REQ_ASYNC_WRITE:
  598.                 if (copy_from_user(req->data, int2ptr(req->req.sendb),
  599.                                    req->req.length)) {
  600.                         req->req.error = RAW1394_ERROR_MEMFAULT;
  601.                         break;
  602.                 }
  604.                 req->req.error = highlevel_write(fi->host, node, node, req->data,
  605.                                                  addr, req->req.length);
  606.                 req->req.length = 0;
  607.                 break;
  609.         case RAW1394_REQ_LOCK:
  610.                 if ((req->req.misc == EXTCODE_FETCH_ADD)
  611.                     || (req->req.misc == EXTCODE_LITTLE_ADD)) {
  612.                         if (req->req.length != 4) {
  613.                                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  614.                                 break;
  615.                         }
  616.                 } else {
  617.                         if (req->req.length != 8) {
  618.                                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  619.                                 break;
  620.                         }
  621.                 }
  623.                 if (copy_from_user(req->data, int2ptr(req->req.sendb),
  624.                                    req->req.length)) {
  625.                         req->req.error = RAW1394_ERROR_MEMFAULT;
  626.                         break;
  627.                 }
  629.                 if (req->req.length == 8) {
  630.                         req->req.error = highlevel_lock(fi->host, node,
  631.                                                         req->data, addr,
  632.                                                         req->data[1],
  633.                                                         req->data[0],
  634.                                                         req->req.misc);
  635.                         req->req.length = 4;
  636.                 } else {
  637.                         req->req.error = highlevel_lock(fi->host, node,
  638.                                                         req->data, addr,
  639.                                                         req->data[0], 0,
  640.                                                         req->req.misc);
  641.                 }
  642.                 break;
  644.         case RAW1394_REQ_LOCK64:
  645.         default:
  646.                 req->req.error = RAW1394_ERROR_STATE_ORDER;
  647.         }
  649.         if (req->req.error)
  650.                 req->req.length = 0;
  651.         if (req->req.error >= 0)
  652.                 req->req.error |= ACK_PENDING << 16;
  654.         queue_complete_req(req);
  655.         return sizeof(struct raw1394_request);
  656. }
  658. static int handle_remote_request(struct file_info *fi,
  659.                                  struct pending_request *req, int node)
  660. {
  661.         struct hpsb_packet *packet = NULL;
  662.         u64 addr = req->req.address & 0xffffffffffffULL;
  664.         switch (req->req.type) {
  665.         case RAW1394_REQ_ASYNC_READ:
  666.                 if (req->req.length == 4) {
  667.                         packet = hpsb_make_readqpacket(fi->host, node, addr);
  668.                         if (!packet) return -ENOMEM;
  670.                         req->data = &packet->header[3];
  671.                 } else {
  672.                         packet = hpsb_make_readbpacket(fi->host, node, addr,
  673.                                                        req->req.length);
  674.                         if (!packet) return -ENOMEM;
  676.                         req->data = packet->data;
  677.                 }
  678.                 break;
  680.         case RAW1394_REQ_ASYNC_WRITE:
  681.                 if (req->req.length == 4) {
  682.                         quadlet_t x;
  684.                         if (copy_from_user(&x, int2ptr(req->req.sendb), 4)) {
  685.                                 req->req.error = RAW1394_ERROR_MEMFAULT;
  686.                         }
  688.                         packet = hpsb_make_writeqpacket(fi->host, node, addr,
  689.                                                         x);
  690.                         if (!packet) return -ENOMEM;
  691.                 } else {
  692.                         packet = hpsb_make_writebpacket(fi->host, node, addr,
  693.                                                         req->req.length);
  694.                         if (!packet) return -ENOMEM;
  696.                         if (copy_from_user(packet->data, int2ptr(req->req.sendb),
  697.                                            req->req.length)) {
  698.                                 req->req.error = RAW1394_ERROR_MEMFAULT;
  699.                         }
  700.                 }
  701.                 req->req.length = 0;
  702.                 break;
  704.         case RAW1394_REQ_LOCK:
  705.                 if ((req->req.misc == EXTCODE_FETCH_ADD)
  706.                     || (req->req.misc == EXTCODE_LITTLE_ADD)) {
  707.                         if (req->req.length != 4) {
  708.                                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  709.                                 break;
  710.                         }
  711.                 } else {
  712.                         if (req->req.length != 8) {
  713.                                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  714.                                 break;
  715.                         }
  716.                 }
  718.                 packet = hpsb_make_lockpacket(fi->host, node, addr,
  719.                                               req->req.misc);
  720.                 if (!packet) return -ENOMEM;
  722.                 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
  723.                                    req->req.length)) {
  724.                         req->req.error = RAW1394_ERROR_MEMFAULT;
  725.                         break;
  726.                 }
  728.                 req->data = packet->data;
  729.                 req->req.length = 4;
  730.                 break;
  732.         case RAW1394_REQ_LOCK64:
  733.         default:
  734.                 req->req.error = RAW1394_ERROR_STATE_ORDER;
  735.         }
  737.         req->packet = packet;
  739.         if (req->req.error) {
  740.                 req->req.length = 0;
  741.                 queue_complete_req(req);
  742.                 return sizeof(struct raw1394_request);
  743.         }
  745.         req->tq.data = req;
  746.         hpsb_add_packet_complete_task(packet, &req->tq);
  748.         spin_lock_irq(&fi->reqlists_lock);
  749.         list_add_tail(&req->list, &fi->req_pending);
  750.         spin_unlock_irq(&fi->reqlists_lock);
  752. packet->generation = req->req.generation;
  754.         if (!hpsb_send_packet(packet)) {
  755.                 req->req.error = RAW1394_ERROR_SEND_ERROR;
  756.                 req->req.length = 0;
  757.                 free_tlabel(packet->host, packet->node_id, packet->tlabel);
  758.                 queue_complete_req(req);
  759.         }
  760.         return sizeof(struct raw1394_request);
  761. }
  763. static int handle_iso_send(struct file_info *fi, struct pending_request *req,
  764.                            int channel)
  765. {
  766.         struct hpsb_packet *packet;
  768.         packet = alloc_hpsb_packet(req->req.length);
  769.         if (!packet) return -ENOMEM;
  770.         req->packet = packet;
  772.         fill_iso_packet(packet, req->req.length, channel & 0x3f,
  773.                         (req->req.misc >> 16) & 0x3, req->req.misc & 0xf);
  774.         packet->type = hpsb_iso;
  775.         packet->speed_code = req->req.address & 0x3;
  776.         packet->host = fi->host;
  778.         if (copy_from_user(packet->data, int2ptr(req->req.sendb),
  779.                            req->req.length)) {
  780.                 req->req.error = RAW1394_ERROR_MEMFAULT;
  781.                 req->req.length = 0;
  782.                 queue_complete_req(req);
  783.                 return sizeof(struct raw1394_request);
  784.         }
  786.         req->tq.data = req;
  787.         req->tq.routine = (void (*)(void*))queue_complete_req;
  788.         req->req.length = 0;
  789. hpsb_add_packet_complete_task(packet, &req->tq);
  791.         spin_lock_irq(&fi->reqlists_lock);
  792.         list_add_tail(&req->list, &fi->req_pending);
  793.         spin_unlock_irq(&fi->reqlists_lock);
  795. /* Update the generation of the packet just before sending. */
  796. packet->generation = get_hpsb_generation(fi->host);
  798.         if (!hpsb_send_packet(packet)) {
  799.                 req->req.error = RAW1394_ERROR_SEND_ERROR;
  800.                 queue_complete_req(req);
  801.         }
  803.         return sizeof(struct raw1394_request);
  804. }
  806. static int state_connected(struct file_info *fi, struct pending_request *req)
  807. {
  808.         int node = req->req.address >> 48;
  810.         req->req.error = RAW1394_ERROR_NONE;
  812.         if (req->req.type ==  RAW1394_REQ_ISO_SEND) {
  813.                 return handle_iso_send(fi, req, node);
  814.         }
  816.         if (req->req.generation != get_hpsb_generation(fi->host)) {
  817.                 req->req.error = RAW1394_ERROR_GENERATION;
  818.                 req->req.generation = get_hpsb_generation(fi->host);
  819.                 req->req.length = 0;
  820.                 queue_complete_req(req);
  821.                 return sizeof(struct raw1394_request);
  822.         }
  824.         switch (req->req.type) {
  825.         case RAW1394_REQ_ISO_LISTEN:
  826.                 handle_iso_listen(fi, req);
  827.                 return sizeof(struct raw1394_request);
  829.         case RAW1394_REQ_FCP_LISTEN:
  830.                 handle_fcp_listen(fi, req);
  831.                 return sizeof(struct raw1394_request);
  833.         case RAW1394_REQ_RESET_BUS:
  834.                 hpsb_reset_bus(fi->host, LONG_RESET);
  835.                 return sizeof(struct raw1394_request);
  836.         }
  838.         if (req->req.length == 0) {
  839.                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  840.                 queue_complete_req(req);
  841.                 return sizeof(struct raw1394_request);
  842.         }
  844.         if (fi->host->node_id == node) {
  845.                 return handle_local_request(fi, req, node);
  846.         }
  848.         return handle_remote_request(fi, req, node);
  849. }
  852. static ssize_t raw1394_write(struct file *file, const char *buffer, size_t count,
  853.                      loff_t *offset_is_ignored)
  854. {
  855.         struct file_info *fi = (struct file_info *)file->private_data;
  856.         struct pending_request *req;
  857.         ssize_t retval = 0;
  859.         if (count != sizeof(struct raw1394_request)) {
  860.                 return -EINVAL;
  861.         }
  863.         req = alloc_pending_request();
  864.         if (req == NULL) {
  865.                 return -ENOMEM;
  866.         }
  867.         req->file_info = fi;
  869.         if (copy_from_user(&req->req, buffer, sizeof(struct raw1394_request))) {
  870.                 free_pending_request(req);
  871.                 return -EFAULT;
  872.         }
  874.         switch (fi->state) {
  875.         case opened:
  876.                 retval = state_opened(fi, req);
  877.                 break;
  879.         case initialized:
  880.                 retval = state_initialized(fi, req);
  881.                 break;
  883.         case connected:
  884.                 retval = state_connected(fi, req);
  885.                 break;
  886.         }
  888.         if (retval < 0) {
  889.                 free_pending_request(req);
  890.         }
  892.         return retval;
  893. }
  895. static unsigned int raw1394_poll(struct file *file, poll_table *pt)
  896. {
  897.         struct file_info *fi = file->private_data;
  898.         unsigned int mask = POLLOUT | POLLWRNORM;
  900.         poll_wait(file, &fi->poll_wait_complete, pt);
  902.         spin_lock_irq(&fi->reqlists_lock);
  903.         if (!list_empty(&fi->req_complete)) {
  904.                 mask |= POLLIN | POLLRDNORM;
  905.         }
  906.         spin_unlock_irq(&fi->reqlists_lock);
  908.         return mask;
  909. }
  911. static int raw1394_open(struct inode *inode, struct file *file)
  912. {
  913.         struct file_info *fi;
  915.         if (ieee1394_file_to_instance(file) > 0) {
  916.                 return -ENXIO;
  917.         }
  919.         fi = kmalloc(sizeof(struct file_info), SLAB_KERNEL);
  920.         if (fi == NULL)
  921.                 return -ENOMEM;
  922.         
  923.         memset(fi, 0, sizeof(struct file_info));
  925.         INIT_LIST_HEAD(&fi->list);
  926.         fi->state = opened;
  927.         INIT_LIST_HEAD(&fi->req_pending);
  928.         INIT_LIST_HEAD(&fi->req_complete);
  929.         sema_init(&fi->complete_sem, 0);
  930.         spin_lock_init(&fi->reqlists_lock);
  931.         init_waitqueue_head(&fi->poll_wait_complete);
  933.         file->private_data = fi;
  935.         return 0;
  936. }
  938. static int raw1394_release(struct inode *inode, struct file *file)
  939. {
  940.         struct file_info *fi = file->private_data;
  941.         struct list_head *lh;
  942.         struct pending_request *req;
  943.         int done = 0, i;
  945.         for (i = 0; i < 64; i++) {
  946.                 if (fi->listen_channels & (1ULL << i)) {
  947.                         hpsb_unlisten_channel(hl_handle, fi->host, i);
  948.                 }
  949.         }
  951.         spin_lock(&host_info_lock);
  952.         fi->listen_channels = 0;
  953.         spin_unlock(&host_info_lock);
  955.         while (!done) {
  956.                 spin_lock_irq(&fi->reqlists_lock);
  958.                 while (!list_empty(&fi->req_complete)) {
  959.                         lh = fi->req_complete.next;
  960.                         list_del(lh);
  962.                         req = list_entry(lh, struct pending_request, list);
  964.                         free_pending_request(req);
  965.                 }
  967.                 if (list_empty(&fi->req_pending)) done = 1;
  969.                 spin_unlock_irq(&fi->reqlists_lock);
  971.                 if (!done) down_interruptible(&fi->complete_sem);
  972.         }
  974.         if (fi->state == connected) {
  975.                 spin_lock_irq(&host_info_lock);
  976.                 list_del(&fi->list);
  977.                 spin_unlock_irq(&host_info_lock);
  979.                 hpsb_unref_host(fi->host);
  980.         }
  982.         kfree(fi);
  984.         return 0;
  985. }
  987. static struct hpsb_highlevel_ops hl_ops = {
  988.         .add_host =    add_host,
  989.         .remove_host = remove_host,
  990.         .host_reset =  host_reset,
  991.         .iso_receive = iso_receive,
  992.         .fcp_request = fcp_request,
  993. };
  995. static struct file_operations file_ops = {
  996. .owner = THIS_MODULE,
  997.         .read = raw1394_read, 
  998.         .write = raw1394_write, 
  999.         .poll = raw1394_poll, 
  1000.         .open = raw1394_open, 
  1001.         .release = raw1394_release, 
  1002. };
  1004. static int __init init_raw1394(void)
  1005. {
  1006.         hl_handle = hpsb_register_highlevel(RAW1394_DEVICE_NAME, &hl_ops);
  1007.         if (hl_handle == NULL) {
  1008.                 HPSB_ERR("raw1394 failed to register with ieee1394 highlevel");
  1009.                 return -ENOMEM;
  1010.         }
  1012. devfs_handle = devfs_register(NULL,
  1013.       RAW1394_DEVICE_NAME, DEVFS_FL_NONE,
  1014.                                       IEEE1394_MAJOR,
  1015.       IEEE1394_MINOR_BLOCK_RAW1394 * 16,
  1016.                                       S_IFCHR | S_IRUSR | S_IWUSR, &file_ops,
  1017.                                       NULL);
  1019.         if (ieee1394_register_chardev(IEEE1394_MINOR_BLOCK_RAW1394,
  1020.       THIS_MODULE, &file_ops)) {
  1021.                 HPSB_ERR("raw1394 failed to register minor device block");
  1022. devfs_unregister(devfs_handle);
  1023. hpsb_unregister_highlevel(hl_handle);
  1024.                 return -EBUSY;
  1025.         }
  1026. printk(KERN_INFO "raw1394: /dev/%s device initializedn", RAW1394_DEVICE_NAME);
  1027.         return 0;
  1028. }
  1030. static void __exit cleanup_raw1394(void)
  1031. {
  1032.         ieee1394_unregister_chardev(IEEE1394_MINOR_BLOCK_RAW1394);
  1033. devfs_unregister(devfs_handle);
  1034.         hpsb_unregister_highlevel(hl_handle);
  1035. }
  1037. module_init(init_raw1394);
  1038. module_exit(cleanup_raw1394);
  1039. MODULE_LICENSE("GPL");