tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

misc: mic: cleanups for "--strict" checkpatch.

These changes were mostly authored by Joe Perches <joe@perches.com>
@ https://lkml.org/lkml/2013/9/5/602

Reported-by: Joe Perches <joe@perches.com>
Signed-off-by: Ashutosh Dixit <ashutosh.dixit@intel.com>
Signed-off-by: Dasaratharaman Chandramouli <dasaratharaman.chandramouli@intel.com>
Signed-off-by: Nikhil Rao <nikhil.rao@intel.com>
Signed-off-by: Harshavardhan R Kharche <harshavardhan.r.kharche@intel.com>
Signed-off-by: Sudeep Dutt <sudeep.dutt@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

authored by

Ashutosh Dixit and committed by
Greg Kroah-Hartman ced2c60f 4aa79961

+158 -167
+33 -32
Documentation/mic/mpssd/mpssd.c
··· 246 246 if (*dev) 247 247 strncpy(ifr.ifr_name, dev, IFNAMSIZ); 248 248 249 - err = ioctl(fd, TUNSETIFF, (void *) &ifr); 249 + err = ioctl(fd, TUNSETIFF, (void *)&ifr); 250 250 if (err < 0) { 251 251 mpsslog("%s %s %d TUNSETIFF failed %s\n", 252 252 mic->name, __func__, __LINE__, strerror(errno)); ··· 363 363 { 364 364 if (copy->out_len != sum_iovec_len(copy)) { 365 365 mpsslog("%s %s %d BUG copy->out_len 0x%x len 0x%x\n", 366 - mic->name, __func__, __LINE__, 366 + mic->name, __func__, __LINE__, 367 367 copy->out_len, sum_iovec_len(copy)); 368 368 assert(copy->out_len == sum_iovec_len(copy)); 369 369 } ··· 372 372 /* Display an iovec */ 373 373 static void 374 374 disp_iovec(struct mic_info *mic, struct mic_copy_desc *copy, 375 - const char *s, int line) 375 + const char *s, int line) 376 376 { 377 377 int i; 378 378 ··· 401 401 /* Central API which triggers the copies */ 402 402 static int 403 403 mic_virtio_copy(struct mic_info *mic, int fd, 404 - struct mic_vring *vr, struct mic_copy_desc *copy) 404 + struct mic_vring *vr, struct mic_copy_desc *copy) 405 405 { 406 406 int ret; 407 407 ··· 440 440 vr0->info = vr0->va + 441 441 vring_size(MIC_VRING_ENTRIES, MIC_VIRTIO_RING_ALIGN); 442 442 vring_init(&vr0->vr, 443 - MIC_VRING_ENTRIES, vr0->va, MIC_VIRTIO_RING_ALIGN); 443 + MIC_VRING_ENTRIES, vr0->va, MIC_VIRTIO_RING_ALIGN); 444 444 mpsslog("%s %s vr0 %p vr0->info %p vr_size 0x%x vring 0x%x ", 445 445 __func__, mic->name, vr0->va, vr0->info, vr_size, 446 446 vring_size(MIC_VRING_ENTRIES, MIC_VIRTIO_RING_ALIGN)); ··· 453 453 vr1->info = vr1->va + vring_size(MIC_VRING_ENTRIES, 454 454 MIC_VIRTIO_RING_ALIGN); 455 455 vring_init(&vr1->vr, 456 - MIC_VRING_ENTRIES, vr1->va, MIC_VIRTIO_RING_ALIGN); 456 + MIC_VRING_ENTRIES, vr1->va, MIC_VIRTIO_RING_ALIGN); 457 457 mpsslog("%s %s vr1 %p vr1->info %p vr_size 0x%x vring 0x%x ", 458 458 __func__, mic->name, vr1->va, vr1->info, vr_size, 459 459 vring_size(MIC_VRING_ENTRIES, MIC_VIRTIO_RING_ALIGN)); ··· 551 551 net_poll[NET_FD_TUN].events = POLLIN; 552 552 553 553 if (MAP_FAILED == init_vr(mic, mic->mic_net.virtio_net_fd, 554 - VIRTIO_ID_NET, &tx_vr, &rx_vr, 554 + VIRTIO_ID_NET, &tx_vr, &rx_vr, 555 555 virtnet_dev_page.dd.num_vq)) { 556 556 mpsslog("%s init_vr failed %s\n", 557 557 mic->name, strerror(errno)); ··· 576 576 } 577 577 if (!(desc->status & VIRTIO_CONFIG_S_DRIVER_OK)) 578 578 wait_for_card_driver(mic, mic->mic_net.virtio_net_fd, 579 - VIRTIO_ID_NET); 579 + VIRTIO_ID_NET); 580 580 /* 581 581 * Check if there is data to be read from TUN and write to 582 582 * virtio net fd if there is. ··· 587 587 copy.iov, copy.iovcnt); 588 588 if (len > 0) { 589 589 struct virtio_net_hdr *hdr 590 - = (struct virtio_net_hdr *) vnet_hdr[0]; 590 + = (struct virtio_net_hdr *)vnet_hdr[0]; 591 591 592 592 /* Disable checksums on the card since we are on 593 593 a reliable PCIe link */ ··· 606 606 #endif 607 607 spin_for_descriptors(mic, &tx_vr); 608 608 txrx_prepare(VIRTIO_ID_NET, 1, &tx_vr, &copy, 609 - len); 609 + len); 610 610 611 611 err = mic_virtio_copy(mic, 612 612 mic->mic_net.virtio_net_fd, &tx_vr, ··· 644 644 le16toh(rx_vr.vr.avail->idx)) { 645 645 copy.iov = iov1; 646 646 txrx_prepare(VIRTIO_ID_NET, 0, &rx_vr, &copy, 647 - MAX_NET_PKT_SIZE 647 + MAX_NET_PKT_SIZE 648 648 + sizeof(struct virtio_net_hdr)); 649 649 650 650 err = mic_virtio_copy(mic, ··· 669 669 verify_out_len(mic, &copy); 670 670 #ifdef DEBUG 671 671 disp_iovec(mic, copy, __func__, 672 - __LINE__); 672 + __LINE__); 673 673 mpsslog("%s %s %d ", 674 674 mic->name, __func__, __LINE__); 675 675 mpsslog("read from net 0x%lx\n", ··· 686 686 } else { 687 687 #ifdef DEBUG 688 688 disp_iovec(mic, &copy, __func__, 689 - __LINE__); 689 + __LINE__); 690 690 mpsslog("%s %s %d ", 691 691 mic->name, __func__, 692 692 __LINE__); ··· 750 750 err = grantpt(pty_fd); 751 751 if (err < 0) { 752 752 mpsslog("can't grant access: %s %s\n", 753 - pts_name, strerror(errno)); 753 + pts_name, strerror(errno)); 754 754 goto _close_pty; 755 755 } 756 756 err = unlockpt(pty_fd); 757 757 if (err < 0) { 758 758 mpsslog("can't unlock a pseudoterminal: %s %s\n", 759 - pts_name, strerror(errno)); 759 + pts_name, strerror(errno)); 760 760 goto _close_pty; 761 761 } 762 762 console_poll[MONITOR_FD].fd = pty_fd; ··· 766 766 console_poll[VIRTIO_CONSOLE_FD].events = POLLIN; 767 767 768 768 if (MAP_FAILED == init_vr(mic, mic->mic_console.virtio_console_fd, 769 - VIRTIO_ID_CONSOLE, &tx_vr, &rx_vr, 769 + VIRTIO_ID_CONSOLE, &tx_vr, &rx_vr, 770 770 virtcons_dev_page.dd.num_vq)) { 771 771 mpsslog("%s init_vr failed %s\n", 772 772 mic->name, strerror(errno)); ··· 787 787 } 788 788 if (!(desc->status & VIRTIO_CONFIG_S_DRIVER_OK)) 789 789 wait_for_card_driver(mic, 790 - mic->mic_console.virtio_console_fd, 790 + mic->mic_console.virtio_console_fd, 791 791 VIRTIO_ID_CONSOLE); 792 792 793 793 if (console_poll[MONITOR_FD].revents & POLLIN) { ··· 802 802 #endif 803 803 spin_for_descriptors(mic, &tx_vr); 804 804 txrx_prepare(VIRTIO_ID_CONSOLE, 1, &tx_vr, 805 - &copy, len); 805 + &copy, len); 806 806 807 807 err = mic_virtio_copy(mic, 808 808 mic->mic_console.virtio_console_fd, ··· 837 837 le16toh(rx_vr.vr.avail->idx)) { 838 838 copy.iov = iov1; 839 839 txrx_prepare(VIRTIO_ID_CONSOLE, 0, &rx_vr, 840 - &copy, PAGE_SIZE); 840 + &copy, PAGE_SIZE); 841 841 842 842 err = mic_virtio_copy(mic, 843 843 mic->mic_console.virtio_console_fd, ··· 848 848 verify_out_len(mic, &copy); 849 849 #ifdef DEBUG 850 850 disp_iovec(mic, copy, __func__, 851 - __LINE__); 851 + __LINE__); 852 852 mpsslog("%s %s %d ", 853 853 mic->name, __func__, __LINE__); 854 854 mpsslog("read from net 0x%lx\n", ··· 865 865 } else { 866 866 #ifdef DEBUG 867 867 disp_iovec(mic, copy, __func__, 868 - __LINE__); 868 + __LINE__); 869 869 mpsslog("%s %s %d ", 870 870 mic->name, __func__, 871 871 __LINE__); ··· 1033 1033 } 1034 1034 add_virtio_device(mic, &virtblk_dev_page.dd); 1035 1035 if (MAP_FAILED == init_vr(mic, mic->mic_virtblk.virtio_block_fd, 1036 - VIRTIO_ID_BLOCK, vring, NULL, virtblk_dev_page.dd.num_vq)) { 1036 + VIRTIO_ID_BLOCK, vring, NULL, 1037 + virtblk_dev_page.dd.num_vq)) { 1037 1038 mpsslog("%s init_vr failed %s\n", 1038 1039 mic->name, strerror(errno)); 1039 1040 return false; ··· 1061 1060 { 1062 1061 if (le32toh(desc->len) != sizeof(struct virtio_blk_outhdr)) { 1063 1062 mpsslog("%s() %d: length is not sizeof(virtio_blk_outhd)\n", 1064 - __func__, __LINE__); 1063 + __func__, __LINE__); 1065 1064 return -EIO; 1066 1065 } 1067 1066 if (!(le16toh(desc->flags) & VRING_DESC_F_NEXT)) { ··· 1133 1132 static void * 1134 1133 virtio_block(void *arg) 1135 1134 { 1136 - struct mic_info *mic = (struct mic_info *) arg; 1135 + struct mic_info *mic = (struct mic_info *)arg; 1137 1136 int ret; 1138 1137 struct pollfd block_poll; 1139 1138 struct mic_vring vring; ··· 1220 1219 status = 0; 1221 1220 fos = mic->mic_virtblk.backend_addr + 1222 1221 (hdr.sector * SECTOR_SIZE); 1223 - buffer_desc_idx = desc_idx = 1224 - next_desc(desc); 1222 + buffer_desc_idx = next_desc(desc); 1223 + desc_idx = buffer_desc_idx; 1225 1224 for (desc = &vring.vr.desc[buffer_desc_idx]; 1226 1225 desc->flags & VRING_DESC_F_NEXT; 1227 1226 desc_idx = next_desc(desc), ··· 1256 1255 iovec, 1257 1256 piov - iovec); 1258 1257 if (ret < 0 && 1259 - status != 0) 1258 + status != 0) 1260 1259 status = ret; 1261 1260 } 1262 1261 /* write status and update used pointer */ ··· 1392 1391 char value[4096]; 1393 1392 1394 1393 snprintf(pathname, PATH_MAX - 1, "%s/%s/%s", 1395 - MICSYSFSDIR, mic->name, "state"); 1394 + MICSYSFSDIR, mic->name, "state"); 1396 1395 1397 1396 fd = open(pathname, O_RDONLY); 1398 1397 if (fd < 0) { ··· 1561 1560 virtio_console, mic); 1562 1561 if (err) 1563 1562 mpsslog("%s virtcons pthread_create failed %s\n", 1564 - mic->name, strerror(err)); 1563 + mic->name, strerror(err)); 1565 1564 err = pthread_create(&mic->mic_net.net_thread, NULL, 1566 1565 virtio_net, mic); 1567 1566 if (err) 1568 1567 mpsslog("%s virtnet pthread_create failed %s\n", 1569 - mic->name, strerror(err)); 1568 + mic->name, strerror(err)); 1570 1569 err = pthread_create(&mic->mic_virtblk.block_thread, NULL, 1571 1570 virtio_block, mic); 1572 1571 if (err) 1573 1572 mpsslog("%s virtblk pthread_create failed %s\n", 1574 - mic->name, strerror(err)); 1573 + mic->name, strerror(err)); 1575 1574 sigemptyset(&act.sa_mask); 1576 1575 err = sigaction(SIGUSR1, &act, NULL); 1577 1576 if (err) 1578 1577 mpsslog("%s sigaction SIGUSR1 failed %s\n", 1579 - mic->name, strerror(errno)); 1578 + mic->name, strerror(errno)); 1580 1579 while (1) 1581 1580 sleep(60); 1582 1581 case -1:
+2 -2
Documentation/mic/mpssd/sysfs.c
··· 35 35 snprintf(filename, PATH_MAX, "%s/%s", MICSYSFSDIR, entry); 36 36 else 37 37 snprintf(filename, PATH_MAX, 38 - "%s/%s/%s", MICSYSFSDIR, dir, entry); 38 + "%s/%s/%s", MICSYSFSDIR, dir, entry); 39 39 40 40 fd = open(filename, O_RDONLY); 41 41 if (fd < 0) { ··· 75 75 snprintf(filename, PATH_MAX, "%s/%s", MICSYSFSDIR, entry); 76 76 else 77 77 snprintf(filename, PATH_MAX, "%s/%s/%s", 78 - MICSYSFSDIR, dir, entry); 78 + MICSYSFSDIR, dir, entry); 79 79 80 80 oldvalue = readsysfs(dir, entry); 81 81
-1
drivers/misc/mic/card/mic_device.c
··· 167 167 return (struct mic_irq *)cookie; 168 168 err: 169 169 return ERR_PTR(rc); 170 - 171 170 } 172 171 173 172 /**
+8 -9
drivers/misc/mic/card/mic_virtio.c
··· 103 103 for (i = 0; i < bits; i++) { 104 104 if (test_bit(i, vdev->features)) 105 105 iowrite8(ioread8(&out_features[i / 8]) | (1 << (i % 8)), 106 - &out_features[i / 8]); 106 + &out_features[i / 8]); 107 107 } 108 108 } 109 109 ··· 197 197 static void mic_del_vq(struct virtqueue *vq, int n) 198 198 { 199 199 struct mic_vdev *mvdev = to_micvdev(vq->vdev); 200 - struct vring *vr = (struct vring *) (vq + 1); 200 + struct vring *vr = (struct vring *)(vq + 1); 201 201 202 - free_pages((unsigned long) vr->used, 203 - get_order(mvdev->used_size[n])); 202 + free_pages((unsigned long) vr->used, get_order(mvdev->used_size[n])); 204 203 vring_del_virtqueue(vq); 205 204 mic_card_unmap(mvdev->mdev, mvdev->vr[n]); 206 205 mvdev->vr[n] = NULL; ··· 273 274 /* Allocate and reassign used ring now */ 274 275 mvdev->used_size[index] = PAGE_ALIGN(sizeof(__u16) * 3 + 275 276 sizeof(struct vring_used_elem) * config.num); 276 - used = (void *) __get_free_pages(GFP_KERNEL | __GFP_ZERO, 277 - get_order(mvdev->used_size[index])); 277 + used = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO, 278 + get_order(mvdev->used_size[index])); 278 279 if (!used) { 279 280 err = -ENOMEM; 280 281 dev_err(mic_dev(mvdev), "%s %d err %d\n", ··· 290 291 * vring_new_virtqueue() would ensure that 291 292 * (&vq->vring == (struct vring *) (&vq->vq + 1)); 292 293 */ 293 - vr = (struct vring *) (vq + 1); 294 + vr = (struct vring *)(vq + 1); 294 295 vr->used = used; 295 296 296 297 vq->priv = mvdev; ··· 543 544 if (dev) { 544 545 if (remove) 545 546 iowrite8(MIC_VIRTIO_PARAM_DEV_REMOVE, 546 - &dc->config_change); 547 + &dc->config_change); 547 548 put_device(dev); 548 549 mic_handle_config_change(d, i, mdrv); 549 550 ret = mic_remove_device(d, i, mdrv); ··· 558 559 559 560 /* new device */ 560 561 dev_dbg(mdrv->dev, "%s %d Adding new virtio device %p\n", 561 - __func__, __LINE__, d); 562 + __func__, __LINE__, d); 562 563 if (!remove) 563 564 mic_add_device(d, i, mdrv); 564 565 }
+2 -2
drivers/misc/mic/card/mic_x100.c
··· 66 66 /* Ensure that the interrupt is ordered w.r.t previous stores. */ 67 67 wmb(); 68 68 mic_mmio_write(mw, MIC_X100_SBOX_SDBIC0_DBREQ_BIT, 69 - MIC_X100_SBOX_BASE_ADDRESS + 70 - (MIC_X100_SBOX_SDBIC0 + (4 * doorbell))); 69 + MIC_X100_SBOX_BASE_ADDRESS + 70 + (MIC_X100_SBOX_SDBIC0 + (4 * doorbell))); 71 71 } 72 72 73 73 /**
+43 -47
drivers/misc/mic/host/mic_debugfs.c
··· 103 103 unsigned long flags; 104 104 105 105 seq_printf(s, "MIC %-2d |%-10s| %-14s %-10s\n", 106 - mdev->id, "SMPT entry", "SW DMA addr", "RefCount"); 106 + mdev->id, "SMPT entry", "SW DMA addr", "RefCount"); 107 107 seq_puts(s, "====================================================\n"); 108 108 109 109 if (mdev->smpt) { ··· 111 111 spin_lock_irqsave(&smpt_info->smpt_lock, flags); 112 112 for (i = 0; i < smpt_info->info.num_reg; i++) { 113 113 seq_printf(s, "%9s|%-10d| %-#14llx %-10lld\n", 114 - " ", i, smpt_info->entry[i].dma_addr, 115 - smpt_info->entry[i].ref_count); 114 + " ", i, smpt_info->entry[i].dma_addr, 115 + smpt_info->entry[i].ref_count); 116 116 } 117 117 spin_unlock_irqrestore(&smpt_info->smpt_lock, flags); 118 118 } ··· 203 203 int i, j; 204 204 205 205 seq_printf(s, "Bootparam: magic 0x%x\n", 206 - bootparam->magic); 206 + bootparam->magic); 207 207 seq_printf(s, "Bootparam: h2c_shutdown_db %d\n", 208 - bootparam->h2c_shutdown_db); 208 + bootparam->h2c_shutdown_db); 209 209 seq_printf(s, "Bootparam: h2c_config_db %d\n", 210 - bootparam->h2c_config_db); 210 + bootparam->h2c_config_db); 211 211 seq_printf(s, "Bootparam: c2h_shutdown_db %d\n", 212 - bootparam->c2h_shutdown_db); 212 + bootparam->c2h_shutdown_db); 213 213 seq_printf(s, "Bootparam: shutdown_status %d\n", 214 - bootparam->shutdown_status); 214 + bootparam->shutdown_status); 215 215 seq_printf(s, "Bootparam: shutdown_card %d\n", 216 - bootparam->shutdown_card); 216 + bootparam->shutdown_card); 217 217 218 218 for (i = sizeof(*bootparam); i < MIC_DP_SIZE; 219 219 i += mic_total_desc_size(d)) { ··· 239 239 seq_printf(s, "address 0x%llx ", vqconfig->address); 240 240 seq_printf(s, "num %d ", vqconfig->num); 241 241 seq_printf(s, "used address 0x%llx\n", 242 - vqconfig->used_address); 242 + vqconfig->used_address); 243 243 } 244 244 245 - features = (__u32 *) mic_vq_features(d); 245 + features = (__u32 *)mic_vq_features(d); 246 246 seq_printf(s, "Features: Host 0x%x ", features[0]); 247 247 seq_printf(s, "Guest 0x%x\n", features[1]); 248 248 ··· 256 256 seq_printf(s, "Guest Ack %d ", dc->guest_ack); 257 257 seq_printf(s, "Host ack %d\n", dc->host_ack); 258 258 seq_printf(s, "Used address updated %d ", 259 - dc->used_address_updated); 259 + dc->used_address_updated); 260 260 seq_printf(s, "Vdev 0x%llx\n", dc->vdev); 261 261 seq_printf(s, "c2h doorbell %d ", dc->c2h_vdev_db); 262 262 seq_printf(s, "h2c doorbell %d\n", dc->h2c_vdev_db); ··· 294 294 list_for_each_safe(pos, tmp, &mdev->vdev_list) { 295 295 mvdev = list_entry(pos, struct mic_vdev, list); 296 296 seq_printf(s, "VDEV type %d state %s in %ld out %ld\n", 297 - mvdev->virtio_id, 298 - mic_vdevup(mvdev) ? "UP" : "DOWN", 299 - mvdev->in_bytes, 300 - mvdev->out_bytes); 297 + mvdev->virtio_id, 298 + mic_vdevup(mvdev) ? "UP" : "DOWN", 299 + mvdev->in_bytes, 300 + mvdev->out_bytes); 301 301 for (i = 0; i < MIC_MAX_VRINGS; i++) { 302 302 struct vring_desc *desc; 303 303 struct vring_avail *avail; ··· 309 309 continue; 310 310 desc = vrh->vring.desc; 311 311 seq_printf(s, "vring i %d avail_idx %d", 312 - i, mvr->vring.info->avail_idx & (num - 1)); 312 + i, mvr->vring.info->avail_idx & (num - 1)); 313 313 seq_printf(s, " vring i %d avail_idx %d\n", 314 - i, mvr->vring.info->avail_idx); 314 + i, mvr->vring.info->avail_idx); 315 315 seq_printf(s, "vrh i %d weak_barriers %d", 316 - i, vrh->weak_barriers); 316 + i, vrh->weak_barriers); 317 317 seq_printf(s, " last_avail_idx %d last_used_idx %d", 318 - vrh->last_avail_idx, vrh->last_used_idx); 318 + vrh->last_avail_idx, vrh->last_used_idx); 319 319 seq_printf(s, " completed %d\n", vrh->completed); 320 320 for (j = 0; j < num; j++) { 321 321 seq_printf(s, "desc[%d] addr 0x%llx len %d", 322 - j, desc->addr, desc->len); 322 + j, desc->addr, desc->len); 323 323 seq_printf(s, " flags 0x%x next %d\n", 324 - desc->flags, 325 - desc->next); 324 + desc->flags, desc->next); 326 325 desc++; 327 326 } 328 327 avail = vrh->vring.avail; 329 328 seq_printf(s, "avail flags 0x%x idx %d\n", 330 - avail->flags, avail->idx & (num - 1)); 329 + avail->flags, avail->idx & (num - 1)); 331 330 seq_printf(s, "avail flags 0x%x idx %d\n", 332 - avail->flags, avail->idx); 331 + avail->flags, avail->idx); 333 332 for (j = 0; j < num; j++) 334 333 seq_printf(s, "avail ring[%d] %d\n", 335 - j, avail->ring[j]); 334 + j, avail->ring[j]); 336 335 used = vrh->vring.used; 337 336 seq_printf(s, "used flags 0x%x idx %d\n", 338 - used->flags, used->idx & (num - 1)); 337 + used->flags, used->idx & (num - 1)); 339 338 seq_printf(s, "used flags 0x%x idx %d\n", 340 - used->flags, used->idx); 339 + used->flags, used->idx); 341 340 for (j = 0; j < num; j++) 342 341 seq_printf(s, "used ring[%d] id %d len %d\n", 343 - j, used->ring[j].id, used->ring[j].len); 342 + j, used->ring[j].id, 343 + used->ring[j].len); 344 344 } 345 345 } 346 346 mutex_unlock(&mdev->mic_mutex); ··· 389 389 reg = mdev->intr_ops->read_msi_to_src_map(mdev, entry); 390 390 391 391 seq_printf(s, "%s %-10d %s %-10d MXAR[%d]: %08X\n", 392 - "IRQ:", vector, "Entry:", entry, i, reg); 392 + "IRQ:", vector, "Entry:", entry, i, reg); 393 393 394 394 seq_printf(s, "%-10s", "offset:"); 395 395 for (j = (MIC_NUM_OFFSETS - 1); j >= 0; j--) ··· 400 400 seq_printf(s, "%-10s", "count:"); 401 401 for (j = (MIC_NUM_OFFSETS - 1); j >= 0; j--) 402 402 seq_printf(s, "%4d ", 403 - (mdev->irq_info.mic_msi_map[i] & BIT(j)) ? 404 - 1 : 0); 403 + (mdev->irq_info.mic_msi_map[i] & 404 + BIT(j)) ? 1 : 0); 405 405 seq_puts(s, "\n\n"); 406 406 } 407 407 } else { ··· 409 409 } 410 410 411 411 return 0; 412 - 413 412 } 414 413 415 414 static int mic_msi_irq_info_debug_open(struct inode *inode, struct file *file) ··· 442 443 if (!mdev->dbg_dir) 443 444 return; 444 445 445 - debugfs_create_file("log_buf", 0444, mdev->dbg_dir, 446 - mdev, &log_buf_ops); 446 + debugfs_create_file("log_buf", 0444, mdev->dbg_dir, mdev, &log_buf_ops); 447 447 448 - debugfs_create_file("smpt", 0444, mdev->dbg_dir, 449 - mdev, &smpt_file_ops); 448 + debugfs_create_file("smpt", 0444, mdev->dbg_dir, mdev, &smpt_file_ops); 450 449 451 - debugfs_create_file("soft_reset", 0444, mdev->dbg_dir, 452 - mdev, &soft_reset_ops); 450 + debugfs_create_file("soft_reset", 0444, mdev->dbg_dir, mdev, 451 + &soft_reset_ops); 453 452 454 - debugfs_create_file("post_code", 0444, mdev->dbg_dir, 455 - mdev, &post_code_ops); 453 + debugfs_create_file("post_code", 0444, mdev->dbg_dir, mdev, 454 + &post_code_ops); 456 455 457 - debugfs_create_file("dp", 0444, mdev->dbg_dir, 458 - mdev, &dp_ops); 456 + debugfs_create_file("dp", 0444, mdev->dbg_dir, mdev, &dp_ops); 459 457 460 - debugfs_create_file("vdev_info", 0444, mdev->dbg_dir, 461 - mdev, &vdev_info_ops); 458 + debugfs_create_file("vdev_info", 0444, mdev->dbg_dir, mdev, 459 + &vdev_info_ops); 462 460 463 - debugfs_create_file("msi_irq_info", 0444, mdev->dbg_dir, 464 - mdev, &msi_irq_info_ops); 461 + debugfs_create_file("msi_irq_info", 0444, mdev->dbg_dir, mdev, 462 + &msi_irq_info_ops); 465 463 } 466 464 467 465 /**
+3 -3
drivers/misc/mic/host/mic_fops.c
··· 140 140 141 141 poll_wait(f, &mvdev->waitq, wait); 142 142 143 - if (mic_vdev_inited(mvdev)) 143 + if (mic_vdev_inited(mvdev)) { 144 144 mask = POLLERR; 145 - else if (mvdev->poll_wake) { 145 + } else if (mvdev->poll_wake) { 146 146 mvdev->poll_wake = 0; 147 147 mask = POLLIN | POLLOUT; 148 148 } ··· 152 152 153 153 static inline int 154 154 mic_query_offset(struct mic_vdev *mvdev, unsigned long offset, 155 - unsigned long *size, unsigned long *pa) 155 + unsigned long *size, unsigned long *pa) 156 156 { 157 157 struct mic_device *mdev = mvdev->mdev; 158 158 unsigned long start = MIC_DP_SIZE;
+18 -16
drivers/misc/mic/host/mic_intr.c
··· 71 71 72 72 /* Return the interrupt offset from the index. Index is 0 based. */ 73 73 static u16 mic_map_src_to_offset(struct mic_device *mdev, 74 - int intr_src, enum mic_intr_type type) { 75 - 74 + int intr_src, enum mic_intr_type type) 75 + { 76 76 if (type >= MIC_NUM_INTR_TYPES) 77 77 return MIC_NUM_OFFSETS; 78 78 if (intr_src >= mdev->intr_info->intr_len[type]) ··· 112 112 struct mic_intr_cb *intr_cb; 113 113 unsigned long flags; 114 114 int rc; 115 - intr_cb = kmalloc(sizeof(struct mic_intr_cb), GFP_KERNEL); 115 + intr_cb = kmalloc(sizeof(*intr_cb), GFP_KERNEL); 116 116 117 117 if (!intr_cb) 118 118 return ERR_PTR(-ENOMEM); ··· 159 159 if (intr_cb->cb_id == idx) { 160 160 list_del(pos); 161 161 ida_simple_remove(&mdev->irq_info.cb_ida, 162 - intr_cb->cb_id); 162 + intr_cb->cb_id); 163 163 kfree(intr_cb); 164 164 spin_unlock_irqrestore( 165 165 &mdev->irq_info.mic_intr_lock, flags); ··· 182 182 static int mic_setup_msix(struct mic_device *mdev, struct pci_dev *pdev) 183 183 { 184 184 int rc, i; 185 + int entry_size = sizeof(*mdev->irq_info.msix_entries); 185 186 186 - mdev->irq_info.msix_entries = kmalloc(sizeof(struct msix_entry) * 187 - MIC_MIN_MSIX, GFP_KERNEL); 187 + mdev->irq_info.msix_entries = kmalloc_array(MIC_MIN_MSIX, 188 + entry_size, GFP_KERNEL); 188 189 if (!mdev->irq_info.msix_entries) { 189 190 rc = -ENOMEM; 190 191 goto err_nomem1; ··· 232 231 { 233 232 int i; 234 233 235 - mdev->irq_info.cb_list = kmalloc(sizeof(struct list_head) * 236 - MIC_NUM_OFFSETS, GFP_KERNEL); 234 + mdev->irq_info.cb_list = kmalloc_array(MIC_NUM_OFFSETS, 235 + sizeof(*mdev->irq_info.cb_list), 236 + GFP_KERNEL); 237 237 if (!mdev->irq_info.cb_list) 238 238 return -ENOMEM; 239 239 ··· 263 261 264 262 if (list_empty(&mdev->irq_info.cb_list[i])) { 265 263 spin_unlock_irqrestore(&mdev->irq_info.mic_intr_lock, 266 - flags); 264 + flags); 267 265 break; 268 266 } 269 267 ··· 271 269 intr_cb = list_entry(pos, struct mic_intr_cb, list); 272 270 list_del(pos); 273 271 ida_simple_remove(&mdev->irq_info.cb_ida, 274 - intr_cb->cb_id); 272 + intr_cb->cb_id); 275 273 kfree(intr_cb); 276 274 } 277 275 spin_unlock_irqrestore(&mdev->irq_info.mic_intr_lock, flags); ··· 429 427 offset = mic_map_src_to_offset(mdev, intr_src, type); 430 428 if (offset >= MIC_NUM_OFFSETS) { 431 429 dev_err(mdev->sdev->parent, 432 - "Error mapping index %d to a valid source id.\n", 433 - intr_src); 430 + "Error mapping index %d to a valid source id.\n", 431 + intr_src); 434 432 rc = -EINVAL; 435 433 goto err; 436 434 } ··· 439 437 msix = mic_get_available_vector(mdev); 440 438 if (!msix) { 441 439 dev_err(mdev->sdev->parent, 442 - "No MSIx vectors available for use.\n"); 440 + "No MSIx vectors available for use.\n"); 443 441 rc = -ENOSPC; 444 442 goto err; 445 443 } ··· 462 460 offset, func, data); 463 461 if (IS_ERR(intr_cb)) { 464 462 dev_err(mdev->sdev->parent, 465 - "No available callback entries for use\n"); 463 + "No available callback entries for use\n"); 466 464 rc = PTR_ERR(intr_cb); 467 465 goto err; 468 466 } ··· 508 506 if (mdev->irq_info.num_vectors > 1) { 509 507 if (entry >= mdev->irq_info.num_vectors) { 510 508 dev_warn(mdev->sdev->parent, 511 - "entry %d should be < num_irq %d\n", 509 + "entry %d should be < num_irq %d\n", 512 510 entry, mdev->irq_info.num_vectors); 513 511 return; 514 512 } ··· 583 581 for (i = 0; i < mdev->irq_info.num_vectors; i++) { 584 582 if (mdev->irq_info.mic_msi_map[i]) 585 583 dev_warn(&pdev->dev, "irq %d may still be in use.\n", 586 - mdev->irq_info.msix_entries[i].vector); 584 + mdev->irq_info.msix_entries[i].vector); 587 585 } 588 586 kfree(mdev->irq_info.mic_msi_map); 589 587 kfree(mdev->irq_info.msix_entries);
+7 -7
drivers/misc/mic/host/mic_smpt.c
··· 84 84 for (i = spt; i < spt + entries; i++, 85 85 addr += smpt_info->info.page_size) { 86 86 if (!smpt_info->entry[i].ref_count && 87 - (smpt_info->entry[i].dma_addr != addr)) { 87 + (smpt_info->entry[i].dma_addr != addr)) { 88 88 mdev->smpt_ops->set(mdev, addr, i); 89 89 smpt_info->entry[i].dma_addr = addr; 90 90 } ··· 183 183 184 184 if (!mic_is_system_addr(mdev, mic_addr)) { 185 185 dev_err(mdev->sdev->parent, 186 - "mic_addr is invalid. mic_addr = 0x%llx\n", mic_addr); 186 + "mic_addr is invalid. mic_addr = 0x%llx\n", mic_addr); 187 187 return -EINVAL; 188 188 } 189 189 spt = mic_sys_addr_to_smpt(mdev, mic_addr); ··· 286 286 smpt_info->entry[i].ref_count -= ref[i - spt]; 287 287 if (smpt_info->entry[i].ref_count < 0) 288 288 dev_warn(mdev->sdev->parent, 289 - "ref count for entry %d is negative\n", i); 289 + "ref count for entry %d is negative\n", i); 290 290 } 291 291 spin_unlock_irqrestore(&smpt_info->smpt_lock, flags); 292 292 kfree(ref); ··· 320 320 "mic_map failed dma_addr 0x%llx size 0x%lx\n", 321 321 dma_addr, size); 322 322 pci_unmap_single(pdev, dma_addr, 323 - size, PCI_DMA_BIDIRECTIONAL); 323 + size, PCI_DMA_BIDIRECTIONAL); 324 324 } 325 325 } 326 326 return mic_addr; ··· 366 366 367 367 smpt_info = mdev->smpt; 368 368 mdev->smpt_ops->init(mdev); 369 - smpt_info->entry = kmalloc(sizeof(struct mic_smpt) 370 - * smpt_info->info.num_reg, GFP_KERNEL); 369 + smpt_info->entry = kmalloc_array(smpt_info->info.num_reg, 370 + sizeof(*smpt_info->entry), GFP_KERNEL); 371 371 if (!smpt_info->entry) { 372 372 err = -ENOMEM; 373 373 goto free_smpt; ··· 412 412 smpt_info->entry[i].ref_count); 413 413 if (smpt_info->entry[i].ref_count) 414 414 dev_warn(mdev->sdev->parent, 415 - "ref count for entry %d is not zero\n", i); 415 + "ref count for entry %d is not zero\n", i); 416 416 } 417 417 kfree(smpt_info->entry); 418 418 kfree(smpt_info);
+10 -10
drivers/misc/mic/host/mic_sysfs.c
··· 130 130 131 131 static ssize_t 132 132 state_store(struct device *dev, struct device_attribute *attr, 133 - const char *buf, size_t count) 133 + const char *buf, size_t count) 134 134 { 135 135 int rc = 0; 136 136 struct mic_device *mdev = dev_get_drvdata(dev->parent); ··· 163 163 static DEVICE_ATTR_RW(state); 164 164 165 165 static ssize_t shutdown_status_show(struct device *dev, 166 - struct device_attribute *attr, char *buf) 166 + struct device_attribute *attr, char *buf) 167 167 { 168 168 struct mic_device *mdev = dev_get_drvdata(dev->parent); 169 169 ··· 193 193 194 194 static ssize_t 195 195 cmdline_store(struct device *dev, struct device_attribute *attr, 196 - const char *buf, size_t count) 196 + const char *buf, size_t count) 197 197 { 198 198 struct mic_device *mdev = dev_get_drvdata(dev->parent); 199 199 ··· 239 239 240 240 static ssize_t 241 241 firmware_store(struct device *dev, struct device_attribute *attr, 242 - const char *buf, size_t count) 242 + const char *buf, size_t count) 243 243 { 244 244 struct mic_device *mdev = dev_get_drvdata(dev->parent); 245 245 ··· 284 284 285 285 static ssize_t 286 286 ramdisk_store(struct device *dev, struct device_attribute *attr, 287 - const char *buf, size_t count) 287 + const char *buf, size_t count) 288 288 { 289 289 struct mic_device *mdev = dev_get_drvdata(dev->parent); 290 290 ··· 330 330 331 331 static ssize_t 332 332 bootmode_store(struct device *dev, struct device_attribute *attr, 333 - const char *buf, size_t count) 333 + const char *buf, size_t count) 334 334 { 335 335 struct mic_device *mdev = dev_get_drvdata(dev->parent); 336 336 ··· 363 363 364 364 static ssize_t 365 365 log_buf_addr_show(struct device *dev, struct device_attribute *attr, 366 - char *buf) 366 + char *buf) 367 367 { 368 368 struct mic_device *mdev = dev_get_drvdata(dev->parent); 369 369 ··· 375 375 376 376 static ssize_t 377 377 log_buf_addr_store(struct device *dev, struct device_attribute *attr, 378 - const char *buf, size_t count) 378 + const char *buf, size_t count) 379 379 { 380 380 struct mic_device *mdev = dev_get_drvdata(dev->parent); 381 381 int ret; ··· 397 397 398 398 static ssize_t 399 399 log_buf_len_show(struct device *dev, struct device_attribute *attr, 400 - char *buf) 400 + char *buf) 401 401 { 402 402 struct mic_device *mdev = dev_get_drvdata(dev->parent); 403 403 ··· 409 409 410 410 static ssize_t 411 411 log_buf_len_store(struct device *dev, struct device_attribute *attr, 412 - const char *buf, size_t count) 412 + const char *buf, size_t count) 413 413 { 414 414 struct mic_device *mdev = dev_get_drvdata(dev->parent); 415 415 int ret;
+17 -20
drivers/misc/mic/host/mic_virtio.c
··· 195 195 MIC_VRINGH_READ, &out_len); 196 196 if (ret) { 197 197 dev_err(mic_dev(mvdev), "%s %d err %d\n", 198 - __func__, __LINE__, ret); 198 + __func__, __LINE__, ret); 199 199 break; 200 200 } 201 201 len -= out_len; ··· 206 206 !MIC_VRINGH_READ, &out_len); 207 207 if (ret) { 208 208 dev_err(mic_dev(mvdev), "%s %d err %d\n", 209 - __func__, __LINE__, ret); 209 + __func__, __LINE__, ret); 210 210 break; 211 211 } 212 212 len -= out_len; ··· 225 225 * Update the used ring if a descriptor was available and some data was 226 226 * copied in/out and the user asked for a used ring update. 227 227 */ 228 - if (*head != USHRT_MAX && copy->out_len && 229 - copy->update_used) { 228 + if (*head != USHRT_MAX && copy->out_len && copy->update_used) { 230 229 u32 total = 0; 231 230 232 231 /* Determine the total data consumed */ ··· 366 367 367 368 static irqreturn_t mic_virtio_intr_handler(int irq, void *data) 368 369 { 369 - 370 370 struct mic_vdev *mvdev = data; 371 371 struct mic_device *mdev = mvdev->mdev; 372 372 ··· 392 394 } 393 395 394 396 if (copy_from_user(mic_vq_configspace(mvdev->dd), 395 - argp, mvdev->dd->config_len)) { 397 + argp, mvdev->dd->config_len)) { 396 398 dev_err(mic_dev(mvdev), "%s %d err %d\n", 397 399 __func__, __LINE__, -EFAULT); 398 400 ret = -EFAULT; ··· 436 438 return -EFAULT; 437 439 } 438 440 439 - if (mic_aligned_desc_size(&dd) > MIC_MAX_DESC_BLK_SIZE 440 - || dd.num_vq > MIC_MAX_VRINGS) { 441 + if (mic_aligned_desc_size(&dd) > MIC_MAX_DESC_BLK_SIZE || 442 + dd.num_vq > MIC_MAX_VRINGS) { 441 443 dev_err(mic_dev(mvdev), "%s %d err %d\n", 442 444 __func__, __LINE__, -EINVAL); 443 445 return -EINVAL; ··· 501 503 { 502 504 struct mic_device_ctrl *dc; 503 505 504 - dc = mvdev->dc = (void *)devpage + mic_aligned_desc_size(devpage); 506 + dc = (void *)devpage + mic_aligned_desc_size(devpage); 505 507 506 508 dc->config_change = 0; 507 509 dc->guest_ack = 0; ··· 510 512 dc->used_address_updated = 0; 511 513 dc->c2h_vdev_db = -1; 512 514 dc->h2c_vdev_db = -1; 515 + mvdev->dc = dc; 513 516 } 514 517 515 518 int mic_virtio_add_device(struct mic_vdev *mvdev, ··· 550 551 sizeof(struct _mic_vring_info)); 551 552 vr->va = (void *) 552 553 __get_free_pages(GFP_KERNEL | __GFP_ZERO, 553 - get_order(vr_size)); 554 + get_order(vr_size)); 554 555 if (!vr->va) { 555 556 ret = -ENOMEM; 556 557 dev_err(mic_dev(mvdev), "%s %d err %d\n", ··· 563 564 vqconfig[i].address = mic_map_single(mdev, 564 565 vr->va, vr_size); 565 566 if (mic_map_error(vqconfig[i].address)) { 566 - free_pages((unsigned long)vr->va, 567 - get_order(vr_size)); 567 + free_pages((unsigned long)vr->va, get_order(vr_size)); 568 568 ret = -ENOMEM; 569 569 dev_err(mic_dev(mvdev), "%s %d err %d\n", 570 570 __func__, __LINE__, ret); ··· 571 573 } 572 574 vqconfig[i].address = cpu_to_le64(vqconfig[i].address); 573 575 574 - vring_init(&vr->vr, num, 575 - vr->va, MIC_VIRTIO_RING_ALIGN); 576 + vring_init(&vr->vr, num, vr->va, MIC_VIRTIO_RING_ALIGN); 576 577 ret = vringh_init_kern(&mvr->vrh, 577 578 *(u32 *)mic_vq_features(mvdev->dd), num, false, 578 579 vr->vr.desc, vr->vr.avail, vr->vr.used); ··· 590 593 __func__, __LINE__, i, vr->va, vr->info, vr_size); 591 594 } 592 595 593 - snprintf(irqname, sizeof(irqname), 594 - "mic%dvirtio%d", mdev->id, mvdev->virtio_id); 596 + snprintf(irqname, sizeof(irqname), "mic%dvirtio%d", mdev->id, 597 + mvdev->virtio_id); 595 598 mvdev->virtio_db = mic_next_db(mdev); 596 599 mvdev->virtio_cookie = mic_request_irq(mdev, mic_virtio_intr_handler, 597 600 irqname, mvdev, mvdev->virtio_db, MIC_INTR_DB); ··· 625 628 for (j = 0; j < i; j++) { 626 629 struct mic_vringh *mvr = &mvdev->mvr[j]; 627 630 mic_unmap_single(mdev, le64_to_cpu(vqconfig[j].address), 628 - mvr->vring.len); 631 + mvr->vring.len); 629 632 free_pages((unsigned long)mvr->vring.va, 630 - get_order(mvr->vring.len)); 633 + get_order(mvr->vring.len)); 631 634 } 632 635 mutex_unlock(&mdev->mic_mutex); 633 636 return ret; ··· 673 676 vringh_kiov_cleanup(&mvr->riov); 674 677 vringh_kiov_cleanup(&mvr->wiov); 675 678 mic_unmap_single(mdev, le64_to_cpu(vqconfig[i].address), 676 - mvr->vring.len); 679 + mvr->vring.len); 677 680 free_pages((unsigned long)mvr->vring.va, 678 - get_order(mvr->vring.len)); 681 + get_order(mvr->vring.len)); 679 682 } 680 683 681 684 list_for_each_safe(pos, tmp, &mdev->vdev_list) {
+15 -18
drivers/misc/mic/host/mic_x100.c
··· 46 46 dev_dbg(mdev->sdev->parent, "Writing 0x%x to scratch pad index %d\n", 47 47 val, idx); 48 48 mic_mmio_write(&mdev->mmio, val, 49 - MIC_X100_SBOX_BASE_ADDRESS + 50 - MIC_X100_SBOX_SPAD0 + idx * 4); 49 + MIC_X100_SBOX_BASE_ADDRESS + 50 + MIC_X100_SBOX_SPAD0 + idx * 4); 51 51 } 52 52 53 53 /** ··· 130 130 { 131 131 struct mic_mw *mw = &mdev->mmio; 132 132 u64 apic_icr_offset = MIC_X100_SBOX_APICICR0 + doorbell * 8; 133 - u32 apicicr_low = mic_mmio_read(mw, 134 - MIC_X100_SBOX_BASE_ADDRESS + apic_icr_offset); 133 + u32 apicicr_low = mic_mmio_read(mw, MIC_X100_SBOX_BASE_ADDRESS + 134 + apic_icr_offset); 135 135 136 136 /* for MIC we need to make sure we "hit" the send_icr bit (13) */ 137 137 apicicr_low = (apicicr_low | (1 << 13)); ··· 139 139 /* Ensure that the interrupt is ordered w.r.t. previous stores. */ 140 140 wmb(); 141 141 mic_mmio_write(mw, apicicr_low, 142 - MIC_X100_SBOX_BASE_ADDRESS + apic_icr_offset); 142 + MIC_X100_SBOX_BASE_ADDRESS + apic_icr_offset); 143 143 } 144 144 145 145 /** ··· 153 153 /* Ensure that the interrupt is ordered w.r.t. previous stores. */ 154 154 wmb(); 155 155 mic_mmio_write(&mdev->mmio, 0, 156 - MIC_X100_SBOX_BASE_ADDRESS + rdmasr_offset); 156 + MIC_X100_SBOX_BASE_ADDRESS + rdmasr_offset); 157 157 } 158 158 159 159 /** ··· 212 212 */ 213 213 static void mic_x100_hw_intr_init(struct mic_device *mdev) 214 214 { 215 - mdev->intr_info = (struct mic_intr_info *) mic_x100_intr_init; 215 + mdev->intr_info = (struct mic_intr_info *)mic_x100_intr_init; 216 216 } 217 217 218 218 /** ··· 244 244 */ 245 245 static void 246 246 mic_x100_program_msi_to_src_map(struct mic_device *mdev, 247 - int idx, int offset, bool set) 247 + int idx, int offset, bool set) 248 248 { 249 249 unsigned long reg; 250 250 struct mic_mw *mw = &mdev->mmio; ··· 308 308 apicicr_low = (vector | (1 << 13)); 309 309 310 310 mic_mmio_write(mw, mic_x100_get_apic_id(mdev), 311 - MIC_X100_SBOX_BASE_ADDRESS + apic_icr_offset + 4); 311 + MIC_X100_SBOX_BASE_ADDRESS + apic_icr_offset + 4); 312 312 313 313 /* Ensure that the interrupt is ordered w.r.t. previous stores. */ 314 314 wmb(); 315 315 mic_mmio_write(mw, apicicr_low, 316 - MIC_X100_SBOX_BASE_ADDRESS + apic_icr_offset); 316 + MIC_X100_SBOX_BASE_ADDRESS + apic_icr_offset); 317 317 } 318 318 319 319 /** ··· 365 365 len += snprintf(buf, CMDLINE_SIZE - len, 366 366 " mem=%dM", boot_mem); 367 367 if (mdev->cmdline) 368 - snprintf(buf + len, CMDLINE_SIZE - len, 369 - " %s", mdev->cmdline); 368 + snprintf(buf + len, CMDLINE_SIZE - len, " %s", mdev->cmdline); 370 369 memcpy_toio(cmd_line_va, buf, strlen(buf) + 1); 371 370 kfree(buf); 372 371 return 0; ··· 396 397 * Typically the bootaddr for card OS is 64M 397 398 * so copy over the ramdisk @ 128M. 398 399 */ 399 - memcpy_toio(mdev->aper.va + (mdev->bootaddr << 1), 400 - fw->data, fw->size); 400 + memcpy_toio(mdev->aper.va + (mdev->bootaddr << 1), fw->data, fw->size); 401 401 iowrite32(cpu_to_le32(mdev->bootaddr << 1), &bp->hdr.ramdisk_image); 402 402 iowrite32(cpu_to_le32(fw->size), &bp->hdr.ramdisk_size); 403 403 release_firmware(fw); ··· 482 484 if (mdev->ramdisk) 483 485 rc = mic_x100_load_ramdisk(mdev); 484 486 error: 485 - dev_dbg(mdev->sdev->parent, "%s %d rc %d\n", 486 - __func__, __LINE__, rc); 487 + dev_dbg(mdev->sdev->parent, "%s %d rc %d\n", __func__, __LINE__, rc); 487 488 done: 488 489 return rc; 489 490 } ··· 521 524 uint32_t smpt_reg_val = BUILD_SMPT(SNOOP_ON, 522 525 dma_addr >> mdev->smpt->info.page_shift); 523 526 mic_mmio_write(&mdev->mmio, smpt_reg_val, 524 - MIC_X100_SBOX_BASE_ADDRESS + 525 - MIC_X100_SBOX_SMPT00 + (4 * index)); 527 + MIC_X100_SBOX_BASE_ADDRESS + 528 + MIC_X100_SBOX_SMPT00 + (4 * index)); 526 529 } 527 530 528 531 /**