Lines Matching refs:dc
331 struct nozomi *dc;
479 static void nozomi_setup_memory(struct nozomi *dc)
481 void __iomem *offset = dc->base_addr + dc->config_table.dl_start;
488 dc->port[PORT_MDM].dl_addr[CH_A] = offset;
489 dc->port[PORT_MDM].dl_addr[CH_B] =
490 (offset += dc->config_table.dl_mdm_len1);
491 dc->port[PORT_MDM].dl_size[CH_A] =
492 dc->config_table.dl_mdm_len1 - buff_offset;
493 dc->port[PORT_MDM].dl_size[CH_B] =
494 dc->config_table.dl_mdm_len2 - buff_offset;
497 dc->port[PORT_DIAG].dl_addr[CH_A] =
498 (offset += dc->config_table.dl_mdm_len2);
499 dc->port[PORT_DIAG].dl_size[CH_A] =
500 dc->config_table.dl_diag_len1 - buff_offset;
501 dc->port[PORT_DIAG].dl_addr[CH_B] =
502 (offset += dc->config_table.dl_diag_len1);
503 dc->port[PORT_DIAG].dl_size[CH_B] =
504 dc->config_table.dl_diag_len2 - buff_offset;
507 dc->port[PORT_APP1].dl_addr[CH_A] =
508 (offset += dc->config_table.dl_diag_len2);
509 dc->port[PORT_APP1].dl_size[CH_A] =
510 dc->config_table.dl_app1_len - buff_offset;
513 dc->port[PORT_APP2].dl_addr[CH_A] =
514 (offset += dc->config_table.dl_app1_len);
515 dc->port[PORT_APP2].dl_size[CH_A] =
516 dc->config_table.dl_app2_len - buff_offset;
519 dc->port[PORT_CTRL].dl_addr[CH_A] =
520 (offset += dc->config_table.dl_app2_len);
521 dc->port[PORT_CTRL].dl_size[CH_A] =
522 dc->config_table.dl_ctrl_len - buff_offset;
524 offset = dc->base_addr + dc->config_table.ul_start;
527 dc->port[PORT_MDM].ul_addr[CH_A] = offset;
528 dc->port[PORT_MDM].ul_size[CH_A] =
529 dc->config_table.ul_mdm_len1 - buff_offset;
530 dc->port[PORT_MDM].ul_addr[CH_B] =
531 (offset += dc->config_table.ul_mdm_len1);
532 dc->port[PORT_MDM].ul_size[CH_B] =
533 dc->config_table.ul_mdm_len2 - buff_offset;
536 dc->port[PORT_DIAG].ul_addr[CH_A] =
537 (offset += dc->config_table.ul_mdm_len2);
538 dc->port[PORT_DIAG].ul_size[CH_A] =
539 dc->config_table.ul_diag_len - buff_offset;
542 dc->port[PORT_APP1].ul_addr[CH_A] =
543 (offset += dc->config_table.ul_diag_len);
544 dc->port[PORT_APP1].ul_size[CH_A] =
545 dc->config_table.ul_app1_len - buff_offset;
548 dc->port[PORT_APP2].ul_addr[CH_A] =
549 (offset += dc->config_table.ul_app1_len);
550 dc->port[PORT_APP2].ul_size[CH_A] =
551 dc->config_table.ul_app2_len - buff_offset;
554 dc->port[PORT_CTRL].ul_addr[CH_A] =
555 (offset += dc->config_table.ul_app2_len);
556 dc->port[PORT_CTRL].ul_size[CH_A] =
557 dc->config_table.ul_ctrl_len - buff_offset;
562 static void dump_table(const struct nozomi *dc)
564 DBG3("signature: 0x%08X", dc->config_table.signature);
565 DBG3("version: 0x%04X", dc->config_table.version);
567 dc->config_table.product_information);
568 DBG3("toggle enabled: %d", dc->config_table.toggle.enabled);
569 DBG3("toggle up_mdm: %d", dc->config_table.toggle.mdm_ul);
570 DBG3("toggle dl_mdm: %d", dc->config_table.toggle.mdm_dl);
571 DBG3("toggle dl_dbg: %d", dc->config_table.toggle.diag_dl);
573 DBG3("dl_start: 0x%04X", dc->config_table.dl_start);
574 DBG3("dl_mdm_len0: 0x%04X, %d", dc->config_table.dl_mdm_len1,
575 dc->config_table.dl_mdm_len1);
576 DBG3("dl_mdm_len1: 0x%04X, %d", dc->config_table.dl_mdm_len2,
577 dc->config_table.dl_mdm_len2);
578 DBG3("dl_diag_len0: 0x%04X, %d", dc->config_table.dl_diag_len1,
579 dc->config_table.dl_diag_len1);
580 DBG3("dl_diag_len1: 0x%04X, %d", dc->config_table.dl_diag_len2,
581 dc->config_table.dl_diag_len2);
582 DBG3("dl_app1_len: 0x%04X, %d", dc->config_table.dl_app1_len,
583 dc->config_table.dl_app1_len);
584 DBG3("dl_app2_len: 0x%04X, %d", dc->config_table.dl_app2_len,
585 dc->config_table.dl_app2_len);
586 DBG3("dl_ctrl_len: 0x%04X, %d", dc->config_table.dl_ctrl_len,
587 dc->config_table.dl_ctrl_len);
588 DBG3("ul_start: 0x%04X, %d", dc->config_table.ul_start,
589 dc->config_table.ul_start);
590 DBG3("ul_mdm_len[0]: 0x%04X, %d", dc->config_table.ul_mdm_len1,
591 dc->config_table.ul_mdm_len1);
592 DBG3("ul_mdm_len[1]: 0x%04X, %d", dc->config_table.ul_mdm_len2,
593 dc->config_table.ul_mdm_len2);
594 DBG3("ul_diag_len: 0x%04X, %d", dc->config_table.ul_diag_len,
595 dc->config_table.ul_diag_len);
596 DBG3("ul_app1_len: 0x%04X, %d", dc->config_table.ul_app1_len,
597 dc->config_table.ul_app1_len);
598 DBG3("ul_app2_len: 0x%04X, %d", dc->config_table.ul_app2_len,
599 dc->config_table.ul_app2_len);
600 DBG3("ul_ctrl_len: 0x%04X, %d", dc->config_table.ul_ctrl_len,
601 dc->config_table.ul_ctrl_len);
604 static inline void dump_table(const struct nozomi *dc) { }
611 static int nozomi_read_config_table(struct nozomi *dc)
613 read_mem32((u32 *) &dc->config_table, dc->base_addr + 0,
616 if (dc->config_table.signature != NOZOMI_CONFIG_MAGIC) {
617 dev_err(&dc->pdev->dev, "ConfigTable Bad! 0x%08X != 0x%08X\n",
618 dc->config_table.signature, NOZOMI_CONFIG_MAGIC);
622 if ((dc->config_table.version == 0)
623 || (dc->config_table.toggle.enabled == TOGGLE_VALID)) {
627 nozomi_setup_memory(dc);
629 dc->port[PORT_MDM].toggle_ul = dc->config_table.toggle.mdm_ul;
630 dc->port[PORT_MDM].toggle_dl = dc->config_table.toggle.mdm_dl;
631 dc->port[PORT_DIAG].toggle_dl = dc->config_table.toggle.diag_dl;
633 dc->port[PORT_MDM].toggle_ul,
634 dc->port[PORT_MDM].toggle_dl, dc->port[PORT_DIAG].toggle_dl);
636 dump_table(dc);
639 memset(&dc->port[i].ctrl_dl, 0, sizeof(struct ctrl_dl));
640 memset(&dc->port[i].ctrl_ul, 0, sizeof(struct ctrl_ul));
644 dc->last_ier = dc->last_ier | CTRL_DL;
645 writew(dc->last_ier, dc->reg_ier);
647 dc->state = NOZOMI_STATE_ALLOCATED;
648 dev_info(&dc->pdev->dev, "Initialization OK!\n");
652 if ((dc->config_table.version > 0)
653 && (dc->config_table.toggle.enabled != TOGGLE_VALID)) {
657 dev_info(&dc->pdev->dev, "Version of card: %d\n",
658 dc->config_table.version);
661 nozomi_setup_memory(dc);
669 write_mem32(dc->port[PORT_MDM].ul_addr[CH_A],
671 write_mem32(dc->port[PORT_MDM].ul_addr[CH_B],
674 writew(MDM_UL | DIAG_DL | MDM_DL, dc->reg_fcr);
683 static void enable_transmit_ul(enum port_type port, struct nozomi *dc)
688 dc->last_ier |= mask[port];
689 writew(dc->last_ier, dc->reg_ier);
691 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
696 static void disable_transmit_ul(enum port_type port, struct nozomi *dc)
702 dc->last_ier &= mask[port];
703 writew(dc->last_ier, dc->reg_ier);
705 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
710 static void enable_transmit_dl(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 disable_transmit_dl(enum port_type port, struct nozomi *dc)
729 dc->last_ier &= mask[port];
730 writew(dc->last_ier, dc->reg_ier);
732 dev_err(&dc->pdev->dev, "Called with wrong port?\n");
740 static int send_data(enum port_type index, struct nozomi *dc)
743 struct port *port = &dc->port[index];
749 size = kfifo_out(&port->fifo_ul, dc->send_buf,
761 write_mem32(addr + 4, (u32 *) dc->send_buf, size);
769 static int receive_data(enum port_type index, struct nozomi *dc)
774 struct port *port = &dc->port[index];
786 disable_transmit_dl(index, dc);
792 dev_err(&dc->pdev->dev, "size == 0?\n");
814 set_bit(index, &dc->flip);
870 static int receive_flow_control(struct nozomi *dc)
877 read_mem32((u32 *) &ctrl_dl, dc->port[PORT_CTRL].dl_addr[CH_A], 2);
900 if (dc->state == NOZOMI_STATE_ALLOCATED) {
905 dc->state = NOZOMI_STATE_READY;
906 dev_info(&dc->pdev->dev, "Device READY!\n");
910 dev_err(&dc->pdev->dev,
915 DBG1("0x%04X->0x%04X", *((u16 *)&dc->port[port].ctrl_dl),
918 old_ctrl = dc->port[port].ctrl_dl;
919 dc->port[port].ctrl_dl = ctrl_dl;
924 disable_transmit_ul(port, dc);
928 if (kfifo_len(&dc->port[port].fifo_ul)) {
932 kfifo_len(&dc->port[port].fifo_ul));
933 enable_transmit_ul(port, dc);
945 dc->port[port].tty_icount.cts++;
947 dc->port[port].tty_icount.dsr++;
949 dc->port[port].tty_icount.rng++;
951 dc->port[port].tty_icount.dcd++;
953 wake_up_interruptible(&dc->port[port].tty_wait);
957 dc->port[port].tty_icount.dcd, dc->port[port].tty_icount.cts,
958 dc->port[port].tty_icount.rng, dc->port[port].tty_icount.dsr);
964 const struct nozomi *dc)
976 dev_err(&dc->pdev->dev,
988 static int send_flow_control(struct nozomi *dc)
994 if (dc->port[i].update_flow_control) {
999 dc->port[i].ctrl_ul.port = port2ctrl(i, dc);
1000 ctrl = (u16 *)&dc->port[i].ctrl_ul;
1001 write_mem32(dc->port[PORT_CTRL].ul_addr[0], \
1003 dc->port[i].update_flow_control = 0;
1015 static int handle_data_dl(struct nozomi *dc, enum port_type port, u8 *toggle,
1019 if (receive_data(port, dc)) {
1020 writew(mask1, dc->reg_fcr);
1025 if (receive_data(port, dc)) {
1026 writew(mask2, dc->reg_fcr);
1031 if (receive_data(port, dc)) {
1032 writew(mask2, dc->reg_fcr);
1037 if (receive_data(port, dc)) {
1038 writew(mask1, dc->reg_fcr);
1043 dev_err(&dc->pdev->dev, "port out of sync!, toggle:%d\n",
1055 static int handle_data_ul(struct nozomi *dc, enum port_type port, u16 read_iir)
1057 u8 *toggle = &(dc->port[port].toggle_ul);
1060 dc->last_ier &= ~MDM_UL;
1061 writew(dc->last_ier, dc->reg_ier);
1062 if (send_data(port, dc)) {
1063 writew(MDM_UL1, dc->reg_fcr);
1064 dc->last_ier = dc->last_ier | MDM_UL;
1065 writew(dc->last_ier, dc->reg_ier);
1070 dc->last_ier &= ~MDM_UL;
1071 writew(dc->last_ier, dc->reg_ier);
1072 if (send_data(port, dc)) {
1073 writew(MDM_UL2, dc->reg_fcr);
1074 dc->last_ier = dc->last_ier | MDM_UL;
1075 writew(dc->last_ier, dc->reg_ier);
1081 dc->last_ier &= ~MDM_UL;
1082 writew(dc->last_ier, dc->reg_ier);
1083 if (send_data(port, dc)) {
1084 writew(MDM_UL2, dc->reg_fcr);
1085 dc->last_ier = dc->last_ier | MDM_UL;
1086 writew(dc->last_ier, dc->reg_ier);
1091 dc->last_ier &= ~MDM_UL;
1092 writew(dc->last_ier, dc->reg_ier);
1093 if (send_data(port, dc)) {
1094 writew(MDM_UL1, dc->reg_fcr);
1095 dc->last_ier = dc->last_ier | MDM_UL;
1096 writew(dc->last_ier, dc->reg_ier);
1101 writew(read_iir & MDM_UL, dc->reg_fcr);
1102 dev_err(&dc->pdev->dev, "port out of sync!\n");
1110 struct nozomi *dc = dev_id;
1114 if (!dc)
1117 spin_lock(&dc->spin_mutex);
1118 read_iir = readw(dc->reg_iir);
1125 * (by masking with dc->last_ier)
1127 read_iir &= dc->last_ier;
1134 dc->last_ier);
1137 if (unlikely(!nozomi_read_config_table(dc))) {
1138 dc->last_ier = 0x0;
1139 writew(dc->last_ier, dc->reg_ier);
1140 dev_err(&dc->pdev->dev, "Could not read status from "
1143 writew(RESET, dc->reg_fcr);
1150 dc->last_ier &= ~CTRL_UL;
1151 writew(dc->last_ier, dc->reg_ier);
1152 if (send_flow_control(dc)) {
1153 writew(CTRL_UL, dc->reg_fcr);
1154 dc->last_ier = dc->last_ier | CTRL_UL;
1155 writew(dc->last_ier, dc->reg_ier);
1159 receive_flow_control(dc);
1160 writew(CTRL_DL, dc->reg_fcr);
1163 if (!handle_data_dl(dc, PORT_MDM,
1164 &(dc->port[PORT_MDM].toggle_dl), read_iir,
1166 dev_err(&dc->pdev->dev, "MDM_DL out of sync!\n");
1171 if (!handle_data_ul(dc, PORT_MDM, read_iir)) {
1172 dev_err(&dc->pdev->dev, "MDM_UL out of sync!\n");
1177 if (!handle_data_dl(dc, PORT_DIAG,
1178 &(dc->port[PORT_DIAG].toggle_dl), read_iir,
1180 dev_err(&dc->pdev->dev, "DIAG_DL out of sync!\n");
1185 dc->last_ier &= ~DIAG_UL;
1186 writew(dc->last_ier, dc->reg_ier);
1187 if (send_data(PORT_DIAG, dc)) {
1188 writew(DIAG_UL, dc->reg_fcr);
1189 dc->last_ier = dc->last_ier | DIAG_UL;
1190 writew(dc->last_ier, dc->reg_ier);
1194 if (receive_data(PORT_APP1, dc))
1195 writew(APP1_DL, dc->reg_fcr);
1198 dc->last_ier &= ~APP1_UL;
1199 writew(dc->last_ier, dc->reg_ier);
1200 if (send_data(PORT_APP1, dc)) {
1201 writew(APP1_UL, dc->reg_fcr);
1202 dc->last_ier = dc->last_ier | APP1_UL;
1203 writew(dc->last_ier, dc->reg_ier);
1207 if (receive_data(PORT_APP2, dc))
1208 writew(APP2_DL, dc->reg_fcr);
1211 dc->last_ier &= ~APP2_UL;
1212 writew(dc->last_ier, dc->reg_ier);
1213 if (send_data(PORT_APP2, dc)) {
1214 writew(APP2_UL, dc->reg_fcr);
1215 dc->last_ier = dc->last_ier | APP2_UL;
1216 writew(dc->last_ier, dc->reg_ier);
1221 spin_unlock(&dc->spin_mutex);
1224 if (test_and_clear_bit(a, &dc->flip))
1225 tty_flip_buffer_push(&dc->port[a].port);
1229 spin_unlock(&dc->spin_mutex);
1233 static void nozomi_get_card_type(struct nozomi *dc)
1239 size += pci_resource_len(dc->pdev, i);
1242 dc->card_type = size == 2048 ? F32_2 : F32_8;
1244 dev_info(&dc->pdev->dev, "Card type is: %d\n", dc->card_type);
1247 static void nozomi_setup_private_data(struct nozomi *dc)
1249 void __iomem *offset = dc->base_addr + dc->card_type / 2;
1252 dc->reg_fcr = (void __iomem *)(offset + R_FCR);
1253 dc->reg_iir = (void __iomem *)(offset + R_IIR);
1254 dc->reg_ier = (void __iomem *)(offset + R_IER);
1255 dc->last_ier = 0;
1256 dc->flip = 0;
1258 dc->port[PORT_MDM].token_dl = MDM_DL;
1259 dc->port[PORT_DIAG].token_dl = DIAG_DL;
1260 dc->port[PORT_APP1].token_dl = APP1_DL;
1261 dc->port[PORT_APP2].token_dl = APP2_DL;
1264 init_waitqueue_head(&dc->port[i].tty_wait);
1270 const struct nozomi *dc = dev_get_drvdata(dev);
1272 return sprintf(buf, "%d\n", dc->card_type);
1279 const struct nozomi *dc = dev_get_drvdata(dev);
1281 return sprintf(buf, "%u\n", dc->open_ttys);
1285 static void make_sysfs_files(struct nozomi *dc)
1287 if (device_create_file(&dc->pdev->dev, &dev_attr_card_type))
1288 dev_err(&dc->pdev->dev,
1290 if (device_create_file(&dc->pdev->dev, &dev_attr_open_ttys))
1291 dev_err(&dc->pdev->dev,
1295 static void remove_sysfs_files(struct nozomi *dc)
1297 device_remove_file(&dc->pdev->dev, &dev_attr_card_type);
1298 device_remove_file(&dc->pdev->dev, &dev_attr_open_ttys);
1306 struct nozomi *dc = NULL;
1320 dc = kzalloc(sizeof(struct nozomi), GFP_KERNEL);
1321 if (unlikely(!dc)) {
1327 dc->pdev = pdev;
1329 ret = pci_enable_device(dc->pdev);
1335 ret = pci_request_regions(dc->pdev, NOZOMI_NAME);
1343 nozomi_get_card_type(dc);
1345 dc->base_addr = pci_iomap(dc->pdev, 0, dc->card_type);
1346 if (!dc->base_addr) {
1352 dc->send_buf = kmalloc(SEND_BUF_MAX, GFP_KERNEL);
1353 if (!dc->send_buf) {
1360 if (kfifo_alloc(&dc->port[i].fifo_ul, FIFO_BUFFER_SIZE_UL,
1369 spin_lock_init(&dc->spin_mutex);
1371 nozomi_setup_private_data(dc);
1374 dc->last_ier = 0;
1375 writew(dc->last_ier, dc->reg_ier);
1378 NOZOMI_NAME, dc);
1384 DBG1("base_addr: %p", dc->base_addr);
1386 make_sysfs_files(dc);
1388 dc->index_start = ndev_idx * MAX_PORT;
1389 ndevs[ndev_idx] = dc;
1391 pci_set_drvdata(pdev, dc);
1394 dc->last_ier = RESET;
1395 iowrite16(dc->last_ier, dc->reg_ier);
1397 dc->state = NOZOMI_STATE_ENABLED;
1401 struct port *port = &dc->port[i];
1402 port->dc = dc;
1406 dc->index_start + i, &pdev->dev);
1420 tty_unregister_device(ntty_driver, dc->index_start + i);
1421 tty_port_destroy(&dc->port[i].port);
1423 free_irq(pdev->irq, dc);
1428 kfifo_free(&dc->port[i].fifo_ul);
1430 kfree(dc->send_buf);
1431 iounmap(dc->base_addr);
1437 kfree(dc);
1442 static void tty_exit(struct nozomi *dc)
1447 tty_port_tty_hangup(&dc->port[i].port, false);
1451 while (dc->open_ttys)
1454 tty_unregister_device(ntty_driver, dc->index_start + i);
1455 tty_port_destroy(&dc->port[i].port);
1464 struct nozomi *dc = pci_get_drvdata(pdev);
1467 dc->last_ier = 0;
1468 writew(dc->last_ier, dc->reg_ier);
1470 tty_exit(dc);
1480 /* Setup dc->reg addresses to we can use defines here */
1481 write_mem32(dc->port[PORT_CTRL].ul_addr[0], (u32 *)&ctrl, 2);
1482 writew(CTRL_UL, dc->reg_fcr); /* push the token to the card. */
1484 remove_sysfs_files(dc);
1486 free_irq(pdev->irq, dc);
1489 kfifo_free(&dc->port[i].fifo_ul);
1491 kfree(dc->send_buf);
1493 iounmap(dc->base_addr);
1499 ndevs[dc->index_start / MAX_PORT] = NULL;
1501 kfree(dc);
1533 struct nozomi *dc = get_dc_by_tty(tty);
1535 if (!port || !dc || dc->state != NOZOMI_STATE_READY)
1551 struct nozomi *dc = port->dc;
1555 spin_lock_irqsave(&dc->spin_mutex, flags);
1556 dc->last_ier = dc->last_ier | port->token_dl;
1557 writew(dc->last_ier, dc->reg_ier);
1558 dc->open_ttys++;
1559 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1573 struct nozomi *dc = port->dc;
1577 spin_lock_irqsave(&dc->spin_mutex, flags);
1578 dc->last_ier &= ~(port->token_dl);
1579 writew(dc->last_ier, dc->reg_ier);
1580 dc->open_ttys--;
1581 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1606 struct nozomi *dc = get_dc_by_tty(tty);
1610 if (!dc || !port)
1615 spin_lock_irqsave(&dc->spin_mutex, flags);
1617 if (port == &(dc->port[PORT_MDM])) {
1620 enable_transmit_ul(tty->index % MAX_PORT, dc);
1622 dev_err(&dc->pdev->dev,
1626 enable_transmit_ul(tty->index % MAX_PORT, dc);
1628 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1646 const struct nozomi *dc = get_dc_by_tty(tty);
1648 if (dc)
1675 struct nozomi *dc = get_dc_by_tty(tty);
1678 spin_lock_irqsave(&dc->spin_mutex, flags);
1688 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1757 struct nozomi *dc = get_dc_by_tty(tty);
1760 spin_lock_irqsave(&dc->spin_mutex, flags);
1761 enable_transmit_dl(tty->index % MAX_PORT, dc);
1764 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1773 struct nozomi *dc = get_dc_by_tty(tty);
1776 spin_lock_irqsave(&dc->spin_mutex, flags);
1778 spin_unlock_irqrestore(&dc->spin_mutex, flags);
1785 struct nozomi *dc = get_dc_by_tty(tty);
1787 if (unlikely(!dc || !port))