[PATCH] drivers/cdrom/cm206.c: cleanups

/* First, we define some polling functions. These are actually

   only being used in the initialization. */

void send_command_polled(int command)

static void send_command_polled(int command)

{

	int loop = POLLOOP;

	while (!(inw(r_line_status) & ls_transmitter_buffer_empty)

	outw(command, r_uart_transmit);

}

uch receive_echo_polled(void)

static uch receive_echo_polled(void)

{

	int loop = POLLOOP;

	while (!(inw(r_line_status) & ls_receive_buffer_full) && loop > 0) {

	return ((uch) inw(r_uart_receive));

}

uch send_receive_polled(int command)

static uch send_receive_polled(int command)

{

	send_command_polled(command);

	return receive_echo_polled();

}

inline void clear_ur(void)

static inline void clear_ur(void)

{

	if (cd->ur_r != cd->ur_w) {

		debug(("Deleting bytes from fifo:"));

}

/* we have put the address of the wait queue in who */

void cm206_timeout(unsigned long who)

static void cm206_timeout(unsigned long who)

{

	cd->timed_out = 1;

	debug(("Timing out\n"));

/* This function returns 1 if a timeout occurred, 0 if an interrupt

   happened */

int sleep_or_timeout(wait_queue_head_t * wait, int timeout)

static int sleep_or_timeout(wait_queue_head_t * wait, int timeout)

{

	cd->timed_out = 0;

	init_timer(&cd->timer);

		return 0;

}

void cm206_delay(int nr_jiffies)

{

	DECLARE_WAIT_QUEUE_HEAD(wait);

	sleep_or_timeout(&wait, nr_jiffies);

}

void send_command(int command)

static void send_command(int command)

{

	debug(("Sending 0x%x\n", command));

	if (!(inw(r_line_status) & ls_transmitter_buffer_empty)) {

		outw(command, r_uart_transmit);

}

uch receive_byte(int timeout)

static uch receive_byte(int timeout)

{

	uch ret;

	cli();

	return ret;

}

inline uch receive_echo(void)

static inline uch receive_echo(void)

{

	return receive_byte(UART_TIMEOUT);

}

inline uch send_receive(int command)

static inline uch send_receive(int command)

{

	send_command(command);

	return receive_echo();

}

inline uch wait_dsb(void)

static inline uch wait_dsb(void)

{

	return receive_byte(DSB_TIMEOUT);

}

int type_0_command(int command, int expect_dsb)

static int type_0_command(int command, int expect_dsb)

{

	int e;

	clear_ur();

	return 0;

}

int type_1_command(int command, int bytes, uch * status)

static int type_1_command(int command, int bytes, uch * status)

{				/* returns info */

	int i;

	if (type_0_command(command, 0))

/* This function resets the adapter card. We'd better not do this too

 * often, because it tends to generate `lost interrupts.' */

void reset_cm260(void)

static void reset_cm260(void)

{

	outw(dc_normal | dc_initialize | READ_AHEAD, r_data_control);

	udelay(10);		/* 3.3 mu sec minimum */

}

/* fsm: frame-sec-min from linear address; one of many */

void fsm(int lba, uch * fsm)

static void fsm(int lba, uch * fsm)

{

	fsm[0] = lba % 75;

	lba /= 75;

	fsm[2] = lba / 60;

}

inline int fsm2lba(uch * fsm)

static inline int fsm2lba(uch * fsm)

{

	return fsm[0] + 75 * (fsm[1] - 2 + 60 * fsm[2]);

}

inline int f_s_m2lba(uch f, uch s, uch m)

static inline int f_s_m2lba(uch f, uch s, uch m)

{

	return f + 75 * (s - 2 + 60 * m);

}

int start_read(int start)

static int start_read(int start)

{

	uch read_sector[4] = { c_read_data, };

	int i, e;

	return 0;

}

int stop_read(void)

static int stop_read(void)

{

	int e;

	type_0_command(c_stop, 0);

   routine takes care of this. Set a flag `background' in the cd

   struct to indicate the process. */

int read_background(int start, int reading)

static int read_background(int start, int reading)

{

	if (cd->background)

		return -1;	/* can't do twice */

#define MAX_TRIES 100

int read_sector(int start)

static int read_sector(int start)

{

	int tries = 0;

	if (cd->background) {

/* This command clears the dsb_possible_media_change flag, so we must 

 * retain it.

 */

void get_drive_status(void)

static void get_drive_status(void)

{

	uch status[2];

	type_1_command(c_drive_status, 2, status);	/* this might be done faster */

			  dsb_drive_not_ready | dsb_tray_not_closed));

}

void get_disc_status(void)

static void get_disc_status(void)

{

	if (type_1_command(c_disc_status, 7, cd->disc_status)) {

		debug(("get_disc_status: error\n"));

/* Empty buffer empties $sectors$ sectors of the adapter card buffer,

 * and then reads a sector in kernel memory.  */

void empty_buffer(int sectors)

static void empty_buffer(int sectors)

{

	while (sectors >= 0) {

		transport_data(r_fifo_output_buffer,

/* try_adapter. This function determines if the requested sector is

   in adapter memory, or will appear there soon. Returns 0 upon

   success */

int try_adapter(int sector)

static int try_adapter(int sector)

{

	if (cd->adapter_first <= sector && sector < cd->adapter_last) {

		/* sector is in adapter memory */

*/

/* seek seeks to address lba. It does wait to arrive there. */

void seek(int lba)

static void seek(int lba)

{

	int i;

	uch seek_command[4] = { c_seek, };

	return (bcd >> 4) * 10 + (bcd & 0xf);

}

inline uch normalize_track(uch track)

static inline uch normalize_track(uch track)

{

	if (track < 1)

		return 1;

 * tracks seen in the process. Input $track$ must be between 1 and

 * #-of-tracks+1.  Note that the start of the disc must be in toc[1].fsm. 

 */

int get_toc_lba(uch track)

static int get_toc_lba(uch track)

{

	int max = 74 * 60 * 75 - 150, min = fsm2lba(cd->toc[1].fsm);

	int i, lba, l, old_lba = 0;

	return lba;

}

void update_toc_entry(uch track)

static void update_toc_entry(uch track)

{

	track = normalize_track(track);

	if (!cd->toc[track].track)

}

/* return 0 upon success */

int read_toc_header(struct cdrom_tochdr *hp)

static int read_toc_header(struct cdrom_tochdr *hp)

{

	if (!FIRST_TRACK)

		get_disc_status();

	return -1;

}

void play_from_to_msf(struct cdrom_msf *msfp)

static void play_from_to_msf(struct cdrom_msf *msfp)

{

	uch play_command[] = { c_play,

		msfp->cdmsf_frame0, msfp->cdmsf_sec0, msfp->cdmsf_min0,

	cd->dsb = wait_dsb();

}

void play_from_to_track(int from, int to)

static void play_from_to_track(int from, int to)

{

	uch play_command[8] = { c_play, };

	int i;

	cd->dsb = wait_dsb();

}

int get_current_q(struct cdrom_subchnl *qp)

static int get_current_q(struct cdrom_subchnl *qp)

{

	int i;

	uch *q = cd->q;

	return 0;

}

void invalidate_toc(void)

static void invalidate_toc(void)

{

	memset(cd->toc, 0, sizeof(cd->toc));

	memset(cd->disc_status, 0, sizeof(cd->disc_status));

}

/* cdrom.c guarantees that cdte_format == CDROM_MSF */

void get_toc_entry(struct cdrom_tocentry *ep)

static void get_toc_entry(struct cdrom_tocentry *ep)

{

	uch track = normalize_track(ep->cdte_track);

	update_toc_entry(track);

 * upon success. Memory checking has been done by cdrom_ioctl(), the

 * calling function, as well as LBA/MSF sanitization.

*/

int cm206_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,

static int cm206_audio_ioctl(struct cdrom_device_info *cdi, unsigned int cmd,

			     void *arg)

{

	switch (cmd) {

	}

}

int cm206_media_changed(struct cdrom_device_info *cdi, int disc_nr)

static int cm206_media_changed(struct cdrom_device_info *cdi, int disc_nr)

{

	if (cd != NULL) {

		int r;

/* The new generic cdrom support. Routines should be concise, most of

   the logic should be in cdrom.c */

/* returns number of times device is in use */

int cm206_open_files(struct cdrom_device_info *cdi)

{

	if (cd)

		return cd->openfiles;

	return -1;

}

/* controls tray movement */

int cm206_tray_move(struct cdrom_device_info *cdi, int position)

static int cm206_tray_move(struct cdrom_device_info *cdi, int position)

{

	if (position) {		/* 1: eject */

		type_0_command(c_open_tray, 1);

}

/* gives current state of the drive */

int cm206_drive_status(struct cdrom_device_info *cdi, int slot_nr)

static int cm206_drive_status(struct cdrom_device_info *cdi, int slot_nr)

{

	get_drive_status();

	if (cd->dsb & dsb_tray_not_closed)

}

/* locks or unlocks door lock==1: lock; return 0 upon success */

int cm206_lock_door(struct cdrom_device_info *cdi, int lock)

static int cm206_lock_door(struct cdrom_device_info *cdi, int lock)

{

	uch command = (lock) ? c_lock_tray : c_unlock_tray;

	type_0_command(command, 1);	/* wait and get dsb */

/* Although a session start should be in LBA format, we return it in 

   MSF format because it is slightly easier, and the new generic ioctl

   will take care of the necessary conversion. */

int cm206_get_last_session(struct cdrom_device_info *cdi,

static int cm206_get_last_session(struct cdrom_device_info *cdi,

				  struct cdrom_multisession *mssp)

{

	if (!FIRST_TRACK)

	return 0;

}

int cm206_get_upc(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)

static int cm206_get_upc(struct cdrom_device_info *cdi, struct cdrom_mcn *mcn)

{

	uch upc[10];

	char *ret = mcn->medium_catalog_number;

	return 0;

}

int cm206_reset(struct cdrom_device_info *cdi)

static int cm206_reset(struct cdrom_device_info *cdi)

{

	stop_read();

	reset_cm260();

	return 0;

}

int cm206_select_speed(struct cdrom_device_info *cdi, int speed)

static int cm206_select_speed(struct cdrom_device_info *cdi, int speed)

{

	int r;

	switch (speed) {

   request_region, 15 bits of one port and 6 of another make things

   likely enough to accept the region on the first hit...

 */

int __init probe_base_port(int base)

static int __init probe_base_port(int base)

{

	int b = 0x300, e = 0x370;	/* this is the range of start addresses */

	volatile int fool, i;

#if !defined(MODULE) || defined(AUTO_PROBE_MODULE)

/* Probe for irq# nr. If nr==0, probe for all possible irq's. */

int __init probe_irq(int nr)

static int __init probe_irq(int nr)

{

	int irqs, irq;

	outw(dc_normal | READ_AHEAD, r_data_control);	/* disable irq-generation */

	}

}

int __cm206_init(void)

static int __cm206_init(void)

{

	parse_options();

#if !defined(AUTO_PROBE_MODULE)

	return cm206_init();

}

void __exit cm206_exit(void)

static void __exit cm206_exit(void)

{

	del_gendisk(cm206_gendisk);

	put_disk(cm206_gendisk);