/* * Char device for device raw access * * Copyright (C) 2005-2007  Kristian Hoegsberg <krh@bitplanet.net> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include <linux/module.h>#include <linux/kernel.h>#include <linux/wait.h>#include <linux/errno.h>#include <linux/device.h>#include <linux/vmalloc.h>#include <linux/poll.h>#include <linux/preempt.h>#include <linux/time.h>#include <linux/delay.h>#include <linux/mm.h>#include <linux/idr.h>#include <linux/compat.h>#include <linux/firewire-cdev.h>#include <asm/system.h>#include <asm/uaccess.h>#include "fw-transaction.h"#include "fw-topology.h"#include "fw-device.h" struct client;struct client_resource {	struct list_head link;	void (*release)(struct client *client, struct client_resource *r);	u32 handle;}; /* * dequeue_event() just kfree()'s the event, so the event has to be * the first field in the struct. */ struct event {	struct { void *data; size_t size; } v[2];	struct list_head link;}; struct bus_reset {	struct event event;	struct fw_cdev_event_bus_reset reset;}; struct response {	struct event event;	struct fw_transaction transaction;	struct client *client;	struct client_resource resource;	struct fw_cdev_event_response response;}; struct iso_interrupt {	struct event event;	struct fw_cdev_event_iso_interrupt interrupt;}; struct client {	u32 version;	struct fw_device *device;	spinlock_t lock;	u32 resource_handle;	struct list_head resource_list;	struct list_head event_list;	wait_queue_head_t wait;	u64 bus_reset_closure; 	struct fw_iso_context *iso_context;	u64 iso_closure;	struct fw_iso_buffer buffer;	unsigned long vm_start; 	struct list_head link;}; static inline void __user *u64_to_uptr(__u64 value){	return (void __user *)(unsigned long)value;} static inline __u64uptr_to_u64(void __user *ptr){	return (__u64)(unsigned long)ptr;} static int fw_device_op_open(struct inode *inode, struct file *file){	struct fw_device *device;	struct client *client;	unsigned long flags; 	device = fw_device_get_by_devt(inode->i_rdev);	if (device == NULL)		return -ENODEV; 	if (fw_device_is_shutdown(device)) {		fw_device_put(device);		return -ENODEV;	} 	client = kzalloc(sizeof(*client), GFP_KERNEL);	if (client == NULL) {		fw_device_put(device);		return -ENOMEM;	} 	client->device = device;	INIT_LIST_HEAD(&client->event_list);	INIT_LIST_HEAD(&client->resource_list);	spin_lock_init(&client->lock);	init_waitqueue_head(&client->wait); 	file->private_data = client; 	spin_lock_irqsave(&device->card->lock, flags);	list_add_tail(&client->link, &device->client_list);	spin_unlock_irqrestore(&device->card->lock, flags); 	return 0;} static void queue_event(struct client *client, struct event *event,			void *data0, size_t size0, void *data1, size_t size1){	unsigned long flags; 	event->v[0].data = data0;	event->v[0].size = size0;	event->v[1].data = data1;	event->v[1].size = size1; 	spin_lock_irqsave(&client->lock, flags);	list_add_tail(&event->link, &client->event_list);	spin_unlock_irqrestore(&client->lock, flags); 	wake_up_interruptible(&client->wait);} static intdequeue_event(struct client *client, char __user *buffer, size_t count){	unsigned long flags;	struct event *event;	size_t size, total;	int i, retval; 	retval = wait_event_interruptible(client->wait,					  !list_empty(&client->event_list) ||					  fw_device_is_shutdown(client->device));	if (retval < 0)		return retval; 	if (list_empty(&client->event_list) &&		       fw_device_is_shutdown(client->device))		return -ENODEV; 	spin_lock_irqsave(&client->lock, flags);	event = container_of(client->event_list.next, struct event, link);	list_del(&event->link);	spin_unlock_irqrestore(&client->lock, flags); 	total = 0;	for (i = 0; i < ARRAY_SIZE(event->v) && total < count; i++) {		size = min(event->v[i].size, count - total);		if (copy_to_user(buffer + total, event->v[i].data, size)) {			retval = -EFAULT;			goto out;		}		total += size;	}	retval = total;  out:	kfree(event); 	return retval;} static ssize_tfw_device_op_read(struct file *file,		  char __user *buffer, size_t count, loff_t *offset){	struct client *client = file->private_data; 	return dequeue_event(client, buffer, count);} /* caller must hold card->lock so that node pointers can be dereferenced here */static voidfill_bus_reset_event(struct fw_cdev_event_bus_reset *event,		     struct client *client){	struct fw_card *card = client->device->card; 	event->closure	     = client->bus_reset_closure;	event->type          = FW_CDEV_EVENT_BUS_RESET;	event->generation    = client->device->generation;	event->node_id       = client->device->node_id;	event->local_node_id = card->local_node->node_id;	event->bm_node_id    = 0; /* FIXME: We don't track the BM. */	event->irm_node_id   = card->irm_node->node_id;	event->root_node_id  = card->root_node->node_id;} static voidfor_each_client(struct fw_device *device,		void (*callback)(struct client *client)){	struct fw_card *card = device->card;	struct client *c;	unsigned long flags; 	spin_lock_irqsave(&card->lock, flags); 	list_for_each_entry(c, &device->client_list, link)		callback(c); 	spin_unlock_irqrestore(&card->lock, flags);} static voidqueue_bus_reset_event(struct client *client){	struct bus_reset *bus_reset; 	bus_reset = kzalloc(sizeof(*bus_reset), GFP_ATOMIC);	if (bus_reset == NULL) {		fw_notify("Out of memory when allocating bus reset event\n");		return;	} 	fill_bus_reset_event(&bus_reset->reset, client); 	queue_event(client, &bus_reset->event,		    &bus_reset->reset, sizeof(bus_reset->reset), NULL, 0);} void fw_device_cdev_update(struct fw_device *device){	for_each_client(device, queue_bus_reset_event);} static void wake_up_client(struct client *client){	wake_up_interruptible(&client->wait);} void fw_device_cdev_remove(struct fw_device *device){	for_each_client(device, wake_up_client);} static int ioctl_get_info(struct client *client, void *buffer){	struct fw_cdev_get_info *get_info = buffer;	struct fw_cdev_event_bus_reset bus_reset;	struct fw_card *card = client->device->card;	unsigned long ret = 0; 	client->version = get_info->version;	get_info->version = FW_CDEV_VERSION; 	down_read(&fw_device_rwsem); 	if (get_info->rom != 0) {		void __user *uptr = u64_to_uptr(get_info->rom);		size_t want = get_info->rom_length;		size_t have = client->device->config_rom_length * 4; 		ret = copy_to_user(uptr, client->device->config_rom,				   min(want, have));	}	get_info->rom_length = client->device->config_rom_length * 4; 	up_read(&fw_device_rwsem); 	if (ret != 0)		return -EFAULT; 	client->bus_reset_closure = get_info->bus_reset_closure;	if (get_info->bus_reset != 0) {		void __user *uptr = u64_to_uptr(get_info->bus_reset);		unsigned long flags; 		spin_lock_irqsave(&card->lock, flags);		fill_bus_reset_event(&bus_reset, client);		spin_unlock_irqrestore(&card->lock, flags); 		if (copy_to_user(uptr, &bus_reset, sizeof(bus_reset)))			return -EFAULT;	} 	get_info->card = card->index; 	return 0;} static voidadd_client_resource(struct client *client, struct client_resource *resource){	unsigned long flags; 	spin_lock_irqsave(&client->lock, flags);	list_add_tail(&resource->link, &client->resource_list);	resource->handle = client->resource_handle++;	spin_unlock_irqrestore(&client->lock, flags);} static intrelease_client_resource(struct client *client, u32 handle,			struct client_resource **resource){	struct client_resource *r;	unsigned long flags; 	spin_lock_irqsave(&client->lock, flags);	list_for_each_entry(r, &client->resource_list, link) {		if (r->handle == handle) {			list_del(&r->link);			break;		}	}	spin_unlock_irqrestore(&client->lock, flags); 	if (&r->link == &client->resource_list)		return -EINVAL; 	if (resource)		*resource = r;	else		r->release(client, r); 	return 0;} static voidrelease_transaction(struct client *client, struct client_resource *resource){	struct response *response =		container_of(resource, struct response, resource); 	fw_cancel_transaction(client->device->card, &response->transaction);} static voidcomplete_transaction(struct fw_card *card, int rcode,		     void *payload, size_t length, void *data){	struct response *response = data;	struct client *client = response->client;	unsigned long flags; 	if (length < response->response.length)		response->response.length = length;	if (rcode == RCODE_COMPLETE)		memcpy(response->response.data, payload,		       response->response.length); 	spin_lock_irqsave(&client->lock, flags);	list_del(&response->resource.link);	spin_unlock_irqrestore(&client->lock, flags); 	response->response.type   = FW_CDEV_EVENT_RESPONSE;	response->response.rcode  = rcode;	queue_event(client, &response->event,		    &response->response, sizeof(response->response),		    response->response.data, response->response.length);} static int ioctl_send_request(struct client *client, void *buffer){	struct fw_device *device = client->device;	struct fw_cdev_send_request *request = buffer;	struct response *response; 	/* What is the biggest size we'll accept, really? */	if (request->length > 4096)		return -EINVAL; 	response = kmalloc(sizeof(*response) + request->length, GFP_KERNEL);	if (response == NULL)		return -ENOMEM; 	response->client = client;	response->response.length = request->length;	response->response.closure = request->closure; 	if (request->data &&	    copy_from_user(response->response.data,			   u64_to_uptr(request->data), request->length)) {		kfree(response);		return -EFAULT;	} 	response->resource.release = release_transaction;	add_client_resource(client, &response->resource); 	fw_send_request(device->card, &response->transaction,			request->tcode & 0x1f,			device->node->node_id,			request->generation,			device->max_speed,			request->offset,			response->response.data, request->length,			complete_transaction, response); 	if (request->data)		return sizeof(request) + request->length;	else		return sizeof(request);} struct address_handler {	struct fw_address_handler handler;	__u64 closure;	struct client *client;	struct client_resource resource;}; struct request {	struct fw_request *request;	void *data;	size_t length;	struct client_resource resource;}; struct request_event {	struct event event;	struct fw_cdev_event_request request;}; static voidrelease_request(struct client *client, struct client_resource *resource){	struct request *request =		container_of(resource, struct request, resource); 	fw_send_response(client->device->card, request->request,			 RCODE_CONFLICT_ERROR);	kfree(request);} static voidhandle_request(struct fw_card *card, struct fw_request *r,	       int tcode, int destination, int source,	       int generation, int speed,	       unsigned long long offset,	       void *payload, size_t length, void *callback_data){	struct address_handler *handler = callback_data;	struct request *request;	struct request_event *e;	struct client *client = handler->client; 	request = kmalloc(sizeof(*request), GFP_ATOMIC);	e = kmalloc(sizeof(*e), GFP_ATOMIC);	if (request == NULL || e == NULL) {		kfree(request);		kfree(e);		fw_send_response(card, r, RCODE_CONFLICT_ERROR);		return;	} 	request->request = r;	request->data    = payload;	request->length  = length; 	request->resource.release = release_request;	add_client_resource(client, &request->resource); 	e->request.type    = FW_CDEV_EVENT_REQUEST;	e->request.tcode   = tcode;	e->request.offset  = offset;	e->request.length  = length;	e->request.handle  = request->resource.handle;	e->request.closure = handler->closure; 	queue_event(client, &e->event,		    &e->request, sizeof(e->request), payload, length);}

Lines 1–500 of 1038. Load more