Lines Matching refs:dc
335 struct nozomi *dc;
492 static void nozomi_setup_memory(struct nozomi *dc)
494 void __iomem *offset = dc->base_addr + dc->config_table.dl_start;
501 dc->port[PORT_MDM].dl_addr[CH_A] = offset;
502 dc->port[PORT_MDM].dl_addr[CH_B] =
503 (offset += dc->config_table.dl_mdm_len1);
504 dc->port[PORT_MDM].dl_size[CH_A] =
505 dc->config_table.dl_mdm_len1 - buff_offset;
506 dc->port[PORT_MDM].dl_size[CH_B] =
507 dc->config_table.dl_mdm_len2 - buff_offset;
510 dc->port[PORT_DIAG].dl_addr[CH_A] =
511 (offset += dc->config_table.dl_mdm_len2);
512 dc->port[PORT_DIAG].dl_size[CH_A] =
513 dc->config_table.dl_diag_len1 - buff_offset;
514 dc->port[PORT_DIAG].dl_addr[CH_B] =
515 (offset += dc->config_table.dl_diag_len1);
516 dc->port[PORT_DIAG].dl_size[CH_B] =
517 dc->config_table.dl_diag_len2 - buff_offset;
520 dc->port[PORT_APP1].dl_addr[CH_A] =
521 (offset += dc->config_table.dl_diag_len2);
522 dc->port[PORT_APP1].dl_size[CH_A] =
523 dc->config_table.dl_app1_len - buff_offset;
526 dc->port[PORT_APP2].dl_addr[CH_A] =
527 (offset += dc->config_table.dl_app1_len);
528 dc->port[PORT_APP2].dl_size[CH_A] =
529 dc->config_table.dl_app2_len - buff_offset;
532 dc->port[PORT_CTRL].dl_addr[CH_A] =
533 (offset += dc->config_table.dl_app2_len);
534 dc->port[PORT_CTRL].dl_size[CH_A] =
535 dc->config_table.dl_ctrl_len - buff_offset;
537 offset = dc->base_addr + dc->config_table.ul_start;
540 dc->port[PORT_MDM].ul_addr[CH_A] = offset;
541 dc->port[PORT_MDM].ul_size[CH_A] =
542 dc->config_table.ul_mdm_len1 - buff_offset;
543 dc->port[PORT_MDM].ul_addr[CH_B] =
544 (offset += dc->config_table.ul_mdm_len1);
545 dc->port[PORT_MDM].ul_size[CH_B] =
546 dc->config_table.ul_mdm_len2 - buff_offset;
549 dc->port[PORT_DIAG].ul_addr[CH_A] =
550 (offset += dc->config_table.ul_mdm_len2);
551 dc->port[PORT_DIAG].ul_size[CH_A] =
552 dc->config_table.ul_diag_len - buff_offset;
555 dc->port[PORT_APP1].ul_addr[CH_A] =
556 (offset += dc->config_table.ul_diag_len);
557 dc->port[PORT_APP1].ul_size[CH_A] =
558 dc->config_table.ul_app1_len - buff_offset;
561 dc->port[PORT_APP2].ul_addr[CH_A] =
562 (offset += dc->config_table.ul_app1_len);
563 dc->port[PORT_APP2].ul_size[CH_A] =
564 dc->config_table.ul_app2_len - buff_offset;
567 dc->port[PORT_CTRL].ul_addr[CH_A] =
568 (offset += dc->config_table.ul_app2_len);
569 dc->port[PORT_CTRL].ul_size[CH_A] =
570 dc->config_table.ul_ctrl_len - buff_offset;
575 static void dump_table(const struct nozomi *dc)
577 DBG3("signature: 0x%08X", dc->config_table.signature);
578 DBG3("version: 0x%04X", dc->config_table.version);
580 dc->config_table.product_information);
581 DBG3("toggle enabled: %d", dc->config_table.toggle.enabled);
582 DBG3("toggle up_mdm: %d", dc->config_table.toggle.mdm_ul);
583 DBG3("toggle dl_mdm: %d", dc->config_table.toggle.mdm_dl);
584 DBG3("toggle dl_dbg: %d", dc->config_table.toggle.diag_dl);
586 DBG3("dl_start: 0x%04X", dc->config_table.dl_start);
587 DBG3("dl_mdm_len0: 0x%04X, %d", dc->config_table.dl_mdm_len1,
588 dc->config_table.dl_mdm_len1);
589 DBG3("dl_mdm_len1: 0x%04X, %d", dc->config_table.dl_mdm_len2,
590 dc->config_table.dl_mdm_len2);
591 DBG3("dl_diag_len0: 0x%04X, %d", dc->config_table.dl_diag_len1,
592 dc->config_table.dl_diag_len1);
593 DBG3("dl_diag_len1: 0x%04X, %d", dc->config_table.dl_diag_len2,
594 dc->config_table.dl_diag_len2);
595 DBG3("dl_app1_len: 0x%04X, %d", dc->config_table.dl_app1_len,
596 dc->config_table.dl_app1_len);
597 DBG3("dl_app2_len: 0x%04X, %d", dc->config_table.dl_app2_len,
598 dc->config_table.dl_app2_len);
599 DBG3("dl_ctrl_len: 0x%04X, %d", dc->config_table.dl_ctrl_len,
600 dc->config_table.dl_ctrl_len);
601 DBG3("ul_start: 0x%04X, %d", dc->config_table.ul_start,
602 dc->config_table.ul_start);
603 DBG3("ul_mdm_len[0]: 0x%04X, %d", dc->config_table.ul_mdm_len1,
604 dc->config_table.ul_mdm_len1);
605 DBG3("ul_mdm_len[1]: 0x%04X, %d", dc->config_table.ul_mdm_len2,
606 dc->config_table.ul_mdm_len2);
607 DBG3("ul_diag_len: 0x%04X, %d", dc->config_table.ul_diag_len,
608 dc->config_table.ul_diag_len);
609 DBG3("ul_app1_len: 0x%04X, %d", dc->config_table.ul_app1_len,
610 dc->config_table.ul_app1_len);
611 DBG3("ul_app2_len: 0x%04X, %d", dc->config_table.ul_app2_len,
612 dc->config_table.ul_app2_len);
613 DBG3("ul_ctrl_len: 0x%04X, %d", dc->config_table.ul_ctrl_len,
614 dc->config_table.ul_ctrl_len);
617 static inline void dump_table(const struct nozomi *dc) { }
624 static int nozomi_read_config_table(struct nozomi *dc)
626 read_mem32((u32 *) &dc->config_table, dc->base_addr + 0,
629 if (dc->config_table.signature != NOZOMI_CONFIG_MAGIC) {
630 dev_err(&dc->pdev->dev, "ConfigTable Bad! 0x%08X != 0x%08X\n",
631 dc->config_table.signature, NOZOMI_CONFIG_MAGIC);
635 if ((dc->config_table.version == 0)
636 || (dc->config_table.toggle.enabled == TOGGLE_VALID)) {
640 nozomi_setup_memory(dc);
642 dc->port[PORT_MDM].toggle_ul = dc->config_table.toggle.mdm_ul;
643 dc->port[PORT_MDM].toggle_dl = dc->config_table.toggle.mdm_dl;
644 dc->port[PORT_DIAG].toggle_dl = dc->config_table.toggle.diag_dl;
646 dc->port[PORT_MDM].toggle_ul,
647 dc->port[PORT_MDM].toggle_dl, dc->port[PORT_DIAG].toggle_dl);
649 dump_table(dc);
652 memset(&dc->port[i].ctrl_dl, 0, sizeof(struct ctrl_dl));
653 memset(&dc->port[i].ctrl_ul, 0, sizeof(struct ctrl_ul));
657 dc->last_ier = dc->last_ier | CTRL_DL;
658 writew(dc->last_ier, dc->reg_ier);
660 dc->state = NOZOMI_STATE_ALLOCATED;
661 dev_info(&dc->pdev->dev, "Initialization OK!\n");
665 if ((dc->config_table.version > 0)
666 && (dc->config_table.toggle.enabled != TOGGLE_VALID)) {
670 dev_info(&dc->pdev->dev, "Version of card: %d\n",
671 dc->config_table.version);
674 nozomi_setup_memory(dc);
682 write_mem32(dc->port[PORT_MDM].ul_addr[CH_A],
684 write_mem32(dc->port[PORT_MDM].ul_addr[CH_B],
687 writew(MDM_UL | DIAG_DL | MDM_DL, dc->reg_fcr);
696 static void enable_transmit_ul(enum port_type port, struct nozomi *dc)
701 dc->last_ier |= mask[port];
702 writew(dc->last_ier, dc->reg_ier);
704 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
709 static void disable_transmit_ul(enum port_type port, struct nozomi *dc)
715 dc->last_ier &= mask[port];
716 writew(dc->last_ier, dc->reg_ier);
718 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
723 static void enable_transmit_dl(enum port_type port, struct nozomi *dc)
728 dc->last_ier |= mask[port];
729 writew(dc->last_ier, dc->reg_ier);
731 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
736 static void disable_transmit_dl(enum port_type port, struct nozomi *dc)
742 dc->last_ier &= mask[port];
743 writew(dc->last_ier, dc->reg_ier);
745 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
753 static int send_data(enum port_type index, struct nozomi *dc)
756 struct port *port = &dc->port[index];
762 size = kfifo_out(&port->fifo_ul, dc->send_buf,
774 write_mem32(addr + 4, (u32 *) dc->send_buf, size);
782 static int receive_data(enum port_type index, struct nozomi *dc)
787 struct port *port = &dc->port[index];
800 disable_transmit_dl(index, dc);
806 dev_err(&dc->pdev->dev, "size == 0?\n");
828 set_bit(index, &dc->flip);
884 static int receive_flow_control(struct nozomi *dc)
891 read_mem32((u32 *) &ctrl_dl, dc->port[PORT_CTRL].dl_addr[CH_A], 2);
914 if (dc->state == NOZOMI_STATE_ALLOCATED) {
919 dc->state = NOZOMI_STATE_READY;
920 dev_info(&dc->pdev->dev, "Device READY!\n");
924 dev_err(&dc->pdev->dev,
929 DBG1("0x%04X->0x%04X", *((u16 *)&dc->port[port].ctrl_dl),
932 old_ctrl = dc->port[port].ctrl_dl;
933 dc->port[port].ctrl_dl = ctrl_dl;
938 disable_transmit_ul(port, dc);
942 if (kfifo_len(&dc->port[port].fifo_ul)) {
946 kfifo_len(&dc->port[port].fifo_ul));
947 enable_transmit_ul(port, dc);
959 dc->port[port].tty_icount.cts++;
961 dc->port[port].tty_icount.dsr++;
963 dc->port[port].tty_icount.rng++;
965 dc->port[port].tty_icount.dcd++;
967 wake_up_interruptible(&dc->port[port].tty_wait);
971 dc->port[port].tty_icount.dcd, dc->port[port].tty_icount.cts,
972 dc->port[port].tty_icount.rng, dc->port[port].tty_icount.dsr);
978 const struct nozomi *dc)
990 dev_err(&dc->pdev->dev,
1002 static int send_flow_control(struct nozomi *dc)
1008 if (dc->port[i].update_flow_control) {
1013 dc->port[i].ctrl_ul.port = port2ctrl(i, dc);
1014 ctrl = (u16 *)&dc->port[i].ctrl_ul;
1015 write_mem32(dc->port[PORT_CTRL].ul_addr[0], \
1017 dc->port[i].update_flow_control = 0;
1029 static int handle_data_dl(struct nozomi *dc, enum port_type port, u8 *toggle,
1033 if (receive_data(port, dc)) {
1034 writew(mask1, dc->reg_fcr);
1039 if (receive_data(port, dc)) {
1040 writew(mask2, dc->reg_fcr);
1045 if (receive_data(port, dc)) {
1046 writew(mask2, dc->reg_fcr);
1051 if (receive_data(port, dc)) {
1052 writew(mask1, dc->reg_fcr);
1057 dev_err(&dc->pdev->dev, "port out of sync!, toggle:%d\n",
1069 static int handle_data_ul(struct nozomi *dc, enum port_type port, u16 read_iir)
1071 u8 *toggle = &(dc->port[port].toggle_ul);
1074 dc->last_ier &= ~MDM_UL;
1075 writew(dc->last_ier, dc->reg_ier);
1076 if (send_data(port, dc)) {
1077 writew(MDM_UL1, dc->reg_fcr);
1078 dc->last_ier = dc->last_ier | MDM_UL;
1079 writew(dc->last_ier, dc->reg_ier);
1084 dc->last_ier &= ~MDM_UL;
1085 writew(dc->last_ier, dc->reg_ier);
1086 if (send_data(port, dc)) {
1087 writew(MDM_UL2, dc->reg_fcr);
1088 dc->last_ier = dc->last_ier | MDM_UL;
1089 writew(dc->last_ier, dc->reg_ier);
1095 dc->last_ier &= ~MDM_UL;
1096 writew(dc->last_ier, dc->reg_ier);
1097 if (send_data(port, dc)) {
1098 writew(MDM_UL2, dc->reg_fcr);
1099 dc->last_ier = dc->last_ier | MDM_UL;
1100 writew(dc->last_ier, dc->reg_ier);
1105 dc->last_ier &= ~MDM_UL;
1106 writew(dc->last_ier, dc->reg_ier);
1107 if (send_data(port, dc)) {
1108 writew(MDM_UL1, dc->reg_fcr);
1109 dc->last_ier = dc->last_ier | MDM_UL;
1110 writew(dc->last_ier, dc->reg_ier);
1115 writew(read_iir & MDM_UL, dc->reg_fcr);
1116 dev_err(&dc->pdev->dev, "port out of sync!\n");
1124 struct nozomi *dc = dev_id;
1128 if (!dc)
1131 spin_lock(&dc->spin_mutex);
1132 read_iir = readw(dc->reg_iir);
1139 * (by masking with dc->last_ier)
1141 read_iir &= dc->last_ier;
1148 dc->last_ier);
1151 if (unlikely(!nozomi_read_config_table(dc))) {
1152 dc->last_ier = 0x0;
1153 writew(dc->last_ier, dc->reg_ier);
1154 dev_err(&dc->pdev->dev, "Could not read status from "
1157 writew(RESET, dc->reg_fcr);
1164 dc->last_ier &= ~CTRL_UL;
1165 writew(dc->last_ier, dc->reg_ier);
1166 if (send_flow_control(dc)) {
1167 writew(CTRL_UL, dc->reg_fcr);
1168 dc->last_ier = dc->last_ier | CTRL_UL;
1169 writew(dc->last_ier, dc->reg_ier);
1173 receive_flow_control(dc);
1174 writew(CTRL_DL, dc->reg_fcr);
1177 if (!handle_data_dl(dc, PORT_MDM,
1178 &(dc->port[PORT_MDM].toggle_dl), read_iir,
1180 dev_err(&dc->pdev->dev, "MDM_DL out of sync!\n");
1185 if (!handle_data_ul(dc, PORT_MDM, read_iir)) {
1186 dev_err(&dc->pdev->dev, "MDM_UL out of sync!\n");
1191 if (!handle_data_dl(dc, PORT_DIAG,
1192 &(dc->port[PORT_DIAG].toggle_dl), read_iir,
1194 dev_err(&dc->pdev->dev, "DIAG_DL out of sync!\n");
1199 dc->last_ier &= ~DIAG_UL;
1200 writew(dc->last_ier, dc->reg_ier);
1201 if (send_data(PORT_DIAG, dc)) {
1202 writew(DIAG_UL, dc->reg_fcr);
1203 dc->last_ier = dc->last_ier | DIAG_UL;
1204 writew(dc->last_ier, dc->reg_ier);
1208 if (receive_data(PORT_APP1, dc))
1209 writew(APP1_DL, dc->reg_fcr);
1212 dc->last_ier &= ~APP1_UL;
1213 writew(dc->last_ier, dc->reg_ier);
1214 if (send_data(PORT_APP1, dc)) {
1215 writew(APP1_UL, dc->reg_fcr);
1216 dc->last_ier = dc->last_ier | APP1_UL;
1217 writew(dc->last_ier, dc->reg_ier);
1221 if (receive_data(PORT_APP2, dc))
1222 writew(APP2_DL, dc->reg_fcr);
1225 dc->last_ier &= ~APP2_UL;
1226 writew(dc->last_ier, dc->reg_ier);
1227 if (send_data(PORT_APP2, dc)) {
1228 writew(APP2_UL, dc->reg_fcr);
1229 dc->last_ier = dc->last_ier | APP2_UL;
1230 writew(dc->last_ier, dc->reg_ier);
1235 spin_unlock(&dc->spin_mutex);
1238 if (test_and_clear_bit(a, &dc->flip))
1239 tty_flip_buffer_push(&dc->port[a].port);
1243 spin_unlock(&dc->spin_mutex);
1247 static void nozomi_get_card_type(struct nozomi *dc)
1253 size += pci_resource_len(dc->pdev, i);
1256 dc->card_type = size == 2048 ? F32_2 : F32_8;
1258 dev_info(&dc->pdev->dev, "Card type is: %d\n", dc->card_type);
1261 static void nozomi_setup_private_data(struct nozomi *dc)
1263 void __iomem *offset = dc->base_addr + dc->card_type / 2;
1266 dc->reg_fcr = (void __iomem *)(offset + R_FCR);
1267 dc->reg_iir = (void __iomem *)(offset + R_IIR);
1268 dc->reg_ier = (void __iomem *)(offset + R_IER);
1269 dc->last_ier = 0;
1270 dc->flip = 0;
1272 dc->port[PORT_MDM].token_dl = MDM_DL;
1273 dc->port[PORT_DIAG].token_dl = DIAG_DL;
1274 dc->port[PORT_APP1].token_dl = APP1_DL;
1275 dc->port[PORT_APP2].token_dl = APP2_DL;
1278 init_waitqueue_head(&dc->port[i].tty_wait);
1284 const struct nozomi *dc = dev_get_drvdata(dev);
1286 return sprintf(buf, "%d\n", dc->card_type);
1293 const struct nozomi *dc = dev_get_drvdata(dev);
1295 return sprintf(buf, "%u\n", dc->open_ttys);
1299 static void make_sysfs_files(struct nozomi *dc)
1301 if (device_create_file(&dc->pdev->dev, &dev_attr_card_type))
1302 dev_err(&dc->pdev->dev,
1304 if (device_create_file(&dc->pdev->dev, &dev_attr_open_ttys))
1305 dev_err(&dc->pdev->dev,
1309 static void remove_sysfs_files(struct nozomi *dc)
1311 device_remove_file(&dc->pdev->dev, &dev_attr_card_type);
1312 device_remove_file(&dc->pdev->dev, &dev_attr_open_ttys);
1320 struct nozomi *dc = NULL;
1336 dc = kzalloc(sizeof(struct nozomi), GFP_KERNEL);
1337 if (unlikely(!dc)) {
1343 dc->pdev = pdev;
1345 ret = pci_enable_device(dc->pdev);
1351 ret = pci_request_regions(dc->pdev, NOZOMI_NAME);
1359 nozomi_get_card_type(dc);
1361 dc->base_addr = pci_iomap(dc->pdev, 0, dc->card_type);
1362 if (!dc->base_addr) {
1368 dc->send_buf = kmalloc(SEND_BUF_MAX, GFP_KERNEL);
1369 if (!dc->send_buf) {
1376 if (kfifo_alloc(&dc->port[i].fifo_ul, FIFO_BUFFER_SIZE_UL,
1385 spin_lock_init(&dc->spin_mutex);
1387 nozomi_setup_private_data(dc);
1390 dc->last_ier = 0;
1391 writew(dc->last_ier, dc->reg_ier);
1394 NOZOMI_NAME, dc);
1400 DBG1("base_addr: %p", dc->base_addr);
1402 make_sysfs_files(dc);
1404 dc->index_start = ndev_idx * MAX_PORT;
1405 ndevs[ndev_idx] = dc;
1407 pci_set_drvdata(pdev, dc);
1410 dc->last_ier = RESET;
1411 iowrite16(dc->last_ier, dc->reg_ier);
1413 dc->state = NOZOMI_STATE_ENABLED;
1417 struct port *port = &dc->port[i];
1418 port->dc = dc;
1422 dc->index_start + i, &pdev->dev);
1436 tty_unregister_device(ntty_driver, dc->index_start + i);
1437 tty_port_destroy(&dc->port[i].port);
1439 free_irq(pdev->irq, dc);
1444 kfifo_free(&dc->port[i].fifo_ul);
1446 kfree(dc->send_buf);
1447 iounmap(dc->base_addr);
1453 kfree(dc);
1458 static void tty_exit(struct nozomi *dc)
1465 tty_port_tty_hangup(&dc->port[i].port, false);
1469 while (dc->open_ttys)
1472 tty_unregister_device(ntty_driver, dc->index_start + i);
1473 tty_port_destroy(&dc->port[i].port);
1482 struct nozomi *dc = pci_get_drvdata(pdev);
1485 dc->last_ier = 0;
1486 writew(dc->last_ier, dc->reg_ier);
1488 tty_exit(dc);
1498 /* Setup dc->reg addresses to we can use defines here */
1499 write_mem32(dc->port[PORT_CTRL].ul_addr[0], (u32 *)&ctrl, 2);
1500 writew(CTRL_UL, dc->reg_fcr); /* push the token to the card. */
1502 remove_sysfs_files(dc);
1504 free_irq(pdev->irq, dc);
1507 kfifo_free(&dc->port[i].fifo_ul);
1509 kfree(dc->send_buf);
1511 iounmap(dc->base_addr);
1517 ndevs[dc->index_start / MAX_PORT] = NULL;
1519 kfree(dc);
1551 struct nozomi *dc = get_dc_by_tty(tty);
1553 if (!port || !dc || dc->state != NOZOMI_STATE_READY)
1569 struct nozomi *dc = port->dc;
1573 spin_lock_irqsave(&dc->spin_mutex, flags);
1574 dc->last_ier = dc->last_ier | port->token_dl;
1575 writew(dc->last_ier, dc->reg_ier);
1576 dc->open_ttys++;
1577 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1591 struct nozomi *dc = port->dc;
1595 spin_lock_irqsave(&dc->spin_mutex, flags);
1596 dc->last_ier &= ~(port->token_dl);
1597 writew(dc->last_ier, dc->reg_ier);
1598 dc->open_ttys--;
1599 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1624 struct nozomi *dc = get_dc_by_tty(tty);
1630 if (!dc || !port)
1635 spin_lock_irqsave(&dc->spin_mutex, flags);
1637 if (port == &(dc->port[PORT_MDM])) {
1640 enable_transmit_ul(tty->index % MAX_PORT, dc);
1642 dev_err(&dc->pdev->dev,
1646 enable_transmit_ul(tty->index % MAX_PORT, dc);
1648 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1666 const struct nozomi *dc = get_dc_by_tty(tty);
1668 if (dc)
1695 struct nozomi *dc = get_dc_by_tty(tty);
1698 spin_lock_irqsave(&dc->spin_mutex, flags);
1708 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1779 struct nozomi *dc = get_dc_by_tty(tty);
1783 spin_lock_irqsave(&dc->spin_mutex, flags);
1784 enable_transmit_dl(tty->index % MAX_PORT, dc);
1787 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1796 struct nozomi *dc = get_dc_by_tty(tty);
1800 spin_lock_irqsave(&dc->spin_mutex, flags);
1802 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1809 struct nozomi *dc = get_dc_by_tty(tty);
1812 if (unlikely(!dc || !port)) {