linux/drivers/ata/pata_parport/pata_parport.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright 2023 Ondrej Zary
 * based on paride.c by Grant R. Guenther <[email protected]>
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/parport.h>
#include "pata_parport.h"

#define DRV_NAME …

static DEFINE_IDR(parport_list);
static DEFINE_IDR(protocols);
static DEFINE_IDA(pata_parport_bus_dev_ids);
static DEFINE_MUTEX(pi_mutex);

static bool probe = …;
module_param(probe, bool, 0644);
MODULE_PARM_DESC(…) …;

/*
 * libata drivers cannot sleep so this driver claims parport before activating
 * the ata host and keeps it claimed (and protocol connected) until the ata
 * host is removed. Unfortunately, this means that you cannot use any chained
 * devices (neither other pata_parport devices nor a printer).
 */
static void pi_connect(struct pi_adapter *pi)
{ … }

static void pi_disconnect(struct pi_adapter *pi)
{ … }

static void pata_parport_dev_select(struct ata_port *ap, unsigned int device)
{ … }

static void pata_parport_set_devctl(struct ata_port *ap, u8 ctl)
{ … }

static bool pata_parport_devchk(struct ata_port *ap, unsigned int device)
{ … }

static int pata_parport_wait_after_reset(struct ata_link *link,
					 unsigned int devmask,
					 unsigned long deadline)
{ … }

static int pata_parport_bus_softreset(struct ata_port *ap, unsigned int devmask,
				      unsigned long deadline)
{ … }

static int pata_parport_softreset(struct ata_link *link, unsigned int *classes,
				  unsigned long deadline)
{ … }

static u8 pata_parport_check_status(struct ata_port *ap)
{ … }

static u8 pata_parport_check_altstatus(struct ata_port *ap)
{ … }

static void pata_parport_tf_load(struct ata_port *ap,
				 const struct ata_taskfile *tf)
{ … }

static void pata_parport_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
{ … }

static void pata_parport_exec_command(struct ata_port *ap,
				      const struct ata_taskfile *tf)
{ … }

static unsigned int pata_parport_data_xfer(struct ata_queued_cmd *qc,
				unsigned char *buf, unsigned int buflen, int rw)
{ … }

static void pata_parport_drain_fifo(struct ata_queued_cmd *qc)
{ … }

static struct ata_port_operations pata_parport_port_ops = …;

static const struct ata_port_info pata_parport_port_info = …;

static void pi_release(struct pi_adapter *pi)
{ … }

static int default_test_proto(struct pi_adapter *pi)
{ … }

static int pi_test_proto(struct pi_adapter *pi)
{ … }

static bool pi_probe_mode(struct pi_adapter *pi, int max)
{ … }

static bool pi_probe_unit(struct pi_adapter *pi, int unit)
{ … }

static void pata_parport_dev_release(struct device *dev)
{ … }

static void pata_parport_bus_release(struct device *dev)
{ … }

static const struct bus_type pata_parport_bus_type = …;

static struct device pata_parport_bus = …;

static const struct scsi_host_template pata_parport_sht = …;

struct pi_device_match { … };

static int pi_find_dev(struct device *dev, void *data)
{ … }

static struct pi_adapter *pi_init_one(struct parport *parport,
			struct pi_protocol *pr, int mode, int unit, int delay)
{ … }

int pata_parport_register_driver(struct pi_protocol *pr)
{ … }
EXPORT_SYMBOL_GPL(…);

void pata_parport_unregister_driver(struct pi_protocol *pr)
{ … }
EXPORT_SYMBOL_GPL(…);

static ssize_t new_device_store(const struct bus_type *bus, const char *buf, size_t count)
{ … }
static BUS_ATTR_WO(new_device);

static void pi_remove_one(struct device *dev)
{ … }

static ssize_t delete_device_store(const struct bus_type *bus, const char *buf, size_t count)
{ … }
static BUS_ATTR_WO(delete_device);

static void pata_parport_attach(struct parport *port)
{ … }

static int pi_remove_port(struct device *dev, void *p)
{ … }

static void pata_parport_detach(struct parport *port)
{ … }

static struct parport_driver pata_parport_driver = …;

static __init int pata_parport_init(void)
{ … }

static __exit void pata_parport_exit(void)
{ … }

MODULE_AUTHOR(…) …;
MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;
MODULE_ALIAS(…) …;

module_init(…) …;
module_exit(pata_parport_exit);