drivers/gpib/common/gpib_os.c

Source file repositories/reference/linux-study-clean/drivers/gpib/common/gpib_os.c

File Facts

System
Linux kernel
Corpus path
drivers/gpib/common/gpib_os.c
Extension
.c
Size
59958 bytes
Lines
2325
Domain
Driver Families
Bucket
drivers/gpib
Inferred role
Driver Families: operation-table or driver-model contract
Status
pattern implementation candidate

Why This File Exists

Repeatable hardware-adapter layer. Deep compatibility for every driver is out of scope; this atlas records patterns, probe lifecycles, bus glue, IRQ/DMA usage, and links back to core abstractions.

Dependency Surface

Detected Declarations

Annotated Snippet

static const struct file_operations ib_fops = {
	.owner = THIS_MODULE,
	.llseek = NULL,
	.unlocked_ioctl = &ibioctl,
	.compat_ioctl = &ibioctl,
	.open = &ibopen,
	.release = &ibclose,
};

struct gpib_board board_array[GPIB_MAX_NUM_BOARDS];

LIST_HEAD(registered_drivers);

void init_gpib_descriptor(struct gpib_descriptor *desc)
{
	desc->pad = 0;
	desc->sad = -1;
	desc->is_board = 0;
	desc->autopoll_enabled = 0;
	atomic_set(&desc->io_in_progress, 0);
	atomic_set(&desc->descriptor_busy, 0);
}

int gpib_register_driver(struct gpib_interface *interface, struct module *provider_module)
{
	struct gpib_interface_list *entry;

	entry = kmalloc_obj(*entry);
	if (!entry)
		return -ENOMEM;

	entry->interface = interface;
	entry->module = provider_module;
	list_add(&entry->list, &registered_drivers);

	return 0;
}
EXPORT_SYMBOL(gpib_register_driver);

void gpib_unregister_driver(struct gpib_interface *interface)
{
	int i;
	struct list_head *list_ptr;

	for (i = 0; i < GPIB_MAX_NUM_BOARDS; i++) {
		struct gpib_board *board = &board_array[i];

		if (board->interface == interface) {
			if (board->use_count > 0)
				pr_warn("gpib: Warning: deregistered interface %s in use\n",
					interface->name);
			iboffline(board);
			board->interface = NULL;
		}
	}
	for (list_ptr = registered_drivers.next; list_ptr != &registered_drivers;) {
		struct gpib_interface_list *entry;

		entry = list_entry(list_ptr, struct gpib_interface_list, list);
		list_ptr = list_ptr->next;
		if (entry->interface == interface) {
			list_del(&entry->list);
			kfree(entry);
		}
	}
}
EXPORT_SYMBOL(gpib_unregister_driver);

static void init_gpib_board_config(struct gpib_board_config *config)
{
	memset(config, 0, sizeof(struct gpib_board_config));
	config->pci_bus = -1;
	config->pci_slot = -1;
}

void init_gpib_board(struct gpib_board *board)
{
	board->interface = NULL;
	board->provider_module = NULL;
	board->buffer = NULL;
	board->buffer_length = 0;
	board->status = 0;
	init_waitqueue_head(&board->wait);
	mutex_init(&board->user_mutex);
	mutex_init(&board->big_gpib_mutex);
	board->locking_pid = 0;
	spin_lock_init(&board->locking_pid_spinlock);
	spin_lock_init(&board->spinlock);
	timer_setup(&board->timer, NULL, 0);
	board->dev = NULL;

Annotation

Implementation Notes