/* * IEEE 1394 for Linux * * Raw interface to the bus * * Copyright (C) 1999, 2000 Andreas E. Bombe * 2001, 2002 Manfred Weihs <weihs@ict.tuwien.ac.at> * 2002 Christian Toegel <christian.toegel@gmx.at> * * This code is licensed under the GPL. See the file COPYING in the root * directory of the kernel sources for details. * * * Contributions: * * Manfred Weihs <weihs@ict.tuwien.ac.at> * configuration ROM manipulation * address range mapping * adaptation for new (transparent) loopback mechanism * sending of arbitrary async packets * Christian Toegel <christian.toegel@gmx.at> * address range mapping * lock64 request * transmit physical packet * busreset notification control (switch on/off) * busreset with selection of type (short/long) * request_reply */ #include <linux/kernel.h> #include <linux/list.h> #include <linux/string.h> #include <linux/slab.h> #include <linux/fs.h> #include <linux/poll.h> #include <linux/module.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/vmalloc.h> #include <linux/cdev.h> #include <asm/uaccess.h> #include <asm/atomic.h> #include <linux/compat.h> #include "csr1212.h" #include "highlevel.h" #include "hosts.h" #include "ieee1394.h" #include "ieee1394_core.h" #include "ieee1394_hotplug.h" #include "ieee1394_transactions.h" #include "ieee1394_types.h" #include "iso.h" #include "nodemgr.h" #include "raw1394.h" #include "raw1394-private.h" #define int2ptr(x) ((void __user *)(unsigned long)x) #define ptr2int(x) ((u64)(unsigned long)(void __user *)x) #ifdef CONFIG_IEEE1394_VERBOSEDEBUG #define RAW1394_DEBUG #endif #ifdef RAW1394_DEBUG #define DBGMSG(fmt, args...) \ printk(KERN_INFO "raw1394:" fmt "\n" , ## args) #else #define DBGMSG(fmt, args...) do {} while (0) #endif static LIST_HEAD(host_info_list); static int host_count; static DEFINE_SPINLOCK(host_info_lock); static atomic_t internal_generation = ATOMIC_INIT(0); static atomic_t iso_buffer_size; static const int iso_buffer_max = 4 * 1024 * 1024; /* 4 MB */ static struct hpsb_highlevel raw1394_highlevel; static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer, u64 addr, size_t length, u16 flags); static int arm_write(struct hpsb_host *host, int nodeid, int destid, quadlet_t * data, u64 addr, size_t length, u16 flags); static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store, u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode, u16 flags); static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store, u64 addr, octlet_t data, octlet_t arg, int ext_tcode, u16 flags); static struct hpsb_address_ops arm_ops = { .read = arm_read, .write = arm_write, .lock = arm_lock, .lock64 = arm_lock64, }; static void queue_complete_cb(struct pending_request *req); static struct pending_request *__alloc_pending_request(gfp_t flags) { struct pending_request *req; req = kzalloc(sizeof(*req), flags); if (req) INIT_LIST_HEAD(&req->list); return req; } static inline struct pending_request *alloc_pending_request(void) { return __alloc_pending_request(GFP_KERNEL); } static void free_pending_request(struct pending_request *req) { if (req->ibs) { if (atomic_dec_and_test(&req->ibs->refcount)) { atomic_sub(req->ibs->data_size, &iso_buffer_size); kfree(req->ibs); } } else if (req->free_data) { kfree(req->data); } hpsb_free_packet(req->packet); kfree(req); } /* fi->reqlists_lock must be taken */ static void __queue_complete_req(struct pending_request *req) { struct file_info *fi = req->file_info; list_move_tail(&req->list, &fi->req_complete); wake_up(&fi->wait_complete); } static void queue_complete_req(struct pending_request *req) { unsigned long flags; struct file_info *fi = req->file_info; spin_lock_irqsave(&fi->reqlists_lock, flags); __queue_complete_req(req); spin_unlock_irqrestore(&fi->reqlists_lock, flags); } static void queue_complete_cb(struct pending_request *req) { struct hpsb_packet *packet = req->packet; int rcode = (packet->header[1] >> 12) & 0xf; switch (packet->ack_code) { case ACKX_NONE: case ACKX_SEND_ERROR: req->req.error = RAW1394_ERROR_SEND_ERROR; break; case ACKX_ABORTED: req->req.error = RAW1394_ERROR_ABORTED; break; case ACKX_TIMEOUT: req->req.error = RAW1394_ERROR_TIMEOUT; break; default: req->req.error = (packet->ack_code << 16) | rcode; break; } if (!((packet->ack_code == ACK_PENDING) && (rcode == RCODE_COMPLETE))) { req->req.length = 0; } if ((req->req.type == RAW1394_REQ_ASYNC_READ) || (req->req.type == RAW1394_REQ_ASYNC_WRITE) || (req->req.type == RAW1394_REQ_ASYNC_STREAM) || (req->req.type == RAW1394_REQ_LOCK) || (req->req.type == RAW1394_REQ_LOCK64)) hpsb_free_tlabel(packet); queue_complete_req(req); } static void add_host(struct hpsb_host *host) { struct host_info *hi; unsigned long flags; hi = kmalloc(sizeof(*hi), GFP_KERNEL); if (hi) { INIT_LIST_HEAD(&hi->list); hi->host = host; INIT_LIST_HEAD(&hi->file_info_list); spin_lock_irqsave(&host_info_lock, flags); list_add_tail(&hi->list, &host_info_list); host_count++; spin_unlock_irqrestore(&host_info_lock, flags); } atomic_inc(&internal_generation); } static struct host_info *find_host_info(struct hpsb_host *host) { struct host_info *hi; list_for_each_entry(hi, &host_info_list, list) if (hi->host == host) return hi; return NULL; } static void remove_host(struct hpsb_host *host) { struct host_info *hi; unsigned long flags; spin_lock_irqsave(&host_info_lock, flags); hi = find_host_info(host); if (hi != NULL) { list_del(&hi->list); host_count--; /* FIXME: address ranges should be removed and fileinfo states should be initialized (including setting generation to internal-generation ...) */ } spin_unlock_irqrestore(&host_info_lock, flags); if (hi == NULL) { printk(KERN_ERR "raw1394: attempt to remove unknown host " "0x%p\n", host); return; } kfree(hi); atomic_inc(&internal_generation); } static void host_reset(struct hpsb_host *host) { unsigned long flags; struct host_info *hi; struct file_info *fi; struct pending_request *req; spin_lock_irqsave(&host_info_lock, flags); hi = find_host_info(host); if (hi != NULL) { list_for_each_entry(fi, &hi->file_info_list, list) { if (fi->notification == RAW1394_NOTIFY_ON) { req = __alloc_pending_request(GFP_ATOMIC); if (req != NULL) { req->file_info = fi; req->req.type = RAW1394_REQ_BUS_RESET; req->req.generation = get_hpsb_generation(host); req->req.misc = (host->node_id << 16) | host->node_count; if (fi->protocol_version > 3) { req->req.misc |= (NODEID_TO_NODE (host->irm_id) << 8); } queue_complete_req(req); } } } } spin_unlock_irqrestore(&host_info_lock, flags); } static void fcp_request(struct hpsb_host *host, int nodeid, int direction, int cts, u8 * data, size_t length) { unsigned long flags; struct host_info *hi; struct file_info *fi; struct pending_request *req, *req_next; struct iso_block_store *ibs = NULL; LIST_HEAD(reqs); if ((atomic_read(&iso_buffer_size) + length) > iso_buffer_max) { HPSB_INFO("dropped fcp request"); return; } spin_lock_irqsave(&host_info_lock, flags); hi = find_host_info(host); if (hi != NULL) { list_for_each_entry(fi, &hi->file_info_list, list) { if (!fi->fcp_buffer) continue; req = __alloc_pending_request(GFP_ATOMIC); if (!req) break; if (!ibs) { ibs = kmalloc(sizeof(*ibs) + length, GFP_ATOMIC); if (!ibs) { kfree(req); break; } atomic_add(length, &iso_buffer_size); atomic_set(&ibs->refcount, 0); ibs->data_size = length; memcpy(ibs->data, data, length); } atomic_inc(&ibs->refcount); req->file_info = fi; req->ibs = ibs; req->data = ibs->data; req->req.type = RAW1394_REQ_FCP_REQUEST; req->req.generation = get_hpsb_generation(host); req->req.misc = nodeid | (direction << 16); req->req.recvb = ptr2int(fi->fcp_buffer); req->req.length = length; list_add_tail(&req->list, &reqs); } } spin_unlock_irqrestore(&host_info_lock, flags); list_for_each_entry_safe(req, req_next, &reqs, list) queue_complete_req(req); } #ifdef CONFIG_COMPAT struct compat_raw1394_req { __u32 type; __s32 error; __u32 misc; __u32 generation; __u32 length; __u64 address; __u64 tag; __u64 sendb; __u64 recvb; } #if defined(CONFIG_X86_64) || defined(CONFIG_IA64) __attribute__((packed)) #endif ; static const char __user *raw1394_compat_write(const char __user *buf) { struct compat_raw1394_req __user *cr = (typeof(cr)) buf; struct raw1394_request __user *r; r = compat_alloc_user_space(sizeof(struct raw1394_request)); #define C(x) __copy_in_user(&r->x, &cr->x, sizeof(r->x)) if (copy_in_user(r, cr, sizeof(struct compat_raw1394_req)) || C(address) || C(tag) || C(sendb) || C(recvb)) return ERR_PTR(-EFAULT); return (const char __user *)r; } #undef C #define P(x) __put_user(r->x, &cr->x) static int raw1394_compat_read(const char __user *buf, struct raw1394_request *r) { struct compat_raw1394_req __user *cr = (typeof(cr)) buf; if (!access_ok(VERIFY_WRITE, cr, sizeof(struct compat_raw1394_req)) || P(type) || P(error) || P(misc) || P(generation) || P(length) || P(address) || P(tag) || P(sendb) || P(recvb)) return -EFAULT; return sizeof(struct compat_raw1394_req); } #undef P #endif /* get next completed request (caller must hold fi->reqlists_lock) */ static inline struct pending_request *__next_complete_req(struct file_info *fi) { struct list_head *lh; struct pending_request *req = NULL; if (!list_empty(&fi->req_complete)) { lh = fi->req_complete.next; list_del(lh); req = list_entry(lh, struct pending_request, list); } return req; } /* atomically get next completed request */ static struct pending_request *next_complete_req(struct file_info *fi) { unsigned long flags; struct pending_request *req; spin_lock_irqsave(&fi->reqlists_lock, flags); req = __next_complete_req(fi); spin_unlock_irqrestore(&fi->reqlists_lock, flags); return req; } static ssize_t raw1394_read(struct file *file, char __user * buffer, size_t count, loff_t * offset_is_ignored) { struct file_info *fi = (struct file_info *)file->private_data; struct pending_request *req; ssize_t ret; #ifdef CONFIG_COMPAT if (count == sizeof(struct compat_raw1394_req)) { /* ok */ } else #endif if (count != sizeof(struct raw1394_request)) { return -EINVAL; } if (!access_ok(VERIFY_WRITE, buffer, count)) { return -EFAULT; } if (file->f_flags & O_NONBLOCK) { if (!(req = next_complete_req(fi))) return -EAGAIN; } else { /* * NB: We call the macro wait_event_interruptible() with a * condition argument with side effect. This is only possible * because the side effect does not occur until the condition * became true, and wait_event_interruptible() won't evaluate * the condition again after that. */ if (wait_event_interruptible(fi->wait_complete, (req = next_complete_req(fi)))) return -ERESTARTSYS; } if (req->req.length) { if (copy_to_user(int2ptr(req->req.recvb), req->data, req->req.length)) { req->req.error = RAW1394_ERROR_MEMFAULT; } } #ifdef CONFIG_COMPAT if (count == sizeof(struct compat_raw1394_req) && sizeof(struct compat_raw1394_req) != sizeof(struct raw1394_request)) { ret = raw1394_compat_read(buffer, &req->req); } else #endif { if (copy_to_user(buffer, &req->req, sizeof(req->req))) { ret = -EFAULT; goto out; } ret = (ssize_t) sizeof(struct raw1394_request); } out: free_pending_request(req); return ret; } static int state_opened(struct file_info *fi, struct pending_request *req) { if (req->req.type == RAW1394_REQ_INITIALIZE) { switch (req->req.misc) { case RAW1394_KERNELAPI_VERSION: case 3: fi->state = initialized; fi->protocol_version = req->req.misc; req->req.error = RAW1394_ERROR_NONE; req->req.generation = atomic_read(&internal_generation); break; default: req->req.error = RAW1394_ERROR_COMPAT; req->req.misc = RAW1394_KERNELAPI_VERSION; } } else { req->req.error = RAW1394_ERROR_STATE_ORDER; } req->req.length = 0; queue_complete_req(req); return 0; } static int state_initialized(struct file_info *fi, struct pending_request *req) { unsigned long flags; struct host_info *hi; struct raw1394_khost_list *khl; if (req->req.generation != atomic_read(&internal_generation)) { req->req.error = RAW1394_ERROR_GENERATION; req->req.generation = atomic_read(&internal_generation); req->req.length = 0; queue_complete_req(req); return 0; } switch (req->req.type) { case RAW1394_REQ_LIST_CARDS: spin_lock_irqsave(&host_info_lock, flags); khl = kmalloc(sizeof(*khl) * host_count, GFP_ATOMIC); if (khl) { req->req.misc = host_count; req->data = (quadlet_t *) khl; list_for_each_entry(hi, &host_info_list, list) { khl->nodes = hi->host->node_count; strcpy(khl->name, hi->host->driver->name); khl++; } } spin_unlock_irqrestore(&host_info_lock, flags); if (khl) { req->req.error = RAW1394_ERROR_NONE; req->req.length = min(req->req.length, (u32) (sizeof (struct raw1394_khost_list) * req->req.misc)); req->free_data = 1; } else { return -ENOMEM; } break; case RAW1394_REQ_SET_CARD: spin_lock_irqsave(&host_info_lock, flags); if (req->req.misc >= host_count) { req->req.error = RAW1394_ERROR_INVALID_ARG; goto out_set_card; } list_for_each_entry(hi, &host_info_list, list) if (!req->req.misc--) break; get_device(&hi->host->device); /* FIXME handle failure case */ list_add_tail(&fi->list, &hi->file_info_list); /* prevent unloading of the host's low-level driver */ if (!try_module_get(hi->host->driver->owner)) { req->req.error = RAW1394_ERROR_ABORTED; goto out_set_card; } WARN_ON(fi->host); fi->host = hi->host; fi->state = connected; req->req.error = RAW1394_ERROR_NONE; req->req.generation = get_hpsb_generation(fi->host); req->req.misc = (fi->host->node_id << 16) | fi->host->node_count; if (fi->protocol_version > 3) req->req.misc |= NODEID_TO_NODE(fi->host->irm_id) << 8; out_set_card: spin_unlock_irqrestore(&host_info_lock, flags); req->req.length = 0; break; default: req->req.error = RAW1394_ERROR_STATE_ORDER; req->req.length = 0; break; } queue_complete_req(req); return 0; } static void handle_fcp_listen(struct file_info *fi, struct pending_request *req) { if (req->req.misc) { if (fi->fcp_buffer) { req->req.error = RAW1394_ERROR_ALREADY; } else { fi->fcp_buffer = int2ptr(req->req.recvb); } } else { if (!fi->fcp_buffer) { req->req.error = RAW1394_ERROR_ALREADY; } else { fi->fcp_buffer = NULL; } } req->req.length = 0; queue_complete_req(req); } static int handle_async_request(struct file_info *fi, struct pending_request *req, int node) { unsigned long flags; struct hpsb_packet *packet = NULL; u64 addr = req->req.address & 0xffffffffffffULL; switch (req->req.type) { case RAW1394_REQ_ASYNC_READ: DBGMSG("read_request called"); packet = hpsb_make_readpacket(fi->host, node, addr, req->req.length); if (!packet) return -ENOMEM; if (req->req.length == 4) req->data = &packet->header[3]; else req->data = packet->data; break; case RAW1394_REQ_ASYNC_WRITE: DBGMSG("write_request called"); packet = hpsb_make_writepacket(fi->host, node, addr, NULL, req->req.length); if (!packet) return -ENOMEM; if (req->req.length == 4) { if (copy_from_user (&packet->header[3], int2ptr(req->req.sendb), req->req.length)) req->req.error = RAW1394_ERROR_MEMFAULT; } else { if (copy_from_user (packet->data, int2ptr(req->req.sendb), req->req.length)) req->req.error = RAW1394_ERROR_MEMFAULT; } req->req.length = 0; break; case RAW1394_REQ_ASYNC_STREAM: DBGMSG("stream_request called"); packet = hpsb_make_streampacket(fi->host, NULL, req->req.length, node & 0x3f /*channel */ , (req->req.misc >> 16) & 0x3, req->req.misc & 0xf); if (!packet) return -ENOMEM; if (copy_from_user(packet->data, int2ptr(req->req.sendb), req->req.length)) req->req.error = RAW1394_ERROR_MEMFAULT; req->req.length = 0; break; case RAW1394_REQ_LOCK: DBGMSG("lock_request called"); if ((req->req.misc == EXTCODE_FETCH_ADD) || (req->req.misc == EXTCODE_LITTLE_ADD)) { if (req->req.length != 4) { req->req.error = RAW1394_ERROR_INVALID_ARG; break; } } else { if (req->req.length != 8) { req->req.error = RAW1394_ERROR_INVALID_ARG; break; } } packet = hpsb_make_lockpacket(fi->host, node, addr, req->req.misc, NULL, 0); if (!packet) return -ENOMEM; if (copy_from_user(packet->data, int2ptr(req->req.sendb), req->req.length)) { req->req.error = RAW1394_ERROR_MEMFAULT; break; } req->data = packet->data; req->req.length = 4; break; case RAW1394_REQ_LOCK64: DBGMSG("lock64_request called"); if ((req->req.misc == EXTCODE_FETCH_ADD) || (req->req.misc == EXTCODE_LITTLE_ADD)) { if (req->req.length != 8) { req->req.error = RAW1394_ERROR_INVALID_ARG; break; } } else { if (req->req.length != 16) { req->req.error = RAW1394_ERROR_INVALID_ARG; break; } } packet = hpsb_make_lock64packet(fi->host, node, addr, req->req.misc, NULL, 0); if (!packet) return -ENOMEM; if (copy_from_user(packet->data, int2ptr(req->req.sendb), req->req.length)) { req->req.error = RAW1394_ERROR_MEMFAULT; break; } req->data = packet->data; req->req.length = 8; break; default: req->req.error = RAW1394_ERROR_STATE_ORDER; } req->packet = packet; if (req->req.error) { req->req.length = 0; queue_complete_req(req); return 0; } hpsb_set_packet_complete_task(packet, (void (*)(void *))queue_complete_cb, req); spin_lock_irqsave(&fi->reqlists_lock, flags); list_add_tail(&req->list, &fi->req_pending); spin_unlock_irqrestore(&fi->reqlists_lock, flags); packet->generation = req->req.generation; if (hpsb_send_packet(packet) < 0) { req->req.error = RAW1394_ERROR_SEND_ERROR; req->req.length = 0; hpsb_free_tlabel(packet); queue_complete_req(req); } return 0; } static int handle_async_send(struct file_info *fi, struct pending_request *req) { unsigned long flags; struct hpsb_packet *packet; int header_length = req->req.misc & 0xffff; int expect_response = req->req.misc >> 16; size_t data_size; if (header_length > req->req.length || header_length < 12 || header_length > FIELD_SIZEOF(struct hpsb_packet, header)) { req->req.error = RAW1394_ERROR_INVALID_ARG; req->req.length = 0; queue_complete_req(req); return 0; } data_size = req->req.length - header_length; packet = hpsb_alloc_packet(data_size); req->packet = packet; if (!packet) return -ENOMEM; if (copy_from_user(packet->header, int2ptr(req->req.sendb), header_length)) { req->req.error = RAW1394_ERROR_MEMFAULT; req->req.length = 0; queue_complete_req(req); return 0; } if (copy_from_user (packet->data, int2ptr(req->req.sendb) + header_length, data_size)) { req->req.error = RAW1394_ERROR_MEMFAULT; req->req.length = 0; queue_complete_req(req); return 0; } packet->type = hpsb_async; packet->node_id = packet->header[0] >> 16; packet->tcode = (packet->header[0] >> 4) & 0xf; packet->tlabel = (packet->header[0] >> 10) & 0x3f; packet->host = fi->host; packet->expect_response = expect_response; packet->header_size = header_length; packet->data_size = data_size; req->req.length = 0; hpsb_set_packet_complete_task(packet, (void (*)(void *))queue_complete_cb, req); spin_lock_irqsave(&fi->reqlists_lock, flags); list_add_tail(&req->list, &fi->req_pending); spin_unlock_irqrestore(&fi->reqlists_lock, flags); /* Update the generation of the packet just before sending. */ packet->generation = req->req.generation; if (hpsb_send_packet(packet) < 0) { req->req.error = RAW1394_ERROR_SEND_ERROR; queue_complete_req(req); } return 0; } static int arm_read(struct hpsb_host *host, int nodeid, quadlet_t * buffer, u64 addr, size_t length, u16 flags) { unsigned long irqflags; struct pending_request *req; struct host_info *hi; struct file_info *fi = NULL; struct list_head *entry; struct arm_addr *arm_addr = NULL; struct arm_request *arm_req = NULL; struct arm_response *arm_resp = NULL; int found = 0, size = 0, rcode = -1; struct arm_request_response *arm_req_resp = NULL; DBGMSG("arm_read called by node: %X " "addr: %4.4x %8.8x length: %Zu", nodeid, (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF), length); spin_lock_irqsave(&host_info_lock, irqflags); hi = find_host_info(host); /* search address-entry */ if (hi != NULL) { list_for_each_entry(fi, &hi->file_info_list, list) { entry = fi->addr_list.next; while (entry != &(fi->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if (((arm_addr->start) <= (addr)) && ((arm_addr->end) >= (addr + length))) { found = 1; break; } entry = entry->next; } if (found) { break; } } } rcode = -1; if (!found) { printk(KERN_ERR "raw1394: arm_read FAILED addr_entry not found" " -> rcode_address_error\n"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_ADDRESS_ERROR); } else { DBGMSG("arm_read addr_entry FOUND"); } if (arm_addr->rec_length < length) { DBGMSG("arm_read blocklength too big -> rcode_data_error"); rcode = RCODE_DATA_ERROR; /* hardware error, data is unavailable */ } if (rcode == -1) { if (arm_addr->access_rights & ARM_READ) { if (!(arm_addr->client_transactions & ARM_READ)) { memcpy(buffer, (arm_addr->addr_space_buffer) + (addr - (arm_addr-> start)), length); DBGMSG("arm_read -> (rcode_complete)"); rcode = RCODE_COMPLETE; } } else { rcode = RCODE_TYPE_ERROR; /* function not allowed */ DBGMSG("arm_read -> rcode_type_error (access denied)"); } } if (arm_addr->notification_options & ARM_READ) { DBGMSG("arm_read -> entering notification-section"); req = __alloc_pending_request(GFP_ATOMIC); if (!req) { DBGMSG("arm_read -> rcode_conflict_error"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected. The request may be retried */ } if (rcode == RCODE_COMPLETE) { size = sizeof(struct arm_request) + sizeof(struct arm_response) + length * sizeof(byte_t) + sizeof(struct arm_request_response); } else { size = sizeof(struct arm_request) + sizeof(struct arm_response) + sizeof(struct arm_request_response); } req->data = kmalloc(size, GFP_ATOMIC); if (!(req->data)) { free_pending_request(req); DBGMSG("arm_read -> rcode_conflict_error"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected. The request may be retried */ } req->free_data = 1; req->file_info = fi; req->req.type = RAW1394_REQ_ARM; req->req.generation = get_hpsb_generation(host); req->req.misc = (((length << 16) & (0xFFFF0000)) | (ARM_READ & 0xFF)); req->req.tag = arm_addr->arm_tag; req->req.recvb = arm_addr->recvb; req->req.length = size; arm_req_resp = (struct arm_request_response *)(req->data); arm_req = (struct arm_request *)((byte_t *) (req->data) + (sizeof (struct arm_request_response))); arm_resp = (struct arm_response *)((byte_t *) (arm_req) + (sizeof(struct arm_request))); arm_req->buffer = NULL; arm_resp->buffer = NULL; if (rcode == RCODE_COMPLETE) { byte_t *buf = (byte_t *) arm_resp + sizeof(struct arm_response); memcpy(buf, (arm_addr->addr_space_buffer) + (addr - (arm_addr-> start)), length); arm_resp->buffer = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request) + sizeof(struct arm_response)); } arm_resp->buffer_length = (rcode == RCODE_COMPLETE) ? length : 0; arm_resp->response_code = rcode; arm_req->buffer_length = 0; arm_req->generation = req->req.generation; arm_req->extended_transaction_code = 0; arm_req->destination_offset = addr; arm_req->source_nodeid = nodeid; arm_req->destination_nodeid = host->node_id; arm_req->tlabel = (flags >> 10) & 0x3f; arm_req->tcode = (flags >> 4) & 0x0f; arm_req_resp->request = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response)); arm_req_resp->response = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request)); queue_complete_req(req); } spin_unlock_irqrestore(&host_info_lock, irqflags); return (rcode); } static int arm_write(struct hpsb_host *host, int nodeid, int destid, quadlet_t * data, u64 addr, size_t length, u16 flags) { unsigned long irqflags; struct pending_request *req; struct host_info *hi; struct file_info *fi = NULL; struct list_head *entry; struct arm_addr *arm_addr = NULL; struct arm_request *arm_req = NULL; struct arm_response *arm_resp = NULL; int found = 0, size = 0, rcode = -1, length_conflict = 0; struct arm_request_response *arm_req_resp = NULL; DBGMSG("arm_write called by node: %X " "addr: %4.4x %8.8x length: %Zu", nodeid, (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF), length); spin_lock_irqsave(&host_info_lock, irqflags); hi = find_host_info(host); /* search address-entry */ if (hi != NULL) { list_for_each_entry(fi, &hi->file_info_list, list) { entry = fi->addr_list.next; while (entry != &(fi->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if (((arm_addr->start) <= (addr)) && ((arm_addr->end) >= (addr + length))) { found = 1; break; } entry = entry->next; } if (found) { break; } } } rcode = -1; if (!found) { printk(KERN_ERR "raw1394: arm_write FAILED addr_entry not found" " -> rcode_address_error\n"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_ADDRESS_ERROR); } else { DBGMSG("arm_write addr_entry FOUND"); } if (arm_addr->rec_length < length) { DBGMSG("arm_write blocklength too big -> rcode_data_error"); length_conflict = 1; rcode = RCODE_DATA_ERROR; /* hardware error, data is unavailable */ } if (rcode == -1) { if (arm_addr->access_rights & ARM_WRITE) { if (!(arm_addr->client_transactions & ARM_WRITE)) { memcpy((arm_addr->addr_space_buffer) + (addr - (arm_addr->start)), data, length); DBGMSG("arm_write -> (rcode_complete)"); rcode = RCODE_COMPLETE; } } else { rcode = RCODE_TYPE_ERROR; /* function not allowed */ DBGMSG("arm_write -> rcode_type_error (access denied)"); } } if (arm_addr->notification_options & ARM_WRITE) { DBGMSG("arm_write -> entering notification-section"); req = __alloc_pending_request(GFP_ATOMIC); if (!req) { DBGMSG("arm_write -> rcode_conflict_error"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected. The request my be retried */ } size = sizeof(struct arm_request) + sizeof(struct arm_response) + (length) * sizeof(byte_t) + sizeof(struct arm_request_response); req->data = kmalloc(size, GFP_ATOMIC); if (!(req->data)) { free_pending_request(req); DBGMSG("arm_write -> rcode_conflict_error"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected. The request may be retried */ } req->free_data = 1; req->file_info = fi; req->req.type = RAW1394_REQ_ARM; req->req.generation = get_hpsb_generation(host); req->req.misc = (((length << 16) & (0xFFFF0000)) | (ARM_WRITE & 0xFF)); req->req.tag = arm_addr->arm_tag; req->req.recvb = arm_addr->recvb; req->req.length = size; arm_req_resp = (struct arm_request_response *)(req->data); arm_req = (struct arm_request *)((byte_t *) (req->data) + (sizeof (struct arm_request_response))); arm_resp = (struct arm_response *)((byte_t *) (arm_req) + (sizeof(struct arm_request))); arm_resp->buffer = NULL; memcpy((byte_t *) arm_resp + sizeof(struct arm_response), data, length); arm_req->buffer = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request) + sizeof(struct arm_response)); arm_req->buffer_length = length; arm_req->generation = req->req.generation; arm_req->extended_transaction_code = 0; arm_req->destination_offset = addr; arm_req->source_nodeid = nodeid; arm_req->destination_nodeid = destid; arm_req->tlabel = (flags >> 10) & 0x3f; arm_req->tcode = (flags >> 4) & 0x0f; arm_resp->buffer_length = 0; arm_resp->response_code = rcode; arm_req_resp->request = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response)); arm_req_resp->response = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request)); queue_complete_req(req); } spin_unlock_irqrestore(&host_info_lock, irqflags); return (rcode); } static int arm_lock(struct hpsb_host *host, int nodeid, quadlet_t * store, u64 addr, quadlet_t data, quadlet_t arg, int ext_tcode, u16 flags) { unsigned long irqflags; struct pending_request *req; struct host_info *hi; struct file_info *fi = NULL; struct list_head *entry; struct arm_addr *arm_addr = NULL; struct arm_request *arm_req = NULL; struct arm_response *arm_resp = NULL; int found = 0, size = 0, rcode = -1; quadlet_t old, new; struct arm_request_response *arm_req_resp = NULL; if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) || ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) { DBGMSG("arm_lock called by node: %X " "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X", nodeid, (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF, be32_to_cpu(data)); } else { DBGMSG("arm_lock called by node: %X " "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X arg: %8.8X", nodeid, (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF, be32_to_cpu(data), be32_to_cpu(arg)); } spin_lock_irqsave(&host_info_lock, irqflags); hi = find_host_info(host); /* search address-entry */ if (hi != NULL) { list_for_each_entry(fi, &hi->file_info_list, list) { entry = fi->addr_list.next; while (entry != &(fi->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if (((arm_addr->start) <= (addr)) && ((arm_addr->end) >= (addr + sizeof(*store)))) { found = 1; break; } entry = entry->next; } if (found) { break; } } } rcode = -1; if (!found) { printk(KERN_ERR "raw1394: arm_lock FAILED addr_entry not found" " -> rcode_address_error\n"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_ADDRESS_ERROR); } else { DBGMSG("arm_lock addr_entry FOUND"); } if (rcode == -1) { if (arm_addr->access_rights & ARM_LOCK) { if (!(arm_addr->client_transactions & ARM_LOCK)) { memcpy(&old, (arm_addr->addr_space_buffer) + (addr - (arm_addr-> start)), sizeof(old)); switch (ext_tcode) { case (EXTCODE_MASK_SWAP): new = data | (old & ~arg); break; case (EXTCODE_COMPARE_SWAP): if (old == arg) { new = data; } else { new = old; } break; case (EXTCODE_FETCH_ADD): new = cpu_to_be32(be32_to_cpu(data) + be32_to_cpu(old)); break; case (EXTCODE_LITTLE_ADD): new = cpu_to_le32(le32_to_cpu(data) + le32_to_cpu(old)); break; case (EXTCODE_BOUNDED_ADD): if (old != arg) { new = cpu_to_be32(be32_to_cpu (data) + be32_to_cpu (old)); } else { new = old; } break; case (EXTCODE_WRAP_ADD): if (old != arg) { new = cpu_to_be32(be32_to_cpu (data) + be32_to_cpu (old)); } else { new = data; } break; default: rcode = RCODE_TYPE_ERROR; /* function not allowed */ printk(KERN_ERR "raw1394: arm_lock FAILED " "ext_tcode not allowed -> rcode_type_error\n"); break; } /*switch */ if (rcode == -1) { DBGMSG("arm_lock -> (rcode_complete)"); rcode = RCODE_COMPLETE; memcpy(store, &old, sizeof(*store)); memcpy((arm_addr->addr_space_buffer) + (addr - (arm_addr->start)), &new, sizeof(*store)); } } } else { rcode = RCODE_TYPE_ERROR; /* function not allowed */ DBGMSG("arm_lock -> rcode_type_error (access denied)"); } } if (arm_addr->notification_options & ARM_LOCK) { byte_t *buf1, *buf2; DBGMSG("arm_lock -> entering notification-section"); req = __alloc_pending_request(GFP_ATOMIC); if (!req) { DBGMSG("arm_lock -> rcode_conflict_error"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected. The request may be retried */ } size = sizeof(struct arm_request) + sizeof(struct arm_response) + 3 * sizeof(*store) + sizeof(struct arm_request_response); /* maximum */ req->data = kmalloc(size, GFP_ATOMIC); if (!(req->data)) { free_pending_request(req); DBGMSG("arm_lock -> rcode_conflict_error"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected. The request may be retried */ } req->free_data = 1; arm_req_resp = (struct arm_request_response *)(req->data); arm_req = (struct arm_request *)((byte_t *) (req->data) + (sizeof (struct arm_request_response))); arm_resp = (struct arm_response *)((byte_t *) (arm_req) + (sizeof(struct arm_request))); buf1 = (byte_t *) arm_resp + sizeof(struct arm_response); buf2 = buf1 + 2 * sizeof(*store); if ((ext_tcode == EXTCODE_FETCH_ADD) || (ext_tcode == EXTCODE_LITTLE_ADD)) { arm_req->buffer_length = sizeof(*store); memcpy(buf1, &data, sizeof(*store)); } else { arm_req->buffer_length = 2 * sizeof(*store); memcpy(buf1, &arg, sizeof(*store)); memcpy(buf1 + sizeof(*store), &data, sizeof(*store)); } if (rcode == RCODE_COMPLETE) { arm_resp->buffer_length = sizeof(*store); memcpy(buf2, &old, sizeof(*store)); } else { arm_resp->buffer_length = 0; } req->file_info = fi; req->req.type = RAW1394_REQ_ARM; req->req.generation = get_hpsb_generation(host); req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) | (ARM_LOCK & 0xFF)); req->req.tag = arm_addr->arm_tag; req->req.recvb = arm_addr->recvb; req->req.length = size; arm_req->generation = req->req.generation; arm_req->extended_transaction_code = ext_tcode; arm_req->destination_offset = addr; arm_req->source_nodeid = nodeid; arm_req->destination_nodeid = host->node_id; arm_req->tlabel = (flags >> 10) & 0x3f; arm_req->tcode = (flags >> 4) & 0x0f; arm_resp->response_code = rcode; arm_req_resp->request = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response)); arm_req_resp->response = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request)); arm_req->buffer = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request) + sizeof(struct arm_response)); arm_resp->buffer = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request) + sizeof(struct arm_response) + 2 * sizeof(*store)); queue_complete_req(req); } spin_unlock_irqrestore(&host_info_lock, irqflags); return (rcode); } static int arm_lock64(struct hpsb_host *host, int nodeid, octlet_t * store, u64 addr, octlet_t data, octlet_t arg, int ext_tcode, u16 flags) { unsigned long irqflags; struct pending_request *req; struct host_info *hi; struct file_info *fi = NULL; struct list_head *entry; struct arm_addr *arm_addr = NULL; struct arm_request *arm_req = NULL; struct arm_response *arm_resp = NULL; int found = 0, size = 0, rcode = -1; octlet_t old, new; struct arm_request_response *arm_req_resp = NULL; if (((ext_tcode & 0xFF) == EXTCODE_FETCH_ADD) || ((ext_tcode & 0xFF) == EXTCODE_LITTLE_ADD)) { DBGMSG("arm_lock64 called by node: %X " "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X ", nodeid, (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF, (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF), (u32) (be64_to_cpu(data) & 0xFFFFFFFF)); } else { DBGMSG("arm_lock64 called by node: %X " "addr: %4.4x %8.8x extcode: %2.2X data: %8.8X %8.8X arg: " "%8.8X %8.8X ", nodeid, (u16) ((addr >> 32) & 0xFFFF), (u32) (addr & 0xFFFFFFFF), ext_tcode & 0xFF, (u32) ((be64_to_cpu(data) >> 32) & 0xFFFFFFFF), (u32) (be64_to_cpu(data) & 0xFFFFFFFF), (u32) ((be64_to_cpu(arg) >> 32) & 0xFFFFFFFF), (u32) (be64_to_cpu(arg) & 0xFFFFFFFF)); } spin_lock_irqsave(&host_info_lock, irqflags); hi = find_host_info(host); /* search addressentry in file_info's for host */ if (hi != NULL) { list_for_each_entry(fi, &hi->file_info_list, list) { entry = fi->addr_list.next; while (entry != &(fi->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if (((arm_addr->start) <= (addr)) && ((arm_addr->end) >= (addr + sizeof(*store)))) { found = 1; break; } entry = entry->next; } if (found) { break; } } } rcode = -1; if (!found) { printk(KERN_ERR "raw1394: arm_lock64 FAILED addr_entry not found" " -> rcode_address_error\n"); spin_unlock_irqrestore(&host_info_lock, irqflags); return (RCODE_ADDRESS_ERROR); } else { DBGMSG("arm_lock64 addr_entry FOUND"); } if (rcode == -1) { if (arm_addr->access_rights & ARM_LOCK) { if (!(arm_addr->client_transactions & ARM_LOCK)) { memcpy(&old, (arm_addr->addr_space_buffer) + (addr - (arm_addr-> start)), sizeof(old)); switch (ext_tcode) { case (EXTCODE_MASK_SWAP): new = data | (old & ~arg); break; case (EXTCODE_COMPARE_SWAP): if (old == arg) { new = data; } else { new = old; } break; case (EXTCODE_FETCH_ADD): new = cpu_to_be64(be64_to_cpu(data) + be64_to_cpu(old)); break; case (EXTCODE_LITTLE_ADD): new = cpu_to_le64(le64_to_cpu(data) + le64_to_cpu(old)); break; case (EXTCODE_BOUNDED_ADD): if (old != arg) { new = cpu_to_be64(be64_to_cpu (data) + be64_to_cpu (old)); } else { new = old; } break; case (EXTCODE_WRAP_ADD): if (old != arg) { new = cpu_to_be64(be64_to_cpu (data) + be64_to_cpu (old)); } else { new = data; } break; default: printk(KERN_ERR "raw1394: arm_lock64 FAILED " "ext_tcode not allowed -> rcode_type_error\n"); rcode = RCODE_TYPE_ERROR; /* function not allowed */ break; } /*switch */ if (rcode == -1) { DBGMSG ("arm_lock64 -> (rcode_complete)"); rcode = RCODE_COMPLETE; memcpy(store, &old, sizeof(*store)); memcpy((arm_addr->addr_space_buffer) + (addr - (arm_addr->start)), &new, sizeof(*store)); } } } else { rcode = RCODE_TYPE_ERROR; /* function not allowed */ DBGMSG ("arm_lock64 -> rcode_type_error (access denied)"); } } if (arm_addr->notification_options & ARM_LOCK) { byte_t *buf1, *buf2; DBGMSG("arm_lock64 -> entering notification-section"); req = __alloc_pending_request(GFP_ATOMIC); if (!req) { spin_unlock_irqrestore(&host_info_lock, irqflags); DBGMSG("arm_lock64 -> rcode_conflict_error"); return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected. The request may be retried */ } size = sizeof(struct arm_request) + sizeof(struct arm_response) + 3 * sizeof(*store) + sizeof(struct arm_request_response); /* maximum */ req->data = kmalloc(size, GFP_ATOMIC); if (!(req->data)) { free_pending_request(req); spin_unlock_irqrestore(&host_info_lock, irqflags); DBGMSG("arm_lock64 -> rcode_conflict_error"); return (RCODE_CONFLICT_ERROR); /* A resource conflict was detected. The request may be retried */ } req->free_data = 1; arm_req_resp = (struct arm_request_response *)(req->data); arm_req = (struct arm_request *)((byte_t *) (req->data) + (sizeof (struct arm_request_response))); arm_resp = (struct arm_response *)((byte_t *) (arm_req) + (sizeof(struct arm_request))); buf1 = (byte_t *) arm_resp + sizeof(struct arm_response); buf2 = buf1 + 2 * sizeof(*store); if ((ext_tcode == EXTCODE_FETCH_ADD) || (ext_tcode == EXTCODE_LITTLE_ADD)) { arm_req->buffer_length = sizeof(*store); memcpy(buf1, &data, sizeof(*store)); } else { arm_req->buffer_length = 2 * sizeof(*store); memcpy(buf1, &arg, sizeof(*store)); memcpy(buf1 + sizeof(*store), &data, sizeof(*store)); } if (rcode == RCODE_COMPLETE) { arm_resp->buffer_length = sizeof(*store); memcpy(buf2, &old, sizeof(*store)); } else { arm_resp->buffer_length = 0; } req->file_info = fi; req->req.type = RAW1394_REQ_ARM; req->req.generation = get_hpsb_generation(host); req->req.misc = ((((sizeof(*store)) << 16) & (0xFFFF0000)) | (ARM_LOCK & 0xFF)); req->req.tag = arm_addr->arm_tag; req->req.recvb = arm_addr->recvb; req->req.length = size; arm_req->generation = req->req.generation; arm_req->extended_transaction_code = ext_tcode; arm_req->destination_offset = addr; arm_req->source_nodeid = nodeid; arm_req->destination_nodeid = host->node_id; arm_req->tlabel = (flags >> 10) & 0x3f; arm_req->tcode = (flags >> 4) & 0x0f; arm_resp->response_code = rcode; arm_req_resp->request = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response)); arm_req_resp->response = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request)); arm_req->buffer = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request) + sizeof(struct arm_response)); arm_resp->buffer = int2ptr((arm_addr->recvb) + sizeof(struct arm_request_response) + sizeof(struct arm_request) + sizeof(struct arm_response) + 2 * sizeof(*store)); queue_complete_req(req); } spin_unlock_irqrestore(&host_info_lock, irqflags); return (rcode); } static int arm_register(struct file_info *fi, struct pending_request *req) { int retval; struct arm_addr *addr; struct host_info *hi; struct file_info *fi_hlp = NULL; struct list_head *entry; struct arm_addr *arm_addr = NULL; int same_host, another_host; unsigned long flags; DBGMSG("arm_register called " "addr(Offset): %8.8x %8.8x length: %u " "rights: %2.2X notify: %2.2X " "max_blk_len: %4.4X", (u32) ((req->req.address >> 32) & 0xFFFF), (u32) (req->req.address & 0xFFFFFFFF), req->req.length, ((req->req.misc >> 8) & 0xFF), (req->req.misc & 0xFF), ((req->req.misc >> 16) & 0xFFFF)); /* check addressrange */ if ((((req->req.address) & ~(0xFFFFFFFFFFFFULL)) != 0) || (((req->req.address + req->req.length) & ~(0xFFFFFFFFFFFFULL)) != 0)) { req->req.length = 0; return (-EINVAL); } /* addr-list-entry for fileinfo */ addr = kmalloc(sizeof(*addr), GFP_KERNEL); if (!addr) { req->req.length = 0; return (-ENOMEM); } /* allocation of addr_space_buffer */ addr->addr_space_buffer = vmalloc(req->req.length); if (!(addr->addr_space_buffer)) { kfree(addr); req->req.length = 0; return (-ENOMEM); } /* initialization of addr_space_buffer */ if ((req->req.sendb) == (unsigned long)NULL) { /* init: set 0 */ memset(addr->addr_space_buffer, 0, req->req.length); } else { /* init: user -> kernel */ if (copy_from_user (addr->addr_space_buffer, int2ptr(req->req.sendb), req->req.length)) { vfree(addr->addr_space_buffer); kfree(addr); return (-EFAULT); } } INIT_LIST_HEAD(&addr->addr_list); addr->arm_tag = req->req.tag; addr->start = req->req.address; addr->end = req->req.address + req->req.length; addr->access_rights = (u8) (req->req.misc & 0x0F); addr->notification_options = (u8) ((req->req.misc >> 4) & 0x0F); addr->client_transactions = (u8) ((req->req.misc >> 8) & 0x0F); addr->access_rights |= addr->client_transactions; addr->notification_options |= addr->client_transactions; addr->recvb = req->req.recvb; addr->rec_length = (u16) ((req->req.misc >> 16) & 0xFFFF); spin_lock_irqsave(&host_info_lock, flags); hi = find_host_info(fi->host); same_host = 0; another_host = 0; /* same host with address-entry containing same addressrange ? */ list_for_each_entry(fi_hlp, &hi->file_info_list, list) { entry = fi_hlp->addr_list.next; while (entry != &(fi_hlp->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if ((arm_addr->start == addr->start) && (arm_addr->end == addr->end)) { DBGMSG("same host ownes same " "addressrange -> EALREADY"); same_host = 1; break; } entry = entry->next; } if (same_host) { break; } } if (same_host) { /* addressrange occupied by same host */ spin_unlock_irqrestore(&host_info_lock, flags); vfree(addr->addr_space_buffer); kfree(addr); return (-EALREADY); } /* another host with valid address-entry containing same addressrange */ list_for_each_entry(hi, &host_info_list, list) { if (hi->host != fi->host) { list_for_each_entry(fi_hlp, &hi->file_info_list, list) { entry = fi_hlp->addr_list.next; while (entry != &(fi_hlp->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if ((arm_addr->start == addr->start) && (arm_addr->end == addr->end)) { DBGMSG ("another host ownes same " "addressrange"); another_host = 1; break; } entry = entry->next; } if (another_host) { break; } } } } spin_unlock_irqrestore(&host_info_lock, flags); if (another_host) { DBGMSG("another hosts entry is valid -> SUCCESS"); if (copy_to_user(int2ptr(req->req.recvb), &addr->start, sizeof(u64))) { printk(KERN_ERR "raw1394: arm_register failed " " address-range-entry is invalid -> EFAULT !!!\n"); vfree(addr->addr_space_buffer); kfree(addr); return (-EFAULT); } free_pending_request(req); /* immediate success or fail */ /* INSERT ENTRY */ spin_lock_irqsave(&host_info_lock, flags); list_add_tail(&addr->addr_list, &fi->addr_list); spin_unlock_irqrestore(&host_info_lock, flags); return 0; } retval = hpsb_register_addrspace(&raw1394_highlevel, fi->host, &arm_ops, req->req.address, req->req.address + req->req.length); if (retval) { /* INSERT ENTRY */ spin_lock_irqsave(&host_info_lock, flags); list_add_tail(&addr->addr_list, &fi->addr_list); spin_unlock_irqrestore(&host_info_lock, flags); } else { DBGMSG("arm_register failed errno: %d \n", retval); vfree(addr->addr_space_buffer); kfree(addr); return (-EALREADY); } free_pending_request(req); /* immediate success or fail */ return 0; } static int arm_unregister(struct file_info *fi, struct pending_request *req) { int found = 0; int retval = 0; struct list_head *entry; struct arm_addr *addr = NULL; struct host_info *hi; struct file_info *fi_hlp = NULL; struct arm_addr *arm_addr = NULL; int another_host; unsigned long flags; DBGMSG("arm_Unregister called addr(Offset): " "%8.8x %8.8x", (u32) ((req->req.address >> 32) & 0xFFFF), (u32) (req->req.address & 0xFFFFFFFF)); spin_lock_irqsave(&host_info_lock, flags); /* get addr */ entry = fi->addr_list.next; while (entry != &(fi->addr_list)) { addr = list_entry(entry, struct arm_addr, addr_list); if (addr->start == req->req.address) { found = 1; break; } entry = entry->next; } if (!found) { DBGMSG("arm_Unregister addr not found"); spin_unlock_irqrestore(&host_info_lock, flags); return (-EINVAL); } DBGMSG("arm_Unregister addr found"); another_host = 0; /* another host with valid address-entry containing same addressrange */ list_for_each_entry(hi, &host_info_list, list) { if (hi->host != fi->host) { list_for_each_entry(fi_hlp, &hi->file_info_list, list) { entry = fi_hlp->addr_list.next; while (entry != &(fi_hlp->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if (arm_addr->start == addr->start) { DBGMSG("another host ownes " "same addressrange"); another_host = 1; break; } entry = entry->next; } if (another_host) { break; } } } } if (another_host) { DBGMSG("delete entry from list -> success"); list_del(&addr->addr_list); spin_unlock_irqrestore(&host_info_lock, flags); vfree(addr->addr_space_buffer); kfree(addr); free_pending_request(req); /* immediate success or fail */ return 0; } retval = hpsb_unregister_addrspace(&raw1394_highlevel, fi->host, addr->start); if (!retval) { printk(KERN_ERR "raw1394: arm_Unregister failed -> EINVAL\n"); spin_unlock_irqrestore(&host_info_lock, flags); return (-EINVAL); } DBGMSG("delete entry from list -> success"); list_del(&addr->addr_list); spin_unlock_irqrestore(&host_info_lock, flags); vfree(addr->addr_space_buffer); kfree(addr); free_pending_request(req); /* immediate success or fail */ return 0; } /* Copy data from ARM buffer(s) to user buffer. */ static int arm_get_buf(struct file_info *fi, struct pending_request *req) { struct arm_addr *arm_addr = NULL; unsigned long flags; unsigned long offset; struct list_head *entry; DBGMSG("arm_get_buf " "addr(Offset): %04X %08X length: %u", (u32) ((req->req.address >> 32) & 0xFFFF), (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length); spin_lock_irqsave(&host_info_lock, flags); entry = fi->addr_list.next; while (entry != &(fi->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if ((arm_addr->start <= req->req.address) && (arm_addr->end > req->req.address)) { if (req->req.address + req->req.length <= arm_addr->end) { offset = req->req.address - arm_addr->start; spin_unlock_irqrestore(&host_info_lock, flags); DBGMSG ("arm_get_buf copy_to_user( %08X, %p, %u )", (u32) req->req.recvb, arm_addr->addr_space_buffer + offset, (u32) req->req.length); if (copy_to_user (int2ptr(req->req.recvb), arm_addr->addr_space_buffer + offset, req->req.length)) return (-EFAULT); /* We have to free the request, because we * queue no response, and therefore nobody * will free it. */ free_pending_request(req); return 0; } else { DBGMSG("arm_get_buf request exceeded mapping"); spin_unlock_irqrestore(&host_info_lock, flags); return (-EINVAL); } } entry = entry->next; } spin_unlock_irqrestore(&host_info_lock, flags); return (-EINVAL); } /* Copy data from user buffer to ARM buffer(s). */ static int arm_set_buf(struct file_info *fi, struct pending_request *req) { struct arm_addr *arm_addr = NULL; unsigned long flags; unsigned long offset; struct list_head *entry; DBGMSG("arm_set_buf " "addr(Offset): %04X %08X length: %u", (u32) ((req->req.address >> 32) & 0xFFFF), (u32) (req->req.address & 0xFFFFFFFF), (u32) req->req.length); spin_lock_irqsave(&host_info_lock, flags); entry = fi->addr_list.next; while (entry != &(fi->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if ((arm_addr->start <= req->req.address) && (arm_addr->end > req->req.address)) { if (req->req.address + req->req.length <= arm_addr->end) { offset = req->req.address - arm_addr->start; spin_unlock_irqrestore(&host_info_lock, flags); DBGMSG ("arm_set_buf copy_from_user( %p, %08X, %u )", arm_addr->addr_space_buffer + offset, (u32) req->req.sendb, (u32) req->req.length); if (copy_from_user (arm_addr->addr_space_buffer + offset, int2ptr(req->req.sendb), req->req.length)) return (-EFAULT); /* We have to free the request, because we * queue no response, and therefore nobody * will free it. */ free_pending_request(req); return 0; } else { DBGMSG("arm_set_buf request exceeded mapping"); spin_unlock_irqrestore(&host_info_lock, flags); return (-EINVAL); } } entry = entry->next; } spin_unlock_irqrestore(&host_info_lock, flags); return (-EINVAL); } static int reset_notification(struct file_info *fi, struct pending_request *req) { DBGMSG("reset_notification called - switch %s ", (req->req.misc == RAW1394_NOTIFY_OFF) ? "OFF" : "ON"); if ((req->req.misc == RAW1394_NOTIFY_OFF) || (req->req.misc == RAW1394_NOTIFY_ON)) { fi->notification = (u8) req->req.misc; free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */ return 0; } /* error EINVAL (22) invalid argument */ return (-EINVAL); } static int write_phypacket(struct file_info *fi, struct pending_request *req) { struct hpsb_packet *packet = NULL; int retval = 0; quadlet_t data; unsigned long flags; data = be32_to_cpu((u32) req->req.sendb); DBGMSG("write_phypacket called - quadlet 0x%8.8x ", data); packet = hpsb_make_phypacket(fi->host, data); if (!packet) return -ENOMEM; req->req.length = 0; req->packet = packet; hpsb_set_packet_complete_task(packet, (void (*)(void *))queue_complete_cb, req); spin_lock_irqsave(&fi->reqlists_lock, flags); list_add_tail(&req->list, &fi->req_pending); spin_unlock_irqrestore(&fi->reqlists_lock, flags); packet->generation = req->req.generation; retval = hpsb_send_packet(packet); DBGMSG("write_phypacket send_packet called => retval: %d ", retval); if (retval < 0) { req->req.error = RAW1394_ERROR_SEND_ERROR; req->req.length = 0; queue_complete_req(req); } return 0; } static int get_config_rom(struct file_info *fi, struct pending_request *req) { int ret = 0; quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL); int status; if (!data) return -ENOMEM; status = csr1212_read(fi->host->csr.rom, CSR1212_CONFIG_ROM_SPACE_OFFSET, data, req->req.length); if (copy_to_user(int2ptr(req->req.recvb), data, req->req.length)) ret = -EFAULT; if (copy_to_user (int2ptr(req->req.tag), &fi->host->csr.rom->cache_head->len, sizeof(fi->host->csr.rom->cache_head->len))) ret = -EFAULT; if (copy_to_user(int2ptr(req->req.address), &fi->host->csr.generation, sizeof(fi->host->csr.generation))) ret = -EFAULT; if (copy_to_user(int2ptr(req->req.sendb), &status, sizeof(status))) ret = -EFAULT; kfree(data); if (ret >= 0) { free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */ } return ret; } static int update_config_rom(struct file_info *fi, struct pending_request *req) { int ret = 0; quadlet_t *data = kmalloc(req->req.length, GFP_KERNEL); if (!data) return -ENOMEM; if (copy_from_user(data, int2ptr(req->req.sendb), req->req.length)) { ret = -EFAULT; } else { int status = hpsb_update_config_rom(fi->host, data, req->req.length, (unsigned char)req->req. misc); if (copy_to_user (int2ptr(req->req.recvb), &status, sizeof(status))) ret = -ENOMEM; } kfree(data); if (ret >= 0) { free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */ fi->cfgrom_upd = 1; } return ret; } static int modify_config_rom(struct file_info *fi, struct pending_request *req) { struct csr1212_keyval *kv; struct csr1212_csr_rom_cache *cache; struct csr1212_dentry *dentry; u32 dr; int ret = 0; if (req->req.misc == ~0) { if (req->req.length == 0) return -EINVAL; /* Find an unused slot */ for (dr = 0; dr < RAW1394_MAX_USER_CSR_DIRS && fi->csr1212_dirs[dr]; dr++) ; if (dr == RAW1394_MAX_USER_CSR_DIRS) return -ENOMEM; fi->csr1212_dirs[dr] = csr1212_new_directory(CSR1212_KV_ID_VENDOR); if (!fi->csr1212_dirs[dr]) return -ENOMEM; } else { dr = req->req.misc; if (!fi->csr1212_dirs[dr]) return -EINVAL; /* Delete old stuff */ for (dentry = fi->csr1212_dirs[dr]->value.directory.dentries_head; dentry; dentry = dentry->next) { csr1212_detach_keyval_from_directory(fi->host->csr.rom-> root_kv, dentry->kv); } if (req->req.length == 0) { csr1212_release_keyval(fi->csr1212_dirs[dr]); fi->csr1212_dirs[dr] = NULL; hpsb_update_config_rom_image(fi->host); free_pending_request(req); return 0; } } cache = csr1212_rom_cache_malloc(0, req->req.length); if (!cache) { csr1212_release_keyval(fi->csr1212_dirs[dr]); fi->csr1212_dirs[dr] = NULL; return -ENOMEM; } cache->filled_head = kmalloc(sizeof(*cache->filled_head), GFP_KERNEL); if (!cache->filled_head) { csr1212_release_keyval(fi->csr1212_dirs[dr]); fi->csr1212_dirs[dr] = NULL; CSR1212_FREE(cache); return -ENOMEM; } cache->filled_tail = cache->filled_head; if (copy_from_user(cache->data, int2ptr(req->req.sendb), req->req.length)) { csr1212_release_keyval(fi->csr1212_dirs[dr]); fi->csr1212_dirs[dr] = NULL; ret = -EFAULT; } else { cache->len = req->req.length; cache->filled_head->offset_start = 0; cache->filled_head->offset_end = cache->size - 1; cache->layout_head = cache->layout_tail = fi->csr1212_dirs[dr]; ret = CSR1212_SUCCESS; /* parse all the items */ for (kv = cache->layout_head; ret == CSR1212_SUCCESS && kv; kv = kv->next) { ret = csr1212_parse_keyval(kv, cache); } /* attach top level items to the root directory */ for (dentry = fi->csr1212_dirs[dr]->value.directory.dentries_head; ret == CSR1212_SUCCESS && dentry; dentry = dentry->next) { ret = csr1212_attach_keyval_to_directory(fi->host->csr. rom->root_kv, dentry->kv); } if (ret == CSR1212_SUCCESS) { ret = hpsb_update_config_rom_image(fi->host); if (ret >= 0 && copy_to_user(int2ptr(req->req.recvb), &dr, sizeof(dr))) { ret = -ENOMEM; } } } kfree(cache->filled_head); CSR1212_FREE(cache); if (ret >= 0) { /* we have to free the request, because we queue no response, * and therefore nobody will free it */ free_pending_request(req); return 0; } else { for (dentry = fi->csr1212_dirs[dr]->value.directory.dentries_head; dentry; dentry = dentry->next) { csr1212_detach_keyval_from_directory(fi->host->csr.rom-> root_kv, dentry->kv); } csr1212_release_keyval(fi->csr1212_dirs[dr]); fi->csr1212_dirs[dr] = NULL; return ret; } } static int state_connected(struct file_info *fi, struct pending_request *req) { int node = req->req.address >> 48; req->req.error = RAW1394_ERROR_NONE; switch (req->req.type) { case RAW1394_REQ_ECHO: queue_complete_req(req); return 0; case RAW1394_REQ_ARM_REGISTER: return arm_register(fi, req); case RAW1394_REQ_ARM_UNREGISTER: return arm_unregister(fi, req); case RAW1394_REQ_ARM_SET_BUF: return arm_set_buf(fi, req); case RAW1394_REQ_ARM_GET_BUF: return arm_get_buf(fi, req); case RAW1394_REQ_RESET_NOTIFY: return reset_notification(fi, req); case RAW1394_REQ_ISO_SEND: case RAW1394_REQ_ISO_LISTEN: printk(KERN_DEBUG "raw1394: old iso ABI has been removed\n"); req->req.error = RAW1394_ERROR_COMPAT; req->req.misc = RAW1394_KERNELAPI_VERSION; queue_complete_req(req); return 0; case RAW1394_REQ_FCP_LISTEN: handle_fcp_listen(fi, req); return 0; case RAW1394_REQ_RESET_BUS: if (req->req.misc == RAW1394_LONG_RESET) { DBGMSG("busreset called (type: LONG)"); hpsb_reset_bus(fi->host, LONG_RESET); free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */ return 0; } if (req->req.misc == RAW1394_SHORT_RESET) { DBGMSG("busreset called (type: SHORT)"); hpsb_reset_bus(fi->host, SHORT_RESET); free_pending_request(req); /* we have to free the request, because we queue no response, and therefore nobody will free it */ return 0; } /* error EINVAL (22) invalid argument */ return (-EINVAL); case RAW1394_REQ_GET_ROM: return get_config_rom(fi, req); case RAW1394_REQ_UPDATE_ROM: return update_config_rom(fi, req); case RAW1394_REQ_MODIFY_ROM: return modify_config_rom(fi, req); } if (req->req.generation != get_hpsb_generation(fi->host)) { req->req.error = RAW1394_ERROR_GENERATION; req->req.generation = get_hpsb_generation(fi->host); req->req.length = 0; queue_complete_req(req); return 0; } switch (req->req.type) { case RAW1394_REQ_PHYPACKET: return write_phypacket(fi, req); case RAW1394_REQ_ASYNC_SEND: return handle_async_send(fi, req); } if (req->req.length == 0) { req->req.error = RAW1394_ERROR_INVALID_ARG; queue_complete_req(req); return 0; } return handle_async_request(fi, req, node); } static ssize_t raw1394_write(struct file *file, const char __user * buffer, size_t count, loff_t * offset_is_ignored) { struct file_info *fi = (struct file_info *)file->private_data; struct pending_request *req; ssize_t retval = -EBADFD; #ifdef CONFIG_COMPAT if (count == sizeof(struct compat_raw1394_req) && sizeof(struct compat_raw1394_req) != sizeof(struct raw1394_request)) { buffer = raw1394_compat_write(buffer); if (IS_ERR(buffer)) return PTR_ERR(buffer); } else #endif if (count != sizeof(struct raw1394_request)) { return -EINVAL; } req = alloc_pending_request(); if (req == NULL) { return -ENOMEM; } req->file_info = fi; if (copy_from_user(&req->req, buffer, sizeof(struct raw1394_request))) { free_pending_request(req); return -EFAULT; } switch (fi->state) { case opened: retval = state_opened(fi, req); break; case initialized: retval = state_initialized(fi, req); break; case connected: retval = state_connected(fi, req); break; } if (retval < 0) { free_pending_request(req); } else { BUG_ON(retval); retval = count; } return retval; } /* rawiso operations */ /* check if any RAW1394_REQ_RAWISO_ACTIVITY event is already in the * completion queue (reqlists_lock must be taken) */ static inline int __rawiso_event_in_queue(struct file_info *fi) { struct pending_request *req; list_for_each_entry(req, &fi->req_complete, list) if (req->req.type == RAW1394_REQ_RAWISO_ACTIVITY) return 1; return 0; } /* put a RAWISO_ACTIVITY event in the queue, if one isn't there already */ static void queue_rawiso_event(struct file_info *fi) { unsigned long flags; spin_lock_irqsave(&fi->reqlists_lock, flags); /* only one ISO activity event may be in the queue */ if (!__rawiso_event_in_queue(fi)) { struct pending_request *req = __alloc_pending_request(GFP_ATOMIC); if (req) { req->file_info = fi; req->req.type = RAW1394_REQ_RAWISO_ACTIVITY; req->req.generation = get_hpsb_generation(fi->host); __queue_complete_req(req); } else { /* on allocation failure, signal an overflow */ if (fi->iso_handle) { atomic_inc(&fi->iso_handle->overflows); } } } spin_unlock_irqrestore(&fi->reqlists_lock, flags); } static void rawiso_activity_cb(struct hpsb_iso *iso) { unsigned long flags; struct host_info *hi; struct file_info *fi; spin_lock_irqsave(&host_info_lock, flags); hi = find_host_info(iso->host); if (hi != NULL) { list_for_each_entry(fi, &hi->file_info_list, list) { if (fi->iso_handle == iso) queue_rawiso_event(fi); } } spin_unlock_irqrestore(&host_info_lock, flags); } /* helper function - gather all the kernel iso status bits for returning to user-space */ static void raw1394_iso_fill_status(struct hpsb_iso *iso, struct raw1394_iso_status *stat) { int overflows = atomic_read(&iso->overflows); int skips = atomic_read(&iso->skips); stat->config.data_buf_size = iso->buf_size; stat->config.buf_packets = iso->buf_packets; stat->config.channel = iso->channel; stat->config.speed = iso->speed; stat->config.irq_interval = iso->irq_interval; stat->n_packets = hpsb_iso_n_ready(iso); stat->overflows = ((skips & 0xFFFF) << 16) | ((overflows & 0xFFFF)); stat->xmit_cycle = iso->xmit_cycle; } static int raw1394_iso_xmit_init(struct file_info *fi, void __user * uaddr) { struct raw1394_iso_status stat; if (!fi->host) return -EINVAL; if (copy_from_user(&stat, uaddr, sizeof(stat))) return -EFAULT; fi->iso_handle = hpsb_iso_xmit_init(fi->host, stat.config.data_buf_size, stat.config.buf_packets, stat.config.channel, stat.config.speed, stat.config.irq_interval, rawiso_activity_cb); if (!fi->iso_handle) return -ENOMEM; fi->iso_state = RAW1394_ISO_XMIT; raw1394_iso_fill_status(fi->iso_handle, &stat); if (copy_to_user(uaddr, &stat, sizeof(stat))) return -EFAULT; /* queue an event to get things started */ rawiso_activity_cb(fi->iso_handle); return 0; } static int raw1394_iso_recv_init(struct file_info *fi, void __user * uaddr) { struct raw1394_iso_status stat; if (!fi->host) return -EINVAL; if (copy_from_user(&stat, uaddr, sizeof(stat))) return -EFAULT; fi->iso_handle = hpsb_iso_recv_init(fi->host, stat.config.data_buf_size, stat.config.buf_packets, stat.config.channel, stat.config.dma_mode, stat.config.irq_interval, rawiso_activity_cb); if (!fi->iso_handle) return -ENOMEM; fi->iso_state = RAW1394_ISO_RECV; raw1394_iso_fill_status(fi->iso_handle, &stat); if (copy_to_user(uaddr, &stat, sizeof(stat))) return -EFAULT; return 0; } static int raw1394_iso_get_status(struct file_info *fi, void __user * uaddr) { struct raw1394_iso_status stat; struct hpsb_iso *iso = fi->iso_handle; raw1394_iso_fill_status(fi->iso_handle, &stat); if (copy_to_user(uaddr, &stat, sizeof(stat))) return -EFAULT; /* reset overflow counter */ atomic_set(&iso->overflows, 0); /* reset skip counter */ atomic_set(&iso->skips, 0); return 0; } /* copy N packet_infos out of the ringbuffer into user-supplied array */ static int raw1394_iso_recv_packets(struct file_info *fi, void __user * uaddr) { struct raw1394_iso_packets upackets; unsigned int packet = fi->iso_handle->first_packet; int i; if (copy_from_user(&upackets, uaddr, sizeof(upackets))) return -EFAULT; if (upackets.n_packets > hpsb_iso_n_ready(fi->iso_handle)) return -EINVAL; /* ensure user-supplied buffer is accessible and big enough */ if (!access_ok(VERIFY_WRITE, upackets.infos, upackets.n_packets * sizeof(struct raw1394_iso_packet_info))) return -EFAULT; /* copy the packet_infos out */ for (i = 0; i < upackets.n_packets; i++) { if (__copy_to_user(&upackets.infos[i], &fi->iso_handle->infos[packet], sizeof(struct raw1394_iso_packet_info))) return -EFAULT; packet = (packet + 1) % fi->iso_handle->buf_packets; } return 0; } /* copy N packet_infos from user to ringbuffer, and queue them for transmission */ static int raw1394_iso_send_packets(struct file_info *fi, void __user * uaddr) { struct raw1394_iso_packets upackets; int i, rv; if (copy_from_user(&upackets, uaddr, sizeof(upackets))) return -EFAULT; if (upackets.n_packets >= fi->iso_handle->buf_packets) return -EINVAL; if (upackets.n_packets >= hpsb_iso_n_ready(fi->iso_handle)) return -EAGAIN; /* ensure user-supplied buffer is accessible and big enough */ if (!access_ok(VERIFY_READ, upackets.infos, upackets.n_packets * sizeof(struct raw1394_iso_packet_info))) return -EFAULT; /* copy the infos structs in and queue the packets */ for (i = 0; i < upackets.n_packets; i++) { struct raw1394_iso_packet_info info; if (__copy_from_user(&info, &upackets.infos[i], sizeof(struct raw1394_iso_packet_info))) return -EFAULT; rv = hpsb_iso_xmit_queue_packet(fi->iso_handle, info.offset, info.len, info.tag, info.sy); if (rv) return rv; } return 0; } static void raw1394_iso_shutdown(struct file_info *fi) { if (fi->iso_handle) hpsb_iso_shutdown(fi->iso_handle); fi->iso_handle = NULL; fi->iso_state = RAW1394_ISO_INACTIVE; } static int raw1394_read_cycle_timer(struct file_info *fi, void __user * uaddr) { struct raw1394_cycle_timer ct; int err; err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time); if (!err) if (copy_to_user(uaddr, &ct, sizeof(ct))) err = -EFAULT; return err; } /* mmap the rawiso xmit/recv buffer */ static int raw1394_mmap(struct file *file, struct vm_area_struct *vma) { struct file_info *fi = file->private_data; if (fi->iso_state == RAW1394_ISO_INACTIVE) return -EINVAL; return dma_region_mmap(&fi->iso_handle->data_buf, file, vma); } /* ioctl is only used for rawiso operations */ static long do_raw1394_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct file_info *fi = file->private_data; void __user *argp = (void __user *)arg; switch (fi->iso_state) { case RAW1394_ISO_INACTIVE: switch (cmd) { case RAW1394_IOC_ISO_XMIT_INIT: return raw1394_iso_xmit_init(fi, argp); case RAW1394_IOC_ISO_RECV_INIT: return raw1394_iso_recv_init(fi, argp); default: break; } break; case RAW1394_ISO_RECV: switch (cmd) { case RAW1394_IOC_ISO_RECV_START:{ /* copy args from user-space */ int args[3]; if (copy_from_user (&args[0], argp, sizeof(args))) return -EFAULT; return hpsb_iso_recv_start(fi->iso_handle, args[0], args[1], args[2]); } case RAW1394_IOC_ISO_XMIT_RECV_STOP: hpsb_iso_stop(fi->iso_handle); return 0; case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL: return hpsb_iso_recv_listen_channel(fi->iso_handle, arg); case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL: return hpsb_iso_recv_unlisten_channel(fi->iso_handle, arg); case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK:{ /* copy the u64 from user-space */ u64 mask; if (copy_from_user(&mask, argp, sizeof(mask))) return -EFAULT; return hpsb_iso_recv_set_channel_mask(fi-> iso_handle, mask); } case RAW1394_IOC_ISO_GET_STATUS: return raw1394_iso_get_status(fi, argp); case RAW1394_IOC_ISO_RECV_PACKETS: return raw1394_iso_recv_packets(fi, argp); case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS: return hpsb_iso_recv_release_packets(fi->iso_handle, arg); case RAW1394_IOC_ISO_RECV_FLUSH: return hpsb_iso_recv_flush(fi->iso_handle); case RAW1394_IOC_ISO_SHUTDOWN: raw1394_iso_shutdown(fi); return 0; case RAW1394_IOC_ISO_QUEUE_ACTIVITY: queue_rawiso_event(fi); return 0; } break; case RAW1394_ISO_XMIT: switch (cmd) { case RAW1394_IOC_ISO_XMIT_START:{ /* copy two ints from user-space */ int args[2]; if (copy_from_user (&args[0], argp, sizeof(args))) return -EFAULT; return hpsb_iso_xmit_start(fi->iso_handle, args[0], args[1]); } case RAW1394_IOC_ISO_XMIT_SYNC: return hpsb_iso_xmit_sync(fi->iso_handle); case RAW1394_IOC_ISO_XMIT_RECV_STOP: hpsb_iso_stop(fi->iso_handle); return 0; case RAW1394_IOC_ISO_GET_STATUS: return raw1394_iso_get_status(fi, argp); case RAW1394_IOC_ISO_XMIT_PACKETS: return raw1394_iso_send_packets(fi, argp); case RAW1394_IOC_ISO_SHUTDOWN: raw1394_iso_shutdown(fi); return 0; case RAW1394_IOC_ISO_QUEUE_ACTIVITY: queue_rawiso_event(fi); return 0; } break; default: break; } /* state-independent commands */ switch(cmd) { case RAW1394_IOC_GET_CYCLE_TIMER: return raw1394_read_cycle_timer(fi, argp); default: break; } return -EINVAL; } static long raw1394_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { long ret; lock_kernel(); ret = do_raw1394_ioctl(file, cmd, arg); unlock_kernel(); return ret; } #ifdef CONFIG_COMPAT struct raw1394_iso_packets32 { __u32 n_packets; compat_uptr_t infos; } __attribute__((packed)); struct raw1394_cycle_timer32 { __u32 cycle_timer; __u64 local_time; } #if defined(CONFIG_X86_64) || defined(CONFIG_IA64) __attribute__((packed)) #endif ; #define RAW1394_IOC_ISO_RECV_PACKETS32 \ _IOW ('#', 0x25, struct raw1394_iso_packets32) #define RAW1394_IOC_ISO_XMIT_PACKETS32 \ _IOW ('#', 0x27, struct raw1394_iso_packets32) #define RAW1394_IOC_GET_CYCLE_TIMER32 \ _IOR ('#', 0x30, struct raw1394_cycle_timer32) static long raw1394_iso_xmit_recv_packets32(struct file *file, unsigned int cmd, struct raw1394_iso_packets32 __user *arg) { compat_uptr_t infos32; void __user *infos; long err = -EFAULT; struct raw1394_iso_packets __user *dst = compat_alloc_user_space(sizeof(struct raw1394_iso_packets)); if (!copy_in_user(&dst->n_packets, &arg->n_packets, sizeof arg->n_packets) && !copy_from_user(&infos32, &arg->infos, sizeof infos32)) { infos = compat_ptr(infos32); if (!copy_to_user(&dst->infos, &infos, sizeof infos)) err = do_raw1394_ioctl(file, cmd, (unsigned long)dst); } return err; } static long raw1394_read_cycle_timer32(struct file_info *fi, void __user * uaddr) { struct raw1394_cycle_timer32 ct; int err; err = hpsb_read_cycle_timer(fi->host, &ct.cycle_timer, &ct.local_time); if (!err) if (copy_to_user(uaddr, &ct, sizeof(ct))) err = -EFAULT; return err; } static long raw1394_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { struct file_info *fi = file->private_data; void __user *argp = (void __user *)arg; long err; lock_kernel(); switch (cmd) { /* These requests have same format as long as 'int' has same size. */ case RAW1394_IOC_ISO_RECV_INIT: case RAW1394_IOC_ISO_RECV_START: case RAW1394_IOC_ISO_RECV_LISTEN_CHANNEL: case RAW1394_IOC_ISO_RECV_UNLISTEN_CHANNEL: case RAW1394_IOC_ISO_RECV_SET_CHANNEL_MASK: case RAW1394_IOC_ISO_RECV_RELEASE_PACKETS: case RAW1394_IOC_ISO_RECV_FLUSH: case RAW1394_IOC_ISO_XMIT_RECV_STOP: case RAW1394_IOC_ISO_XMIT_INIT: case RAW1394_IOC_ISO_XMIT_START: case RAW1394_IOC_ISO_XMIT_SYNC: case RAW1394_IOC_ISO_GET_STATUS: case RAW1394_IOC_ISO_SHUTDOWN: case RAW1394_IOC_ISO_QUEUE_ACTIVITY: err = do_raw1394_ioctl(file, cmd, arg); break; /* These request have different format. */ case RAW1394_IOC_ISO_RECV_PACKETS32: err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_RECV_PACKETS, argp); break; case RAW1394_IOC_ISO_XMIT_PACKETS32: err = raw1394_iso_xmit_recv_packets32(file, RAW1394_IOC_ISO_XMIT_PACKETS, argp); break; case RAW1394_IOC_GET_CYCLE_TIMER32: err = raw1394_read_cycle_timer32(fi, argp); break; default: err = -EINVAL; break; } unlock_kernel(); return err; } #endif static unsigned int raw1394_poll(struct file *file, poll_table * pt) { struct file_info *fi = file->private_data; unsigned int mask = POLLOUT | POLLWRNORM; unsigned long flags; poll_wait(file, &fi->wait_complete, pt); spin_lock_irqsave(&fi->reqlists_lock, flags); if (!list_empty(&fi->req_complete)) { mask |= POLLIN | POLLRDNORM; } spin_unlock_irqrestore(&fi->reqlists_lock, flags); return mask; } static int raw1394_open(struct inode *inode, struct file *file) { struct file_info *fi; fi = kzalloc(sizeof(*fi), GFP_KERNEL); if (!fi) return -ENOMEM; fi->notification = (u8) RAW1394_NOTIFY_ON; /* busreset notification */ INIT_LIST_HEAD(&fi->list); fi->state = opened; INIT_LIST_HEAD(&fi->req_pending); INIT_LIST_HEAD(&fi->req_complete); spin_lock_init(&fi->reqlists_lock); init_waitqueue_head(&fi->wait_complete); INIT_LIST_HEAD(&fi->addr_list); file->private_data = fi; return 0; } static int raw1394_release(struct inode *inode, struct file *file) { struct file_info *fi = file->private_data; struct list_head *lh; struct pending_request *req; int i, fail; int retval = 0; struct list_head *entry; struct arm_addr *addr = NULL; struct host_info *hi; struct file_info *fi_hlp = NULL; struct arm_addr *arm_addr = NULL; int another_host; int csr_mod = 0; unsigned long flags; if (fi->iso_state != RAW1394_ISO_INACTIVE) raw1394_iso_shutdown(fi); spin_lock_irqsave(&host_info_lock, flags); fail = 0; /* set address-entries invalid */ while (!list_empty(&fi->addr_list)) { another_host = 0; lh = fi->addr_list.next; addr = list_entry(lh, struct arm_addr, addr_list); /* another host with valid address-entry containing same addressrange? */ list_for_each_entry(hi, &host_info_list, list) { if (hi->host != fi->host) { list_for_each_entry(fi_hlp, &hi->file_info_list, list) { entry = fi_hlp->addr_list.next; while (entry != &(fi_hlp->addr_list)) { arm_addr = list_entry(entry, struct arm_addr, addr_list); if (arm_addr->start == addr->start) { DBGMSG ("raw1394_release: " "another host ownes " "same addressrange"); another_host = 1; break; } entry = entry->next; } if (another_host) { break; } } } } if (!another_host) { DBGMSG("raw1394_release: call hpsb_arm_unregister"); retval = hpsb_unregister_addrspace(&raw1394_highlevel, fi->host, addr->start); if (!retval) { ++fail; printk(KERN_ERR "raw1394_release arm_Unregister failed\n"); } } DBGMSG("raw1394_release: delete addr_entry from list"); list_del(&addr->addr_list); vfree(addr->addr_space_buffer); kfree(addr); } /* while */ spin_unlock_irqrestore(&host_info_lock, flags); if (fail > 0) { printk(KERN_ERR "raw1394: during addr_list-release " "error(s) occurred \n"); } for (;;) { /* This locked section guarantees that neither * complete nor pending requests exist once i!=0 */ spin_lock_irqsave(&fi->reqlists_lock, flags); while ((req = __next_complete_req(fi))) free_pending_request(req); i = list_empty(&fi->req_pending); spin_unlock_irqrestore(&fi->reqlists_lock, flags); if (i) break; /* * Sleep until more requests can be freed. * * NB: We call the macro wait_event() with a condition argument * with side effect. This is only possible because the side * effect does not occur until the condition became true, and * wait_event() won't evaluate the condition again after that. */ wait_event(fi->wait_complete, (req = next_complete_req(fi))); free_pending_request(req); } /* Remove any sub-trees left by user space programs */ for (i = 0; i < RAW1394_MAX_USER_CSR_DIRS; i++) { struct csr1212_dentry *dentry; if (!fi->csr1212_dirs[i]) continue; for (dentry = fi->csr1212_dirs[i]->value.directory.dentries_head; dentry; dentry = dentry->next) { csr1212_detach_keyval_from_directory(fi->host->csr.rom-> root_kv, dentry->kv); } csr1212_release_keyval(fi->csr1212_dirs[i]); fi->csr1212_dirs[i] = NULL; csr_mod = 1; } if ((csr_mod || fi->cfgrom_upd) && hpsb_update_config_rom_image(fi->host) < 0) HPSB_ERR ("Failed to generate Configuration ROM image for host %d", fi->host->id); if (fi->state == connected) { spin_lock_irqsave(&host_info_lock, flags); list_del(&fi->list); spin_unlock_irqrestore(&host_info_lock, flags); put_device(&fi->host->device); } spin_lock_irqsave(&host_info_lock, flags); if (fi->host) module_put(fi->host->driver->owner); spin_unlock_irqrestore(&host_info_lock, flags); kfree(fi); return 0; } /*** HOTPLUG STUFF **********************************************************/ /* * Export information about protocols/devices supported by this driver. */ #ifdef MODULE static struct ieee1394_device_id raw1394_id_table[] = { { .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION, .specifier_id = AVC_UNIT_SPEC_ID_ENTRY & 0xffffff, .version = AVC_SW_VERSION_ENTRY & 0xffffff}, { .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION, .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff, .version = CAMERA_SW_VERSION_ENTRY & 0xffffff}, { .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION, .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff, .version = (CAMERA_SW_VERSION_ENTRY + 1) & 0xffffff}, { .match_flags = IEEE1394_MATCH_SPECIFIER_ID | IEEE1394_MATCH_VERSION, .specifier_id = CAMERA_UNIT_SPEC_ID_ENTRY & 0xffffff, .version = (CAMERA_SW_VERSION_ENTRY + 2) & 0xffffff}, {} }; MODULE_DEVICE_TABLE(ieee1394, raw1394_id_table); #endif /* MODULE */ static struct hpsb_protocol_driver raw1394_driver = { .name = "raw1394", }; /******************************************************************************/ static struct hpsb_highlevel raw1394_highlevel = { .name = RAW1394_DEVICE_NAME, .add_host = add_host, .remove_host = remove_host, .host_reset = host_reset, .fcp_request = fcp_request, }; static struct cdev raw1394_cdev; static const struct file_operations raw1394_fops = { .owner = THIS_MODULE, .read = raw1394_read, .write = raw1394_write, .mmap = raw1394_mmap, .unlocked_ioctl = raw1394_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = raw1394_compat_ioctl, #endif .poll = raw1394_poll, .open = raw1394_open, .release = raw1394_release, }; static int __init init_raw1394(void) { int ret = 0; hpsb_register_highlevel(&raw1394_highlevel); if (IS_ERR (device_create_drvdata( hpsb_protocol_class, NULL, MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16), NULL, RAW1394_DEVICE_NAME))) { ret = -EFAULT; goto out_unreg; } cdev_init(&raw1394_cdev, &raw1394_fops); raw1394_cdev.owner = THIS_MODULE; ret = cdev_add(&raw1394_cdev, IEEE1394_RAW1394_DEV, 1); if (ret) { HPSB_ERR("raw1394 failed to register minor device block"); goto out_dev; } HPSB_INFO("raw1394: /dev/%s device initialized", RAW1394_DEVICE_NAME); ret = hpsb_register_protocol(&raw1394_driver); if (ret) { HPSB_ERR("raw1394: failed to register protocol"); cdev_del(&raw1394_cdev); goto out_dev; } goto out; out_dev: device_destroy(hpsb_protocol_class, MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16)); out_unreg: hpsb_unregister_highlevel(&raw1394_highlevel); out: return ret; } static void __exit cleanup_raw1394(void) { device_destroy(hpsb_protocol_class, MKDEV(IEEE1394_MAJOR, IEEE1394_MINOR_BLOCK_RAW1394 * 16)); cdev_del(&raw1394_cdev); hpsb_unregister_highlevel(&raw1394_highlevel); hpsb_unregister_protocol(&raw1394_driver); } module_init(init_raw1394); module_exit(cleanup_raw1394); MODULE_LICENSE("GPL");