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

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

嵌入式Linux

开发平台：

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>
  25. #if LINUX_VERSION_CODE > KERNEL_VERSION(2,3,0)
  26. #include <linux/devfs_fs_kernel.h>
  27. #endif
  29. #include "ieee1394.h"
  30. #include "ieee1394_types.h"
  31. #include "ieee1394_core.h"
  32. #include "hosts.h"
  33. #include "highlevel.h"
  34. #include "ieee1394_transactions.h"
  35. #include "raw1394.h"
  38. #if BITS_PER_LONG == 64
  39. #define int2ptr(x) ((void *)x)
  40. #define ptr2int(x) ((u64)x)
  41. #else
  42. #define int2ptr(x) ((void *)(u32)x)
  43. #define ptr2int(x) ((u64)(u32)x)
  44. #endif
  47. static devfs_handle_t devfs_handle;
  49. static LIST_HEAD(host_info_list);
  50. static int host_count;
  51. static spinlock_t host_info_lock = SPIN_LOCK_UNLOCKED;
  52. static atomic_t internal_generation = ATOMIC_INIT(0);
  54. static struct hpsb_highlevel *hl_handle;
  56. static atomic_t iso_buffer_size;
  57. static const int iso_buffer_max = 4 * 1024 * 1024; /* 4 MB */
  59. static void queue_complete_cb(struct pending_request *req);
  61. static struct pending_request *__alloc_pending_request(int flags)
  62. {
  63.         struct pending_request *req;
  65.         req = (struct pending_request *)kmalloc(sizeof(struct pending_request),
  66.                                                 flags);
  67.         if (req != NULL) {
  68.                 memset(req, 0, sizeof(struct pending_request));
  69.                 INIT_LIST_HEAD(&req->list);
  70. INIT_TQUEUE(&req->tq, (void(*)(void*))queue_complete_cb, NULL);
  71.         }
  73.         return req;
  74. }
  76. static inline struct pending_request *alloc_pending_request(void)
  77. {
  78.         return __alloc_pending_request(SLAB_KERNEL);
  79. }
  81. static void free_pending_request(struct pending_request *req)
  82. {
  83.         if (req->ibs) {
  84.                 if (atomic_dec_and_test(&req->ibs->refcount)) {
  85.                         atomic_sub(req->ibs->data_size, &iso_buffer_size);
  86.                         kfree(req->ibs);
  87.                 }
  88.         } else if (req->free_data) {
  89.                 kfree(req->data);
  90.         }
  91.         free_hpsb_packet(req->packet);
  92.         kfree(req);
  93. }
  95. static void queue_complete_req(struct pending_request *req)
  96. {
  97.         unsigned long flags;
  98.         struct file_info *fi = req->file_info;
  100.         spin_lock_irqsave(&fi->reqlists_lock, flags);
  101.         list_del(&req->list);
  102.         list_add_tail(&req->list, &fi->req_complete);
  103.         spin_unlock_irqrestore(&fi->reqlists_lock, flags);
  105.         up(&fi->complete_sem);
  106.         wake_up_interruptible(&fi->poll_wait_complete);
  107. }
  109. static void queue_complete_cb(struct pending_request *req)
  110. {
  111.         struct hpsb_packet *packet = req->packet;
  112.         int rcode = (packet->header[1] >> 12) & 0xf;
  114.         switch (packet->ack_code) {
  115.         case ACKX_NONE:
  116.         case ACKX_SEND_ERROR:
  117.                 req->req.error = RAW1394_ERROR_SEND_ERROR;
  118.                 break;
  119.         case ACKX_ABORTED:
  120.                 req->req.error = RAW1394_ERROR_ABORTED;
  121.                 break;
  122.         case ACKX_TIMEOUT:
  123.                 req->req.error = RAW1394_ERROR_TIMEOUT;
  124.                 break;
  125.         default:
  126.                 req->req.error = (packet->ack_code << 16) | rcode;
  127.                 break;
  128.         }
  130.         if (!((packet->ack_code == ACK_PENDING) && (rcode == RCODE_COMPLETE))) {
  131.                 req->req.length = 0;
  132.         }
  134.         free_tlabel(packet->host, packet->node_id, packet->tlabel);
  136.         queue_complete_req(req);
  137. }
  140. static void add_host(struct hpsb_host *host)
  141. {
  142.         struct host_info *hi;
  144.         hi = (struct host_info *)kmalloc(sizeof(struct host_info), SLAB_KERNEL);
  145.         if (hi != NULL) {
  146.                 INIT_LIST_HEAD(&hi->list);
  147.                 hi->host = host;
  148.                 INIT_LIST_HEAD(&hi->file_info_list);
  150.                 spin_lock_irq(&host_info_lock);
  151.                 list_add_tail(&hi->list, &host_info_list);
  152.                 host_count++;
  153.                 spin_unlock_irq(&host_info_lock);
  154.         }
  156.         atomic_inc(&internal_generation);
  157. }
  160. static struct host_info *find_host_info(struct hpsb_host *host)
  161. {
  162.         struct list_head *lh;
  163.         struct host_info *hi;
  165.         list_for_each(lh, &host_info_list) {
  166.                 hi = list_entry(lh, struct host_info, list);
  167.                 if (hi->host == host) {
  168.                         return hi;
  169.                 }
  170.         }
  172.         return NULL;
  173. }
  175. static void remove_host(struct hpsb_host *host)
  176. {
  177.         struct host_info *hi;
  179.         spin_lock_irq(&host_info_lock);
  180.         hi = find_host_info(host);
  182.         if (hi != NULL) {
  183.                 list_del(&hi->list);
  184.                 host_count--;
  185.         }
  186.         spin_unlock_irq(&host_info_lock);
  188.         if (hi == NULL) {
  189.                 printk(KERN_ERR "raw1394: attempt to remove unknown host "
  190.                        "0x%pn", host);
  191.                 return;
  192.         }
  194.         kfree(hi);
  195. }
  197. static void host_reset(struct hpsb_host *host)
  198. {
  199.         unsigned long flags;
  200.         struct list_head *lh;
  201.         struct host_info *hi;
  202.         struct file_info *fi;
  203.         struct pending_request *req;
  205.         spin_lock_irqsave(&host_info_lock, flags);
  206.         hi = find_host_info(host);
  208.         if (hi != NULL) {
  209.                 list_for_each(lh, &hi->file_info_list) {
  210.                         fi = list_entry(lh, struct file_info, list);
  211.                         req = __alloc_pending_request(SLAB_ATOMIC);
  213.                         if (req != NULL) {
  214.                                 req->file_info = fi;
  215.                                 req->req.type = RAW1394_REQ_BUS_RESET;
  216.                                 req->req.generation = get_hpsb_generation(host);
  217.                                 req->req.misc = (host->node_id << 16)
  218.                                         | host->node_count;
  219.                                 if (fi->protocol_version > 3) {
  220.                                         req->req.misc |= ((host->irm_id
  221.                                                            & NODE_MASK) << 8);
  222.                                 }
  224.                                 queue_complete_req(req);
  225.                         }
  226.                 }
  227.         }
  228.         spin_unlock_irqrestore(&host_info_lock, flags);
  230.         atomic_inc(&internal_generation);
  231. }
  233. static void iso_receive(struct hpsb_host *host, int channel, quadlet_t *data,
  234.                         unsigned int length)
  235. {
  236.         unsigned long flags;
  237.         struct list_head *lh;
  238.         struct host_info *hi;
  239.         struct file_info *fi;
  240.         struct pending_request *req;
  241.         struct iso_block_store *ibs = NULL;
  242.         LIST_HEAD(reqs);
  244.         if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
  245.                 HPSB_INFO("dropped iso packet");
  246.                 return;
  247.         }
  249.         spin_lock_irqsave(&host_info_lock, flags);
  250.         hi = find_host_info(host);
  252.         if (hi != NULL) {
  253. list_for_each(lh, &hi->file_info_list) {
  254.                         fi = list_entry(lh, struct file_info, list);
  256.                         if (!(fi->listen_channels & (1ULL << channel))) {
  257.                                 continue;
  258.                         }
  260.                         req = __alloc_pending_request(SLAB_ATOMIC);
  261.                         if (!req) break;
  263.                         if (!ibs) {
  264.                                 ibs = kmalloc(sizeof(struct iso_block_store)
  265.                                               + length, SLAB_ATOMIC);
  266.                                 if (!ibs) {
  267.                                         kfree(req);
  268.                                         break;
  269.                                 }
  271.                                 atomic_add(length, &iso_buffer_size);
  272.                                 atomic_set(&ibs->refcount, 0);
  273.                                 ibs->data_size = length;
  274.                                 memcpy(ibs->data, data, length);
  275.                         }
  277.                         atomic_inc(&ibs->refcount);
  279.                         req->file_info = fi;
  280.                         req->ibs = ibs;
  281.                         req->data = ibs->data;
  282.                         req->req.type = RAW1394_REQ_ISO_RECEIVE;
  283.                         req->req.generation = get_hpsb_generation(host);
  284.                         req->req.misc = 0;
  285.                         req->req.recvb = ptr2int(fi->iso_buffer);
  286.                         req->req.length = MIN(length, fi->iso_buffer_length);
  287.                         
  288.                         list_add_tail(&req->list, &reqs);
  289.                 }
  290.         }
  291.         spin_unlock_irqrestore(&host_info_lock, flags);
  293.         lh = reqs.next;
  294.         while (lh != &reqs) {
  295.                 req = list_entry(lh, struct pending_request, list);
  296.                 lh = lh->next;
  298.                 queue_complete_req(req);
  299.         }
  300. }
  302. static void fcp_request(struct hpsb_host *host, int nodeid, int direction,
  303.                         int cts, u8 *data, unsigned int length)
  304. {
  305.         unsigned long flags;
  306.         struct list_head *lh;
  307.         struct host_info *hi;
  308.         struct file_info *fi;
  309.         struct pending_request *req;
  310.         struct iso_block_store *ibs = NULL;
  311.         LIST_HEAD(reqs);
  313.         if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) {
  314.                 HPSB_INFO("dropped fcp request");
  315.                 return;
  316.         }
  318.         spin_lock_irqsave(&host_info_lock, flags);
  319.         hi = find_host_info(host);
  321.         if (hi != NULL) {
  322. list_for_each(lh, &hi->file_info_list) {
  323.                         fi = list_entry(lh, struct file_info, list);
  325.                         if (!fi->fcp_buffer) {
  326.                                 continue;
  327.                         }
  329.                         req = __alloc_pending_request(SLAB_ATOMIC);
  330.                         if (!req) break;
  332.                         if (!ibs) {
  333.                                 ibs = kmalloc(sizeof(struct iso_block_store)
  334.                                               + length, SLAB_ATOMIC);
  335.                                 if (!ibs) {
  336.                                         kfree(req);
  337.                                         break;
  338.                                 }
  340.                                 atomic_add(length, &iso_buffer_size);
  341.                                 atomic_set(&ibs->refcount, 0);
  342.                                 ibs->data_size = length;
  343.                                 memcpy(ibs->data, data, length);
  344.                         }
  346.                         atomic_inc(&ibs->refcount);
  348.                         req->file_info = fi;
  349.                         req->ibs = ibs;
  350.                         req->data = ibs->data;
  351.                         req->req.type = RAW1394_REQ_FCP_REQUEST;
  352.                         req->req.generation = get_hpsb_generation(host);
  353.                         req->req.misc = nodeid | (direction << 16);
  354.                         req->req.recvb = ptr2int(fi->fcp_buffer);
  355.                         req->req.length = length;
  356.                         
  357.                         list_add_tail(&req->list, &reqs);
  358.                 }
  359.         }
  360.         spin_unlock_irqrestore(&host_info_lock, flags);
  362.         lh = reqs.next;
  363.         while (lh != &reqs) {
  364.                 req = list_entry(lh, struct pending_request, list);
  365.                 lh = lh->next;
  367.                 queue_complete_req(req);
  368.         }
  369. }
  372. static ssize_t raw1394_read(struct file *file, char *buffer, size_t count,
  373.                     loff_t *offset_is_ignored)
  374. {
  375.         struct file_info *fi = (struct file_info *)file->private_data;
  376.         struct list_head *lh;
  377.         struct pending_request *req;
  379.         if (count != sizeof(struct raw1394_request)) {
  380.                 return -EINVAL;
  381.         }
  383.         if (!access_ok(VERIFY_WRITE, buffer, count)) {
  384.                 return -EFAULT;
  385.         }
  387.         if (file->f_flags & O_NONBLOCK) {
  388.                 if (down_trylock(&fi->complete_sem)) {
  389.                         return -EAGAIN;
  390.                 }
  391.         } else {
  392.                 if (down_interruptible(&fi->complete_sem)) {
  393.                         return -ERESTARTSYS;
  394.                 }
  395.         }
  397.         spin_lock_irq(&fi->reqlists_lock);
  398.         lh = fi->req_complete.next;
  399.         list_del(lh);
  400.         spin_unlock_irq(&fi->reqlists_lock);
  402.         req = list_entry(lh, struct pending_request, list);
  404.         if (req->req.length) {
  405.                 if (copy_to_user(int2ptr(req->req.recvb), req->data,
  406.                                  req->req.length)) {
  407.                         req->req.error = RAW1394_ERROR_MEMFAULT;
  408.                 }
  409.         }
  410.         __copy_to_user(buffer, &req->req, sizeof(req->req));
  412.         free_pending_request(req);
  413.         return sizeof(struct raw1394_request);
  414. }
  417. static int state_opened(struct file_info *fi, struct pending_request *req)
  418. {
  419.         if (req->req.type == RAW1394_REQ_INITIALIZE) {
  420.                 switch (req->req.misc) {
  421.                 case RAW1394_KERNELAPI_VERSION:
  422.                 case 3:
  423.                         fi->state = initialized;
  424.                         fi->protocol_version = req->req.misc;
  425.                         req->req.error = RAW1394_ERROR_NONE;
  426.                         req->req.generation = atomic_read(&internal_generation);
  427.                         break;
  429.                 default:
  430.                         req->req.error = RAW1394_ERROR_COMPAT;
  431.                         req->req.misc = RAW1394_KERNELAPI_VERSION;
  432.                 }
  433.         } else {
  434.                 req->req.error = RAW1394_ERROR_STATE_ORDER;
  435.         }
  437.         req->req.length = 0;
  438.         queue_complete_req(req);
  439.         return sizeof(struct raw1394_request);
  440. }
  442. static int state_initialized(struct file_info *fi, struct pending_request *req)
  443. {
  444.         struct list_head *lh;
  445.         struct host_info *hi;
  446.         struct raw1394_khost_list *khl;
  448.         if (req->req.generation != atomic_read(&internal_generation)) {
  449.                 req->req.error = RAW1394_ERROR_GENERATION;
  450.                 req->req.generation = atomic_read(&internal_generation);
  451.                 req->req.length = 0;
  452.                 queue_complete_req(req);
  453.                 return sizeof(struct raw1394_request);
  454.         }
  456.         switch (req->req.type) {
  457.         case RAW1394_REQ_LIST_CARDS:
  458.                 spin_lock_irq(&host_info_lock);
  459.                 khl = kmalloc(sizeof(struct raw1394_khost_list) * host_count,
  460.                               SLAB_ATOMIC);
  462.                 if (khl != NULL) {
  463.                         req->req.misc = host_count;
  464.                         req->data = (quadlet_t *)khl;
  465.                         
  466.                         list_for_each(lh, &host_info_list) {
  467.                                 hi = list_entry(lh, struct host_info, list);
  469.                                 khl->nodes = hi->host->node_count;
  470.                                 strcpy(khl->name, hi->host->template->name);
  472.                                 khl++;
  473.                         }
  474.                 }
  475.                 spin_unlock_irq(&host_info_lock);
  477.                 if (khl != NULL) {
  478.                         req->req.error = RAW1394_ERROR_NONE;
  479.                         req->req.length = MIN(req->req.length,
  480.                                               sizeof(struct raw1394_khost_list)
  481.                                               * req->req.misc);
  482.                         req->free_data = 1;
  483.                 } else {
  484.                         return -ENOMEM;
  485.                 }
  486.                 break;
  488.         case RAW1394_REQ_SET_CARD:
  489.                 lh = NULL;
  491.                 spin_lock_irq(&host_info_lock);
  492.                 if (req->req.misc < host_count) {
  493.                         lh = host_info_list.next;
  494.                         while (req->req.misc--) {
  495.                                 lh = lh->next;
  496.                         }
  497.                         hi = list_entry(lh, struct host_info, list);
  498.                         hpsb_inc_host_usage(hi->host);
  499.                         list_add_tail(&fi->list, &hi->file_info_list);
  500.                         fi->host = hi->host;
  501.                         fi->state = connected;
  502.                 }
  503.                 spin_unlock_irq(&host_info_lock);
  505.                 if (lh != NULL) {
  506.                         req->req.error = RAW1394_ERROR_NONE;
  507.                         req->req.generation = get_hpsb_generation(fi->host);
  508.                         req->req.misc = (fi->host->node_id << 16) 
  509.                                 | fi->host->node_count;
  510.                         if (fi->protocol_version > 3) {
  511.                                 req->req.misc |=
  512.                                         (fi->host->irm_id & NODE_MASK) << 8;
  513.                         }
  514.                 } else {
  515.                         req->req.error = RAW1394_ERROR_INVALID_ARG;
  516.                 }
  518.                 req->req.length = 0;
  519.                 break;
  521.         default:
  522.                 req->req.error = RAW1394_ERROR_STATE_ORDER;
  523.                 req->req.length = 0;
  524.                 break;
  525.         }
  527.         queue_complete_req(req);
  528.         return sizeof(struct raw1394_request);
  529. }
  531. static void handle_iso_listen(struct file_info *fi, struct pending_request *req)
  532. {
  533.         int channel = req->req.misc;
  535.         spin_lock(&host_info_lock);
  536.         if ((channel > 63) || (channel < -64)) {
  537.                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  538.         } else if (channel >= 0) {
  539.                 /* allocate channel req.misc */
  540.                 if (fi->listen_channels & (1ULL << channel)) {
  541.                         req->req.error = RAW1394_ERROR_ALREADY;
  542.                 } else {
  543.                         fi->listen_channels |= 1ULL << channel;
  544.                         hpsb_listen_channel(hl_handle, fi->host, channel);
  545.                         fi->iso_buffer = int2ptr(req->req.recvb);
  546.                         fi->iso_buffer_length = req->req.length;
  547.                 }
  548.         } else {
  549.                 /* deallocate channel (one's complement neg) req.misc */
  550.                 channel = ~channel;
  552.                 if (fi->listen_channels & (1ULL << channel)) {
  553.                         hpsb_unlisten_channel(hl_handle, fi->host, channel);
  554.                         fi->listen_channels &= ~(1ULL << channel);
  555.                 } else {
  556.                         req->req.error = RAW1394_ERROR_INVALID_ARG;
  557.                 }
  558.         }
  560.         req->req.length = 0;
  561.         queue_complete_req(req);
  562.         spin_unlock(&host_info_lock);
  563. }
  565. static void handle_fcp_listen(struct file_info *fi, struct pending_request *req)
  566. {
  567.         if (req->req.misc) {
  568.                 if (fi->fcp_buffer) {
  569.                         req->req.error = RAW1394_ERROR_ALREADY;
  570.                 } else {
  571.                         fi->fcp_buffer = (u8 *)int2ptr(req->req.recvb);
  572.                 }
  573.         } else {
  574.                 if (!fi->fcp_buffer) {
  575.                         req->req.error = RAW1394_ERROR_ALREADY;
  576.                 } else {
  577.                         fi->fcp_buffer = NULL;
  578.                 }
  579.         }
  581.         req->req.length = 0;
  582.         queue_complete_req(req);
  583. }
  585. static int handle_local_request(struct file_info *fi,
  586.                                 struct pending_request *req, int node)
  587. {
  588.         u64 addr = req->req.address & 0xffffffffffffULL;
  590.         req->data = kmalloc(req->req.length, SLAB_KERNEL);
  591.         if (!req->data) return -ENOMEM;
  592.         req->free_data = 1;
  594.         switch (req->req.type) {
  595.         case RAW1394_REQ_ASYNC_READ:
  596.                 req->req.error = highlevel_read(fi->host, node, req->data, addr,
  597.                                                 req->req.length);
  598.                 break;
  600.         case RAW1394_REQ_ASYNC_WRITE:
  601.                 if (copy_from_user(req->data, int2ptr(req->req.sendb),
  602.                                    req->req.length)) {
  603.                         req->req.error = RAW1394_ERROR_MEMFAULT;
  604.                         break;
  605.                 }
  607.                 req->req.error = highlevel_write(fi->host, node, node, req->data,
  608.                                                  addr, req->req.length);
  609.                 req->req.length = 0;
  610.                 break;
  612.         case RAW1394_REQ_LOCK:
  613.                 if ((req->req.misc == EXTCODE_FETCH_ADD)
  614.                     || (req->req.misc == EXTCODE_LITTLE_ADD)) {
  615.                         if (req->req.length != 4) {
  616.                                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  617.                                 break;
  618.                         }
  619.                 } else {
  620.                         if (req->req.length != 8) {
  621.                                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  622.                                 break;
  623.                         }
  624.                 }
  626.                 if (copy_from_user(req->data, int2ptr(req->req.sendb),
  627.                                    req->req.length)) {
  628.                         req->req.error = RAW1394_ERROR_MEMFAULT;
  629.                         break;
  630.                 }
  632.                 if (req->req.length == 8) {
  633.                         req->req.error = highlevel_lock(fi->host, node,
  634.                                                         req->data, addr,
  635.                                                         req->data[1],
  636.                                                         req->data[0],
  637.                                                         req->req.misc);
  638.                         req->req.length = 4;
  639.                 } else {
  640.                         req->req.error = highlevel_lock(fi->host, node,
  641.                                                         req->data, addr,
  642.                                                         req->data[0], 0,
  643.                                                         req->req.misc);
  644.                 }
  645.                 break;
  647.         case RAW1394_REQ_LOCK64:
  648.         default:
  649.                 req->req.error = RAW1394_ERROR_STATE_ORDER;
  650.         }
  652.         if (req->req.error)
  653.                 req->req.length = 0;
  654.         if (req->req.error >= 0)
  655.                 req->req.error |= ACK_PENDING << 16;
  657.         queue_complete_req(req);
  658.         return sizeof(struct raw1394_request);
  659. }
  661. static int handle_remote_request(struct file_info *fi,
  662.                                  struct pending_request *req, int node)
  663. {
  664.         struct hpsb_packet *packet = NULL;
  665.         u64 addr = req->req.address & 0xffffffffffffULL;
  667.         switch (req->req.type) {
  668.         case RAW1394_REQ_ASYNC_READ:
  669.                 if (req->req.length == 4) {
  670.                         packet = hpsb_make_readqpacket(fi->host, node, addr);
  671.                         if (!packet) return -ENOMEM;
  673.                         req->data = &packet->header[3];
  674.                 } else {
  675.                         packet = hpsb_make_readbpacket(fi->host, node, addr,
  676.                                                        req->req.length);
  677.                         if (!packet) return -ENOMEM;
  679.                         req->data = packet->data;
  680.                 }
  681.                 break;
  683.         case RAW1394_REQ_ASYNC_WRITE:
  684.                 if (req->req.length == 4) {
  685.                         quadlet_t x;
  687.                         if (copy_from_user(&x, int2ptr(req->req.sendb), 4)) {
  688.                                 req->req.error = RAW1394_ERROR_MEMFAULT;
  689.                         }
  691.                         packet = hpsb_make_writeqpacket(fi->host, node, addr,
  692.                                                         x);
  693.                         if (!packet) return -ENOMEM;
  694.                 } else {
  695.                         packet = hpsb_make_writebpacket(fi->host, node, addr,
  696.                                                         req->req.length);
  697.                         if (!packet) return -ENOMEM;
  699.                         if (copy_from_user(packet->data, int2ptr(req->req.sendb),
  700.                                            req->req.length)) {
  701.                                 req->req.error = RAW1394_ERROR_MEMFAULT;
  702.                         }
  703.                 }
  704.                 req->req.length = 0;
  705.                 break;
  707.         case RAW1394_REQ_LOCK:
  708.                 if ((req->req.misc == EXTCODE_FETCH_ADD)
  709.                     || (req->req.misc == EXTCODE_LITTLE_ADD)) {
  710.                         if (req->req.length != 4) {
  711.                                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  712.                                 break;
  713.                         }
  714.                 } else {
  715.                         if (req->req.length != 8) {
  716.                                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  717.                                 break;
  718.                         }
  719.                 }
  721.                 packet = hpsb_make_lockpacket(fi->host, node, addr,
  722.                                               req->req.misc);
  723.                 if (!packet) return -ENOMEM;
  725.                 if (copy_from_user(packet->data, int2ptr(req->req.sendb),
  726.                                    req->req.length)) {
  727.                         req->req.error = RAW1394_ERROR_MEMFAULT;
  728.                         break;
  729.                 }
  731.                 req->data = packet->data;
  732.                 req->req.length = 4;
  733.                 break;
  735.         case RAW1394_REQ_LOCK64:
  736.         default:
  737.                 req->req.error = RAW1394_ERROR_STATE_ORDER;
  738.         }
  740.         req->packet = packet;
  742.         if (req->req.error) {
  743.                 req->req.length = 0;
  744.                 queue_complete_req(req);
  745.                 return sizeof(struct raw1394_request);
  746.         }
  748.         req->tq.data = req;
  749.         queue_task(&req->tq, &packet->complete_tq);
  751.         spin_lock_irq(&fi->reqlists_lock);
  752.         list_add_tail(&req->list, &fi->req_pending);
  753.         spin_unlock_irq(&fi->reqlists_lock);
  755. packet->generation = req->req.generation;
  757.         if (!hpsb_send_packet(packet)) {
  758.                 req->req.error = RAW1394_ERROR_SEND_ERROR;
  759.                 req->req.length = 0;
  760.                 free_tlabel(packet->host, packet->node_id, packet->tlabel);
  761.                 queue_complete_req(req);
  762.         }
  763.         return sizeof(struct raw1394_request);
  764. }
  766. static int handle_iso_send(struct file_info *fi, struct pending_request *req,
  767.                            int channel)
  768. {
  769.         struct hpsb_packet *packet;
  771.         packet = alloc_hpsb_packet(req->req.length);
  772.         if (!packet) return -ENOMEM;
  773.         req->packet = packet;
  775.         fill_iso_packet(packet, req->req.length, channel & 0x3f,
  776.                         (req->req.misc >> 16) & 0x3, req->req.misc & 0xf);
  777.         packet->type = hpsb_iso;
  778.         packet->speed_code = req->req.address & 0x3;
  779.         packet->host = fi->host;
  781.         if (copy_from_user(packet->data, int2ptr(req->req.sendb),
  782.                            req->req.length)) {
  783.                 req->req.error = RAW1394_ERROR_MEMFAULT;
  784.                 req->req.length = 0;
  785.                 queue_complete_req(req);
  786.                 return sizeof(struct raw1394_request);
  787.         }
  789.         req->tq.data = req;
  790.         req->tq.routine = (void (*)(void*))queue_complete_req;
  791.         req->req.length = 0;
  792.         queue_task(&req->tq, &packet->complete_tq);
  794.         spin_lock_irq(&fi->reqlists_lock);
  795.         list_add_tail(&req->list, &fi->req_pending);
  796.         spin_unlock_irq(&fi->reqlists_lock);
  798. /* Update the generation of the packet just before sending. */
  799. packet->generation = get_hpsb_generation(fi->host);
  801.         if (!hpsb_send_packet(packet)) {
  802.                 req->req.error = RAW1394_ERROR_SEND_ERROR;
  803.                 queue_complete_req(req);
  804.         }
  806.         return sizeof(struct raw1394_request);
  807. }
  809. static int state_connected(struct file_info *fi, struct pending_request *req)
  810. {
  811.         int node = req->req.address >> 48;
  813.         req->req.error = RAW1394_ERROR_NONE;
  815.         if (req->req.type ==  RAW1394_REQ_ISO_SEND) {
  816.                 return handle_iso_send(fi, req, node);
  817.         }
  819.         if (req->req.generation != get_hpsb_generation(fi->host)) {
  820.                 req->req.error = RAW1394_ERROR_GENERATION;
  821.                 req->req.generation = get_hpsb_generation(fi->host);
  822.                 req->req.length = 0;
  823.                 queue_complete_req(req);
  824.                 return sizeof(struct raw1394_request);
  825.         }
  827.         switch (req->req.type) {
  828.         case RAW1394_REQ_ISO_LISTEN:
  829.                 handle_iso_listen(fi, req);
  830.                 return sizeof(struct raw1394_request);
  832.         case RAW1394_REQ_FCP_LISTEN:
  833.                 handle_fcp_listen(fi, req);
  834.                 return sizeof(struct raw1394_request);
  836.         case RAW1394_REQ_RESET_BUS:
  837.                 hpsb_reset_bus(fi->host, LONG_RESET);
  838.                 return sizeof(struct raw1394_request);
  839.         }
  841.         if (req->req.length == 0) {
  842.                 req->req.error = RAW1394_ERROR_INVALID_ARG;
  843.                 queue_complete_req(req);
  844.                 return sizeof(struct raw1394_request);
  845.         }
  847.         if (fi->host->node_id == node) {
  848.                 return handle_local_request(fi, req, node);
  849.         }
  851.         return handle_remote_request(fi, req, node);
  852. }
  855. static ssize_t raw1394_write(struct file *file, const char *buffer, size_t count,
  856.                      loff_t *offset_is_ignored)
  857. {
  858.         struct file_info *fi = (struct file_info *)file->private_data;
  859.         struct pending_request *req;
  860.         ssize_t retval = 0;
  862.         if (count != sizeof(struct raw1394_request)) {
  863.                 return -EINVAL;
  864.         }
  866.         req = alloc_pending_request();
  867.         if (req == NULL) {
  868.                 return -ENOMEM;
  869.         }
  870.         req->file_info = fi;
  872.         if (copy_from_user(&req->req, buffer, sizeof(struct raw1394_request))) {
  873.                 free_pending_request(req);
  874.                 return -EFAULT;
  875.         }
  877.         switch (fi->state) {
  878.         case opened:
  879.                 retval = state_opened(fi, req);
  880.                 break;
  882.         case initialized:
  883.                 retval = state_initialized(fi, req);
  884.                 break;
  886.         case connected:
  887.                 retval = state_connected(fi, req);
  888.                 break;
  889.         }
  891.         if (retval < 0) {
  892.                 free_pending_request(req);
  893.         }
  895.         return retval;
  896. }
  898. static unsigned int raw1394_poll(struct file *file, poll_table *pt)
  899. {
  900.         struct file_info *fi = file->private_data;
  901.         unsigned int mask = POLLOUT | POLLWRNORM;
  903.         poll_wait(file, &fi->poll_wait_complete, pt);
  905.         spin_lock_irq(&fi->reqlists_lock);
  906.         if (!list_empty(&fi->req_complete)) {
  907.                 mask |= POLLIN | POLLRDNORM;
  908.         }
  909.         spin_unlock_irq(&fi->reqlists_lock);
  911.         return mask;
  912. }
  914. static int raw1394_open(struct inode *inode, struct file *file)
  915. {
  916.         struct file_info *fi;
  918.         if (MINOR(inode->i_rdev)) {
  919.                 return -ENXIO;
  920.         }
  922.         V22_COMPAT_MOD_INC_USE_COUNT;
  924.         fi = kmalloc(sizeof(struct file_info), SLAB_KERNEL);
  925.         if (fi == NULL) {
  926.                 V22_COMPAT_MOD_DEC_USE_COUNT;
  927.                 return -ENOMEM;
  928.         }
  929.         
  930.         memset(fi, 0, sizeof(struct file_info));
  932.         INIT_LIST_HEAD(&fi->list);
  933.         fi->state = opened;
  934.         INIT_LIST_HEAD(&fi->req_pending);
  935.         INIT_LIST_HEAD(&fi->req_complete);
  936.         sema_init(&fi->complete_sem, 0);
  937.         spin_lock_init(&fi->reqlists_lock);
  938.         init_waitqueue_head(&fi->poll_wait_complete);
  940.         file->private_data = fi;
  942.         return 0;
  943. }
  945. static int raw1394_release(struct inode *inode, struct file *file)
  946. {
  947.         struct file_info *fi = file->private_data;
  948.         struct list_head *lh;
  949.         struct pending_request *req;
  950.         int done = 0, i;
  952.         lock_kernel();
  953.         for (i = 0; i < 64; i++) {
  954.                 if (fi->listen_channels & (1ULL << i)) {
  955.                         hpsb_unlisten_channel(hl_handle, fi->host, i);
  956.                 }
  957.         }
  959.         spin_lock(&host_info_lock);
  960.         fi->listen_channels = 0;
  961.         spin_unlock(&host_info_lock);
  963.         while (!done) {
  964.                 spin_lock_irq(&fi->reqlists_lock);
  966.                 while (!list_empty(&fi->req_complete)) {
  967.                         lh = fi->req_complete.next;
  968.                         list_del(lh);
  970.                         req = list_entry(lh, struct pending_request, list);
  972.                         free_pending_request(req);
  973.                 }
  975.                 if (list_empty(&fi->req_pending)) done = 1;
  977.                 spin_unlock_irq(&fi->reqlists_lock);
  979.                 if (!done) down_interruptible(&fi->complete_sem);
  980.         }
  982.         if (fi->state == connected) {
  983.                 spin_lock_irq(&host_info_lock);
  984.                 list_del(&fi->list);
  985.                 spin_unlock_irq(&host_info_lock);
  987.                 hpsb_dec_host_usage(fi->host);
  988.         }
  990.         kfree(fi);
  992.         V22_COMPAT_MOD_DEC_USE_COUNT;
  993.         unlock_kernel();
  994.         return 0;
  995. }
  997. static struct hpsb_highlevel_ops hl_ops = {
  998.         add_host:     add_host,
  999.         remove_host:  remove_host,
  1000.         host_reset:   host_reset,
  1001.         iso_receive:  iso_receive,
  1002.         fcp_request:  fcp_request,
  1003. };
  1005. static struct file_operations file_ops = {
  1006.         OWNER_THIS_MODULE
  1007.         read:     raw1394_read, 
  1008.         write:    raw1394_write, 
  1009.         poll:     raw1394_poll, 
  1010.         open:     raw1394_open, 
  1011.         release:  raw1394_release, 
  1012. };
  1014. static int __init init_raw1394(void)
  1015. {
  1016.         hl_handle = hpsb_register_highlevel(RAW1394_DEVICE_NAME, &hl_ops);
  1017.         if (hl_handle == NULL) {
  1018.                 HPSB_ERR("raw1394 failed to register with ieee1394 highlevel");
  1019.                 return -ENOMEM;
  1020.         }
  1022. devfs_handle = devfs_register(NULL, RAW1394_DEVICE_NAME, DEVFS_FL_NONE,
  1023.                                       RAW1394_DEVICE_MAJOR, 0,
  1024.                                       S_IFCHR | S_IRUSR | S_IWUSR, &file_ops,
  1025.                                       NULL);
  1027.         if (devfs_register_chrdev(RAW1394_DEVICE_MAJOR, RAW1394_DEVICE_NAME, 
  1028.                                   &file_ops)) {
  1029.                 HPSB_ERR("raw1394 failed to register /dev/raw1394 device");
  1030.                 return -EBUSY;
  1031.         }
  1032. printk(KERN_INFO "raw1394: /dev/%s device initializedn", RAW1394_DEVICE_NAME);
  1033.         return 0;
  1034. }
  1036. static void __exit cleanup_raw1394(void)
  1037. {
  1038.         devfs_unregister_chrdev(RAW1394_DEVICE_MAJOR, RAW1394_DEVICE_NAME);
  1039. devfs_unregister(devfs_handle);
  1040.         hpsb_unregister_highlevel(hl_handle);
  1041. }
  1043. module_init(init_raw1394);
  1044. module_exit(cleanup_raw1394);
  1045. MODULE_LICENSE("GPL");