2 * Microsemi Switchtec(tm) PCIe Management Driver
3 * Copyright (c) 2017, Microsemi Corporation
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 #include <linux/switchtec_ioctl.h>
18 #include <linux/interrupt.h>
19 #include <linux/module.h>
21 #include <linux/uaccess.h>
22 #include <linux/poll.h>
23 #include <linux/pci.h>
24 #include <linux/cdev.h>
25 #include <linux/wait.h>
27 MODULE_DESCRIPTION("Microsemi Switchtec(tm) PCIe Management Driver");
28 MODULE_VERSION("0.1");
29 MODULE_LICENSE("GPL");
30 MODULE_AUTHOR("Microsemi Corporation");
32 static int max_devices = 16;
33 module_param(max_devices, int, 0644);
34 MODULE_PARM_DESC(max_devices, "max number of switchtec device instances");
36 static dev_t switchtec_devt;
37 static struct class *switchtec_class;
38 static DEFINE_IDA(switchtec_minor_ida);
40 #define MICROSEMI_VENDOR_ID 0x11f8
41 #define MICROSEMI_NTB_CLASSCODE 0x068000
42 #define MICROSEMI_MGMT_CLASSCODE 0x058000
44 #define SWITCHTEC_MRPC_PAYLOAD_SIZE 1024
45 #define SWITCHTEC_MAX_PFF_CSR 48
47 #define SWITCHTEC_EVENT_OCCURRED BIT(0)
48 #define SWITCHTEC_EVENT_CLEAR BIT(0)
49 #define SWITCHTEC_EVENT_EN_LOG BIT(1)
50 #define SWITCHTEC_EVENT_EN_CLI BIT(2)
51 #define SWITCHTEC_EVENT_EN_IRQ BIT(3)
52 #define SWITCHTEC_EVENT_FATAL BIT(4)
55 SWITCHTEC_GAS_MRPC_OFFSET = 0x0000,
56 SWITCHTEC_GAS_TOP_CFG_OFFSET = 0x1000,
57 SWITCHTEC_GAS_SW_EVENT_OFFSET = 0x1800,
58 SWITCHTEC_GAS_SYS_INFO_OFFSET = 0x2000,
59 SWITCHTEC_GAS_FLASH_INFO_OFFSET = 0x2200,
60 SWITCHTEC_GAS_PART_CFG_OFFSET = 0x4000,
61 SWITCHTEC_GAS_NTB_OFFSET = 0x10000,
62 SWITCHTEC_GAS_PFF_CSR_OFFSET = 0x134000,
66 u8 input_data[SWITCHTEC_MRPC_PAYLOAD_SIZE];
67 u8 output_data[SWITCHTEC_MRPC_PAYLOAD_SIZE];
74 SWITCHTEC_MRPC_STATUS_INPROGRESS = 1,
75 SWITCHTEC_MRPC_STATUS_DONE = 2,
76 SWITCHTEC_MRPC_STATUS_ERROR = 0xFF,
77 SWITCHTEC_MRPC_STATUS_INTERRUPTED = 0x100,
80 struct sw_event_regs {
81 u64 event_report_ctrl;
83 u64 part_event_bitmap;
87 u32 stack_error_event_hdr;
88 u32 stack_error_event_data;
90 u32 ppu_error_event_hdr;
91 u32 ppu_error_event_data;
93 u32 isp_error_event_hdr;
94 u32 isp_error_event_data;
96 u32 sys_reset_event_hdr;
102 u32 fw_non_fatal_hdr;
106 u32 twi_mrpc_comp_hdr;
107 u32 twi_mrpc_comp_data;
109 u32 twi_mrpc_comp_async_hdr;
110 u32 twi_mrpc_comp_async_data;
112 u32 cli_mrpc_comp_hdr;
113 u32 cli_mrpc_comp_data;
115 u32 cli_mrpc_comp_async_hdr;
116 u32 cli_mrpc_comp_async_data;
118 u32 gpio_interrupt_hdr;
119 u32 gpio_interrupt_data;
123 struct sys_info_regs {
126 u32 firmware_version;
128 u32 vendor_table_revision;
129 u32 table_format_version;
131 u32 cfg_file_fmt_version;
135 char product_revision[4];
136 char component_vendor[8];
138 u8 component_revision;
141 struct flash_info_regs {
142 u32 flash_part_map_upd_idx;
144 struct active_partition_info {
150 struct active_partition_info active_cfg;
151 struct active_partition_info inactive_img;
152 struct active_partition_info inactive_cfg;
156 struct partition_info {
161 struct partition_info cfg1;
162 struct partition_info img0;
163 struct partition_info img1;
164 struct partition_info nvlog;
165 struct partition_info vendor[8];
168 struct ntb_info_regs {
176 struct part_cfg_regs {
183 u32 dsp_pff_inst_id[47];
185 u16 vep_vector_number;
186 u16 usp_vector_number;
187 u32 port_event_bitmap;
189 u32 part_event_summary;
192 u32 part_reset_data[5];
194 u32 mrpc_comp_data[5];
195 u32 mrpc_comp_async_hdr;
196 u32 mrpc_comp_async_data[5];
198 u32 dyn_binding_data[5];
203 SWITCHTEC_PART_CFG_EVENT_RESET = 1 << 0,
204 SWITCHTEC_PART_CFG_EVENT_MRPC_CMP = 1 << 1,
205 SWITCHTEC_PART_CFG_EVENT_MRPC_ASYNC_CMP = 1 << 2,
206 SWITCHTEC_PART_CFG_EVENT_DYN_PART_CMP = 1 << 3,
209 struct pff_csr_regs {
212 u32 pci_cfg_header[15];
213 u32 pci_cap_region[48];
214 u32 pcie_cap_region[448];
215 u32 indirect_gas_window[128];
216 u32 indirect_gas_window_off;
218 u32 pff_event_summary;
221 u32 aer_in_p2p_data[5];
223 u32 aer_in_vep_data[5];
234 u32 threshold_data[5];
236 u32 power_mgmt_data[5];
237 u32 tlp_throttling_hdr;
238 u32 tlp_throttling_data[5];
240 u32 force_speed_data[5];
241 u32 credit_timeout_hdr;
242 u32 credit_timeout_data[5];
244 u32 link_state_data[5];
248 struct switchtec_dev {
249 struct pci_dev *pdev;
256 char pff_local[SWITCHTEC_MAX_PFF_CSR];
259 struct mrpc_regs __iomem *mmio_mrpc;
260 struct sw_event_regs __iomem *mmio_sw_event;
261 struct sys_info_regs __iomem *mmio_sys_info;
262 struct flash_info_regs __iomem *mmio_flash_info;
263 struct ntb_info_regs __iomem *mmio_ntb;
264 struct part_cfg_regs __iomem *mmio_part_cfg;
265 struct part_cfg_regs __iomem *mmio_part_cfg_all;
266 struct pff_csr_regs __iomem *mmio_pff_csr;
269 * The mrpc mutex must be held when accessing the other
270 * mrpc_ fields, alive flag and stuser->state field
272 struct mutex mrpc_mutex;
273 struct list_head mrpc_queue;
275 struct work_struct mrpc_work;
276 struct delayed_work mrpc_timeout;
279 wait_queue_head_t event_wq;
283 static struct switchtec_dev *to_stdev(struct device *dev)
285 return container_of(dev, struct switchtec_dev, dev);
295 struct switchtec_user {
296 struct switchtec_dev *stdev;
298 enum mrpc_state state;
300 struct completion comp;
302 struct list_head list;
309 unsigned char data[SWITCHTEC_MRPC_PAYLOAD_SIZE];
313 static struct switchtec_user *stuser_create(struct switchtec_dev *stdev)
315 struct switchtec_user *stuser;
317 stuser = kzalloc(sizeof(*stuser), GFP_KERNEL);
319 return ERR_PTR(-ENOMEM);
321 get_device(&stdev->dev);
322 stuser->stdev = stdev;
323 kref_init(&stuser->kref);
324 INIT_LIST_HEAD(&stuser->list);
325 init_completion(&stuser->comp);
326 stuser->event_cnt = atomic_read(&stdev->event_cnt);
328 dev_dbg(&stdev->dev, "%s: %p\n", __func__, stuser);
333 static void stuser_free(struct kref *kref)
335 struct switchtec_user *stuser;
337 stuser = container_of(kref, struct switchtec_user, kref);
339 dev_dbg(&stuser->stdev->dev, "%s: %p\n", __func__, stuser);
341 put_device(&stuser->stdev->dev);
345 static void stuser_put(struct switchtec_user *stuser)
347 kref_put(&stuser->kref, stuser_free);
350 static void stuser_set_state(struct switchtec_user *stuser,
351 enum mrpc_state state)
353 /* requires the mrpc_mutex to already be held when called */
355 const char * const state_names[] = {
356 [MRPC_IDLE] = "IDLE",
357 [MRPC_QUEUED] = "QUEUED",
358 [MRPC_RUNNING] = "RUNNING",
359 [MRPC_DONE] = "DONE",
362 stuser->state = state;
364 dev_dbg(&stuser->stdev->dev, "stuser state %p -> %s",
365 stuser, state_names[state]);
368 static void mrpc_complete_cmd(struct switchtec_dev *stdev);
370 static void mrpc_cmd_submit(struct switchtec_dev *stdev)
372 /* requires the mrpc_mutex to already be held when called */
374 struct switchtec_user *stuser;
376 if (stdev->mrpc_busy)
379 if (list_empty(&stdev->mrpc_queue))
382 stuser = list_entry(stdev->mrpc_queue.next, struct switchtec_user,
385 stuser_set_state(stuser, MRPC_RUNNING);
386 stdev->mrpc_busy = 1;
387 memcpy_toio(&stdev->mmio_mrpc->input_data,
388 stuser->data, stuser->data_len);
389 iowrite32(stuser->cmd, &stdev->mmio_mrpc->cmd);
391 stuser->status = ioread32(&stdev->mmio_mrpc->status);
392 if (stuser->status != SWITCHTEC_MRPC_STATUS_INPROGRESS)
393 mrpc_complete_cmd(stdev);
395 schedule_delayed_work(&stdev->mrpc_timeout,
396 msecs_to_jiffies(500));
399 static int mrpc_queue_cmd(struct switchtec_user *stuser)
401 /* requires the mrpc_mutex to already be held when called */
403 struct switchtec_dev *stdev = stuser->stdev;
405 kref_get(&stuser->kref);
406 stuser->read_len = sizeof(stuser->data);
407 stuser_set_state(stuser, MRPC_QUEUED);
408 init_completion(&stuser->comp);
409 list_add_tail(&stuser->list, &stdev->mrpc_queue);
411 mrpc_cmd_submit(stdev);
416 static void mrpc_complete_cmd(struct switchtec_dev *stdev)
418 /* requires the mrpc_mutex to already be held when called */
419 struct switchtec_user *stuser;
421 if (list_empty(&stdev->mrpc_queue))
424 stuser = list_entry(stdev->mrpc_queue.next, struct switchtec_user,
427 stuser->status = ioread32(&stdev->mmio_mrpc->status);
428 if (stuser->status == SWITCHTEC_MRPC_STATUS_INPROGRESS)
431 stuser_set_state(stuser, MRPC_DONE);
432 stuser->return_code = 0;
434 if (stuser->status != SWITCHTEC_MRPC_STATUS_DONE)
437 stuser->return_code = ioread32(&stdev->mmio_mrpc->ret_value);
438 if (stuser->return_code != 0)
441 memcpy_fromio(stuser->data, &stdev->mmio_mrpc->output_data,
445 complete_all(&stuser->comp);
446 list_del_init(&stuser->list);
448 stdev->mrpc_busy = 0;
450 mrpc_cmd_submit(stdev);
453 static void mrpc_event_work(struct work_struct *work)
455 struct switchtec_dev *stdev;
457 stdev = container_of(work, struct switchtec_dev, mrpc_work);
459 dev_dbg(&stdev->dev, "%s\n", __func__);
461 mutex_lock(&stdev->mrpc_mutex);
462 cancel_delayed_work(&stdev->mrpc_timeout);
463 mrpc_complete_cmd(stdev);
464 mutex_unlock(&stdev->mrpc_mutex);
467 static void mrpc_timeout_work(struct work_struct *work)
469 struct switchtec_dev *stdev;
472 stdev = container_of(work, struct switchtec_dev, mrpc_timeout.work);
474 dev_dbg(&stdev->dev, "%s\n", __func__);
476 mutex_lock(&stdev->mrpc_mutex);
478 status = ioread32(&stdev->mmio_mrpc->status);
479 if (status == SWITCHTEC_MRPC_STATUS_INPROGRESS) {
480 schedule_delayed_work(&stdev->mrpc_timeout,
481 msecs_to_jiffies(500));
485 mrpc_complete_cmd(stdev);
488 mutex_unlock(&stdev->mrpc_mutex);
491 static ssize_t device_version_show(struct device *dev,
492 struct device_attribute *attr, char *buf)
494 struct switchtec_dev *stdev = to_stdev(dev);
497 ver = ioread32(&stdev->mmio_sys_info->device_version);
499 return sprintf(buf, "%x\n", ver);
501 static DEVICE_ATTR_RO(device_version);
503 static ssize_t fw_version_show(struct device *dev,
504 struct device_attribute *attr, char *buf)
506 struct switchtec_dev *stdev = to_stdev(dev);
509 ver = ioread32(&stdev->mmio_sys_info->firmware_version);
511 return sprintf(buf, "%08x\n", ver);
513 static DEVICE_ATTR_RO(fw_version);
515 static ssize_t io_string_show(char *buf, void __iomem *attr, size_t len)
519 memcpy_fromio(buf, attr, len);
523 for (i = len - 1; i > 0; i--) {
533 #define DEVICE_ATTR_SYS_INFO_STR(field) \
534 static ssize_t field ## _show(struct device *dev, \
535 struct device_attribute *attr, char *buf) \
537 struct switchtec_dev *stdev = to_stdev(dev); \
538 return io_string_show(buf, &stdev->mmio_sys_info->field, \
539 sizeof(stdev->mmio_sys_info->field)); \
542 static DEVICE_ATTR_RO(field)
544 DEVICE_ATTR_SYS_INFO_STR(vendor_id);
545 DEVICE_ATTR_SYS_INFO_STR(product_id);
546 DEVICE_ATTR_SYS_INFO_STR(product_revision);
547 DEVICE_ATTR_SYS_INFO_STR(component_vendor);
549 static ssize_t component_id_show(struct device *dev,
550 struct device_attribute *attr, char *buf)
552 struct switchtec_dev *stdev = to_stdev(dev);
553 int id = ioread16(&stdev->mmio_sys_info->component_id);
555 return sprintf(buf, "PM%04X\n", id);
557 static DEVICE_ATTR_RO(component_id);
559 static ssize_t component_revision_show(struct device *dev,
560 struct device_attribute *attr, char *buf)
562 struct switchtec_dev *stdev = to_stdev(dev);
563 int rev = ioread8(&stdev->mmio_sys_info->component_revision);
565 return sprintf(buf, "%d\n", rev);
567 static DEVICE_ATTR_RO(component_revision);
569 static ssize_t partition_show(struct device *dev,
570 struct device_attribute *attr, char *buf)
572 struct switchtec_dev *stdev = to_stdev(dev);
574 return sprintf(buf, "%d\n", stdev->partition);
576 static DEVICE_ATTR_RO(partition);
578 static ssize_t partition_count_show(struct device *dev,
579 struct device_attribute *attr, char *buf)
581 struct switchtec_dev *stdev = to_stdev(dev);
583 return sprintf(buf, "%d\n", stdev->partition_count);
585 static DEVICE_ATTR_RO(partition_count);
587 static struct attribute *switchtec_device_attrs[] = {
588 &dev_attr_device_version.attr,
589 &dev_attr_fw_version.attr,
590 &dev_attr_vendor_id.attr,
591 &dev_attr_product_id.attr,
592 &dev_attr_product_revision.attr,
593 &dev_attr_component_vendor.attr,
594 &dev_attr_component_id.attr,
595 &dev_attr_component_revision.attr,
596 &dev_attr_partition.attr,
597 &dev_attr_partition_count.attr,
601 ATTRIBUTE_GROUPS(switchtec_device);
603 static int switchtec_dev_open(struct inode *inode, struct file *filp)
605 struct switchtec_dev *stdev;
606 struct switchtec_user *stuser;
608 stdev = container_of(inode->i_cdev, struct switchtec_dev, cdev);
610 stuser = stuser_create(stdev);
612 return PTR_ERR(stuser);
614 filp->private_data = stuser;
615 nonseekable_open(inode, filp);
617 dev_dbg(&stdev->dev, "%s: %p\n", __func__, stuser);
622 static int switchtec_dev_release(struct inode *inode, struct file *filp)
624 struct switchtec_user *stuser = filp->private_data;
631 static int lock_mutex_and_test_alive(struct switchtec_dev *stdev)
633 if (mutex_lock_interruptible(&stdev->mrpc_mutex))
637 mutex_unlock(&stdev->mrpc_mutex);
644 static ssize_t switchtec_dev_write(struct file *filp, const char __user *data,
645 size_t size, loff_t *off)
647 struct switchtec_user *stuser = filp->private_data;
648 struct switchtec_dev *stdev = stuser->stdev;
651 if (size < sizeof(stuser->cmd) ||
652 size > sizeof(stuser->cmd) + sizeof(stuser->data))
655 stuser->data_len = size - sizeof(stuser->cmd);
657 rc = lock_mutex_and_test_alive(stdev);
661 if (stuser->state != MRPC_IDLE) {
666 rc = copy_from_user(&stuser->cmd, data, sizeof(stuser->cmd));
672 data += sizeof(stuser->cmd);
673 rc = copy_from_user(&stuser->data, data, size - sizeof(stuser->cmd));
679 rc = mrpc_queue_cmd(stuser);
682 mutex_unlock(&stdev->mrpc_mutex);
690 static ssize_t switchtec_dev_read(struct file *filp, char __user *data,
691 size_t size, loff_t *off)
693 struct switchtec_user *stuser = filp->private_data;
694 struct switchtec_dev *stdev = stuser->stdev;
697 if (size < sizeof(stuser->cmd) ||
698 size > sizeof(stuser->cmd) + sizeof(stuser->data))
701 rc = lock_mutex_and_test_alive(stdev);
705 if (stuser->state == MRPC_IDLE) {
706 mutex_unlock(&stdev->mrpc_mutex);
710 stuser->read_len = size - sizeof(stuser->return_code);
712 mutex_unlock(&stdev->mrpc_mutex);
714 if (filp->f_flags & O_NONBLOCK) {
715 if (!try_wait_for_completion(&stuser->comp))
718 rc = wait_for_completion_interruptible(&stuser->comp);
723 rc = lock_mutex_and_test_alive(stdev);
727 if (stuser->state != MRPC_DONE) {
728 mutex_unlock(&stdev->mrpc_mutex);
732 rc = copy_to_user(data, &stuser->return_code,
733 sizeof(stuser->return_code));
739 data += sizeof(stuser->return_code);
740 rc = copy_to_user(data, &stuser->data,
741 size - sizeof(stuser->return_code));
747 stuser_set_state(stuser, MRPC_IDLE);
750 mutex_unlock(&stdev->mrpc_mutex);
752 if (stuser->status == SWITCHTEC_MRPC_STATUS_DONE)
754 else if (stuser->status == SWITCHTEC_MRPC_STATUS_INTERRUPTED)
760 static unsigned int switchtec_dev_poll(struct file *filp, poll_table *wait)
762 struct switchtec_user *stuser = filp->private_data;
763 struct switchtec_dev *stdev = stuser->stdev;
766 poll_wait(filp, &stuser->comp.wait, wait);
767 poll_wait(filp, &stdev->event_wq, wait);
769 if (lock_mutex_and_test_alive(stdev))
770 return POLLIN | POLLRDHUP | POLLOUT | POLLERR | POLLHUP;
772 mutex_unlock(&stdev->mrpc_mutex);
774 if (try_wait_for_completion(&stuser->comp))
775 ret |= POLLIN | POLLRDNORM;
777 if (stuser->event_cnt != atomic_read(&stdev->event_cnt))
778 ret |= POLLPRI | POLLRDBAND;
783 static int ioctl_flash_info(struct switchtec_dev *stdev,
784 struct switchtec_ioctl_flash_info __user *uinfo)
786 struct switchtec_ioctl_flash_info info = {0};
787 struct flash_info_regs __iomem *fi = stdev->mmio_flash_info;
789 info.flash_length = ioread32(&fi->flash_length);
790 info.num_partitions = SWITCHTEC_IOCTL_NUM_PARTITIONS;
792 if (copy_to_user(uinfo, &info, sizeof(info)))
798 static void set_fw_info_part(struct switchtec_ioctl_flash_part_info *info,
799 struct partition_info __iomem *pi)
801 info->address = ioread32(&pi->address);
802 info->length = ioread32(&pi->length);
805 static int ioctl_flash_part_info(struct switchtec_dev *stdev,
806 struct switchtec_ioctl_flash_part_info __user *uinfo)
808 struct switchtec_ioctl_flash_part_info info = {0};
809 struct flash_info_regs __iomem *fi = stdev->mmio_flash_info;
810 u32 active_addr = -1;
812 if (copy_from_user(&info, uinfo, sizeof(info)))
815 switch (info.flash_partition) {
816 case SWITCHTEC_IOCTL_PART_CFG0:
817 active_addr = ioread32(&fi->active_cfg);
818 set_fw_info_part(&info, &fi->cfg0);
820 case SWITCHTEC_IOCTL_PART_CFG1:
821 active_addr = ioread32(&fi->active_cfg);
822 set_fw_info_part(&info, &fi->cfg1);
824 case SWITCHTEC_IOCTL_PART_IMG0:
825 active_addr = ioread32(&fi->active_img);
826 set_fw_info_part(&info, &fi->img0);
828 case SWITCHTEC_IOCTL_PART_IMG1:
829 active_addr = ioread32(&fi->active_img);
830 set_fw_info_part(&info, &fi->img1);
832 case SWITCHTEC_IOCTL_PART_NVLOG:
833 set_fw_info_part(&info, &fi->nvlog);
835 case SWITCHTEC_IOCTL_PART_VENDOR0:
836 set_fw_info_part(&info, &fi->vendor[0]);
838 case SWITCHTEC_IOCTL_PART_VENDOR1:
839 set_fw_info_part(&info, &fi->vendor[1]);
841 case SWITCHTEC_IOCTL_PART_VENDOR2:
842 set_fw_info_part(&info, &fi->vendor[2]);
844 case SWITCHTEC_IOCTL_PART_VENDOR3:
845 set_fw_info_part(&info, &fi->vendor[3]);
847 case SWITCHTEC_IOCTL_PART_VENDOR4:
848 set_fw_info_part(&info, &fi->vendor[4]);
850 case SWITCHTEC_IOCTL_PART_VENDOR5:
851 set_fw_info_part(&info, &fi->vendor[5]);
853 case SWITCHTEC_IOCTL_PART_VENDOR6:
854 set_fw_info_part(&info, &fi->vendor[6]);
856 case SWITCHTEC_IOCTL_PART_VENDOR7:
857 set_fw_info_part(&info, &fi->vendor[7]);
863 if (info.address == active_addr)
866 if (copy_to_user(uinfo, &info, sizeof(info)))
872 static int ioctl_event_summary(struct switchtec_dev *stdev,
873 struct switchtec_user *stuser,
874 struct switchtec_ioctl_event_summary __user *usum)
876 struct switchtec_ioctl_event_summary s = {0};
880 s.global = ioread32(&stdev->mmio_sw_event->global_summary);
881 s.part_bitmap = ioread32(&stdev->mmio_sw_event->part_event_bitmap);
882 s.local_part = ioread32(&stdev->mmio_part_cfg->part_event_summary);
884 for (i = 0; i < stdev->partition_count; i++) {
885 reg = ioread32(&stdev->mmio_part_cfg_all[i].part_event_summary);
889 for (i = 0; i < SWITCHTEC_MAX_PFF_CSR; i++) {
890 reg = ioread16(&stdev->mmio_pff_csr[i].vendor_id);
891 if (reg != MICROSEMI_VENDOR_ID)
894 reg = ioread32(&stdev->mmio_pff_csr[i].pff_event_summary);
898 if (copy_to_user(usum, &s, sizeof(s)))
901 stuser->event_cnt = atomic_read(&stdev->event_cnt);
906 static u32 __iomem *global_ev_reg(struct switchtec_dev *stdev,
907 size_t offset, int index)
909 return (void __iomem *)stdev->mmio_sw_event + offset;
912 static u32 __iomem *part_ev_reg(struct switchtec_dev *stdev,
913 size_t offset, int index)
915 return (void __iomem *)&stdev->mmio_part_cfg_all[index] + offset;
918 static u32 __iomem *pff_ev_reg(struct switchtec_dev *stdev,
919 size_t offset, int index)
921 return (void __iomem *)&stdev->mmio_pff_csr[index] + offset;
924 #define EV_GLB(i, r)[i] = {offsetof(struct sw_event_regs, r), global_ev_reg}
925 #define EV_PAR(i, r)[i] = {offsetof(struct part_cfg_regs, r), part_ev_reg}
926 #define EV_PFF(i, r)[i] = {offsetof(struct pff_csr_regs, r), pff_ev_reg}
928 const struct event_reg {
930 u32 __iomem *(*map_reg)(struct switchtec_dev *stdev,
931 size_t offset, int index);
933 EV_GLB(SWITCHTEC_IOCTL_EVENT_STACK_ERROR, stack_error_event_hdr),
934 EV_GLB(SWITCHTEC_IOCTL_EVENT_PPU_ERROR, ppu_error_event_hdr),
935 EV_GLB(SWITCHTEC_IOCTL_EVENT_ISP_ERROR, isp_error_event_hdr),
936 EV_GLB(SWITCHTEC_IOCTL_EVENT_SYS_RESET, sys_reset_event_hdr),
937 EV_GLB(SWITCHTEC_IOCTL_EVENT_FW_EXC, fw_exception_hdr),
938 EV_GLB(SWITCHTEC_IOCTL_EVENT_FW_NMI, fw_nmi_hdr),
939 EV_GLB(SWITCHTEC_IOCTL_EVENT_FW_NON_FATAL, fw_non_fatal_hdr),
940 EV_GLB(SWITCHTEC_IOCTL_EVENT_FW_FATAL, fw_fatal_hdr),
941 EV_GLB(SWITCHTEC_IOCTL_EVENT_TWI_MRPC_COMP, twi_mrpc_comp_hdr),
942 EV_GLB(SWITCHTEC_IOCTL_EVENT_TWI_MRPC_COMP_ASYNC,
943 twi_mrpc_comp_async_hdr),
944 EV_GLB(SWITCHTEC_IOCTL_EVENT_CLI_MRPC_COMP, cli_mrpc_comp_hdr),
945 EV_GLB(SWITCHTEC_IOCTL_EVENT_CLI_MRPC_COMP_ASYNC,
946 cli_mrpc_comp_async_hdr),
947 EV_GLB(SWITCHTEC_IOCTL_EVENT_GPIO_INT, gpio_interrupt_hdr),
948 EV_PAR(SWITCHTEC_IOCTL_EVENT_PART_RESET, part_reset_hdr),
949 EV_PAR(SWITCHTEC_IOCTL_EVENT_MRPC_COMP, mrpc_comp_hdr),
950 EV_PAR(SWITCHTEC_IOCTL_EVENT_MRPC_COMP_ASYNC, mrpc_comp_async_hdr),
951 EV_PAR(SWITCHTEC_IOCTL_EVENT_DYN_PART_BIND_COMP, dyn_binding_hdr),
952 EV_PFF(SWITCHTEC_IOCTL_EVENT_AER_IN_P2P, aer_in_p2p_hdr),
953 EV_PFF(SWITCHTEC_IOCTL_EVENT_AER_IN_VEP, aer_in_vep_hdr),
954 EV_PFF(SWITCHTEC_IOCTL_EVENT_DPC, dpc_hdr),
955 EV_PFF(SWITCHTEC_IOCTL_EVENT_CTS, cts_hdr),
956 EV_PFF(SWITCHTEC_IOCTL_EVENT_HOTPLUG, hotplug_hdr),
957 EV_PFF(SWITCHTEC_IOCTL_EVENT_IER, ier_hdr),
958 EV_PFF(SWITCHTEC_IOCTL_EVENT_THRESH, threshold_hdr),
959 EV_PFF(SWITCHTEC_IOCTL_EVENT_POWER_MGMT, power_mgmt_hdr),
960 EV_PFF(SWITCHTEC_IOCTL_EVENT_TLP_THROTTLING, tlp_throttling_hdr),
961 EV_PFF(SWITCHTEC_IOCTL_EVENT_FORCE_SPEED, force_speed_hdr),
962 EV_PFF(SWITCHTEC_IOCTL_EVENT_CREDIT_TIMEOUT, credit_timeout_hdr),
963 EV_PFF(SWITCHTEC_IOCTL_EVENT_LINK_STATE, link_state_hdr),
966 static u32 __iomem *event_hdr_addr(struct switchtec_dev *stdev,
967 int event_id, int index)
971 if (event_id < 0 || event_id >= SWITCHTEC_IOCTL_MAX_EVENTS)
972 return ERR_PTR(-EINVAL);
974 off = event_regs[event_id].offset;
976 if (event_regs[event_id].map_reg == part_ev_reg) {
977 if (index == SWITCHTEC_IOCTL_EVENT_LOCAL_PART_IDX)
978 index = stdev->partition;
979 else if (index < 0 || index >= stdev->partition_count)
980 return ERR_PTR(-EINVAL);
981 } else if (event_regs[event_id].map_reg == pff_ev_reg) {
982 if (index < 0 || index >= stdev->pff_csr_count)
983 return ERR_PTR(-EINVAL);
986 return event_regs[event_id].map_reg(stdev, off, index);
989 static int event_ctl(struct switchtec_dev *stdev,
990 struct switchtec_ioctl_event_ctl *ctl)
996 reg = event_hdr_addr(stdev, ctl->event_id, ctl->index);
1000 hdr = ioread32(reg);
1001 for (i = 0; i < ARRAY_SIZE(ctl->data); i++)
1002 ctl->data[i] = ioread32(®[i + 1]);
1004 ctl->occurred = hdr & SWITCHTEC_EVENT_OCCURRED;
1005 ctl->count = (hdr >> 5) & 0xFF;
1007 if (!(ctl->flags & SWITCHTEC_IOCTL_EVENT_FLAG_CLEAR))
1008 hdr &= ~SWITCHTEC_EVENT_CLEAR;
1009 if (ctl->flags & SWITCHTEC_IOCTL_EVENT_FLAG_EN_POLL)
1010 hdr |= SWITCHTEC_EVENT_EN_IRQ;
1011 if (ctl->flags & SWITCHTEC_IOCTL_EVENT_FLAG_DIS_POLL)
1012 hdr &= ~SWITCHTEC_EVENT_EN_IRQ;
1013 if (ctl->flags & SWITCHTEC_IOCTL_EVENT_FLAG_EN_LOG)
1014 hdr |= SWITCHTEC_EVENT_EN_LOG;
1015 if (ctl->flags & SWITCHTEC_IOCTL_EVENT_FLAG_DIS_LOG)
1016 hdr &= ~SWITCHTEC_EVENT_EN_LOG;
1017 if (ctl->flags & SWITCHTEC_IOCTL_EVENT_FLAG_EN_CLI)
1018 hdr |= SWITCHTEC_EVENT_EN_CLI;
1019 if (ctl->flags & SWITCHTEC_IOCTL_EVENT_FLAG_DIS_CLI)
1020 hdr &= ~SWITCHTEC_EVENT_EN_CLI;
1021 if (ctl->flags & SWITCHTEC_IOCTL_EVENT_FLAG_EN_FATAL)
1022 hdr |= SWITCHTEC_EVENT_FATAL;
1023 if (ctl->flags & SWITCHTEC_IOCTL_EVENT_FLAG_DIS_FATAL)
1024 hdr &= ~SWITCHTEC_EVENT_FATAL;
1027 iowrite32(hdr, reg);
1030 if (hdr & SWITCHTEC_EVENT_EN_IRQ)
1031 ctl->flags |= SWITCHTEC_IOCTL_EVENT_FLAG_EN_POLL;
1032 if (hdr & SWITCHTEC_EVENT_EN_LOG)
1033 ctl->flags |= SWITCHTEC_IOCTL_EVENT_FLAG_EN_LOG;
1034 if (hdr & SWITCHTEC_EVENT_EN_CLI)
1035 ctl->flags |= SWITCHTEC_IOCTL_EVENT_FLAG_EN_CLI;
1036 if (hdr & SWITCHTEC_EVENT_FATAL)
1037 ctl->flags |= SWITCHTEC_IOCTL_EVENT_FLAG_EN_FATAL;
1042 static int ioctl_event_ctl(struct switchtec_dev *stdev,
1043 struct switchtec_ioctl_event_ctl __user *uctl)
1047 struct switchtec_ioctl_event_ctl ctl;
1049 if (copy_from_user(&ctl, uctl, sizeof(ctl)))
1052 if (ctl.event_id >= SWITCHTEC_IOCTL_MAX_EVENTS)
1055 if (ctl.flags & SWITCHTEC_IOCTL_EVENT_FLAG_UNUSED)
1058 if (ctl.index == SWITCHTEC_IOCTL_EVENT_IDX_ALL) {
1059 if (event_regs[ctl.event_id].map_reg == global_ev_reg)
1061 else if (event_regs[ctl.event_id].map_reg == part_ev_reg)
1062 nr_idxs = stdev->partition_count;
1063 else if (event_regs[ctl.event_id].map_reg == pff_ev_reg)
1064 nr_idxs = stdev->pff_csr_count;
1068 for (ctl.index = 0; ctl.index < nr_idxs; ctl.index++) {
1069 ret = event_ctl(stdev, &ctl);
1074 ret = event_ctl(stdev, &ctl);
1079 if (copy_to_user(uctl, &ctl, sizeof(ctl)))
1085 static int ioctl_pff_to_port(struct switchtec_dev *stdev,
1086 struct switchtec_ioctl_pff_port *up)
1090 struct part_cfg_regs *pcfg;
1091 struct switchtec_ioctl_pff_port p;
1093 if (copy_from_user(&p, up, sizeof(p)))
1097 for (part = 0; part < stdev->partition_count; part++) {
1098 pcfg = &stdev->mmio_part_cfg_all[part];
1101 reg = ioread32(&pcfg->usp_pff_inst_id);
1107 reg = ioread32(&pcfg->vep_pff_inst_id);
1109 p.port = SWITCHTEC_IOCTL_PFF_VEP;
1113 for (i = 0; i < ARRAY_SIZE(pcfg->dsp_pff_inst_id); i++) {
1114 reg = ioread32(&pcfg->dsp_pff_inst_id[i]);
1126 if (copy_to_user(up, &p, sizeof(p)))
1132 static int ioctl_port_to_pff(struct switchtec_dev *stdev,
1133 struct switchtec_ioctl_pff_port *up)
1135 struct switchtec_ioctl_pff_port p;
1136 struct part_cfg_regs *pcfg;
1138 if (copy_from_user(&p, up, sizeof(p)))
1141 if (p.partition == SWITCHTEC_IOCTL_EVENT_LOCAL_PART_IDX)
1142 pcfg = stdev->mmio_part_cfg;
1143 else if (p.partition < stdev->partition_count)
1144 pcfg = &stdev->mmio_part_cfg_all[p.partition];
1150 p.pff = ioread32(&pcfg->usp_pff_inst_id);
1152 case SWITCHTEC_IOCTL_PFF_VEP:
1153 p.pff = ioread32(&pcfg->vep_pff_inst_id);
1156 if (p.port > ARRAY_SIZE(pcfg->dsp_pff_inst_id))
1158 p.pff = ioread32(&pcfg->dsp_pff_inst_id[p.port - 1]);
1162 if (copy_to_user(up, &p, sizeof(p)))
1168 static long switchtec_dev_ioctl(struct file *filp, unsigned int cmd,
1171 struct switchtec_user *stuser = filp->private_data;
1172 struct switchtec_dev *stdev = stuser->stdev;
1174 void __user *argp = (void __user *)arg;
1176 rc = lock_mutex_and_test_alive(stdev);
1181 case SWITCHTEC_IOCTL_FLASH_INFO:
1182 rc = ioctl_flash_info(stdev, argp);
1184 case SWITCHTEC_IOCTL_FLASH_PART_INFO:
1185 rc = ioctl_flash_part_info(stdev, argp);
1187 case SWITCHTEC_IOCTL_EVENT_SUMMARY:
1188 rc = ioctl_event_summary(stdev, stuser, argp);
1190 case SWITCHTEC_IOCTL_EVENT_CTL:
1191 rc = ioctl_event_ctl(stdev, argp);
1193 case SWITCHTEC_IOCTL_PFF_TO_PORT:
1194 rc = ioctl_pff_to_port(stdev, argp);
1196 case SWITCHTEC_IOCTL_PORT_TO_PFF:
1197 rc = ioctl_port_to_pff(stdev, argp);
1204 mutex_unlock(&stdev->mrpc_mutex);
1208 static const struct file_operations switchtec_fops = {
1209 .owner = THIS_MODULE,
1210 .open = switchtec_dev_open,
1211 .release = switchtec_dev_release,
1212 .write = switchtec_dev_write,
1213 .read = switchtec_dev_read,
1214 .poll = switchtec_dev_poll,
1215 .unlocked_ioctl = switchtec_dev_ioctl,
1216 .compat_ioctl = switchtec_dev_ioctl,
1219 static void stdev_release(struct device *dev)
1221 struct switchtec_dev *stdev = to_stdev(dev);
1226 static void stdev_kill(struct switchtec_dev *stdev)
1228 struct switchtec_user *stuser, *tmpuser;
1230 pci_clear_master(stdev->pdev);
1232 cancel_delayed_work_sync(&stdev->mrpc_timeout);
1234 /* Mark the hardware as unavailable and complete all completions */
1235 mutex_lock(&stdev->mrpc_mutex);
1236 stdev->alive = false;
1238 /* Wake up and kill any users waiting on an MRPC request */
1239 list_for_each_entry_safe(stuser, tmpuser, &stdev->mrpc_queue, list) {
1240 complete_all(&stuser->comp);
1241 list_del_init(&stuser->list);
1245 mutex_unlock(&stdev->mrpc_mutex);
1247 /* Wake up any users waiting on event_wq */
1248 wake_up_interruptible(&stdev->event_wq);
1251 static struct switchtec_dev *stdev_create(struct pci_dev *pdev)
1253 struct switchtec_dev *stdev;
1259 stdev = kzalloc_node(sizeof(*stdev), GFP_KERNEL,
1260 dev_to_node(&pdev->dev));
1262 return ERR_PTR(-ENOMEM);
1264 stdev->alive = true;
1266 INIT_LIST_HEAD(&stdev->mrpc_queue);
1267 mutex_init(&stdev->mrpc_mutex);
1268 stdev->mrpc_busy = 0;
1269 INIT_WORK(&stdev->mrpc_work, mrpc_event_work);
1270 INIT_DELAYED_WORK(&stdev->mrpc_timeout, mrpc_timeout_work);
1271 init_waitqueue_head(&stdev->event_wq);
1272 atomic_set(&stdev->event_cnt, 0);
1275 device_initialize(dev);
1276 dev->class = switchtec_class;
1277 dev->parent = &pdev->dev;
1278 dev->groups = switchtec_device_groups;
1279 dev->release = stdev_release;
1281 minor = ida_simple_get(&switchtec_minor_ida, 0, 0,
1288 dev->devt = MKDEV(MAJOR(switchtec_devt), minor);
1289 dev_set_name(dev, "switchtec%d", minor);
1291 cdev = &stdev->cdev;
1292 cdev_init(cdev, &switchtec_fops);
1293 cdev->owner = THIS_MODULE;
1298 put_device(&stdev->dev);
1302 static int mask_event(struct switchtec_dev *stdev, int eid, int idx)
1304 size_t off = event_regs[eid].offset;
1305 u32 __iomem *hdr_reg;
1308 hdr_reg = event_regs[eid].map_reg(stdev, off, idx);
1309 hdr = ioread32(hdr_reg);
1311 if (!(hdr & SWITCHTEC_EVENT_OCCURRED && hdr & SWITCHTEC_EVENT_EN_IRQ))
1314 dev_dbg(&stdev->dev, "%s: %d %d %x\n", __func__, eid, idx, hdr);
1315 hdr &= ~(SWITCHTEC_EVENT_EN_IRQ | SWITCHTEC_EVENT_OCCURRED);
1316 iowrite32(hdr, hdr_reg);
1321 static int mask_all_events(struct switchtec_dev *stdev, int eid)
1326 if (event_regs[eid].map_reg == part_ev_reg) {
1327 for (idx = 0; idx < stdev->partition_count; idx++)
1328 count += mask_event(stdev, eid, idx);
1329 } else if (event_regs[eid].map_reg == pff_ev_reg) {
1330 for (idx = 0; idx < stdev->pff_csr_count; idx++) {
1331 if (!stdev->pff_local[idx])
1333 count += mask_event(stdev, eid, idx);
1336 count += mask_event(stdev, eid, 0);
1342 static irqreturn_t switchtec_event_isr(int irq, void *dev)
1344 struct switchtec_dev *stdev = dev;
1346 irqreturn_t ret = IRQ_NONE;
1347 int eid, event_count = 0;
1349 reg = ioread32(&stdev->mmio_part_cfg->mrpc_comp_hdr);
1350 if (reg & SWITCHTEC_EVENT_OCCURRED) {
1351 dev_dbg(&stdev->dev, "%s: mrpc comp\n", __func__);
1353 schedule_work(&stdev->mrpc_work);
1354 iowrite32(reg, &stdev->mmio_part_cfg->mrpc_comp_hdr);
1357 for (eid = 0; eid < SWITCHTEC_IOCTL_MAX_EVENTS; eid++)
1358 event_count += mask_all_events(stdev, eid);
1361 atomic_inc(&stdev->event_cnt);
1362 wake_up_interruptible(&stdev->event_wq);
1363 dev_dbg(&stdev->dev, "%s: %d events\n", __func__,
1371 static int switchtec_init_isr(struct switchtec_dev *stdev)
1376 nvecs = pci_alloc_irq_vectors(stdev->pdev, 1, 4,
1377 PCI_IRQ_MSIX | PCI_IRQ_MSI);
1381 event_irq = ioread32(&stdev->mmio_part_cfg->vep_vector_number);
1382 if (event_irq < 0 || event_irq >= nvecs)
1385 event_irq = pci_irq_vector(stdev->pdev, event_irq);
1389 return devm_request_irq(&stdev->pdev->dev, event_irq,
1390 switchtec_event_isr, 0,
1391 KBUILD_MODNAME, stdev);
1394 static void init_pff(struct switchtec_dev *stdev)
1398 struct part_cfg_regs *pcfg = stdev->mmio_part_cfg;
1400 for (i = 0; i < SWITCHTEC_MAX_PFF_CSR; i++) {
1401 reg = ioread16(&stdev->mmio_pff_csr[i].vendor_id);
1402 if (reg != MICROSEMI_VENDOR_ID)
1406 stdev->pff_csr_count = i;
1408 reg = ioread32(&pcfg->usp_pff_inst_id);
1409 if (reg < SWITCHTEC_MAX_PFF_CSR)
1410 stdev->pff_local[reg] = 1;
1412 reg = ioread32(&pcfg->vep_pff_inst_id);
1413 if (reg < SWITCHTEC_MAX_PFF_CSR)
1414 stdev->pff_local[reg] = 1;
1416 for (i = 0; i < ARRAY_SIZE(pcfg->dsp_pff_inst_id); i++) {
1417 reg = ioread32(&pcfg->dsp_pff_inst_id[i]);
1418 if (reg < SWITCHTEC_MAX_PFF_CSR)
1419 stdev->pff_local[reg] = 1;
1423 static int switchtec_init_pci(struct switchtec_dev *stdev,
1424 struct pci_dev *pdev)
1428 rc = pcim_enable_device(pdev);
1432 rc = pcim_iomap_regions(pdev, 0x1, KBUILD_MODNAME);
1436 pci_set_master(pdev);
1438 stdev->mmio = pcim_iomap_table(pdev)[0];
1439 stdev->mmio_mrpc = stdev->mmio + SWITCHTEC_GAS_MRPC_OFFSET;
1440 stdev->mmio_sw_event = stdev->mmio + SWITCHTEC_GAS_SW_EVENT_OFFSET;
1441 stdev->mmio_sys_info = stdev->mmio + SWITCHTEC_GAS_SYS_INFO_OFFSET;
1442 stdev->mmio_flash_info = stdev->mmio + SWITCHTEC_GAS_FLASH_INFO_OFFSET;
1443 stdev->mmio_ntb = stdev->mmio + SWITCHTEC_GAS_NTB_OFFSET;
1444 stdev->partition = ioread8(&stdev->mmio_sys_info->partition_id);
1445 stdev->partition_count = ioread8(&stdev->mmio_ntb->partition_count);
1446 stdev->mmio_part_cfg_all = stdev->mmio + SWITCHTEC_GAS_PART_CFG_OFFSET;
1447 stdev->mmio_part_cfg = &stdev->mmio_part_cfg_all[stdev->partition];
1448 stdev->mmio_pff_csr = stdev->mmio + SWITCHTEC_GAS_PFF_CSR_OFFSET;
1450 if (stdev->partition_count < 1)
1451 stdev->partition_count = 1;
1455 pci_set_drvdata(pdev, stdev);
1460 static int switchtec_pci_probe(struct pci_dev *pdev,
1461 const struct pci_device_id *id)
1463 struct switchtec_dev *stdev;
1466 stdev = stdev_create(pdev);
1468 return PTR_ERR(stdev);
1470 rc = switchtec_init_pci(stdev, pdev);
1474 rc = switchtec_init_isr(stdev);
1476 dev_err(&stdev->dev, "failed to init isr.\n");
1480 iowrite32(SWITCHTEC_EVENT_CLEAR |
1481 SWITCHTEC_EVENT_EN_IRQ,
1482 &stdev->mmio_part_cfg->mrpc_comp_hdr);
1484 rc = cdev_device_add(&stdev->cdev, &stdev->dev);
1488 dev_info(&stdev->dev, "Management device registered.\n");
1495 ida_simple_remove(&switchtec_minor_ida, MINOR(stdev->dev.devt));
1496 put_device(&stdev->dev);
1500 static void switchtec_pci_remove(struct pci_dev *pdev)
1502 struct switchtec_dev *stdev = pci_get_drvdata(pdev);
1504 pci_set_drvdata(pdev, NULL);
1506 cdev_device_del(&stdev->cdev, &stdev->dev);
1507 ida_simple_remove(&switchtec_minor_ida, MINOR(stdev->dev.devt));
1508 dev_info(&stdev->dev, "unregistered.\n");
1511 put_device(&stdev->dev);
1514 #define SWITCHTEC_PCI_DEVICE(device_id) \
1516 .vendor = MICROSEMI_VENDOR_ID, \
1517 .device = device_id, \
1518 .subvendor = PCI_ANY_ID, \
1519 .subdevice = PCI_ANY_ID, \
1520 .class = MICROSEMI_MGMT_CLASSCODE, \
1521 .class_mask = 0xFFFFFFFF, \
1524 .vendor = MICROSEMI_VENDOR_ID, \
1525 .device = device_id, \
1526 .subvendor = PCI_ANY_ID, \
1527 .subdevice = PCI_ANY_ID, \
1528 .class = MICROSEMI_NTB_CLASSCODE, \
1529 .class_mask = 0xFFFFFFFF, \
1532 static const struct pci_device_id switchtec_pci_tbl[] = {
1533 SWITCHTEC_PCI_DEVICE(0x8531), //PFX 24xG3
1534 SWITCHTEC_PCI_DEVICE(0x8532), //PFX 32xG3
1535 SWITCHTEC_PCI_DEVICE(0x8533), //PFX 48xG3
1536 SWITCHTEC_PCI_DEVICE(0x8534), //PFX 64xG3
1537 SWITCHTEC_PCI_DEVICE(0x8535), //PFX 80xG3
1538 SWITCHTEC_PCI_DEVICE(0x8536), //PFX 96xG3
1539 SWITCHTEC_PCI_DEVICE(0x8543), //PSX 48xG3
1540 SWITCHTEC_PCI_DEVICE(0x8544), //PSX 64xG3
1541 SWITCHTEC_PCI_DEVICE(0x8545), //PSX 80xG3
1542 SWITCHTEC_PCI_DEVICE(0x8546), //PSX 96xG3
1545 MODULE_DEVICE_TABLE(pci, switchtec_pci_tbl);
1547 static struct pci_driver switchtec_pci_driver = {
1548 .name = KBUILD_MODNAME,
1549 .id_table = switchtec_pci_tbl,
1550 .probe = switchtec_pci_probe,
1551 .remove = switchtec_pci_remove,
1554 static int __init switchtec_init(void)
1558 rc = alloc_chrdev_region(&switchtec_devt, 0, max_devices,
1563 switchtec_class = class_create(THIS_MODULE, "switchtec");
1564 if (IS_ERR(switchtec_class)) {
1565 rc = PTR_ERR(switchtec_class);
1566 goto err_create_class;
1569 rc = pci_register_driver(&switchtec_pci_driver);
1571 goto err_pci_register;
1573 pr_info(KBUILD_MODNAME ": loaded.\n");
1578 class_destroy(switchtec_class);
1581 unregister_chrdev_region(switchtec_devt, max_devices);
1585 module_init(switchtec_init);
1587 static void __exit switchtec_exit(void)
1589 pci_unregister_driver(&switchtec_pci_driver);
1590 class_destroy(switchtec_class);
1591 unregister_chrdev_region(switchtec_devt, max_devices);
1592 ida_destroy(&switchtec_minor_ida);
1594 pr_info(KBUILD_MODNAME ": unloaded.\n");
1596 module_exit(switchtec_exit);