?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r8169: PCI ID for Corega Gigabit network card
[linux-2.6/linux-loongson.git] / drivers / serial / icom.c
bloba3c00a2521497c7c326678853d32179de40e4e96
1 /*
2 * icom.c
3 *
4 * Copyright (C) 2001 IBM Corporation. All rights reserved.
5 *
6 * Serial device driver.
7 *
8 * Based on code from serial.c
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 */
25 #define SERIAL_DO_RESTART
26 #include <linux/module.h>
27 #include <linux/kernel.h>
28 #include <linux/errno.h>
29 #include <linux/signal.h>
30 #include <linux/sched.h>
31 #include <linux/timer.h>
32 #include <linux/interrupt.h>
33 #include <linux/tty.h>
34 #include <linux/termios.h>
35 #include <linux/fs.h>
36 #include <linux/tty_flip.h>
37 #include <linux/serial.h>
38 #include <linux/serial_reg.h>
39 #include <linux/major.h>
40 #include <linux/string.h>
41 #include <linux/fcntl.h>
42 #include <linux/ptrace.h>
43 #include <linux/ioport.h>
44 #include <linux/mm.h>
45 #include <linux/slab.h>
46 #include <linux/init.h>
47 #include <linux/delay.h>
48 #include <linux/pci.h>
49 #include <linux/vmalloc.h>
50 #include <linux/smp.h>
51 #include <linux/smp_lock.h>
52 #include <linux/spinlock.h>
53 #include <linux/kobject.h>
54 #include <linux/firmware.h>
55 #include <linux/bitops.h>
56
57 #include <asm/system.h>
58 #include <asm/io.h>
59 #include <asm/irq.h>
60 #include <asm/uaccess.h>
61
62 #include "icom.h"
63
64 /*#define ICOM_TRACE enable port trace capabilities */
65
66 #define ICOM_DRIVER_NAME "icom"
67 #define ICOM_VERSION_STR "1.3.1"
68 #define NR_PORTS 128
69 #define ICOM_PORT ((struct icom_port *)port)
70 #define to_icom_adapter(d) container_of(d, struct icom_adapter, kobj)
71
72 static const struct pci_device_id icom_pci_table[] = {
73 {
74 .vendor = PCI_VENDOR_ID_IBM,
75 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_1,
76 .subvendor = PCI_ANY_ID,
77 .subdevice = PCI_ANY_ID,
78 .driver_data = ADAPTER_V1,
79 },
80 {
81 .vendor = PCI_VENDOR_ID_IBM,
82 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
83 .subvendor = PCI_VENDOR_ID_IBM,
84 .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_TWO_PORTS_RVX,
85 .driver_data = ADAPTER_V2,
86 },
87 {
88 .vendor = PCI_VENDOR_ID_IBM,
89 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
90 .subvendor = PCI_VENDOR_ID_IBM,
91 .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM,
92 .driver_data = ADAPTER_V2,
93 },
94 {
95 .vendor = PCI_VENDOR_ID_IBM,
96 .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
97 .subvendor = PCI_VENDOR_ID_IBM,
98 .subdevice = PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL,
99 .driver_data = ADAPTER_V2,
100 },
101 {}
102 };
103
104 struct lookup_proc_table start_proc[4] = {
105 {NULL, ICOM_CONTROL_START_A},
106 {NULL, ICOM_CONTROL_START_B},
107 {NULL, ICOM_CONTROL_START_C},
108 {NULL, ICOM_CONTROL_START_D}
109 };
110
111
112 struct lookup_proc_table stop_proc[4] = {
113 {NULL, ICOM_CONTROL_STOP_A},
114 {NULL, ICOM_CONTROL_STOP_B},
115 {NULL, ICOM_CONTROL_STOP_C},
116 {NULL, ICOM_CONTROL_STOP_D}
117 };
118
119 struct lookup_int_table int_mask_tbl[4] = {
120 {NULL, ICOM_INT_MASK_PRC_A},
121 {NULL, ICOM_INT_MASK_PRC_B},
122 {NULL, ICOM_INT_MASK_PRC_C},
123 {NULL, ICOM_INT_MASK_PRC_D},
124 };
125
126
127 MODULE_DEVICE_TABLE(pci, icom_pci_table);
128
129 static LIST_HEAD(icom_adapter_head);
130
131 /* spinlock for adapter initialization and changing adapter operations */
132 static spinlock_t icom_lock;
133
134 #ifdef ICOM_TRACE
135 static inline void trace(struct icom_port *, char *, unsigned long) {};
136 #else
137 static inline void trace(struct icom_port *icom_port, char *trace_pt, unsigned long trace_data) {};
138 #endif
139
140 static void free_port_memory(struct icom_port *icom_port)
141 {
142 struct pci_dev *dev = icom_port->adapter->pci_dev;
143
144 trace(icom_port, "RET_PORT_MEM", 0);
145 if (icom_port->recv_buf) {
146 pci_free_consistent(dev, 4096, icom_port->recv_buf,
147 icom_port->recv_buf_pci);
148 icom_port->recv_buf = NULL;
149 }
150 if (icom_port->xmit_buf) {
151 pci_free_consistent(dev, 4096, icom_port->xmit_buf,
152 icom_port->xmit_buf_pci);
153 icom_port->xmit_buf = NULL;
154 }
155 if (icom_port->statStg) {
156 pci_free_consistent(dev, 4096, icom_port->statStg,
157 icom_port->statStg_pci);
158 icom_port->statStg = NULL;
159 }
160
161 if (icom_port->xmitRestart) {
162 pci_free_consistent(dev, 4096, icom_port->xmitRestart,
163 icom_port->xmitRestart_pci);
164 icom_port->xmitRestart = NULL;
165 }
166 }
167
168 static int __init get_port_memory(struct icom_port *icom_port)
169 {
170 int index;
171 unsigned long stgAddr;
172 unsigned long startStgAddr;
173 unsigned long offset;
174 struct pci_dev *dev = icom_port->adapter->pci_dev;
175
176 icom_port->xmit_buf =
177 pci_alloc_consistent(dev, 4096, &icom_port->xmit_buf_pci);
178 if (!icom_port->xmit_buf) {
179 dev_err(&dev->dev, "Can not allocate Transmit buffer\n");
180 return -ENOMEM;
181 }
182
183 trace(icom_port, "GET_PORT_MEM",
184 (unsigned long) icom_port->xmit_buf);
185
186 icom_port->recv_buf =
187 pci_alloc_consistent(dev, 4096, &icom_port->recv_buf_pci);
188 if (!icom_port->recv_buf) {
189 dev_err(&dev->dev, "Can not allocate Receive buffer\n");
190 free_port_memory(icom_port);
191 return -ENOMEM;
192 }
193 trace(icom_port, "GET_PORT_MEM",
194 (unsigned long) icom_port->recv_buf);
195
196 icom_port->statStg =
197 pci_alloc_consistent(dev, 4096, &icom_port->statStg_pci);
198 if (!icom_port->statStg) {
199 dev_err(&dev->dev, "Can not allocate Status buffer\n");
200 free_port_memory(icom_port);
201 return -ENOMEM;
202 }
203 trace(icom_port, "GET_PORT_MEM",
204 (unsigned long) icom_port->statStg);
205
206 icom_port->xmitRestart =
207 pci_alloc_consistent(dev, 4096, &icom_port->xmitRestart_pci);
208 if (!icom_port->xmitRestart) {
209 dev_err(&dev->dev,
210 "Can not allocate xmit Restart buffer\n");
211 free_port_memory(icom_port);
212 return -ENOMEM;
213 }
214
215 memset(icom_port->statStg, 0, 4096);
216
217 /* FODs: Frame Out Descriptor Queue, this is a FIFO queue that
218 indicates that frames are to be transmitted
219 */
220
221 stgAddr = (unsigned long) icom_port->statStg;
222 for (index = 0; index < NUM_XBUFFS; index++) {
223 trace(icom_port, "FOD_ADDR", stgAddr);
224 stgAddr = stgAddr + sizeof(icom_port->statStg->xmit[0]);
225 if (index < (NUM_XBUFFS - 1)) {
226 memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
227 icom_port->statStg->xmit[index].leLengthASD =
228 (unsigned short int) cpu_to_le16(XMIT_BUFF_SZ);
229 trace(icom_port, "FOD_ADDR", stgAddr);
230 trace(icom_port, "FOD_XBUFF",
231 (unsigned long) icom_port->xmit_buf);
232 icom_port->statStg->xmit[index].leBuffer =
233 cpu_to_le32(icom_port->xmit_buf_pci);
234 } else if (index == (NUM_XBUFFS - 1)) {
235 memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
236 icom_port->statStg->xmit[index].leLengthASD =
237 (unsigned short int) cpu_to_le16(XMIT_BUFF_SZ);
238 trace(icom_port, "FOD_XBUFF",
239 (unsigned long) icom_port->xmit_buf);
240 icom_port->statStg->xmit[index].leBuffer =
241 cpu_to_le32(icom_port->xmit_buf_pci);
242 } else {
243 memset(&icom_port->statStg->xmit[index], 0, sizeof(struct xmit_status_area));
244 }
245 }
246 /* FIDs */
247 startStgAddr = stgAddr;
248
249 /* fill in every entry, even if no buffer */
250 for (index = 0; index < NUM_RBUFFS; index++) {
251 trace(icom_port, "FID_ADDR", stgAddr);
252 stgAddr = stgAddr + sizeof(icom_port->statStg->rcv[0]);
253 icom_port->statStg->rcv[index].leLength = 0;
254 icom_port->statStg->rcv[index].WorkingLength =
255 (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
256 if (index < (NUM_RBUFFS - 1) ) {
257 offset = stgAddr - (unsigned long) icom_port->statStg;
258 icom_port->statStg->rcv[index].leNext =
259 cpu_to_le32(icom_port-> statStg_pci + offset);
260 trace(icom_port, "FID_RBUFF",
261 (unsigned long) icom_port->recv_buf);
262 icom_port->statStg->rcv[index].leBuffer =
263 cpu_to_le32(icom_port->recv_buf_pci);
264 } else if (index == (NUM_RBUFFS -1) ) {
265 offset = startStgAddr - (unsigned long) icom_port->statStg;
266 icom_port->statStg->rcv[index].leNext =
267 cpu_to_le32(icom_port-> statStg_pci + offset);
268 trace(icom_port, "FID_RBUFF",
269 (unsigned long) icom_port->recv_buf + 2048);
270 icom_port->statStg->rcv[index].leBuffer =
271 cpu_to_le32(icom_port->recv_buf_pci + 2048);
272 } else {
273 icom_port->statStg->rcv[index].leNext = 0;
274 icom_port->statStg->rcv[index].leBuffer = 0;
275 }
276 }
277
278 return 0;
279 }
280
281 static void stop_processor(struct icom_port *icom_port)
282 {
283 unsigned long temp;
284 unsigned long flags;
285 int port;
286
287 spin_lock_irqsave(&icom_lock, flags);
288
289 port = icom_port->port;
290 if (port == 0 || port == 1)
291 stop_proc[port].global_control_reg = &icom_port->global_reg->control;
292 else
293 stop_proc[port].global_control_reg = &icom_port->global_reg->control_2;
294
295
296 if (port < 4) {
297 temp = readl(stop_proc[port].global_control_reg);
298 temp =
299 (temp & ~start_proc[port].processor_id) | stop_proc[port].processor_id;
300 writel(temp, stop_proc[port].global_control_reg);
301
302 /* write flush */
303 readl(stop_proc[port].global_control_reg);
304 } else {
305 dev_err(&icom_port->adapter->pci_dev->dev,
306 "Invalid port assignment\n");
307 }
308
309 spin_unlock_irqrestore(&icom_lock, flags);
310 }
311
312 static void start_processor(struct icom_port *icom_port)
313 {
314 unsigned long temp;
315 unsigned long flags;
316 int port;
317
318 spin_lock_irqsave(&icom_lock, flags);
319
320 port = icom_port->port;
321 if (port == 0 || port == 1)
322 start_proc[port].global_control_reg = &icom_port->global_reg->control;
323 else
324 start_proc[port].global_control_reg = &icom_port->global_reg->control_2;
325 if (port < 4) {
326 temp = readl(start_proc[port].global_control_reg);
327 temp =
328 (temp & ~stop_proc[port].processor_id) | start_proc[port].processor_id;
329 writel(temp, start_proc[port].global_control_reg);
330
331 /* write flush */
332 readl(start_proc[port].global_control_reg);
333 } else {
334 dev_err(&icom_port->adapter->pci_dev->dev,
335 "Invalid port assignment\n");
336 }
337
338 spin_unlock_irqrestore(&icom_lock, flags);
339 }
340
341 static void load_code(struct icom_port *icom_port)
342 {
343 const struct firmware *fw;
344 char __iomem *iram_ptr;
345 int index;
346 int status = 0;
347 void __iomem *dram_ptr = icom_port->dram;
348 dma_addr_t temp_pci;
349 unsigned char *new_page = NULL;
350 unsigned char cable_id = NO_CABLE;
351 struct pci_dev *dev = icom_port->adapter->pci_dev;
352
353 /* Clear out any pending interrupts */
354 writew(0x3FFF, icom_port->int_reg);
355
356 trace(icom_port, "CLEAR_INTERRUPTS", 0);
357
358 /* Stop processor */
359 stop_processor(icom_port);
360
361 /* Zero out DRAM */
362 memset_io(dram_ptr, 0, 512);
363
364 /* Load Call Setup into Adapter */
365 if (request_firmware(&fw, "icom_call_setup.bin", &dev->dev) < 0) {
366 dev_err(&dev->dev,"Unable to load icom_call_setup.bin firmware image\n");
367 status = -1;
368 goto load_code_exit;
369 }
370
371 if (fw->size > ICOM_DCE_IRAM_OFFSET) {
372 dev_err(&dev->dev, "Invalid firmware image for icom_call_setup.bin found.\n");
373 release_firmware(fw);
374 status = -1;
375 goto load_code_exit;
376 }
377
378 iram_ptr = (char __iomem *)icom_port->dram + ICOM_IRAM_OFFSET;
379 for (index = 0; index < fw->size; index++)
380 writeb(fw->data[index], &iram_ptr[index]);
381
382 release_firmware(fw);
383
384 /* Load Resident DCE portion of Adapter */
385 if (request_firmware(&fw, "icom_res_dce.bin", &dev->dev) < 0) {
386 dev_err(&dev->dev,"Unable to load icom_res_dce.bin firmware image\n");
387 status = -1;
388 goto load_code_exit;
389 }
390
391 if (fw->size > ICOM_IRAM_SIZE) {
392 dev_err(&dev->dev, "Invalid firmware image for icom_res_dce.bin found.\n");
393 release_firmware(fw);
394 status = -1;
395 goto load_code_exit;
396 }
397
398 iram_ptr = (char __iomem *) icom_port->dram + ICOM_IRAM_OFFSET;
399 for (index = ICOM_DCE_IRAM_OFFSET; index < fw->size; index++)
400 writeb(fw->data[index], &iram_ptr[index]);
401
402 release_firmware(fw);
403
404 /* Set Hardware level */
405 if ((icom_port->adapter->version | ADAPTER_V2) == ADAPTER_V2)
406 writeb(V2_HARDWARE, &(icom_port->dram->misc_flags));
407
408 /* Start the processor in Adapter */
409 start_processor(icom_port);
410
411 writeb((HDLC_PPP_PURE_ASYNC | HDLC_FF_FILL),
412 &(icom_port->dram->HDLCConfigReg));
413 writeb(0x04, &(icom_port->dram->FlagFillIdleTimer)); /* 0.5 seconds */
414 writeb(0x00, &(icom_port->dram->CmdReg));
415 writeb(0x10, &(icom_port->dram->async_config3));
416 writeb((ICOM_ACFG_DRIVE1 | ICOM_ACFG_NO_PARITY | ICOM_ACFG_8BPC |
417 ICOM_ACFG_1STOP_BIT), &(icom_port->dram->async_config2));
418
419 /*Set up data in icom DRAM to indicate where personality
420 *code is located and its length.
421 */
422 new_page = pci_alloc_consistent(dev, 4096, &temp_pci);
423
424 if (!new_page) {
425 dev_err(&dev->dev, "Can not allocate DMA buffer\n");
426 status = -1;
427 goto load_code_exit;
428 }
429
430 if (request_firmware(&fw, "icom_asc.bin", &dev->dev) < 0) {
431 dev_err(&dev->dev,"Unable to load icom_asc.bin firmware image\n");
432 status = -1;
433 goto load_code_exit;
434 }
435
436 if (fw->size > ICOM_DCE_IRAM_OFFSET) {
437 dev_err(&dev->dev, "Invalid firmware image for icom_asc.bin found.\n");
438 release_firmware(fw);
439 status = -1;
440 goto load_code_exit;
441 }
442
443 for (index = 0; index < fw->size; index++)
444 new_page[index] = fw->data[index];
445
446 release_firmware(fw);
447
448 writeb((char) ((fw->size + 16)/16), &icom_port->dram->mac_length);
449 writel(temp_pci, &icom_port->dram->mac_load_addr);
450
451 /*Setting the syncReg to 0x80 causes adapter to start downloading
452 the personality code into adapter instruction RAM.
453 Once code is loaded, it will begin executing and, based on
454 information provided above, will start DMAing data from
455 shared memory to adapter DRAM.
456 */
457 /* the wait loop below verifies this write operation has been done
458 and processed
459 */
460 writeb(START_DOWNLOAD, &icom_port->dram->sync);
461
462 /* Wait max 1 Sec for data download and processor to start */
463 for (index = 0; index < 10; index++) {
464 msleep(100);
465 if (readb(&icom_port->dram->misc_flags) & ICOM_HDW_ACTIVE)
466 break;
467 }
468
469 if (index == 10)
470 status = -1;
471
472 /*
473 * check Cable ID
474 */
475 cable_id = readb(&icom_port->dram->cable_id);
476
477 if (cable_id & ICOM_CABLE_ID_VALID) {
478 /* Get cable ID into the lower 4 bits (standard form) */
479 cable_id = (cable_id & ICOM_CABLE_ID_MASK) >> 4;
480 icom_port->cable_id = cable_id;
481 } else {
482 dev_err(&dev->dev,"Invalid or no cable attached\n");
483 icom_port->cable_id = NO_CABLE;
484 }
485
486 load_code_exit:
487
488 if (status != 0) {
489 /* Clear out any pending interrupts */
490 writew(0x3FFF, icom_port->int_reg);
491
492 /* Turn off port */
493 writeb(ICOM_DISABLE, &(icom_port->dram->disable));
494
495 /* Stop processor */
496 stop_processor(icom_port);
497
498 dev_err(&icom_port->adapter->pci_dev->dev,"Port not opertional\n");
499 }
500
501 if (new_page != NULL)
502 pci_free_consistent(dev, 4096, new_page, temp_pci);
503 }
504
505 static int startup(struct icom_port *icom_port)
506 {
507 unsigned long temp;
508 unsigned char cable_id, raw_cable_id;
509 unsigned long flags;
510 int port;
511
512 trace(icom_port, "STARTUP", 0);
513
514 if (!icom_port->dram) {
515 /* should NEVER be NULL */
516 dev_err(&icom_port->adapter->pci_dev->dev,
517 "Unusable Port, port configuration missing\n");
518 return -ENODEV;
519 }
520
521 /*
522 * check Cable ID
523 */
524 raw_cable_id = readb(&icom_port->dram->cable_id);
525 trace(icom_port, "CABLE_ID", raw_cable_id);
526
527 /* Get cable ID into the lower 4 bits (standard form) */
528 cable_id = (raw_cable_id & ICOM_CABLE_ID_MASK) >> 4;
529
530 /* Check for valid Cable ID */
531 if (!(raw_cable_id & ICOM_CABLE_ID_VALID) ||
532 (cable_id != icom_port->cable_id)) {
533
534 /* reload adapter code, pick up any potential changes in cable id */
535 load_code(icom_port);
536
537 /* still no sign of cable, error out */
538 raw_cable_id = readb(&icom_port->dram->cable_id);
539 cable_id = (raw_cable_id & ICOM_CABLE_ID_MASK) >> 4;
540 if (!(raw_cable_id & ICOM_CABLE_ID_VALID) ||
541 (icom_port->cable_id == NO_CABLE))
542 return -EIO;
543 }
544
545 /*
546 * Finally, clear and enable interrupts
547 */
548 spin_lock_irqsave(&icom_lock, flags);
549 port = icom_port->port;
550 if (port == 0 || port == 1)
551 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
552 else
553 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
554
555 if (port == 0 || port == 2)
556 writew(0x00FF, icom_port->int_reg);
557 else
558 writew(0x3F00, icom_port->int_reg);
559 if (port < 4) {
560 temp = readl(int_mask_tbl[port].global_int_mask);
561 writel(temp & ~int_mask_tbl[port].processor_id, int_mask_tbl[port].global_int_mask);
562
563 /* write flush */
564 readl(int_mask_tbl[port].global_int_mask);
565 } else {
566 dev_err(&icom_port->adapter->pci_dev->dev,
567 "Invalid port assignment\n");
568 }
569
570 spin_unlock_irqrestore(&icom_lock, flags);
571 return 0;
572 }
573
574 static void shutdown(struct icom_port *icom_port)
575 {
576 unsigned long temp;
577 unsigned char cmdReg;
578 unsigned long flags;
579 int port;
580
581 spin_lock_irqsave(&icom_lock, flags);
582 trace(icom_port, "SHUTDOWN", 0);
583
584 /*
585 * disable all interrupts
586 */
587 port = icom_port->port;
588 if (port == 0 || port == 1)
589 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask;
590 else
591 int_mask_tbl[port].global_int_mask = &icom_port->global_reg->int_mask_2;
592
593 if (port < 4) {
594 temp = readl(int_mask_tbl[port].global_int_mask);
595 writel(temp | int_mask_tbl[port].processor_id, int_mask_tbl[port].global_int_mask);
596
597 /* write flush */
598 readl(int_mask_tbl[port].global_int_mask);
599 } else {
600 dev_err(&icom_port->adapter->pci_dev->dev,
601 "Invalid port assignment\n");
602 }
603 spin_unlock_irqrestore(&icom_lock, flags);
604
605 /*
606 * disable break condition
607 */
608 cmdReg = readb(&icom_port->dram->CmdReg);
609 if ((cmdReg | CMD_SND_BREAK) == CMD_SND_BREAK) {
610 writeb(cmdReg & ~CMD_SND_BREAK, &icom_port->dram->CmdReg);
611 }
612 }
613
614 static int icom_write(struct uart_port *port)
615 {
616 unsigned long data_count;
617 unsigned char cmdReg;
618 unsigned long offset;
619 int temp_tail = port->info->xmit.tail;
620
621 trace(ICOM_PORT, "WRITE", 0);
622
623 if (cpu_to_le16(ICOM_PORT->statStg->xmit[0].flags) &
624 SA_FLAGS_READY_TO_XMIT) {
625 trace(ICOM_PORT, "WRITE_FULL", 0);
626 return 0;
627 }
628
629 data_count = 0;
630 while ((port->info->xmit.head != temp_tail) &&
631 (data_count <= XMIT_BUFF_SZ)) {
632
633 ICOM_PORT->xmit_buf[data_count++] =
634 port->info->xmit.buf[temp_tail];
635
636 temp_tail++;
637 temp_tail &= (UART_XMIT_SIZE - 1);
638 }
639
640 if (data_count) {
641 ICOM_PORT->statStg->xmit[0].flags =
642 cpu_to_le16(SA_FLAGS_READY_TO_XMIT);
643 ICOM_PORT->statStg->xmit[0].leLength =
644 cpu_to_le16(data_count);
645 offset =
646 (unsigned long) &ICOM_PORT->statStg->xmit[0] -
647 (unsigned long) ICOM_PORT->statStg;
648 *ICOM_PORT->xmitRestart =
649 cpu_to_le32(ICOM_PORT->statStg_pci + offset);
650 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
651 writeb(cmdReg | CMD_XMIT_RCV_ENABLE,
652 &ICOM_PORT->dram->CmdReg);
653 writeb(START_XMIT, &ICOM_PORT->dram->StartXmitCmd);
654 trace(ICOM_PORT, "WRITE_START", data_count);
655 /* write flush */
656 readb(&ICOM_PORT->dram->StartXmitCmd);
657 }
658
659 return data_count;
660 }
661
662 static inline void check_modem_status(struct icom_port *icom_port)
663 {
664 static char old_status = 0;
665 char delta_status;
666 unsigned char status;
667
668 spin_lock(&icom_port->uart_port.lock);
669
670 /*modem input register */
671 status = readb(&icom_port->dram->isr);
672 trace(icom_port, "CHECK_MODEM", status);
673 delta_status = status ^ old_status;
674 if (delta_status) {
675 if (delta_status & ICOM_RI)
676 icom_port->uart_port.icount.rng++;
677 if (delta_status & ICOM_DSR)
678 icom_port->uart_port.icount.dsr++;
679 if (delta_status & ICOM_DCD)
680 uart_handle_dcd_change(&icom_port->uart_port,
681 delta_status & ICOM_DCD);
682 if (delta_status & ICOM_CTS)
683 uart_handle_cts_change(&icom_port->uart_port,
684 delta_status & ICOM_CTS);
685
686 wake_up_interruptible(&icom_port->uart_port.info->
687 delta_msr_wait);
688 old_status = status;
689 }
690 spin_unlock(&icom_port->uart_port.lock);
691 }
692
693 static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
694 {
695 unsigned short int count;
696 int i;
697
698 if (port_int_reg & (INT_XMIT_COMPLETED)) {
699 trace(icom_port, "XMIT_COMPLETE", 0);
700
701 /* clear buffer in use bit */
702 icom_port->statStg->xmit[0].flags &=
703 cpu_to_le16(~SA_FLAGS_READY_TO_XMIT);
704
705 count = (unsigned short int)
706 cpu_to_le16(icom_port->statStg->xmit[0].leLength);
707 icom_port->uart_port.icount.tx += count;
708
709 for (i=0; i<count &&
710 !uart_circ_empty(&icom_port->uart_port.info->xmit); i++) {
711
712 icom_port->uart_port.info->xmit.tail++;
713 icom_port->uart_port.info->xmit.tail &=
714 (UART_XMIT_SIZE - 1);
715 }
716
717 if (!icom_write(&icom_port->uart_port))
718 /* activate write queue */
719 uart_write_wakeup(&icom_port->uart_port);
720 } else
721 trace(icom_port, "XMIT_DISABLED", 0);
722 }
723
724 static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
725 {
726 short int count, rcv_buff;
727 struct tty_struct *tty = icom_port->uart_port.info->tty;
728 unsigned short int status;
729 struct uart_icount *icount;
730 unsigned long offset;
731 unsigned char flag;
732
733 trace(icom_port, "RCV_COMPLETE", 0);
734 rcv_buff = icom_port->next_rcv;
735
736 status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
737 while (status & SA_FL_RCV_DONE) {
738 int first = -1;
739
740 trace(icom_port, "FID_STATUS", status);
741 count = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].leLength);
742
743 count = tty_buffer_request_room(tty, count);
744 trace(icom_port, "RCV_COUNT", count);
745
746 trace(icom_port, "REAL_COUNT", count);
747
748 offset =
749 cpu_to_le32(icom_port->statStg->rcv[rcv_buff].leBuffer) -
750 icom_port->recv_buf_pci;
751
752 /* Block copy all but the last byte as this may have status */
753 if (count > 0) {
754 first = icom_port->recv_buf[offset];
755 tty_insert_flip_string(tty, icom_port->recv_buf + offset, count - 1);
756 }
757
758 icount = &icom_port->uart_port.icount;
759 icount->rx += count;
760
761 /* Break detect logic */
762 if ((status & SA_FLAGS_FRAME_ERROR)
763 && first == 0) {
764 status &= ~SA_FLAGS_FRAME_ERROR;
765 status |= SA_FLAGS_BREAK_DET;
766 trace(icom_port, "BREAK_DET", 0);
767 }
768
769 flag = TTY_NORMAL;
770
771 if (status &
772 (SA_FLAGS_BREAK_DET | SA_FLAGS_PARITY_ERROR |
773 SA_FLAGS_FRAME_ERROR | SA_FLAGS_OVERRUN)) {
774
775 if (status & SA_FLAGS_BREAK_DET)
776 icount->brk++;
777 if (status & SA_FLAGS_PARITY_ERROR)
778 icount->parity++;
779 if (status & SA_FLAGS_FRAME_ERROR)
780 icount->frame++;
781 if (status & SA_FLAGS_OVERRUN)
782 icount->overrun++;
783
784 /*
785 * Now check to see if character should be
786 * ignored, and mask off conditions which
787 * should be ignored.
788 */
789 if (status & icom_port->ignore_status_mask) {
790 trace(icom_port, "IGNORE_CHAR", 0);
791 goto ignore_char;
792 }
793
794 status &= icom_port->read_status_mask;
795
796 if (status & SA_FLAGS_BREAK_DET) {
797 flag = TTY_BREAK;
798 } else if (status & SA_FLAGS_PARITY_ERROR) {
799 trace(icom_port, "PARITY_ERROR", 0);
800 flag = TTY_PARITY;
801 } else if (status & SA_FLAGS_FRAME_ERROR)
802 flag = TTY_FRAME;
803
804 }
805
806 tty_insert_flip_char(tty, *(icom_port->recv_buf + offset + count - 1), flag);
807
808 if (status & SA_FLAGS_OVERRUN)
809 /*
810 * Overrun is special, since it's
811 * reported immediately, and doesn't
812 * affect the current character
813 */
814 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
815 ignore_char:
816 icom_port->statStg->rcv[rcv_buff].flags = 0;
817 icom_port->statStg->rcv[rcv_buff].leLength = 0;
818 icom_port->statStg->rcv[rcv_buff].WorkingLength =
819 (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
820
821 rcv_buff++;
822 if (rcv_buff == NUM_RBUFFS)
823 rcv_buff = 0;
824
825 status = cpu_to_le16(icom_port->statStg->rcv[rcv_buff].flags);
826 }
827 icom_port->next_rcv = rcv_buff;
828 tty_flip_buffer_push(tty);
829 }
830
831 static void process_interrupt(u16 port_int_reg,
832 struct icom_port *icom_port)
833 {
834
835 spin_lock(&icom_port->uart_port.lock);
836 trace(icom_port, "INTERRUPT", port_int_reg);
837
838 if (port_int_reg & (INT_XMIT_COMPLETED | INT_XMIT_DISABLED))
839 xmit_interrupt(port_int_reg, icom_port);
840
841 if (port_int_reg & INT_RCV_COMPLETED)
842 recv_interrupt(port_int_reg, icom_port);
843
844 spin_unlock(&icom_port->uart_port.lock);
845 }
846
847 static irqreturn_t icom_interrupt(int irq, void *dev_id,
848 struct pt_regs *regs)
849 {
850 void __iomem * int_reg;
851 u32 adapter_interrupts;
852 u16 port_int_reg;
853 struct icom_adapter *icom_adapter;
854 struct icom_port *icom_port;
855
856 /* find icom_port for this interrupt */
857 icom_adapter = (struct icom_adapter *) dev_id;
858
859 if ((icom_adapter->version | ADAPTER_V2) == ADAPTER_V2) {
860 int_reg = icom_adapter->base_addr + 0x8024;
861
862 adapter_interrupts = readl(int_reg);
863
864 if (adapter_interrupts & 0x00003FFF) {
865 /* port 2 interrupt, NOTE: for all ADAPTER_V2, port 2 will be active */
866 icom_port = &icom_adapter->port_info[2];
867 port_int_reg = (u16) adapter_interrupts;
868 process_interrupt(port_int_reg, icom_port);
869 check_modem_status(icom_port);
870 }
871 if (adapter_interrupts & 0x3FFF0000) {
872 /* port 3 interrupt */
873 icom_port = &icom_adapter->port_info[3];
874 if (icom_port->status == ICOM_PORT_ACTIVE) {
875 port_int_reg =
876 (u16) (adapter_interrupts >> 16);
877 process_interrupt(port_int_reg, icom_port);
878 check_modem_status(icom_port);
879 }
880 }
881
882 /* Clear out any pending interrupts */
883 writel(adapter_interrupts, int_reg);
884
885 int_reg = icom_adapter->base_addr + 0x8004;
886 } else {
887 int_reg = icom_adapter->base_addr + 0x4004;
888 }
889
890 adapter_interrupts = readl(int_reg);
891
892 if (adapter_interrupts & 0x00003FFF) {
893 /* port 0 interrupt, NOTE: for all adapters, port 0 will be active */
894 icom_port = &icom_adapter->port_info[0];
895 port_int_reg = (u16) adapter_interrupts;
896 process_interrupt(port_int_reg, icom_port);
897 check_modem_status(icom_port);
898 }
899 if (adapter_interrupts & 0x3FFF0000) {
900 /* port 1 interrupt */
901 icom_port = &icom_adapter->port_info[1];
902 if (icom_port->status == ICOM_PORT_ACTIVE) {
903 port_int_reg = (u16) (adapter_interrupts >> 16);
904 process_interrupt(port_int_reg, icom_port);
905 check_modem_status(icom_port);
906 }
907 }
908
909 /* Clear out any pending interrupts */
910 writel(adapter_interrupts, int_reg);
911
912 /* flush the write */
913 adapter_interrupts = readl(int_reg);
914
915 return IRQ_HANDLED;
916 }
917
918 /*
919 * ------------------------------------------------------------------
920 * Begin serial-core API
921 * ------------------------------------------------------------------
922 */
923 static unsigned int icom_tx_empty(struct uart_port *port)
924 {
925 int ret;
926 unsigned long flags;
927
928 spin_lock_irqsave(&port->lock, flags);
929 if (cpu_to_le16(ICOM_PORT->statStg->xmit[0].flags) &
930 SA_FLAGS_READY_TO_XMIT)
931 ret = TIOCSER_TEMT;
932 else
933 ret = 0;
934
935 spin_unlock_irqrestore(&port->lock, flags);
936 return ret;
937 }
938
939 static void icom_set_mctrl(struct uart_port *port, unsigned int mctrl)
940 {
941 unsigned char local_osr;
942
943 trace(ICOM_PORT, "SET_MODEM", 0);
944 local_osr = readb(&ICOM_PORT->dram->osr);
945
946 if (mctrl & TIOCM_RTS) {
947 trace(ICOM_PORT, "RAISE_RTS", 0);
948 local_osr |= ICOM_RTS;
949 } else {
950 trace(ICOM_PORT, "LOWER_RTS", 0);
951 local_osr &= ~ICOM_RTS;
952 }
953
954 if (mctrl & TIOCM_DTR) {
955 trace(ICOM_PORT, "RAISE_DTR", 0);
956 local_osr |= ICOM_DTR;
957 } else {
958 trace(ICOM_PORT, "LOWER_DTR", 0);
959 local_osr &= ~ICOM_DTR;
960 }
961
962 writeb(local_osr, &ICOM_PORT->dram->osr);
963 }
964
965 static unsigned int icom_get_mctrl(struct uart_port *port)
966 {
967 unsigned char status;
968 unsigned int result;
969
970 trace(ICOM_PORT, "GET_MODEM", 0);
971
972 status = readb(&ICOM_PORT->dram->isr);
973
974 result = ((status & ICOM_DCD) ? TIOCM_CAR : 0)
975 | ((status & ICOM_RI) ? TIOCM_RNG : 0)
976 | ((status & ICOM_DSR) ? TIOCM_DSR : 0)
977 | ((status & ICOM_CTS) ? TIOCM_CTS : 0);
978 return result;
979 }
980
981 static void icom_stop_tx(struct uart_port *port)
982 {
983 unsigned char cmdReg;
984
985 trace(ICOM_PORT, "STOP", 0);
986 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
987 writeb(cmdReg | CMD_HOLD_XMIT, &ICOM_PORT->dram->CmdReg);
988 }
989
990 static void icom_start_tx(struct uart_port *port)
991 {
992 unsigned char cmdReg;
993
994 trace(ICOM_PORT, "START", 0);
995 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
996 if ((cmdReg & CMD_HOLD_XMIT) == CMD_HOLD_XMIT)
997 writeb(cmdReg & ~CMD_HOLD_XMIT,
998 &ICOM_PORT->dram->CmdReg);
999
1000 icom_write(port);
1001 }
1002
1003 static void icom_send_xchar(struct uart_port *port, char ch)
1004 {
1005 unsigned char xdata;
1006 int index;
1007 unsigned long flags;
1008
1009 trace(ICOM_PORT, "SEND_XCHAR", ch);
1010
1011 /* wait .1 sec to send char */
1012 for (index = 0; index < 10; index++) {
1013 spin_lock_irqsave(&port->lock, flags);
1014 xdata = readb(&ICOM_PORT->dram->xchar);
1015 if (xdata == 0x00) {
1016 trace(ICOM_PORT, "QUICK_WRITE", 0);
1017 writeb(ch, &ICOM_PORT->dram->xchar);
1018
1019 /* flush write operation */
1020 xdata = readb(&ICOM_PORT->dram->xchar);
1021 spin_unlock_irqrestore(&port->lock, flags);
1022 break;
1023 }
1024 spin_unlock_irqrestore(&port->lock, flags);
1025 msleep(10);
1026 }
1027 }
1028
1029 static void icom_stop_rx(struct uart_port *port)
1030 {
1031 unsigned char cmdReg;
1032
1033 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1034 writeb(cmdReg & ~CMD_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1035 }
1036
1037 static void icom_enable_ms(struct uart_port *port)
1038 {
1039 /* no-op */
1040 }
1041
1042 static void icom_break(struct uart_port *port, int break_state)
1043 {
1044 unsigned char cmdReg;
1045 unsigned long flags;
1046
1047 spin_lock_irqsave(&port->lock, flags);
1048 trace(ICOM_PORT, "BREAK", 0);
1049 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1050 if (break_state == -1) {
1051 writeb(cmdReg | CMD_SND_BREAK, &ICOM_PORT->dram->CmdReg);
1052 } else {
1053 writeb(cmdReg & ~CMD_SND_BREAK, &ICOM_PORT->dram->CmdReg);
1054 }
1055 spin_unlock_irqrestore(&port->lock, flags);
1056 }
1057
1058 static int icom_open(struct uart_port *port)
1059 {
1060 int retval;
1061
1062 kobject_get(&ICOM_PORT->adapter->kobj);
1063 retval = startup(ICOM_PORT);
1064
1065 if (retval) {
1066 kobject_put(&ICOM_PORT->adapter->kobj);
1067 trace(ICOM_PORT, "STARTUP_ERROR", 0);
1068 return retval;
1069 }
1070
1071 return 0;
1072 }
1073
1074 static void icom_close(struct uart_port *port)
1075 {
1076 unsigned char cmdReg;
1077
1078 trace(ICOM_PORT, "CLOSE", 0);
1079
1080 /* stop receiver */
1081 cmdReg = readb(&ICOM_PORT->dram->CmdReg);
1082 writeb(cmdReg & (unsigned char) ~CMD_RCV_ENABLE,
1083 &ICOM_PORT->dram->CmdReg);
1084
1085 shutdown(ICOM_PORT);
1086
1087 kobject_put(&ICOM_PORT->adapter->kobj);
1088 }
1089
1090 static void icom_set_termios(struct uart_port *port,
1091 struct termios *termios,
1092 struct termios *old_termios)
1093 {
1094 int baud;
1095 unsigned cflag, iflag;
1096 int bits;
1097 char new_config2;
1098 char new_config3 = 0;
1099 char tmp_byte;
1100 int index;
1101 int rcv_buff, xmit_buff;
1102 unsigned long offset;
1103 unsigned long flags;
1104
1105 spin_lock_irqsave(&port->lock, flags);
1106 trace(ICOM_PORT, "CHANGE_SPEED", 0);
1107
1108 cflag = termios->c_cflag;
1109 iflag = termios->c_iflag;
1110
1111 new_config2 = ICOM_ACFG_DRIVE1;
1112
1113 /* byte size and parity */
1114 switch (cflag & CSIZE) {
1115 case CS5: /* 5 bits/char */
1116 new_config2 |= ICOM_ACFG_5BPC;
1117 bits = 7;
1118 break;
1119 case CS6: /* 6 bits/char */
1120 new_config2 |= ICOM_ACFG_6BPC;
1121 bits = 8;
1122 break;
1123 case CS7: /* 7 bits/char */
1124 new_config2 |= ICOM_ACFG_7BPC;
1125 bits = 9;
1126 break;
1127 case CS8: /* 8 bits/char */
1128 new_config2 |= ICOM_ACFG_8BPC;
1129 bits = 10;
1130 break;
1131 default:
1132 bits = 10;
1133 break;
1134 }
1135 if (cflag & CSTOPB) {
1136 /* 2 stop bits */
1137 new_config2 |= ICOM_ACFG_2STOP_BIT;
1138 bits++;
1139 }
1140 if (cflag & PARENB) {
1141 /* parity bit enabled */
1142 new_config2 |= ICOM_ACFG_PARITY_ENAB;
1143 trace(ICOM_PORT, "PARENB", 0);
1144 bits++;
1145 }
1146 if (cflag & PARODD) {
1147 /* odd parity */
1148 new_config2 |= ICOM_ACFG_PARITY_ODD;
1149 trace(ICOM_PORT, "PARODD", 0);
1150 }
1151
1152 /* Determine divisor based on baud rate */
1153 baud = uart_get_baud_rate(port, termios, old_termios,
1154 icom_acfg_baud[0],
1155 icom_acfg_baud[BAUD_TABLE_LIMIT]);
1156 if (!baud)
1157 baud = 9600; /* B0 transition handled in rs_set_termios */
1158
1159 for (index = 0; index < BAUD_TABLE_LIMIT; index++) {
1160 if (icom_acfg_baud[index] == baud) {
1161 new_config3 = index;
1162 break;
1163 }
1164 }
1165
1166 uart_update_timeout(port, cflag, baud);
1167
1168 /* CTS flow control flag and modem status interrupts */
1169 tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1170 if (cflag & CRTSCTS)
1171 tmp_byte |= HDLC_HDW_FLOW;
1172 else
1173 tmp_byte &= ~HDLC_HDW_FLOW;
1174 writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1175
1176 /*
1177 * Set up parity check flag
1178 */
1179 ICOM_PORT->read_status_mask = SA_FLAGS_OVERRUN | SA_FL_RCV_DONE;
1180 if (iflag & INPCK)
1181 ICOM_PORT->read_status_mask |=
1182 SA_FLAGS_FRAME_ERROR | SA_FLAGS_PARITY_ERROR;
1183
1184 if ((iflag & BRKINT) || (iflag & PARMRK))
1185 ICOM_PORT->read_status_mask |= SA_FLAGS_BREAK_DET;
1186
1187 /*
1188 * Characters to ignore
1189 */
1190 ICOM_PORT->ignore_status_mask = 0;
1191 if (iflag & IGNPAR)
1192 ICOM_PORT->ignore_status_mask |=
1193 SA_FLAGS_PARITY_ERROR | SA_FLAGS_FRAME_ERROR;
1194 if (iflag & IGNBRK) {
1195 ICOM_PORT->ignore_status_mask |= SA_FLAGS_BREAK_DET;
1196 /*
1197 * If we're ignore parity and break indicators, ignore
1198 * overruns too. (For real raw support).
1199 */
1200 if (iflag & IGNPAR)
1201 ICOM_PORT->ignore_status_mask |= SA_FLAGS_OVERRUN;
1202 }
1203
1204 /*
1205 * !!! ignore all characters if CREAD is not set
1206 */
1207 if ((cflag & CREAD) == 0)
1208 ICOM_PORT->ignore_status_mask |= SA_FL_RCV_DONE;
1209
1210 /* Turn off Receiver to prepare for reset */
1211 writeb(CMD_RCV_DISABLE, &ICOM_PORT->dram->CmdReg);
1212
1213 for (index = 0; index < 10; index++) {
1214 if (readb(&ICOM_PORT->dram->PrevCmdReg) == 0x00) {
1215 break;
1216 }
1217 }
1218
1219 /* clear all current buffers of data */
1220 for (rcv_buff = 0; rcv_buff < NUM_RBUFFS; rcv_buff++) {
1221 ICOM_PORT->statStg->rcv[rcv_buff].flags = 0;
1222 ICOM_PORT->statStg->rcv[rcv_buff].leLength = 0;
1223 ICOM_PORT->statStg->rcv[rcv_buff].WorkingLength =
1224 (unsigned short int) cpu_to_le16(RCV_BUFF_SZ);
1225 }
1226
1227 for (xmit_buff = 0; xmit_buff < NUM_XBUFFS; xmit_buff++) {
1228 ICOM_PORT->statStg->xmit[xmit_buff].flags = 0;
1229 }
1230
1231 /* activate changes and start xmit and receiver here */
1232 /* Enable the receiver */
1233 writeb(new_config3, &(ICOM_PORT->dram->async_config3));
1234 writeb(new_config2, &(ICOM_PORT->dram->async_config2));
1235 tmp_byte = readb(&(ICOM_PORT->dram->HDLCConfigReg));
1236 tmp_byte |= HDLC_PPP_PURE_ASYNC | HDLC_FF_FILL;
1237 writeb(tmp_byte, &(ICOM_PORT->dram->HDLCConfigReg));
1238 writeb(0x04, &(ICOM_PORT->dram->FlagFillIdleTimer)); /* 0.5 seconds */
1239 writeb(0xFF, &(ICOM_PORT->dram->ier)); /* enable modem signal interrupts */
1240
1241 /* reset processor */
1242 writeb(CMD_RESTART, &ICOM_PORT->dram->CmdReg);
1243
1244 for (index = 0; index < 10; index++) {
1245 if (readb(&ICOM_PORT->dram->CmdReg) == 0x00) {
1246 break;
1247 }
1248 }
1249
1250 /* Enable Transmitter and Reciever */
1251 offset =
1252 (unsigned long) &ICOM_PORT->statStg->rcv[0] -
1253 (unsigned long) ICOM_PORT->statStg;
1254 writel(ICOM_PORT->statStg_pci + offset,
1255 &ICOM_PORT->dram->RcvStatusAddr);
1256 ICOM_PORT->next_rcv = 0;
1257 ICOM_PORT->put_length = 0;
1258 *ICOM_PORT->xmitRestart = 0;
1259 writel(ICOM_PORT->xmitRestart_pci,
1260 &ICOM_PORT->dram->XmitStatusAddr);
1261 trace(ICOM_PORT, "XR_ENAB", 0);
1262 writeb(CMD_XMIT_RCV_ENABLE, &ICOM_PORT->dram->CmdReg);
1263
1264 spin_unlock_irqrestore(&port->lock, flags);
1265 }
1266
1267 static const char *icom_type(struct uart_port *port)
1268 {
1269 return "icom";
1270 }
1271
1272 static void icom_release_port(struct uart_port *port)
1273 {
1274 }
1275
1276 static int icom_request_port(struct uart_port *port)
1277 {
1278 return 0;
1279 }
1280
1281 static void icom_config_port(struct uart_port *port, int flags)
1282 {
1283 port->type = PORT_ICOM;
1284 }
1285
1286 static struct uart_ops icom_ops = {
1287 .tx_empty = icom_tx_empty,
1288 .set_mctrl = icom_set_mctrl,
1289 .get_mctrl = icom_get_mctrl,
1290 .stop_tx = icom_stop_tx,
1291 .start_tx = icom_start_tx,
1292 .send_xchar = icom_send_xchar,
1293 .stop_rx = icom_stop_rx,
1294 .enable_ms = icom_enable_ms,
1295 .break_ctl = icom_break,
1296 .startup = icom_open,
1297 .shutdown = icom_close,
1298 .set_termios = icom_set_termios,
1299 .type = icom_type,
1300 .release_port = icom_release_port,
1301 .request_port = icom_request_port,
1302 .config_port = icom_config_port,
1303 };
1304
1305 #define ICOM_CONSOLE NULL
1306
1307 static struct uart_driver icom_uart_driver = {
1308 .owner = THIS_MODULE,
1309 .driver_name = ICOM_DRIVER_NAME,
1310 .dev_name = "ttyA",
1311 .major = ICOM_MAJOR,
1312 .minor = ICOM_MINOR_START,
1313 .nr = NR_PORTS,
1314 .cons = ICOM_CONSOLE,
1315 };
1316
1317 static int __devinit icom_init_ports(struct icom_adapter *icom_adapter)
1318 {
1319 u32 subsystem_id = icom_adapter->subsystem_id;
1320 int retval = 0;
1321 int i;
1322 struct icom_port *icom_port;
1323
1324 if (icom_adapter->version == ADAPTER_V1) {
1325 icom_adapter->numb_ports = 2;
1326
1327 for (i = 0; i < 2; i++) {
1328 icom_port = &icom_adapter->port_info[i];
1329 icom_port->port = i;
1330 icom_port->status = ICOM_PORT_ACTIVE;
1331 icom_port->imbed_modem = ICOM_UNKNOWN;
1332 }
1333 } else {
1334 if (subsystem_id == PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL) {
1335 icom_adapter->numb_ports = 4;
1336
1337 for (i = 0; i < 4; i++) {
1338 icom_port = &icom_adapter->port_info[i];
1339
1340 icom_port->port = i;
1341 icom_port->status = ICOM_PORT_ACTIVE;
1342 icom_port->imbed_modem = ICOM_IMBED_MODEM;
1343 }
1344 } else {
1345 icom_adapter->numb_ports = 4;
1346
1347 icom_adapter->port_info[0].port = 0;
1348 icom_adapter->port_info[0].status = ICOM_PORT_ACTIVE;
1349
1350 if (subsystem_id ==
1351 PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM) {
1352 icom_adapter->port_info[0].imbed_modem = ICOM_IMBED_MODEM;
1353 } else {
1354 icom_adapter->port_info[0].imbed_modem = ICOM_RVX;
1355 }
1356
1357 icom_adapter->port_info[1].status = ICOM_PORT_OFF;
1358
1359 icom_adapter->port_info[2].port = 2;
1360 icom_adapter->port_info[2].status = ICOM_PORT_ACTIVE;
1361 icom_adapter->port_info[2].imbed_modem = ICOM_RVX;
1362 icom_adapter->port_info[3].status = ICOM_PORT_OFF;
1363 }
1364 }
1365
1366 return retval;
1367 }
1368
1369 static void icom_port_active(struct icom_port *icom_port, struct icom_adapter *icom_adapter, int port_num)
1370 {
1371 if (icom_adapter->version == ADAPTER_V1) {
1372 icom_port->global_reg = icom_adapter->base_addr + 0x4000;
1373 icom_port->int_reg = icom_adapter->base_addr +
1374 0x4004 + 2 - 2 * port_num;
1375 } else {
1376 icom_port->global_reg = icom_adapter->base_addr + 0x8000;
1377 if (icom_port->port < 2)
1378 icom_port->int_reg = icom_adapter->base_addr +
1379 0x8004 + 2 - 2 * icom_port->port;
1380 else
1381 icom_port->int_reg = icom_adapter->base_addr +
1382 0x8024 + 2 - 2 * (icom_port->port - 2);
1383 }
1384 }
1385 static int __init icom_load_ports(struct icom_adapter *icom_adapter)
1386 {
1387 struct icom_port *icom_port;
1388 int port_num;
1389 int retval;
1390
1391 for (port_num = 0; port_num < icom_adapter->numb_ports; port_num++) {
1392
1393 icom_port = &icom_adapter->port_info[port_num];
1394
1395 if (icom_port->status == ICOM_PORT_ACTIVE) {
1396 icom_port_active(icom_port, icom_adapter, port_num);
1397 icom_port->dram = icom_adapter->base_addr +
1398 0x2000 * icom_port->port;
1399
1400 icom_port->adapter = icom_adapter;
1401
1402 /* get port memory */
1403 if ((retval = get_port_memory(icom_port)) != 0) {
1404 dev_err(&icom_port->adapter->pci_dev->dev,
1405 "Memory allocation for port FAILED\n");
1406 }
1407 }
1408 }
1409 return 0;
1410 }
1411
1412 static int __devinit icom_alloc_adapter(struct icom_adapter
1413 **icom_adapter_ref)
1414 {
1415 int adapter_count = 0;
1416 struct icom_adapter *icom_adapter;
1417 struct icom_adapter *cur_adapter_entry;
1418 struct list_head *tmp;
1419
1420 icom_adapter = (struct icom_adapter *)
1421 kmalloc(sizeof(struct icom_adapter), GFP_KERNEL);
1422
1423 if (!icom_adapter) {
1424 return -ENOMEM;
1425 }
1426
1427 memset(icom_adapter, 0, sizeof(struct icom_adapter));
1428
1429 list_for_each(tmp, &icom_adapter_head) {
1430 cur_adapter_entry =
1431 list_entry(tmp, struct icom_adapter,
1432 icom_adapter_entry);
1433 if (cur_adapter_entry->index != adapter_count) {
1434 break;
1435 }
1436 adapter_count++;
1437 }
1438
1439 icom_adapter->index = adapter_count;
1440 list_add_tail(&icom_adapter->icom_adapter_entry, tmp);
1441
1442 *icom_adapter_ref = icom_adapter;
1443 return 0;
1444 }
1445
1446 static void icom_free_adapter(struct icom_adapter *icom_adapter)
1447 {
1448 list_del(&icom_adapter->icom_adapter_entry);
1449 kfree(icom_adapter);
1450 }
1451
1452 static void icom_remove_adapter(struct icom_adapter *icom_adapter)
1453 {
1454 struct icom_port *icom_port;
1455 int index;
1456
1457 for (index = 0; index < icom_adapter->numb_ports; index++) {
1458 icom_port = &icom_adapter->port_info[index];
1459
1460 if (icom_port->status == ICOM_PORT_ACTIVE) {
1461 dev_info(&icom_adapter->pci_dev->dev,
1462 "Device removed\n");
1463
1464 uart_remove_one_port(&icom_uart_driver,
1465 &icom_port->uart_port);
1466
1467 /* be sure that DTR and RTS are dropped */
1468 writeb(0x00, &icom_port->dram->osr);
1469
1470 /* Wait 0.1 Sec for simple Init to complete */
1471 msleep(100);
1472
1473 /* Stop proccessor */
1474 stop_processor(icom_port);
1475
1476 free_port_memory(icom_port);
1477 }
1478 }
1479
1480 free_irq(icom_adapter->irq_number, (void *) icom_adapter);
1481 iounmap(icom_adapter->base_addr);
1482 icom_free_adapter(icom_adapter);
1483 pci_release_regions(icom_adapter->pci_dev);
1484 }
1485
1486 static void icom_kobj_release(struct kobject *kobj)
1487 {
1488 struct icom_adapter *icom_adapter;
1489
1490 icom_adapter = to_icom_adapter(kobj);
1491 icom_remove_adapter(icom_adapter);
1492 }
1493
1494 static struct kobj_type icom_kobj_type = {
1495 .release = icom_kobj_release,
1496 };
1497
1498 static int __devinit icom_probe(struct pci_dev *dev,
1499 const struct pci_device_id *ent)
1500 {
1501 int index;
1502 unsigned int command_reg;
1503 int retval;
1504 struct icom_adapter *icom_adapter;
1505 struct icom_port *icom_port;
1506
1507 retval = pci_enable_device(dev);
1508 if (retval) {
1509 dev_err(&dev->dev, "Device enable FAILED\n");
1510 return retval;
1511 }
1512
1513 if ( (retval = pci_request_regions(dev, "icom"))) {
1514 dev_err(&dev->dev, "pci_request_region FAILED\n");
1515 pci_disable_device(dev);
1516 return retval;
1517 }
1518
1519 pci_set_master(dev);
1520
1521 if ( (retval = pci_read_config_dword(dev, PCI_COMMAND, &command_reg))) {
1522 dev_err(&dev->dev, "PCI Config read FAILED\n");
1523 return retval;
1524 }
1525
1526 pci_write_config_dword(dev, PCI_COMMAND,
1527 command_reg | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER
1528 | PCI_COMMAND_PARITY | PCI_COMMAND_SERR);
1529
1530 if (ent->driver_data == ADAPTER_V1) {
1531 pci_write_config_dword(dev, 0x44, 0x8300830A);
1532 } else {
1533 pci_write_config_dword(dev, 0x44, 0x42004200);
1534 pci_write_config_dword(dev, 0x48, 0x42004200);
1535 }
1536
1537
1538 retval = icom_alloc_adapter(&icom_adapter);
1539 if (retval) {
1540 dev_err(&dev->dev, "icom_alloc_adapter FAILED\n");
1541 retval = -EIO;
1542 goto probe_exit0;
1543 }
1544
1545 icom_adapter->base_addr_pci = pci_resource_start(dev, 0);
1546 icom_adapter->irq_number = dev->irq;
1547 icom_adapter->pci_dev = dev;
1548 icom_adapter->version = ent->driver_data;
1549 icom_adapter->subsystem_id = ent->subdevice;
1550
1551
1552 retval = icom_init_ports(icom_adapter);
1553 if (retval) {
1554 dev_err(&dev->dev, "Port configuration failed\n");
1555 goto probe_exit1;
1556 }
1557
1558 icom_adapter->base_addr = ioremap(icom_adapter->base_addr_pci,
1559 pci_resource_len(dev, 0));
1560
1561 if (!icom_adapter->base_addr)
1562 goto probe_exit1;
1563
1564 /* save off irq and request irq line */
1565 if ( (retval = request_irq(dev->irq, icom_interrupt,
1566 IRQF_DISABLED | IRQF_SHARED, ICOM_DRIVER_NAME,
1567 (void *) icom_adapter))) {
1568 goto probe_exit2;
1569 }
1570
1571 retval = icom_load_ports(icom_adapter);
1572
1573 for (index = 0; index < icom_adapter->numb_ports; index++) {
1574 icom_port = &icom_adapter->port_info[index];
1575
1576 if (icom_port->status == ICOM_PORT_ACTIVE) {
1577 icom_port->uart_port.irq = icom_port->adapter->irq_number;
1578 icom_port->uart_port.type = PORT_ICOM;
1579 icom_port->uart_port.iotype = UPIO_MEM;
1580 icom_port->uart_port.membase =
1581 (char *) icom_adapter->base_addr_pci;
1582 icom_port->uart_port.fifosize = 16;
1583 icom_port->uart_port.ops = &icom_ops;
1584 icom_port->uart_port.line =
1585 icom_port->port + icom_adapter->index * 4;
1586 if (uart_add_one_port (&icom_uart_driver, &icom_port->uart_port)) {
1587 icom_port->status = ICOM_PORT_OFF;
1588 dev_err(&dev->dev, "Device add failed\n");
1589 } else
1590 dev_info(&dev->dev, "Device added\n");
1591 }
1592 }
1593
1594 kobject_init(&icom_adapter->kobj);
1595 icom_adapter->kobj.ktype = &icom_kobj_type;
1596 return 0;
1597
1598 probe_exit2:
1599 iounmap(icom_adapter->base_addr);
1600 probe_exit1:
1601 icom_free_adapter(icom_adapter);
1602
1603 probe_exit0:
1604 pci_release_regions(dev);
1605 pci_disable_device(dev);
1606
1607 return retval;
1608
1609
1610 }
1611
1612 static void __devexit icom_remove(struct pci_dev *dev)
1613 {
1614 struct icom_adapter *icom_adapter;
1615 struct list_head *tmp;
1616
1617 list_for_each(tmp, &icom_adapter_head) {
1618 icom_adapter = list_entry(tmp, struct icom_adapter,
1619 icom_adapter_entry);
1620 if (icom_adapter->pci_dev == dev) {
1621 kobject_put(&icom_adapter->kobj);
1622 return;
1623 }
1624 }
1625
1626 dev_err(&dev->dev, "Unable to find device to remove\n");
1627 }
1628
1629 static struct pci_driver icom_pci_driver = {
1630 .name = ICOM_DRIVER_NAME,
1631 .id_table = icom_pci_table,
1632 .probe = icom_probe,
1633 .remove = __devexit_p(icom_remove),
1634 };
1635
1636 static int __init icom_init(void)
1637 {
1638 int ret;
1639
1640 spin_lock_init(&icom_lock);
1641
1642 ret = uart_register_driver(&icom_uart_driver);
1643 if (ret)
1644 return ret;
1645
1646 ret = pci_register_driver(&icom_pci_driver);
1647
1648 if (ret < 0)
1649 uart_unregister_driver(&icom_uart_driver);
1650
1651 return ret;
1652 }
1653
1654 static void __exit icom_exit(void)
1655 {
1656 pci_unregister_driver(&icom_pci_driver);
1657 uart_unregister_driver(&icom_uart_driver);
1658 }
1659
1660 module_init(icom_init);
1661 module_exit(icom_exit);
1662
1663 #ifdef ICOM_TRACE
1664 static inline void trace(struct icom_port *icom_port, char *trace_pt,
1665 unsigned long trace_data)
1666 {
1667 dev_info(&icom_port->adapter->pci_dev->dev, ":%d:%s - %lx\n",
1668 icom_port->port, trace_pt, trace_data);
1669 }
1670 #endif
1671
1672 MODULE_AUTHOR("Michael Anderson <mjanders@us.ibm.com>");
1673 MODULE_DESCRIPTION("IBM iSeries Serial IOA driver");
1674 MODULE_SUPPORTED_DEVICE
1675 ("IBM iSeries 2745, 2771, 2772, 2742, 2793 and 2805 Communications adapters");
1676 MODULE_LICENSE("GPL");
1677
linux kernel for loongson