xref: /kernel/linux/linux-5.10/drivers/tty/synclink.c

599 void usc_DisableMasterIrqBit( struct mgsl_struct *info );
600 void usc_EnableMasterIrqBit( struct mgsl_struct *info );
601 void usc_EnableInterrupts( struct mgsl_struct *info, u16 IrqMask );
602 void usc_DisableInterrupts( struct mgsl_struct *info, u16 IrqMask );
603 void usc_ClearIrqPendingBits( struct mgsl_struct *info, u16 IrqMask );
663 static u16  usc_InDmaReg( struct mgsl_struct *info, u16 Port );
664 static void usc_OutDmaReg( struct mgsl_struct *info, u16 Port, u16 Value );
665 static void usc_DmaCmd( struct mgsl_struct *info, u16 Cmd );
667 static u16  usc_InReg( struct mgsl_struct *info, u16 Port );
668 static void usc_OutReg( struct mgsl_struct *info, u16 Port, u16 Value );
669 static void usc_RTCmd( struct mgsl_struct *info, u16 Cmd );
670 void usc_RCmd( struct mgsl_struct *info, u16 Cmd );
671 void usc_TCmd( struct mgsl_struct *info, u16 Cmd );
678 static void usc_process_rxoverrun_sync( struct mgsl_struct *info );
679 static void usc_start_receiver( struct mgsl_struct *info );
680 static void usc_stop_receiver( struct mgsl_struct *info );
682 static void usc_start_transmitter( struct mgsl_struct *info );
683 static void usc_stop_transmitter( struct mgsl_struct *info );
684 static void usc_set_txidle( struct mgsl_struct *info );
685 static void usc_load_txfifo( struct mgsl_struct *info );
687 static void usc_enable_aux_clock( struct mgsl_struct *info, u32 DataRate );
688 static void usc_enable_loopback( struct mgsl_struct *info, int enable );
690 static void usc_get_serial_signals( struct mgsl_struct *info );
691 static void usc_set_serial_signals( struct mgsl_struct *info );
693 static void usc_reset( struct mgsl_struct *info );
695 static void usc_set_sync_mode( struct mgsl_struct *info );
696 static void usc_set_sdlc_mode( struct mgsl_struct *info );
697 static void usc_set_async_mode( struct mgsl_struct *info );
698 static void usc_enable_async_clock( struct mgsl_struct *info, u32 DataRate );
700 static void usc_loopback_frame( struct mgsl_struct *info );
705 static void usc_loopmode_cancel_transmit( struct mgsl_struct * info );
706 static void usc_loopmode_insert_request( struct mgsl_struct * info );
707 static int usc_loopmode_active( struct mgsl_struct * info);
708 static void usc_loopmode_send_done( struct mgsl_struct * info );
710 static int mgsl_ioctl_common(struct mgsl_struct *info, unsigned int cmd, unsigned long arg);
714 static void hdlcdev_tx_done(struct mgsl_struct *info);
715 static void hdlcdev_rx(struct mgsl_struct *info, char *buf, int size);
716 static int  hdlcdev_init(struct mgsl_struct *info);
717 static void hdlcdev_exit(struct mgsl_struct *info);
736 static void mgsl_trace_block(struct mgsl_struct *info,const char* data, int count, int xmit);
741 static bool mgsl_register_test( struct mgsl_struct *info );
742 static bool mgsl_irq_test( struct mgsl_struct *info );
743 static bool mgsl_dma_test( struct mgsl_struct *info );
744 static bool mgsl_memory_test( struct mgsl_struct *info );
745 static int mgsl_adapter_test( struct mgsl_struct *info );
750 static int mgsl_claim_resources(struct mgsl_struct *info);
751 static void mgsl_release_resources(struct mgsl_struct *info);
752 static void mgsl_add_device(struct mgsl_struct *info);
758 static void mgsl_free_rx_frame_buffers( struct mgsl_struct *info, unsigned int StartIndex, unsigned int EndIndex );
759 static bool mgsl_get_rx_frame( struct mgsl_struct *info );
760 static bool mgsl_get_raw_rx_frame( struct mgsl_struct *info );
761 static void mgsl_reset_rx_dma_buffers( struct mgsl_struct *info );
762 static void mgsl_reset_tx_dma_buffers( struct mgsl_struct *info );
763 static int num_free_tx_dma_buffers(struct mgsl_struct *info);
764 static void mgsl_load_tx_dma_buffer( struct mgsl_struct *info, const char *Buffer, unsigned int BufferSize);
770 static int  mgsl_allocate_dma_buffers(struct mgsl_struct *info);
771 static void mgsl_free_dma_buffers(struct mgsl_struct *info);
772 static int  mgsl_alloc_frame_memory(struct mgsl_struct *info, DMABUFFERENTRY *BufferList,int Buffercount);
773 static void mgsl_free_frame_memory(struct mgsl_struct *info, DMABUFFERENTRY *BufferList,int Buffercount);
774 static int  mgsl_alloc_buffer_list_memory(struct mgsl_struct *info);
775 static void mgsl_free_buffer_list_memory(struct mgsl_struct *info);
776 static int mgsl_alloc_intermediate_rxbuffer_memory(struct mgsl_struct *info);
777 static void mgsl_free_intermediate_rxbuffer_memory(struct mgsl_struct *info);
778 static int mgsl_alloc_intermediate_txbuffer_memory(struct mgsl_struct *info);
779 static void mgsl_free_intermediate_txbuffer_memory(struct mgsl_struct *info);
780 static bool load_next_tx_holding_buffer(struct mgsl_struct *info);
781 static int save_tx_buffer_request(struct mgsl_struct *info,const char *Buffer, unsigned int BufferSize);
787 static void mgsl_bh_receive(struct mgsl_struct *info);
788 static void mgsl_bh_transmit(struct mgsl_struct *info);
789 static void mgsl_bh_status(struct mgsl_struct *info);
794 static void mgsl_isr_null( struct mgsl_struct *info );
795 static void mgsl_isr_transmit_data( struct mgsl_struct *info );
796 static void mgsl_isr_receive_data( struct mgsl_struct *info );
797 static void mgsl_isr_receive_status( struct mgsl_struct *info );
798 static void mgsl_isr_transmit_status( struct mgsl_struct *info );
799 static void mgsl_isr_io_pin( struct mgsl_struct *info );
800 static void mgsl_isr_misc( struct mgsl_struct *info );
801 static void mgsl_isr_receive_dma( struct mgsl_struct *info );
802 static void mgsl_isr_transmit_dma( struct mgsl_struct *info );
823 static int mgsl_get_stats(struct mgsl_struct * info, struct mgsl_icount
825 static int mgsl_get_params(struct mgsl_struct * info, MGSL_PARAMS  __user *user_params);
826 static int mgsl_set_params(struct mgsl_struct * info, MGSL_PARAMS  __user *new_params);
827 static int mgsl_get_txidle(struct mgsl_struct * info, int __user *idle_mode);
828 static int mgsl_set_txidle(struct mgsl_struct * info, int idle_mode);
829 static int mgsl_txenable(struct mgsl_struct * info, int enable);
830 static int mgsl_txabort(struct mgsl_struct * info);
831 static int mgsl_rxenable(struct mgsl_struct * info, int enable);
832 static int mgsl_wait_event(struct mgsl_struct * info, int __user *mask);
833 static int mgsl_loopmode_send_done( struct mgsl_struct * info );
907 static void mgsl_change_params(struct mgsl_struct *info);
921 static inline int mgsl_paranoia_check(struct mgsl_struct *info,
930 	if (!info) {
934 	if (info->magic != MGSL_MAGIC) {
939 	if (!info)
970  * Arguments:		tty	pointer to tty info structure
975 	struct mgsl_struct *info = tty->driver_data;
978 	if (mgsl_paranoia_check(info, tty->name, "mgsl_stop"))
982 		printk("mgsl_stop(%s)\n",info->device_name);	
984 	spin_lock_irqsave(&info->irq_spinlock,flags);
985 	if (info->tx_enabled)
986 	 	usc_stop_transmitter(info);
987 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
993  * Arguments:		tty	pointer to tty info structure
998 	struct mgsl_struct *info = tty->driver_data;
1001 	if (mgsl_paranoia_check(info, tty->name, "mgsl_start"))
1005 		printk("mgsl_start(%s)\n",info->device_name);	
1007 	spin_lock_irqsave(&info->irq_spinlock,flags);
1008 	if (!info->tx_enabled)
1009 	 	usc_start_transmitter(info);
1010 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
1021 static int mgsl_bh_action(struct mgsl_struct *info)
1026 	spin_lock_irqsave(&info->irq_spinlock,flags);
1028 	if (info->pending_bh & BH_RECEIVE) {
1029 		info->pending_bh &= ~BH_RECEIVE;
1031 	} else if (info->pending_bh & BH_TRANSMIT) {
1032 		info->pending_bh &= ~BH_TRANSMIT;
1034 	} else if (info->pending_bh & BH_STATUS) {
1035 		info->pending_bh &= ~BH_STATUS;
1041 		info->bh_running = false;
1042 		info->bh_requested = false;
1045 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
1055 	struct mgsl_struct *info =
1061 			__FILE__,__LINE__,info->device_name);
1063 	info->bh_running = true;
1065 	while((action = mgsl_bh_action(info)) != 0) {
1075 			mgsl_bh_receive(info);
1078 			mgsl_bh_transmit(info);
1081 			mgsl_bh_status(info);
1092 			__FILE__,__LINE__,info->device_name);
1095 static void mgsl_bh_receive(struct mgsl_struct *info)
1097 	bool (*get_rx_frame)(struct mgsl_struct *info) =
1098 		(info->params.mode == MGSL_MODE_HDLC ? mgsl_get_rx_frame : mgsl_get_raw_rx_frame);
1102 			__FILE__,__LINE__,info->device_name);
1106 		if (info->rx_rcc_underrun) {
1108 			spin_lock_irqsave(&info->irq_spinlock,flags);
1109 			usc_start_receiver(info);
1110 			spin_unlock_irqrestore(&info->irq_spinlock,flags);
1113 	} while(get_rx_frame(info));
1116 static void mgsl_bh_transmit(struct mgsl_struct *info)
1118 	struct tty_struct *tty = info->port.tty;
1123 			__FILE__,__LINE__,info->device_name);
1131 	spin_lock_irqsave(&info->irq_spinlock,flags);
1132  	if ( !info->tx_active && info->loopmode_send_done_requested )
1133  		usc_loopmode_send_done( info );
1134 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
1137 static void mgsl_bh_status(struct mgsl_struct *info)
1141 			__FILE__,__LINE__,info->device_name);
1143 	info->ri_chkcount = 0;
1144 	info->dsr_chkcount = 0;
1145 	info->dcd_chkcount = 0;
1146 	info->cts_chkcount = 0;
1155  * Arguments:		info	pointer to device instance data
1158 static void mgsl_isr_receive_status( struct mgsl_struct *info )
1160 	u16 status = usc_InReg( info, RCSR );
1167 		info->loopmode_insert_requested &&
1168  		usc_loopmode_active(info) )
1170 		++info->icount.rxabort;
1171 	 	info->loopmode_insert_requested = false;
1174 		info->cmr_value &= ~BIT13;
1175  		usc_OutReg(info, CMR, info->cmr_value);
1178 	 	usc_OutReg(info, RICR,
1179  			(usc_InReg(info, RICR) & ~RXSTATUS_ABORT_RECEIVED));
1184 			info->icount.exithunt++;
1186 			info->icount.rxidle++;
1187 		wake_up_interruptible(&info->event_wait_q);
1191 		info->icount.rxover++;
1192 		usc_process_rxoverrun_sync( info );
1195 	usc_ClearIrqPendingBits( info, RECEIVE_STATUS );
1196 	usc_UnlatchRxstatusBits( info, status );
1207  * Arguments:		info	       pointer to device instance data
1210 static void mgsl_isr_transmit_status( struct mgsl_struct *info )
1212 	u16 status = usc_InReg( info, TCSR );
1218 	usc_ClearIrqPendingBits( info, TRANSMIT_STATUS );
1219 	usc_UnlatchTxstatusBits( info, status );
1228  		usc_DmaCmd( info, DmaCmd_ResetTxChannel );
1229  		usc_RTCmd( info, RTCmd_PurgeTxFifo );
1233 		info->icount.txok++;
1235 		info->icount.txunder++;
1237 		info->icount.txabort++;
1239 		info->icount.txunder++;
1241 	info->tx_active = false;
1242 	info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1243 	del_timer(&info->tx_timer);	
1245 	if ( info->drop_rts_on_tx_done ) {
1246 		usc_get_serial_signals( info );
1247 		if ( info->serial_signals & SerialSignal_RTS ) {
1248 			info->serial_signals &= ~SerialSignal_RTS;
1249 			usc_set_serial_signals( info );
1251 		info->drop_rts_on_tx_done = false;
1255 	if (info->netcount)
1256 		hdlcdev_tx_done(info);
1260 		if (info->port.tty->stopped || info->port.tty->hw_stopped) {
1261 			usc_stop_transmitter(info);
1264 		info->pending_bh |= BH_TRANSMIT;
1274  * Arguments:		info	       pointer to device instance data
1277 static void mgsl_isr_io_pin( struct mgsl_struct *info )
1280 	u16 status = usc_InReg( info, MISR );
1286 	usc_ClearIrqPendingBits( info, IO_PIN );
1287 	usc_UnlatchIostatusBits( info, status );
1291 		icount = &info->icount;
1294 			if ((info->ri_chkcount)++ >= IO_PIN_SHUTDOWN_LIMIT)
1295 				usc_DisablestatusIrqs(info,SICR_RI);
1298 				info->input_signal_events.ri_up++;	
1300 				info->input_signal_events.ri_down++;	
1303 			if ((info->dsr_chkcount)++ >= IO_PIN_SHUTDOWN_LIMIT)
1304 				usc_DisablestatusIrqs(info,SICR_DSR);
1307 				info->input_signal_events.dsr_up++;
1309 				info->input_signal_events.dsr_down++;
1312 			if ((info->dcd_chkcount)++ >= IO_PIN_SHUTDOWN_LIMIT)
1313 				usc_DisablestatusIrqs(info,SICR_DCD);
1316 				info->input_signal_events.dcd_up++;
1318 				info->input_signal_events.dcd_down++;
1320 			if (info->netcount) {
1322 					netif_carrier_on(info->netdev);
1324 					netif_carrier_off(info->netdev);
1330 			if ((info->cts_chkcount)++ >= IO_PIN_SHUTDOWN_LIMIT)
1331 				usc_DisablestatusIrqs(info,SICR_CTS);
1334 				info->input_signal_events.cts_up++;
1336 				info->input_signal_events.cts_down++;
1338 		wake_up_interruptible(&info->status_event_wait_q);
1339 		wake_up_interruptible(&info->event_wait_q);
1341 		if (tty_port_check_carrier(&info->port) &&
1344 				printk("%s CD now %s...", info->device_name,
1347 				wake_up_interruptible(&info->port.open_wait);
1351 				if (info->port.tty)
1352 					tty_hangup(info->port.tty);
1356 		if (tty_port_cts_enabled(&info->port) &&
1358 			if (info->port.tty->hw_stopped) {
1362 					info->port.tty->hw_stopped = 0;
1363 					usc_start_transmitter(info);
1364 					info->pending_bh |= BH_TRANSMIT;
1371 					if (info->port.tty)
1372 						info->port.tty->hw_stopped = 1;
1373 					usc_stop_transmitter(info);
1379 	info->pending_bh |= BH_STATUS;
1383 		usc_OutReg( info, SICR,
1384 			(unsigned short)(usc_InReg(info,SICR) & ~(SICR_TXC_ACTIVE+SICR_TXC_INACTIVE)) );
1385 		usc_UnlatchIostatusBits( info, MISCSTATUS_TXC_LATCHED );
1386 		info->irq_occurred = true;
1395  * Arguments:		info	pointer to device instance data
1398 static void mgsl_isr_transmit_data( struct mgsl_struct *info )
1402 			__FILE__,__LINE__,info->xmit_cnt);
1404 	usc_ClearIrqPendingBits( info, TRANSMIT_DATA );
1406 	if (info->port.tty->stopped || info->port.tty->hw_stopped) {
1407 		usc_stop_transmitter(info);
1411 	if ( info->xmit_cnt )
1412 		usc_load_txfifo( info );
1414 		info->tx_active = false;
1416 	if (info->xmit_cnt < WAKEUP_CHARS)
1417 		info->pending_bh |= BH_TRANSMIT;
1427  * Arguments:		info		pointer to device instance data
1430 static void mgsl_isr_receive_data( struct mgsl_struct *info )
1436  	struct	mgsl_icount *icount = &info->icount;
1442 	usc_ClearIrqPendingBits( info, RECEIVE_DATA );
1445 	usc_RCmd( info, RCmd_SelectRicrRxFifostatus );
1449 	usc_OutReg( info, RICR+LSBONLY, (u16)(usc_InReg(info, RICR+LSBONLY) & ~BIT3 ));
1453 	while( (Fifocount = (usc_InReg(info,RICR) >> 8)) ) {
1457 		outw( (inw(info->io_base + CCAR) & 0x0780) | (RDR+LSBONLY),
1458 		      info->io_base + CCAR );
1459 		DataByte = inb( info->io_base + CCAR );
1462 		status = usc_InReg(info, RCSR);
1465 			usc_UnlatchRxstatusBits(info,RXSTATUS_ALL);
1484 				usc_RTCmd(info,RTCmd_PurgeRxFifo);
1489 			if (status & info->ignore_status_mask)
1492 			status &= info->read_status_mask;
1496 				if (info->port.flags & ASYNC_SAK)
1497 					do_SAK(info->port.tty);
1503 		tty_insert_flip_char(&info->port, DataByte, flag);
1509 			work += tty_insert_flip_char(&info->port, 0, TTY_OVERRUN);
1520 		tty_flip_buffer_push(&info->port);
1527  * Arguments:		info		pointer to device extension (instance data)
1530 static void mgsl_isr_misc( struct mgsl_struct *info )
1532 	u16 status = usc_InReg( info, MISR );
1539 	    (info->params.mode == MGSL_MODE_HDLC)) {
1542 		usc_EnableReceiver(info,DISABLE_UNCONDITIONAL);
1543 		usc_DmaCmd(info, DmaCmd_ResetRxChannel);
1544 		usc_UnlatchRxstatusBits(info, RXSTATUS_ALL);
1545 		usc_ClearIrqPendingBits(info, RECEIVE_DATA | RECEIVE_STATUS);
1546 		usc_DisableInterrupts(info, RECEIVE_DATA | RECEIVE_STATUS);
1549 		info->pending_bh |= BH_RECEIVE;
1550 		info->rx_rcc_underrun = true;
1553 	usc_ClearIrqPendingBits( info, MISC );
1554 	usc_UnlatchMiscstatusBits( info, status );
1563  * Arguments:		info		pointer to device extension (instance data)
1566 static void mgsl_isr_null( struct mgsl_struct *info )
1587  * Arguments:		info		pointer to device instance data
1590 static void mgsl_isr_receive_dma( struct mgsl_struct *info )
1595 	usc_OutDmaReg( info, CDIR, BIT9 | BIT1 );
1599 	status = usc_InDmaReg( info, RDMR );
1603 			__FILE__,__LINE__,info->device_name,status);
1605 	info->pending_bh |= BH_RECEIVE;
1608 		info->rx_overflow = true;
1609 		info->icount.buf_overrun++;
1631  * Arguments:		info		pointer to device instance data
1634 static void mgsl_isr_transmit_dma( struct mgsl_struct *info )
1639 	usc_OutDmaReg(info, CDIR, BIT8 | BIT0 );
1644 	status = usc_InDmaReg( info, TDMR );
1648 			__FILE__,__LINE__,info->device_name,status);
1651 		--info->tx_dma_buffers_used;
1656 		if ( load_next_tx_holding_buffer(info) ) {
1660 			info->pending_bh |= BH_TRANSMIT;
1679 	struct mgsl_struct *info = dev_id;
1685 			__FILE__, __LINE__, info->irq_level);
1687 	spin_lock(&info->irq_spinlock);
1691 		UscVector = usc_InReg(info, IVR) >> 9;
1692 		DmaVector = usc_InDmaReg(info, DIVR);
1696 				__FILE__,__LINE__,info->device_name,UscVector,DmaVector);
1703 			(*UscIsrTable[UscVector])(info);
1705 			mgsl_isr_transmit_dma(info);
1707 			mgsl_isr_receive_dma(info);
1709 		if ( info->isr_overflow ) {
1711 				__FILE__, __LINE__, info->device_name, info->irq_level);
1712 			usc_DisableMasterIrqBit(info);
1713 			usc_DisableDmaInterrupts(info,DICR_MASTER);
1722 	if ( info->pending_bh && !info->bh_running && !info->bh_requested ) {
1725 				__FILE__,__LINE__,info->device_name);
1726 		schedule_work(&info->task);
1727 		info->bh_requested = true;
1730 	spin_unlock(&info->irq_spinlock);
1734 			__FILE__, __LINE__, info->irq_level);
1743  * Arguments:		info	pointer to device instance data
1746 static int startup(struct mgsl_struct * info)
1751 		printk("%s(%d):mgsl_startup(%s)\n",__FILE__,__LINE__,info->device_name);
1753 	if (tty_port_initialized(&info->port))
1756 	if (!info->xmit_buf) {
1758 		info->xmit_buf = (unsigned char *)get_zeroed_page(GFP_KERNEL);
1759 		if (!info->xmit_buf) {
1761 				__FILE__,__LINE__,info->device_name);
1766 	info->pending_bh = 0;
1768 	memset(&info->icount, 0, sizeof(info->icount));
1770 	timer_setup(&info->tx_timer, mgsl_tx_timeout, 0);
1773 	retval = mgsl_claim_resources(info);
1777 		retval = mgsl_adapter_test(info);
1780   		if (capable(CAP_SYS_ADMIN) && info->port.tty)
1781 			set_bit(TTY_IO_ERROR, &info->port.tty->flags);
1782 		mgsl_release_resources(info);
1787 	mgsl_change_params(info);
1789 	if (info->port.tty)
1790 		clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
1792 	tty_port_set_initialized(&info->port, 1);
1801  * Arguments:		info	pointer to device instance data
1804 static void shutdown(struct mgsl_struct * info)
1808 	if (!tty_port_initialized(&info->port))
1813 			 __FILE__,__LINE__, info->device_name );
1817 	wake_up_interruptible(&info->status_event_wait_q);
1818 	wake_up_interruptible(&info->event_wait_q);
1820 	del_timer_sync(&info->tx_timer);
1822 	if (info->xmit_buf) {
1823 		free_page((unsigned long) info->xmit_buf);
1824 		info->xmit_buf = NULL;
1827 	spin_lock_irqsave(&info->irq_spinlock,flags);
1828 	usc_DisableMasterIrqBit(info);
1829 	usc_stop_receiver(info);
1830 	usc_stop_transmitter(info);
1831 	usc_DisableInterrupts(info,RECEIVE_DATA | RECEIVE_STATUS |
1833 	usc_DisableDmaInterrupts(info,DICR_MASTER + DICR_TRANSMIT + DICR_RECEIVE);
1838 	usc_OutReg(info, PCR, (u16)((usc_InReg(info, PCR) | BIT15) | BIT14));
1843 	usc_OutReg(info, PCR, (u16)((usc_InReg(info, PCR) | BIT13) | BIT12));
1845 	if (!info->port.tty || info->port.tty->termios.c_cflag & HUPCL) {
1846 		info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
1847 		usc_set_serial_signals(info);
1850 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
1852 	mgsl_release_resources(info);
1854 	if (info->port.tty)
1855 		set_bit(TTY_IO_ERROR, &info->port.tty->flags);
1857 	tty_port_set_initialized(&info->port, 0);
1860 static void mgsl_program_hw(struct mgsl_struct *info)
1864 	spin_lock_irqsave(&info->irq_spinlock,flags);
1866 	usc_stop_receiver(info);
1867 	usc_stop_transmitter(info);
1868 	info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
1870 	if (info->params.mode == MGSL_MODE_HDLC ||
1871 	    info->params.mode == MGSL_MODE_RAW ||
1872 	    info->netcount)
1873 		usc_set_sync_mode(info);
1875 		usc_set_async_mode(info);
1877 	usc_set_serial_signals(info);
1879 	info->dcd_chkcount = 0;
1880 	info->cts_chkcount = 0;
1881 	info->ri_chkcount = 0;
1882 	info->dsr_chkcount = 0;
1884 	usc_EnableStatusIrqs(info,SICR_CTS+SICR_DSR+SICR_DCD+SICR_RI);
1885 	usc_EnableInterrupts(info, IO_PIN);
1886 	usc_get_serial_signals(info);
1888 	if (info->netcount || info->port.tty->termios.c_cflag & CREAD)
1889 		usc_start_receiver(info);
1891 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
1896 static void mgsl_change_params(struct mgsl_struct *info)
1901 	if (!info->port.tty)
1906 			 __FILE__,__LINE__, info->device_name );
1908 	cflag = info->port.tty->termios.c_cflag;
1913 		info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
1915 		info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
1920 	      case CS5: info->params.data_bits = 5; break;
1921 	      case CS6: info->params.data_bits = 6; break;
1922 	      case CS7: info->params.data_bits = 7; break;
1923 	      case CS8: info->params.data_bits = 8; break;
1925 	      default:  info->params.data_bits = 7; break;
1929 		info->params.stop_bits = 2;
1931 		info->params.stop_bits = 1;
1933 	info->params.parity = ASYNC_PARITY_NONE;
1936 			info->params.parity = ASYNC_PARITY_ODD;
1938 			info->params.parity = ASYNC_PARITY_EVEN;
1941 			info->params.parity = ASYNC_PARITY_SPACE;
1948 	bits_per_char = info->params.data_bits + 
1949 			info->params.stop_bits + 1;
1955 	if (info->params.data_rate <= 460800)
1956 		info->params.data_rate = tty_get_baud_rate(info->port.tty);
1958 	if ( info->params.data_rate ) {
1959 		info->timeout = (32*HZ*bits_per_char) / 
1960 				info->params.data_rate;
1962 	info->timeout += HZ/50;		/* Add .02 seconds of slop */
1964 	tty_port_set_cts_flow(&info->port, cflag & CRTSCTS);
1965 	tty_port_set_check_carrier(&info->port, ~cflag & CLOCAL);
1969 	info->read_status_mask = RXSTATUS_OVERRUN;
1970 	if (I_INPCK(info->port.tty))
1971 		info->read_status_mask |= RXSTATUS_PARITY_ERROR | RXSTATUS_FRAMING_ERROR;
1972  	if (I_BRKINT(info->port.tty) || I_PARMRK(info->port.tty))
1973  		info->read_status_mask |= RXSTATUS_BREAK_RECEIVED;
1975 	if (I_IGNPAR(info->port.tty))
1976 		info->ignore_status_mask |= RXSTATUS_PARITY_ERROR | RXSTATUS_FRAMING_ERROR;
1977 	if (I_IGNBRK(info->port.tty)) {
1978 		info->ignore_status_mask |= RXSTATUS_BREAK_RECEIVED;
1982 		if (I_IGNPAR(info->port.tty))
1983 			info->ignore_status_mask |= RXSTATUS_OVERRUN;
1986 	mgsl_program_hw(info);
2001 	struct mgsl_struct *info = tty->driver_data;
2007 			__FILE__, __LINE__, ch, info->device_name);
2010 	if (mgsl_paranoia_check(info, tty->name, "mgsl_put_char"))
2013 	if (!info->xmit_buf)
2016 	spin_lock_irqsave(&info->irq_spinlock, flags);
2018 	if ((info->params.mode == MGSL_MODE_ASYNC ) || !info->tx_active) {
2019 		if (info->xmit_cnt < SERIAL_XMIT_SIZE - 1) {
2020 			info->xmit_buf[info->xmit_head++] = ch;
2021 			info->xmit_head &= SERIAL_XMIT_SIZE-1;
2022 			info->xmit_cnt++;
2026 	spin_unlock_irqrestore(&info->irq_spinlock, flags);
2041 	struct mgsl_struct *info = tty->driver_data;
2046 			__FILE__,__LINE__,info->device_name,info->xmit_cnt);
2048 	if (mgsl_paranoia_check(info, tty->name, "mgsl_flush_chars"))
2051 	if (info->xmit_cnt <= 0 || tty->stopped || tty->hw_stopped ||
2052 	    !info->xmit_buf)
2057 			__FILE__,__LINE__,info->device_name );
2059 	spin_lock_irqsave(&info->irq_spinlock,flags);
2061 	if (!info->tx_active) {
2062 		if ( (info->params.mode == MGSL_MODE_HDLC ||
2063 			info->params.mode == MGSL_MODE_RAW) && info->xmit_cnt ) {
2067 			mgsl_load_tx_dma_buffer(info,
2068 				 info->xmit_buf,info->xmit_cnt);
2070 	 	usc_start_transmitter(info);
2073 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2093 	struct mgsl_struct *info = tty->driver_data;
2098 			__FILE__,__LINE__,info->device_name,count);
2100 	if (mgsl_paranoia_check(info, tty->name, "mgsl_write"))
2103 	if (!info->xmit_buf)
2106 	if ( info->params.mode == MGSL_MODE_HDLC ||
2107 			info->params.mode == MGSL_MODE_RAW ) {
2109 		if (info->tx_active) {
2111 			if ( info->params.mode == MGSL_MODE_HDLC ) {
2120 			if (info->tx_holding_count >= info->num_tx_holding_buffers ) {
2128 			save_tx_buffer_request(info,buf,count);
2133 			spin_lock_irqsave(&info->irq_spinlock,flags);
2134 			load_next_tx_holding_buffer(info);
2135 			spin_unlock_irqrestore(&info->irq_spinlock,flags);
2143 		if ( (info->params.flags & HDLC_FLAG_HDLC_LOOPMODE) &&
2144 			!usc_loopmode_active(info) )
2150 		if ( info->xmit_cnt ) {
2157 			mgsl_load_tx_dma_buffer(info,
2158 				info->xmit_buf,info->xmit_cnt);
2161 					__FILE__,__LINE__,info->device_name);
2165 					__FILE__,__LINE__,info->device_name);
2167 			info->xmit_cnt = count;
2168 			mgsl_load_tx_dma_buffer(info,buf,count);
2172 			spin_lock_irqsave(&info->irq_spinlock,flags);
2174 				min(SERIAL_XMIT_SIZE - info->xmit_cnt - 1,
2175 				    SERIAL_XMIT_SIZE - info->xmit_head));
2177 				spin_unlock_irqrestore(&info->irq_spinlock,flags);
2180 			memcpy(info->xmit_buf + info->xmit_head, buf, c);
2181 			info->xmit_head = ((info->xmit_head + c) &
2183 			info->xmit_cnt += c;
2184 			spin_unlock_irqrestore(&info->irq_spinlock,flags);
2191  	if (info->xmit_cnt && !tty->stopped && !tty->hw_stopped) {
2192 		spin_lock_irqsave(&info->irq_spinlock,flags);
2193 		if (!info->tx_active)
2194 		 	usc_start_transmitter(info);
2195 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
2200 			__FILE__,__LINE__,info->device_name,ret);
2210  * Arguments:		tty	pointer to tty info structure
2215 	struct mgsl_struct *info = tty->driver_data;
2218 	if (mgsl_paranoia_check(info, tty->name, "mgsl_write_room"))
2220 	ret = SERIAL_XMIT_SIZE - info->xmit_cnt - 1;
2226 			 __FILE__,__LINE__, info->device_name,ret );
2228 	if ( info->params.mode == MGSL_MODE_HDLC ||
2229 		info->params.mode == MGSL_MODE_RAW ) {
2231 		if ( info->tx_active )
2245  * Arguments:		tty	pointer to tty info structure
2250 	struct mgsl_struct *info = tty->driver_data;
2254 			 __FILE__,__LINE__, info->device_name );
2256 	if (mgsl_paranoia_check(info, tty->name, "mgsl_chars_in_buffer"))
2261 			 __FILE__,__LINE__, info->device_name,info->xmit_cnt );
2263 	if ( info->params.mode == MGSL_MODE_HDLC ||
2264 		info->params.mode == MGSL_MODE_RAW ) {
2266 		if ( info->tx_active )
2267 			return info->max_frame_size;
2272 	return info->xmit_cnt;
2279  * Arguments:		tty	pointer to tty info structure
2284 	struct mgsl_struct *info = tty->driver_data;
2289 			 __FILE__,__LINE__, info->device_name );
2291 	if (mgsl_paranoia_check(info, tty->name, "mgsl_flush_buffer"))
2294 	spin_lock_irqsave(&info->irq_spinlock,flags); 
2295 	info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
2296 	del_timer(&info->tx_timer);	
2297 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2306  * Arguments:		tty	pointer to tty info structure
2312 	struct mgsl_struct *info = tty->driver_data;
2317 			 __FILE__,__LINE__, info->device_name, ch );
2319 	if (mgsl_paranoia_check(info, tty->name, "mgsl_send_xchar"))
2322 	info->x_char = ch;
2325 		spin_lock_irqsave(&info->irq_spinlock,flags);
2326 		if (!info->tx_enabled)
2327 		 	usc_start_transmitter(info);
2328 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
2336  * Arguments:		tty	pointer to tty info structure
2341 	struct mgsl_struct *info = tty->driver_data;
2346 			 __FILE__,__LINE__, info->device_name );
2348 	if (mgsl_paranoia_check(info, tty->name, "mgsl_throttle"))
2355 		spin_lock_irqsave(&info->irq_spinlock,flags);
2356 		info->serial_signals &= ~SerialSignal_RTS;
2357 	 	usc_set_serial_signals(info);
2358 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
2366  * Arguments:		tty	pointer to tty info structure
2371 	struct mgsl_struct *info = tty->driver_data;
2376 			 __FILE__,__LINE__, info->device_name );
2378 	if (mgsl_paranoia_check(info, tty->name, "mgsl_unthrottle"))
2382 		if (info->x_char)
2383 			info->x_char = 0;
2389 		spin_lock_irqsave(&info->irq_spinlock,flags);
2390 		info->serial_signals |= SerialSignal_RTS;
2391 	 	usc_set_serial_signals(info);
2392 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
2401  * Arguments:	info		pointer to device instance data
2406 static int mgsl_get_stats(struct mgsl_struct * info, struct mgsl_icount __user *user_icount)
2412 			 __FILE__,__LINE__, info->device_name);
2415 		memset(&info->icount, 0, sizeof(info->icount));
2417 		mutex_lock(&info->port.mutex);
2418 		COPY_TO_USER(err, user_icount, &info->icount, sizeof(struct mgsl_icount));
2419 		mutex_unlock(&info->port.mutex);
2432  * Arguments:	info		pointer to device instance data
2437 static int mgsl_get_params(struct mgsl_struct * info, MGSL_PARAMS __user *user_params)
2442 			 __FILE__,__LINE__, info->device_name);
2444 	mutex_lock(&info->port.mutex);
2445 	COPY_TO_USER(err,user_params, &info->params, sizeof(MGSL_PARAMS));
2446 	mutex_unlock(&info->port.mutex);
2450 				__FILE__,__LINE__,info->device_name);
2464  * 	info		pointer to device instance data
2469 static int mgsl_set_params(struct mgsl_struct * info, MGSL_PARAMS __user *new_params)
2477 			info->device_name );
2482 				__FILE__,__LINE__,info->device_name);
2486 	mutex_lock(&info->port.mutex);
2487 	spin_lock_irqsave(&info->irq_spinlock,flags);
2488 	memcpy(&info->params,&tmp_params,sizeof(MGSL_PARAMS));
2489 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2491  	mgsl_change_params(info);
2492 	mutex_unlock(&info->port.mutex);
2502  * Arguments:	info		pointer to device instance data
2507 static int mgsl_get_txidle(struct mgsl_struct * info, int __user *idle_mode)
2513 			 __FILE__,__LINE__, info->device_name, info->idle_mode);
2515 	COPY_TO_USER(err,idle_mode, &info->idle_mode, sizeof(int));
2519 				__FILE__,__LINE__,info->device_name);
2529  * Arguments:	 	info		pointer to device instance data
2534 static int mgsl_set_txidle(struct mgsl_struct * info, int idle_mode)
2540 			info->device_name, idle_mode );
2542 	spin_lock_irqsave(&info->irq_spinlock,flags);
2543 	info->idle_mode = idle_mode;
2544 	usc_set_txidle( info );
2545 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2556  * 	info		pointer to device instance data
2561 static int mgsl_txenable(struct mgsl_struct * info, int enable)
2567 			info->device_name, enable);
2569 	spin_lock_irqsave(&info->irq_spinlock,flags);
2571 		if ( !info->tx_enabled ) {
2573 			usc_start_transmitter(info);
2581 			if ( info->params.flags & HDLC_FLAG_HDLC_LOOPMODE )
2582 				usc_loopmode_insert_request( info );
2585 		if ( info->tx_enabled )
2586 			usc_stop_transmitter(info);
2588 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2595  * Arguments:	 	info		pointer to device instance data
2598 static int mgsl_txabort(struct mgsl_struct * info)
2604 			info->device_name);
2606 	spin_lock_irqsave(&info->irq_spinlock,flags);
2607 	if ( info->tx_active && info->params.mode == MGSL_MODE_HDLC )
2609 		if ( info->params.flags & HDLC_FLAG_HDLC_LOOPMODE )
2610 			usc_loopmode_cancel_transmit( info );
2612 			usc_TCmd(info,TCmd_SendAbort);
2614 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2621  * Arguments:	 	info		pointer to device instance data
2625 static int mgsl_rxenable(struct mgsl_struct * info, int enable)
2631 			info->device_name, enable);
2633 	spin_lock_irqsave(&info->irq_spinlock,flags);
2635 		if ( !info->rx_enabled )
2636 			usc_start_receiver(info);
2638 		if ( info->rx_enabled )
2639 			usc_stop_receiver(info);
2641 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2648  * Arguments:	 	info	pointer to device instance data
2654 static int mgsl_wait_event(struct mgsl_struct * info, int __user * mask_ptr)
2672 			info->device_name, mask);
2674 	spin_lock_irqsave(&info->irq_spinlock,flags);
2677 	usc_get_serial_signals(info);
2678 	s = info->serial_signals;
2685 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
2690 	cprev = info->icount;
2691 	oldsigs = info->input_signal_events;
2695 		u16 oldreg = usc_InReg(info,RICR);
2700 			usc_OutReg(info, RICR, newreg);
2704 	add_wait_queue(&info->event_wait_q, &wait);
2706 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2717 		spin_lock_irqsave(&info->irq_spinlock,flags);
2718 		cnow = info->icount;
2719 		newsigs = info->input_signal_events;
2721 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
2756 	remove_wait_queue(&info->event_wait_q, &wait);
2760 		spin_lock_irqsave(&info->irq_spinlock,flags);
2761 		if (!waitqueue_active(&info->event_wait_q)) {
2763 			usc_OutReg(info, RICR, usc_InReg(info,RICR) &
2766 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
2776 static int modem_input_wait(struct mgsl_struct *info,int arg)
2784 	spin_lock_irqsave(&info->irq_spinlock,flags);
2785 	cprev = info->icount;
2786 	add_wait_queue(&info->status_event_wait_q, &wait);
2788 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2798 		spin_lock_irqsave(&info->irq_spinlock,flags);
2799 		cnow = info->icount;
2801 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
2821 	remove_wait_queue(&info->status_event_wait_q, &wait);
2830 	struct mgsl_struct *info = tty->driver_data;
2834 	spin_lock_irqsave(&info->irq_spinlock,flags);
2835  	usc_get_serial_signals(info);
2836 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2838 	result = ((info->serial_signals & SerialSignal_RTS) ? TIOCM_RTS:0) +
2839 		((info->serial_signals & SerialSignal_DTR) ? TIOCM_DTR:0) +
2840 		((info->serial_signals & SerialSignal_DCD) ? TIOCM_CAR:0) +
2841 		((info->serial_signals & SerialSignal_RI)  ? TIOCM_RNG:0) +
2842 		((info->serial_signals & SerialSignal_DSR) ? TIOCM_DSR:0) +
2843 		((info->serial_signals & SerialSignal_CTS) ? TIOCM_CTS:0);
2847 			 __FILE__,__LINE__, info->device_name, result );
2856 	struct mgsl_struct *info = tty->driver_data;
2861 			__FILE__,__LINE__,info->device_name, set, clear);
2864 		info->serial_signals |= SerialSignal_RTS;
2866 		info->serial_signals |= SerialSignal_DTR;
2868 		info->serial_signals &= ~SerialSignal_RTS;
2870 		info->serial_signals &= ~SerialSignal_DTR;
2872 	spin_lock_irqsave(&info->irq_spinlock,flags);
2873  	usc_set_serial_signals(info);
2874 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2887 	struct mgsl_struct * info = tty->driver_data;
2892 			 __FILE__,__LINE__, info->device_name, break_state);
2894 	if (mgsl_paranoia_check(info, tty->name, "mgsl_break"))
2897 	spin_lock_irqsave(&info->irq_spinlock,flags);
2899 		usc_OutReg(info,IOCR,(u16)(usc_InReg(info,IOCR) | BIT7));
2901 		usc_OutReg(info,IOCR,(u16)(usc_InReg(info,IOCR) & ~BIT7));
2902 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2917 	struct mgsl_struct * info = tty->driver_data;
2921 	spin_lock_irqsave(&info->irq_spinlock,flags);
2922 	cnow = info->icount;
2923 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
2952 	struct mgsl_struct * info = tty->driver_data;
2956 			info->device_name, cmd );
2958 	if (mgsl_paranoia_check(info, tty->name, "mgsl_ioctl"))
2966 	return mgsl_ioctl_common(info, cmd, arg);
2969 static int mgsl_ioctl_common(struct mgsl_struct *info, unsigned int cmd, unsigned long arg)
2975 			return mgsl_get_params(info, argp);
2977 			return mgsl_set_params(info, argp);
2979 			return mgsl_get_txidle(info, argp);
2981 			return mgsl_set_txidle(info,(int)arg);
2983 			return mgsl_txenable(info,(int)arg);
2985 			return mgsl_rxenable(info,(int)arg);
2987 			return mgsl_txabort(info);
2989 			return mgsl_get_stats(info, argp);
2991 			return mgsl_wait_event(info, argp);
2993 			return mgsl_loopmode_send_done(info);
2998 			return modem_input_wait(info,(int)arg);
3019 	struct mgsl_struct *info = tty->driver_data;
3026 	mgsl_change_params(info);
3030 		info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
3031 		spin_lock_irqsave(&info->irq_spinlock,flags);
3032 	 	usc_set_serial_signals(info);
3033 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
3038 		info->serial_signals |= SerialSignal_DTR;
3040 			info->serial_signals |= SerialSignal_RTS;
3041 		spin_lock_irqsave(&info->irq_spinlock,flags);
3042 	 	usc_set_serial_signals(info);
3043 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
3068 	struct mgsl_struct * info = tty->driver_data;
3070 	if (mgsl_paranoia_check(info, tty->name, "mgsl_close"))
3075 			 __FILE__,__LINE__, info->device_name, info->port.count);
3077 	if (tty_port_close_start(&info->port, tty, filp) == 0)
3080 	mutex_lock(&info->port.mutex);
3081 	if (tty_port_initialized(&info->port))
3082  		mgsl_wait_until_sent(tty, info->timeout);
3085 	shutdown(info);
3086 	mutex_unlock(&info->port.mutex);
3088 	tty_port_close_end(&info->port, tty);	
3089 	info->port.tty = NULL;
3093 			tty->driver->name, info->port.count);
3103  *	tty		pointer to tty info structure
3110 	struct mgsl_struct * info = tty->driver_data;
3113 	if (!info )
3118 			 __FILE__,__LINE__, info->device_name );
3120 	if (mgsl_paranoia_check(info, tty->name, "mgsl_wait_until_sent"))
3123 	if (!tty_port_initialized(&info->port))
3134 	if ( info->params.data_rate ) {
3135 	       	char_time = info->timeout/(32 * 5);
3144 	if ( info->params.mode == MGSL_MODE_HDLC ||
3145 		info->params.mode == MGSL_MODE_RAW ) {
3146 		while (info->tx_active) {
3154 		while (!(usc_InReg(info,TCSR) & TXSTATUS_ALL_SENT) &&
3155 			info->tx_enabled) {
3167 			 __FILE__,__LINE__, info->device_name );
3181 	struct mgsl_struct * info = tty->driver_data;
3185 			 __FILE__,__LINE__, info->device_name );
3187 	if (mgsl_paranoia_check(info, tty->name, "mgsl_hangup"))
3191 	shutdown(info);
3193 	info->port.count = 0;	
3194 	tty_port_set_active(&info->port, 0);
3195 	info->port.tty = NULL;
3197 	wake_up_interruptible(&info->port.open_wait);
3210 	struct mgsl_struct *info = container_of(port, struct mgsl_struct, port);
3212 	spin_lock_irqsave(&info->irq_spinlock, flags);
3213  	usc_get_serial_signals(info);
3214 	spin_unlock_irqrestore(&info->irq_spinlock, flags);
3215 	return (info->serial_signals & SerialSignal_DCD) ? 1 : 0;
3220 	struct mgsl_struct *info = container_of(port, struct mgsl_struct, port);
3223 	spin_lock_irqsave(&info->irq_spinlock,flags);
3225 		info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
3227 		info->serial_signals &= ~(SerialSignal_RTS | SerialSignal_DTR);
3228  	usc_set_serial_signals(info);
3229 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
3240  * 	tty		pointer to tty info structure
3242  * 	info		pointer to device instance data
3247 			   struct mgsl_struct *info)
3254 	struct tty_port *port = &info->port;
3283 	spin_lock_irqsave(&info->irq_spinlock, flags);
3285 	spin_unlock_irqrestore(&info->irq_spinlock, flags);
3300 		dcd = tty_port_carrier_raised(&info->port);
3339 	struct mgsl_struct *info;
3349 	/* find the info structure for the specified line */
3350 	info = mgsl_device_list;
3351 	while (info && info->line != line)
3352 		info = info->next_device;
3353 	if (mgsl_paranoia_check(info, tty->name, "mgsl_open"))
3355 	tty->driver_data = info;
3357 	return tty_port_install(&info->port, driver, tty);
3365  * Arguments:		tty	pointer to tty info structure
3372 	struct mgsl_struct *info = tty->driver_data;
3376 	info->port.tty = tty;
3380 			 __FILE__,__LINE__,tty->driver->name, info->port.count);
3382 	info->port.low_latency = (info->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
3384 	spin_lock_irqsave(&info->netlock, flags);
3385 	if (info->netcount) {
3387 		spin_unlock_irqrestore(&info->netlock, flags);
3390 	info->port.count++;
3391 	spin_unlock_irqrestore(&info->netlock, flags);
3393 	if (info->port.count == 1) {
3395 		retval = startup(info);
3400 	retval = block_til_ready(tty, filp, info);
3404 				 __FILE__,__LINE__, info->device_name, retval);
3410 			 __FILE__,__LINE__, info->device_name);
3416 			info->port.tty = NULL; /* tty layer will release tty struct */
3417 		if(info->port.count)
3418 			info->port.count--;
3429 static inline void line_info(struct seq_file *m, struct mgsl_struct *info)
3435 		info->device_name, info->io_base, info->irq_level,
3436 		info->phys_memory_base, info->phys_lcr_base);
3439 	spin_lock_irqsave(&info->irq_spinlock,flags);
3440  	usc_get_serial_signals(info);
3441 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
3445 	if (info->serial_signals & SerialSignal_RTS)
3447 	if (info->serial_signals & SerialSignal_CTS)
3449 	if (info->serial_signals & SerialSignal_DTR)
3451 	if (info->serial_signals & SerialSignal_DSR)
3453 	if (info->serial_signals & SerialSignal_DCD)
3455 	if (info->serial_signals & SerialSignal_RI)
3458 	if (info->params.mode == MGSL_MODE_HDLC ||
3459 	    info->params.mode == MGSL_MODE_RAW ) {
3461 			      info->icount.txok, info->icount.rxok);
3462 		if (info->icount.txunder)
3463 			seq_printf(m, " txunder:%d", info->icount.txunder);
3464 		if (info->icount.txabort)
3465 			seq_printf(m, " txabort:%d", info->icount.txabort);
3466 		if (info->icount.rxshort)
3467 			seq_printf(m, " rxshort:%d", info->icount.rxshort);
3468 		if (info->icount.rxlong)
3469 			seq_printf(m, " rxlong:%d", info->icount.rxlong);
3470 		if (info->icount.rxover)
3471 			seq_printf(m, " rxover:%d", info->icount.rxover);
3472 		if (info->icount.rxcrc)
3473 			seq_printf(m, " rxcrc:%d", info->icount.rxcrc);
3476 			      info->icount.tx, info->icount.rx);
3477 		if (info->icount.frame)
3478 			seq_printf(m, " fe:%d", info->icount.frame);
3479 		if (info->icount.parity)
3480 			seq_printf(m, " pe:%d", info->icount.parity);
3481 		if (info->icount.brk)
3482 			seq_printf(m, " brk:%d", info->icount.brk);
3483 		if (info->icount.overrun)
3484 			seq_printf(m, " oe:%d", info->icount.overrun);
3491 	 info->tx_active,info->bh_requested,info->bh_running,
3492 	 info->pending_bh);
3494 	spin_lock_irqsave(&info->irq_spinlock,flags);
3496 	u16 Tcsr = usc_InReg( info, TCSR );
3497 	u16 Tdmr = usc_InDmaReg( info, TDMR );
3498 	u16 Ticr = usc_InReg( info, TICR );
3499 	u16 Rscr = usc_InReg( info, RCSR );
3500 	u16 Rdmr = usc_InDmaReg( info, RDMR );
3501 	u16 Ricr = usc_InReg( info, RICR );
3502 	u16 Icr = usc_InReg( info, ICR );
3503 	u16 Dccr = usc_InReg( info, DCCR );
3504 	u16 Tmr = usc_InReg( info, TMR );
3505 	u16 Tccr = usc_InReg( info, TCCR );
3506 	u16 Ccar = inw( info->io_base + CCAR );
3511 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
3517 	struct mgsl_struct *info;
3521 	info = mgsl_device_list;
3522 	while( info ) {
3523 		line_info(m, info);
3524 		info = info->next_device;
3534  * Arguments:		info	pointer to device instance data
3537 static int mgsl_allocate_dma_buffers(struct mgsl_struct *info)
3541 	info->last_mem_alloc = 0;
3548 	BuffersPerFrame = (unsigned short)(info->max_frame_size/DMABUFFERSIZE);
3549 	if ( info->max_frame_size % DMABUFFERSIZE )
3571 	info->tx_buffer_count = info->num_tx_dma_buffers * BuffersPerFrame;
3572 	info->rx_buffer_count = 62 - info->tx_buffer_count;
3576 			__FILE__,__LINE__, info->tx_buffer_count,info->rx_buffer_count);
3578 	if ( mgsl_alloc_buffer_list_memory( info ) < 0 ||
3579 		  mgsl_alloc_frame_memory(info, info->rx_buffer_list, info->rx_buffer_count) < 0 || 
3580 		  mgsl_alloc_frame_memory(info, info->tx_buffer_list, info->tx_buffer_count) < 0 || 
3581 		  mgsl_alloc_intermediate_rxbuffer_memory(info) < 0  ||
3582 		  mgsl_alloc_intermediate_txbuffer_memory(info) < 0 ) {
3587 	mgsl_reset_rx_dma_buffers( info );
3588   	mgsl_reset_tx_dma_buffers( info );
3602  * (plus some other info about the buffer).
3614  * Arguments:		info	pointer to device instance data
3617 static int mgsl_alloc_buffer_list_memory( struct mgsl_struct *info )
3622 	info->buffer_list = info->memory_base + info->last_mem_alloc;
3623 	info->buffer_list_phys = info->last_mem_alloc;
3624 	info->last_mem_alloc += BUFFERLISTSIZE;
3628 	memset( info->buffer_list, 0, BUFFERLISTSIZE );
3633 	info->rx_buffer_list = (DMABUFFERENTRY *)info->buffer_list;
3634 	info->tx_buffer_list = (DMABUFFERENTRY *)info->buffer_list;
3635 	info->tx_buffer_list += info->rx_buffer_count;
3646 	for ( i = 0; i < info->rx_buffer_count; i++ ) {
3648 		info->rx_buffer_list[i].phys_entry =
3649 			info->buffer_list_phys + (i * sizeof(DMABUFFERENTRY));
3654 		info->rx_buffer_list[i].link = info->buffer_list_phys;
3656 		if ( i < info->rx_buffer_count - 1 )
3657 			info->rx_buffer_list[i].link += (i + 1) * sizeof(DMABUFFERENTRY);
3660 	for ( i = 0; i < info->tx_buffer_count; i++ ) {
3662 		info->tx_buffer_list[i].phys_entry = info->buffer_list_phys +
3663 			((info->rx_buffer_count + i) * sizeof(DMABUFFERENTRY));
3668 		info->tx_buffer_list[i].link = info->buffer_list_phys +
3669 			info->rx_buffer_count * sizeof(DMABUFFERENTRY);
3671 		if ( i < info->tx_buffer_count - 1 )
3672 			info->tx_buffer_list[i].link += (i + 1) * sizeof(DMABUFFERENTRY);
3688 static void mgsl_free_buffer_list_memory( struct mgsl_struct *info )
3690 	info->buffer_list = NULL;
3691 	info->rx_buffer_list = NULL;
3692 	info->tx_buffer_list = NULL;
3706  *	info		pointer to device instance data
3712 static int mgsl_alloc_frame_memory(struct mgsl_struct *info,DMABUFFERENTRY *BufferList,int Buffercount)
3719 		BufferList[i].virt_addr = info->memory_base + info->last_mem_alloc;
3720 		BufferList[i].phys_addr = info->last_mem_alloc;
3721 		info->last_mem_alloc += DMABUFFERSIZE;
3736  *	info		pointer to device instance data
3742 static void mgsl_free_frame_memory(struct mgsl_struct *info, DMABUFFERENTRY *BufferList, int Buffercount)
3760  * Arguments:		info	pointer to device instance data
3763 static void mgsl_free_dma_buffers( struct mgsl_struct *info )
3765 	mgsl_free_frame_memory( info, info->rx_buffer_list, info->rx_buffer_count );
3766 	mgsl_free_frame_memory( info, info->tx_buffer_list, info->tx_buffer_count );
3767 	mgsl_free_buffer_list_memory( info );
3780  *	info		pointer to device instance data
3784 static int mgsl_alloc_intermediate_rxbuffer_memory(struct mgsl_struct *info)
3786 	info->intermediate_rxbuffer = kmalloc(info->max_frame_size, GFP_KERNEL | GFP_DMA);
3787 	if ( info->intermediate_rxbuffer == NULL )
3790 	info->flag_buf = kzalloc(info->max_frame_size, GFP_KERNEL);
3791 	if (!info->flag_buf) {
3792 		kfree(info->intermediate_rxbuffer);
3793 		info->intermediate_rxbuffer = NULL;
3806  *	info		pointer to device instance data
3810 static void mgsl_free_intermediate_rxbuffer_memory(struct mgsl_struct *info)
3812 	kfree(info->intermediate_rxbuffer);
3813 	info->intermediate_rxbuffer = NULL;
3814 	kfree(info->flag_buf);
3815 	info->flag_buf = NULL;
3828  *	info		pointer to device instance data
3832 static int mgsl_alloc_intermediate_txbuffer_memory(struct mgsl_struct *info)
3838 				info->device_name, __FILE__,__LINE__,info->num_tx_holding_buffers);
3840 	memset(info->tx_holding_buffers,0,sizeof(info->tx_holding_buffers));
3842 	for ( i=0; i<info->num_tx_holding_buffers; ++i) {
3843 		info->tx_holding_buffers[i].buffer =
3844 			kmalloc(info->max_frame_size, GFP_KERNEL);
3845 		if (info->tx_holding_buffers[i].buffer == NULL) {
3847 				kfree(info->tx_holding_buffers[i].buffer);
3848 				info->tx_holding_buffers[i].buffer = NULL;
3864  *	info		pointer to device instance data
3868 static void mgsl_free_intermediate_txbuffer_memory(struct mgsl_struct *info)
3872 	for ( i=0; i<info->num_tx_holding_buffers; ++i ) {
3873 		kfree(info->tx_holding_buffers[i].buffer);
3874 		info->tx_holding_buffers[i].buffer = NULL;
3877 	info->get_tx_holding_index = 0;
3878 	info->put_tx_holding_index = 0;
3879 	info->tx_holding_count = 0;
3892  *	info		pointer to device instance data
3898 static bool load_next_tx_holding_buffer(struct mgsl_struct *info)
3902 	if ( info->tx_holding_count ) {
3907 			&info->tx_holding_buffers[info->get_tx_holding_index];
3908 		int num_free = num_free_tx_dma_buffers(info);
3914 			info->xmit_cnt = ptx->buffer_size;
3915 			mgsl_load_tx_dma_buffer(info,ptx->buffer,ptx->buffer_size);
3917 			--info->tx_holding_count;
3918 			if ( ++info->get_tx_holding_index >= info->num_tx_holding_buffers)
3919 				info->get_tx_holding_index=0;
3922 			mod_timer(&info->tx_timer, jiffies + msecs_to_jiffies(5000));
3938  *	info		pointer to device instance data
3944 static int save_tx_buffer_request(struct mgsl_struct *info,const char *Buffer, unsigned int BufferSize)
3948 	if ( info->tx_holding_count >= info->num_tx_holding_buffers ) {
3952 	ptx = &info->tx_holding_buffers[info->put_tx_holding_index];
3956 	++info->tx_holding_count;
3957 	if ( ++info->put_tx_holding_index >= info->num_tx_holding_buffers)
3958 		info->put_tx_holding_index=0;
3963 static int mgsl_claim_resources(struct mgsl_struct *info)
3965 	if (request_region(info->io_base,info->io_addr_size,"synclink") == NULL) {
3967 			__FILE__,__LINE__,info->device_name, info->io_base);
3970 	info->io_addr_requested = true;
3972 	if ( request_irq(info->irq_level,mgsl_interrupt,info->irq_flags,
3973 		info->device_name, info ) < 0 ) {
3975 			__FILE__,__LINE__,info->device_name, info->irq_level );
3978 	info->irq_requested = true;
3980 	if (request_mem_region(info->phys_memory_base,0x40000,"synclink") == NULL) {
3982 			__FILE__,__LINE__,info->device_name, info->phys_memory_base);
3985 	info->shared_mem_requested = true;
3986 	if (request_mem_region(info->phys_lcr_base + info->lcr_offset,128,"synclink") == NULL) {
3988 			__FILE__,__LINE__,info->device_name, info->phys_lcr_base + info->lcr_offset);
3991 	info->lcr_mem_requested = true;
3993 	info->memory_base = ioremap(info->phys_memory_base, 0x40000);
3994 	if (!info->memory_base) {
3996 			__FILE__,__LINE__,info->device_name, info->phys_memory_base );
4000 	if ( !mgsl_memory_test(info) ) {
4002 			__FILE__,__LINE__,info->device_name, info->phys_memory_base );
4006 	info->lcr_base = ioremap(info->phys_lcr_base, PAGE_SIZE);
4007 	if (!info->lcr_base) {
4009 			__FILE__,__LINE__,info->device_name, info->phys_lcr_base );
4012 	info->lcr_base += info->lcr_offset;
4014 	if ( mgsl_allocate_dma_buffers(info) < 0 ) {
4016 			__FILE__,__LINE__,info->device_name, info->dma_level );
4022 	mgsl_release_resources(info);
4027 static void mgsl_release_resources(struct mgsl_struct *info)
4031 			__FILE__,__LINE__,info->device_name );
4033 	if ( info->irq_requested ) {
4034 		free_irq(info->irq_level, info);
4035 		info->irq_requested = false;
4037 	if ( info->dma_requested ) {
4038 		disable_dma(info->dma_level);
4039 		free_dma(info->dma_level);
4040 		info->dma_requested = false;
4042 	mgsl_free_dma_buffers(info);
4043 	mgsl_free_intermediate_rxbuffer_memory(info);
4044      	mgsl_free_intermediate_txbuffer_memory(info);
4046 	if ( info->io_addr_requested ) {
4047 		release_region(info->io_base,info->io_addr_size);
4048 		info->io_addr_requested = false;
4050 	if ( info->shared_mem_requested ) {
4051 		release_mem_region(info->phys_memory_base,0x40000);
4052 		info->shared_mem_requested = false;
4054 	if ( info->lcr_mem_requested ) {
4055 		release_mem_region(info->phys_lcr_base + info->lcr_offset,128);
4056 		info->lcr_mem_requested = false;
4058 	if (info->memory_base){
4059 		iounmap(info->memory_base);
4060 		info->memory_base = NULL;
4062 	if (info->lcr_base){
4063 		iounmap(info->lcr_base - info->lcr_offset);
4064 		info->lcr_base = NULL;
4069 			__FILE__,__LINE__,info->device_name );
4078  * Arguments:		info	pointer to device instance data
4081 static void mgsl_add_device( struct mgsl_struct *info )
4083 	info->next_device = NULL;
4084 	info->line = mgsl_device_count;
4085 	sprintf(info->device_name,"ttySL%d",info->line);
4087 	if (info->line < MAX_TOTAL_DEVICES) {
4088 		if (maxframe[info->line])
4089 			info->max_frame_size = maxframe[info->line];
4091 		if (txdmabufs[info->line]) {
4092 			info->num_tx_dma_buffers = txdmabufs[info->line];
4093 			if (info->num_tx_dma_buffers < 1)
4094 				info->num_tx_dma_buffers = 1;
4097 		if (txholdbufs[info->line]) {
4098 			info->num_tx_holding_buffers = txholdbufs[info->line];
4099 			if (info->num_tx_holding_buffers < 1)
4100 				info->num_tx_holding_buffers = 1;
4101 			else if (info->num_tx_holding_buffers > MAX_TX_HOLDING_BUFFERS)
4102 				info->num_tx_holding_buffers = MAX_TX_HOLDING_BUFFERS;
4109 		mgsl_device_list = info;
4114 		current_dev->next_device = info;
4117 	if ( info->max_frame_size < 4096 )
4118 		info->max_frame_size = 4096;
4119 	else if ( info->max_frame_size > 65535 )
4120 		info->max_frame_size = 65535;
4123 		info->hw_version + 1, info->device_name, info->io_base, info->irq_level,
4124 		info->phys_memory_base, info->phys_lcr_base,
4125 	     	info->max_frame_size );
4128 	hdlcdev_init(info);
4148 	struct mgsl_struct *info;
4150 	info = kzalloc(sizeof(struct mgsl_struct),
4153 	if (!info) {
4156 		tty_port_init(&info->port);
4157 		info->port.ops = &mgsl_port_ops;
4158 		info->magic = MGSL_MAGIC;
4159 		INIT_WORK(&info->task, mgsl_bh_handler);
4160 		info->max_frame_size = 4096;
4161 		info->port.close_delay = 5*HZ/10;
4162 		info->port.closing_wait = 30*HZ;
4163 		init_waitqueue_head(&info->status_event_wait_q);
4164 		init_waitqueue_head(&info->event_wait_q);
4165 		spin_lock_init(&info->irq_spinlock);
4166 		spin_lock_init(&info->netlock);
4167 		memcpy(&info->params,&default_params,sizeof(MGSL_PARAMS));
4168 		info->idle_mode = HDLC_TXIDLE_FLAGS;
4169 		info->num_tx_dma_buffers = 1;
4170 		info->num_tx_holding_buffers = 0;
4173 	return info;
4244 	struct mgsl_struct *info;
4257 	info = mgsl_device_list;
4258 	while(info) {
4260 		hdlcdev_exit(info);
4262 		mgsl_release_resources(info);
4263 		tmp = info;
4264 		info = info->next_device;
4321  *    info   pointer to device information structure
4328 static void usc_RTCmd( struct mgsl_struct *info, u16 Cmd )
4333 	outw( Cmd + info->loopback_bits, info->io_base + CCAR );
4336 	inw( info->io_base + CCAR );
4347  *    info   pointer to device information structure
4354 static void usc_DmaCmd( struct mgsl_struct *info, u16 Cmd )
4357 	outw( Cmd + info->mbre_bit, info->io_base );
4360 	inw( info->io_base );
4371  *    info      pointer to device info structure
4380 static void usc_OutDmaReg( struct mgsl_struct *info, u16 RegAddr, u16 RegValue )
4385 	outw( RegAddr + info->mbre_bit, info->io_base );
4386 	outw( RegValue, info->io_base );
4389 	inw( info->io_base );
4400  *    info     pointer to device info structure
4408 static u16 usc_InDmaReg( struct mgsl_struct *info, u16 RegAddr )
4413 	outw( RegAddr + info->mbre_bit, info->io_base );
4414 	return inw( info->io_base );
4426  *    info      pointer to device info structure
4435 static void usc_OutReg( struct mgsl_struct *info, u16 RegAddr, u16 RegValue )
4437 	outw( RegAddr + info->loopback_bits, info->io_base + CCAR );
4438 	outw( RegValue, info->io_base + CCAR );
4441 	inw( info->io_base + CCAR );
4452  *    info       pointer to device extension
4459 static u16 usc_InReg( struct mgsl_struct *info, u16 RegAddr )
4461 	outw( RegAddr + info->loopback_bits, info->io_base + CCAR );
4462 	return inw( info->io_base + CCAR );
4470  * Arguments:		info    pointer to device instance data
4473 static void usc_set_sdlc_mode( struct mgsl_struct *info )
4487 	usc_OutReg(info,TMCR,0x1f);
4488 	RegValue=usc_InReg(info,TMDR);
4491  	if ( info->params.flags & HDLC_FLAG_HDLC_LOOPMODE )
4525 		if (info->params.mode == MGSL_MODE_RAW) {
4528 			usc_OutReg( info, IOCR,		/* Set IOCR DCD is RxSync Detect Input */
4529 				(unsigned short)((usc_InReg(info, IOCR) & ~(BIT13|BIT12)) | BIT12));
4549 		if ( info->params.flags & HDLC_FLAG_UNDERRUN_ABORT15 )
4551 		else if ( info->params.flags & HDLC_FLAG_UNDERRUN_FLAG )
4553 		else if ( info->params.flags & HDLC_FLAG_UNDERRUN_CRC )
4557 		if ( info->params.preamble != HDLC_PREAMBLE_PATTERN_NONE )
4561 	if ( info->params.mode == MGSL_MODE_HDLC &&
4562 		(info->params.flags & HDLC_FLAG_SHARE_ZERO) )
4565 	if ( info->params.addr_filter != 0xff )
4568 		usc_OutReg( info, RSR, info->params.addr_filter );
4572 	usc_OutReg( info, CMR, RegValue );
4573 	info->cmr_value = RegValue;
4592 	switch ( info->params.encoding ) {
4602 	if ( (info->params.crc_type & HDLC_CRC_MASK) == HDLC_CRC_16_CCITT )
4604 	else if ( (info->params.crc_type & HDLC_CRC_MASK) == HDLC_CRC_32_CCITT )
4607 	usc_OutReg( info, RMR, RegValue );
4616 	usc_OutReg( info, RCLR, RCLRVALUE );
4618 	usc_RCmd( info, RCmd_SelectRicrdma_level );
4638 	RegValue = usc_InReg( info, RICR ) & 0xc0;
4640 	usc_OutReg( info, RICR, (u16)(0x030a | RegValue) );
4644 	usc_UnlatchRxstatusBits( info, RXSTATUS_ALL );
4645 	usc_ClearIrqPendingBits( info, RECEIVE_STATUS );
4664 	switch ( info->params.encoding ) {
4674 	if ( (info->params.crc_type & HDLC_CRC_MASK) == HDLC_CRC_16_CCITT )
4676 	else if ( (info->params.crc_type & HDLC_CRC_MASK) == HDLC_CRC_32_CCITT )
4679 	usc_OutReg( info, TMR, RegValue );
4681 	usc_set_txidle( info );
4684 	usc_TCmd( info, TCmd_SelectTicrdma_level );
4701 	usc_OutReg( info, TICR, 0x0736 );
4703 	usc_UnlatchTxstatusBits( info, TXSTATUS_ALL );
4704 	usc_ClearIrqPendingBits( info, TRANSMIT_STATUS );
4723 	info->tcsr_value = 0;
4726 		info->tcsr_value |= TCSR_UNDERWAIT;
4728 	usc_OutReg( info, TCSR, info->tcsr_value );
4745 	if ( info->params.flags & HDLC_FLAG_RXC_DPLL )
4747 	else if ( info->params.flags & HDLC_FLAG_RXC_BRG )
4749  	else if ( info->params.flags & HDLC_FLAG_RXC_TXCPIN)
4754 	if ( info->params.flags & HDLC_FLAG_TXC_DPLL )
4756 	else if ( info->params.flags & HDLC_FLAG_TXC_BRG )
4758  	else if ( info->params.flags & HDLC_FLAG_TXC_RXCPIN)
4763 	usc_OutReg( info, CMCR, RegValue );
4783 	if ( info->params.flags & (HDLC_FLAG_RXC_DPLL | HDLC_FLAG_TXC_DPLL) ) {
4793 		if ( info->params.flags & HDLC_FLAG_DPLL_DIV16 ) {
4797 		else if ( info->params.flags & HDLC_FLAG_DPLL_DIV8 ) {
4818  		if ( info->params.clock_speed )
4820 			Tc = (u16)((XtalSpeed/DpllDivisor)/info->params.clock_speed);
4821 			if ( !((((XtalSpeed/DpllDivisor) % info->params.clock_speed) * 2)
4822 			       / info->params.clock_speed) )
4830 		usc_OutReg( info, TC1R, Tc );
4834 		switch ( info->params.encoding ) {
4846 	usc_OutReg( info, HCR, RegValue );
4867 	usc_OutReg( info, CCSR, 0x1020 );
4870 	if ( info->params.flags & HDLC_FLAG_AUTO_CTS ) {
4871 		usc_OutReg( info, SICR,
4872 			    (u16)(usc_InReg(info,SICR) | SICR_CTS_INACTIVE) );
4877 	usc_EnableMasterIrqBit( info );
4879 	usc_ClearIrqPendingBits( info, RECEIVE_STATUS | RECEIVE_DATA |
4883 	usc_OutReg(info, SICR, (u16)(usc_InReg(info,SICR) | BIT3));
4884 	usc_EnableInterrupts(info, MISC);
4886 	info->mbre_bit = 0;
4887 	outw( 0, info->io_base ); 			/* clear Master Bus Enable (DCAR) */
4888 	usc_DmaCmd( info, DmaCmd_ResetAllChannels );	/* disable both DMA channels */
4889 	info->mbre_bit = BIT8;
4890 	outw( BIT8, info->io_base );			/* set Master Bus Enable (DCAR) */
4915 	usc_OutDmaReg( info, DCR, 0xa00b );
4930 	usc_OutDmaReg( info, RDMR, 0xf200 );
4946 	usc_OutDmaReg( info, TDMR, 0xf200 );
4962 	usc_OutDmaReg( info, DICR, 0x9000 );
4964 	usc_InDmaReg( info, RDMR );		/* clear pending receive DMA IRQ bits */
4965 	usc_InDmaReg( info, TDMR );		/* clear pending transmit DMA IRQ bits */
4966 	usc_OutDmaReg( info, CDIR, 0x0303 );	/* clear IUS and Pending for Tx and Rx */
4984 	switch ( info->params.preamble_length ) {
4990 	switch ( info->params.preamble ) {
4997 	usc_OutReg( info, CCR, RegValue );
5008 	usc_OutDmaReg( info, BDCR, 0x0000 );
5010 	usc_stop_transmitter(info);
5011 	usc_stop_receiver(info);
5021  * Arguments:		info	pointer to device instance data
5025 static void usc_enable_loopback(struct mgsl_struct *info, int enable)
5029 		usc_OutReg(info,IOCR,usc_InReg(info,IOCR) | (BIT7 | BIT6));
5044 		usc_OutReg( info, CMCR, 0x0f64 );
5048 		if (info->params.clock_speed) {
5049 			usc_OutReg(info, TC0R, (u16)((11059200/info->params.clock_speed)-1));
5051 			usc_OutReg(info, TC0R, (u16)8);
5055 		usc_OutReg( info, HCR, (u16)((usc_InReg( info, HCR ) & ~BIT1) | BIT0) );
5058 		usc_OutReg(info, IOCR, (u16)((usc_InReg(info, IOCR) & 0xfff8) | 0x0004));
5061 		info->loopback_bits = 0x300;
5062 		outw( 0x0300, info->io_base + CCAR );
5065 		usc_OutReg(info,IOCR,usc_InReg(info,IOCR) & ~(BIT7 | BIT6));
5068 		info->loopback_bits = 0;
5069 		outw( 0,info->io_base + CCAR );
5080  *	info		pointer to device extension
5086 static void usc_enable_aux_clock( struct mgsl_struct *info, u32 data_rate )
5107 		usc_OutReg( info, TC0R, Tc );
5115 		usc_OutReg( info, HCR, (u16)((usc_InReg( info, HCR ) & ~BIT1) | BIT0) );
5118 		usc_OutReg( info, IOCR, (u16)((usc_InReg(info, IOCR) & 0xfff8) | 0x0004) );
5121 		usc_OutReg( info, HCR, (u16)(usc_InReg( info, HCR ) & ~BIT0) );
5136  *	info		pointer to device extension
5140 static void usc_process_rxoverrun_sync( struct mgsl_struct *info )
5149 	DMABUFFERENTRY *buffer_list = info->rx_buffer_list;
5152 	usc_DmaCmd( info, DmaCmd_PauseRxChannel );
5153 	usc_RCmd( info, RCmd_EnterHuntmode );
5154 	usc_RTCmd( info, RTCmd_PurgeRxFifo );
5159 	frame_start_index = start_index = end_index = info->current_rx_buffer;
5192   		if ( end_index == info->rx_buffer_count )
5200 			mgsl_reset_rx_dma_buffers( info );
5221 			*((unsigned long *)&(info->rx_buffer_list[start_index++].count)) = DMABUFFERSIZE;
5224   			if ( start_index == info->rx_buffer_count )
5234 		usc_UnlatchRxstatusBits(info,RXSTATUS_ALL);
5235 		usc_ClearIrqPendingBits(info, RECEIVE_DATA|RECEIVE_STATUS);
5236 		usc_UnlatchRxstatusBits(info, RECEIVE_DATA|RECEIVE_STATUS);
5238 		usc_EnableReceiver(info,DISABLE_UNCONDITIONAL);
5241 		usc_OutReg( info, CCSR, (u16)(usc_InReg(info,CCSR) | BIT13) );
5244 		phys_addr = info->rx_buffer_list[frame_start_index].phys_entry;
5245 		usc_OutDmaReg( info, NRARL, (u16)phys_addr );
5246 		usc_OutDmaReg( info, NRARU, (u16)(phys_addr >> 16) );
5248 		usc_UnlatchRxstatusBits( info, RXSTATUS_ALL );
5249 		usc_ClearIrqPendingBits( info, RECEIVE_DATA | RECEIVE_STATUS );
5250 		usc_EnableInterrupts( info, RECEIVE_STATUS );
5255 		usc_OutDmaReg( info, RDIAR, BIT3 | BIT2 );
5256 		usc_OutDmaReg( info, DICR, (u16)(usc_InDmaReg(info,DICR) | BIT1) );
5257 		usc_DmaCmd( info, DmaCmd_InitRxChannel );
5258 		if ( info->params.flags & HDLC_FLAG_AUTO_DCD )
5259 			usc_EnableReceiver(info,ENABLE_AUTO_DCD);
5261 			usc_EnableReceiver(info,ENABLE_UNCONDITIONAL);
5266 		usc_OutReg( info, CCSR, (u16)(usc_InReg(info,CCSR) | BIT13) );
5267 		usc_RTCmd( info, RTCmd_PurgeRxFifo );
5276  * Arguments:		info	pointer to device instance data
5279 static void usc_stop_receiver( struct mgsl_struct *info )
5283 			 __FILE__,__LINE__, info->device_name );
5287 	usc_DmaCmd( info, DmaCmd_ResetRxChannel );
5289 	usc_UnlatchRxstatusBits( info, RXSTATUS_ALL );
5290 	usc_ClearIrqPendingBits( info, RECEIVE_DATA | RECEIVE_STATUS );
5291 	usc_DisableInterrupts( info, RECEIVE_DATA | RECEIVE_STATUS );
5293 	usc_EnableReceiver(info,DISABLE_UNCONDITIONAL);
5296 	usc_OutReg( info, CCSR, (u16)(usc_InReg(info,CCSR) | BIT13) );
5297 	usc_RTCmd( info, RTCmd_PurgeRxFifo );
5299 	info->rx_enabled = false;
5300 	info->rx_overflow = false;
5301 	info->rx_rcc_underrun = false;
5309  * Arguments:		info	pointer to device instance data
5312 static void usc_start_receiver( struct mgsl_struct *info )
5318 			 __FILE__,__LINE__, info->device_name );
5320 	mgsl_reset_rx_dma_buffers( info );
5321 	usc_stop_receiver( info );
5323 	usc_OutReg( info, CCSR, (u16)(usc_InReg(info,CCSR) | BIT13) );
5324 	usc_RTCmd( info, RTCmd_PurgeRxFifo );
5326 	if ( info->params.mode == MGSL_MODE_HDLC ||
5327 		info->params.mode == MGSL_MODE_RAW ) {
5333 		phys_addr = info->rx_buffer_list[0].phys_entry;
5334 		usc_OutDmaReg( info, NRARL, (u16)phys_addr );
5335 		usc_OutDmaReg( info, NRARU, (u16)(phys_addr >> 16) );
5337 		usc_UnlatchRxstatusBits( info, RXSTATUS_ALL );
5338 		usc_ClearIrqPendingBits( info, RECEIVE_DATA | RECEIVE_STATUS );
5339 		usc_EnableInterrupts( info, RECEIVE_STATUS );
5344 		usc_OutDmaReg( info, RDIAR, BIT3 | BIT2 );
5345 		usc_OutDmaReg( info, DICR, (u16)(usc_InDmaReg(info,DICR) | BIT1) );
5346 		usc_DmaCmd( info, DmaCmd_InitRxChannel );
5347 		if ( info->params.flags & HDLC_FLAG_AUTO_DCD )
5348 			usc_EnableReceiver(info,ENABLE_AUTO_DCD);
5350 			usc_EnableReceiver(info,ENABLE_UNCONDITIONAL);
5352 		usc_UnlatchRxstatusBits(info, RXSTATUS_ALL);
5353 		usc_ClearIrqPendingBits(info, RECEIVE_DATA | RECEIVE_STATUS);
5354 		usc_EnableInterrupts(info, RECEIVE_DATA);
5356 		usc_RTCmd( info, RTCmd_PurgeRxFifo );
5357 		usc_RCmd( info, RCmd_EnterHuntmode );
5359 		usc_EnableReceiver(info,ENABLE_UNCONDITIONAL);
5362 	usc_OutReg( info, CCSR, 0x1020 );
5364 	info->rx_enabled = true;
5373  * Arguments:		info	pointer to device instance data
5376 static void usc_start_transmitter( struct mgsl_struct *info )
5383 			 __FILE__,__LINE__, info->device_name );
5385 	if ( info->xmit_cnt ) {
5391 		info->drop_rts_on_tx_done = false;
5393 		if ( info->params.flags & HDLC_FLAG_AUTO_RTS ) {
5394 			usc_get_serial_signals( info );
5395 			if ( !(info->serial_signals & SerialSignal_RTS) ) {
5396 				info->serial_signals |= SerialSignal_RTS;
5397 				usc_set_serial_signals( info );
5398 				info->drop_rts_on_tx_done = true;
5403 		if ( info->params.mode == MGSL_MODE_ASYNC ) {
5404 			if ( !info->tx_active ) {
5405 				usc_UnlatchTxstatusBits(info, TXSTATUS_ALL);
5406 				usc_ClearIrqPendingBits(info, TRANSMIT_STATUS + TRANSMIT_DATA);
5407 				usc_EnableInterrupts(info, TRANSMIT_DATA);
5408 				usc_load_txfifo(info);
5412 			usc_DmaCmd( info, DmaCmd_ResetTxChannel );
5417 			FrameSize = info->tx_buffer_list[info->start_tx_dma_buffer].rcc;
5423 	    		if ( info->params.mode == MGSL_MODE_RAW )
5424 				info->tx_buffer_list[info->start_tx_dma_buffer].rcc = 0;
5428 			usc_OutReg( info, TCLR, (u16)FrameSize );
5430 			usc_RTCmd( info, RTCmd_PurgeTxFifo );
5433 			phys_addr = info->tx_buffer_list[info->start_tx_dma_buffer].phys_entry;
5434 			usc_OutDmaReg( info, NTARL, (u16)phys_addr );
5435 			usc_OutDmaReg( info, NTARU, (u16)(phys_addr >> 16) );
5437 			usc_UnlatchTxstatusBits( info, TXSTATUS_ALL );
5438 			usc_ClearIrqPendingBits( info, TRANSMIT_STATUS );
5439 			usc_EnableInterrupts( info, TRANSMIT_STATUS );
5441 			if ( info->params.mode == MGSL_MODE_RAW &&
5442 					info->num_tx_dma_buffers > 1 ) {
5450 			   usc_OutDmaReg( info, TDIAR, BIT2|BIT3 );
5451 			   usc_OutDmaReg( info, DICR, (u16)(usc_InDmaReg(info,DICR) | BIT0) );
5455 			usc_DmaCmd( info, DmaCmd_InitTxChannel );
5457 			usc_TCmd( info, TCmd_SendFrame );
5459 			mod_timer(&info->tx_timer, jiffies +
5462 		info->tx_active = true;
5465 	if ( !info->tx_enabled ) {
5466 		info->tx_enabled = true;
5467 		if ( info->params.flags & HDLC_FLAG_AUTO_CTS )
5468 			usc_EnableTransmitter(info,ENABLE_AUTO_CTS);
5470 			usc_EnableTransmitter(info,ENABLE_UNCONDITIONAL);
5479  * Arguments:		info	pointer to device isntance data
5482 static void usc_stop_transmitter( struct mgsl_struct *info )
5486 			 __FILE__,__LINE__, info->device_name );
5488 	del_timer(&info->tx_timer);	
5490 	usc_UnlatchTxstatusBits( info, TXSTATUS_ALL );
5491 	usc_ClearIrqPendingBits( info, TRANSMIT_STATUS + TRANSMIT_DATA );
5492 	usc_DisableInterrupts( info, TRANSMIT_STATUS + TRANSMIT_DATA );
5494 	usc_EnableTransmitter(info,DISABLE_UNCONDITIONAL);
5495 	usc_DmaCmd( info, DmaCmd_ResetTxChannel );
5496 	usc_RTCmd( info, RTCmd_PurgeTxFifo );
5498 	info->tx_enabled = false;
5499 	info->tx_active = false;
5508  * Arguments:		info	pointer to device extension (instance data)
5511 static void usc_load_txfifo( struct mgsl_struct *info )
5516 	if ( !info->xmit_cnt && !info->x_char )
5520 	usc_TCmd( info, TCmd_SelectTicrTxFifostatus );
5524 	while( (Fifocount = usc_InReg(info, TICR) >> 8) && info->xmit_cnt ) {
5528 		if ( (info->xmit_cnt > 1) && (Fifocount > 1) && !info->x_char ) {
5531 			TwoBytes[0] = info->xmit_buf[info->xmit_tail++];
5532 			info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
5533 			TwoBytes[1] = info->xmit_buf[info->xmit_tail++];
5534 			info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
5536 			outw( *((u16 *)TwoBytes), info->io_base + DATAREG);
5538 			info->xmit_cnt -= 2;
5539 			info->icount.tx += 2;
5543 			outw( (inw( info->io_base + CCAR) & 0x0780) | (TDR+LSBONLY),
5544 				info->io_base + CCAR );
5546 			if (info->x_char) {
5548 				outw( info->x_char,info->io_base + CCAR );
5549 				info->x_char = 0;
5551 				outw( info->xmit_buf[info->xmit_tail++],info->io_base + CCAR );
5552 				info->xmit_tail = info->xmit_tail & (SERIAL_XMIT_SIZE-1);
5553 				info->xmit_cnt--;
5555 			info->icount.tx++;
5565  * Arguments:		info	pointer to device instance data
5568 static void usc_reset( struct mgsl_struct *info )
5576 	volatile u32 *MiscCtrl = (u32 *)(info->lcr_base + 0x50);
5577 	u32 *LCR0BRDR = (u32 *)(info->lcr_base + 0x28);
5579 	info->misc_ctrl_value |= BIT30;
5580 	*MiscCtrl = info->misc_ctrl_value;
5589 	info->misc_ctrl_value &= ~BIT30;
5590 	*MiscCtrl = info->misc_ctrl_value;
5603 	info->mbre_bit = 0;
5604 	info->loopback_bits = 0;
5605 	info->usc_idle_mode = 0;
5624 	outw( 0x000c,info->io_base + SDPIN );
5627 	outw( 0,info->io_base );
5628 	outw( 0,info->io_base + CCAR );
5631 	usc_RTCmd( info, RTCmd_SelectLittleEndian );
5648 	usc_OutReg( info, PCR, 0xf0f5 );
5665 	usc_OutReg( info, IOCR, 0x0004 );
5673  * Arguments:		info		pointer to device instance data
5676 static void usc_set_async_mode( struct mgsl_struct *info )
5681 	usc_DisableMasterIrqBit( info );
5683 	outw( 0, info->io_base ); 			/* clear Master Bus Enable (DCAR) */
5684 	usc_DmaCmd( info, DmaCmd_ResetAllChannels );	/* disable both DMA channels */
5686 	usc_loopback_frame( info );
5701 	if ( info->params.stop_bits != 1 )
5703 	usc_OutReg( info, CMR, RegValue );
5720 	if ( info->params.data_bits != 8 )
5723 	if ( info->params.parity != ASYNC_PARITY_NONE ) {
5725 		if ( info->params.parity != ASYNC_PARITY_ODD )
5729 	usc_OutReg( info, RMR, RegValue );
5734 	usc_RCmd( info, RCmd_SelectRicrIntLevel );
5757 	usc_OutReg( info, RICR, 0x0000 );
5759 	usc_UnlatchRxstatusBits( info, RXSTATUS_ALL );
5760 	usc_ClearIrqPendingBits( info, RECEIVE_STATUS );
5777 	if ( info->params.data_bits != 8 )
5780 	if ( info->params.parity != ASYNC_PARITY_NONE ) {
5782 		if ( info->params.parity != ASYNC_PARITY_ODD )
5786 	usc_OutReg( info, TMR, RegValue );
5788 	usc_set_txidle( info );
5793 	usc_TCmd( info, TCmd_SelectTicrIntLevel );
5811 	usc_OutReg( info, TICR, 0x1f40 );
5813 	usc_UnlatchTxstatusBits( info, TXSTATUS_ALL );
5814 	usc_ClearIrqPendingBits( info, TRANSMIT_STATUS );
5816 	usc_enable_async_clock( info, info->params.data_rate );
5837 	usc_OutReg( info, CCSR, 0x0020 );
5839 	usc_DisableInterrupts( info, TRANSMIT_STATUS + TRANSMIT_DATA +
5842 	usc_ClearIrqPendingBits( info, TRANSMIT_STATUS + TRANSMIT_DATA +
5845 	usc_EnableMasterIrqBit( info );
5847 	if (info->params.loopback) {
5848 		info->loopback_bits = 0x300;
5849 		outw(0x0300, info->io_base + CCAR);
5858  *	clear any 'stale' status info left over from running in	async mode.
5865  * Arguments:		info		pointer to device instance data
5868 static void usc_loopback_frame( struct mgsl_struct *info )
5871 	unsigned long oldmode = info->params.mode;
5873 	info->params.mode = MGSL_MODE_HDLC;
5875 	usc_DisableMasterIrqBit( info );
5877 	usc_set_sdlc_mode( info );
5878 	usc_enable_loopback( info, 1 );
5881 	usc_OutReg( info, TC0R, 0 );
5897 	usc_OutReg( info, CCR, 0x0100 );
5900 	usc_RTCmd( info, RTCmd_PurgeRxFifo );
5901 	usc_EnableReceiver(info,ENABLE_UNCONDITIONAL);
5906 	usc_OutReg( info, TCLR, 2 );
5907 	usc_RTCmd( info, RTCmd_PurgeTxFifo );
5910 	usc_UnlatchTxstatusBits(info,TXSTATUS_ALL);
5911 	outw(0,info->io_base + DATAREG);
5914 	usc_TCmd( info, TCmd_SendFrame );
5915 	usc_EnableTransmitter(info,ENABLE_UNCONDITIONAL);
5919 		if (usc_InReg( info, RCSR ) & (BIT8 | BIT4 | BIT3 | BIT1))
5923 	usc_enable_loopback(info, 0);
5925 	usc_EnableMasterIrqBit(info);
5927 	info->params.mode = oldmode;
5933  * Arguments:		info	pointer to adapter info structure
5936 static void usc_set_sync_mode( struct mgsl_struct *info )
5938 	usc_loopback_frame( info );
5939 	usc_set_sdlc_mode( info );
5941 	usc_enable_aux_clock(info, info->params.clock_speed);
5943 	if (info->params.loopback)
5944 		usc_enable_loopback(info,1);
5950  * Arguments:		info	pointer to device instance data
5953 static void usc_set_txidle( struct mgsl_struct *info )
5959 	switch( info->idle_mode ){
5969 	info->usc_idle_mode = usc_idle_mode;
5970 	//usc_OutReg(info, TCSR, usc_idle_mode);
5971 	info->tcsr_value &= ~IDLEMODE_MASK;	/* clear idle mode bits */
5972 	info->tcsr_value += usc_idle_mode;
5973 	usc_OutReg(info, TCSR, info->tcsr_value);
5982 	if ( info->params.mode == MGSL_MODE_RAW ) {
5984 		switch( info->idle_mode ) {
6004 		usc_SetTransmitSyncChars(info,syncpat,syncpat);
6013  * Arguments:		info	pointer to device instance data
6016 static void usc_get_serial_signals( struct mgsl_struct *info )
6021 	info->serial_signals &= SerialSignal_RTS | SerialSignal_DTR;
6026 	status = usc_InReg( info, MISR );
6031 		info->serial_signals |= SerialSignal_CTS;
6034 		info->serial_signals |= SerialSignal_DCD;
6037 		info->serial_signals |= SerialSignal_RI;
6040 		info->serial_signals |= SerialSignal_DSR;
6049  * Arguments:		info	pointer to device instance data
6052 static void usc_set_serial_signals( struct mgsl_struct *info )
6055 	unsigned char V24Out = info->serial_signals;
6059 	Control = usc_InReg( info, PCR );
6071 	usc_OutReg( info, PCR, Control );
6079  * Arguments:		info		pointer to device instance data
6084 static void usc_enable_async_clock( struct mgsl_struct *info, u32 data_rate )
6101 		usc_OutReg( info, CMCR, 0x0f64 );
6110 		usc_OutReg( info, TC0R, (u16)((691200/data_rate) - 1) );
6118 		usc_OutReg( info, HCR,
6119 			    (u16)((usc_InReg( info, HCR ) & ~BIT1) | BIT0) );
6124 		usc_OutReg( info, IOCR,
6125 			    (u16)((usc_InReg(info, IOCR) & 0xfff8) | 0x0004) );
6128 		usc_OutReg( info, HCR, (u16)(usc_InReg( info, HCR ) & ~BIT0) );
6187  * Arguments:		info	pointer to device instance data
6190 static void mgsl_reset_tx_dma_buffers( struct mgsl_struct *info )
6194 	for ( i = 0; i < info->tx_buffer_count; i++ ) {
6195 		*((unsigned long *)&(info->tx_buffer_list[i].count)) = 0;
6198 	info->current_tx_buffer = 0;
6199 	info->start_tx_dma_buffer = 0;
6200 	info->tx_dma_buffers_used = 0;
6202 	info->get_tx_holding_index = 0;
6203 	info->put_tx_holding_index = 0;
6204 	info->tx_holding_count = 0;
6213  * Arguments:		info	pointer to device instance data
6216 static int num_free_tx_dma_buffers(struct mgsl_struct *info)
6218 	return info->tx_buffer_count - info->tx_dma_buffers_used;
6228  * Arguments:		info	pointer to device instance data
6231 static void mgsl_reset_rx_dma_buffers( struct mgsl_struct *info )
6235 	for ( i = 0; i < info->rx_buffer_count; i++ ) {
6236 		*((unsigned long *)&(info->rx_buffer_list[i].count)) = DMABUFFERSIZE;
6237 //		info->rx_buffer_list[i].count = DMABUFFERSIZE;
6238 //		info->rx_buffer_list[i].status = 0;
6241 	info->current_rx_buffer = 0;
6253  * 	info			pointer to device instance data
6259 static void mgsl_free_rx_frame_buffers( struct mgsl_struct *info, unsigned int StartIndex, unsigned int EndIndex )
6271 		pBufEntry = &(info->rx_buffer_list[Index]);
6285 		if ( Index == info->rx_buffer_count )
6290 	info->current_rx_buffer = Index;
6299  * Arguments:	 	info	pointer to device extension
6302 static bool mgsl_get_rx_frame(struct mgsl_struct *info)
6310 	struct tty_struct *tty = info->port.tty;
6320 	StartIndex = EndIndex = info->current_rx_buffer;
6322 	while( !info->rx_buffer_list[EndIndex].status ) {
6330 		if ( info->rx_buffer_list[EndIndex].count )
6335 		if ( EndIndex == info->rx_buffer_count )
6345 			if ( info->rx_enabled ){
6346 				spin_lock_irqsave(&info->irq_spinlock,flags);
6347 				usc_start_receiver(info);
6348 				spin_unlock_irqrestore(&info->irq_spinlock,flags);
6357 	status = info->rx_buffer_list[EndIndex].status;
6362 			info->icount.rxshort++;
6364 			info->icount.rxabort++;
6366 			info->icount.rxover++;
6368 			info->icount.rxcrc++;
6369 			if ( info->params.crc_type & HDLC_CRC_RETURN_EX )
6375 			info->netdev->stats.rx_errors++;
6376 			info->netdev->stats.rx_frame_errors++;
6389 		framesize = RCLRVALUE - info->rx_buffer_list[EndIndex].rcc;
6392 		if ( info->params.crc_type == HDLC_CRC_16_CCITT )
6394 		else if ( info->params.crc_type == HDLC_CRC_32_CCITT )
6400 			__FILE__,__LINE__,info->device_name,status,framesize);
6403 		mgsl_trace_block(info,info->rx_buffer_list[StartIndex].virt_addr,
6407 		if ( ( (info->params.crc_type & HDLC_CRC_RETURN_EX) &&
6408 				((framesize+1) > info->max_frame_size) ) ||
6409 			(framesize > info->max_frame_size) )
6410 			info->icount.rxlong++;
6415 			unsigned char *ptmp = info->intermediate_rxbuffer;
6418 				info->icount.rxok++;
6427 				pBufEntry = &(info->rx_buffer_list[index]);
6432 				if ( ++index == info->rx_buffer_count )
6436 			if ( info->params.crc_type & HDLC_CRC_RETURN_EX ) {
6444 						__FILE__,__LINE__,info->device_name,
6449 			if (info->netcount)
6450 				hdlcdev_rx(info,info->intermediate_rxbuffer,framesize);
6453 				ldisc_receive_buf(tty, info->intermediate_rxbuffer, info->flag_buf, framesize);
6457 	mgsl_free_rx_frame_buffers( info, StartIndex, EndIndex );
6463 	if ( info->rx_enabled && info->rx_overflow ) {
6469 		if ( !info->rx_buffer_list[EndIndex].status &&
6470 			info->rx_buffer_list[EndIndex].count ) {
6471 			spin_lock_irqsave(&info->irq_spinlock,flags);
6472 			usc_start_receiver(info);
6473 			spin_unlock_irqrestore(&info->irq_spinlock,flags);
6497  * Arguments:	 	info	pointer to device extension
6500 static bool mgsl_get_raw_rx_frame(struct mgsl_struct *info)
6508 	struct tty_struct *tty = info->port.tty;
6525 	CurrentIndex = NextIndex = info->current_rx_buffer;
6527 	if ( NextIndex == info->rx_buffer_count )
6530 	if ( info->rx_buffer_list[CurrentIndex].status != 0 ||
6531 		(info->rx_buffer_list[CurrentIndex].count == 0 &&
6532 			info->rx_buffer_list[NextIndex].count == 0)) {
6540 		status = info->rx_buffer_list[CurrentIndex].status;
6545 				info->icount.rxshort++;
6547 				info->icount.rxabort++;
6549 				info->icount.rxover++;
6551 				info->icount.rxcrc++;
6589 				if ( info->rx_buffer_list[CurrentIndex].rcc )
6590 					framesize = RCLRVALUE - info->rx_buffer_list[CurrentIndex].rcc;
6611 				__FILE__,__LINE__,info->device_name,status,framesize);
6614 			mgsl_trace_block(info,info->rx_buffer_list[CurrentIndex].virt_addr,
6621 			pBufEntry = &(info->rx_buffer_list[CurrentIndex]);
6622 			memcpy( info->intermediate_rxbuffer, pBufEntry->virt_addr, framesize);
6623 			info->icount.rxok++;
6625 			ldisc_receive_buf(tty, info->intermediate_rxbuffer, info->flag_buf, framesize);
6629 		mgsl_free_rx_frame_buffers( info, CurrentIndex, CurrentIndex );
6635 	if ( info->rx_enabled && info->rx_overflow ) {
6641 		if ( !info->rx_buffer_list[CurrentIndex].status &&
6642 			info->rx_buffer_list[CurrentIndex].count ) {
6643 			spin_lock_irqsave(&info->irq_spinlock,flags);
6644 			usc_start_receiver(info);
6645 			spin_unlock_irqrestore(&info->irq_spinlock,flags);
6659  * 	info		pointer to device extension
6665 static void mgsl_load_tx_dma_buffer(struct mgsl_struct *info,
6673 		mgsl_trace_block(info,Buffer, min_t(int, BufferSize, DMABUFFERSIZE), 1);
6675 	if (info->params.flags & HDLC_FLAG_HDLC_LOOPMODE) {
6679 	 	info->cmr_value |= BIT13;
6686 	i = info->current_tx_buffer;
6687 	info->start_tx_dma_buffer = i;
6692 	info->tx_buffer_list[i].status = info->cmr_value & 0xf000;
6693 	info->tx_buffer_list[i].rcc    = BufferSize;
6694 	info->tx_buffer_list[i].count  = BufferSize;
6701 		pBufEntry = &info->tx_buffer_list[i++];
6703 		if ( i == info->tx_buffer_count )
6723 		++info->tx_dma_buffers_used;
6727 	info->current_tx_buffer = i;
6736  * Arguments:		info	pointer to device instance data
6739 static bool mgsl_register_test( struct mgsl_struct *info )
6748 	spin_lock_irqsave(&info->irq_spinlock,flags);
6749 	usc_reset(info);
6753 	if ( (usc_InReg( info, SICR ) != 0) ||
6754 		  (usc_InReg( info, IVR  ) != 0) ||
6755 		  (usc_InDmaReg( info, DIVR ) != 0) ){
6764 			usc_OutReg( info, TC0R, BitPatterns[i] );
6765 			usc_OutReg( info, TC1R, BitPatterns[(i+1)%Patterncount] );
6766 			usc_OutReg( info, TCLR, BitPatterns[(i+2)%Patterncount] );
6767 			usc_OutReg( info, RCLR, BitPatterns[(i+3)%Patterncount] );
6768 			usc_OutReg( info, RSR,  BitPatterns[(i+4)%Patterncount] );
6769 			usc_OutDmaReg( info, TBCR, BitPatterns[(i+5)%Patterncount] );
6771 			if ( (usc_InReg( info, TC0R ) != BitPatterns[i]) ||
6772 				  (usc_InReg( info, TC1R ) != BitPatterns[(i+1)%Patterncount]) ||
6773 				  (usc_InReg( info, TCLR ) != BitPatterns[(i+2)%Patterncount]) ||
6774 				  (usc_InReg( info, RCLR ) != BitPatterns[(i+3)%Patterncount]) ||
6775 				  (usc_InReg( info, RSR )  != BitPatterns[(i+4)%Patterncount]) ||
6776 				  (usc_InDmaReg( info, TBCR ) != BitPatterns[(i+5)%Patterncount]) ){
6783 	usc_reset(info);
6784 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
6792  * Arguments:		info	pointer to device instance data
6795 static bool mgsl_irq_test( struct mgsl_struct *info )
6800 	spin_lock_irqsave(&info->irq_spinlock,flags);
6801 	usc_reset(info);
6808 	info->irq_occurred = false;
6814 	usc_OutReg( info, PCR, (unsigned short)((usc_InReg(info, PCR) | BIT13) & ~BIT12) );
6816 	usc_EnableMasterIrqBit(info);
6817 	usc_EnableInterrupts(info, IO_PIN);
6818 	usc_ClearIrqPendingBits(info, IO_PIN);
6820 	usc_UnlatchIostatusBits(info, MISCSTATUS_TXC_LATCHED);
6821 	usc_EnableStatusIrqs(info, SICR_TXC_ACTIVE + SICR_TXC_INACTIVE);
6823 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
6826 	while( EndTime-- && !info->irq_occurred ) {
6830 	spin_lock_irqsave(&info->irq_spinlock,flags);
6831 	usc_reset(info);
6832 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
6834 	return info->irq_occurred;
6844  * Arguments:		info	pointer to device instance data
6847 static bool mgsl_dma_test( struct mgsl_struct *info )
6861 	memcpy(&tmp_params,&info->params,sizeof(MGSL_PARAMS));
6863 	memcpy(&info->params,&default_params,sizeof(MGSL_PARAMS));
6867 	spin_lock_irqsave(&info->irq_spinlock,flags);
6871 	usc_reset(info);
6872 	usc_set_sdlc_mode(info);
6873 	usc_enable_loopback(info,1);
6895 	usc_OutDmaReg( info, RDMR, 0xe200 );
6897 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
6907 	info->tx_buffer_list[0].count  = FrameSize;
6908 	info->tx_buffer_list[0].rcc    = FrameSize;
6909 	info->tx_buffer_list[0].status = 0x4000;
6913 	TmpPtr = info->tx_buffer_list[0].virt_addr;
6920 	info->rx_buffer_list[0].status = 0;
6921 	info->rx_buffer_list[0].count = FrameSize + 4;
6925 	memset( info->rx_buffer_list[0].virt_addr, 0, FrameSize + 4 );
6930 	info->tx_buffer_list[1].count = 0;
6931 	info->rx_buffer_list[1].count = 0;
6938 	spin_lock_irqsave(&info->irq_spinlock,flags);
6941 	usc_RTCmd( info, RTCmd_PurgeRxFifo );
6944 	phys_addr = info->rx_buffer_list[0].phys_entry;
6945 	usc_OutDmaReg( info, NRARL, (unsigned short)phys_addr );
6946 	usc_OutDmaReg( info, NRARU, (unsigned short)(phys_addr >> 16) );
6949 	usc_InDmaReg( info, RDMR );
6950 	usc_DmaCmd( info, DmaCmd_InitRxChannel );
6953 	usc_OutReg( info, RMR, (unsigned short)((usc_InReg(info, RMR) & 0xfffc) | 0x0002) );
6955 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
6971 		spin_lock_irqsave(&info->irq_spinlock,flags);
6972 		status = usc_InDmaReg( info, RDMR );
6973 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
6988 	spin_lock_irqsave(&info->irq_spinlock,flags);
6993 	usc_OutReg( info, TCLR, (unsigned short)info->tx_buffer_list[0].count );
6994 	usc_RTCmd( info, RTCmd_PurgeTxFifo );
6998 	phys_addr = info->tx_buffer_list[0].phys_entry;
6999 	usc_OutDmaReg( info, NTARL, (unsigned short)phys_addr );
7000 	usc_OutDmaReg( info, NTARU, (unsigned short)(phys_addr >> 16) );
7004 	usc_OutReg( info, TCSR, (unsigned short)(( usc_InReg(info, TCSR) & 0x0f00) | 0xfa) );
7005 	usc_DmaCmd( info, DmaCmd_InitTxChannel );
7009 	usc_TCmd( info, TCmd_SelectTicrTxFifostatus );
7011 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
7027 		spin_lock_irqsave(&info->irq_spinlock,flags);
7028 		FifoLevel = usc_InReg(info, TICR) >> 8;
7029 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
7047 		spin_lock_irqsave(&info->irq_spinlock,flags);
7050 		usc_TCmd( info, TCmd_SendFrame );
7051 		usc_OutReg( info, TMR, (unsigned short)((usc_InReg(info, TMR) & 0xfffc) | 0x0002) );
7053 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
7065 		spin_lock_irqsave(&info->irq_spinlock,flags);
7066 		status = usc_InReg( info, TCSR );
7067 		spin_unlock_irqrestore(&info->irq_spinlock,flags);
7075 			spin_lock_irqsave(&info->irq_spinlock,flags);
7076 			status = usc_InReg( info, TCSR );
7077 			spin_unlock_irqrestore(&info->irq_spinlock,flags);
7095 		status=info->rx_buffer_list[0].status;
7101 			status=info->rx_buffer_list[0].status;
7108 		status = info->rx_buffer_list[0].status;
7114 			if ( memcmp( info->tx_buffer_list[0].virt_addr ,
7115 				info->rx_buffer_list[0].virt_addr, FrameSize ) ){
7121 	spin_lock_irqsave(&info->irq_spinlock,flags);
7122 	usc_reset( info );
7123 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
7126 	memcpy(&info->params,&tmp_params,sizeof(MGSL_PARAMS));
7136  * Arguments:		info	pointer to device instance data
7139 static int mgsl_adapter_test( struct mgsl_struct *info )
7143 			__FILE__,__LINE__,info->device_name );
7145 	if ( !mgsl_register_test( info ) ) {
7146 		info->init_error = DiagStatus_AddressFailure;
7148 			__FILE__,__LINE__,info->device_name, (unsigned short)(info->io_base) );
7152 	if ( !mgsl_irq_test( info ) ) {
7153 		info->init_error = DiagStatus_IrqFailure;
7155 			__FILE__,__LINE__,info->device_name, (unsigned short)(info->irq_level) );
7159 	if ( !mgsl_dma_test( info ) ) {
7160 		info->init_error = DiagStatus_DmaFailure;
7162 			__FILE__,__LINE__,info->device_name, (unsigned short)(info->dma_level) );
7168 			__FILE__,__LINE__,info->device_name );
7178  * Arguments:		info	pointer to device instance data
7181 static bool mgsl_memory_test( struct mgsl_struct *info )
7190 	TestAddr = (unsigned long *)info->memory_base;
7208 	TestAddr = (unsigned long *)info->memory_base;
7216 	memset( info->memory_base, 0, SHARED_MEM_ADDRESS_SIZE );
7281 static void mgsl_trace_block(struct mgsl_struct *info,const char* data, int count, int xmit)
7286 		printk("%s tx data:\n",info->device_name);
7288 		printk("%s rx data:\n",info->device_name);
7323 	struct mgsl_struct *info = from_timer(info, t, tx_timer);
7328 			__FILE__,__LINE__,info->device_name);
7329 	if(info->tx_active &&
7330 	   (info->params.mode == MGSL_MODE_HDLC ||
7331 	    info->params.mode == MGSL_MODE_RAW) ) {
7332 		info->icount.txtimeout++;
7334 	spin_lock_irqsave(&info->irq_spinlock,flags);
7335 	info->tx_active = false;
7336 	info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
7338 	if ( info->params.flags & HDLC_FLAG_HDLC_LOOPMODE )
7339 		usc_loopmode_cancel_transmit( info );
7341 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
7344 	if (info->netcount)
7345 		hdlcdev_tx_done(info);
7348 		mgsl_bh_transmit(info);
7356 static int mgsl_loopmode_send_done( struct mgsl_struct * info )
7360 	spin_lock_irqsave(&info->irq_spinlock,flags);
7361 	if (info->params.flags & HDLC_FLAG_HDLC_LOOPMODE) {
7362 		if (info->tx_active)
7363 			info->loopmode_send_done_requested = true;
7365 			usc_loopmode_send_done(info);
7367 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
7375 static void usc_loopmode_send_done( struct mgsl_struct * info )
7377  	info->loopmode_send_done_requested = false;
7379  	info->cmr_value &= ~BIT13;
7380  	usc_OutReg(info, CMR, info->cmr_value);
7385 static void usc_loopmode_cancel_transmit( struct mgsl_struct * info )
7388  	usc_RTCmd( info, RTCmd_PurgeTxFifo );
7389  	usc_DmaCmd( info, DmaCmd_ResetTxChannel );
7390   	usc_loopmode_send_done( info );
7397 static void usc_loopmode_insert_request( struct mgsl_struct * info )
7399  	info->loopmode_insert_requested = true;
7404  	usc_OutReg( info, RICR, 
7405 		(usc_InReg( info, RICR ) | RXSTATUS_ABORT_RECEIVED ) );
7408 	info->cmr_value |= BIT13;
7409  	usc_OutReg(info, CMR, info->cmr_value);
7414 static int usc_loopmode_active( struct mgsl_struct * info)
7416  	return usc_InReg( info, CCSR ) & BIT7 ? 1 : 0 ;
7434 	struct mgsl_struct *info = dev_to_port(dev);
7439 	if (info->port.count)
7460 	info->params.encoding = new_encoding;
7461 	info->params.crc_type = new_crctype;
7464 	if (info->netcount)
7465 		mgsl_program_hw(info);
7478 	struct mgsl_struct *info = dev_to_port(dev);
7488 	info->xmit_cnt = skb->len;
7489 	mgsl_load_tx_dma_buffer(info, skb->data, skb->len);
7502 	spin_lock_irqsave(&info->irq_spinlock,flags);
7503 	if (!info->tx_active)
7504 	 	usc_start_transmitter(info);
7505 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
7520 	struct mgsl_struct *info = dev_to_port(dev);
7533 	spin_lock_irqsave(&info->netlock, flags);
7534 	if (info->port.count != 0 || info->netcount != 0) {
7536 		spin_unlock_irqrestore(&info->netlock, flags);
7539 	info->netcount=1;
7540 	spin_unlock_irqrestore(&info->netlock, flags);
7543 	if ((rc = startup(info)) != 0) {
7544 		spin_lock_irqsave(&info->netlock, flags);
7545 		info->netcount=0;
7546 		spin_unlock_irqrestore(&info->netlock, flags);
7551 	info->serial_signals |= SerialSignal_RTS | SerialSignal_DTR;
7552 	mgsl_program_hw(info);
7559 	spin_lock_irqsave(&info->irq_spinlock, flags);
7560 	usc_get_serial_signals(info);
7561 	spin_unlock_irqrestore(&info->irq_spinlock, flags);
7562 	if (info->serial_signals & SerialSignal_DCD)
7579 	struct mgsl_struct *info = dev_to_port(dev);
7588 	shutdown(info);
7592 	spin_lock_irqsave(&info->netlock, flags);
7593 	info->netcount=0;
7594 	spin_unlock_irqrestore(&info->netlock, flags);
7612 	struct mgsl_struct *info = dev_to_port(dev);
7619 	if (info->port.count)
7634 		flags = info->params.flags & (HDLC_FLAG_RXC_RXCPIN | HDLC_FLAG_RXC_DPLL |
7648 		new_line.clock_rate = info->params.clock_speed;
7649 		new_line.loopback   = info->params.loopback ? 1:0;
7668 		case CLOCK_DEFAULT:  flags = info->params.flags &
7679 		info->params.flags &= ~(HDLC_FLAG_RXC_RXCPIN | HDLC_FLAG_RXC_DPLL |
7683 		info->params.flags |= flags;
7685 		info->params.loopback = new_line.loopback;
7688 			info->params.clock_speed = new_line.clock_rate;
7690 			info->params.clock_speed = 0;
7693 		if (info->netcount)
7694 			mgsl_program_hw(info);
7709 	struct mgsl_struct *info = dev_to_port(dev);
7718 	spin_lock_irqsave(&info->irq_spinlock,flags);
7719 	usc_stop_transmitter(info);
7720 	spin_unlock_irqrestore(&info->irq_spinlock,flags);
7727  * @info: pointer to device instance information
7731 static void hdlcdev_tx_done(struct mgsl_struct *info)
7733 	if (netif_queue_stopped(info->netdev))
7734 		netif_wake_queue(info->netdev);
7739  * @info: pointer to device instance information
7745 static void hdlcdev_rx(struct mgsl_struct *info, char *buf, int size)
7748 	struct net_device *dev = info->netdev;
7780  * @info: pointer to device instance information
7786 static int hdlcdev_init(struct mgsl_struct *info)
7794 	dev = alloc_hdlcdev(info);
7801 	dev->base_addr = info->io_base;
7802 	dev->irq       = info->irq_level;
7803 	dev->dma       = info->dma_level;
7823 	info->netdev = dev;
7829  * @info: pointer to device instance information
7833 static void hdlcdev_exit(struct mgsl_struct *info)
7835 	unregister_hdlc_device(info->netdev);
7836 	free_netdev(info->netdev);
7837 	info->netdev = NULL;
7846 	struct mgsl_struct *info;
7853 	info = mgsl_allocate_device();
7854 	if (!info) {
7859         /* Copy user configuration info to device instance data */
7861 	info->io_base = pci_resource_start(dev, 2);
7862 	info->irq_level = dev->irq;
7863 	info->phys_memory_base = pci_resource_start(dev, 3);
7869 	info->phys_lcr_base = pci_resource_start(dev, 0);
7870 	info->lcr_offset    = info->phys_lcr_base & (PAGE_SIZE-1);
7871 	info->phys_lcr_base &= ~(PAGE_SIZE-1);
7873 	info->io_addr_size = 8;
7874 	info->irq_flags = IRQF_SHARED;
7878 		info->misc_ctrl_value = 0x007c4080;
7879 		info->hw_version = 1;
7886 		info->misc_ctrl_value = 0x087e4546;
7887 		info->hw_version = 0;
7890 	mgsl_add_device(info);

Indexes created Thu Nov 07 10:32:03 CST 2024