Loading...
1/************************************************************************
2 * Copyright 2003 Digi International (www.digi.com)
3 *
4 * Copyright (C) 2004 IBM Corporation. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or (at your option)
9 * any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
13 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
14 * PURPOSE. See the GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 * Temple Place - Suite 330, Boston,
19 * MA 02111-1307, USA.
20 *
21 * Contact Information:
22 * Scott H Kilau <Scott_Kilau@digi.com>
23 * Wendy Xiong <wendyx@us.ibm.com>
24 *
25 *
26 ***********************************************************************/
27#include <linux/moduleparam.h>
28#include <linux/pci.h>
29#include <linux/slab.h>
30
31#include "jsm.h"
32
33MODULE_AUTHOR("Digi International, http://www.digi.com");
34MODULE_DESCRIPTION("Driver for the Digi International "
35 "Neo PCI based product line");
36MODULE_LICENSE("GPL");
37MODULE_SUPPORTED_DEVICE("jsm");
38
39#define JSM_DRIVER_NAME "jsm"
40#define NR_PORTS 32
41#define JSM_MINOR_START 0
42
43struct uart_driver jsm_uart_driver = {
44 .owner = THIS_MODULE,
45 .driver_name = JSM_DRIVER_NAME,
46 .dev_name = "ttyn",
47 .major = 0,
48 .minor = JSM_MINOR_START,
49 .nr = NR_PORTS,
50};
51
52static pci_ers_result_t jsm_io_error_detected(struct pci_dev *pdev,
53 pci_channel_state_t state);
54static pci_ers_result_t jsm_io_slot_reset(struct pci_dev *pdev);
55static void jsm_io_resume(struct pci_dev *pdev);
56
57static struct pci_error_handlers jsm_err_handler = {
58 .error_detected = jsm_io_error_detected,
59 .slot_reset = jsm_io_slot_reset,
60 .resume = jsm_io_resume,
61};
62
63int jsm_debug;
64module_param(jsm_debug, int, 0);
65MODULE_PARM_DESC(jsm_debug, "Driver debugging level");
66
67static int __devinit jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
68{
69 int rc = 0;
70 struct jsm_board *brd;
71 static int adapter_count = 0;
72
73 rc = pci_enable_device(pdev);
74 if (rc) {
75 dev_err(&pdev->dev, "Device enable FAILED\n");
76 goto out;
77 }
78
79 rc = pci_request_regions(pdev, "jsm");
80 if (rc) {
81 dev_err(&pdev->dev, "pci_request_region FAILED\n");
82 goto out_disable_device;
83 }
84
85 brd = kzalloc(sizeof(struct jsm_board), GFP_KERNEL);
86 if (!brd) {
87 dev_err(&pdev->dev,
88 "memory allocation for board structure failed\n");
89 rc = -ENOMEM;
90 goto out_release_regions;
91 }
92
93 /* store the info for the board we've found */
94 brd->boardnum = adapter_count++;
95 brd->pci_dev = pdev;
96 if (pdev->device == PCIE_DEVICE_ID_NEO_4_IBM)
97 brd->maxports = 4;
98 else if (pdev->device == PCI_DEVICE_ID_DIGI_NEO_8)
99 brd->maxports = 8;
100 else
101 brd->maxports = 2;
102
103 spin_lock_init(&brd->bd_intr_lock);
104
105 /* store which revision we have */
106 brd->rev = pdev->revision;
107
108 brd->irq = pdev->irq;
109
110 jsm_printk(INIT, INFO, &brd->pci_dev,
111 "jsm_found_board - NEO adapter\n");
112
113 /* get the PCI Base Address Registers */
114 brd->membase = pci_resource_start(pdev, 0);
115 brd->membase_end = pci_resource_end(pdev, 0);
116
117 if (brd->membase & 1)
118 brd->membase &= ~3;
119 else
120 brd->membase &= ~15;
121
122 /* Assign the board_ops struct */
123 brd->bd_ops = &jsm_neo_ops;
124
125 brd->bd_uart_offset = 0x200;
126 brd->bd_dividend = 921600;
127
128 brd->re_map_membase = ioremap(brd->membase, pci_resource_len(pdev, 0));
129 if (!brd->re_map_membase) {
130 dev_err(&pdev->dev,
131 "card has no PCI Memory resources, "
132 "failing board.\n");
133 rc = -ENOMEM;
134 goto out_kfree_brd;
135 }
136
137 rc = request_irq(brd->irq, brd->bd_ops->intr,
138 IRQF_SHARED, "JSM", brd);
139 if (rc) {
140 printk(KERN_WARNING "Failed to hook IRQ %d\n",brd->irq);
141 goto out_iounmap;
142 }
143
144 rc = jsm_tty_init(brd);
145 if (rc < 0) {
146 dev_err(&pdev->dev, "Can't init tty devices (%d)\n", rc);
147 rc = -ENXIO;
148 goto out_free_irq;
149 }
150
151 rc = jsm_uart_port_init(brd);
152 if (rc < 0) {
153 /* XXX: leaking all resources from jsm_tty_init here! */
154 dev_err(&pdev->dev, "Can't init uart port (%d)\n", rc);
155 rc = -ENXIO;
156 goto out_free_irq;
157 }
158
159 /* Log the information about the board */
160 dev_info(&pdev->dev, "board %d: Digi Neo (rev %d), irq %d\n",
161 adapter_count, brd->rev, brd->irq);
162
163 /*
164 * allocate flip buffer for board.
165 *
166 * Okay to malloc with GFP_KERNEL, we are not at interrupt
167 * context, and there are no locks held.
168 */
169 brd->flipbuf = kzalloc(MYFLIPLEN, GFP_KERNEL);
170 if (!brd->flipbuf) {
171 /* XXX: leaking all resources from jsm_tty_init and
172 jsm_uart_port_init here! */
173 dev_err(&pdev->dev, "memory allocation for flipbuf failed\n");
174 rc = -ENOMEM;
175 goto out_free_uart;
176 }
177
178 pci_set_drvdata(pdev, brd);
179 pci_save_state(pdev);
180
181 return 0;
182 out_free_uart:
183 jsm_remove_uart_port(brd);
184 out_free_irq:
185 jsm_remove_uart_port(brd);
186 free_irq(brd->irq, brd);
187 out_iounmap:
188 iounmap(brd->re_map_membase);
189 out_kfree_brd:
190 kfree(brd);
191 out_release_regions:
192 pci_release_regions(pdev);
193 out_disable_device:
194 pci_disable_device(pdev);
195 out:
196 return rc;
197}
198
199static void __devexit jsm_remove_one(struct pci_dev *pdev)
200{
201 struct jsm_board *brd = pci_get_drvdata(pdev);
202 int i = 0;
203
204 jsm_remove_uart_port(brd);
205
206 free_irq(brd->irq, brd);
207 iounmap(brd->re_map_membase);
208
209 /* Free all allocated channels structs */
210 for (i = 0; i < brd->maxports; i++) {
211 if (brd->channels[i]) {
212 kfree(brd->channels[i]->ch_rqueue);
213 kfree(brd->channels[i]->ch_equeue);
214 kfree(brd->channels[i]->ch_wqueue);
215 kfree(brd->channels[i]);
216 }
217 }
218
219 pci_release_regions(pdev);
220 pci_disable_device(pdev);
221 kfree(brd->flipbuf);
222 kfree(brd);
223}
224
225static struct pci_device_id jsm_pci_tbl[] = {
226 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2DB9), 0, 0, 0 },
227 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2DB9PRI), 0, 0, 1 },
228 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45), 0, 0, 2 },
229 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45PRI), 0, 0, 3 },
230 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4_IBM), 0, 0, 4 },
231 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_NEO_8), 0, 0, 5 },
232 { 0, }
233};
234MODULE_DEVICE_TABLE(pci, jsm_pci_tbl);
235
236static struct pci_driver jsm_driver = {
237 .name = "jsm",
238 .id_table = jsm_pci_tbl,
239 .probe = jsm_probe_one,
240 .remove = __devexit_p(jsm_remove_one),
241 .err_handler = &jsm_err_handler,
242};
243
244static pci_ers_result_t jsm_io_error_detected(struct pci_dev *pdev,
245 pci_channel_state_t state)
246{
247 struct jsm_board *brd = pci_get_drvdata(pdev);
248
249 jsm_remove_uart_port(brd);
250
251 return PCI_ERS_RESULT_NEED_RESET;
252}
253
254static pci_ers_result_t jsm_io_slot_reset(struct pci_dev *pdev)
255{
256 int rc;
257
258 rc = pci_enable_device(pdev);
259
260 if (rc)
261 return PCI_ERS_RESULT_DISCONNECT;
262
263 pci_set_master(pdev);
264
265 return PCI_ERS_RESULT_RECOVERED;
266}
267
268static void jsm_io_resume(struct pci_dev *pdev)
269{
270 struct jsm_board *brd = pci_get_drvdata(pdev);
271
272 pci_restore_state(pdev);
273
274 jsm_uart_port_init(brd);
275}
276
277static int __init jsm_init_module(void)
278{
279 int rc;
280
281 rc = uart_register_driver(&jsm_uart_driver);
282 if (!rc) {
283 rc = pci_register_driver(&jsm_driver);
284 if (rc)
285 uart_unregister_driver(&jsm_uart_driver);
286 }
287 return rc;
288}
289
290static void __exit jsm_exit_module(void)
291{
292 pci_unregister_driver(&jsm_driver);
293 uart_unregister_driver(&jsm_uart_driver);
294}
295
296module_init(jsm_init_module);
297module_exit(jsm_exit_module);
1/************************************************************************
2 * Copyright 2003 Digi International (www.digi.com)
3 *
4 * Copyright (C) 2004 IBM Corporation. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or (at your option)
9 * any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the
13 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
14 * PURPOSE. See the GNU General Public License for more details.
15 *
16 * Contact Information:
17 * Scott H Kilau <Scott_Kilau@digi.com>
18 * Wendy Xiong <wendyx@us.ibm.com>
19 *
20 *
21 ***********************************************************************/
22#include <linux/module.h>
23#include <linux/pci.h>
24#include <linux/slab.h>
25
26#include "jsm.h"
27
28MODULE_AUTHOR("Digi International, http://www.digi.com");
29MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line");
30MODULE_LICENSE("GPL");
31MODULE_SUPPORTED_DEVICE("jsm");
32
33#define JSM_DRIVER_NAME "jsm"
34#define NR_PORTS 32
35#define JSM_MINOR_START 0
36
37struct uart_driver jsm_uart_driver = {
38 .owner = THIS_MODULE,
39 .driver_name = JSM_DRIVER_NAME,
40 .dev_name = "ttyn",
41 .major = 0,
42 .minor = JSM_MINOR_START,
43 .nr = NR_PORTS,
44};
45
46static pci_ers_result_t jsm_io_error_detected(struct pci_dev *pdev,
47 pci_channel_state_t state);
48static pci_ers_result_t jsm_io_slot_reset(struct pci_dev *pdev);
49static void jsm_io_resume(struct pci_dev *pdev);
50
51static const struct pci_error_handlers jsm_err_handler = {
52 .error_detected = jsm_io_error_detected,
53 .slot_reset = jsm_io_slot_reset,
54 .resume = jsm_io_resume,
55};
56
57int jsm_debug;
58module_param(jsm_debug, int, 0);
59MODULE_PARM_DESC(jsm_debug, "Driver debugging level");
60
61static int jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
62{
63 int rc = 0;
64 struct jsm_board *brd;
65 static int adapter_count;
66
67 rc = pci_enable_device(pdev);
68 if (rc) {
69 dev_err(&pdev->dev, "Device enable FAILED\n");
70 goto out;
71 }
72
73 rc = pci_request_regions(pdev, JSM_DRIVER_NAME);
74 if (rc) {
75 dev_err(&pdev->dev, "pci_request_region FAILED\n");
76 goto out_disable_device;
77 }
78
79 brd = kzalloc(sizeof(*brd), GFP_KERNEL);
80 if (!brd) {
81 rc = -ENOMEM;
82 goto out_release_regions;
83 }
84
85 /* store the info for the board we've found */
86 brd->boardnum = adapter_count++;
87 brd->pci_dev = pdev;
88
89 switch (pdev->device) {
90 case PCI_DEVICE_ID_NEO_2DB9:
91 case PCI_DEVICE_ID_NEO_2DB9PRI:
92 case PCI_DEVICE_ID_NEO_2RJ45:
93 case PCI_DEVICE_ID_NEO_2RJ45PRI:
94 case PCI_DEVICE_ID_NEO_2_422_485:
95 brd->maxports = 2;
96 break;
97
98 case PCI_DEVICE_ID_CLASSIC_4:
99 case PCI_DEVICE_ID_CLASSIC_4_422:
100 case PCI_DEVICE_ID_NEO_4:
101 case PCIE_DEVICE_ID_NEO_4:
102 case PCIE_DEVICE_ID_NEO_4RJ45:
103 case PCIE_DEVICE_ID_NEO_4_IBM:
104 brd->maxports = 4;
105 break;
106
107 case PCI_DEVICE_ID_CLASSIC_8:
108 case PCI_DEVICE_ID_CLASSIC_8_422:
109 case PCI_DEVICE_ID_DIGI_NEO_8:
110 case PCIE_DEVICE_ID_NEO_8:
111 case PCIE_DEVICE_ID_NEO_8RJ45:
112 brd->maxports = 8;
113 break;
114
115 default:
116 brd->maxports = 1;
117 break;
118 }
119
120 spin_lock_init(&brd->bd_intr_lock);
121
122 /* store which revision we have */
123 brd->rev = pdev->revision;
124
125 brd->irq = pdev->irq;
126
127 switch (pdev->device) {
128 case PCI_DEVICE_ID_CLASSIC_4:
129 case PCI_DEVICE_ID_CLASSIC_4_422:
130 case PCI_DEVICE_ID_CLASSIC_8:
131 case PCI_DEVICE_ID_CLASSIC_8_422:
132
133 jsm_dbg(INIT, &brd->pci_dev,
134 "jsm_found_board - Classic adapter\n");
135
136 /*
137 * For PCI ClassicBoards
138 * PCI Local Address (.i.e. "resource" number) space
139 * 0 PLX Memory Mapped Config
140 * 1 PLX I/O Mapped Config
141 * 2 I/O Mapped UARTs and Status
142 * 3 Memory Mapped VPD
143 * 4 Memory Mapped UARTs and Status
144 */
145
146 /* Get the PCI Base Address Registers */
147 brd->membase = pci_resource_start(pdev, 4);
148 brd->membase_end = pci_resource_end(pdev, 4);
149
150 if (brd->membase & 0x1)
151 brd->membase &= ~0x3;
152 else
153 brd->membase &= ~0xF;
154
155 brd->iobase = pci_resource_start(pdev, 1);
156 brd->iobase_end = pci_resource_end(pdev, 1);
157 brd->iobase = ((unsigned int)(brd->iobase)) & 0xFFFE;
158
159 /* Assign the board_ops struct */
160 brd->bd_ops = &jsm_cls_ops;
161
162 brd->bd_uart_offset = 0x8;
163 brd->bd_dividend = 921600;
164
165 brd->re_map_membase = ioremap(brd->membase,
166 pci_resource_len(pdev, 4));
167 if (!brd->re_map_membase) {
168 dev_err(&pdev->dev,
169 "Card has no PCI Memory resources, failing board.\n");
170 rc = -ENOMEM;
171 goto out_kfree_brd;
172 }
173
174 /*
175 * Enable Local Interrupt 1 (0x1),
176 * Local Interrupt 1 Polarity Active high (0x2),
177 * Enable PCI interrupt (0x43)
178 */
179 outb(0x43, brd->iobase + 0x4c);
180
181 break;
182
183 case PCI_DEVICE_ID_NEO_2DB9:
184 case PCI_DEVICE_ID_NEO_2DB9PRI:
185 case PCI_DEVICE_ID_NEO_2RJ45:
186 case PCI_DEVICE_ID_NEO_2RJ45PRI:
187 case PCI_DEVICE_ID_NEO_2_422_485:
188 case PCI_DEVICE_ID_NEO_4:
189 case PCIE_DEVICE_ID_NEO_4:
190 case PCIE_DEVICE_ID_NEO_4RJ45:
191 case PCIE_DEVICE_ID_NEO_4_IBM:
192 case PCI_DEVICE_ID_DIGI_NEO_8:
193 case PCIE_DEVICE_ID_NEO_8:
194 case PCIE_DEVICE_ID_NEO_8RJ45:
195
196 jsm_dbg(INIT, &brd->pci_dev, "jsm_found_board - NEO adapter\n");
197
198 /* get the PCI Base Address Registers */
199 brd->membase = pci_resource_start(pdev, 0);
200 brd->membase_end = pci_resource_end(pdev, 0);
201
202 if (brd->membase & 1)
203 brd->membase &= ~0x3;
204 else
205 brd->membase &= ~0xF;
206
207 /* Assign the board_ops struct */
208 brd->bd_ops = &jsm_neo_ops;
209
210 brd->bd_uart_offset = 0x200;
211 brd->bd_dividend = 921600;
212
213 brd->re_map_membase = ioremap(brd->membase,
214 pci_resource_len(pdev, 0));
215 if (!brd->re_map_membase) {
216 dev_err(&pdev->dev,
217 "Card has no PCI Memory resources, failing board.\n");
218 rc = -ENOMEM;
219 goto out_kfree_brd;
220 }
221
222 break;
223 default:
224 return -ENXIO;
225 }
226
227 rc = request_irq(brd->irq, brd->bd_ops->intr, IRQF_SHARED, "JSM", brd);
228 if (rc) {
229 dev_warn(&pdev->dev, "Failed to hook IRQ %d\n", brd->irq);
230 goto out_iounmap;
231 }
232
233 rc = jsm_tty_init(brd);
234 if (rc < 0) {
235 dev_err(&pdev->dev, "Can't init tty devices (%d)\n", rc);
236 rc = -ENXIO;
237 goto out_free_irq;
238 }
239
240 rc = jsm_uart_port_init(brd);
241 if (rc < 0) {
242 /* XXX: leaking all resources from jsm_tty_init here! */
243 dev_err(&pdev->dev, "Can't init uart port (%d)\n", rc);
244 rc = -ENXIO;
245 goto out_free_irq;
246 }
247
248 /* Log the information about the board */
249 dev_info(&pdev->dev, "board %d: Digi Classic/Neo (rev %d), irq %d\n",
250 adapter_count, brd->rev, brd->irq);
251
252 pci_set_drvdata(pdev, brd);
253 pci_save_state(pdev);
254
255 return 0;
256 out_free_irq:
257 jsm_remove_uart_port(brd);
258 free_irq(brd->irq, brd);
259 out_iounmap:
260 iounmap(brd->re_map_membase);
261 out_kfree_brd:
262 kfree(brd);
263 out_release_regions:
264 pci_release_regions(pdev);
265 out_disable_device:
266 pci_disable_device(pdev);
267 out:
268 return rc;
269}
270
271static void jsm_remove_one(struct pci_dev *pdev)
272{
273 struct jsm_board *brd = pci_get_drvdata(pdev);
274 int i = 0;
275
276 switch (pdev->device) {
277 case PCI_DEVICE_ID_CLASSIC_4:
278 case PCI_DEVICE_ID_CLASSIC_4_422:
279 case PCI_DEVICE_ID_CLASSIC_8:
280 case PCI_DEVICE_ID_CLASSIC_8_422:
281 /* Tell card not to interrupt anymore. */
282 outb(0x0, brd->iobase + 0x4c);
283 break;
284 default:
285 break;
286 }
287
288 jsm_remove_uart_port(brd);
289
290 free_irq(brd->irq, brd);
291 iounmap(brd->re_map_membase);
292
293 /* Free all allocated channels structs */
294 for (i = 0; i < brd->maxports; i++) {
295 if (brd->channels[i]) {
296 kfree(brd->channels[i]->ch_rqueue);
297 kfree(brd->channels[i]->ch_equeue);
298 kfree(brd->channels[i]);
299 }
300 }
301
302 pci_release_regions(pdev);
303 pci_disable_device(pdev);
304 kfree(brd);
305}
306
307static struct pci_device_id jsm_pci_tbl[] = {
308 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2DB9), 0, 0, 0 },
309 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2DB9PRI), 0, 0, 1 },
310 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45), 0, 0, 2 },
311 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2RJ45PRI), 0, 0, 3 },
312 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4_IBM), 0, 0, 4 },
313 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_DIGI_NEO_8), 0, 0, 5 },
314 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_4), 0, 0, 6 },
315 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_1_422), 0, 0, 7 },
316 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_1_422_485), 0, 0, 8 },
317 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_NEO_2_422_485), 0, 0, 9 },
318 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_8), 0, 0, 10 },
319 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4), 0, 0, 11 },
320 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_4RJ45), 0, 0, 12 },
321 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_8RJ45), 0, 0, 13 },
322 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_CLASSIC_4), 0, 0, 14 },
323 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_CLASSIC_4_422), 0, 0, 15 },
324 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_CLASSIC_8), 0, 0, 16 },
325 { PCI_DEVICE(PCI_VENDOR_ID_DIGI, PCI_DEVICE_ID_CLASSIC_8_422), 0, 0, 17 },
326 { 0, }
327};
328MODULE_DEVICE_TABLE(pci, jsm_pci_tbl);
329
330static struct pci_driver jsm_driver = {
331 .name = JSM_DRIVER_NAME,
332 .id_table = jsm_pci_tbl,
333 .probe = jsm_probe_one,
334 .remove = jsm_remove_one,
335 .err_handler = &jsm_err_handler,
336};
337
338static pci_ers_result_t jsm_io_error_detected(struct pci_dev *pdev,
339 pci_channel_state_t state)
340{
341 struct jsm_board *brd = pci_get_drvdata(pdev);
342
343 jsm_remove_uart_port(brd);
344
345 return PCI_ERS_RESULT_NEED_RESET;
346}
347
348static pci_ers_result_t jsm_io_slot_reset(struct pci_dev *pdev)
349{
350 int rc;
351
352 rc = pci_enable_device(pdev);
353
354 if (rc)
355 return PCI_ERS_RESULT_DISCONNECT;
356
357 pci_set_master(pdev);
358
359 return PCI_ERS_RESULT_RECOVERED;
360}
361
362static void jsm_io_resume(struct pci_dev *pdev)
363{
364 struct jsm_board *brd = pci_get_drvdata(pdev);
365
366 pci_restore_state(pdev);
367 pci_save_state(pdev);
368
369 jsm_uart_port_init(brd);
370}
371
372static int __init jsm_init_module(void)
373{
374 int rc;
375
376 rc = uart_register_driver(&jsm_uart_driver);
377 if (!rc) {
378 rc = pci_register_driver(&jsm_driver);
379 if (rc)
380 uart_unregister_driver(&jsm_uart_driver);
381 }
382 return rc;
383}
384
385static void __exit jsm_exit_module(void)
386{
387 pci_unregister_driver(&jsm_driver);
388 uart_unregister_driver(&jsm_uart_driver);
389}
390
391module_init(jsm_init_module);
392module_exit(jsm_exit_module);