mei: hook mei_device on class device · tjh.dev/kernel@7704e6b

+3 -3

drivers/misc/mei/bus-fixup.c

··· 386 386 ret = __mei_cl_send(cl, (u8 *)&cmd, sizeof(cmd), 0, 387 387 MEI_CL_IO_TX_BLOCKING); 388 388 if (ret < 0) { 389 - dev_err(bus->dev, "Could not send IF version cmd ret = %d\n", ret); 389 + dev_err(&bus->dev, "Could not send IF version cmd ret = %d\n", ret); 390 390 return ret; 391 391 } 392 392 ··· 401 401 bytes_recv = __mei_cl_recv(cl, (u8 *)reply, if_version_length, &vtag, 402 402 0, 0); 403 403 if (bytes_recv < 0 || (size_t)bytes_recv < if_version_length) { 404 - dev_err(bus->dev, "Could not read IF version ret = %d\n", bytes_recv); 404 + dev_err(&bus->dev, "Could not read IF version ret = %d\n", bytes_recv); 405 405 ret = -EIO; 406 406 goto err; 407 407 } 408 408 409 409 memcpy(ver, reply->data, sizeof(*ver)); 410 410 411 - dev_info(bus->dev, "NFC MEI VERSION: IVN 0x%x Vendor ID 0x%x Type 0x%x\n", 411 + dev_info(&bus->dev, "NFC MEI VERSION: IVN 0x%x Vendor ID 0x%x Type 0x%x\n", 412 412 ver->fw_ivn, ver->vendor_id, ver->radio_type); 413 413 414 414 err:

+14 -10

drivers/misc/mei/bus.c

··· 637 637 */ 638 638 static bool mei_cl_bus_module_get(struct mei_cl_device *cldev) 639 639 { 640 - return try_module_get(cldev->bus->dev->driver->owner); 640 + return try_module_get(cldev->bus->parent->driver->owner); 641 641 } 642 642 643 643 /** ··· 647 647 */ 648 648 static void mei_cl_bus_module_put(struct mei_cl_device *cldev) 649 649 { 650 - module_put(cldev->bus->dev->driver->owner); 650 + module_put(cldev->bus->parent->driver->owner); 651 651 } 652 652 653 653 /** ··· 1285 1285 1286 1286 static struct mei_device *mei_dev_bus_get(struct mei_device *bus) 1287 1287 { 1288 - if (bus) 1289 - get_device(bus->dev); 1288 + if (bus) { 1289 + get_device(&bus->dev); 1290 + get_device(bus->parent); 1291 + } 1290 1292 1291 1293 return bus; 1292 1294 } 1293 1295 1294 1296 static void mei_dev_bus_put(struct mei_device *bus) 1295 1297 { 1296 - if (bus) 1297 - put_device(bus->dev); 1298 + if (bus) { 1299 + put_device(bus->parent); 1300 + put_device(&bus->dev); 1301 + } 1298 1302 } 1299 1303 1300 1304 static void mei_cl_bus_dev_release(struct device *dev) ··· 1332 1328 static inline void mei_cl_bus_set_name(struct mei_cl_device *cldev) 1333 1329 { 1334 1330 dev_set_name(&cldev->dev, "%s-%pUl", 1335 - dev_name(cldev->bus->dev), 1331 + dev_name(cldev->bus->parent), 1336 1332 mei_me_cl_uuid(cldev->me_cl)); 1337 1333 } 1338 1334 ··· 1361 1357 } 1362 1358 1363 1359 device_initialize(&cldev->dev); 1364 - cldev->dev.parent = bus->dev; 1360 + cldev->dev.parent = bus->parent; 1365 1361 cldev->dev.bus = &mei_cl_bus_type; 1366 1362 cldev->dev.type = &mei_cl_device_type; 1367 1363 cldev->bus = mei_dev_bus_get(bus); ··· 1496 1492 1497 1493 WARN_ON(!mutex_is_locked(&bus->cl_bus_lock)); 1498 1494 1499 - dev_dbg(bus->dev, "initializing %pUl", mei_me_cl_uuid(me_cl)); 1495 + dev_dbg(&bus->dev, "initializing %pUl", mei_me_cl_uuid(me_cl)); 1500 1496 1501 1497 if (me_cl->bus_added) 1502 1498 return; ··· 1547 1543 } 1548 1544 mutex_unlock(&bus->cl_bus_lock); 1549 1545 1550 - dev_dbg(bus->dev, "rescan end"); 1546 + dev_dbg(&bus->dev, "rescan end"); 1551 1547 } 1552 1548 1553 1549 void mei_cl_bus_rescan_work(struct work_struct *work)

+41 -41

drivers/misc/mei/client.c

··· 262 262 { 263 263 struct mei_me_client *me_cl; 264 264 265 - dev_dbg(dev->dev, "remove %pUl\n", uuid); 265 + dev_dbg(&dev->dev, "remove %pUl\n", uuid); 266 266 267 267 down_write(&dev->me_clients_rwsem); 268 268 me_cl = __mei_me_cl_by_uuid(dev, uuid); ··· 635 635 636 636 id = find_first_zero_bit(dev->host_clients_map, MEI_CLIENTS_MAX); 637 637 if (id >= MEI_CLIENTS_MAX) { 638 - dev_err(dev->dev, "id exceeded %d", MEI_CLIENTS_MAX); 638 + dev_err(&dev->dev, "id exceeded %d", MEI_CLIENTS_MAX); 639 639 return -EMFILE; 640 640 } 641 641 642 642 if (dev->open_handle_count >= MEI_MAX_OPEN_HANDLE_COUNT) { 643 - dev_err(dev->dev, "open_handle_count exceeded %d", 643 + dev_err(&dev->dev, "open_handle_count exceeded %d", 644 644 MEI_MAX_OPEN_HANDLE_COUNT); 645 645 return -EMFILE; 646 646 } ··· 709 709 710 710 schedule_work(&dev->bus_rescan_work); 711 711 712 - pm_runtime_mark_last_busy(dev->dev); 713 - dev_dbg(dev->dev, "rpm: autosuspend\n"); 714 - pm_request_autosuspend(dev->dev); 712 + pm_runtime_mark_last_busy(dev->parent); 713 + dev_dbg(&dev->dev, "rpm: autosuspend\n"); 714 + pm_request_autosuspend(dev->parent); 715 715 } 716 716 717 717 /** ··· 724 724 { 725 725 if (mei_pg_state(dev) == MEI_PG_ON || 726 726 mei_pg_in_transition(dev)) { 727 - dev_dbg(dev->dev, "device is in pg\n"); 727 + dev_dbg(&dev->dev, "device is in pg\n"); 728 728 return false; 729 729 } 730 730 731 731 if (!dev->hbuf_is_ready) { 732 - dev_dbg(dev->dev, "hbuf is not ready\n"); 732 + dev_dbg(&dev->dev, "hbuf is not ready\n"); 733 733 return false; 734 734 } 735 735 ··· 981 981 return 0; 982 982 } 983 983 984 - rets = pm_runtime_get(dev->dev); 984 + rets = pm_runtime_get(dev->parent); 985 985 if (rets < 0 && rets != -EINPROGRESS) { 986 - pm_runtime_put_noidle(dev->dev); 986 + pm_runtime_put_noidle(dev->parent); 987 987 cl_err(dev, cl, "rpm: get failed %d\n", rets); 988 988 return rets; 989 989 } ··· 991 991 rets = __mei_cl_disconnect(cl); 992 992 993 993 cl_dbg(dev, cl, "rpm: autosuspend\n"); 994 - pm_runtime_mark_last_busy(dev->dev); 995 - pm_runtime_put_autosuspend(dev->dev); 994 + pm_runtime_mark_last_busy(dev->parent); 995 + pm_runtime_put_autosuspend(dev->parent); 996 996 997 997 return rets; 998 998 } ··· 1118 1118 goto nortpm; 1119 1119 } 1120 1120 1121 - rets = pm_runtime_get(dev->dev); 1121 + rets = pm_runtime_get(dev->parent); 1122 1122 if (rets < 0 && rets != -EINPROGRESS) { 1123 - pm_runtime_put_noidle(dev->dev); 1123 + pm_runtime_put_noidle(dev->parent); 1124 1124 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1125 1125 goto nortpm; 1126 1126 } ··· 1167 1167 rets = cl->status; 1168 1168 out: 1169 1169 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1170 - pm_runtime_mark_last_busy(dev->dev); 1171 - pm_runtime_put_autosuspend(dev->dev); 1170 + pm_runtime_mark_last_busy(dev->parent); 1171 + pm_runtime_put_autosuspend(dev->parent); 1172 1172 1173 1173 mei_io_cb_free(cb); 1174 1174 ··· 1517 1517 if (!mei_cl_is_connected(cl)) 1518 1518 return -ENODEV; 1519 1519 1520 - rets = pm_runtime_get(dev->dev); 1520 + rets = pm_runtime_get(dev->parent); 1521 1521 if (rets < 0 && rets != -EINPROGRESS) { 1522 - pm_runtime_put_noidle(dev->dev); 1522 + pm_runtime_put_noidle(dev->parent); 1523 1523 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1524 1524 return rets; 1525 1525 } ··· 1554 1554 1555 1555 out: 1556 1556 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1557 - pm_runtime_mark_last_busy(dev->dev); 1558 - pm_runtime_put_autosuspend(dev->dev); 1557 + pm_runtime_mark_last_busy(dev->parent); 1558 + pm_runtime_put_autosuspend(dev->parent); 1559 1559 1560 1560 mei_io_cb_free(cb); 1561 1561 return rets; ··· 1683 1683 1684 1684 mei_cl_set_read_by_fp(cl, fp); 1685 1685 1686 - rets = pm_runtime_get(dev->dev); 1686 + rets = pm_runtime_get(dev->parent); 1687 1687 if (rets < 0 && rets != -EINPROGRESS) { 1688 - pm_runtime_put_noidle(dev->dev); 1688 + pm_runtime_put_noidle(dev->parent); 1689 1689 cl_err(dev, cl, "rpm: get failed %d\n", rets); 1690 1690 goto nortpm; 1691 1691 } ··· 1702 1702 1703 1703 out: 1704 1704 cl_dbg(dev, cl, "rpm: autosuspend\n"); 1705 - pm_runtime_mark_last_busy(dev->dev); 1706 - pm_runtime_put_autosuspend(dev->dev); 1705 + pm_runtime_mark_last_busy(dev->parent); 1706 + pm_runtime_put_autosuspend(dev->parent); 1707 1707 nortpm: 1708 1708 if (rets) 1709 1709 mei_io_cb_free(cb); ··· 1972 1972 blocking = cb->blocking; 1973 1973 data = buf->data; 1974 1974 1975 - rets = pm_runtime_get(dev->dev); 1975 + rets = pm_runtime_get(dev->parent); 1976 1976 if (rets < 0 && rets != -EINPROGRESS) { 1977 - pm_runtime_put_noidle(dev->dev); 1977 + pm_runtime_put_noidle(dev->parent); 1978 1978 cl_err(dev, cl, "rpm: get failed %zd\n", rets); 1979 1979 goto free; 1980 1980 } ··· 2092 2092 rets = buf_len; 2093 2093 err: 2094 2094 cl_dbg(dev, cl, "rpm: autosuspend\n"); 2095 - pm_runtime_mark_last_busy(dev->dev); 2096 - pm_runtime_put_autosuspend(dev->dev); 2095 + pm_runtime_mark_last_busy(dev->parent); 2096 + pm_runtime_put_autosuspend(dev->parent); 2097 2097 free: 2098 2098 mei_io_cb_free(cb); 2099 2099 ··· 2119 2119 if (waitqueue_active(&cl->tx_wait)) { 2120 2120 wake_up_interruptible(&cl->tx_wait); 2121 2121 } else { 2122 - pm_runtime_mark_last_busy(dev->dev); 2123 - pm_request_autosuspend(dev->dev); 2122 + pm_runtime_mark_last_busy(dev->parent); 2123 + pm_request_autosuspend(dev->parent); 2124 2124 } 2125 2125 break; 2126 2126 ··· 2251 2251 2252 2252 static int mei_cl_dma_alloc(struct mei_cl *cl, u8 buf_id, size_t size) 2253 2253 { 2254 - cl->dma.vaddr = dmam_alloc_coherent(cl->dev->dev, size, 2254 + cl->dma.vaddr = dmam_alloc_coherent(&cl->dev->dev, size, 2255 2255 &cl->dma.daddr, GFP_KERNEL); 2256 2256 if (!cl->dma.vaddr) 2257 2257 return -ENOMEM; ··· 2265 2265 static void mei_cl_dma_free(struct mei_cl *cl) 2266 2266 { 2267 2267 cl->dma.buffer_id = 0; 2268 - dmam_free_coherent(cl->dev->dev, 2268 + dmam_free_coherent(&cl->dev->dev, 2269 2269 cl->dma.size, cl->dma.vaddr, cl->dma.daddr); 2270 2270 cl->dma.size = 0; 2271 2271 cl->dma.vaddr = NULL; ··· 2321 2321 return -EPROTO; 2322 2322 } 2323 2323 2324 - rets = pm_runtime_get(dev->dev); 2324 + rets = pm_runtime_get(dev->parent); 2325 2325 if (rets < 0 && rets != -EINPROGRESS) { 2326 - pm_runtime_put_noidle(dev->dev); 2326 + pm_runtime_put_noidle(dev->parent); 2327 2327 cl_err(dev, cl, "rpm: get failed %d\n", rets); 2328 2328 return rets; 2329 2329 } 2330 2330 2331 2331 rets = mei_cl_dma_alloc(cl, buffer_id, size); 2332 2332 if (rets) { 2333 - pm_runtime_put_noidle(dev->dev); 2333 + pm_runtime_put_noidle(dev->parent); 2334 2334 return rets; 2335 2335 } 2336 2336 ··· 2366 2366 mei_cl_dma_free(cl); 2367 2367 2368 2368 cl_dbg(dev, cl, "rpm: autosuspend\n"); 2369 - pm_runtime_mark_last_busy(dev->dev); 2370 - pm_runtime_put_autosuspend(dev->dev); 2369 + pm_runtime_mark_last_busy(dev->parent); 2370 + pm_runtime_put_autosuspend(dev->parent); 2371 2371 2372 2372 mei_io_cb_free(cb); 2373 2373 return rets; ··· 2406 2406 if (!cl->dma_mapped) 2407 2407 return -EPROTO; 2408 2408 2409 - rets = pm_runtime_get(dev->dev); 2409 + rets = pm_runtime_get(dev->parent); 2410 2410 if (rets < 0 && rets != -EINPROGRESS) { 2411 - pm_runtime_put_noidle(dev->dev); 2411 + pm_runtime_put_noidle(dev->parent); 2412 2412 cl_err(dev, cl, "rpm: get failed %d\n", rets); 2413 2413 return rets; 2414 2414 } ··· 2444 2444 mei_cl_dma_free(cl); 2445 2445 out: 2446 2446 cl_dbg(dev, cl, "rpm: autosuspend\n"); 2447 - pm_runtime_mark_last_busy(dev->dev); 2448 - pm_runtime_put_autosuspend(dev->dev); 2447 + pm_runtime_mark_last_busy(dev->parent); 2448 + pm_runtime_put_autosuspend(dev->parent); 2449 2449 2450 2450 mei_io_cb_free(cb); 2451 2451 return rets;

+3 -3

drivers/misc/mei/client.h

··· 275 275 #define MEI_CL_PRM(cl) (cl)->host_client_id, mei_cl_me_id(cl) 276 276 277 277 #define cl_dbg(dev, cl, format, arg...) \ 278 - dev_dbg((dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg) 278 + dev_dbg(&(dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg) 279 279 280 280 #define cl_warn(dev, cl, format, arg...) \ 281 - dev_warn((dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg) 281 + dev_warn(&(dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg) 282 282 283 283 #define cl_err(dev, cl, format, arg...) \ 284 - dev_err((dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg) 284 + dev_err(&(dev)->dev, MEI_CL_FMT format, MEI_CL_PRM(cl), ##arg) 285 285 286 286 #endif /* _MEI_CLIENT_H_ */

+4 -4

drivers/misc/mei/dma-ring.c

··· 30 30 if (dscr->vaddr) 31 31 return 0; 32 32 33 - dscr->vaddr = dmam_alloc_coherent(dev->dev, dscr->size, &dscr->daddr, 33 + dscr->vaddr = dmam_alloc_coherent(dev->parent, dscr->size, &dscr->daddr, 34 34 GFP_KERNEL); 35 35 if (!dscr->vaddr) 36 36 return -ENOMEM; ··· 50 50 if (!dscr->vaddr) 51 51 return; 52 52 53 - dmam_free_coherent(dev->dev, dscr->size, dscr->vaddr, dscr->daddr); 53 + dmam_free_coherent(dev->parent, dscr->size, dscr->vaddr, dscr->daddr); 54 54 dscr->vaddr = NULL; 55 55 } 56 56 ··· 177 177 if (WARN_ON(!ctrl)) 178 178 return; 179 179 180 - dev_dbg(dev->dev, "reading from dma %u bytes\n", len); 180 + dev_dbg(&dev->dev, "reading from dma %u bytes\n", len); 181 181 182 182 if (!len) 183 183 return; ··· 254 254 if (WARN_ON(!ctrl)) 255 255 return; 256 256 257 - dev_dbg(dev->dev, "writing to dma %u bytes\n", len); 257 + dev_dbg(&dev->dev, "writing to dma %u bytes\n", len); 258 258 hbuf_depth = mei_dma_ring_hbuf_depth(dev); 259 259 wr_idx = READ_ONCE(ctrl->hbuf_wr_idx) & (hbuf_depth - 1); 260 260 slots = mei_data2slots(len);

+7 -9

drivers/misc/mei/gsc-me.c

··· 106 106 } 107 107 } 108 108 109 + ret = mei_register(dev, device); 110 + if (ret) 111 + goto deinterrupt; 112 + 109 113 pm_runtime_get_noresume(device); 110 114 pm_runtime_set_active(device); 111 115 pm_runtime_enable(device); 112 116 113 - /* Continue to char device setup in spite of firmware handshake failure. 117 + /* Continue in spite of firmware handshake failure. 114 118 * In order to provide access to the firmware status registers to the user 115 119 * space via sysfs. 116 120 */ ··· 124 120 pm_runtime_set_autosuspend_delay(device, MEI_GSC_RPM_TIMEOUT); 125 121 pm_runtime_use_autosuspend(device); 126 122 127 - ret = mei_register(dev, device); 128 - if (ret) 129 - goto register_err; 130 - 131 123 pm_runtime_put_noidle(device); 132 124 return 0; 133 125 134 - register_err: 135 - mei_stop(dev); 126 + deinterrupt: 136 127 if (!mei_me_hw_use_polling(hw)) 137 128 devm_free_irq(device, hw->irq, dev); 138 - 139 129 err: 140 130 dev_err(device, "probe failed: %d\n", ret); 141 131 dev_set_drvdata(device, NULL); ··· 250 252 251 253 irq_ret = mei_me_irq_thread_handler(1, dev); 252 254 if (irq_ret != IRQ_HANDLED) 253 - dev_err(dev->dev, "thread handler fail %d\n", irq_ret); 255 + dev_err(&dev->dev, "thread handler fail %d\n", irq_ret); 254 256 255 257 return 0; 256 258 }

+58 -63

drivers/misc/mei/hbm.c

··· 239 239 240 240 if (ret == 0 && (dev->hbm_state <= MEI_HBM_STARTING)) { 241 241 dev->hbm_state = MEI_HBM_IDLE; 242 - dev_err(dev->dev, "waiting for mei start failed\n"); 242 + dev_err(&dev->dev, "waiting for mei start failed\n"); 243 243 return -ETIME; 244 244 } 245 245 return 0; ··· 271 271 dev->hbm_state = MEI_HBM_IDLE; 272 272 ret = mei_hbm_write_message(dev, &mei_hdr, &req); 273 273 if (ret) { 274 - dev_err(dev->dev, "version message write failed: ret = %d\n", 275 - ret); 274 + dev_err(&dev->dev, "version message write failed: ret = %d\n", ret); 276 275 return ret; 277 276 } 278 277 ··· 311 312 312 313 ret = mei_hbm_write_message(dev, &mei_hdr, &req); 313 314 if (ret) { 314 - dev_err(dev->dev, "dma setup request write failed: ret = %d.\n", 315 - ret); 315 + dev_err(&dev->dev, "dma setup request write failed: ret = %d.\n", ret); 316 316 return ret; 317 317 } 318 318 ··· 349 351 350 352 ret = mei_hbm_write_message(dev, &mei_hdr, &req); 351 353 if (ret) { 352 - dev_err(dev->dev, 353 - "capabilities request write failed: ret = %d.\n", ret); 354 + dev_err(&dev->dev, "capabilities request write failed: ret = %d.\n", ret); 354 355 return ret; 355 356 } 356 357 ··· 383 386 384 387 ret = mei_hbm_write_message(dev, &mei_hdr, &req); 385 388 if (ret) { 386 - dev_err(dev->dev, "enumeration request write failed: ret = %d.\n", 387 - ret); 389 + dev_err(&dev->dev, "enumeration request write failed: ret = %d.\n", ret); 388 390 return ret; 389 391 } 390 392 dev->hbm_state = MEI_HBM_ENUM_CLIENTS; ··· 439 443 struct hbm_add_client_response resp; 440 444 int ret; 441 445 442 - dev_dbg(dev->dev, "adding client response\n"); 446 + dev_dbg(&dev->dev, "adding client response\n"); 443 447 444 448 mei_hbm_hdr(&mei_hdr, sizeof(resp)); 445 449 ··· 450 454 451 455 ret = mei_hbm_write_message(dev, &mei_hdr, &resp); 452 456 if (ret) 453 - dev_err(dev->dev, "add client response write failed: ret = %d\n", 454 - ret); 457 + dev_err(&dev->dev, "add client response write failed: ret = %d\n", ret); 455 458 return ret; 456 459 } 457 460 ··· 747 752 748 753 ret = mei_hbm_write_message(dev, &mei_hdr, &req); 749 754 if (ret) { 750 - dev_err(dev->dev, "properties request write failed: ret = %d\n", 755 + dev_err(&dev->dev, "properties request write failed: ret = %d\n", 751 756 ret); 752 757 return ret; 753 758 } ··· 783 788 784 789 ret = mei_hbm_write_message(dev, &mei_hdr, &req); 785 790 if (ret) 786 - dev_err(dev->dev, "power gate command write failed.\n"); 791 + dev_err(&dev->dev, "power gate command write failed.\n"); 787 792 return ret; 788 793 } 789 794 EXPORT_SYMBOL_GPL(mei_hbm_pg); ··· 842 847 843 848 me_cl = mei_me_cl_by_id(dev, fctrl->me_addr); 844 849 if (!me_cl) { 845 - dev_err(dev->dev, "no such me client %d\n", fctrl->me_addr); 850 + dev_err(&dev->dev, "no such me client %d\n", fctrl->me_addr); 846 851 return -ENOENT; 847 852 } 848 853 ··· 852 857 } 853 858 854 859 me_cl->tx_flow_ctrl_creds++; 855 - dev_dbg(dev->dev, "recv flow ctrl msg ME %d (single) creds = %d.\n", 860 + dev_dbg(&dev->dev, "recv flow ctrl msg ME %d (single) creds = %d.\n", 856 861 fctrl->me_addr, me_cl->tx_flow_ctrl_creds); 857 862 858 863 rets = 0; ··· 1080 1085 { 1081 1086 if (mei_pg_state(dev) != MEI_PG_OFF || 1082 1087 dev->pg_event != MEI_PG_EVENT_WAIT) { 1083 - dev_err(dev->dev, "hbm: pg entry response: state mismatch [%s, %d]\n", 1088 + dev_err(&dev->dev, "hbm: pg entry response: state mismatch [%s, %d]\n", 1084 1089 mei_pg_state_str(mei_pg_state(dev)), dev->pg_event); 1085 1090 return -EPROTO; 1086 1091 } ··· 1098 1103 */ 1099 1104 void mei_hbm_pg_resume(struct mei_device *dev) 1100 1105 { 1101 - pm_request_resume(dev->dev); 1106 + pm_request_resume(dev->parent); 1102 1107 } 1103 1108 EXPORT_SYMBOL_GPL(mei_hbm_pg_resume); 1104 1109 ··· 1114 1119 if (mei_pg_state(dev) != MEI_PG_ON || 1115 1120 (dev->pg_event != MEI_PG_EVENT_WAIT && 1116 1121 dev->pg_event != MEI_PG_EVENT_IDLE)) { 1117 - dev_err(dev->dev, "hbm: pg exit response: state mismatch [%s, %d]\n", 1122 + dev_err(&dev->dev, "hbm: pg exit response: state mismatch [%s, %d]\n", 1118 1123 mei_pg_state_str(mei_pg_state(dev)), dev->pg_event); 1119 1124 return -EPROTO; 1120 1125 } ··· 1271 1276 * hbm is put to idle during system reset 1272 1277 */ 1273 1278 if (dev->hbm_state == MEI_HBM_IDLE) { 1274 - dev_dbg(dev->dev, "hbm: state is idle ignore spurious messages\n"); 1279 + dev_dbg(&dev->dev, "hbm: state is idle ignore spurious messages\n"); 1275 1280 return 0; 1276 1281 } 1277 1282 1278 1283 switch (mei_msg->hbm_cmd) { 1279 1284 case HOST_START_RES_CMD: 1280 - dev_dbg(dev->dev, "hbm: start: response message received.\n"); 1285 + dev_dbg(&dev->dev, "hbm: start: response message received.\n"); 1281 1286 1282 1287 dev->init_clients_timer = 0; 1283 1288 1284 1289 version_res = (struct hbm_host_version_response *)mei_msg; 1285 1290 1286 - dev_dbg(dev->dev, "HBM VERSION: DRIVER=%02d:%02d DEVICE=%02d:%02d\n", 1291 + dev_dbg(&dev->dev, "HBM VERSION: DRIVER=%02d:%02d DEVICE=%02d:%02d\n", 1287 1292 HBM_MAJOR_VERSION, HBM_MINOR_VERSION, 1288 1293 version_res->me_max_version.major_version, 1289 1294 version_res->me_max_version.minor_version); ··· 1299 1304 } 1300 1305 1301 1306 if (!mei_hbm_version_is_supported(dev)) { 1302 - dev_warn(dev->dev, "hbm: start: version mismatch - stopping the driver.\n"); 1307 + dev_warn(&dev->dev, "hbm: start: version mismatch - stopping the driver.\n"); 1303 1308 1304 1309 dev->hbm_state = MEI_HBM_STOPPED; 1305 1310 if (mei_hbm_stop_req(dev)) { 1306 - dev_err(dev->dev, "hbm: start: failed to send stop request\n"); 1311 + dev_err(&dev->dev, "hbm: start: failed to send stop request\n"); 1307 1312 return -EIO; 1308 1313 } 1309 1314 break; ··· 1315 1320 dev->hbm_state != MEI_HBM_STARTING) { 1316 1321 if (dev->dev_state == MEI_DEV_POWER_DOWN || 1317 1322 dev->dev_state == MEI_DEV_POWERING_DOWN) { 1318 - dev_dbg(dev->dev, "hbm: start: on shutdown, ignoring\n"); 1323 + dev_dbg(&dev->dev, "hbm: start: on shutdown, ignoring\n"); 1319 1324 return 0; 1320 1325 } 1321 - dev_err(dev->dev, "hbm: start: state mismatch, [%d, %d]\n", 1326 + dev_err(&dev->dev, "hbm: start: state mismatch, [%d, %d]\n", 1322 1327 dev->dev_state, dev->hbm_state); 1323 1328 return -EPROTO; 1324 1329 } ··· 1332 1337 1333 1338 if (dev->hbm_f_dr_supported) { 1334 1339 if (mei_dmam_ring_alloc(dev)) 1335 - dev_info(dev->dev, "running w/o dma ring\n"); 1340 + dev_info(&dev->dev, "running w/o dma ring\n"); 1336 1341 if (mei_dma_ring_is_allocated(dev)) { 1337 1342 if (mei_hbm_dma_setup_req(dev)) 1338 1343 return -EIO; ··· 1352 1357 break; 1353 1358 1354 1359 case MEI_HBM_CAPABILITIES_RES_CMD: 1355 - dev_dbg(dev->dev, "hbm: capabilities response: message received.\n"); 1360 + dev_dbg(&dev->dev, "hbm: capabilities response: message received.\n"); 1356 1361 1357 1362 dev->init_clients_timer = 0; 1358 1363 ··· 1360 1365 dev->hbm_state != MEI_HBM_CAP_SETUP) { 1361 1366 if (dev->dev_state == MEI_DEV_POWER_DOWN || 1362 1367 dev->dev_state == MEI_DEV_POWERING_DOWN) { 1363 - dev_dbg(dev->dev, "hbm: capabilities response: on shutdown, ignoring\n"); 1368 + dev_dbg(&dev->dev, "hbm: capabilities response: on shutdown, ignoring\n"); 1364 1369 return 0; 1365 1370 } 1366 - dev_err(dev->dev, "hbm: capabilities response: state mismatch, [%d, %d]\n", 1371 + dev_err(&dev->dev, "hbm: capabilities response: state mismatch, [%d, %d]\n", 1367 1372 dev->dev_state, dev->hbm_state); 1368 1373 return -EPROTO; 1369 1374 } ··· 1379 1384 1380 1385 if (dev->hbm_f_dr_supported) { 1381 1386 if (mei_dmam_ring_alloc(dev)) 1382 - dev_info(dev->dev, "running w/o dma ring\n"); 1387 + dev_info(&dev->dev, "running w/o dma ring\n"); 1383 1388 if (mei_dma_ring_is_allocated(dev)) { 1384 1389 if (mei_hbm_dma_setup_req(dev)) 1385 1390 return -EIO; ··· 1395 1400 break; 1396 1401 1397 1402 case MEI_HBM_DMA_SETUP_RES_CMD: 1398 - dev_dbg(dev->dev, "hbm: dma setup response: message received.\n"); 1403 + dev_dbg(&dev->dev, "hbm: dma setup response: message received.\n"); 1399 1404 1400 1405 dev->init_clients_timer = 0; 1401 1406 ··· 1403 1408 dev->hbm_state != MEI_HBM_DR_SETUP) { 1404 1409 if (dev->dev_state == MEI_DEV_POWER_DOWN || 1405 1410 dev->dev_state == MEI_DEV_POWERING_DOWN) { 1406 - dev_dbg(dev->dev, "hbm: dma setup response: on shutdown, ignoring\n"); 1411 + dev_dbg(&dev->dev, "hbm: dma setup response: on shutdown, ignoring\n"); 1407 1412 return 0; 1408 1413 } 1409 - dev_err(dev->dev, "hbm: dma setup response: state mismatch, [%d, %d]\n", 1414 + dev_err(&dev->dev, "hbm: dma setup response: state mismatch, [%d, %d]\n", 1410 1415 dev->dev_state, dev->hbm_state); 1411 1416 return -EPROTO; 1412 1417 } ··· 1417 1422 u8 status = dma_setup_res->status; 1418 1423 1419 1424 if (status == MEI_HBMS_NOT_ALLOWED) { 1420 - dev_dbg(dev->dev, "hbm: dma setup not allowed\n"); 1425 + dev_dbg(&dev->dev, "hbm: dma setup not allowed\n"); 1421 1426 } else { 1422 - dev_info(dev->dev, "hbm: dma setup response: failure = %d %s\n", 1427 + dev_info(&dev->dev, "hbm: dma setup response: failure = %d %s\n", 1423 1428 status, 1424 1429 mei_hbm_status_str(status)); 1425 1430 } ··· 1432 1437 break; 1433 1438 1434 1439 case CLIENT_CONNECT_RES_CMD: 1435 - dev_dbg(dev->dev, "hbm: client connect response: message received.\n"); 1440 + dev_dbg(&dev->dev, "hbm: client connect response: message received.\n"); 1436 1441 mei_hbm_cl_res(dev, cl_cmd, MEI_FOP_CONNECT); 1437 1442 break; 1438 1443 1439 1444 case CLIENT_DISCONNECT_RES_CMD: 1440 - dev_dbg(dev->dev, "hbm: client disconnect response: message received.\n"); 1445 + dev_dbg(&dev->dev, "hbm: client disconnect response: message received.\n"); 1441 1446 mei_hbm_cl_res(dev, cl_cmd, MEI_FOP_DISCONNECT); 1442 1447 break; 1443 1448 1444 1449 case MEI_FLOW_CONTROL_CMD: 1445 - dev_dbg(dev->dev, "hbm: client flow control response: message received.\n"); 1450 + dev_dbg(&dev->dev, "hbm: client flow control response: message received.\n"); 1446 1451 1447 1452 fctrl = (struct hbm_flow_control *)mei_msg; 1448 1453 mei_hbm_cl_tx_flow_ctrl_creds_res(dev, fctrl); 1449 1454 break; 1450 1455 1451 1456 case MEI_PG_ISOLATION_ENTRY_RES_CMD: 1452 - dev_dbg(dev->dev, "hbm: power gate isolation entry response received\n"); 1457 + dev_dbg(&dev->dev, "hbm: power gate isolation entry response received\n"); 1453 1458 ret = mei_hbm_pg_enter_res(dev); 1454 1459 if (ret) 1455 1460 return ret; 1456 1461 break; 1457 1462 1458 1463 case MEI_PG_ISOLATION_EXIT_REQ_CMD: 1459 - dev_dbg(dev->dev, "hbm: power gate isolation exit request received\n"); 1464 + dev_dbg(&dev->dev, "hbm: power gate isolation exit request received\n"); 1460 1465 ret = mei_hbm_pg_exit_res(dev); 1461 1466 if (ret) 1462 1467 return ret; 1463 1468 break; 1464 1469 1465 1470 case HOST_CLIENT_PROPERTIES_RES_CMD: 1466 - dev_dbg(dev->dev, "hbm: properties response: message received.\n"); 1471 + dev_dbg(&dev->dev, "hbm: properties response: message received.\n"); 1467 1472 1468 1473 dev->init_clients_timer = 0; 1469 1474 ··· 1471 1476 dev->hbm_state != MEI_HBM_CLIENT_PROPERTIES) { 1472 1477 if (dev->dev_state == MEI_DEV_POWER_DOWN || 1473 1478 dev->dev_state == MEI_DEV_POWERING_DOWN) { 1474 - dev_dbg(dev->dev, "hbm: properties response: on shutdown, ignoring\n"); 1479 + dev_dbg(&dev->dev, "hbm: properties response: on shutdown, ignoring\n"); 1475 1480 return 0; 1476 1481 } 1477 - dev_err(dev->dev, "hbm: properties response: state mismatch, [%d, %d]\n", 1482 + dev_err(&dev->dev, "hbm: properties response: state mismatch, [%d, %d]\n", 1478 1483 dev->dev_state, dev->hbm_state); 1479 1484 return -EPROTO; 1480 1485 } ··· 1482 1487 props_res = (struct hbm_props_response *)mei_msg; 1483 1488 1484 1489 if (props_res->status == MEI_HBMS_CLIENT_NOT_FOUND) { 1485 - dev_dbg(dev->dev, "hbm: properties response: %d CLIENT_NOT_FOUND\n", 1490 + dev_dbg(&dev->dev, "hbm: properties response: %d CLIENT_NOT_FOUND\n", 1486 1491 props_res->me_addr); 1487 1492 } else if (props_res->status) { 1488 - dev_err(dev->dev, "hbm: properties response: wrong status = %d %s\n", 1493 + dev_err(&dev->dev, "hbm: properties response: wrong status = %d %s\n", 1489 1494 props_res->status, 1490 1495 mei_hbm_status_str(props_res->status)); 1491 1496 return -EPROTO; ··· 1500 1505 break; 1501 1506 1502 1507 case HOST_ENUM_RES_CMD: 1503 - dev_dbg(dev->dev, "hbm: enumeration response: message received\n"); 1508 + dev_dbg(&dev->dev, "hbm: enumeration response: message received\n"); 1504 1509 1505 1510 dev->init_clients_timer = 0; 1506 1511 ··· 1514 1519 dev->hbm_state != MEI_HBM_ENUM_CLIENTS) { 1515 1520 if (dev->dev_state == MEI_DEV_POWER_DOWN || 1516 1521 dev->dev_state == MEI_DEV_POWERING_DOWN) { 1517 - dev_dbg(dev->dev, "hbm: enumeration response: on shutdown, ignoring\n"); 1522 + dev_dbg(&dev->dev, "hbm: enumeration response: on shutdown, ignoring\n"); 1518 1523 return 0; 1519 1524 } 1520 - dev_err(dev->dev, "hbm: enumeration response: state mismatch, [%d, %d]\n", 1525 + dev_err(&dev->dev, "hbm: enumeration response: state mismatch, [%d, %d]\n", 1521 1526 dev->dev_state, dev->hbm_state); 1522 1527 return -EPROTO; 1523 1528 } ··· 1531 1536 break; 1532 1537 1533 1538 case HOST_STOP_RES_CMD: 1534 - dev_dbg(dev->dev, "hbm: stop response: message received\n"); 1539 + dev_dbg(&dev->dev, "hbm: stop response: message received\n"); 1535 1540 1536 1541 dev->init_clients_timer = 0; 1537 1542 1538 1543 if (dev->hbm_state != MEI_HBM_STOPPED) { 1539 - dev_err(dev->dev, "hbm: stop response: state mismatch, [%d, %d]\n", 1544 + dev_err(&dev->dev, "hbm: stop response: state mismatch, [%d, %d]\n", 1540 1545 dev->dev_state, dev->hbm_state); 1541 1546 return -EPROTO; 1542 1547 } 1543 1548 1544 1549 mei_set_devstate(dev, MEI_DEV_POWER_DOWN); 1545 - dev_info(dev->dev, "hbm: stop response: resetting.\n"); 1550 + dev_info(&dev->dev, "hbm: stop response: resetting.\n"); 1546 1551 /* force the reset */ 1547 1552 return -EPROTO; 1548 1553 1549 1554 case CLIENT_DISCONNECT_REQ_CMD: 1550 - dev_dbg(dev->dev, "hbm: disconnect request: message received\n"); 1555 + dev_dbg(&dev->dev, "hbm: disconnect request: message received\n"); 1551 1556 1552 1557 disconnect_req = (struct hbm_client_connect_request *)mei_msg; 1553 1558 mei_hbm_fw_disconnect_req(dev, disconnect_req); 1554 1559 break; 1555 1560 1556 1561 case ME_STOP_REQ_CMD: 1557 - dev_dbg(dev->dev, "hbm: stop request: message received\n"); 1562 + dev_dbg(&dev->dev, "hbm: stop request: message received\n"); 1558 1563 dev->hbm_state = MEI_HBM_STOPPED; 1559 1564 if (mei_hbm_stop_req(dev)) { 1560 - dev_err(dev->dev, "hbm: stop request: failed to send stop request\n"); 1565 + dev_err(&dev->dev, "hbm: stop request: failed to send stop request\n"); 1561 1566 return -EIO; 1562 1567 } 1563 1568 break; 1564 1569 1565 1570 case MEI_HBM_ADD_CLIENT_REQ_CMD: 1566 - dev_dbg(dev->dev, "hbm: add client request received\n"); 1571 + dev_dbg(&dev->dev, "hbm: add client request received\n"); 1567 1572 /* 1568 1573 * after the host receives the enum_resp 1569 1574 * message clients may be added or removed 1570 1575 */ 1571 1576 if (dev->hbm_state <= MEI_HBM_ENUM_CLIENTS || 1572 1577 dev->hbm_state >= MEI_HBM_STOPPED) { 1573 - dev_err(dev->dev, "hbm: add client: state mismatch, [%d, %d]\n", 1578 + dev_err(&dev->dev, "hbm: add client: state mismatch, [%d, %d]\n", 1574 1579 dev->dev_state, dev->hbm_state); 1575 1580 return -EPROTO; 1576 1581 } 1577 1582 add_cl_req = (struct hbm_add_client_request *)mei_msg; 1578 1583 ret = mei_hbm_fw_add_cl_req(dev, add_cl_req); 1579 1584 if (ret) { 1580 - dev_err(dev->dev, "hbm: add client: failed to send response %d\n", 1585 + dev_err(&dev->dev, "hbm: add client: failed to send response %d\n", 1581 1586 ret); 1582 1587 return -EIO; 1583 1588 } 1584 - dev_dbg(dev->dev, "hbm: add client request processed\n"); 1589 + dev_dbg(&dev->dev, "hbm: add client request processed\n"); 1585 1590 break; 1586 1591 1587 1592 case MEI_HBM_NOTIFY_RES_CMD: 1588 - dev_dbg(dev->dev, "hbm: notify response received\n"); 1593 + dev_dbg(&dev->dev, "hbm: notify response received\n"); 1589 1594 mei_hbm_cl_res(dev, cl_cmd, notify_res_to_fop(cl_cmd)); 1590 1595 break; 1591 1596 1592 1597 case MEI_HBM_NOTIFICATION_CMD: 1593 - dev_dbg(dev->dev, "hbm: notification\n"); 1598 + dev_dbg(&dev->dev, "hbm: notification\n"); 1594 1599 mei_hbm_cl_notify(dev, cl_cmd); 1595 1600 break; 1596 1601 1597 1602 case MEI_HBM_CLIENT_DMA_MAP_RES_CMD: 1598 - dev_dbg(dev->dev, "hbm: client dma map response: message received.\n"); 1603 + dev_dbg(&dev->dev, "hbm: client dma map response: message received.\n"); 1599 1604 client_dma_res = (struct hbm_client_dma_response *)mei_msg; 1600 1605 mei_hbm_cl_dma_map_res(dev, client_dma_res); 1601 1606 break; 1602 1607 1603 1608 case MEI_HBM_CLIENT_DMA_UNMAP_RES_CMD: 1604 - dev_dbg(dev->dev, "hbm: client dma unmap response: message received.\n"); 1609 + dev_dbg(&dev->dev, "hbm: client dma unmap response: message received.\n"); 1605 1610 client_dma_res = (struct hbm_client_dma_response *)mei_msg; 1606 1611 mei_hbm_cl_dma_unmap_res(dev, client_dma_res); 1607 1612 break;

+50 -50

drivers/misc/mei/hw-me.c

··· 84 84 u32 reg; 85 85 86 86 reg = mei_me_reg_read(to_me_hw(dev), ME_CSR_HA); 87 - trace_mei_reg_read(dev->dev, "ME_CSR_HA", ME_CSR_HA, reg); 87 + trace_mei_reg_read(&dev->dev, "ME_CSR_HA", ME_CSR_HA, reg); 88 88 89 89 return reg; 90 90 } ··· 101 101 u32 reg; 102 102 103 103 reg = mei_me_reg_read(to_me_hw(dev), H_CSR); 104 - trace_mei_reg_read(dev->dev, "H_CSR", H_CSR, reg); 104 + trace_mei_reg_read(&dev->dev, "H_CSR", H_CSR, reg); 105 105 106 106 return reg; 107 107 } ··· 114 114 */ 115 115 static inline void mei_hcsr_write(struct mei_device *dev, u32 reg) 116 116 { 117 - trace_mei_reg_write(dev->dev, "H_CSR", H_CSR, reg); 117 + trace_mei_reg_write(&dev->dev, "H_CSR", H_CSR, reg); 118 118 mei_me_reg_write(to_me_hw(dev), H_CSR, reg); 119 119 } 120 120 ··· 156 156 u32 reg; 157 157 158 158 reg = mei_me_reg_read(to_me_hw(dev), H_D0I3C); 159 - trace_mei_reg_read(dev->dev, "H_D0I3C", H_D0I3C, reg); 159 + trace_mei_reg_read(&dev->dev, "H_D0I3C", H_D0I3C, reg); 160 160 161 161 return reg; 162 162 } ··· 169 169 */ 170 170 static inline void mei_me_d0i3c_write(struct mei_device *dev, u32 reg) 171 171 { 172 - trace_mei_reg_write(dev->dev, "H_D0I3C", H_D0I3C, reg); 172 + trace_mei_reg_write(&dev->dev, "H_D0I3C", H_D0I3C, reg); 173 173 mei_me_reg_write(to_me_hw(dev), H_D0I3C, reg); 174 174 } 175 175 ··· 189 189 return -EOPNOTSUPP; 190 190 191 191 *trc = mei_me_reg_read(hw, ME_TRC); 192 - trace_mei_reg_read(dev->dev, "ME_TRC", ME_TRC, *trc); 192 + trace_mei_reg_read(&dev->dev, "ME_TRC", ME_TRC, *trc); 193 193 194 194 return 0; 195 195 } ··· 217 217 for (i = 0; i < fw_src->count && i < MEI_FW_STATUS_MAX; i++) { 218 218 ret = hw->read_fws(dev, fw_src->status[i], 219 219 &fw_status->status[i]); 220 - trace_mei_pci_cfg_read(dev->dev, "PCI_CFG_HFS_X", 220 + trace_mei_pci_cfg_read(&dev->dev, "PCI_CFG_HFS_X", 221 221 fw_src->status[i], 222 222 fw_status->status[i]); 223 223 if (ret) ··· 251 251 252 252 reg = 0; 253 253 hw->read_fws(dev, PCI_CFG_HFS_1, &reg); 254 - trace_mei_pci_cfg_read(dev->dev, "PCI_CFG_HFS_1", PCI_CFG_HFS_1, reg); 254 + trace_mei_pci_cfg_read(&dev->dev, "PCI_CFG_HFS_1", PCI_CFG_HFS_1, reg); 255 255 hw->d0i3_supported = 256 256 ((reg & PCI_CFG_HFS_1_D0I3_MSK) == PCI_CFG_HFS_1_D0I3_MSK); 257 257 ··· 447 447 return; 448 448 449 449 hw->read_fws(dev, PCI_CFG_HFS_5, &fwsts5); 450 - trace_mei_pci_cfg_read(dev->dev, "PCI_CFG_HFS_5", PCI_CFG_HFS_5, fwsts5); 450 + trace_mei_pci_cfg_read(&dev->dev, "PCI_CFG_HFS_5", PCI_CFG_HFS_5, fwsts5); 451 451 452 452 if ((fwsts5 & GSC_CFG_HFS_5_BOOT_TYPE_MSK) == GSC_CFG_HFS_5_BOOT_TYPE_PXP) { 453 453 if (dev->gsc_reset_to_pxp == MEI_DEV_RESET_TO_PXP_DEFAULT) ··· 460 460 return; 461 461 462 462 if ((fwsts5 & GSC_CFG_HFS_5_BOOT_TYPE_MSK) == GSC_CFG_HFS_5_BOOT_TYPE_PXP) { 463 - dev_dbg(dev->dev, "pxp mode is ready 0x%08x\n", fwsts5); 463 + dev_dbg(&dev->dev, "pxp mode is ready 0x%08x\n", fwsts5); 464 464 dev->pxp_mode = MEI_DEV_PXP_READY; 465 465 } else { 466 - dev_dbg(dev->dev, "pxp mode is not ready 0x%08x\n", fwsts5); 466 + dev_dbg(&dev->dev, "pxp mode is not ready 0x%08x\n", fwsts5); 467 467 } 468 468 } 469 469 ··· 482 482 dev->timeouts.hw_ready); 483 483 mutex_lock(&dev->device_lock); 484 484 if (!dev->recvd_hw_ready) { 485 - dev_err(dev->dev, "wait hw ready failed\n"); 485 + dev_err(&dev->dev, "wait hw ready failed\n"); 486 486 return -ETIME; 487 487 } 488 488 ··· 516 516 fw_pm_event != PCI_CFG_HFS_2_PM_CM_RESET_ERROR) 517 517 goto end; 518 518 } else { 519 - dev_err(dev->dev, "failed to read firmware status: %d\n", ret); 519 + dev_err(&dev->dev, "failed to read firmware status: %d\n", ret); 520 520 } 521 521 } 522 522 523 523 mei_fw_status2str(&dev->saved_fw_status, fw_sts_str, sizeof(fw_sts_str)); 524 - dev_warn(dev->dev, "unexpected reset: fw_pm_event = 0x%x, dev_state = %u fw status = %s\n", 524 + dev_warn(&dev->dev, "unexpected reset: fw_pm_event = 0x%x, dev_state = %u fw status = %s\n", 525 525 fw_pm_event, dev->saved_dev_state, fw_sts_str); 526 526 527 527 end: ··· 544 544 mei_me_check_fw_reset(dev); 545 545 if (ret) 546 546 return ret; 547 - dev_dbg(dev->dev, "hw is ready\n"); 547 + dev_dbg(&dev->dev, "hw is ready\n"); 548 548 549 549 mei_me_host_set_ready(dev); 550 550 return ret; ··· 644 644 return -EINVAL; 645 645 646 646 if (!data && data_len) { 647 - dev_err(dev->dev, "wrong parameters null data with data_len = %zu\n", data_len); 647 + dev_err(&dev->dev, "wrong parameters null data with data_len = %zu\n", data_len); 648 648 return -EINVAL; 649 649 } 650 650 651 - dev_dbg(dev->dev, MEI_HDR_FMT, MEI_HDR_PRM((struct mei_msg_hdr *)hdr)); 651 + dev_dbg(&dev->dev, MEI_HDR_FMT, MEI_HDR_PRM((struct mei_msg_hdr *)hdr)); 652 652 653 653 empty_slots = mei_hbuf_empty_slots(dev); 654 - dev_dbg(dev->dev, "empty slots = %d.\n", empty_slots); 654 + dev_dbg(&dev->dev, "empty slots = %d.\n", empty_slots); 655 655 656 656 if (empty_slots < 0) 657 657 return -EOVERFLOW; ··· 706 706 if (filled_slots > buffer_depth) 707 707 return -EOVERFLOW; 708 708 709 - dev_dbg(dev->dev, "filled_slots =%08x\n", filled_slots); 709 + dev_dbg(&dev->dev, "filled_slots =%08x\n", filled_slots); 710 710 return (int)filled_slots; 711 711 } 712 712 ··· 748 748 u32 reg; 749 749 750 750 reg = mei_me_reg_read(hw, H_HPG_CSR); 751 - trace_mei_reg_read(dev->dev, "H_HPG_CSR", H_HPG_CSR, reg); 751 + trace_mei_reg_read(&dev->dev, "H_HPG_CSR", H_HPG_CSR, reg); 752 752 753 753 reg |= H_HPG_CSR_PGI; 754 754 755 - trace_mei_reg_write(dev->dev, "H_HPG_CSR", H_HPG_CSR, reg); 755 + trace_mei_reg_write(&dev->dev, "H_HPG_CSR", H_HPG_CSR, reg); 756 756 mei_me_reg_write(hw, H_HPG_CSR, reg); 757 757 } 758 758 ··· 767 767 u32 reg; 768 768 769 769 reg = mei_me_reg_read(hw, H_HPG_CSR); 770 - trace_mei_reg_read(dev->dev, "H_HPG_CSR", H_HPG_CSR, reg); 770 + trace_mei_reg_read(&dev->dev, "H_HPG_CSR", H_HPG_CSR, reg); 771 771 772 772 WARN(!(reg & H_HPG_CSR_PGI), "PGI is not set\n"); 773 773 774 774 reg |= H_HPG_CSR_PGIHEXR; 775 775 776 - trace_mei_reg_write(dev->dev, "H_HPG_CSR", H_HPG_CSR, reg); 776 + trace_mei_reg_write(&dev->dev, "H_HPG_CSR", H_HPG_CSR, reg); 777 777 mei_me_reg_write(hw, H_HPG_CSR, reg); 778 778 } 779 779 ··· 905 905 return true; 906 906 907 907 notsupported: 908 - dev_dbg(dev->dev, "pg: not supported: d0i3 = %d HGP = %d hbm version %d.%d ?= %d.%d\n", 908 + dev_dbg(&dev->dev, "pg: not supported: d0i3 = %d HGP = %d hbm version %d.%d ?= %d.%d\n", 909 909 hw->d0i3_supported, 910 910 !!(reg & ME_PGIC_HRA), 911 911 dev->version.major_version, ··· 974 974 reg = mei_me_d0i3c_read(dev); 975 975 if (reg & H_D0I3C_I3) { 976 976 /* we are in d0i3, nothing to do */ 977 - dev_dbg(dev->dev, "d0i3 set not needed\n"); 977 + dev_dbg(&dev->dev, "d0i3 set not needed\n"); 978 978 ret = 0; 979 979 goto on; 980 980 } ··· 1003 1003 1004 1004 reg = mei_me_d0i3_set(dev, true); 1005 1005 if (!(reg & H_D0I3C_CIP)) { 1006 - dev_dbg(dev->dev, "d0i3 enter wait not needed\n"); 1006 + dev_dbg(&dev->dev, "d0i3 enter wait not needed\n"); 1007 1007 ret = 0; 1008 1008 goto on; 1009 1009 } ··· 1027 1027 hw->pg_state = MEI_PG_ON; 1028 1028 out: 1029 1029 dev->pg_event = MEI_PG_EVENT_IDLE; 1030 - dev_dbg(dev->dev, "d0i3 enter ret = %d\n", ret); 1030 + dev_dbg(&dev->dev, "d0i3 enter ret = %d\n", ret); 1031 1031 return ret; 1032 1032 } 1033 1033 ··· 1049 1049 reg = mei_me_d0i3c_read(dev); 1050 1050 if (reg & H_D0I3C_I3) { 1051 1051 /* we are in d0i3, nothing to do */ 1052 - dev_dbg(dev->dev, "already d0i3 : set not needed\n"); 1052 + dev_dbg(&dev->dev, "already d0i3 : set not needed\n"); 1053 1053 goto on; 1054 1054 } 1055 1055 ··· 1057 1057 on: 1058 1058 hw->pg_state = MEI_PG_ON; 1059 1059 dev->pg_event = MEI_PG_EVENT_IDLE; 1060 - dev_dbg(dev->dev, "d0i3 enter\n"); 1060 + dev_dbg(&dev->dev, "d0i3 enter\n"); 1061 1061 return 0; 1062 1062 } 1063 1063 ··· 1079 1079 reg = mei_me_d0i3c_read(dev); 1080 1080 if (!(reg & H_D0I3C_I3)) { 1081 1081 /* we are not in d0i3, nothing to do */ 1082 - dev_dbg(dev->dev, "d0i3 exit not needed\n"); 1082 + dev_dbg(&dev->dev, "d0i3 exit not needed\n"); 1083 1083 ret = 0; 1084 1084 goto off; 1085 1085 } 1086 1086 1087 1087 reg = mei_me_d0i3_unset(dev); 1088 1088 if (!(reg & H_D0I3C_CIP)) { 1089 - dev_dbg(dev->dev, "d0i3 exit wait not needed\n"); 1089 + dev_dbg(&dev->dev, "d0i3 exit wait not needed\n"); 1090 1090 ret = 0; 1091 1091 goto off; 1092 1092 } ··· 1111 1111 out: 1112 1112 dev->pg_event = MEI_PG_EVENT_IDLE; 1113 1113 1114 - dev_dbg(dev->dev, "d0i3 exit ret = %d\n", ret); 1114 + dev_dbg(&dev->dev, "d0i3 exit ret = %d\n", ret); 1115 1115 return ret; 1116 1116 } 1117 1117 ··· 1154 1154 * force H_RDY because it could be 1155 1155 * wiped off during PG 1156 1156 */ 1157 - dev_dbg(dev->dev, "d0i3 set host ready\n"); 1157 + dev_dbg(&dev->dev, "d0i3 set host ready\n"); 1158 1158 mei_me_host_set_ready(dev); 1159 1159 } 1160 1160 } else { ··· 1170 1170 * we got here because of HW initiated exit from D0i3. 1171 1171 * Start runtime pm resume sequence to exit low power state. 1172 1172 */ 1173 - dev_dbg(dev->dev, "d0i3 want resume\n"); 1173 + dev_dbg(&dev->dev, "d0i3 want resume\n"); 1174 1174 mei_hbm_pg_resume(dev); 1175 1175 } 1176 1176 } ··· 1250 1250 } 1251 1251 } 1252 1252 1253 - pm_runtime_set_active(dev->dev); 1253 + pm_runtime_set_active(dev->parent); 1254 1254 1255 1255 hcsr = mei_hcsr_read(dev); 1256 1256 /* H_RST may be found lit before reset is started, ··· 1259 1259 * we need to clean H_RST bit to start a successful reset sequence. 1260 1260 */ 1261 1261 if ((hcsr & H_RST) == H_RST) { 1262 - dev_warn(dev->dev, "H_RST is set = 0x%08X", hcsr); 1262 + dev_warn(&dev->dev, "H_RST is set = 0x%08X", hcsr); 1263 1263 hcsr &= ~H_RST; 1264 1264 mei_hcsr_set(dev, hcsr); 1265 1265 hcsr = mei_hcsr_read(dev); ··· 1280 1280 hcsr = mei_hcsr_read(dev); 1281 1281 1282 1282 if ((hcsr & H_RST) == 0) 1283 - dev_warn(dev->dev, "H_RST is not set = 0x%08X", hcsr); 1283 + dev_warn(&dev->dev, "H_RST is not set = 0x%08X", hcsr); 1284 1284 1285 1285 if ((hcsr & H_RDY) == H_RDY) 1286 - dev_warn(dev->dev, "H_RDY is not cleared 0x%08X", hcsr); 1286 + dev_warn(&dev->dev, "H_RDY is not cleared 0x%08X", hcsr); 1287 1287 1288 1288 if (!intr_enable) { 1289 1289 mei_me_hw_reset_release(dev); ··· 1313 1313 if (!me_intr_src(hcsr)) 1314 1314 return IRQ_NONE; 1315 1315 1316 - dev_dbg(dev->dev, "interrupt source 0x%08X\n", me_intr_src(hcsr)); 1316 + dev_dbg(&dev->dev, "interrupt source 0x%08X\n", me_intr_src(hcsr)); 1317 1317 1318 1318 /* disable interrupts on device */ 1319 1319 me_intr_disable(dev, hcsr); ··· 1339 1339 u32 hcsr; 1340 1340 int rets = 0; 1341 1341 1342 - dev_dbg(dev->dev, "function called after ISR to handle the interrupt processing.\n"); 1342 + dev_dbg(&dev->dev, "function called after ISR to handle the interrupt processing.\n"); 1343 1343 /* initialize our complete list */ 1344 1344 mutex_lock(&dev->device_lock); 1345 1345 ··· 1351 1351 /* check if ME wants a reset */ 1352 1352 if (!mei_hw_is_ready(dev) && dev->dev_state != MEI_DEV_RESETTING) { 1353 1353 if (kind_is_gsc(dev) || kind_is_gscfi(dev)) { 1354 - dev_dbg(dev->dev, "FW not ready: resetting: dev_state = %d\n", 1354 + dev_dbg(&dev->dev, "FW not ready: resetting: dev_state = %d\n", 1355 1355 dev->dev_state); 1356 1356 } else { 1357 - dev_warn(dev->dev, "FW not ready: resetting: dev_state = %d\n", 1357 + dev_warn(&dev->dev, "FW not ready: resetting: dev_state = %d\n", 1358 1358 dev->dev_state); 1359 1359 } 1360 1360 if (dev->dev_state == MEI_DEV_POWERING_DOWN || ··· 1373 1373 /* check if we need to start the dev */ 1374 1374 if (!mei_host_is_ready(dev)) { 1375 1375 if (mei_hw_is_ready(dev)) { 1376 - dev_dbg(dev->dev, "we need to start the dev.\n"); 1376 + dev_dbg(&dev->dev, "we need to start the dev.\n"); 1377 1377 dev->recvd_hw_ready = true; 1378 1378 wake_up(&dev->wait_hw_ready); 1379 1379 } else { 1380 - dev_dbg(dev->dev, "Spurious Interrupt\n"); 1380 + dev_dbg(&dev->dev, "Spurious Interrupt\n"); 1381 1381 } 1382 1382 goto end; 1383 1383 } 1384 1384 /* check slots available for reading */ 1385 1385 slots = mei_count_full_read_slots(dev); 1386 1386 while (slots > 0) { 1387 - dev_dbg(dev->dev, "slots to read = %08x\n", slots); 1387 + dev_dbg(&dev->dev, "slots to read = %08x\n", slots); 1388 1388 rets = mei_irq_read_handler(dev, &cmpl_list, &slots); 1389 1389 /* There is a race between ME write and interrupt delivery: 1390 1390 * Not all data is always available immediately after the ··· 1394 1394 break; 1395 1395 1396 1396 if (rets) { 1397 - dev_err(dev->dev, "mei_irq_read_handler ret = %d, state = %d.\n", 1397 + dev_err(&dev->dev, "mei_irq_read_handler ret = %d, state = %d.\n", 1398 1398 rets, dev->dev_state); 1399 1399 if (dev->dev_state != MEI_DEV_RESETTING && 1400 1400 dev->dev_state != MEI_DEV_DISABLED && ··· 1421 1421 mei_irq_compl_handler(dev, &cmpl_list); 1422 1422 1423 1423 end: 1424 - dev_dbg(dev->dev, "interrupt thread end ret = %d\n", rets); 1424 + dev_dbg(&dev->dev, "interrupt thread end ret = %d\n", rets); 1425 1425 mei_me_intr_enable(dev); 1426 1426 mutex_unlock(&dev->device_lock); 1427 1427 return IRQ_HANDLED; ··· 1453 1453 irqreturn_t irq_ret; 1454 1454 long polling_timeout = MEI_POLLING_TIMEOUT_ACTIVE; 1455 1455 1456 - dev_dbg(dev->dev, "kernel thread is running\n"); 1456 + dev_dbg(&dev->dev, "kernel thread is running\n"); 1457 1457 while (!kthread_should_stop()) { 1458 1458 struct mei_me_hw *hw = to_me_hw(dev); 1459 1459 u32 hcsr; ··· 1470 1470 polling_timeout = MEI_POLLING_TIMEOUT_ACTIVE; 1471 1471 irq_ret = mei_me_irq_thread_handler(1, dev); 1472 1472 if (irq_ret != IRQ_HANDLED) 1473 - dev_err(dev->dev, "irq_ret %d\n", irq_ret); 1473 + dev_err(&dev->dev, "irq_ret %d\n", irq_ret); 1474 1474 } else { 1475 1475 /* 1476 1476 * Increase timeout by MEI_POLLING_TIMEOUT_ACTIVE ··· 1804 1804 struct mei_me_hw *hw; 1805 1805 int i; 1806 1806 1807 - dev = devm_kzalloc(parent, sizeof(*dev) + sizeof(*hw), GFP_KERNEL); 1807 + dev = kzalloc(sizeof(*dev) + sizeof(*hw), GFP_KERNEL); 1808 1808 if (!dev) 1809 1809 return NULL; 1810 1810

+30 -30

drivers/misc/mei/hw-txe.c

··· 160 160 struct mei_txe_hw *hw = to_txe_hw(dev); 161 161 bool do_req = hw->aliveness != req; 162 162 163 - dev_dbg(dev->dev, "Aliveness current=%d request=%d\n", 163 + dev_dbg(&dev->dev, "Aliveness current=%d request=%d\n", 164 164 hw->aliveness, req); 165 165 if (do_req) { 166 166 dev->pg_event = MEI_PG_EVENT_WAIT; ··· 227 227 hw->aliveness = mei_txe_aliveness_get(dev); 228 228 if (hw->aliveness == expected) { 229 229 dev->pg_event = MEI_PG_EVENT_IDLE; 230 - dev_dbg(dev->dev, "aliveness settled after %lld usecs\n", 230 + dev_dbg(&dev->dev, "aliveness settled after %lld usecs\n", 231 231 ktime_to_us(ktime_sub(ktime_get(), start))); 232 232 return 0; 233 233 } ··· 235 235 } while (ktime_before(ktime_get(), stop)); 236 236 237 237 dev->pg_event = MEI_PG_EVENT_IDLE; 238 - dev_err(dev->dev, "aliveness timed out\n"); 238 + dev_err(&dev->dev, "aliveness timed out\n"); 239 239 return -ETIME; 240 240 } 241 241 ··· 270 270 ret = hw->aliveness == expected ? 0 : -ETIME; 271 271 272 272 if (ret) 273 - dev_warn(dev->dev, "aliveness timed out = %ld aliveness = %d event = %d\n", 273 + dev_warn(&dev->dev, "aliveness timed out = %ld aliveness = %d event = %d\n", 274 274 err, hw->aliveness, dev->pg_event); 275 275 else 276 - dev_dbg(dev->dev, "aliveness settled after = %d msec aliveness = %d event = %d\n", 276 + dev_dbg(&dev->dev, "aliveness settled after = %d msec aliveness = %d event = %d\n", 277 277 jiffies_to_msecs(timeout - err), 278 278 hw->aliveness, dev->pg_event); 279 279 ··· 438 438 */ 439 439 static void mei_txe_synchronize_irq(struct mei_device *dev) 440 440 { 441 - struct pci_dev *pdev = to_pci_dev(dev->dev); 441 + struct pci_dev *pdev = to_pci_dev(dev->parent); 442 442 443 443 synchronize_irq(pdev->irq); 444 444 } ··· 464 464 TXE_INTR_OUT_DB)); 465 465 466 466 if (ret) { 467 - dev_dbg(dev->dev, 467 + dev_dbg(&dev->dev, 468 468 "Pending Interrupts InReady=%01d Readiness=%01d, Aliveness=%01d, OutDoor=%01d\n", 469 469 !!(hw->intr_cause & TXE_INTR_IN_READY), 470 470 !!(hw->intr_cause & TXE_INTR_READINESS), ··· 612 612 msecs_to_jiffies(SEC_RESET_WAIT_TIMEOUT)); 613 613 mutex_lock(&dev->device_lock); 614 614 if (!dev->recvd_hw_ready) { 615 - dev_err(dev->dev, "wait for readiness failed\n"); 615 + dev_err(&dev->dev, "wait for readiness failed\n"); 616 616 return -ETIME; 617 617 } 618 618 ··· 638 638 struct mei_fw_status *fw_status) 639 639 { 640 640 const struct mei_fw_status *fw_src = &mei_txe_fw_sts; 641 - struct pci_dev *pdev = to_pci_dev(dev->dev); 641 + struct pci_dev *pdev = to_pci_dev(dev->parent); 642 642 int ret; 643 643 int i; 644 644 ··· 649 649 for (i = 0; i < fw_src->count && i < MEI_FW_STATUS_MAX; i++) { 650 650 ret = pci_read_config_dword(pdev, fw_src->status[i], 651 651 &fw_status->status[i]); 652 - trace_mei_pci_cfg_read(dev->dev, "PCI_CFG_HSF_X", 652 + trace_mei_pci_cfg_read(&dev->dev, "PCI_CFG_HSF_X", 653 653 fw_src->status[i], 654 654 fw_status->status[i]); 655 655 if (ret) ··· 677 677 hw->aliveness = mei_txe_aliveness_get(dev); 678 678 hw->readiness = mei_txe_readiness_get(dev); 679 679 680 - dev_dbg(dev->dev, "aliveness_resp = 0x%08x, readiness = 0x%08x.\n", 680 + dev_dbg(&dev->dev, "aliveness_resp = 0x%08x, readiness = 0x%08x.\n", 681 681 hw->aliveness, hw->readiness); 682 682 683 683 return 0; ··· 708 708 if (WARN_ON(!hdr || !data || hdr_len & 0x3)) 709 709 return -EINVAL; 710 710 711 - dev_dbg(dev->dev, MEI_HDR_FMT, MEI_HDR_PRM((struct mei_msg_hdr *)hdr)); 711 + dev_dbg(&dev->dev, MEI_HDR_FMT, MEI_HDR_PRM((struct mei_msg_hdr *)hdr)); 712 712 713 713 dw_cnt = mei_data2slots(hdr_len + data_len); 714 714 if (dw_cnt > slots) ··· 724 724 char fw_sts_str[MEI_FW_STATUS_STR_SZ]; 725 725 726 726 mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ); 727 - dev_err(dev->dev, "Input is not ready %s\n", fw_sts_str); 727 + dev_err(&dev->dev, "Input is not ready %s\n", fw_sts_str); 728 728 return -EAGAIN; 729 729 } 730 730 ··· 828 828 reg_buf = (u32 *)buf; 829 829 rem = len & 0x3; 830 830 831 - dev_dbg(dev->dev, "buffer-length = %lu buf[0]0x%08X\n", 831 + dev_dbg(&dev->dev, "buffer-length = %lu buf[0]0x%08X\n", 832 832 len, mei_txe_out_data_read(dev, 0)); 833 833 834 834 for (i = 0; i < len / MEI_SLOT_SIZE; i++) { 835 835 /* skip header: index starts from 1 */ 836 836 reg = mei_txe_out_data_read(dev, i + 1); 837 - dev_dbg(dev->dev, "buf[%d] = 0x%08X\n", i, reg); 837 + dev_dbg(&dev->dev, "buf[%d] = 0x%08X\n", i, reg); 838 838 *reg_buf++ = reg; 839 839 } 840 840 ··· 879 879 */ 880 880 if (aliveness_req != hw->aliveness) 881 881 if (mei_txe_aliveness_poll(dev, aliveness_req) < 0) { 882 - dev_err(dev->dev, "wait for aliveness settle failed ... bailing out\n"); 882 + dev_err(&dev->dev, "wait for aliveness settle failed ... bailing out\n"); 883 883 return -EIO; 884 884 } 885 885 ··· 889 889 if (aliveness_req) { 890 890 mei_txe_aliveness_set(dev, 0); 891 891 if (mei_txe_aliveness_poll(dev, 0) < 0) { 892 - dev_err(dev->dev, "wait for aliveness failed ... bailing out\n"); 892 + dev_err(&dev->dev, "wait for aliveness failed ... bailing out\n"); 893 893 return -EIO; 894 894 } 895 895 } ··· 921 921 922 922 ret = mei_txe_readiness_wait(dev); 923 923 if (ret < 0) { 924 - dev_err(dev->dev, "waiting for readiness failed\n"); 924 + dev_err(&dev->dev, "waiting for readiness failed\n"); 925 925 return ret; 926 926 } 927 927 ··· 937 937 938 938 ret = mei_txe_aliveness_set_sync(dev, 1); 939 939 if (ret < 0) { 940 - dev_err(dev->dev, "wait for aliveness failed ... bailing out\n"); 940 + dev_err(&dev->dev, "wait for aliveness failed ... bailing out\n"); 941 941 return ret; 942 942 } 943 943 944 - pm_runtime_set_active(dev->dev); 944 + pm_runtime_set_active(dev->parent); 945 945 946 946 /* enable input ready interrupts: 947 947 * SEC_IPC_HOST_INT_MASK.IPC_INPUT_READY_INT_MASK ··· 1049 1049 s32 slots; 1050 1050 int rets = 0; 1051 1051 1052 - dev_dbg(dev->dev, "irq thread: Interrupt Registers HHISR|HISR|SEC=%02X|%04X|%02X\n", 1052 + dev_dbg(&dev->dev, "irq thread: Interrupt Registers HHISR|HISR|SEC=%02X|%04X|%02X\n", 1053 1053 mei_txe_br_reg_read(hw, HHISR_REG), 1054 1054 mei_txe_br_reg_read(hw, HISR_REG), 1055 1055 mei_txe_sec_reg_read_silent(hw, SEC_IPC_HOST_INT_STATUS_REG)); ··· 1059 1059 mutex_lock(&dev->device_lock); 1060 1060 INIT_LIST_HEAD(&cmpl_list); 1061 1061 1062 - if (pci_dev_msi_enabled(to_pci_dev(dev->dev))) 1062 + if (pci_dev_msi_enabled(to_pci_dev(dev->parent))) 1063 1063 mei_txe_check_and_ack_intrs(dev, true); 1064 1064 1065 1065 /* show irq events */ ··· 1073 1073 * or TXE driver resetting the HECI interface. 1074 1074 */ 1075 1075 if (test_and_clear_bit(TXE_INTR_READINESS_BIT, &hw->intr_cause)) { 1076 - dev_dbg(dev->dev, "Readiness Interrupt was received...\n"); 1076 + dev_dbg(&dev->dev, "Readiness Interrupt was received...\n"); 1077 1077 1078 1078 /* Check if SeC is going through reset */ 1079 1079 if (mei_txe_readiness_is_sec_rdy(hw->readiness)) { 1080 - dev_dbg(dev->dev, "we need to start the dev.\n"); 1080 + dev_dbg(&dev->dev, "we need to start the dev.\n"); 1081 1081 dev->recvd_hw_ready = true; 1082 1082 } else { 1083 1083 dev->recvd_hw_ready = false; 1084 1084 if (dev->dev_state != MEI_DEV_RESETTING) { 1085 1085 1086 - dev_warn(dev->dev, "FW not ready: resetting.\n"); 1086 + dev_warn(&dev->dev, "FW not ready: resetting.\n"); 1087 1087 schedule_work(&dev->reset_work); 1088 1088 goto end; 1089 1089 ··· 1100 1100 1101 1101 if (test_and_clear_bit(TXE_INTR_ALIVENESS_BIT, &hw->intr_cause)) { 1102 1102 /* Clear the interrupt cause */ 1103 - dev_dbg(dev->dev, 1103 + dev_dbg(&dev->dev, 1104 1104 "Aliveness Interrupt: Status: %d\n", hw->aliveness); 1105 1105 dev->pg_event = MEI_PG_EVENT_RECEIVED; 1106 1106 if (waitqueue_active(&hw->wait_aliveness_resp)) ··· 1118 1118 if (rets && 1119 1119 (dev->dev_state != MEI_DEV_RESETTING && 1120 1120 dev->dev_state != MEI_DEV_POWER_DOWN)) { 1121 - dev_err(dev->dev, 1121 + dev_err(&dev->dev, 1122 1122 "mei_irq_read_handler ret = %d.\n", rets); 1123 1123 1124 1124 schedule_work(&dev->reset_work); ··· 1136 1136 dev->hbuf_is_ready = mei_hbuf_is_ready(dev); 1137 1137 rets = mei_irq_write_handler(dev, &cmpl_list); 1138 1138 if (rets && rets != -EMSGSIZE) 1139 - dev_err(dev->dev, "mei_irq_write_handler ret = %d.\n", 1139 + dev_err(&dev->dev, "mei_irq_write_handler ret = %d.\n", 1140 1140 rets); 1141 1141 dev->hbuf_is_ready = mei_hbuf_is_ready(dev); 1142 1142 } ··· 1144 1144 mei_irq_compl_handler(dev, &cmpl_list); 1145 1145 1146 1146 end: 1147 - dev_dbg(dev->dev, "interrupt thread end ret = %d\n", rets); 1147 + dev_dbg(&dev->dev, "interrupt thread end ret = %d\n", rets); 1148 1148 1149 1149 mutex_unlock(&dev->device_lock); 1150 1150 ··· 1197 1197 struct mei_device *dev; 1198 1198 struct mei_txe_hw *hw; 1199 1199 1200 - dev = devm_kzalloc(&pdev->dev, sizeof(*dev) + sizeof(*hw), GFP_KERNEL); 1200 + dev = kzalloc(sizeof(*dev) + sizeof(*hw), GFP_KERNEL); 1201 1201 if (!dev) 1202 1202 return NULL; 1203 1203

+23 -24

drivers/misc/mei/init.c

··· 96 96 97 97 ret = mei_fw_status(dev, &fw_status); 98 98 if (ret) { 99 - dev_err(dev->dev, "failed to read firmware status: %d\n", ret); 99 + dev_err(&dev->dev, "failed to read firmware status: %d\n", ret); 100 100 return; 101 101 } 102 102 ··· 126 126 127 127 mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ); 128 128 if (kind_is_gsc(dev) || kind_is_gscfi(dev)) { 129 - dev_dbg(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n", 129 + dev_dbg(&dev->dev, "unexpected reset: dev_state = %s fw status = %s\n", 130 130 mei_dev_state_str(state), fw_sts_str); 131 131 mei_save_fw_status(dev); 132 132 } else { 133 - dev_warn(dev->dev, "unexpected reset: dev_state = %s fw status = %s\n", 133 + dev_warn(&dev->dev, "unexpected reset: dev_state = %s fw status = %s\n", 134 134 mei_dev_state_str(state), fw_sts_str); 135 135 } 136 136 } ··· 150 150 151 151 dev->reset_count++; 152 152 if (dev->reset_count > MEI_MAX_CONSEC_RESET) { 153 - dev_err(dev->dev, "reset: reached maximal consecutive resets: disabling the device\n"); 153 + dev_err(&dev->dev, "reset: reached maximal consecutive resets: disabling the device\n"); 154 154 mei_set_devstate(dev, MEI_DEV_DISABLED); 155 155 return -ENODEV; 156 156 } ··· 170 170 memset(dev->rd_msg_hdr, 0, sizeof(dev->rd_msg_hdr)); 171 171 172 172 if (ret) { 173 - dev_err(dev->dev, "hw_reset failed ret = %d\n", ret); 173 + dev_err(&dev->dev, "hw_reset failed ret = %d\n", ret); 174 174 return ret; 175 175 } 176 176 177 177 if (state == MEI_DEV_POWER_DOWN) { 178 - dev_dbg(dev->dev, "powering down: end of reset\n"); 178 + dev_dbg(&dev->dev, "powering down: end of reset\n"); 179 179 mei_set_devstate(dev, MEI_DEV_DISABLED); 180 180 return 0; 181 181 } ··· 185 185 char fw_sts_str[MEI_FW_STATUS_STR_SZ]; 186 186 187 187 mei_fw_status_str(dev, fw_sts_str, MEI_FW_STATUS_STR_SZ); 188 - dev_err(dev->dev, "hw_start failed ret = %d fw status = %s\n", ret, fw_sts_str); 188 + dev_err(&dev->dev, "hw_start failed ret = %d fw status = %s\n", ret, fw_sts_str); 189 189 return ret; 190 190 } 191 191 192 192 if (dev->dev_state != MEI_DEV_RESETTING) { 193 - dev_dbg(dev->dev, "wrong state = %d on link start\n", dev->dev_state); 193 + dev_dbg(&dev->dev, "wrong state = %d on link start\n", dev->dev_state); 194 194 return 0; 195 195 } 196 196 197 - dev_dbg(dev->dev, "link is established start sending messages.\n"); 197 + dev_dbg(&dev->dev, "link is established start sending messages.\n"); 198 198 199 199 mei_set_devstate(dev, MEI_DEV_INIT_CLIENTS); 200 200 ret = mei_hbm_start_req(dev); 201 201 if (ret) { 202 - dev_err(dev->dev, "hbm_start failed ret = %d\n", ret); 202 + dev_err(&dev->dev, "hbm_start failed ret = %d\n", ret); 203 203 mei_set_devstate(dev, MEI_DEV_RESETTING); 204 204 return ret; 205 205 } ··· 228 228 if (ret) 229 229 goto err; 230 230 231 - dev_dbg(dev->dev, "reset in start the mei device.\n"); 231 + dev_dbg(&dev->dev, "reset in start the mei device.\n"); 232 232 233 233 dev->reset_count = 0; 234 234 do { ··· 236 236 ret = mei_reset(dev); 237 237 238 238 if (ret == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { 239 - dev_err(dev->dev, "reset failed ret = %d", ret); 239 + dev_err(&dev->dev, "reset failed ret = %d", ret); 240 240 goto err; 241 241 } 242 242 } while (ret); 243 243 244 244 if (mei_hbm_start_wait(dev)) { 245 - dev_err(dev->dev, "HBM haven't started"); 245 + dev_err(&dev->dev, "HBM haven't started"); 246 246 goto err; 247 247 } 248 248 249 249 if (!mei_hbm_version_is_supported(dev)) { 250 - dev_dbg(dev->dev, "MEI start failed.\n"); 250 + dev_dbg(&dev->dev, "MEI start failed.\n"); 251 251 goto err; 252 252 } 253 253 254 - dev_dbg(dev->dev, "link layer has been established.\n"); 254 + dev_dbg(&dev->dev, "link layer has been established.\n"); 255 255 256 256 mutex_unlock(&dev->device_lock); 257 257 return 0; 258 258 err: 259 - dev_err(dev->dev, "link layer initialization failed.\n"); 259 + dev_err(&dev->dev, "link layer initialization failed.\n"); 260 260 mei_set_devstate(dev, MEI_DEV_DISABLED); 261 261 mutex_unlock(&dev->device_lock); 262 262 return -ENODEV; ··· 284 284 mutex_unlock(&dev->device_lock); 285 285 286 286 if (err == -ENODEV || dev->dev_state == MEI_DEV_DISABLED) { 287 - dev_err(dev->dev, "device disabled = %d\n", err); 287 + dev_err(&dev->dev, "device disabled = %d\n", err); 288 288 return -ENODEV; 289 289 } 290 290 ··· 313 313 mutex_unlock(&dev->device_lock); 314 314 315 315 if (dev->dev_state == MEI_DEV_DISABLED) { 316 - dev_err(dev->dev, "device disabled = %d\n", ret); 316 + dev_err(&dev->dev, "device disabled = %d\n", ret); 317 317 return; 318 318 } 319 319 ··· 324 324 325 325 void mei_stop(struct mei_device *dev) 326 326 { 327 - dev_dbg(dev->dev, "stopping the device.\n"); 327 + dev_dbg(&dev->dev, "stopping the device.\n"); 328 328 329 329 mutex_lock(&dev->device_lock); 330 330 mei_set_devstate(dev, MEI_DEV_POWERING_DOWN); ··· 365 365 list_empty(&dev->write_list) && 366 366 list_empty(&dev->write_waiting_list)); 367 367 368 - dev_dbg(dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n", 368 + dev_dbg(&dev->dev, "write pg: is idle[%d] state=%s ctrl=%01d write=%01d wwait=%01d\n", 369 369 idle, 370 370 mei_dev_state_str(dev->dev_state), 371 371 list_empty(&dev->ctrl_wr_list), ··· 380 380 * mei_device_init - initialize mei_device structure 381 381 * 382 382 * @dev: the mei device 383 - * @device: the device structure 383 + * @parent: the parent device 384 384 * @slow_fw: configure longer timeouts as FW is slow 385 385 * @hw_ops: hw operations 386 386 */ 387 387 void mei_device_init(struct mei_device *dev, 388 - struct device *device, 388 + struct device *parent, 389 389 bool slow_fw, 390 390 const struct mei_hw_ops *hw_ops) 391 391 { ··· 426 426 427 427 dev->pg_event = MEI_PG_EVENT_IDLE; 428 428 dev->ops = hw_ops; 429 - dev->dev = device; 429 + dev->parent = parent; 430 430 431 431 dev->timeouts.hw_ready = mei_secs_to_jiffies(MEI_HW_READY_TIMEOUT); 432 432 dev->timeouts.connect = MEI_CONNECT_TIMEOUT; ··· 444 444 } 445 445 } 446 446 EXPORT_SYMBOL_GPL(mei_device_init); 447 -

+22 -23

drivers/misc/mei/interrupt.c

··· 76 76 * that length fits into rd_msg_buf 77 77 */ 78 78 mei_read_slots(dev, dev->rd_msg_buf, discard_len); 79 - dev_dbg(dev->dev, "discarding message " MEI_HDR_FMT "\n", 79 + dev_dbg(&dev->dev, "discarding message " MEI_HDR_FMT "\n", 80 80 MEI_HDR_PRM(hdr)); 81 81 } 82 82 ··· 229 229 cl_dbg(dev, cl, "completed read length = %zu\n", cb->buf_idx); 230 230 list_move_tail(&cb->list, cmpl_list); 231 231 } else { 232 - pm_runtime_mark_last_busy(dev->dev); 233 - pm_request_autosuspend(dev->dev); 232 + pm_runtime_mark_last_busy(dev->parent); 233 + pm_request_autosuspend(dev->parent); 234 234 } 235 235 236 236 return 0; ··· 310 310 return ret; 311 311 } 312 312 313 - pm_runtime_mark_last_busy(dev->dev); 314 - pm_request_autosuspend(dev->dev); 313 + pm_runtime_mark_last_busy(dev->parent); 314 + pm_request_autosuspend(dev->parent); 315 315 316 316 list_move_tail(&cb->list, &cl->rd_pending); 317 317 ··· 373 373 dev->rd_msg_hdr[0] = mei_read_hdr(dev); 374 374 dev->rd_msg_hdr_count = 1; 375 375 (*slots)--; 376 - dev_dbg(dev->dev, "slots =%08x.\n", *slots); 376 + dev_dbg(&dev->dev, "slots =%08x.\n", *slots); 377 377 378 378 ret = hdr_is_valid(dev->rd_msg_hdr[0]); 379 379 if (ret) { 380 - dev_err(dev->dev, "corrupted message header 0x%08X\n", 380 + dev_err(&dev->dev, "corrupted message header 0x%08X\n", 381 381 dev->rd_msg_hdr[0]); 382 382 goto end; 383 383 } 384 384 } 385 385 386 386 mei_hdr = (struct mei_msg_hdr *)dev->rd_msg_hdr; 387 - dev_dbg(dev->dev, MEI_HDR_FMT, MEI_HDR_PRM(mei_hdr)); 387 + dev_dbg(&dev->dev, MEI_HDR_FMT, MEI_HDR_PRM(mei_hdr)); 388 388 389 389 if (mei_slots2data(*slots) < mei_hdr->length) { 390 - dev_err(dev->dev, "less data available than length=%08x.\n", 390 + dev_err(&dev->dev, "less data available than length=%08x.\n", 391 391 *slots); 392 392 /* we can't read the message */ 393 393 ret = -ENODATA; ··· 402 402 dev->rd_msg_hdr[1] = mei_read_hdr(dev); 403 403 dev->rd_msg_hdr_count++; 404 404 (*slots)--; 405 - dev_dbg(dev->dev, "extended header is %08x\n", dev->rd_msg_hdr[1]); 405 + dev_dbg(&dev->dev, "extended header is %08x\n", dev->rd_msg_hdr[1]); 406 406 } 407 407 meta_hdr = ((struct mei_ext_meta_hdr *)&dev->rd_msg_hdr[1]); 408 408 if (check_add_overflow((u32)sizeof(*meta_hdr), 409 409 mei_slots2data(meta_hdr->size), 410 410 &hdr_size_ext)) { 411 - dev_err(dev->dev, "extended message size too big %d\n", 411 + dev_err(&dev->dev, "extended message size too big %d\n", 412 412 meta_hdr->size); 413 413 return -EBADMSG; 414 414 } 415 415 if (hdr_size_left < hdr_size_ext) { 416 - dev_err(dev->dev, "corrupted message header len %d\n", 416 + dev_err(&dev->dev, "corrupted message header len %d\n", 417 417 mei_hdr->length); 418 418 return -EBADMSG; 419 419 } ··· 422 422 ext_hdr_end = meta_hdr->size + 2; 423 423 for (i = dev->rd_msg_hdr_count; i < ext_hdr_end; i++) { 424 424 dev->rd_msg_hdr[i] = mei_read_hdr(dev); 425 - dev_dbg(dev->dev, "extended header %d is %08x\n", i, 425 + dev_dbg(&dev->dev, "extended header %d is %08x\n", i, 426 426 dev->rd_msg_hdr[i]); 427 427 dev->rd_msg_hdr_count++; 428 428 (*slots)--; ··· 431 431 432 432 if (mei_hdr->dma_ring) { 433 433 if (hdr_size_left != sizeof(dev->rd_msg_hdr[ext_hdr_end])) { 434 - dev_err(dev->dev, "corrupted message header len %d\n", 434 + dev_err(&dev->dev, "corrupted message header len %d\n", 435 435 mei_hdr->length); 436 436 return -EBADMSG; 437 437 } ··· 446 446 if (hdr_is_hbm(mei_hdr)) { 447 447 ret = mei_hbm_dispatch(dev, mei_hdr); 448 448 if (ret) { 449 - dev_dbg(dev->dev, "mei_hbm_dispatch failed ret = %d\n", 450 - ret); 449 + dev_dbg(&dev->dev, "mei_hbm_dispatch failed ret = %d\n", ret); 451 450 goto end; 452 451 } 453 452 goto reset_slots; ··· 473 474 ret = 0; 474 475 goto reset_slots; 475 476 } 476 - dev_err(dev->dev, "no destination client found 0x%08X\n", dev->rd_msg_hdr[0]); 477 + dev_err(&dev->dev, "no destination client found 0x%08X\n", dev->rd_msg_hdr[0]); 477 478 ret = -EBADMSG; 478 479 goto end; 479 480 ··· 484 485 *slots = mei_count_full_read_slots(dev); 485 486 if (*slots == -EOVERFLOW) { 486 487 /* overflow - reset */ 487 - dev_err(dev->dev, "resetting due to slots overflow.\n"); 488 + dev_err(&dev->dev, "resetting due to slots overflow.\n"); 488 489 /* set the event since message has been read */ 489 490 ret = -ERANGE; 490 491 goto end; ··· 524 525 return -EMSGSIZE; 525 526 526 527 /* complete all waiting for write CB */ 527 - dev_dbg(dev->dev, "complete all waiting for write cb.\n"); 528 + dev_dbg(&dev->dev, "complete all waiting for write cb.\n"); 528 529 529 530 list_for_each_entry_safe(cb, next, &dev->write_waiting_list, list) { 530 531 cl = cb->cl; ··· 536 537 } 537 538 538 539 /* complete control write list CB */ 539 - dev_dbg(dev->dev, "complete control write list cb.\n"); 540 + dev_dbg(&dev->dev, "complete control write list cb.\n"); 540 541 list_for_each_entry_safe(cb, next, &dev->ctrl_wr_list, list) { 541 542 cl = cb->cl; 542 543 switch (cb->fop_type) { ··· 590 591 591 592 } 592 593 /* complete write list CB */ 593 - dev_dbg(dev->dev, "complete write list cb.\n"); 594 + dev_dbg(&dev->dev, "complete write list cb.\n"); 594 595 list_for_each_entry_safe(cb, next, &dev->write_list, list) { 595 596 cl = cb->cl; 596 597 ret = mei_cl_irq_write(cl, cb, cmpl_list); ··· 655 656 656 657 if (dev->init_clients_timer) { 657 658 if (--dev->init_clients_timer == 0) { 658 - dev_err(dev->dev, "timer: init clients timeout hbm_state = %d.\n", 659 + dev_err(&dev->dev, "timer: init clients timeout hbm_state = %d.\n", 659 660 dev->hbm_state); 660 661 mei_reset(dev); 661 662 goto out; ··· 671 672 list_for_each_entry(cl, &dev->file_list, link) { 672 673 if (cl->timer_count) { 673 674 if (--cl->timer_count == 0) { 674 - dev_err(dev->dev, "timer: connect/disconnect timeout.\n"); 675 + dev_err(&dev->dev, "timer: connect/disconnect timeout.\n"); 675 676 mei_connect_timeout(cl); 676 677 goto out; 677 678 }

+56 -26

drivers/misc/mei/main.c

··· 51 51 52 52 int err; 53 53 54 - dev = container_of(inode->i_cdev, struct mei_device, cdev); 54 + dev = idr_find(&mei_idr, iminor(inode)); 55 + if (!dev) 56 + return -ENODEV; 57 + get_device(&dev->dev); 55 58 56 59 mutex_lock(&dev->device_lock); 57 60 58 61 if (dev->dev_state != MEI_DEV_ENABLED) { 59 - dev_dbg(dev->dev, "dev_state != MEI_ENABLED dev_state = %s\n", 62 + dev_dbg(&dev->dev, "dev_state != MEI_ENABLED dev_state = %s\n", 60 63 mei_dev_state_str(dev->dev_state)); 61 64 err = -ENODEV; 62 65 goto err_unlock; ··· 80 77 81 78 err_unlock: 82 79 mutex_unlock(&dev->device_lock); 80 + put_device(&dev->dev); 83 81 return err; 84 82 } 85 83 ··· 156 152 file->private_data = NULL; 157 153 158 154 mutex_unlock(&dev->device_lock); 155 + put_device(&dev->dev); 159 156 return rets; 160 157 } 161 158 ··· 482 477 483 478 me_cl = mei_me_cl_by_uuid(dev, uuid); 484 479 if (!me_cl) { 485 - dev_dbg(dev->dev, "Cannot connect to FW Client UUID = %pUl\n", 480 + dev_dbg(&dev->dev, "Cannot connect to FW Client UUID = %pUl\n", 486 481 uuid); 487 482 return -ENOTTY; 488 483 } ··· 1120 1115 1121 1116 dev->dev_state = state; 1122 1117 1123 - clsdev = class_find_device_by_devt(&mei_class, dev->cdev.dev); 1118 + if (!dev->cdev) 1119 + return; 1120 + 1121 + clsdev = class_find_device_by_devt(&mei_class, dev->cdev->dev); 1124 1122 if (clsdev) { 1125 1123 sysfs_notify(&clsdev->kobj, NULL, "dev_state"); 1126 1124 put_device(clsdev); ··· 1199 1191 if (ret >= 0) 1200 1192 dev->minor = ret; 1201 1193 else if (ret == -ENOSPC) 1202 - dev_err(dev->dev, "too many mei devices\n"); 1194 + dev_err(&dev->dev, "too many mei devices\n"); 1203 1195 1204 1196 mutex_unlock(&mei_minor_lock); 1205 1197 return ret; ··· 1217 1209 mutex_unlock(&mei_minor_lock); 1218 1210 } 1219 1211 1212 + static void mei_device_release(struct device *dev) 1213 + { 1214 + kfree(dev_get_drvdata(dev)); 1215 + } 1216 + 1220 1217 int mei_register(struct mei_device *dev, struct device *parent) 1221 1218 { 1222 - struct device *clsdev; /* class device */ 1223 1219 int ret, devno; 1224 1220 1225 1221 ret = mei_minor_get(dev); ··· 1232 1220 1233 1221 /* Fill in the data structures */ 1234 1222 devno = MKDEV(MAJOR(mei_devt), dev->minor); 1235 - cdev_init(&dev->cdev, &mei_fops); 1236 - dev->cdev.owner = parent->driver->owner; 1223 + 1224 + device_initialize(&dev->dev); 1225 + dev->dev.devt = devno; 1226 + dev->dev.class = &mei_class; 1227 + dev->dev.parent = parent; 1228 + dev->dev.groups = mei_groups; 1229 + dev->dev.release = mei_device_release; 1230 + dev_set_drvdata(&dev->dev, dev); 1231 + 1232 + dev->cdev = cdev_alloc(); 1233 + if (!dev->cdev) { 1234 + ret = -ENOMEM; 1235 + goto err; 1236 + } 1237 + dev->cdev->ops = &mei_fops; 1238 + dev->cdev->owner = parent->driver->owner; 1239 + cdev_set_parent(dev->cdev, &dev->dev.kobj); 1237 1240 1238 1241 /* Add the device */ 1239 - ret = cdev_add(&dev->cdev, devno, 1); 1242 + ret = cdev_add(dev->cdev, devno, 1); 1240 1243 if (ret) { 1241 - dev_err(parent, "unable to add device %d:%d\n", 1244 + dev_err(parent, "unable to add cdev for device %d:%d\n", 1242 1245 MAJOR(mei_devt), dev->minor); 1243 - goto err_dev_add; 1246 + goto err_del_cdev; 1244 1247 } 1245 1248 1246 - clsdev = device_create_with_groups(&mei_class, parent, devno, 1247 - dev, mei_groups, 1248 - "mei%d", dev->minor); 1249 - 1250 - if (IS_ERR(clsdev)) { 1251 - dev_err(parent, "unable to create device %d:%d\n", 1252 - MAJOR(mei_devt), dev->minor); 1253 - ret = PTR_ERR(clsdev); 1254 - goto err_dev_create; 1249 + ret = dev_set_name(&dev->dev, "mei%d", dev->minor); 1250 + if (ret) { 1251 + dev_err(parent, "unable to set name to device %d:%d ret = %d\n", 1252 + MAJOR(mei_devt), dev->minor, ret); 1253 + goto err_del_cdev; 1255 1254 } 1256 1255 1257 - mei_dbgfs_register(dev, dev_name(clsdev)); 1256 + ret = device_add(&dev->dev); 1257 + if (ret) { 1258 + dev_err(parent, "unable to add device %d:%d ret = %d\n", 1259 + MAJOR(mei_devt), dev->minor, ret); 1260 + goto err_del_cdev; 1261 + } 1262 + 1263 + mei_dbgfs_register(dev, dev_name(&dev->dev)); 1258 1264 1259 1265 return 0; 1260 1266 1261 - err_dev_create: 1262 - cdev_del(&dev->cdev); 1263 - err_dev_add: 1267 + err_del_cdev: 1268 + cdev_del(dev->cdev); 1269 + err: 1264 1270 mei_minor_free(dev); 1265 1271 return ret; 1266 1272 } ··· 1288 1258 { 1289 1259 int devno; 1290 1260 1291 - devno = dev->cdev.dev; 1292 - cdev_del(&dev->cdev); 1261 + devno = dev->cdev->dev; 1262 + cdev_del(dev->cdev); 1293 1263 1294 1264 mei_dbgfs_deregister(dev); 1295 1265

+7 -5

drivers/misc/mei/mei_dev.h

··· 470 470 /** 471 471 * struct mei_device - MEI private device struct 472 472 * 473 - * @dev : device on a bus 474 - * @cdev : character device 473 + * @parent : device on a bus 474 + * @dev : device object 475 + * @cdev : character device pointer 475 476 * @minor : minor number allocated for device 476 477 * 477 478 * @write_list : write pending list ··· 557 556 * @hw : hw specific data 558 557 */ 559 558 struct mei_device { 560 - struct device *dev; 561 - struct cdev cdev; 559 + struct device *parent; 560 + struct device dev; 561 + struct cdev *cdev; 562 562 int minor; 563 563 564 564 struct list_head write_list; ··· 705 703 * mei init function prototypes 706 704 */ 707 705 void mei_device_init(struct mei_device *dev, 708 - struct device *device, 706 + struct device *parent, 709 707 bool slow_fw, 710 708 const struct mei_hw_ops *hw_ops); 711 709 int mei_reset(struct mei_device *dev);

+10 -10

drivers/misc/mei/pci-me.c

··· 143 143 144 144 static int mei_me_read_fws(const struct mei_device *dev, int where, u32 *val) 145 145 { 146 - struct pci_dev *pdev = to_pci_dev(dev->dev); 146 + struct pci_dev *pdev = to_pci_dev(dev->parent); 147 147 148 148 return pci_read_config_dword(pdev, where, val); 149 149 } ··· 238 238 goto end; 239 239 } 240 240 241 + err = mei_register(dev, &pdev->dev); 242 + if (err) 243 + goto release_irq; 244 + 241 245 if (mei_start(dev)) { 242 246 dev_err(&pdev->dev, "init hw failure.\n"); 243 247 err = -ENODEV; 244 - goto release_irq; 248 + goto deregister; 245 249 } 246 250 247 251 pm_runtime_set_autosuspend_delay(&pdev->dev, MEI_ME_RPM_TIMEOUT); 248 252 pm_runtime_use_autosuspend(&pdev->dev); 249 - 250 - err = mei_register(dev, &pdev->dev); 251 - if (err) 252 - goto stop; 253 253 254 254 pci_set_drvdata(pdev, dev); 255 255 ··· 280 280 281 281 return 0; 282 282 283 - stop: 284 - mei_stop(dev); 283 + deregister: 284 + mei_deregister(dev); 285 285 release_irq: 286 286 mei_cancel_work(dev); 287 287 mei_disable_interrupts(dev); ··· 475 475 */ 476 476 static inline void mei_me_set_pm_domain(struct mei_device *dev) 477 477 { 478 - struct pci_dev *pdev = to_pci_dev(dev->dev); 478 + struct pci_dev *pdev = to_pci_dev(dev->parent); 479 479 480 480 if (pdev->dev.bus && pdev->dev.bus->pm) { 481 481 dev->pg_domain.ops = *pdev->dev.bus->pm; ··· 496 496 static inline void mei_me_unset_pm_domain(struct mei_device *dev) 497 497 { 498 498 /* stop using pm callbacks if any */ 499 - dev_pm_domain_set(dev->dev, NULL); 499 + dev_pm_domain_set(dev->parent, NULL); 500 500 } 501 501 502 502 static const struct dev_pm_ops mei_me_pm_ops = {

+2 -2

drivers/misc/mei/pci-txe.c

··· 321 321 */ 322 322 static inline void mei_txe_set_pm_domain(struct mei_device *dev) 323 323 { 324 - struct pci_dev *pdev = to_pci_dev(dev->dev); 324 + struct pci_dev *pdev = to_pci_dev(dev->parent); 325 325 326 326 if (pdev->dev.bus && pdev->dev.bus->pm) { 327 327 dev->pg_domain.ops = *pdev->dev.bus->pm; ··· 342 342 static inline void mei_txe_unset_pm_domain(struct mei_device *dev) 343 343 { 344 344 /* stop using pm callbacks if any */ 345 - dev_pm_domain_set(dev->dev, NULL); 345 + dev_pm_domain_set(dev->parent, NULL); 346 346 } 347 347 348 348 static const struct dev_pm_ops mei_txe_pm_ops = {

+13 -13

drivers/misc/mei/platform-vsc.c

··· 152 152 MEI_VSC_POLL_TIMEOUT_US, true, 153 153 hw, &buf, sizeof(buf)); 154 154 if (ret) { 155 - dev_err(mei_dev->dev, "wait fw ready failed: %d\n", ret); 155 + dev_err(&mei_dev->dev, "wait fw ready failed: %d\n", ret); 156 156 return ret; 157 157 } 158 158 ··· 259 259 if (!intr_enable) 260 260 return 0; 261 261 262 - return vsc_tp_init(hw->tp, mei_dev->dev); 262 + return vsc_tp_init(hw->tp, mei_dev->parent); 263 263 } 264 264 265 265 static const struct mei_hw_ops mei_vsc_hw_ops = { ··· 325 325 mei_dev->hbuf_is_ready = mei_hbuf_is_ready(mei_dev); 326 326 ret = mei_irq_write_handler(mei_dev, &cmpl_list); 327 327 if (ret) 328 - dev_err(mei_dev->dev, "dispatch write request failed: %d\n", ret); 328 + dev_err(&mei_dev->dev, "dispatch write request failed: %d\n", ret); 329 329 330 330 mei_dev->hbuf_is_ready = mei_hbuf_is_ready(mei_dev); 331 331 mei_irq_compl_handler(mei_dev, &cmpl_list); ··· 343 343 if (!tp) 344 344 return dev_err_probe(dev, -ENODEV, "no platform data\n"); 345 345 346 - mei_dev = devm_kzalloc(dev, size_add(sizeof(*mei_dev), sizeof(*hw)), 347 - GFP_KERNEL); 346 + mei_dev = kzalloc(size_add(sizeof(*mei_dev), sizeof(*hw)), GFP_KERNEL); 348 347 if (!mei_dev) 349 348 return -ENOMEM; 350 349 351 350 mei_device_init(mei_dev, dev, false, &mei_vsc_hw_ops); 351 + 352 352 mei_dev->fw_f_fw_ver_supported = 0; 353 353 mei_dev->kind = "ivsc"; 354 354 ··· 360 360 361 361 vsc_tp_register_event_cb(tp, mei_vsc_event_cb, mei_dev); 362 362 363 + ret = mei_register(mei_dev, dev); 364 + if (ret) 365 + goto err_dereg; 366 + 363 367 ret = mei_start(mei_dev); 364 368 if (ret) { 365 369 dev_err_probe(dev, ret, "init hw failed\n"); 366 370 goto err_cancel; 367 371 } 368 372 369 - ret = mei_register(mei_dev, dev); 370 - if (ret) 371 - goto err_stop; 372 - 373 - pm_runtime_enable(mei_dev->dev); 373 + pm_runtime_enable(mei_dev->parent); 374 374 375 375 return 0; 376 376 377 - err_stop: 378 - mei_stop(mei_dev); 377 + err_dereg: 378 + mei_deregister(mei_dev); 379 379 380 380 err_cancel: 381 381 mei_cancel_work(mei_dev); ··· 392 392 struct mei_device *mei_dev = platform_get_drvdata(pdev); 393 393 struct mei_vsc_hw *hw = mei_dev_to_vsc_hw(mei_dev); 394 394 395 - pm_runtime_disable(mei_dev->dev); 395 + pm_runtime_disable(mei_dev->parent); 396 396 397 397 mei_stop(mei_dev); 398 398

Configure Feed

Configure Feed