arch/arm/mach-pxa/smemc.c

17

static unsigned long msc[2];

arch/arm/mach-pxa/smemc.c

23

msc[0] = __raw_readl(MSC0);

arch/arm/mach-pxa/smemc.c

24

msc[1] = __raw_readl(MSC1);

arch/arm/mach-pxa/smemc.c

37

__raw_writel(msc[0], MSC0);

arch/arm/mach-pxa/smemc.c

38

__raw_writel(msc[1], MSC1);

arch/mips/include/asm/ip32/mace.h

268

volatile unsigned int msc;

drivers/acpi/arm64/mpam.c

112

return mpam_ris_create(msc, res->ris_index, MPAM_CLASS_CACHE,

drivers/acpi/arm64/mpam.c

121

return mpam_ris_create(msc, res->ris_index, MPAM_CLASS_MEMORY,

drivers/acpi/arm64/mpam.c

129

int acpi_mpam_parse_resources(struct mpam_msc *msc,

drivers/acpi/arm64/mpam.c

153

err = acpi_mpam_parse_resource(msc, resource);

drivers/acpi/arm64/mpam.c

98

static int acpi_mpam_parse_resource(struct mpam_msc *msc,

drivers/crypto/nx/nx.c

338

struct max_sync_cop *msc;

drivers/crypto/nx/nx.c

341

msc = (struct max_sync_cop *)p->value;

drivers/crypto/nx/nx.c

353

trip = msc->trip;

drivers/crypto/nx/nx.c

357

i < msc->triplets;

drivers/crypto/nx/nx.c

359

if (msc->fc >= NX_MAX_FC || msc->mode >= NX_MAX_MODE) {

drivers/crypto/nx/nx.c

361

"combo: %d/%d (ignored)\n", msc->fc,

drivers/crypto/nx/nx.c

362

msc->mode);

drivers/crypto/nx/nx.c

376

props->ap[msc->fc][msc->mode][0].databytelen =

drivers/crypto/nx/nx.c

378

props->ap[msc->fc][msc->mode][0].sglen =

drivers/crypto/nx/nx.c

382

props->ap[msc->fc][msc->mode][1].databytelen =

drivers/crypto/nx/nx.c

384

props->ap[msc->fc][msc->mode][1].sglen =

drivers/crypto/nx/nx.c

388

if (msc->fc == NX_FC_AES) {

drivers/crypto/nx/nx.c

389

props->ap[msc->fc][msc->mode][2].

drivers/crypto/nx/nx.c

391

props->ap[msc->fc][msc->mode][2].sglen =

drivers/crypto/nx/nx.c

393

} else if (msc->fc == NX_FC_AES_HMAC ||

drivers/crypto/nx/nx.c

394

msc->fc == NX_FC_SHA) {

drivers/crypto/nx/nx.c

395

props->ap[msc->fc][msc->mode][1].

drivers/crypto/nx/nx.c

397

props->ap[msc->fc][msc->mode][1].sglen =

drivers/crypto/nx/nx.c

402

": (%u/256)\n", msc->fc);

drivers/crypto/nx/nx.c

406

props->ap[msc->fc][msc->mode][2].databytelen =

drivers/crypto/nx/nx.c

408

props->ap[msc->fc][msc->mode][2].sglen =

drivers/crypto/nx/nx.c

413

"len combo: (%u/%u)\n", msc->fc,

drivers/crypto/nx/nx.c

422

msc = (struct max_sync_cop *)trip;

drivers/hid/hid-magicmouse.c

154

static int magicmouse_firm_touch(struct magicmouse_sc *msc)

drivers/hid/hid-magicmouse.c

162

for (ii = 0; ii < msc->ntouches; ii++) {

drivers/hid/hid-magicmouse.c

163

int idx = msc->tracking_ids[ii];

drivers/hid/hid-magicmouse.c

164

if (msc->touches[idx].size < 8) {

drivers/hid/hid-magicmouse.c

177

static void magicmouse_emit_buttons(struct magicmouse_sc *msc, int state)

drivers/hid/hid-magicmouse.c

179

int last_state = test_bit(BTN_LEFT, msc->input->key) << 0 |

drivers/hid/hid-magicmouse.c

180

test_bit(BTN_RIGHT, msc->input->key) << 1 |

drivers/hid/hid-magicmouse.c

181

test_bit(BTN_MIDDLE, msc->input->key) << 2;

drivers/hid/hid-magicmouse.c

194

} else if ((id = magicmouse_firm_touch(msc)) >= 0) {

drivers/hid/hid-magicmouse.c

195

int x = msc->touches[id].x;

drivers/hid/hid-magicmouse.c

204

input_report_key(msc->input, BTN_MIDDLE, state & 4);

drivers/hid/hid-magicmouse.c

207

input_report_key(msc->input, BTN_LEFT, state & 1);

drivers/hid/hid-magicmouse.c

208

input_report_key(msc->input, BTN_RIGHT, state & 2);

drivers/hid/hid-magicmouse.c

211

msc->scroll_accel = SCROLL_ACCEL_DEFAULT;

drivers/hid/hid-magicmouse.c

214

static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tdata)

drivers/hid/hid-magicmouse.c

216

struct input_dev *input = msc->input;

drivers/hid/hid-magicmouse.c

258

msc->tracking_ids[raw_id] = id;

drivers/hid/hid-magicmouse.c

259

msc->touches[id].x = x;

drivers/hid/hid-magicmouse.c

260

msc->touches[id].y = y;

drivers/hid/hid-magicmouse.c

261

msc->touches[id].size = size;

drivers/hid/hid-magicmouse.c

270

int step_x = msc->touches[id].scroll_x - x;

drivers/hid/hid-magicmouse.c

271

int step_y = msc->touches[id].scroll_y - y;

drivers/hid/hid-magicmouse.c

274

((64 - (int)scroll_speed) * msc->scroll_accel) /

drivers/hid/hid-magicmouse.c

277

int step_x_hr = msc->touches[id].scroll_x_hr - x;

drivers/hid/hid-magicmouse.c

278

int step_y_hr = msc->touches[id].scroll_y_hr - y;

drivers/hid/hid-magicmouse.c

283

msc->touches[id].scroll_x = x;

drivers/hid/hid-magicmouse.c

284

msc->touches[id].scroll_y = y;

drivers/hid/hid-magicmouse.c

285

msc->touches[id].scroll_x_hr = x;

drivers/hid/hid-magicmouse.c

286

msc->touches[id].scroll_y_hr = y;

drivers/hid/hid-magicmouse.c

287

msc->touches[id].scroll_x_active = false;

drivers/hid/hid-magicmouse.c

288

msc->touches[id].scroll_y_active = false;

drivers/hid/hid-magicmouse.c

292

msc->scroll_jiffies + HZ / 2))

drivers/hid/hid-magicmouse.c

293

msc->scroll_accel = max_t(int,

drivers/hid/hid-magicmouse.c

294

msc->scroll_accel - 1, 1);

drivers/hid/hid-magicmouse.c

296

msc->scroll_accel = SCROLL_ACCEL_DEFAULT;

drivers/hid/hid-magicmouse.c

300

step_x /= (64 - (int)scroll_speed) * msc->scroll_accel;

drivers/hid/hid-magicmouse.c

302

msc->touches[id].scroll_x -= step_x *

drivers/hid/hid-magicmouse.c

303

(64 - scroll_speed) * msc->scroll_accel;

drivers/hid/hid-magicmouse.c

304

msc->scroll_jiffies = now;

drivers/hid/hid-magicmouse.c

308

step_y /= (64 - (int)scroll_speed) * msc->scroll_accel;

drivers/hid/hid-magicmouse.c

310

msc->touches[id].scroll_y -= step_y *

drivers/hid/hid-magicmouse.c

311

(64 - scroll_speed) * msc->scroll_accel;

drivers/hid/hid-magicmouse.c

312

msc->scroll_jiffies = now;

drivers/hid/hid-magicmouse.c

316

if (!msc->touches[id].scroll_x_active &&

drivers/hid/hid-magicmouse.c

318

msc->touches[id].scroll_x_active = true;

drivers/hid/hid-magicmouse.c

319

msc->touches[id].scroll_x_hr = x;

drivers/hid/hid-magicmouse.c

325

msc->touches[id].scroll_x_active) {

drivers/hid/hid-magicmouse.c

326

msc->touches[id].scroll_x_hr -= step_x_hr *

drivers/hid/hid-magicmouse.c

333

if (!msc->touches[id].scroll_y_active &&

drivers/hid/hid-magicmouse.c

335

msc->touches[id].scroll_y_active = true;

drivers/hid/hid-magicmouse.c

336

msc->touches[id].scroll_y_hr = y;

drivers/hid/hid-magicmouse.c

342

msc->touches[id].scroll_y_active) {

drivers/hid/hid-magicmouse.c

343

msc->touches[id].scroll_y_hr -= step_y_hr *

drivers/hid/hid-magicmouse.c

354

msc->ntouches++;

drivers/hid/hid-magicmouse.c

389

struct magicmouse_sc *msc = hid_get_drvdata(hdev);

drivers/hid/hid-magicmouse.c

390

struct input_dev *input = msc->input;

drivers/hid/hid-magicmouse.c

405

msc->ntouches = 0;

drivers/hid/hid-magicmouse.c

407

magicmouse_emit_touch(msc, ii, data + ii * 9 + 4);

drivers/hid/hid-magicmouse.c

427

msc->ntouches = 0;

drivers/hid/hid-magicmouse.c

429

magicmouse_emit_touch(msc, ii, data + ii * 9 + 12);

drivers/hid/hid-magicmouse.c

443

msc->ntouches = 0;

drivers/hid/hid-magicmouse.c

445

magicmouse_emit_touch(msc, ii, data + ii * 8 + 6);

drivers/hid/hid-magicmouse.c

471

msc->ntouches = 0;

drivers/hid/hid-magicmouse.c

473

magicmouse_emit_touch(msc, ii, data + ii * 8 + 14);

drivers/hid/hid-magicmouse.c

504

magicmouse_emit_buttons(msc, clicks & 3);

drivers/hid/hid-magicmouse.c

524

struct magicmouse_sc *msc = hid_get_drvdata(hdev);

drivers/hid/hid-magicmouse.c

525

if ((msc->input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2 ||

drivers/hid/hid-magicmouse.c

526

msc->input->id.product == USB_DEVICE_ID_APPLE_MAGICMOUSE2_USBC) &&

drivers/hid/hid-magicmouse.c

705

struct magicmouse_sc *msc = hid_get_drvdata(hdev);

drivers/hid/hid-magicmouse.c

707

if (!msc->input)

drivers/hid/hid-magicmouse.c

708

msc->input = hi->input;

drivers/hid/hid-magicmouse.c

725

struct magicmouse_sc *msc = hid_get_drvdata(hdev);

drivers/hid/hid-magicmouse.c

728

if (!msc->input) {

drivers/hid/hid-magicmouse.c

733

ret = magicmouse_setup_input(msc->input, hdev);

drivers/hid/hid-magicmouse.c

737

msc->input = NULL;

drivers/hid/hid-magicmouse.c

790

struct magicmouse_sc *msc =

drivers/hid/hid-magicmouse.c

794

ret = magicmouse_enable_multitouch(msc->hdev);

drivers/hid/hid-magicmouse.c

796

hid_err(msc->hdev, "unable to request touch data (%d)\n", ret);

drivers/hid/hid-magicmouse.c

844

struct magicmouse_sc *msc = timer_container_of(msc, t, battery_timer);

drivers/hid/hid-magicmouse.c

845

struct hid_device *hdev = msc->hdev;

drivers/hid/hid-magicmouse.c

848

mod_timer(&msc->battery_timer,

drivers/hid/hid-magicmouse.c

856

struct magicmouse_sc *msc;

drivers/hid/hid-magicmouse.c

860

msc = devm_kzalloc(&hdev->dev, sizeof(*msc), GFP_KERNEL);

drivers/hid/hid-magicmouse.c

861

if (msc == NULL) {

drivers/hid/hid-magicmouse.c

866

msc->scroll_accel = SCROLL_ACCEL_DEFAULT;

drivers/hid/hid-magicmouse.c

867

msc->hdev = hdev;

drivers/hid/hid-magicmouse.c

868

INIT_DEFERRABLE_WORK(&msc->work, magicmouse_enable_mt_work);

drivers/hid/hid-magicmouse.c

870

msc->quirks = id->driver_data;

drivers/hid/hid-magicmouse.c

871

hid_set_drvdata(hdev, msc);

drivers/hid/hid-magicmouse.c

887

timer_setup(&msc->battery_timer, magicmouse_battery_timer_tick, 0);

drivers/hid/hid-magicmouse.c

888

mod_timer(&msc->battery_timer,

drivers/hid/hid-magicmouse.c

898

if (!msc->input) {

drivers/hid/hid-magicmouse.c

953

schedule_delayed_work(&msc->work, msecs_to_jiffies(500));

drivers/hid/hid-magicmouse.c

960

timer_delete_sync(&msc->battery_timer);

drivers/hid/hid-magicmouse.c

968

struct magicmouse_sc *msc = hid_get_drvdata(hdev);

drivers/hid/hid-magicmouse.c

970

if (msc) {

drivers/hid/hid-magicmouse.c

971

cancel_delayed_work_sync(&msc->work);

drivers/hid/hid-magicmouse.c

974

timer_delete_sync(&msc->battery_timer);

drivers/hwtracing/intel_th/msu.c

1013

block = dma_alloc_coherent(msc_dev(win->msc)->parent->parent,

drivers/hwtracing/intel_th/msu.c

1026

dma_free_coherent(msc_dev(win->msc)->parent->parent, PAGE_SIZE,

drivers/hwtracing/intel_th/msu.c

1035

static void msc_buffer_set_uc(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1041

if (msc->mode == MSC_MODE_SINGLE) {

drivers/hwtracing/intel_th/msu.c

1042

set_memory_uc((unsigned long)msc->base, msc->nr_pages);

drivers/hwtracing/intel_th/msu.c

1046

list_for_each_entry(win, &msc->win_list, entry) {

drivers/hwtracing/intel_th/msu.c

1055

static void msc_buffer_set_wb(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1061

if (msc->mode == MSC_MODE_SINGLE) {

drivers/hwtracing/intel_th/msu.c

1062

set_memory_wb((unsigned long)msc->base, msc->nr_pages);

drivers/hwtracing/intel_th/msu.c

1066

list_for_each_entry(win, &msc->win_list, entry) {

drivers/hwtracing/intel_th/msu.c

1076

msc_buffer_set_uc(struct msc *msc) {}

drivers/hwtracing/intel_th/msu.c

1077

static inline void msc_buffer_set_wb(struct msc *msc) {}

drivers/hwtracing/intel_th/msu.c

1100

static int msc_buffer_win_alloc(struct msc *msc, unsigned int nr_blocks)

drivers/hwtracing/intel_th/msu.c

1112

win->msc = msc;

drivers/hwtracing/intel_th/msu.c

1117

if (!list_empty(&msc->win_list)) {

drivers/hwtracing/intel_th/msu.c

1118

struct msc_window *prev = list_last_entry(&msc->win_list,

drivers/hwtracing/intel_th/msu.c

1125

if (msc->mbuf && msc->mbuf->alloc_window)

drivers/hwtracing/intel_th/msu.c

1126

ret = msc->mbuf->alloc_window(msc->mbuf_priv, &win->sgt,

drivers/hwtracing/intel_th/msu.c

1137

if (list_empty(&msc->win_list)) {

drivers/hwtracing/intel_th/msu.c

1138

msc->base = msc_win_base(win);

drivers/hwtracing/intel_th/msu.c

1139

msc->base_addr = msc_win_base_dma(win);

drivers/hwtracing/intel_th/msu.c

1140

msc->cur_win = win;

drivers/hwtracing/intel_th/msu.c

1143

list_add_tail(&win->entry, &msc->win_list);

drivers/hwtracing/intel_th/msu.c

1144

msc->nr_pages += nr_blocks;

drivers/hwtracing/intel_th/msu.c

1154

static void __msc_buffer_win_free(struct msc *msc, struct msc_window *win)

drivers/hwtracing/intel_th/msu.c

1160

dma_free_coherent(msc_dev(win->msc)->parent->parent, PAGE_SIZE,

drivers/hwtracing/intel_th/msu.c

1174

static void msc_buffer_win_free(struct msc *msc, struct msc_window *win)

drivers/hwtracing/intel_th/msu.c

1176

msc->nr_pages -= win->nr_blocks;

drivers/hwtracing/intel_th/msu.c

1179

if (list_empty(&msc->win_list)) {

drivers/hwtracing/intel_th/msu.c

1180

msc->base = NULL;

drivers/hwtracing/intel_th/msu.c

1181

msc->base_addr = 0;

drivers/hwtracing/intel_th/msu.c

1184

if (msc->mbuf && msc->mbuf->free_window)

drivers/hwtracing/intel_th/msu.c

1185

msc->mbuf->free_window(msc->mbuf_priv, win->sgt);

drivers/hwtracing/intel_th/msu.c

1187

__msc_buffer_win_free(msc, win);

drivers/hwtracing/intel_th/msu.c

1199

static void msc_buffer_relink(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1204

list_for_each_entry(win, &msc->win_list, entry) {

drivers/hwtracing/intel_th/msu.c

1215

next_win = list_first_entry(&msc->win_list,

drivers/hwtracing/intel_th/msu.c

1253

static void msc_buffer_multi_free(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1257

list_for_each_entry_safe(win, iter, &msc->win_list, entry)

drivers/hwtracing/intel_th/msu.c

1258

msc_buffer_win_free(msc, win);

drivers/hwtracing/intel_th/msu.c

1261

static int msc_buffer_multi_alloc(struct msc *msc, unsigned long *nr_pages,

drivers/hwtracing/intel_th/msu.c

1267

ret = msc_buffer_win_alloc(msc, nr_pages[i]);

drivers/hwtracing/intel_th/msu.c

1269

msc_buffer_multi_free(msc);

drivers/hwtracing/intel_th/msu.c

1274

msc_buffer_relink(msc);

drivers/hwtracing/intel_th/msu.c

1288

static void msc_buffer_free(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1290

msc_buffer_set_wb(msc);

drivers/hwtracing/intel_th/msu.c

1292

if (msc->mode == MSC_MODE_SINGLE)

drivers/hwtracing/intel_th/msu.c

1293

msc_buffer_contig_free(msc);

drivers/hwtracing/intel_th/msu.c

1294

else if (msc->mode == MSC_MODE_MULTI)

drivers/hwtracing/intel_th/msu.c

1295

msc_buffer_multi_free(msc);

drivers/hwtracing/intel_th/msu.c

1315

static int msc_buffer_alloc(struct msc *msc, unsigned long *nr_pages,

drivers/hwtracing/intel_th/msu.c

1321

if (atomic_read(&msc->user_count) != -1)

drivers/hwtracing/intel_th/msu.c

1324

if (msc->mode == MSC_MODE_SINGLE) {

drivers/hwtracing/intel_th/msu.c

1328

ret = msc_buffer_contig_alloc(msc, nr_pages[0] << PAGE_SHIFT);

drivers/hwtracing/intel_th/msu.c

1329

} else if (msc->mode == MSC_MODE_MULTI) {

drivers/hwtracing/intel_th/msu.c

1330

ret = msc_buffer_multi_alloc(msc, nr_pages, nr_wins);

drivers/hwtracing/intel_th/msu.c

1336

msc_buffer_set_uc(msc);

drivers/hwtracing/intel_th/msu.c

1341

if (WARN_ON_ONCE(atomic_cmpxchg(&msc->user_count, -1, 0) != -1))

drivers/hwtracing/intel_th/msu.c

1359

static int msc_buffer_unlocked_free_unless_used(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1363

count = atomic_cmpxchg(&msc->user_count, 0, -1);

drivers/hwtracing/intel_th/msu.c

1370

msc_buffer_free(msc);

drivers/hwtracing/intel_th/msu.c

1385

static int msc_buffer_free_unless_used(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1389

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1390

ret = msc_buffer_unlocked_free_unless_used(msc);

drivers/hwtracing/intel_th/msu.c

1391

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1406

static struct page *msc_buffer_get_page(struct msc *msc, unsigned long pgoff)

drivers/hwtracing/intel_th/msu.c

1412

if (msc->mode == MSC_MODE_SINGLE)

drivers/hwtracing/intel_th/msu.c

1413

return msc_buffer_contig_get_page(msc, pgoff);

drivers/hwtracing/intel_th/msu.c

1415

list_for_each_entry(win, &msc->win_list, entry)

drivers/hwtracing/intel_th/msu.c

1474

struct msc *msc = dev_get_drvdata(&thdev->dev);

drivers/hwtracing/intel_th/msu.c

1480

iter = msc_iter_install(msc);

drivers/hwtracing/intel_th/msu.c

1492

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1494

msc_iter_remove(iter, msc);

drivers/hwtracing/intel_th/msu.c

1500

msc_single_to_user(struct msc *msc, char __user *buf, loff_t off, size_t len)

drivers/hwtracing/intel_th/msu.c

1502

unsigned long size = msc->nr_pages << PAGE_SHIFT, rem = len;

drivers/hwtracing/intel_th/msu.c

1505

if (msc->single_wrap) {

drivers/hwtracing/intel_th/msu.c

1506

start += msc->single_sz;

drivers/hwtracing/intel_th/msu.c

1509

if (copy_to_user(buf, msc->base + start, tocopy))

drivers/hwtracing/intel_th/msu.c

1519

tocopy = min(rem, msc->single_sz - start);

drivers/hwtracing/intel_th/msu.c

1520

if (copy_to_user(buf, msc->base + start, tocopy))

drivers/hwtracing/intel_th/msu.c

1529

if (copy_to_user(buf, msc->base + start, rem))

drivers/hwtracing/intel_th/msu.c

1539

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1544

if (!atomic_inc_unless_negative(&msc->user_count))

drivers/hwtracing/intel_th/msu.c

1547

if (msc->mode == MSC_MODE_SINGLE && !msc->single_wrap)

drivers/hwtracing/intel_th/msu.c

1548

size = msc->single_sz;

drivers/hwtracing/intel_th/msu.c

1550

size = msc->nr_pages << PAGE_SHIFT;

drivers/hwtracing/intel_th/msu.c

1561

if (msc->mode == MSC_MODE_SINGLE) {

drivers/hwtracing/intel_th/msu.c

1562

ret = msc_single_to_user(msc, buf, off, len);

drivers/hwtracing/intel_th/msu.c

1565

} else if (msc->mode == MSC_MODE_MULTI) {

drivers/hwtracing/intel_th/msu.c

1579

atomic_dec(&msc->user_count);

drivers/hwtracing/intel_th/msu.c

1591

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1593

atomic_inc(&msc->mmap_count);

drivers/hwtracing/intel_th/msu.c

1599

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1601

if (!atomic_dec_and_mutex_lock(&msc->mmap_count, &msc->buf_mutex))

drivers/hwtracing/intel_th/msu.c

1605

atomic_dec(&msc->user_count);

drivers/hwtracing/intel_th/msu.c

1606

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1612

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1615

page = msc_buffer_get_page(msc, vmf->pgoff);

drivers/hwtracing/intel_th/msu.c

1633

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

1643

if (!atomic_inc_unless_negative(&msc->user_count))

drivers/hwtracing/intel_th/msu.c

1646

if (msc->mode != MSC_MODE_SINGLE &&

drivers/hwtracing/intel_th/msu.c

1647

msc->mode != MSC_MODE_MULTI)

drivers/hwtracing/intel_th/msu.c

1650

if (size >> PAGE_SHIFT != msc->nr_pages)

drivers/hwtracing/intel_th/msu.c

1653

atomic_set(&msc->mmap_count, 1);

drivers/hwtracing/intel_th/msu.c

1658

atomic_dec(&msc->user_count);

drivers/hwtracing/intel_th/msu.c

1676

struct msc *msc = dev_get_drvdata(&thdev->dev);

drivers/hwtracing/intel_th/msu.c

1682

reg = __raw_readl(msc->reg_base + REG_MSU_MSC0STS);

drivers/hwtracing/intel_th/msu.c

1687

dev_dbg(msc_dev(msc), "timeout waiting for MSC0 PLE\n");

drivers/hwtracing/intel_th/msu.c

1690

static int intel_th_msc_init(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1692

atomic_set(&msc->user_count, -1);

drivers/hwtracing/intel_th/msu.c

1694

msc->mode = msc->multi_is_broken ? MSC_MODE_SINGLE : MSC_MODE_MULTI;

drivers/hwtracing/intel_th/msu.c

1695

mutex_init(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1696

INIT_LIST_HEAD(&msc->win_list);

drivers/hwtracing/intel_th/msu.c

1697

INIT_LIST_HEAD(&msc->iter_list);

drivers/hwtracing/intel_th/msu.c

1699

msc->burst_len =

drivers/hwtracing/intel_th/msu.c

1700

(ioread32(msc->reg_base + REG_MSU_MSC0CTL) & MSC_LEN) >>

drivers/hwtracing/intel_th/msu.c

1706

static int msc_win_switch(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1710

if (list_empty(&msc->win_list))

drivers/hwtracing/intel_th/msu.c

1713

first = list_first_entry(&msc->win_list, struct msc_window, entry);

drivers/hwtracing/intel_th/msu.c

1715

if (msc_is_last_win(msc->cur_win))

drivers/hwtracing/intel_th/msu.c

1716

msc->cur_win = first;

drivers/hwtracing/intel_th/msu.c

1718

msc->cur_win = list_next_entry(msc->cur_win, entry);

drivers/hwtracing/intel_th/msu.c

1720

msc->base = msc_win_base(msc->cur_win);

drivers/hwtracing/intel_th/msu.c

1721

msc->base_addr = msc_win_base_dma(msc->cur_win);

drivers/hwtracing/intel_th/msu.c

1723

intel_th_trace_switch(msc->thdev);

drivers/hwtracing/intel_th/msu.c

1735

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

1741

win = msc_find_window(msc, sgt, false);

drivers/hwtracing/intel_th/msu.c

1746

if (msc->switch_on_unlock == win) {

drivers/hwtracing/intel_th/msu.c

1747

msc->switch_on_unlock = NULL;

drivers/hwtracing/intel_th/msu.c

1748

msc_win_switch(msc);

drivers/hwtracing/intel_th/msu.c

1755

struct msc *msc = container_of(work, struct msc, work);

drivers/hwtracing/intel_th/msu.c

1757

intel_th_msc_deactivate(msc->thdev);

drivers/hwtracing/intel_th/msu.c

1762

struct msc *msc = dev_get_drvdata(&thdev->dev);

drivers/hwtracing/intel_th/msu.c

1763

u32 msusts = ioread32(msc->msu_base + REG_MSU_MSUSTS);

drivers/hwtracing/intel_th/msu.c

1764

u32 mask = msc->index ? MSUSTS_MSC1BLAST : MSUSTS_MSC0BLAST;

drivers/hwtracing/intel_th/msu.c

1767

if (!msc->do_irq || !msc->mbuf)

drivers/hwtracing/intel_th/msu.c

1773

return msc->enabled ? IRQ_HANDLED : IRQ_NONE;

drivers/hwtracing/intel_th/msu.c

1775

iowrite32(msusts, msc->msu_base + REG_MSU_MSUSTS);

drivers/hwtracing/intel_th/msu.c

1777

if (!msc->enabled)

drivers/hwtracing/intel_th/msu.c

1781

win = msc->cur_win;

drivers/hwtracing/intel_th/msu.c

1790

if (msc->stop_on_full)

drivers/hwtracing/intel_th/msu.c

1791

schedule_work(&msc->work);

drivers/hwtracing/intel_th/msu.c

1793

msc->switch_on_unlock = next_win;

drivers/hwtracing/intel_th/msu.c

1801

msc_win_switch(msc);

drivers/hwtracing/intel_th/msu.c

1803

if (msc->mbuf && msc->mbuf->ready)

drivers/hwtracing/intel_th/msu.c

1804

msc->mbuf->ready(msc->mbuf_priv, win->sgt,

drivers/hwtracing/intel_th/msu.c

1820

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

1822

return scnprintf(buf, PAGE_SIZE, "%d\n", msc->wrap);

drivers/hwtracing/intel_th/msu.c

1829

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

1837

msc->wrap = !!val;

drivers/hwtracing/intel_th/msu.c

1844

static void msc_buffer_unassign(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

1846

lockdep_assert_held(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1848

if (!msc->mbuf)

drivers/hwtracing/intel_th/msu.c

1851

msc->mbuf->unassign(msc->mbuf_priv);

drivers/hwtracing/intel_th/msu.c

1852

msu_buffer_put(msc->mbuf);

drivers/hwtracing/intel_th/msu.c

1853

msc->mbuf_priv = NULL;

drivers/hwtracing/intel_th/msu.c

1854

msc->mbuf = NULL;

drivers/hwtracing/intel_th/msu.c

1860

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

1861

const char *mode = msc_mode[msc->mode];

drivers/hwtracing/intel_th/msu.c

1864

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1865

if (msc->mbuf)

drivers/hwtracing/intel_th/msu.c

1866

mode = msc->mbuf->name;

drivers/hwtracing/intel_th/msu.c

1868

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1878

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

1901

if (!msc->do_irq) {

drivers/hwtracing/intel_th/msu.c

1914

if (i == MSC_MODE_MULTI && msc->multi_is_broken)

drivers/hwtracing/intel_th/msu.c

1917

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1921

if (mbuf && mbuf == msc->mbuf) {

drivers/hwtracing/intel_th/msu.c

1927

ret = msc_buffer_unlocked_free_unless_used(msc);

drivers/hwtracing/intel_th/msu.c

1939

msc_buffer_unassign(msc);

drivers/hwtracing/intel_th/msu.c

1940

msc->mbuf_priv = mbuf_priv;

drivers/hwtracing/intel_th/msu.c

1941

msc->mbuf = mbuf;

drivers/hwtracing/intel_th/msu.c

1943

msc_buffer_unassign(msc);

drivers/hwtracing/intel_th/msu.c

1946

msc->mode = i;

drivers/hwtracing/intel_th/msu.c

1951

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1961

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

1965

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1967

if (msc->mode == MSC_MODE_SINGLE)

drivers/hwtracing/intel_th/msu.c

1968

count = scnprintf(buf, PAGE_SIZE, "%ld\n", msc->nr_pages);

drivers/hwtracing/intel_th/msu.c

1969

else if (msc->mode == MSC_MODE_MULTI) {

drivers/hwtracing/intel_th/msu.c

1970

list_for_each_entry(win, &msc->win_list, entry) {

drivers/hwtracing/intel_th/msu.c

1979

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

1988

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

1998

ret = msc_buffer_free_unless_used(msc);

drivers/hwtracing/intel_th/msu.c

2021

if (nr_wins && msc->mode == MSC_MODE_SINGLE) {

drivers/hwtracing/intel_th/msu.c

2044

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

2045

ret = msc_buffer_alloc(msc, win, nr_wins);

drivers/hwtracing/intel_th/msu.c

2046

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

2060

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

2072

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

2078

if (msc->mode == MSC_MODE_MULTI && !msc->mbuf)

drivers/hwtracing/intel_th/msu.c

2079

ret = msc_win_switch(msc);

drivers/hwtracing/intel_th/msu.c

2080

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

2090

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

2092

return sprintf(buf, "%d\n", msc->stop_on_full);

drivers/hwtracing/intel_th/msu.c

2099

struct msc *msc = dev_get_drvdata(dev);

drivers/hwtracing/intel_th/msu.c

2102

ret = kstrtobool(buf, &msc->stop_on_full);

drivers/hwtracing/intel_th/msu.c

2128

struct msc *msc;

drivers/hwtracing/intel_th/msu.c

2140

msc = devm_kzalloc(dev, sizeof(*msc), GFP_KERNEL);

drivers/hwtracing/intel_th/msu.c

2141

if (!msc)

drivers/hwtracing/intel_th/msu.c

2146

msc->do_irq = 1;

drivers/hwtracing/intel_th/msu.c

2149

msc->multi_is_broken = 1;

drivers/hwtracing/intel_th/msu.c

2151

msc->index = thdev->id;

drivers/hwtracing/intel_th/msu.c

2153

msc->thdev = thdev;

drivers/hwtracing/intel_th/msu.c

2154

msc->reg_base = base + msc->index * 0x100;

drivers/hwtracing/intel_th/msu.c

2155

msc->msu_base = base;

drivers/hwtracing/intel_th/msu.c

2157

INIT_WORK(&msc->work, msc_work);

drivers/hwtracing/intel_th/msu.c

2158

err = intel_th_msc_init(msc);

drivers/hwtracing/intel_th/msu.c

2162

dev_set_drvdata(dev, msc);

drivers/hwtracing/intel_th/msu.c

2169

struct msc *msc = dev_get_drvdata(&thdev->dev);

drivers/hwtracing/intel_th/msu.c

2179

ret = msc_buffer_free_unless_used(msc);

drivers/hwtracing/intel_th/msu.c

315

return win->entry.next == &win->msc->win_list;

drivers/hwtracing/intel_th/msu.c

327

return list_first_entry(&win->msc->win_list, struct msc_window,

drivers/hwtracing/intel_th/msu.c

363

msc_find_window(struct msc *msc, struct sg_table *sgt, bool nonempty)

drivers/hwtracing/intel_th/msu.c

368

if (list_empty(&msc->win_list))

drivers/hwtracing/intel_th/msu.c

376

list_for_each_entry(win, &msc->win_list, entry) {

drivers/hwtracing/intel_th/msu.c

400

static struct msc_window *msc_oldest_window(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

404

if (list_empty(&msc->win_list))

drivers/hwtracing/intel_th/msu.c

407

win = msc_find_window(msc, msc_next_window(msc->cur_win)->sgt, true);

drivers/hwtracing/intel_th/msu.c

411

return list_first_entry(&msc->win_list, struct msc_window, entry);

drivers/hwtracing/intel_th/msu.c

449

static struct msc_iter *msc_iter_install(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

457

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

465

if (msc->enabled) {

drivers/hwtracing/intel_th/msu.c

471

iter->msc = msc;

drivers/hwtracing/intel_th/msu.c

473

list_add_tail(&iter->entry, &msc->iter_list);

drivers/hwtracing/intel_th/msu.c

475

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

480

static void msc_iter_remove(struct msc_iter *iter, struct msc *msc)

drivers/hwtracing/intel_th/msu.c

482

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

484

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

507

static int msc_iter_win_start(struct msc_iter *iter, struct msc *msc)

drivers/hwtracing/intel_th/msu.c

513

iter->start_win = msc_oldest_window(msc);

drivers/hwtracing/intel_th/msu.c

590

struct msc *msc = iter->msc;

drivers/hwtracing/intel_th/msu.c

598

if (msc_iter_win_start(iter, msc))

drivers/hwtracing/intel_th/msu.c

663

static void msc_buffer_clear_hw_header(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

668

list_for_each_entry(win, &msc->win_list, entry) {

drivers/hwtracing/intel_th/msu.c

679

static int intel_th_msu_init(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

683

if (!msc->do_irq)

drivers/hwtracing/intel_th/msu.c

686

if (!msc->mbuf)

drivers/hwtracing/intel_th/msu.c

689

mintctl = ioread32(msc->msu_base + REG_MSU_MINTCTL);

drivers/hwtracing/intel_th/msu.c

690

mintctl |= msc->index ? M1BLIE : M0BLIE;

drivers/hwtracing/intel_th/msu.c

691

iowrite32(mintctl, msc->msu_base + REG_MSU_MINTCTL);

drivers/hwtracing/intel_th/msu.c

692

if (mintctl != ioread32(msc->msu_base + REG_MSU_MINTCTL)) {

drivers/hwtracing/intel_th/msu.c

693

dev_info(msc_dev(msc), "MINTCTL ignores writes: no usable interrupts\n");

drivers/hwtracing/intel_th/msu.c

694

msc->do_irq = 0;

drivers/hwtracing/intel_th/msu.c

698

msusts = ioread32(msc->msu_base + REG_MSU_MSUSTS);

drivers/hwtracing/intel_th/msu.c

699

iowrite32(msusts, msc->msu_base + REG_MSU_MSUSTS);

drivers/hwtracing/intel_th/msu.c

704

static void intel_th_msu_deinit(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

708

if (!msc->do_irq)

drivers/hwtracing/intel_th/msu.c

711

mintctl = ioread32(msc->msu_base + REG_MSU_MINTCTL);

drivers/hwtracing/intel_th/msu.c

712

mintctl &= msc->index ? ~M1BLIE : ~M0BLIE;

drivers/hwtracing/intel_th/msu.c

713

iowrite32(mintctl, msc->msu_base + REG_MSU_MINTCTL);

drivers/hwtracing/intel_th/msu.c

724

if (!win->msc->mbuf)

drivers/hwtracing/intel_th/msu.c

738

atomic_inc(&win->msc->user_count);

drivers/hwtracing/intel_th/msu.c

740

atomic_dec(&win->msc->user_count);

drivers/hwtracing/intel_th/msu.c

75

struct msc *msc;

drivers/hwtracing/intel_th/msu.c

753

dev_warn_ratelimited(msc_dev(win->msc),

drivers/hwtracing/intel_th/msu.c

770

static int msc_configure(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

774

lockdep_assert_held(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

776

if (msc->mode > MSC_MODE_MULTI)

drivers/hwtracing/intel_th/msu.c

779

if (msc->mode == MSC_MODE_MULTI) {

drivers/hwtracing/intel_th/msu.c

780

if (msc_win_set_lockout(msc->cur_win, WIN_READY, WIN_INUSE))

drivers/hwtracing/intel_th/msu.c

783

msc_buffer_clear_hw_header(msc);

drivers/hwtracing/intel_th/msu.c

786

msc->orig_addr = ioread32(msc->reg_base + REG_MSU_MSC0BAR);

drivers/hwtracing/intel_th/msu.c

787

msc->orig_sz = ioread32(msc->reg_base + REG_MSU_MSC0SIZE);

drivers/hwtracing/intel_th/msu.c

789

reg = msc->base_addr >> PAGE_SHIFT;

drivers/hwtracing/intel_th/msu.c

790

iowrite32(reg, msc->reg_base + REG_MSU_MSC0BAR);

drivers/hwtracing/intel_th/msu.c

792

if (msc->mode == MSC_MODE_SINGLE) {

drivers/hwtracing/intel_th/msu.c

793

reg = msc->nr_pages;

drivers/hwtracing/intel_th/msu.c

794

iowrite32(reg, msc->reg_base + REG_MSU_MSC0SIZE);

drivers/hwtracing/intel_th/msu.c

797

reg = ioread32(msc->reg_base + REG_MSU_MSC0CTL);

drivers/hwtracing/intel_th/msu.c

801

reg |= msc->mode << __ffs(MSC_MODE);

drivers/hwtracing/intel_th/msu.c

802

reg |= msc->burst_len << __ffs(MSC_LEN);

drivers/hwtracing/intel_th/msu.c

804

if (msc->wrap)

drivers/hwtracing/intel_th/msu.c

807

iowrite32(reg, msc->reg_base + REG_MSU_MSC0CTL);

drivers/hwtracing/intel_th/msu.c

809

intel_th_msu_init(msc);

drivers/hwtracing/intel_th/msu.c

811

msc->thdev->output.multiblock = msc->mode == MSC_MODE_MULTI;

drivers/hwtracing/intel_th/msu.c

812

intel_th_trace_enable(msc->thdev);

drivers/hwtracing/intel_th/msu.c

813

msc->enabled = 1;

drivers/hwtracing/intel_th/msu.c

815

if (msc->mbuf && msc->mbuf->activate)

drivers/hwtracing/intel_th/msu.c

816

msc->mbuf->activate(msc->mbuf_priv);

drivers/hwtracing/intel_th/msu.c

828

static void msc_disable(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

830

struct msc_window *win = msc->cur_win;

drivers/hwtracing/intel_th/msu.c

833

lockdep_assert_held(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

835

if (msc->mode == MSC_MODE_MULTI)

drivers/hwtracing/intel_th/msu.c

838

if (msc->mbuf && msc->mbuf->deactivate)

drivers/hwtracing/intel_th/msu.c

839

msc->mbuf->deactivate(msc->mbuf_priv);

drivers/hwtracing/intel_th/msu.c

840

intel_th_msu_deinit(msc);

drivers/hwtracing/intel_th/msu.c

841

intel_th_trace_disable(msc->thdev);

drivers/hwtracing/intel_th/msu.c

843

if (msc->mode == MSC_MODE_SINGLE) {

drivers/hwtracing/intel_th/msu.c

844

reg = ioread32(msc->reg_base + REG_MSU_MSC0STS);

drivers/hwtracing/intel_th/msu.c

845

msc->single_wrap = !!(reg & MSCSTS_WRAPSTAT);

drivers/hwtracing/intel_th/msu.c

847

reg = ioread32(msc->reg_base + REG_MSU_MSC0MWP);

drivers/hwtracing/intel_th/msu.c

848

msc->single_sz = reg & ((msc->nr_pages << PAGE_SHIFT) - 1);

drivers/hwtracing/intel_th/msu.c

849

dev_dbg(msc_dev(msc), "MSCnMWP: %08x/%08lx, wrap: %d\n",

drivers/hwtracing/intel_th/msu.c

850

reg, msc->single_sz, msc->single_wrap);

drivers/hwtracing/intel_th/msu.c

853

reg = ioread32(msc->reg_base + REG_MSU_MSC0CTL);

drivers/hwtracing/intel_th/msu.c

855

iowrite32(reg, msc->reg_base + REG_MSU_MSC0CTL);

drivers/hwtracing/intel_th/msu.c

857

if (msc->mbuf && msc->mbuf->ready)

drivers/hwtracing/intel_th/msu.c

858

msc->mbuf->ready(msc->mbuf_priv, win->sgt,

drivers/hwtracing/intel_th/msu.c

861

msc->enabled = 0;

drivers/hwtracing/intel_th/msu.c

863

iowrite32(msc->orig_addr, msc->reg_base + REG_MSU_MSC0BAR);

drivers/hwtracing/intel_th/msu.c

864

iowrite32(msc->orig_sz, msc->reg_base + REG_MSU_MSC0SIZE);

drivers/hwtracing/intel_th/msu.c

866

dev_dbg(msc_dev(msc), "MSCnNWSA: %08x\n",

drivers/hwtracing/intel_th/msu.c

867

ioread32(msc->reg_base + REG_MSU_MSC0NWSA));

drivers/hwtracing/intel_th/msu.c

869

reg = ioread32(msc->reg_base + REG_MSU_MSC0STS);

drivers/hwtracing/intel_th/msu.c

870

dev_dbg(msc_dev(msc), "MSCnSTS: %08x\n", reg);

drivers/hwtracing/intel_th/msu.c

872

reg = ioread32(msc->reg_base + REG_MSU_MSUSTS);

drivers/hwtracing/intel_th/msu.c

873

reg &= msc->index ? MSUSTS_MSC1BLAST : MSUSTS_MSC0BLAST;

drivers/hwtracing/intel_th/msu.c

874

iowrite32(reg, msc->reg_base + REG_MSU_MSUSTS);

drivers/hwtracing/intel_th/msu.c

879

struct msc *msc = dev_get_drvdata(&thdev->dev);

drivers/hwtracing/intel_th/msu.c

882

if (!atomic_inc_unless_negative(&msc->user_count))

drivers/hwtracing/intel_th/msu.c

885

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

888

if (list_empty(&msc->iter_list))

drivers/hwtracing/intel_th/msu.c

889

ret = msc_configure(msc);

drivers/hwtracing/intel_th/msu.c

891

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

894

atomic_dec(&msc->user_count);

drivers/hwtracing/intel_th/msu.c

901

struct msc *msc = dev_get_drvdata(&thdev->dev);

drivers/hwtracing/intel_th/msu.c

903

mutex_lock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

904

if (msc->enabled) {

drivers/hwtracing/intel_th/msu.c

905

msc_disable(msc);

drivers/hwtracing/intel_th/msu.c

906

atomic_dec(&msc->user_count);

drivers/hwtracing/intel_th/msu.c

908

mutex_unlock(&msc->buf_mutex);

drivers/hwtracing/intel_th/msu.c

921

static int msc_buffer_contig_alloc(struct msc *msc, unsigned long size)

drivers/hwtracing/intel_th/msu.c

931

ret = sg_alloc_table(&msc->single_sgt, 1, GFP_KERNEL);

drivers/hwtracing/intel_th/msu.c

941

sg_set_buf(msc->single_sgt.sgl, page_address(page), size);

drivers/hwtracing/intel_th/msu.c

943

ret = dma_map_sg(msc_dev(msc)->parent->parent, msc->single_sgt.sgl, 1,

drivers/hwtracing/intel_th/msu.c

948

msc->nr_pages = nr_pages;

drivers/hwtracing/intel_th/msu.c

949

msc->base = page_address(page);

drivers/hwtracing/intel_th/msu.c

95

struct msc *msc;

drivers/hwtracing/intel_th/msu.c

950

msc->base_addr = sg_dma_address(msc->single_sgt.sgl);

drivers/hwtracing/intel_th/msu.c

958

sg_free_table(&msc->single_sgt);

drivers/hwtracing/intel_th/msu.c

968

static void msc_buffer_contig_free(struct msc *msc)

drivers/hwtracing/intel_th/msu.c

972

dma_unmap_sg(msc_dev(msc)->parent->parent, msc->single_sgt.sgl,

drivers/hwtracing/intel_th/msu.c

974

sg_free_table(&msc->single_sgt);

drivers/hwtracing/intel_th/msu.c

976

for (off = 0; off < msc->nr_pages << PAGE_SHIFT; off += PAGE_SIZE) {

drivers/hwtracing/intel_th/msu.c

977

struct page *page = virt_to_page(msc->base + off);

drivers/hwtracing/intel_th/msu.c

982

msc->nr_pages = 0;

drivers/hwtracing/intel_th/msu.c

992

static struct page *msc_buffer_contig_get_page(struct msc *msc,

drivers/hwtracing/intel_th/msu.c

995

if (pgoff >= msc->nr_pages)

drivers/hwtracing/intel_th/msu.c

998

return virt_to_page(msc->base + (pgoff << PAGE_SHIFT));

drivers/iio/gyro/itg3200_buffer.c

87

u8 msc;

drivers/iio/gyro/itg3200_buffer.c

89

ret = itg3200_read_reg_8(indio_dev, ITG3200_REG_IRQ_CONFIG, &msc);

drivers/iio/gyro/itg3200_buffer.c

94

msc |= ITG3200_IRQ_DATA_RDY_ENABLE;

drivers/iio/gyro/itg3200_buffer.c

96

msc &= ~ITG3200_IRQ_DATA_RDY_ENABLE;

drivers/iio/gyro/itg3200_buffer.c

98

ret = itg3200_write_reg_8(indio_dev, ITG3200_REG_IRQ_CONFIG, msc);

drivers/iio/imu/adis.c

261

u16 msc;

drivers/iio/imu/adis.c

275

ret = __adis_read_reg_16(adis, adis->data->msc_ctrl_reg, &msc);

drivers/iio/imu/adis.c

279

msc |= ADIS_MSC_CTRL_DATA_RDY_POL_HIGH;

drivers/iio/imu/adis.c

280

msc &= ~ADIS_MSC_CTRL_DATA_RDY_DIO2;

drivers/iio/imu/adis.c

282

msc |= ADIS_MSC_CTRL_DATA_RDY_EN;

drivers/iio/imu/adis.c

284

msc &= ~ADIS_MSC_CTRL_DATA_RDY_EN;

drivers/iio/imu/adis.c

286

return __adis_write_reg_16(adis, adis->data->msc_ctrl_reg, msc);

drivers/input/input.c

1523

INPUT_DEV_CAP_ATTR(MSC, msc);

drivers/input/input.c

2174

INPUT_CLEANSE_BITMASK(dev, MSC, msc);

drivers/net/ethernet/renesas/ravb.h

904

u8 msc; /* MAC status code */

drivers/net/ethernet/renesas/ravb.h

911

u8 msc; /* MAC status code */

drivers/net/ethernet/renesas/ravb_main.c

825

desc_status = desc->msc;

drivers/net/ethernet/renesas/ravb_main.c

995

desc_status = desc->msc;

drivers/resctrl/mpam_devices.c

1000

*flt_val = mpam_read_monsel_reg(msc, CFG_CSU_FLT);

drivers/resctrl/mpam_devices.c

1005

*ctl_val = mpam_read_monsel_reg(msc, CFG_MBWU_CTL);

drivers/resctrl/mpam_devices.c

1006

*flt_val = mpam_read_monsel_reg(msc, CFG_MBWU_FLT);

drivers/resctrl/mpam_devices.c

1025

struct mpam_msc *msc = m->ris->vmsc->msc;

drivers/resctrl/mpam_devices.c

1033

mpam_write_monsel_reg(msc, CFG_CSU_FLT, flt_val);

drivers/resctrl/mpam_devices.c

1034

mpam_write_monsel_reg(msc, CFG_CSU_CTL, ctl_val);

drivers/resctrl/mpam_devices.c

1035

mpam_write_monsel_reg(msc, CSU, 0);

drivers/resctrl/mpam_devices.c

1036

mpam_write_monsel_reg(msc, CFG_CSU_CTL, ctl_val | MSMON_CFG_x_CTL_EN);

drivers/resctrl/mpam_devices.c

1041

mpam_write_monsel_reg(msc, CFG_MBWU_FLT, flt_val);

drivers/resctrl/mpam_devices.c

1042

mpam_write_monsel_reg(msc, CFG_MBWU_CTL, ctl_val);

drivers/resctrl/mpam_devices.c

1043

mpam_write_monsel_reg(msc, CFG_MBWU_CTL, ctl_val | MSMON_CFG_x_CTL_EN);

drivers/resctrl/mpam_devices.c

1046

mpam_write_monsel_reg(msc, MBWU, 0);

drivers/resctrl/mpam_devices.c

1048

mpam_msc_zero_mbwu_l(m->ris->vmsc->msc);

drivers/resctrl/mpam_devices.c

1082

struct mpam_msc *msc = m->ris->vmsc->msc;

drivers/resctrl/mpam_devices.c

1085

if (!mpam_mon_sel_lock(msc)) {

drivers/resctrl/mpam_devices.c

1091

mpam_write_monsel_reg(msc, CFG_MON_SEL, mon_sel);

drivers/resctrl/mpam_devices.c

1128

mpam_write_monsel_reg(msc, CFG_MBWU_CTL,

drivers/resctrl/mpam_devices.c

1136

now = mpam_read_monsel_reg(msc, CSU);

drivers/resctrl/mpam_devices.c

1145

now = mpam_msc_read_mbwu_l(msc);

drivers/resctrl/mpam_devices.c

1154

now = mpam_read_monsel_reg(msc, MBWU);

drivers/resctrl/mpam_devices.c

1177

mpam_mon_sel_unlock(msc);

drivers/resctrl/mpam_devices.c

1196

struct mpam_msc *msc = vmsc->msc;

drivers/resctrl/mpam_devices.c

1203

err = smp_call_function_any(&msc->accessibility,

drivers/resctrl/mpam_devices.c

1284

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

1297

msc = vmsc->msc;

drivers/resctrl/mpam_devices.c

1303

if (WARN_ON_ONCE(!mpam_mon_sel_lock(msc)))

drivers/resctrl/mpam_devices.c

1308

mpam_mon_sel_unlock(msc);

drivers/resctrl/mpam_devices.c

1313

static void mpam_reset_msc_bitmap(struct mpam_msc *msc, u16 reg, u16 wd)

drivers/resctrl/mpam_devices.c

1319

lockdep_assert_held(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

1330

__mpam_write_reg(msc, reg, bm);

drivers/resctrl/mpam_devices.c

1338

__mpam_write_reg(msc, reg, bm);

drivers/resctrl/mpam_devices.c

1347

struct mpam_msc *msc = ris->vmsc->msc;

drivers/resctrl/mpam_devices.c

1352

mutex_lock(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

1353

__mpam_part_sel(ris->ris_idx, partid, msc);

drivers/resctrl/mpam_devices.c

1357

mpam_write_partsel_reg(msc, INTPARTID,

drivers/resctrl/mpam_devices.c

1364

__mpam_intpart_sel(ris->ris_idx, partid, msc);

drivers/resctrl/mpam_devices.c

1370

mpam_reset_msc_bitmap(msc, MPAMCFG_CPBM, rprops->cpbm_wd);

drivers/resctrl/mpam_devices.c

1372

mpam_write_partsel_reg(msc, CPBM, cfg->cpbm);

drivers/resctrl/mpam_devices.c

1378

mpam_reset_msc_bitmap(msc, MPAMCFG_MBW_PBM, rprops->mbw_pbm_bits);

drivers/resctrl/mpam_devices.c

1380

mpam_write_partsel_reg(msc, MBW_PBM, cfg->mbw_pbm);

drivers/resctrl/mpam_devices.c

1385

mpam_write_partsel_reg(msc, MBW_MIN, 0);

drivers/resctrl/mpam_devices.c

1390

mpam_write_partsel_reg(msc, MBW_MAX, MPAMCFG_MBW_MAX_MAX);

drivers/resctrl/mpam_devices.c

1392

mpam_write_partsel_reg(msc, MBW_MAX, cfg->mbw_max);

drivers/resctrl/mpam_devices.c

1397

mpam_write_partsel_reg(msc, MBW_PROP, 0);

drivers/resctrl/mpam_devices.c

1400

mpam_write_partsel_reg(msc, CMAX, cmax);

drivers/resctrl/mpam_devices.c

1403

mpam_write_partsel_reg(msc, CMIN, 0);

drivers/resctrl/mpam_devices.c

1406

mpam_write_partsel_reg(msc, CASSOC, MPAMCFG_CASSOC_CASSOC);

drivers/resctrl/mpam_devices.c

1421

mpam_write_partsel_reg(msc, PRI, pri_val);

drivers/resctrl/mpam_devices.c

1424

mutex_unlock(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

1459

struct mpam_msc *msc = ris->vmsc->msc;

drivers/resctrl/mpam_devices.c

1465

if (WARN_ON_ONCE(!mpam_mon_sel_lock(msc)))

drivers/resctrl/mpam_devices.c

1470

mpam_write_monsel_reg(msc, CFG_MON_SEL, mon_sel);

drivers/resctrl/mpam_devices.c

1472

cur_flt = mpam_read_monsel_reg(msc, CFG_MBWU_FLT);

drivers/resctrl/mpam_devices.c

1473

cur_ctl = mpam_read_monsel_reg(msc, CFG_MBWU_CTL);

drivers/resctrl/mpam_devices.c

1474

mpam_write_monsel_reg(msc, CFG_MBWU_CTL, 0);

drivers/resctrl/mpam_devices.c

1477

val = mpam_msc_read_mbwu_l(msc);

drivers/resctrl/mpam_devices.c

1478

mpam_msc_zero_mbwu_l(msc);

drivers/resctrl/mpam_devices.c

1480

val = mpam_read_monsel_reg(msc, MBWU);

drivers/resctrl/mpam_devices.c

1481

mpam_write_monsel_reg(msc, MBWU, 0);

drivers/resctrl/mpam_devices.c

1490

mpam_mon_sel_unlock(msc);

drivers/resctrl/mpam_devices.c

1535

static int mpam_get_msc_preferred_cpu(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

1539

if (cpumask_test_cpu(cpu, &msc->accessibility))

drivers/resctrl/mpam_devices.c

1542

return cpumask_first_and(&msc->accessibility, cpu_online_mask);

drivers/resctrl/mpam_devices.c

1545

static int mpam_touch_msc(struct mpam_msc *msc, int (*fn)(void *a), void *arg)

drivers/resctrl/mpam_devices.c

1551

return smp_call_on_cpu(mpam_get_msc_preferred_cpu(msc), fn, arg, true);

drivers/resctrl/mpam_devices.c

1569

static void mpam_reprogram_msc(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

158

static u32 __mpam_read_reg(struct mpam_msc *msc, u16 reg)

drivers/resctrl/mpam_devices.c

1583

mutex_lock(&msc->cfg_lock);

drivers/resctrl/mpam_devices.c

1584

list_for_each_entry_srcu(ris, &msc->ris, msc_list,

drivers/resctrl/mpam_devices.c

1587

mpam_touch_msc(msc, &mpam_reset_ris, ris);

drivers/resctrl/mpam_devices.c

160

WARN_ON_ONCE(!cpumask_test_cpu(smp_processor_id(), &msc->accessibility));

drivers/resctrl/mpam_devices.c

1601

mpam_touch_msc(msc, __write_config, &arg);

drivers/resctrl/mpam_devices.c

1606

mpam_touch_msc(msc, &mpam_restore_mbwu_state, ris);

drivers/resctrl/mpam_devices.c

1608

mutex_unlock(&msc->cfg_lock);

drivers/resctrl/mpam_devices.c

162

return readl_relaxed(msc->mapped_hwpage + reg);

drivers/resctrl/mpam_devices.c

1620

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

1623

list_for_each_entry_srcu(msc, &mpam_all_msc, all_msc_list,

drivers/resctrl/mpam_devices.c

1625

if (!cpumask_test_cpu(cpu, &msc->accessibility))

drivers/resctrl/mpam_devices.c

1628

if (msc->reenable_error_ppi)

drivers/resctrl/mpam_devices.c

1629

_enable_percpu_irq(&msc->reenable_error_ppi);

drivers/resctrl/mpam_devices.c

1631

if (atomic_fetch_inc(&msc->online_refs) == 0)

drivers/resctrl/mpam_devices.c

1632

mpam_reprogram_msc(msc);

drivers/resctrl/mpam_devices.c

1642

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

1649

list_for_each_entry_srcu(msc, &mpam_all_msc, all_msc_list,

drivers/resctrl/mpam_devices.c

165

static inline u32 _mpam_read_partsel_reg(struct mpam_msc *msc, u16 reg)

drivers/resctrl/mpam_devices.c

1651

if (!cpumask_test_cpu(cpu, &msc->accessibility))

drivers/resctrl/mpam_devices.c

1654

mutex_lock(&msc->probe_lock);

drivers/resctrl/mpam_devices.c

1655

if (!msc->probed)

drivers/resctrl/mpam_devices.c

1656

err = mpam_msc_hw_probe(msc);

drivers/resctrl/mpam_devices.c

1657

mutex_unlock(&msc->probe_lock);

drivers/resctrl/mpam_devices.c

167

lockdep_assert_held_once(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

1676

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

1679

list_for_each_entry_srcu(msc, &mpam_all_msc, all_msc_list,

drivers/resctrl/mpam_devices.c

168

return __mpam_read_reg(msc, reg);

drivers/resctrl/mpam_devices.c

1681

if (!cpumask_test_cpu(cpu, &msc->accessibility))

drivers/resctrl/mpam_devices.c

1684

if (msc->reenable_error_ppi)

drivers/resctrl/mpam_devices.c

1685

disable_percpu_irq(msc->reenable_error_ppi);

drivers/resctrl/mpam_devices.c

1687

if (atomic_dec_and_test(&msc->online_refs)) {

drivers/resctrl/mpam_devices.c

1690

mutex_lock(&msc->cfg_lock);

drivers/resctrl/mpam_devices.c

1691

list_for_each_entry_srcu(ris, &msc->ris, msc_list,

drivers/resctrl/mpam_devices.c

1693

mpam_touch_msc(msc, &mpam_reset_ris, ris);

drivers/resctrl/mpam_devices.c

1702

mpam_touch_msc(msc, &mpam_save_mbwu_state, ris);

drivers/resctrl/mpam_devices.c

1704

mutex_unlock(&msc->cfg_lock);

drivers/resctrl/mpam_devices.c

171

#define mpam_read_partsel_reg(msc, reg) _mpam_read_partsel_reg(msc, MPAMF_##reg)

drivers/resctrl/mpam_devices.c

173

static void __mpam_write_reg(struct mpam_msc *msc, u16 reg, u32 val)

drivers/resctrl/mpam_devices.c

1730

static int __setup_ppi(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

1734

msc->error_dev_id = alloc_percpu(struct mpam_msc *);

drivers/resctrl/mpam_devices.c

1735

if (!msc->error_dev_id)

drivers/resctrl/mpam_devices.c

1738

for_each_cpu(cpu, &msc->accessibility)

drivers/resctrl/mpam_devices.c

1739

*per_cpu_ptr(msc->error_dev_id, cpu) = msc;

drivers/resctrl/mpam_devices.c

1744

static int mpam_msc_setup_error_irq(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

1748

irq = platform_get_irq_byname_optional(msc->pdev, "error");

drivers/resctrl/mpam_devices.c

175

WARN_ON_ONCE(reg + sizeof(u32) > msc->mapped_hwpage_sz);

drivers/resctrl/mpam_devices.c

1754

return __setup_ppi(msc);

drivers/resctrl/mpam_devices.c

1757

if (!cpumask_equal(&msc->accessibility, cpu_possible_mask)) {

drivers/resctrl/mpam_devices.c

1759

msc->id);

drivers/resctrl/mpam_devices.c

176

WARN_ON_ONCE(!cpumask_test_cpu(smp_processor_id(), &msc->accessibility));

drivers/resctrl/mpam_devices.c

1773

static void update_msc_accessibility(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

1778

err = device_property_read_u32(&msc->pdev->dev, "cpu_affinity",

drivers/resctrl/mpam_devices.c

178

writel_relaxed(val, msc->mapped_hwpage + reg);

drivers/resctrl/mpam_devices.c

1781

cpumask_copy(&msc->accessibility, cpu_possible_mask);

drivers/resctrl/mpam_devices.c

1783

acpi_pptt_get_cpus_from_container(affinity_id, &msc->accessibility);

drivers/resctrl/mpam_devices.c

1791

static void mpam_msc_destroy(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

1793

struct platform_device *pdev = msc->pdev;

drivers/resctrl/mpam_devices.c

1798

list_for_each_entry_safe(ris, tmp, &msc->ris, msc_list)

drivers/resctrl/mpam_devices.c

1801

list_del_rcu(&msc->all_msc_list);

drivers/resctrl/mpam_devices.c

1804

add_to_garbage(msc);

drivers/resctrl/mpam_devices.c

1809

struct mpam_msc *msc = platform_get_drvdata(pdev);

drivers/resctrl/mpam_devices.c

181

static inline void _mpam_write_partsel_reg(struct mpam_msc *msc, u16 reg, u32 val)

drivers/resctrl/mpam_devices.c

1812

mpam_msc_destroy(msc);

drivers/resctrl/mpam_devices.c

1822

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

1828

msc = devm_kzalloc(&pdev->dev, sizeof(*msc), GFP_KERNEL);

drivers/resctrl/mpam_devices.c

1829

if (!msc)

drivers/resctrl/mpam_devices.c

183

lockdep_assert_held_once(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

1831

init_garbage(&msc->garbage);

drivers/resctrl/mpam_devices.c

1832

msc->garbage.pdev = pdev;

drivers/resctrl/mpam_devices.c

1834

err = devm_mutex_init(dev, &msc->probe_lock);

drivers/resctrl/mpam_devices.c

1838

err = devm_mutex_init(dev, &msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

184

__mpam_write_reg(msc, reg, val);

drivers/resctrl/mpam_devices.c

1842

err = devm_mutex_init(dev, &msc->error_irq_lock);

drivers/resctrl/mpam_devices.c

1846

err = devm_mutex_init(dev, &msc->cfg_lock);

drivers/resctrl/mpam_devices.c

1850

mpam_mon_sel_lock_init(msc);

drivers/resctrl/mpam_devices.c

1851

msc->id = pdev->id;

drivers/resctrl/mpam_devices.c

1852

msc->pdev = pdev;

drivers/resctrl/mpam_devices.c

1853

INIT_LIST_HEAD_RCU(&msc->all_msc_list);

drivers/resctrl/mpam_devices.c

1854

INIT_LIST_HEAD_RCU(&msc->ris);

drivers/resctrl/mpam_devices.c

1856

update_msc_accessibility(msc);

drivers/resctrl/mpam_devices.c

1857

if (cpumask_empty(&msc->accessibility)) {

drivers/resctrl/mpam_devices.c

1862

err = mpam_msc_setup_error_irq(msc);

drivers/resctrl/mpam_devices.c

1867

msc->iface = MPAM_IFACE_MMIO;

drivers/resctrl/mpam_devices.c

1869

msc->iface = MPAM_IFACE_PCC;

drivers/resctrl/mpam_devices.c

187

#define mpam_write_partsel_reg(msc, reg, val) _mpam_write_partsel_reg(msc, MPAMCFG_##reg, val)

drivers/resctrl/mpam_devices.c

1871

if (msc->iface == MPAM_IFACE_MMIO) {

drivers/resctrl/mpam_devices.c

1880

msc->mapped_hwpage_sz = msc_res->end - msc_res->start;

drivers/resctrl/mpam_devices.c

1881

msc->mapped_hwpage = io;

drivers/resctrl/mpam_devices.c

1886

list_add_rcu(&msc->all_msc_list, &mpam_all_msc);

drivers/resctrl/mpam_devices.c

1887

platform_set_drvdata(pdev, msc);

drivers/resctrl/mpam_devices.c

1889

return msc;

drivers/resctrl/mpam_devices.c

189

static inline u32 _mpam_read_monsel_reg(struct mpam_msc *msc, u16 reg)

drivers/resctrl/mpam_devices.c

1897

struct mpam_msc *msc = NULL;

drivers/resctrl/mpam_devices.c

1901

msc = do_mpam_msc_drv_probe(pdev);

drivers/resctrl/mpam_devices.c

1904

if (IS_ERR(msc))

drivers/resctrl/mpam_devices.c

1905

return PTR_ERR(msc);

drivers/resctrl/mpam_devices.c

1908

err = acpi_mpam_parse_resources(msc, plat_data);

drivers/resctrl/mpam_devices.c

191

mpam_mon_sel_lock_held(msc);

drivers/resctrl/mpam_devices.c

192

return __mpam_read_reg(msc, reg);

drivers/resctrl/mpam_devices.c

195

#define mpam_read_monsel_reg(msc, reg) _mpam_read_monsel_reg(msc, MSMON_##reg)

drivers/resctrl/mpam_devices.c

197

static inline void _mpam_write_monsel_reg(struct mpam_msc *msc, u16 reg, u32 val)

drivers/resctrl/mpam_devices.c

199

mpam_mon_sel_lock_held(msc);

drivers/resctrl/mpam_devices.c

200

__mpam_write_reg(msc, reg, val);

drivers/resctrl/mpam_devices.c

203

#define mpam_write_monsel_reg(msc, reg, val) _mpam_write_monsel_reg(msc, MSMON_##reg, val)

drivers/resctrl/mpam_devices.c

205

static u64 mpam_msc_read_idr(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

209

lockdep_assert_held(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

2099

struct device *dev = &vmsc->msc->pdev->dev;

drivers/resctrl/mpam_devices.c

211

idr_low = mpam_read_partsel_reg(msc, IDR);

drivers/resctrl/mpam_devices.c

2115

struct device *dev = &vmsc->msc->pdev->dev;

drivers/resctrl/mpam_devices.c

213

idr_high = mpam_read_partsel_reg(msc, IDR + 4);

drivers/resctrl/mpam_devices.c

2158

vmsc->msc->nrdy_usec);

drivers/resctrl/mpam_devices.c

218

static void mpam_msc_clear_esr(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

220

u64 esr_low = __mpam_read_reg(msc, MPAMF_ESR);

drivers/resctrl/mpam_devices.c

2221

struct mpam_msc *msc = _msc;

drivers/resctrl/mpam_devices.c

2223

__mpam_write_reg(msc, MPAMF_ECR, MPAMF_ECR_INTEN);

drivers/resctrl/mpam_devices.c

2231

struct mpam_msc *msc = _msc;

drivers/resctrl/mpam_devices.c

2233

__mpam_write_reg(msc, MPAMF_ECR, 0);

drivers/resctrl/mpam_devices.c

2238

static irqreturn_t __mpam_irq_handler(int irq, struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

2244

if (WARN_ON_ONCE(!msc) ||

drivers/resctrl/mpam_devices.c

2246

&msc->accessibility)))

drivers/resctrl/mpam_devices.c

2249

reg = mpam_msc_read_esr(msc);

drivers/resctrl/mpam_devices.c

2256

mpam_msc_clear_esr(msc);

drivers/resctrl/mpam_devices.c

2263

msc->id, mpam_errcode_names[errcode], partid, pmg,

drivers/resctrl/mpam_devices.c

2267

mpam_disable_msc_ecr(msc);

drivers/resctrl/mpam_devices.c

2285

struct mpam_msc *msc = *(struct mpam_msc **)dev_id;

drivers/resctrl/mpam_devices.c

2287

return __mpam_irq_handler(irq, msc);

drivers/resctrl/mpam_devices.c

2292

struct mpam_msc *msc = dev_id;

drivers/resctrl/mpam_devices.c

2294

return __mpam_irq_handler(irq, msc);

drivers/resctrl/mpam_devices.c

2300

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

2305

list_for_each_entry_srcu(msc, &mpam_all_msc, all_msc_list,

drivers/resctrl/mpam_devices.c

2307

irq = platform_get_irq_byname_optional(msc->pdev, "error");

drivers/resctrl/mpam_devices.c

231

if (msc->has_extd_esr)

drivers/resctrl/mpam_devices.c

2316

msc->error_dev_id);

drivers/resctrl/mpam_devices.c

232

__mpam_write_reg(msc, MPAMF_ESR + 4, 0);

drivers/resctrl/mpam_devices.c

2320

msc->reenable_error_ppi = irq;

drivers/resctrl/mpam_devices.c

2321

smp_call_function_many(&msc->accessibility,

drivers/resctrl/mpam_devices.c

2325

err = devm_request_irq(&msc->pdev->dev, irq,

drivers/resctrl/mpam_devices.c

2327

"mpam:msc:error", msc);

drivers/resctrl/mpam_devices.c

233

__mpam_write_reg(msc, MPAMF_ESR, 0);

drivers/resctrl/mpam_devices.c

2332

mutex_lock(&msc->error_irq_lock);

drivers/resctrl/mpam_devices.c

2333

msc->error_irq_req = true;

drivers/resctrl/mpam_devices.c

2334

mpam_touch_msc(msc, mpam_enable_msc_ecr, msc);

drivers/resctrl/mpam_devices.c

2335

msc->error_irq_hw_enabled = true;

drivers/resctrl/mpam_devices.c

2336

mutex_unlock(&msc->error_irq_lock);

drivers/resctrl/mpam_devices.c

2345

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

2349

list_for_each_entry_srcu(msc, &mpam_all_msc, all_msc_list,

drivers/resctrl/mpam_devices.c

2351

irq = platform_get_irq_byname_optional(msc->pdev, "error");

drivers/resctrl/mpam_devices.c

2355

mutex_lock(&msc->error_irq_lock);

drivers/resctrl/mpam_devices.c

2356

if (msc->error_irq_hw_enabled) {

drivers/resctrl/mpam_devices.c

2357

mpam_touch_msc(msc, mpam_disable_msc_ecr, msc);

drivers/resctrl/mpam_devices.c

2358

msc->error_irq_hw_enabled = false;

drivers/resctrl/mpam_devices.c

236

static u64 mpam_msc_read_esr(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

2361

if (msc->error_irq_req) {

drivers/resctrl/mpam_devices.c

2363

msc->reenable_error_ppi = 0;

drivers/resctrl/mpam_devices.c

2364

free_percpu_irq(irq, msc->error_dev_id);

drivers/resctrl/mpam_devices.c

2366

devm_free_irq(&msc->pdev->dev, irq, msc);

drivers/resctrl/mpam_devices.c

2368

msc->error_irq_req = false;

drivers/resctrl/mpam_devices.c

2370

mutex_unlock(&msc->error_irq_lock);

drivers/resctrl/mpam_devices.c

2376

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

2384

msc = vmsc->msc;

drivers/resctrl/mpam_devices.c

2386

if (mpam_mon_sel_lock(msc)) {

drivers/resctrl/mpam_devices.c

2389

mpam_mon_sel_unlock(msc);

drivers/resctrl/mpam_devices.c

240

esr_low = __mpam_read_reg(msc, MPAMF_ESR);

drivers/resctrl/mpam_devices.c

241

if (msc->has_extd_esr)

drivers/resctrl/mpam_devices.c

242

esr_high = __mpam_read_reg(msc, MPAMF_ESR + 4);

drivers/resctrl/mpam_devices.c

2437

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

2444

msc = vmsc->msc;

drivers/resctrl/mpam_devices.c

2458

if (mpam_mon_sel_lock(msc)) {

drivers/resctrl/mpam_devices.c

2460

mpam_mon_sel_unlock(msc);

drivers/resctrl/mpam_devices.c

247

static void __mpam_part_sel_raw(u32 partsel, struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

249

lockdep_assert_held(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

251

mpam_write_partsel_reg(msc, PART_SEL, partsel);

drivers/resctrl/mpam_devices.c

254

static void __mpam_part_sel(u8 ris_idx, u16 partid, struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

2550

struct mpam_msc *msc = vmsc->msc;

drivers/resctrl/mpam_devices.c

2556

mpam_touch_msc(msc, mpam_reset_ris, ris);

drivers/resctrl/mpam_devices.c

259

__mpam_part_sel_raw(partsel, msc);

drivers/resctrl/mpam_devices.c

2590

struct mpam_msc *msc, *tmp;

drivers/resctrl/mpam_devices.c

2610

list_for_each_entry_safe(msc, tmp, &mpam_all_msc, all_msc_list)

drivers/resctrl/mpam_devices.c

2611

mpam_msc_destroy(msc);

drivers/resctrl/mpam_devices.c

262

static void __mpam_intpart_sel(u8 ris_idx, u16 intpartid, struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

2626

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

2631

list_for_each_entry_srcu(msc, &mpam_all_msc, all_msc_list,

drivers/resctrl/mpam_devices.c

2633

mutex_lock(&msc->probe_lock);

drivers/resctrl/mpam_devices.c

2634

if (!msc->probed)

drivers/resctrl/mpam_devices.c

2636

mutex_unlock(&msc->probe_lock);

drivers/resctrl/mpam_devices.c

2674

struct mpam_msc *msc;

drivers/resctrl/mpam_devices.c

268

__mpam_part_sel_raw(partsel, msc);

drivers/resctrl/mpam_devices.c

2690

msc = vmsc->msc;

drivers/resctrl/mpam_devices.c

2692

mutex_lock(&msc->cfg_lock);

drivers/resctrl/mpam_devices.c

2696

mpam_touch_msc(msc, __write_config, &arg);

drivers/resctrl/mpam_devices.c

2698

mutex_unlock(&msc->cfg_lock);

drivers/resctrl/mpam_devices.c

395

mpam_vmsc_alloc(struct mpam_component *comp, struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

409

vmsc->msc = msc;

drivers/resctrl/mpam_devices.c

430

mpam_vmsc_find(struct mpam_component *comp, struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

437

if (vmsc->msc->id == msc->id)

drivers/resctrl/mpam_devices.c

441

return mpam_vmsc_alloc(comp, msc);

drivers/resctrl/mpam_devices.c

468

static int mpam_ris_get_affinity(struct mpam_msc *msc, cpumask_t *affinity,

drivers/resctrl/mpam_devices.c

480

dev_warn_once(&msc->pdev->dev,

drivers/resctrl/mpam_devices.c

486

dev_warn_once(&msc->pdev->dev, "no CPUs associated with cache node\n");

drivers/resctrl/mpam_devices.c

497

cpumask_and(affinity, affinity, &msc->accessibility);

drivers/resctrl/mpam_devices.c

502

static int mpam_ris_create_locked(struct mpam_msc *msc, u8 ris_idx,

drivers/resctrl/mpam_devices.c

511

struct platform_device *pdev = msc->pdev;

drivers/resctrl/mpam_devices.c

518

if (test_and_set_bit(ris_idx, &msc->ris_idxs))

drivers/resctrl/mpam_devices.c

521

ris = devm_kzalloc(&msc->pdev->dev, sizeof(*ris), GFP_KERNEL);

drivers/resctrl/mpam_devices.c

538

vmsc = mpam_vmsc_find(comp, msc);

drivers/resctrl/mpam_devices.c

545

err = mpam_ris_get_affinity(msc, &ris->affinity, type, class, comp);

drivers/resctrl/mpam_devices.c

560

list_add_rcu(&ris->msc_list, &msc->ris);

drivers/resctrl/mpam_devices.c

568

struct mpam_msc *msc = vmsc->msc;

drivers/resctrl/mpam_devices.c

580

clear_bit(ris->ris_idx, &msc->ris_idxs);

drivers/resctrl/mpam_devices.c

589

int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,

drivers/resctrl/mpam_devices.c

595

err = mpam_ris_create_locked(msc, ris_idx, type, class_id,

drivers/resctrl/mpam_devices.c

604

static struct mpam_msc_ris *mpam_get_or_create_ris(struct mpam_msc *msc,

drivers/resctrl/mpam_devices.c

612

if (!test_bit(ris_idx, &msc->ris_idxs)) {

drivers/resctrl/mpam_devices.c

613

err = mpam_ris_create_locked(msc, ris_idx, MPAM_CLASS_UNKNOWN,

drivers/resctrl/mpam_devices.c

619

list_for_each_entry(ris, &msc->ris, msc_list) {

drivers/resctrl/mpam_devices.c

640

struct mpam_msc *msc = ris->vmsc->msc;

drivers/resctrl/mpam_devices.c

642

if (WARN_ON_ONCE(!mpam_mon_sel_lock(msc)))

drivers/resctrl/mpam_devices.c

647

_mpam_write_monsel_reg(msc, mon_reg, mon_sel);

drivers/resctrl/mpam_devices.c

649

_mpam_write_monsel_reg(msc, mon_reg, MSMON___NRDY);

drivers/resctrl/mpam_devices.c

650

now = _mpam_read_monsel_reg(msc, mon_reg);

drivers/resctrl/mpam_devices.c

653

_mpam_write_monsel_reg(msc, mon_reg, 0);

drivers/resctrl/mpam_devices.c

654

now = _mpam_read_monsel_reg(msc, mon_reg);

drivers/resctrl/mpam_devices.c

656

mpam_mon_sel_unlock(msc);

drivers/resctrl/mpam_devices.c

667

struct mpam_msc *msc = ris->vmsc->msc;

drivers/resctrl/mpam_devices.c

668

struct device *dev = &msc->pdev->dev;

drivers/resctrl/mpam_devices.c

672

lockdep_assert_held(&msc->probe_lock);

drivers/resctrl/mpam_devices.c

673

lockdep_assert_held(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

677

u32 ccap_features = mpam_read_partsel_reg(msc, CCAP_IDR);

drivers/resctrl/mpam_devices.c

700

u32 cpor_features = mpam_read_partsel_reg(msc, CPOR_IDR);

drivers/resctrl/mpam_devices.c

709

u32 mbw_features = mpam_read_partsel_reg(msc, MBW_IDR);

drivers/resctrl/mpam_devices.c

730

u32 pri_features = mpam_read_partsel_reg(msc, PRI_IDR);

drivers/resctrl/mpam_devices.c

749

u32 msmon_features = mpam_read_partsel_reg(msc, MSMON_IDR);

drivers/resctrl/mpam_devices.c

755

err = device_property_read_u32(&msc->pdev->dev,

drivers/resctrl/mpam_devices.c

757

&msc->nrdy_usec);

drivers/resctrl/mpam_devices.c

762

csumonidr = mpam_read_partsel_reg(msc, CSUMON_IDR);

drivers/resctrl/mpam_devices.c

787

u32 mbwumon_idr = mpam_read_partsel_reg(msc, MBWUMON_IDR);

drivers/resctrl/mpam_devices.c

827

u32 nrwidr = mpam_read_partsel_reg(msc, PARTID_NRW_IDR);

drivers/resctrl/mpam_devices.c

831

msc->partid_max = min(msc->partid_max, partid_max);

drivers/resctrl/mpam_devices.c

835

static int mpam_msc_hw_probe(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

841

struct device *dev = &msc->pdev->dev;

drivers/resctrl/mpam_devices.c

843

lockdep_assert_held(&msc->probe_lock);

drivers/resctrl/mpam_devices.c

845

idr = __mpam_read_reg(msc, MPAMF_AIDR);

drivers/resctrl/mpam_devices.c

852

mutex_lock(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

853

idr = mpam_msc_read_idr(msc);

drivers/resctrl/mpam_devices.c

854

mutex_unlock(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

856

msc->ris_max = FIELD_GET(MPAMF_IDR_RIS_MAX, idr);

drivers/resctrl/mpam_devices.c

859

msc->partid_max = FIELD_GET(MPAMF_IDR_PARTID_MAX, idr);

drivers/resctrl/mpam_devices.c

860

msc->pmg_max = FIELD_GET(MPAMF_IDR_PMG_MAX, idr);

drivers/resctrl/mpam_devices.c

862

for (ris_idx = 0; ris_idx <= msc->ris_max; ris_idx++) {

drivers/resctrl/mpam_devices.c

863

mutex_lock(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

864

__mpam_part_sel(ris_idx, 0, msc);

drivers/resctrl/mpam_devices.c

865

idr = mpam_msc_read_idr(msc);

drivers/resctrl/mpam_devices.c

866

mutex_unlock(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

870

msc->partid_max = min(msc->partid_max, partid_max);

drivers/resctrl/mpam_devices.c

871

msc->pmg_max = min(msc->pmg_max, pmg_max);

drivers/resctrl/mpam_devices.c

872

msc->has_extd_esr = FIELD_GET(MPAMF_IDR_HAS_EXTD_ESR, idr);

drivers/resctrl/mpam_devices.c

875

ris = mpam_get_or_create_ris(msc, ris_idx);

drivers/resctrl/mpam_devices.c

881

mutex_lock(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

882

__mpam_part_sel(ris_idx, 0, msc);

drivers/resctrl/mpam_devices.c

884

mutex_unlock(&msc->part_sel_lock);

drivers/resctrl/mpam_devices.c

888

mpam_msc_clear_esr(msc);

drivers/resctrl/mpam_devices.c

891

mpam_partid_max = min(mpam_partid_max, msc->partid_max);

drivers/resctrl/mpam_devices.c

892

mpam_pmg_max = min(mpam_pmg_max, msc->pmg_max);

drivers/resctrl/mpam_devices.c

895

msc->probed = true;

drivers/resctrl/mpam_devices.c

914

static u64 mpam_msc_read_mbwu_l(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

920

mpam_mon_sel_lock_held(msc);

drivers/resctrl/mpam_devices.c

922

WARN_ON_ONCE((MSMON_MBWU_L + sizeof(u64)) > msc->mapped_hwpage_sz);

drivers/resctrl/mpam_devices.c

923

WARN_ON_ONCE(!cpumask_test_cpu(smp_processor_id(), &msc->accessibility));

drivers/resctrl/mpam_devices.c

925

mbwu_l_high2 = __mpam_read_reg(msc, MSMON_MBWU_L + 4);

drivers/resctrl/mpam_devices.c

928

mbwu_l_low = __mpam_read_reg(msc, MSMON_MBWU_L);

drivers/resctrl/mpam_devices.c

929

mbwu_l_high2 = __mpam_read_reg(msc, MSMON_MBWU_L + 4);

drivers/resctrl/mpam_devices.c

941

static void mpam_msc_zero_mbwu_l(struct mpam_msc *msc)

drivers/resctrl/mpam_devices.c

943

mpam_mon_sel_lock_held(msc);

drivers/resctrl/mpam_devices.c

945

WARN_ON_ONCE((MSMON_MBWU_L + sizeof(u64)) > msc->mapped_hwpage_sz);

drivers/resctrl/mpam_devices.c

946

WARN_ON_ONCE(!cpumask_test_cpu(smp_processor_id(), &msc->accessibility));

drivers/resctrl/mpam_devices.c

948

__mpam_write_reg(msc, MSMON_MBWU_L, 0);

drivers/resctrl/mpam_devices.c

949

__mpam_write_reg(msc, MSMON_MBWU_L + 4, 0);

drivers/resctrl/mpam_devices.c

995

struct mpam_msc *msc = m->ris->vmsc->msc;

drivers/resctrl/mpam_devices.c

999

*ctl_val = mpam_read_monsel_reg(msc, CFG_CSU_CTL);

drivers/resctrl/mpam_internal.h

126

static inline bool __must_check mpam_mon_sel_lock(struct mpam_msc *msc)

drivers/resctrl/mpam_internal.h

129

if (WARN_ON_ONCE(msc->iface != MPAM_IFACE_MMIO))

drivers/resctrl/mpam_internal.h

132

raw_spin_lock_irqsave(&msc->_mon_sel_lock, msc->_mon_sel_flags);

drivers/resctrl/mpam_internal.h

136

static inline void mpam_mon_sel_unlock(struct mpam_msc *msc)

drivers/resctrl/mpam_internal.h

138

raw_spin_unlock_irqrestore(&msc->_mon_sel_lock, msc->_mon_sel_flags);

drivers/resctrl/mpam_internal.h

141

static inline void mpam_mon_sel_lock_held(struct mpam_msc *msc)

drivers/resctrl/mpam_internal.h

143

lockdep_assert_held_once(&msc->_mon_sel_lock);

drivers/resctrl/mpam_internal.h

146

static inline void mpam_mon_sel_lock_init(struct mpam_msc *msc)

drivers/resctrl/mpam_internal.h

148

raw_spin_lock_init(&msc->_mon_sel_lock);

drivers/resctrl/mpam_internal.h

309

struct mpam_msc *msc;

drivers/resctrl/test_mpam_devices.c

325

static void __test_mpam_reset_msc_bitmap(struct mpam_msc *msc, u16 reg, u16 wd)

drivers/resctrl/test_mpam_devices.c

330

mpam_reset_msc_bitmap(msc, reg, wd);

drivers/resctrl/test_mpam_devices.c

63

fake_vmsc1.msc = &fake_msc1;

drivers/resctrl/test_mpam_devices.c

66

fake_vmsc2.msc = &fake_msc2;

include/linux/arm_mpam.h

26

int acpi_mpam_parse_resources(struct mpam_msc *msc,

include/linux/arm_mpam.h

31

static inline int acpi_mpam_parse_resources(struct mpam_msc *msc,

include/linux/arm_mpam.h

41

int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,

include/linux/arm_mpam.h

44

static inline int mpam_ris_create(struct mpam_msc *msc, u8 ris_idx,

net/bluetooth/rfcomm/core.c

1065

struct rfcomm_msc *msc;

net/bluetooth/rfcomm/core.c

1073

hdr->len = __len8(sizeof(*mcc) + sizeof(*msc));

net/bluetooth/rfcomm/core.c

1077

mcc->len = __len8(sizeof(*msc));

net/bluetooth/rfcomm/core.c

1079

msc = (void *) ptr; ptr += sizeof(*msc);

net/bluetooth/rfcomm/core.c

1080

msc->dlci = __addr(1, dlci);

net/bluetooth/rfcomm/core.c

1081

msc->v24_sig = v24_sig | 0x01;

net/bluetooth/rfcomm/core.c

1611

struct rfcomm_msc *msc = (void *) skb->data;

net/bluetooth/rfcomm/core.c

1613

u8 dlci = __get_dlci(msc->dlci);

net/bluetooth/rfcomm/core.c

1615

BT_DBG("dlci %d cr %d v24 0x%x", dlci, cr, msc->v24_sig);

net/bluetooth/rfcomm/core.c

1622

if (msc->v24_sig & RFCOMM_V24_FC && !d->cfc)

net/bluetooth/rfcomm/core.c

1629

d->remote_v24_sig = msc->v24_sig;

net/bluetooth/rfcomm/core.c

1632

d->modem_status(d, msc->v24_sig);

net/bluetooth/rfcomm/core.c

1636

rfcomm_send_msc(s, 0, dlci, msc->v24_sig);